public ModelController createController(final ModelNode model, final Setup registration) throws InterruptedException { final ServiceController<?> existingController = serviceContainer.getService(ServiceName.of("ModelController")); if (existingController != null) { final CountDownLatch latch = new CountDownLatch(1); existingController.addListener( new AbstractServiceListener<Object>() { public void listenerAdded(ServiceController<?> serviceController) { serviceController.setMode(ServiceController.Mode.REMOVE); } public void transition( ServiceController<?> serviceController, ServiceController.Transition transition) { if (transition.equals(ServiceController.Transition.REMOVING_to_REMOVED)) { latch.countDown(); } } }); latch.await(); } ServiceTarget target = serviceContainer.subTarget(); ControlledProcessState processState = new ControlledProcessState(true); ModelControllerService svc = new ModelControllerService(processState, registration, model); ServiceBuilder<ModelController> builder = target.addService(ServiceName.of("ModelController"), svc); builder.install(); svc.latch.await(); ModelController controller = svc.getValue(); ModelNode setup = Util.getEmptyOperation("setup", new ModelNode()); controller.execute(setup, null, null, null); processState.setRunning(); return controller; }
public static void main(String[] args) throws Exception { final int totalServiceDefinitions = Integer.parseInt(args[0]); final int threadPoolSize = Integer.parseInt(args[1]); final ServiceContainer container = ServiceContainer.Factory.create(); final ThreadPoolExecutor executor = new ThreadPoolExecutor( threadPoolSize, threadPoolSize, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); container.setExecutor(executor); BatchBuilder batch = container.batchBuilder(); final LatchedFinishListener listener = new LatchedFinishListener(); final Value<Field> testFieldValue = new CachedValue<Field>( new LookupFieldValue(new ImmediateValue<Class<?>>(TestObject.class), "test")); final List<Value<Class<?>>> params = Collections.singletonList((Value<Class<?>>) new ImmediateValue<Class<?>>(TestObject.class)); final List<Value<Method>> setterMethodValues = new ArrayList<Value<Method>>(5); for (int i = 0; i < 5; i++) setterMethodValues.add( new CachedValue<Method>( new LookupMethodValue( new ImmediateValue<Class<?>>(TestObject.class), "setOther" + (i), params))); for (int i = 0; i < totalServiceDefinitions; i++) { final TestObject testObject = new TestObject("test" + i); final TestObjectService service = new TestObjectService(testObject); final ServiceBuilder<TestObject> builder = batch.addService(ServiceName.of(("test" + i).intern()), service).addListener(listener); final Object injectedValue = new Object(); // builder.addInjection(injectedValue).toFieldValue(testFieldValue); int nextDivByFive = (5 - (i % 5)) + i; int numDeps = Math.min(nextDivByFive - i, totalServiceDefinitions - i - 1); for (int j = 0; j < numDeps; j++) { int depId = i + j + 1; if (depId % 5 == 0) continue; // builder.addDependency(ServiceName.of(("test" + // depId).intern())).toMethodValue(setterMethodValues.get(j), // Collections.singletonList(Values.injectedValue())); } } batch.install(); listener.await(); System.out.println(totalServiceDefinitions + " : " + listener.getElapsedTime() / 1000.0); container.shutdown(); executor.shutdown(); }
/** * Create a new controller with the passed in operations. * * @param additionalInit Additional initialization that should be done to the parsers, controller * and service container before initializing our extension * @param bootOperations the operations */ protected KernelServices installInController( AdditionalInitialization additionalInit, List<ModelNode> bootOperations) throws Exception { if (additionalInit == null) { additionalInit = new AdditionalInitialization(); } ControllerInitializer controllerInitializer = additionalInit.createControllerInitializer(); additionalInit.setupController(controllerInitializer); // Initialize the controller ServiceContainer container = ServiceContainer.Factory.create("test" + counter.incrementAndGet()); ServiceTarget target = container.subTarget(); ControlledProcessState processState = new ControlledProcessState(true); List<ModelNode> extraOps = controllerInitializer.initializeBootOperations(); List<ModelNode> allOps = new ArrayList<ModelNode>(); if (extraOps != null) { allOps.addAll(extraOps); } allOps.addAll(bootOperations); StringConfigurationPersister persister = new StringConfigurationPersister(allOps, testParser); ModelControllerService svc = new ModelControllerService( additionalInit.getType(), mainExtension, controllerInitializer, additionalInit, processState, persister, additionalInit.isValidateOperations()); ServiceBuilder<ModelController> builder = target.addService(ServiceName.of("ModelController"), svc); builder.install(); additionalInit.addExtraServices(target); // sharedState = svc.state; svc.latch.await(); ModelController controller = svc.getValue(); ModelNode setup = Util.getEmptyOperation("setup", new ModelNode()); controller.execute(setup, null, null, null); processState.setRunning(); KernelServices kernelServices = new KernelServices( container, controller, persister, new OperationValidator(svc.rootRegistration)); this.kernelServices.add(kernelServices); if (svc.error != null) { throw svc.error; } return kernelServices; }
private AuthorizingCallbackHandler getAuthorizingCallbackHandler(final String realmName) { SecurityRealm realm; if (TEST_REALM.equals(realmName)) { realm = securityRealm; } else { ServiceContainer container = getContainer(); ServiceController<?> service = container.getRequiredService(SecurityRealm.ServiceUtil.createServiceName(realmName)); realm = (SecurityRealm) service.getValue(); } return realm.getAuthorizingCallbackHandler(AuthMechanism.PLAIN); }
/** * Test configuration * * @throws Throwable Thrown if case of an error */ @Test public void testRegistryConfiguration() throws Throwable { ServiceController<?> controller = serviceContainer.getService(ConnectorServices.RA_REPOSITORY_SERVICE); assertNotNull(controller); ResourceAdapterRepository repository = (ResourceAdapterRepository) controller.getValue(); assertNotNull(repository); Set<String> ids = repository.getResourceAdapters(javax.jms.MessageListener.class); assertNotNull(ids); int pureInflowListener = 0; for (String id : ids) { if (id.indexOf("PureInflow") != -1) { pureInflowListener++; } } assertEquals(1, pureInflowListener); String piId = ids.iterator().next(); assertNotNull(piId); Endpoint endpoint = repository.getEndpoint(piId); assertNotNull(endpoint); List<MessageListener> listeners = repository.getMessageListeners(piId); assertNotNull(listeners); assertEquals(1, listeners.size()); MessageListener listener = listeners.get(0); ActivationSpec as = listener.getActivation().createInstance(); assertNotNull(as); assertNotNull(as.getResourceAdapter()); }
public ModuleIdentifier addExternalModule(VirtualFile externalModule) { ModuleIdentifier identifier = ModuleIdentifier.create(EXTERNAL_MODULE_PREFIX + externalModule.getPathName()); ServiceName serviceName = ServiceModuleLoader.moduleSpecServiceName(identifier); ServiceController<?> controller = serviceContainer.getService(serviceName); if (controller == null) { try { ExternalModuleSpecService service = new ExternalModuleSpecService(identifier, externalModule.getPhysicalFile()); serviceContainer.addService(serviceName, service).setInitialMode(Mode.ON_DEMAND).install(); } catch (IOException e) { throw new RuntimeException(e); } } return identifier; }
@Override public void unregisterService(ServiceState serviceState) { List<ServiceName> serviceNames = serviceState.getServiceNames(); log.debug("Unregister service: " + serviceNames); AbstractBundle serviceOwner = serviceState.getServiceOwner(); // This event is synchronously delivered before the service has completed unregistering. eventsPlugin.fireServiceEvent(serviceOwner, ServiceEvent.UNREGISTERING, serviceState); // Remove from using bundles for (AbstractBundle bundleState : serviceState.getUsingBundlesInternal()) { while (ungetService(bundleState, serviceState)) ; } // Remove from owner bundle serviceOwner.removeRegisteredService(serviceState); // Unregister name associations for (ServiceName serviceName : serviceNames) { String[] clazzes = (String[]) serviceState.getProperty(Constants.OBJECTCLASS); for (String clazz : clazzes) unregisterNameAssociation(clazz, serviceName); } // Remove from controller ServiceName rootServiceName = serviceNames.get(0); try { ServiceController<?> controller = serviceContainer.getService(rootServiceName); controller.setMode(Mode.REMOVE); } catch (RuntimeException ex) { log.error("Cannot remove service: " + rootServiceName, ex); } }
private void exit() { if (serviceContainer != null) { try { serviceContainer.shutdown(); serviceContainer.awaitTermination(); } catch (RuntimeException rte) { throw rte; } catch (InterruptedException ite) { ite.printStackTrace(); Thread.currentThread().interrupt(); } catch (Exception ex) { ex.printStackTrace(); } } if (controlledProcessStateService != null) { controlledProcessStateService.removePropertyChangeListener(processStateListener); controlledProcessStateService = null; } if (executorService != null) { try { executorService.shutdown(); // 10 secs is arbitrary, but if the service container is terminated, // no good can happen from waiting for ModelControllerClient requests to complete executorService.awaitTermination(10, TimeUnit.SECONDS); } catch (RuntimeException rte) { throw rte; } catch (InterruptedException ite) { ite.printStackTrace(); Thread.currentThread().interrupt(); } catch (Exception ex) { ex.printStackTrace(); } } if (uninstallStdIo) { try { StdioContext.uninstall(); } catch (IllegalStateException ignored) { // something else already did } } SystemExiter.initialize(SystemExiter.Exiter.DEFAULT); }
void shutdown() { if (allowContainerShutdown) { serviceContainer.shutdown(); synchronized (shutdownInitiated) { shutdownInitiated.set(true); LOGGER.debugf("shutdownInitiated.notifyAll"); shutdownInitiated.notifyAll(); } } }
void awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { LOGGER.debugf("awaitTermination: %dms", unit.toMillis(timeout)); synchronized (shutdownInitiated) { if (shutdownInitiated.get() == false) { LOGGER.debugf("shutdownInitiated.wait"); shutdownInitiated.wait(2000); } } serviceContainer.awaitTermination(timeout == 0 ? Long.MAX_VALUE : timeout, unit); }
/** * Uninstall the Bundle associated with this deployment. * * @param context The stop context. */ public synchronized void stop(StopContext context) { log.tracef("Uninstalling deployment: %s", deployment); try { BundleManager bundleManager = injectedBundleManager.getValue(); bundleManager.uninstallBundle(deployment); ServiceController<?> controller = context.getController(); ServiceContainer serviceContainer = controller.getServiceContainer(); controller.setMode(Mode.REMOVE); // [JBAS-8801] Undeployment leaks root deployment service // [TODO] remove this workaround ServiceName serviceName = Services.deploymentUnitName(controller.getName().getSimpleName()); ServiceController<?> deploymentController = serviceContainer.getService(serviceName); if (deploymentController != null) { deploymentController.setMode(Mode.REMOVE); } } catch (Throwable t) { log.errorf(t, "Failed to uninstall deployment: %s", deployment); } }
private LiveOakFactory( File configDir, File applicationsDir, Vertx vertx, String bindAddress, ServiceContainer serviceContainer) { this( configDir, applicationsDir, vertx, bindAddress, serviceContainer, serviceContainer.subTarget()); }
private synchronized void establishModelControllerClient(ControlledProcessState.State state) { ModelControllerClient newClient = null; if (state != ControlledProcessState.State.STOPPING && serviceContainer != null) { @SuppressWarnings("unchecked") final Value<ModelController> controllerService = (Value<ModelController>) serviceContainer.getService(Services.JBOSS_SERVER_CONTROLLER); if (controllerService != null) { final ModelController controller = controllerService.getValue(); newClient = controller.createClient(executorService); } // else TODO use some sort of timeout and poll. A non-stopping server should install a // ModelController very quickly } modelControllerClient = newClient; currentProcessState = state; }
@Test public void testMetadataConfiguration() throws Throwable { ServiceController<?> controller = serviceContainer.getService(ConnectorServices.IRONJACAMAR_MDR); assertNotNull(controller); MetadataRepository repository = (MetadataRepository) controller.getValue(); assertNotNull(repository); Set<String> ids = repository.getResourceAdapters(); assertNotNull(ids); String piId = ids.iterator().next(); assertNotNull(piId); assertNotNull(repository.getResourceAdapter(piId)); }
@Override public void run() { final ServiceContainer sc; final ControlledProcessState ps; synchronized (this) { down = true; sc = container; ps = processState; } try { if (ps != null) { ps.setStopping(); } } finally { if (sc != null) { SystemExiter.logBeforeExit(HostControllerLogger.ROOT_LOGGER::shutdownHookInvoked); final CountDownLatch latch = new CountDownLatch(1); sc.addTerminateListener( new ServiceContainer.TerminateListener() { @Override public void handleTermination(Info info) { latch.countDown(); } }); sc.shutdown(); // wait for all services to finish. for (; ; ) { try { latch.await(); break; } catch (InterruptedException e) { } } } } }
/** * Start the host controller services. * * @throws Exception */ public void bootstrap() throws Exception { final HostRunningModeControl runningModeControl = environment.getRunningModeControl(); final ControlledProcessState processState = new ControlledProcessState(true); shutdownHook.setControlledProcessState(processState); ServiceTarget target = serviceContainer.subTarget(); ControlledProcessStateService controlledProcessStateService = ControlledProcessStateService.addService(target, processState).getValue(); RunningStateJmx.registerMBean( controlledProcessStateService, null, runningModeControl, Type.from(environment.getProcessType().name())); final HostControllerService hcs = new HostControllerService(environment, runningModeControl, authCode, processState); target.addService(HostControllerService.HC_SERVICE_NAME, hcs).install(); }
@Test public void testMetadataConfiguration() throws Throwable { ServiceController<?> controller = serviceContainer.getService(ConnectorServices.IRONJACAMAR_MDR); assertNotNull(controller); MetadataRepository repository = (MetadataRepository) controller.getValue(); assertNotNull(repository); Set<String> ids = repository.getResourceAdapters(); assertNotNull(ids); // on a running server it's always 2 beacause HornetQResourceAdapter is always present assertEquals(1, ids.size()); for (String piId : ids) { assertNotNull(piId); System.out.println("PID:" + piId); assertNotNull(repository.getResourceAdapter(piId)); } }
public synchronized void start(StartContext context) throws StartException { log.debugf("Starting Arquillian Test Runner"); final MBeanServer mbeanServer = injectedMBeanServer.getValue(); serviceContainer = context.getController().getServiceContainer(); serviceTarget = context.getChildTarget(); try { jmxTestRunner = new ExtendedJMXTestRunner(); jmxTestRunner.registerMBean(mbeanServer); } catch (Throwable t) { throw new StartException("Failed to start Arquillian Test Runner", t); } final ArquillianService arqService = this; serviceContainer.addListener( new AbstractServiceListener<Object>() { @Override public void serviceStarted(ServiceController<? extends Object> controller) { ServiceName serviceName = controller.getName(); String simpleName = serviceName.getSimpleName(); if (JBOSS_DEPLOYMENT.isParentOf(serviceName) && simpleName.equals(Phase.INSTALL.toString())) { ServiceName parentName = serviceName.getParent(); ServiceController<?> parentController = serviceContainer.getService(parentName); DeploymentUnit depUnit = (DeploymentUnit) parentController.getValue(); ArquillianConfig arqConfig = ArquillianConfigBuilder.processDeployment(arqService, depUnit); if (arqConfig != null) { log.infof("Arquillian deployment detected: %s", arqConfig); ServiceBuilder<ArquillianConfig> builder = arqConfig.buildService(serviceTarget, controller); FrameworkActivationProcessor.process(serviceContainer, builder, arqConfig); builder.install(); } } } @Override public void serviceStopped(ServiceController<? extends Object> controller) {} }); }
/** * Test configuration * * @throws Throwable Thrown if case of an error */ @Test public void testRegistryConfiguration() throws Throwable { ServiceController<?> controller = serviceContainer.getService(ConnectorServices.RA_REPOSITORY_SERVICE); assertNotNull(controller); ResourceAdapterRepository repository = (ResourceAdapterRepository) controller.getValue(); assertNotNull(repository); Set<String> ids = repository.getResourceAdapters(); assertNotNull(ids); // On a running server it's 3 beacause HornetQResourceAdapter is always present + ra itself and // 1 actrivation from DMR assertEquals(2, ids.size()); for (String piId : ids) { assertNotNull(piId); System.out.println("PID:" + piId); assertNotNull(repository.getResourceAdapter(piId)); } }
public static void removeService(ServiceContainer container, String contextName) { ServiceController<?> controller = container.getService(getServiceName(contextName)); if (controller != null) controller.setMode(Mode.REMOVE); }
boolean isShutdownComplete() { return serviceContainer.isShutdownComplete(); }
@Override public void start() throws ServerStartException { try { // Take control of server use of System.exit SystemExiter.initialize( new SystemExiter.Exiter() { @Override public void exit(int status) { StandaloneServerImpl.this.exit(); } }); // Take control of stdio try { StdioContext.install(); uninstallStdIo = true; } catch (IllegalStateException ignored) { // already installed } // Determine the ServerEnvironment ServerEnvironment serverEnvironment = Main.determineEnvironment( cmdargs, systemProps, systemEnv, ServerEnvironment.LaunchType.EMBEDDED); Bootstrap bootstrap = Bootstrap.Factory.newInstance(); Bootstrap.Configuration configuration = new Bootstrap.Configuration(serverEnvironment); /* * This would setup an {@link TransientConfigurationPersister} which does not persist anything * final ExtensionRegistry extensionRegistry = configuration.getExtensionRegistry(); final Bootstrap.ConfigurationPersisterFactory configurationPersisterFactory = new Bootstrap.ConfigurationPersisterFactory() { @Override public ExtensibleConfigurationPersister createConfigurationPersister(ServerEnvironment serverEnvironment, ExecutorService executorService) { final QName rootElement = new QName(Namespace.CURRENT.getUriString(), "server"); final StandaloneXml parser = new StandaloneXml(Module.getBootModuleLoader(), executorService, extensionRegistry); final File configurationFile = serverEnvironment.getServerConfigurationFile().getBootFile(); XmlConfigurationPersister persister = new TransientConfigurationPersister(configurationFile, rootElement, parser, parser); for (Namespace namespace : Namespace.domainValues()) { if (!namespace.equals(Namespace.CURRENT)) { persister.registerAdditionalRootElement(new QName(namespace.getUriString(), "server"), parser); } } extensionRegistry.setWriterRegistry(persister); return persister; } }; configuration.setConfigurationPersisterFactory(configurationPersisterFactory); */ configuration.setModuleLoader(moduleLoader); Future<ServiceContainer> future = bootstrap.startup(configuration, Collections.<ServiceActivator>emptyList()); serviceContainer = future.get(); executorService = Executors.newCachedThreadPool(); @SuppressWarnings("unchecked") final Value<ControlledProcessStateService> processStateServiceValue = (Value<ControlledProcessStateService>) serviceContainer.getRequiredService(ControlledProcessStateService.SERVICE_NAME); controlledProcessStateService = processStateServiceValue.getValue(); controlledProcessStateService.addPropertyChangeListener(processStateListener); establishModelControllerClient(controlledProcessStateService.getCurrentState()); } catch (RuntimeException rte) { throw rte; } catch (Exception ex) { throw EmbeddedLogger.ROOT_LOGGER.cannotStartEmbeddedServer(ex); } }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) public ServiceState registerService( AbstractBundle bundleState, String[] clazzes, Object serviceValue, Dictionary properties) { if (clazzes == null || clazzes.length == 0) throw new IllegalArgumentException("Null service classes"); // Immediately after registration of a {@link ListenerHook}, the ListenerHook.added() method // will be called // to provide the current collection of service listeners which had been added prior to the hook // being registered. Collection<ListenerInfo> listenerInfos = null; if (serviceValue instanceof ListenerHook) listenerInfos = eventsPlugin.getServiceListenerInfos(null); // A temporary association of the clazz and name Map<ServiceName, String> associations = new HashMap<ServiceName, String>(); // Generate the service names long serviceId = getNextServiceId(); ServiceName[] serviceNames = new ServiceName[clazzes.length]; for (int i = 0; i < clazzes.length; i++) { if (clazzes[i] == null) throw new IllegalArgumentException("Null service class at index: " + i); String shortName = clazzes[i].substring(clazzes[i].lastIndexOf(".") + 1); serviceNames[i] = ServiceName.of( "jbosgi", bundleState.getSymbolicName(), shortName, new Long(serviceId).toString()); } final ServiceState serviceState = new ServiceState(bundleState, serviceId, serviceNames, clazzes, serviceValue, properties); BatchBuilder batchBuilder = serviceContainer.batchBuilder(); Service service = new Service() { @Override public Object getValue() throws IllegalStateException { // [TODO] for injection to work this needs to be the Object value return serviceState; } @Override public void start(StartContext context) throws StartException {} @Override public void stop(StopContext context) {} }; log.debug("Register service: " + Arrays.asList(serviceNames)); ServiceName rootServiceName = serviceNames[0]; BatchServiceBuilder serviceBuilder = batchBuilder.addService(rootServiceName, service); associations.put(rootServiceName, clazzes[0]); // Set the startup mode serviceBuilder.setInitialMode(Mode.AUTOMATIC); // Add the service aliases for (int i = 1; i < serviceNames.length; i++) { ServiceName alias = serviceNames[i]; associations.put(alias, clazzes[1]); serviceBuilder.addAliases(alias); } try { batchBuilder.install(); // Register the name association. We do this here // in case anything went wrong during the install for (Entry<ServiceName, String> aux : associations.entrySet()) { bundleState.addRegisteredService(serviceState); registerNameAssociation(aux.getValue(), aux.getKey()); } } catch (ServiceRegistryException ex) { log.error("Cannot register services: " + serviceNames, ex); } // Call the newly added ListenerHook.added() method if (serviceValue instanceof ListenerHook) { ListenerHook listenerHook = (ListenerHook) serviceValue; listenerHook.added(listenerInfos); } // This event is synchronously delivered after the service has been registered with the // Framework. eventsPlugin.fireServiceEvent(bundleState, ServiceEvent.REGISTERED, serviceState); return serviceState; }
public List<ServiceState> getServiceReferencesInternal( AbstractBundle bundleState, String clazz, Filter filter, boolean checkAssignable) { if (bundleState == null) throw new IllegalArgumentException("Null bundleState"); List<ServiceName> serviceNames; if (clazz != null) { serviceNames = serviceNameMap.get(clazz); if (serviceNames == null) serviceNames = new ArrayList<ServiceName>(); // Add potentially registered xservcie ServiceName xserviceName = ServiceName.of(ModuleContext.XSERVICE_PREFIX, clazz); ServiceController<?> xservice = serviceContainer.getService(xserviceName); if (xservice != null) serviceNames.add(xserviceName); } else { // [MSC-9] Add ability to query the ServiceContainer Set<ServiceName> allServiceNames = new HashSet<ServiceName>(); for (List<ServiceName> auxList : serviceNameMap.values()) allServiceNames.addAll(auxList); serviceNames = new ArrayList<ServiceName>(allServiceNames); } if (serviceNames.isEmpty()) return Collections.emptyList(); if (filter == null) filter = NoFilter.INSTANCE; List<ServiceState> result = new ArrayList<ServiceState>(); for (ServiceName serviceName : serviceNames) { ServiceController<?> controller = serviceContainer.getService(serviceName); if (controller == null) throw new IllegalStateException("Cannot obtain service for: " + serviceName); Object value = controller.getValue(); // Create the ServiceState on demand for an XService instance // [TODO] This should be done eagerly to keep the serviceId constant // [TODO] service events for XService lifecycle changes // [MSC-17] Canonical ServiceName string representation if (value instanceof ServiceState == false && serviceName.toString().contains(ModuleContext.XSERVICE_PREFIX)) { long serviceId = getNextServiceId(); Bundle bundle = packageAdmin.getBundle(value.getClass()); AbstractBundle owner = AbstractBundle.assertBundleState(bundle); value = new ServiceState( owner, serviceId, new ServiceName[] {serviceName}, new String[] {clazz}, value, null); } ServiceState serviceState = (ServiceState) value; if (filter.match(serviceState) == false) continue; Object rawValue = serviceState.getRawValue(); checkAssignable &= (clazz != null); checkAssignable &= (bundleState.getBundleId() != 0); checkAssignable &= !(rawValue instanceof ServiceFactory); if (checkAssignable == false || serviceState.isAssignableTo(bundleState, clazz)) { result.add(serviceState); } } // Sort the result Collections.sort(result, ServiceReferenceComparator.getInstance()); Collections.reverse(result); return Collections.unmodifiableList(result); }
void setServiceMode(ServiceName serviceName, Mode mode) { ServiceController<?> controller = serviceContainer.getService(serviceName); if (controller == null) LOGGER.debugf("Cannot set mode %s on non-existing service: %s", mode, serviceName); else setServiceMode(controller, mode); }
ServiceController<?> getRequiredService(ServiceName serviceName) { return serviceContainer.getRequiredService(serviceName); }
@AfterClass public static void testServerStartupAndShutDown() throws Exception { container.shutdown(); container.awaitTermination(); Assert.assertTrue(container.isShutdownComplete()); }