final ServiceBuilder<?> builder = serviceTarget.addService(bindName, binderService) .addDependency(getServiceNameBase(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()); final ServiceController<?> binderServiceController = builder.install(); final StabilityMonitor monitor = new StabilityMonitor(); monitor.addController(binderServiceController); monitor.removeController(binderServiceController); final Exception startException = binderServiceController.getStartException(); if (startException != null) { throw startException; final RuntimeBindReleaseService.References duBindingReferences = (RuntimeBindReleaseService.References) binderServiceController.getServiceContainer().getService(JndiNamingDependencyProcessor.serviceName(deploymentUnitServiceName)).getValue(); duBindingReferences.add(binderService);
private Object readResolve() throws ObjectStreamException { ServiceName name = ServiceName.parse(serviceName); ServiceController<?> service = currentServiceContainer().getRequiredService(name); StatefulSessionComponent component = (StatefulSessionComponent) service.getValue(); final Map<Object, Object> context = new HashMap<Object, Object>(); for(final Map.Entry<Object, Object> entry : serializableInterceptors.entrySet()) { context.put(entry.getKey(), entry.getValue()); } context.put(SessionID.class, sessionID); context.put(BasicComponentInstance.INSTANCE_KEY, instance); return component.constructComponentInstance(instance, false, context); }
@SuppressWarnings("unchecked") protected void deployServletProcessApplication(ServletProcessApplication processApplication) { ClassLoader contextClassloader = ClassLoaderUtil.getContextClassloader(); String moduleName = ((ModuleClassLoader)contextClassloader).getModule().getIdentifier().toString(); ServiceName serviceName = ServiceNames.forNoViewProcessApplicationStartService(moduleName); ServiceName paModuleService = ServiceNames.forProcessApplicationModuleService(moduleName); if(serviceContainer.getService(serviceName) == null) { ServiceController<ServiceTarget> requiredService = (ServiceController<ServiceTarget>) serviceContainer.getRequiredService(paModuleService); NoViewProcessApplicationStartService service = new NoViewProcessApplicationStartService(processApplication.getReference()); requiredService.getValue() .addService(serviceName, service) .setInitialMode(Mode.ACTIVE) .install(); } }
public void registerProcessEngine(ProcessEngine processEngine) { if(processEngine == null) { throw new ProcessEngineException("Cannot register process engine with Msc Runtime Container: process engine is 'null'"); } ServiceName serviceName = ServiceNames.forManagedProcessEngine(processEngine.getName()); if(serviceContainer.getService(serviceName) == null) { MscManagedProcessEngine processEngineRegistration = new MscManagedProcessEngine(processEngine); // install the service asynchronously. childTarget.addService(serviceName, processEngineRegistration) .setInitialMode(Mode.ACTIVE) .addDependency(ServiceNames.forMscRuntimeContainerDelegate(), MscRuntimeContainerDelegate.class, processEngineRegistration.getRuntimeContainerDelegateInjector()) .install(); } }
@Override protected EmbeddedCacheManager createCacheManager(Properties properties) throws CacheException { // Find a suitable service name to represent this session factory instance String name = properties.getProperty(Environment.SESSION_FACTORY_NAME); this.serviceName = ServiceName.JBOSS.append(DEFAULT_CACHE_CONTAINER, (name != null) ? name : UUID.randomUUID().toString()); String container = properties.getProperty(CACHE_CONTAINER, DEFAULT_CACHE_CONTAINER); ServiceContainer target = ServiceContainerHelper.getCurrentServiceContainer(); InjectedValue<EmbeddedCacheManager> manager = new InjectedValue<EmbeddedCacheManager>(); ServiceBuilder<EmbeddedCacheManager> builder = target.addService(this.serviceName, new ValueService<EmbeddedCacheManager>(manager)) .addDependency(EmbeddedCacheManagerService.getServiceName(container), EmbeddedCacheManager.class, manager) .setInitialMode(ServiceController.Mode.ACTIVE) ; HibernateSecondLevelCache.addSecondLevelCacheDependencies(target, target, builder, new HibernateMetaData(properties)); try { return ServiceContainerHelper.getValue(builder.install()); } catch (StartException e) { throw new CacheException(e); } }
ServiceBuilder<ManagedReferenceFactory> serviceBuilder = phaseContext.getServiceTarget().addService(bindInfo.getBinderServiceName(), service); bindingConfiguration.getSource().getResourceValue(resolutionContext, serviceBuilder, phaseContext, service.getManagedObjectInjector()); serviceBuilder.addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, service.getNamingStoreInjector()); serviceBuilder.install(); } catch (DuplicateServiceException e) { ServiceController<ManagedReferenceFactory> registered = (ServiceController<ManagedReferenceFactory>) CurrentServiceContainer.getServiceContainer().getService(bindInfo.getBinderServiceName()); if (registered == null) throw e; BinderService service = (BinderService) registered.getService(); if (!service.getSource().equals(bindingConfiguration.getSource())) throw EeLogger.ROOT_LOGGER.conflictingBinding(bindingName, bindingConfiguration.getSource()); service = new BinderService(bindInfo.getBindName(), bindingConfiguration.getSource(), true); ServiceTarget externalServiceTarget = phaseContext.getDeploymentUnit().getAttachment(org.jboss.as.server.deployment.Attachments.EXTERNAL_SERVICE_TARGET); ServiceBuilder<ManagedReferenceFactory> serviceBuilder = externalServiceTarget.addService(bindInfo.getBinderServiceName(), service); bindingConfiguration.getSource().getResourceValue(resolutionContext, serviceBuilder, phaseContext, service.getManagedObjectInjector()); serviceBuilder.addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, service.getNamingStoreInjector()); controller = serviceBuilder.install(); } catch (DuplicateServiceException e) { controller = (ServiceController<ManagedReferenceFactory>) CurrentServiceContainer.getServiceContainer().getService(bindInfo.getBinderServiceName()); if (controller == null) throw e; service = (BinderService) controller.getService(); if (!equals(service.getSource(), bindingConfiguration.getSource())) { throw EeLogger.ROOT_LOGGER.conflictingBinding(bindingName, bindingConfiguration.getSource());
/** * 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, false); final HostControllerService hcs = new HostControllerService(environment, runningModeControl, authCode, processState); target.addService(HostControllerService.HC_SERVICE_NAME, hcs).install(); }
try { final BinderService service = new BinderService(bindInfo.getBindName(), bindingConfiguration.getSource()); jndiDepServiceBuilder.requires(bindInfo.getBinderServiceName()); ServiceBuilder<ManagedReferenceFactory> serviceBuilder = serviceTarget.addService(bindInfo.getBinderServiceName(), service); bindingConfiguration.getSource().getResourceValue(resolutionContext, serviceBuilder, phaseContext, service.getManagedObjectInjector()); serviceBuilder.addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, service.getNamingStoreInjector()); serviceBuilder.install(); } catch (DuplicateServiceException e) { ServiceController<ManagedReferenceFactory> registered = (ServiceController<ManagedReferenceFactory>) CurrentServiceContainer.getServiceContainer().getService(bindInfo.getBinderServiceName()); if (registered == null) throw e; BinderService service = (BinderService) registered.getService(); if (!service.getSource().equals(bindingConfiguration.getSource())) throw EeLogger.ROOT_LOGGER.conflictingBinding(bindingName, bindingConfiguration.getSource());
public void remove() { this.adminResourceController.setMode(ServiceController.Mode.REMOVE); this.publicResourceController.setMode(ServiceController.Mode.REMOVE); ApplicationExtensionRemovalService removal = new ApplicationExtensionRemovalService(extController); ServiceTarget target = extController.getServiceContainer().subTarget(); ServiceController<InternalApplicationExtension> extensionController = (ServiceController<InternalApplicationExtension>) extController.getServiceContainer().getService(Services.applicationExtension(appId, this.resourceId)); target.addListener(new AbstractServiceListener<Object>() { @Override public void transition(ServiceController<?> controller, ServiceController.Transition transition) { target.addService(extController.getName().append("remove"), removal) .addDependency(Services.extension(this.extensionId), Extension.class, removal.extensionInjector()) .install();
ServiceBuilder<ModeShapeEngine> engineBuilder = target.addService(ModeShapeServiceNames.ENGINE, engine); ServiceController<ModeShapeEngine> controller = engineBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install(); controller.getServiceContainer().addTerminateListener(shutdownListener); final ServiceName referenceFactoryServiceName = ModeShapeServiceNames.ENGINE.append("reference-factory"); //$NON-NLS-1$ final ServiceBuilder<?> referenceBuilder = target.addService(referenceFactoryServiceName, referenceFactoryService); referenceBuilder.addDependency(ModeShapeServiceNames.ENGINE, ModeShapeEngine.class, referenceFactoryService.getInjector()); referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install(); final ServiceBuilder<?> binderBuilder = target.addService(bindInfo.getBinderServiceName(), binderService); binderBuilder.addDependency(ModeShapeServiceNames.ENGINE, ModeShapeEngine.class,
private void publishPartitionManager(StartContext context) { BindInfo bindInfo = createPartitionManagerBindInfo(); ServiceName serviceName = bindInfo.getBinderServiceName(); final BinderService binderService = new BinderService(serviceName.getCanonicalName()); final ServiceBuilder<ManagedReferenceFactory> builder = context.getController().getServiceContainer() .addService(serviceName, binderService).addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName)); builder.addDependency(ContextNames.JAVA_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()); builder.addDependency(createServiceName(this.alias), PartitionManager.class, new Injector<PartitionManager>() { @Override public void inject(final PartitionManager value) throws InjectionException { binderService.getManagedObjectInjector().inject( new ValueManagedReferenceFactory(new ImmediateValue<Object>(value))); } @Override public void uninject() { binderService.getManagedObjectInjector().uninject(); } }); builder.setInitialMode(Mode.PASSIVE).install(); ROOT_LOGGER.boundToJndi("PartitionManager " + this.alias, bindInfo.getAbsoluteJndiName()); }
ServiceTarget target = container.subTarget(); ServiceBuilder<ModelController> builder = target.addService(Services.JBOSS_SERVER_CONTROLLER, svc); builder.addDependency(ContentRepository.SERVICE_NAME, ContentRepository.class, testModelControllerFactory.getContentRepositoryInjector(svc)); builder.install(); if (legacyModelVersion == null) { ExecutorService mgmtExecutor = new EnhancedQueueExecutor.Builder() .build(); Service<ExecutorService> mgmtExecSvc = new ValueService<>(new ImmediateValue<>(mgmtExecutor)); target.addService(AbstractControllerService.EXECUTOR_CAPABILITY.getCapabilityServiceName(), mgmtExecSvc).install();
private void installPaintFrameService() throws ModuleLoadException { PaintFrameService service = new PaintFrameService(); ServiceTarget serviceSubTarget = container.subTarget(); ServiceBuilder<PaintFrame> serviceBuilder = serviceSubTarget .addService(PaintFrameService.SERVICE_NAME, service); serviceBuilder.setInitialMode(Mode.ACTIVE); Set<ServiceName> dependencies = installShapeExtensions( serviceSubTarget.subTarget(), loadShapeExtensions(MAIN_MODULE)); for (ServiceName serviceName : dependencies) { serviceBuilder.addDependency(DependencyType.OPTIONAL, serviceName, service.getShapeInjector(serviceName.getSimpleName())); } serviceBuilder.addListener(new AbstractServiceListener<PaintFrame>() { @Override public void transition( ServiceController<? extends PaintFrame> controller, Transition transition) { switch (transition) { case REMOVING_to_REMOVED: container.shutdown(); break; default: break; } } }); serviceBuilder.install(); }
public ModuleIdentifier addExternalModule(String externalModule) { ModuleIdentifier identifier = ModuleIdentifier.create(EXTERNAL_MODULE_PREFIX + externalModule); ServiceName serviceName = ServiceModuleLoader.moduleSpecServiceName(identifier); ServiceController<?> controller = serviceContainer.getService(serviceName); if (controller == null) { ExternalModuleSpecService service = new ExternalModuleSpecService(identifier, new File(externalModule)); serviceContainer.addService(serviceName, service).setInitialMode(Mode.ON_DEMAND).install(); } return identifier; }
String cacheType = properties.getProperty(CACHE_TYPE); ServiceName containerServiceName = ServiceName.parse(InfinispanRequirement.CONTAINER.resolve(container)); ServiceBuilder<?> builder = target.addService(ServiceName.JBOSS.append(DEFAULT_CACHE_CONTAINER, name)); Supplier<EmbeddedCacheManager> manager = builder.requires(containerServiceName); ServiceName dependencyName = ServiceName.parse(InfinispanCacheRequirement.CONFIGURATION.resolve(container, cache)); builder.requires(dependencyName); ServiceController<?> controller = builder.install(); monitor.awaitStability(); while (controller.getState() == ServiceController.State.DOWN) { Thread.yield(); monitor.awaitStability();
.append("camunda-fox-platform") .append(moduleName) .append(processEngineServiceSuffix); .append(processArchiveServiceSuffix); final ServiceContainer serviceContainer = context.getController().getServiceContainer(); .addService(processEngineServiceBindingServiceName, processEngineServiceBinder); processEngineServiceBuilder.addDependency(ContextNames.GLOBAL_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, processEngineServiceBinder.getNamingStoreInjector()); processEngineServiceBinder.getManagedObjectInjector().inject(new PlatformServiceReferenceFactory(this)); ServiceBuilder<ManagedReferenceFactory> processArchiveServiceBuilder = serviceContainer.addService(processArchiveServiceBindingServiceName, processArchiveServiceBinder); processArchiveServiceBuilder.addDependency(ContextNames.GLOBAL_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, processArchiveServiceBinder.getNamingStoreInjector()); processArchiveServiceBinder.getManagedObjectInjector().inject(new PlatformServiceReferenceFactory(this)); processEngineServiceBinding = processEngineServiceBuilder.install(); processArchiveServiceBinding = processArchiveServiceBuilder.install();
public void activated() { if (overrideInVMSecurity) { activeMQServer.getValue().getRemotingService().allowInvmSecurityOverride(new ActiveMQPrincipal(DefaultCredentials.getUsername(), DefaultCredentials.getPassword())); } // ActiveMQ only provides a callback to be notified when ActiveMQ core server is activated. // but the JMS service start must not be completed until the JMSServerManager wrappee is indeed started (and has deployed the JMS resources, etc.). // It is possible that the activation service has already been installed but becomes passive when a backup server has failed over (-> ACTIVE) and failed back (-> PASSIVE) // [WFLY-6178] check if the service container is shutdown to avoid an IllegalStateException if an // ActiveMQ backup server is activated during failover while the WildFly server is shutting down. if (serviceContainer.isShutdown()) { return; } if (activeMQActivationController == null) { activeMQActivationController = serviceContainer.addService(ActiveMQActivationService.getServiceName(serverServiceName), new ActiveMQActivationService()) .setInitialMode(Mode.ACTIVE) .install(); } else { activeMQActivationController.setMode(ACTIVE); } }
@SuppressWarnings("unchecked") private ProcessApplicationDeploymentService getDeploymentService(StartContext context, ServiceName deploymentServiceName) { final ServiceContainer serviceContainer = context.getController().getServiceContainer(); ServiceController<ProcessApplicationDeploymentService> deploymentService = (ServiceController<ProcessApplicationDeploymentService>) serviceContainer.getRequiredService(deploymentServiceName); return deploymentService.getValue(); }
final ServiceTarget tracker = container.subTarget(); final ControlledProcessState processState = new ControlledProcessState(configuration.getServerEnvironment().isStandalone()); ControlledProcessStateService.addService(tracker, processState); final Service<?> applicationServerService = new ApplicationServerService(extraServices, configuration, processState); tracker.addService(Services.JBOSS_AS, applicationServerService) .install(); final ServiceController<?> rootService = container.getRequiredService(Services.JBOSS_AS); rootService.addListener(new AbstractServiceListener<Object>() { @Override public void transition(final ServiceController<?> controller, final ServiceController.Transition transition) {
/** * Install the MSC service which listens for JMX notifications. */ @Override public void initialize(ExtensionContext context) { log.info("Initializing " + EXTENSION_NAME); container = CurrentServiceContainer.getServiceContainer(); if(container.getService(JMXNotificationsService.SERVICE_NAME) == null) { log.info("Installing " + JMXNotificationsService.SERVICE_NAME); final ServiceTarget target = container.subTarget(); JMXNotificationsService service = new JMXNotificationsService(); target.addService(JMXNotificationsService.SERVICE_NAME, service) .install(); } }