void removeRuntimeServices(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { // get container and cache addresses final PathAddress cacheAddress = getCacheAddressFromOperation(operation); final PathAddress containerAddress = getCacheContainerAddressFromOperation(operation); // get container and cache names final String cacheName = cacheAddress.getLastElement().getValue(); final String containerName = containerAddress.getLastElement().getValue(); // remove all services started by CacheAdd, in reverse order // remove the binder service ModelNode resolvedValue = null; final String jndiNameString = (resolvedValue = CommonAttributes.JNDI_NAME.resolveModelAttribute(context, model)) .isDefined() ? resolvedValue.asString() : null; final String jndiName = InfinispanJndiName.createCacheJndiNameOrDefault(jndiNameString, containerName, cacheName); ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); context.removeService(bindInfo.getBinderServiceName()); // remove the CacheService instance context.removeService(CacheService.getServiceName(containerName, cacheName)); // remove the cache configuration service context.removeService(CacheConfigurationService.getServiceName(containerName, cacheName)); log.debugf("cache %s removed for container %s", cacheName, containerName); }
ServiceController<?> installJndiService( ServiceTarget target, String containerName, String jndiName, ServiceVerificationHandler verificationHandler) { final ServiceName containerServiceName = EmbeddedCacheManagerService.getServiceName(containerName); final ContextNames.BindInfo binding = createCacheContainerBinding(jndiName, containerName); final BinderService binder = new BinderService(binding.getBindName()); return target .addService(binding.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(binding.getBindName())) .addDependency( containerServiceName, CacheContainer.class, new ManagedReferenceInjector<CacheContainer>(binder.getManagedObjectInjector())) .addDependency( binding.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.PASSIVE) .install(); }
Collection<ServiceController<?>> installChannelServices( ServiceTarget target, String containerName, String cluster, String stack, ServiceVerificationHandler verificationHandler) { ServiceName name = ChannelService.getServiceName(containerName); ContextNames.BindInfo bindInfo = createChannelBinding(containerName); BinderService binder = new BinderService(bindInfo.getBindName()); ServiceController<?> binderService = target .addService(bindInfo.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(bindInfo.getBindName())) .addDependency( name, Channel.class, new ManagedReferenceInjector<Channel>(binder.getManagedObjectInjector())) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.PASSIVE) .install(); InjectedValue<ChannelFactory> channelFactory = new InjectedValue<>(); ServiceController<?> channelService = AsynchronousService.addService(target, name, new ChannelService(cluster, channelFactory)) .addDependency( ChannelFactoryService.getServiceName(stack), ChannelFactory.class, channelFactory) .setInitialMode(ServiceController.Mode.ON_DEMAND) .install(); return Arrays.asList(binderService, channelService); }
@SuppressWarnings("rawtypes") ServiceController<?> installJndiService( ServiceTarget target, String containerName, String cacheName, String jndiNameString, ServiceVerificationHandler verificationHandler) { final String jndiName = InfinispanJndiName.createCacheJndiNameOrDefault(jndiNameString, containerName, cacheName); final ServiceName cacheServiceName = CacheService.getServiceName(containerName, cacheName); final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); final BinderService binder = new BinderService(bindInfo.getBindName()); return target .addService(bindInfo.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName)) .addDependency( cacheServiceName, Cache.class, new ManagedReferenceInjector<Cache>(binder.getManagedObjectInjector())) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.PASSIVE) .install(); }
private void initializeModeShapeEngine( final OperationContext context, final ModelNode operation, ModelNode model, final List<ServiceController<?>> newControllers) { ServiceTarget target = context.getServiceTarget(); final JBossLifeCycleListener shutdownListener = new JBossLifeCycleListener(); engine = buildModeShapeEngine(model); // Engine service ServiceBuilder<JcrEngine> engineBuilder = target.addService(ModeShapeServiceNames.ENGINE, engine); engineBuilder.setInitialMode(ServiceController.Mode.ACTIVE); ServiceController<JcrEngine> controller = engineBuilder.install(); controller.getServiceContainer().addTerminateListener(shutdownListener); newControllers.add(controller); // JNDI Binding final ReferenceFactoryService<JcrEngine> referenceFactoryService = new ReferenceFactoryService<JcrEngine>(); final ServiceName referenceFactoryServiceName = ModeShapeServiceNames.ENGINE.append("reference-factory"); // $NON-NLS-1$ final ServiceBuilder<?> referenceBuilder = target.addService(referenceFactoryServiceName, referenceFactoryService); referenceBuilder.addDependency( ModeShapeServiceNames.ENGINE, JcrEngine.class, referenceFactoryService.getInjector()); referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE); final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(ModeShapeJndiNames.JNDI_BASE_NAME); final BinderService binderService = new BinderService(bindInfo.getBindName()); final ServiceBuilder<?> binderBuilder = target.addService(bindInfo.getBinderServiceName(), binderService); binderBuilder.addDependency( ModeShapeServiceNames.ENGINE, JcrEngine.class, new ManagedReferenceInjector<JcrEngine>(binderService.getManagedObjectInjector())); binderBuilder.addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()); binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE); Logger.getLogger(getClass()) .debug("Binding ModeShape to JNDI name '{0}'", bindInfo.getAbsoluteJndiName()); newControllers.add(referenceBuilder.install()); newControllers.add(binderBuilder.install()); }
void removeRuntimeServices( OperationContext context, ModelNode operation, ModelNode containerModel, ModelNode cacheModel) throws OperationFailedException { // get container and cache addresses final PathAddress cacheAddress = getCacheAddressFromOperation(operation); final PathAddress containerAddress = getCacheContainerAddressFromOperation(operation); // get container and cache names final String cacheName = cacheAddress.getLastElement().getValue(); final String containerName = containerAddress.getLastElement().getValue(); // remove all services started by CacheAdd, in reverse order // remove the binder service ModelNode resolvedValue = null; final String jndiName = (resolvedValue = CacheResourceDefinition.JNDI_NAME.resolveModelAttribute(context, cacheModel)) .isDefined() ? resolvedValue.asString() : null; String defaultCacheName = CacheContainerResourceDefinition.DEFAULT_CACHE .resolveModelAttribute(context, containerModel) .asString(); boolean defaultCache = cacheName.equals(defaultCacheName); ContextNames.BindInfo binding = createCacheBinding( (jndiName != null) ? JndiNameFactory.parse(jndiName) : createJndiName(containerName, cacheName)); context.removeService(binding.getBinderServiceName()); // remove the CacheService instance context.removeService(CacheService.getServiceName(containerName, cacheName)); // remove the cache configuration service context.removeService(CacheConfigurationService.getServiceName(containerName, cacheName)); for (CacheServiceProvider provider : ServiceLoader.load( CacheServiceProvider.class, CacheServiceProvider.class.getClassLoader())) { for (ServiceName name : provider.getServiceNames(containerName, cacheName, defaultCache)) { context.removeService(name); } } log.debugf("cache %s removed for container %s", cacheName, containerName); }
public synchronized void start(StartContext startContext) throws StartException { try { final ServiceContainer container = startContext.getController().getServiceContainer(); deploymentMD = getDeployer().deploy(container); if (deploymentMD.getCfs().length != 1) { throw ConnectorLogger.ROOT_LOGGER.cannotStartDs(); } sqlDataSource = new WildFlyDataSource( (javax.sql.DataSource) deploymentMD.getCfs()[0], jndiName.getAbsoluteJndiName()); DS_DEPLOYER_LOGGER.debugf("Adding datasource: %s", deploymentMD.getCfJndiNames()[0]); CommonDeploymentService cdService = new CommonDeploymentService(deploymentMD); final ServiceName cdServiceName = CommonDeploymentService.getServiceName(jndiName); startContext .getController() .getServiceContainer() .addService(cdServiceName, cdService) // The dependency added must be the JNDI name which for subsystem resources is an alias. // This service // is also used in deployments where the capability service name is not registered for the // service. .addDependency(getServiceName(jndiName)) .setInitialMode(ServiceController.Mode.ACTIVE) .install(); } catch (Throwable t) { throw ConnectorLogger.ROOT_LOGGER.deploymentError(t, dsName); } }
@SuppressWarnings("rawtypes") ServiceController<?> installJndiService( ServiceTarget target, String containerName, String cacheName, boolean defaultCache, String jndiName, ServiceVerificationHandler verificationHandler) { final ServiceName cacheServiceName = CacheService.getServiceName(containerName, cacheName); final ContextNames.BindInfo binding = createCacheBinding( (jndiName != null) ? JndiNameFactory.parse(jndiName) : createJndiName(containerName, cacheName)); final BinderService binder = new BinderService(binding.getBindName()); ServiceBuilder<?> builder = target .addService(binding.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(binding.getBindName())) .addDependency( cacheServiceName, Cache.class, new ManagedReferenceInjector<Cache>(binder.getManagedObjectInjector())) .addDependency( binding.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.PASSIVE); if (defaultCache) { ContextNames.BindInfo defaultBinding = createCacheBinding(createJndiName(containerName, CacheContainer.DEFAULT_CACHE_ALIAS)); builder.addAliases( defaultBinding.getBinderServiceName(), ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(defaultBinding.getBindName())); } return builder.install(); }
@Override protected void performRuntime( OperationContext context, ModelNode operation, ModelNode model, ServiceVerificationHandler verificationHandler, List<ServiceController<?>> newControllers) throws OperationFailedException { // Because we use child resources in a read-only manner to configure the cache, replace the // local model with the full model model = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS)); // Configuration to hold the operation data ConfigurationBuilder builder = new ConfigurationBuilder().read(getDefaultConfiguration(this.mode)); // create a list for dependencies which may need to be added during processing List<Dependency<?>> dependencies = new LinkedList<Dependency<?>>(); // process cache configuration ModelNode describing overrides to defaults processModelNode(model, builder, dependencies); // get all required addresses, names and service names PathAddress cacheAddress = PathAddress.pathAddress(operation.get(OP_ADDR)); PathAddress containerAddress = cacheAddress.subAddress(0, cacheAddress.size() - 1); String cacheName = cacheAddress.getLastElement().getValue(); String containerName = containerAddress.getLastElement().getValue(); ServiceName containerServiceName = EmbeddedCacheManagerService.getServiceName(containerName); ServiceName cacheServiceName = containerServiceName.append(cacheName); ServiceName cacheConfigurationServiceName = CacheConfigurationService.getServiceName(containerName, cacheName); // get container Model Resource rootResource = context.getRootResource(); ModelNode container = rootResource.navigate(containerAddress).getModel(); // get default cache of the container and start mode String defaultCache = container.require(ModelKeys.DEFAULT_CACHE).asString(); ServiceController.Mode initialMode = model.hasDefined(ModelKeys.START) ? StartMode.valueOf(model.get(ModelKeys.START).asString()).getMode() : ServiceController.Mode.ON_DEMAND; // install the cache configuration service (configures a cache) ServiceTarget target = context.getServiceTarget(); InjectedValue<EmbeddedCacheManager> containerInjection = new InjectedValue<EmbeddedCacheManager>(); CacheConfigurationDependencies cacheConfigurationDependencies = new CacheConfigurationDependencies(containerInjection); CacheConfigurationService cacheConfigurationService = new CacheConfigurationService(cacheName, builder, cacheConfigurationDependencies); ServiceBuilder<Configuration> configBuilder = target .addService(cacheConfigurationServiceName, cacheConfigurationService) .addDependency(containerServiceName, EmbeddedCacheManager.class, containerInjection) .setInitialMode(ServiceController.Mode.PASSIVE); Configuration config = builder.build(); if (config.invocationBatching().enabled()) { cacheConfigurationDependencies .getTransactionManagerInjector() .inject(BatchModeTransactionManager.getInstance()); } else if (config.transaction().transactionMode() == org.infinispan.transaction.TransactionMode.TRANSACTIONAL) { configBuilder.addDependency( TxnServices.JBOSS_TXN_TRANSACTION_MANAGER, TransactionManager.class, cacheConfigurationDependencies.getTransactionManagerInjector()); if (config.transaction().useSynchronization()) { configBuilder.addDependency( TxnServices.JBOSS_TXN_SYNCHRONIZATION_REGISTRY, TransactionSynchronizationRegistry.class, cacheConfigurationDependencies.getTransactionSynchronizationRegistryInjector()); } } // add in any additional dependencies resulting from ModelNode parsing for (Dependency<?> dependency : dependencies) { this.addDependency(configBuilder, dependency); } // add an alias for the default cache if (cacheName.equals(defaultCache)) { configBuilder.addAliases(CacheConfigurationService.getServiceName(containerName, null)); } newControllers.add(configBuilder.install()); log.debugf( "Cache configuration service for %s installed for container %s", cacheName, containerName); // now install the corresponding cache service (starts a configured cache) CacheDependencies cacheDependencies = new CacheDependencies(containerInjection); CacheService<Object, Object> cacheService = new CacheService<Object, Object>(cacheName, cacheDependencies); ServiceBuilder<Cache<Object, Object>> cacheBuilder = target .addService(cacheServiceName, cacheService) .addDependency(cacheConfigurationServiceName) .setInitialMode(initialMode); if (config.transaction().recovery().enabled()) { cacheBuilder.addDependency( TxnServices.JBOSS_TXN_ARJUNA_RECOVERY_MANAGER, XAResourceRecoveryRegistry.class, cacheDependencies.getRecoveryRegistryInjector()); } // add an alias for the default cache if (cacheName.equals(defaultCache)) { cacheBuilder.addAliases(CacheService.getServiceName(containerName, null)); } if (initialMode == ServiceController.Mode.ACTIVE) { cacheBuilder.addListener(verificationHandler); } newControllers.add(cacheBuilder.install()); String jndiName = (model.hasDefined(ModelKeys.JNDI_NAME) ? InfinispanJndiName.toJndiName(model.get(ModelKeys.JNDI_NAME).asString()) : InfinispanJndiName.defaultCacheJndiName(containerName, cacheName)) .getAbsoluteName(); ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); BinderService binder = new BinderService(bindInfo.getBindName()); @SuppressWarnings("rawtypes") ServiceBuilder<ManagedReferenceFactory> binderBuilder = target .addService(bindInfo.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName)) .addDependency( cacheServiceName, Cache.class, new ManagedReferenceInjector<Cache>(binder.getManagedObjectInjector())) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.PASSIVE); newControllers.add(binderBuilder.install()); log.debugf("Cache service for cache %s installed for container %s", cacheName, containerName); }
public static ServiceName getServiceName(ContextNames.BindInfo bindInfo) { return SERVICE_NAME_BASE.append(bindInfo.getBinderServiceName().getCanonicalName()); }
@Override protected void performRuntime( OperationContext context, ModelNode operation, ModelNode model, ServiceVerificationHandler verificationHandler, List<ServiceController<?>> newControllers) throws OperationFailedException { // Because we use child resources in a read-only manner to configure the cache container, // replace the local model with the full model model = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS)); final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR)); final String name = address.getLastElement().getValue(); String defaultCache = model.require(ModelKeys.DEFAULT_CACHE).asString(); boolean hasTransport = model.hasDefined(ModelKeys.TRANSPORT) && model.get(ModelKeys.TRANSPORT).hasDefined(ModelKeys.TRANSPORT_NAME); Transport transportConfig = hasTransport ? new Transport() : null; EmbeddedCacheManagerDependencies dependencies = new EmbeddedCacheManagerDependencies(transportConfig); ServiceName[] aliases = null; if (model.hasDefined(ModelKeys.ALIASES)) { List<ModelNode> list = operation.get(ModelKeys.ALIASES).asList(); aliases = new ServiceName[list.size()]; for (int i = 0; i < list.size(); i++) { aliases[i] = EmbeddedCacheManagerService.getServiceName(list.get(i).asString()); } } ServiceTarget target = context.getServiceTarget(); ServiceName serviceName = EmbeddedCacheManagerService.getServiceName(name); ServiceBuilder<EmbeddedCacheManager> containerBuilder = target .addService( serviceName, new EmbeddedCacheManagerService(name, defaultCache, dependencies)) .addDependency( DependencyType.OPTIONAL, ServiceName.JBOSS.append("mbean", "server"), MBeanServer.class, dependencies.getMBeanServerInjector()) .addAliases(aliases) .setInitialMode(ServiceController.Mode.ON_DEMAND); String jndiName = (model.hasDefined(ModelKeys.JNDI_NAME) ? InfinispanJndiName.toJndiName(model.get(ModelKeys.JNDI_NAME).asString()) : InfinispanJndiName.defaultCacheContainerJndiName(name)) .getAbsoluteName(); ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); BinderService binder = new BinderService(bindInfo.getBindName()); ServiceBuilder<ManagedReferenceFactory> binderBuilder = target .addService(bindInfo.getBinderServiceName(), binder) .addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName)) .addDependency( serviceName, CacheContainer.class, new ManagedReferenceInjector<CacheContainer>(binder.getManagedObjectInjector())) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()) .setInitialMode(ServiceController.Mode.ON_DEMAND); newControllers.add(binderBuilder.install()); if (hasTransport) { String stack = null; ModelNode transport = model.get(ModelKeys.TRANSPORT, ModelKeys.TRANSPORT_NAME); if (transport.hasDefined(ModelKeys.STACK)) { stack = transport.get(ModelKeys.STACK).asString(); } if (transport.hasDefined(ModelKeys.LOCK_TIMEOUT)) { transportConfig.setLockTimeout(transport.get(ModelKeys.LOCK_TIMEOUT).asLong()); } addExecutorDependency( containerBuilder, transport, ModelKeys.EXECUTOR, transportConfig.getExecutorInjector()); ServiceName channelServiceName = ChannelService.getServiceName(name); containerBuilder.addDependency( channelServiceName, Channel.class, transportConfig.getChannelInjector()); InjectedValue<ChannelFactory> channelFactory = new InjectedValue<ChannelFactory>(); ServiceBuilder<Channel> channelBuilder = target .addService(channelServiceName, new ChannelService(name, channelFactory)) .addDependency( ChannelFactoryService.getServiceName(stack), ChannelFactory.class, channelFactory) .setInitialMode(ServiceController.Mode.ON_DEMAND); newControllers.add(channelBuilder.install()); } addExecutorDependency( containerBuilder, model, ModelKeys.LISTENER_EXECUTOR, dependencies.getListenerExecutorInjector()); addScheduledExecutorDependency( containerBuilder, model, ModelKeys.EVICTION_EXECUTOR, dependencies.getEvictionExecutorInjector()); addScheduledExecutorDependency( containerBuilder, model, ModelKeys.REPLICATION_QUEUE_EXECUTOR, dependencies.getReplicationQueueExecutorInjector()); newControllers.add(containerBuilder.install()); log.debugf("%s cache container installed", name); }
public void getResourceValue( final ResolutionContext context, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final Module module = deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE); final EEModuleDescription eeModuleDescription = deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION); final String poolName = uniqueName(context, jndiName); final ContextNames.BindInfo bindInfo = ContextNames.bindInfoForEnvEntry( context.getApplicationName(), context.getModuleName(), context.getComponentName(), !context.isCompUsesModule(), jndiName); final DeploymentReflectionIndex reflectionIndex = deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.REFLECTION_INDEX); final boolean securityEnabled = phaseContext.getDeploymentUnit().hasAttachment(SecurityAttachments.SECURITY_ENABLED); try { final Class<?> clazz = module.getClassLoader().loadClass(className); clearUnknownProperties(reflectionIndex, clazz, properties); populateProperties(reflectionIndex, clazz, properties); DsSecurityImpl dsSecurity = new DsSecurityImpl(user, password, null, null); if (XADataSource.class.isAssignableFrom(clazz) && transactional) { final DsXaPoolImpl xaPool = new DsXaPoolImpl( minPoolSize < 0 ? Defaults.MIN_POOL_SIZE : Integer.valueOf(minPoolSize), initialPoolSize < 0 ? Defaults.INITIAL_POOL_SIZE : Integer.valueOf(initialPoolSize), maxPoolSize < 1 ? Defaults.MAX_POOL_SIZE : Integer.valueOf(maxPoolSize), Defaults.PREFILL, Defaults.USE_STRICT_MIN, Defaults.FLUSH_STRATEGY, Defaults.IS_SAME_RM_OVERRIDE, Defaults.INTERLEAVING, Defaults.PAD_XID, Defaults.WRAP_XA_RESOURCE, Defaults.NO_TX_SEPARATE_POOL, Boolean.FALSE, null, Defaults.FAIR, null); final ModifiableXaDataSource dataSource = new ModifiableXaDataSource( transactionIsolation(), null, dsSecurity, null, null, null, null, null, null, poolName, true, jndiName, false, false, Defaults.CONNECTABLE, Defaults.TRACKING, Defaults.MCP, Defaults.ENLISTMENT_TRACE, properties, className, null, null, xaPool, null); final XaDataSourceService xds = new XaDataSourceService( bindInfo.getBinderServiceName().getCanonicalName(), bindInfo, module.getClassLoader()); xds.getDataSourceConfigInjector().inject(dataSource); startDataSource( xds, bindInfo, eeModuleDescription, context, phaseContext.getServiceTarget(), serviceBuilder, injector, securityEnabled); } else { final DsPoolImpl commonPool = new DsPoolImpl( minPoolSize < 0 ? Defaults.MIN_POOL_SIZE : Integer.valueOf(minPoolSize), initialPoolSize < 0 ? Defaults.INITIAL_POOL_SIZE : Integer.valueOf(initialPoolSize), maxPoolSize < 1 ? Defaults.MAX_POOL_SIZE : Integer.valueOf(maxPoolSize), Defaults.PREFILL, Defaults.USE_STRICT_MIN, Defaults.FLUSH_STRATEGY, Boolean.FALSE, null, Defaults.FAIR, null); final ModifiableDataSource dataSource = new ModifiableDataSource( url, null, className, null, transactionIsolation(), properties, null, dsSecurity, null, null, null, null, null, false, poolName, true, jndiName, Defaults.SPY, Defaults.USE_CCM, transactional, Defaults.CONNECTABLE, Defaults.TRACKING, Defaults.MCP, Defaults.ENLISTMENT_TRACE, commonPool); final LocalDataSourceService ds = new LocalDataSourceService( bindInfo.getBinderServiceName().getCanonicalName(), bindInfo, module.getClassLoader()); ds.getDataSourceConfigInjector().inject(dataSource); startDataSource( ds, bindInfo, eeModuleDescription, context, phaseContext.getServiceTarget(), serviceBuilder, injector, securityEnabled); } } catch (Exception e) { throw new DeploymentUnitProcessingException(e); } }
private void performObjectStoreBoottime(OperationContext context, ModelNode model) throws OperationFailedException { boolean useJournalStore = model.hasDefined(USE_JOURNAL_STORE) && model.get(USE_JOURNAL_STORE).asBoolean(); final boolean enableAsyncIO = TransactionSubsystemRootResourceDefinition.JOURNAL_STORE_ENABLE_ASYNC_IO .resolveModelAttribute(context, model) .asBoolean(); final String objectStorePathRef = TransactionSubsystemRootResourceDefinition.OBJECT_STORE_RELATIVE_TO .resolveModelAttribute(context, model) .asString(); final String objectStorePath = TransactionSubsystemRootResourceDefinition.OBJECT_STORE_PATH .resolveModelAttribute(context, model) .asString(); final boolean useJdbcStore = model.hasDefined(USE_JDBC_STORE) && model.get(USE_JDBC_STORE).asBoolean(); final String dataSourceJndiName = TransactionSubsystemRootResourceDefinition.JDBC_STORE_DATASOURCE .resolveModelAttribute(context, model) .asString(); ArjunaObjectStoreEnvironmentService.JdbcStoreConfigBulder confiBuilder = new ArjunaObjectStoreEnvironmentService.JdbcStoreConfigBulder(); confiBuilder .setActionDropTable( TransactionSubsystemRootResourceDefinition.JDBC_ACTION_STORE_DROP_TABLE .resolveModelAttribute(context, model) .asBoolean()) .setStateDropTable( TransactionSubsystemRootResourceDefinition.JDBC_STATE_STORE_DROP_TABLE .resolveModelAttribute(context, model) .asBoolean()) .setCommunicationDropTable( TransactionSubsystemRootResourceDefinition.JDBC_COMMUNICATION_STORE_DROP_TABLE .resolveModelAttribute(context, model) .asBoolean()); if (model.hasDefined( TransactionSubsystemRootResourceDefinition.JDBC_ACTION_STORE_TABLE_PREFIX.getName())) confiBuilder.setActionTablePrefix( TransactionSubsystemRootResourceDefinition.JDBC_ACTION_STORE_TABLE_PREFIX .resolveModelAttribute(context, model) .asString()); if (model.hasDefined( TransactionSubsystemRootResourceDefinition.JDBC_STATE_STORE_TABLE_PREFIX.getName())) confiBuilder.setStateTablePrefix( TransactionSubsystemRootResourceDefinition.JDBC_STATE_STORE_TABLE_PREFIX .resolveModelAttribute(context, model) .asString()); if (model.hasDefined( TransactionSubsystemRootResourceDefinition.JDBC_COMMUNICATION_STORE_TABLE_PREFIX.getName())) confiBuilder.setCommunicationTablePrefix( TransactionSubsystemRootResourceDefinition.JDBC_COMMUNICATION_STORE_TABLE_PREFIX .resolveModelAttribute(context, model) .asString()); TransactionLogger.ROOT_LOGGER.debugf( "objectStorePathRef=%s, objectStorePath=%s%n", objectStorePathRef, objectStorePath); ServiceTarget target = context.getServiceTarget(); // Configure the ObjectStoreEnvironmentBeans final ArjunaObjectStoreEnvironmentService objStoreEnvironmentService = new ArjunaObjectStoreEnvironmentService( useJournalStore, enableAsyncIO, objectStorePath, objectStorePathRef, useJdbcStore, dataSourceJndiName, confiBuilder.build()); ServiceBuilder<Void> builder = target .addService( TxnServices.JBOSS_TXN_ARJUNA_OBJECTSTORE_ENVIRONMENT, objStoreEnvironmentService) .addDependency( PathManagerService.SERVICE_NAME, PathManager.class, objStoreEnvironmentService.getPathManagerInjector()) .addDependency(TxnServices.JBOSS_TXN_CORE_ENVIRONMENT); if (useJdbcStore) { final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(dataSourceJndiName); builder.addDependency(bindInfo.getBinderServiceName()); } builder.setInitialMode(ServiceController.Mode.ACTIVE).install(); TransactionManagerService.addService(target); UserTransactionService.addService(target); target .addService( TxnServices.JBOSS_TXN_USER_TRANSACTION_REGISTRY, new UserTransactionRegistryService()) .setInitialMode(ServiceController.Mode.ACTIVE) .install(); TransactionSynchronizationRegistryService.addService(target); }
static void installRuntimeServices( OperationContext context, PathAddress address, ModelNode fullModel, ServiceVerificationHandler verificationHandler, List<ServiceController<?>> controllers) throws OperationFailedException { String name = address.getLastElement().getValue(); final String jndiName = getJndiName(fullModel, context); final ServiceTarget serviceTarget = context.getServiceTarget(); final MailSessionConfig config = from(context, fullModel); final MailSessionService service = new MailSessionService(config); final ServiceName serviceName = MAIL_SESSION_SERVICE_NAME.append(name); final ServiceBuilder<?> mailSessionBuilder = serviceTarget.addService(serviceName, service); addOutboundSocketDependency(service, mailSessionBuilder, config.getImapServer()); addOutboundSocketDependency(service, mailSessionBuilder, config.getPop3Server()); addOutboundSocketDependency(service, mailSessionBuilder, config.getSmtpServer()); for (CustomServerConfig server : config.getCustomServers()) { if (server.getOutgoingSocketBinding() != null) { addOutboundSocketDependency(service, mailSessionBuilder, server); } } final ManagedReferenceFactory valueManagedReferenceFactory = new MailSessionManagedReferenceFactory(service); final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); final BinderService binderService = new BinderService(bindInfo.getBindName()); final ServiceBuilder<?> binderBuilder = serviceTarget .addService(bindInfo.getBinderServiceName(), binderService) .addInjection(binderService.getManagedObjectInjector(), valueManagedReferenceFactory) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .addListener( new AbstractServiceListener<Object>() { public void transition( final ServiceController<? extends Object> controller, final ServiceController.Transition transition) { switch (transition) { case STARTING_to_UP: { MailLogger.ROOT_LOGGER.boundMailSession(jndiName); break; } case START_REQUESTED_to_DOWN: { MailLogger.ROOT_LOGGER.unboundMailSession(jndiName); break; } case REMOVING_to_REMOVED: { MailLogger.ROOT_LOGGER.removedMailSession(jndiName); break; } } } }); mailSessionBuilder .setInitialMode(ServiceController.Mode.ACTIVE) .addListener(verificationHandler); binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE).addListener(verificationHandler); controllers.add(mailSessionBuilder.install()); controllers.add(binderBuilder.install()); }
@Override protected void performRuntime( final OperationContext context, final ModelNode operation, final ModelNode model, final ServiceVerificationHandler verificationHandler, final List<ServiceController<?>> newControllers) throws OperationFailedException { final ServiceTarget target = context.getServiceTarget(); final AddressContext addressContext = AddressContext.forOperation(operation); final String repositoryName = addressContext.repositoryName(); final String cacheName = attribute(context, model, ModelAttributes.CACHE_NAME, repositoryName); String infinispanConfig = attribute(context, model, ModelAttributes.CACHE_CONFIG, null); String configRelativeTo = attribute(context, model, ModelAttributes.CONFIG_RELATIVE_TO).asString(); final boolean enableMonitoring = attribute(context, model, ModelAttributes.ENABLE_MONITORING).asBoolean(); final String gcThreadPool = attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_THREAD_POOL, null); final String gcInitialTime = attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_INITIAL_TIME, null); final int gcIntervalInHours = attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_INTERVAL).asInt(); final String optThreadPool = attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_THREAD_POOL, null); final String optInitialTime = attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_INITIAL_TIME, null); final int optIntervalInHours = attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_INTERVAL).asInt(); final Integer optTarget = intAttribute( context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_CHILD_COUNT_TARGET, null); final Integer eventBusSize = intAttribute(context, model, ModelAttributes.EVENT_BUS_SIZE, null); final Integer optTolerance = intAttribute( context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_CHILD_COUNT_TOLERANCE, null); // Create a document for the repository configuration ... EditableDocument configDoc = Schematic.newDocument(); configDoc.set(FieldName.NAME, repositoryName); // Determine the JNDI name ... configDoc.set( FieldName.JNDI_NAME, ""); // always set to empty string, since we'll register in JNDI here ... final String jndiName = ModeShapeJndiNames.JNDI_BASE_NAME + repositoryName; String jndiAlias = ModeShapeJndiNames.jndiNameFrom(model, repositoryName); if (jndiName.equals(jndiAlias)) { jndiAlias = null; } if (eventBusSize != null) { configDoc.setNumber(FieldName.EVENT_BUS_SIZE, eventBusSize); } // Parse the cache configuration if (StringUtil.isBlank(infinispanConfig)) { infinispanConfig = "modeshape/" + repositoryName + "-cache-config.xml"; } else { // check if it's a system property String infinispanConfigSystemProperty = System.getProperty(infinispanConfig); if (!StringUtil.isBlank(infinispanConfigSystemProperty)) { infinispanConfig = infinispanConfigSystemProperty; } } // Set the storage information (that was set on the repository ModelNode) ... setRepositoryStorageConfiguration(infinispanConfig, cacheName, configDoc); // Always set whether monitoring is enabled ... enableMonitoring(enableMonitoring, configDoc); // Initial node-types if configured parseCustomNodeTypes(model, configDoc); // Workspace information is on the repository model node (unlike the XML) ... EditableDocument workspacesDoc = parseWorkspaces(context, model, configDoc); // security parseSecurity(context, model, configDoc); // Now create the repository service that manages the lifecycle of the JcrRepository instance // ... RepositoryConfiguration repositoryConfig = new RepositoryConfiguration(configDoc, repositoryName); String configRelativeToSystemProperty = System.getProperty(configRelativeTo); if (!StringUtil.isBlank(configRelativeToSystemProperty)) { configRelativeTo = configRelativeToSystemProperty; } if (!configRelativeTo.endsWith("/")) { configRelativeTo = configRelativeTo + "/"; } RepositoryService repositoryService = new RepositoryService(repositoryConfig, infinispanConfig, configRelativeTo); ServiceName repositoryServiceName = ModeShapeServiceNames.repositoryServiceName(repositoryName); // Sequencing parseSequencing(model, configDoc); // Text Extraction parseTextExtraction(model, configDoc); // Reindexing parseReindexing(model, configDoc); // Journaling parseJournaling(repositoryService, context, model, configDoc); // Add the EngineService's dependencies ... ServiceBuilder<JcrRepository> repositoryServiceBuilder = target.addService(repositoryServiceName, repositoryService); // Add dependency to the ModeShape engine service ... repositoryServiceBuilder.addDependency( ModeShapeServiceNames.ENGINE, ModeShapeEngine.class, repositoryService.getEngineInjector()); repositoryServiceBuilder.setInitialMode(ServiceController.Mode.ACTIVE); // Add garbage collection information ... if (gcThreadPool != null) { configDoc .getOrCreateDocument(FieldName.GARBAGE_COLLECTION) .setString(FieldName.THREAD_POOL, gcThreadPool); } if (gcInitialTime != null) { configDoc .getOrCreateDocument(FieldName.GARBAGE_COLLECTION) .setString(FieldName.INITIAL_TIME, gcInitialTime); } configDoc .getOrCreateDocument(FieldName.GARBAGE_COLLECTION) .setNumber(FieldName.INTERVAL_IN_HOURS, gcIntervalInHours); // Add document optimization information ... if (optTarget != null) { EditableDocument docOpt = configDoc .getOrCreateDocument(FieldName.STORAGE) .getOrCreateDocument(FieldName.DOCUMENT_OPTIMIZATION); if (optThreadPool != null) { docOpt.setString(FieldName.THREAD_POOL, optThreadPool); } if (optInitialTime != null) { docOpt.setString(FieldName.INITIAL_TIME, optInitialTime); } docOpt.setNumber(FieldName.INTERVAL_IN_HOURS, optIntervalInHours); docOpt.setNumber(FieldName.OPTIMIZATION_CHILD_COUNT_TARGET, optTarget.intValue()); if (optTolerance != null) { docOpt.setNumber(FieldName.OPTIMIZATION_CHILD_COUNT_TOLERANCE, optTolerance.intValue()); } } // Add the dependency to the Security Manager repositoryServiceBuilder.addDependency( SecurityManagementService.SERVICE_NAME, ISecurityManagement.class, repositoryService.getSecurityManagementServiceInjector()); // Add dependency, if necessary, to the workspaces cache container String workspacesInfinispanConfig = attribute(context, model, ModelAttributes.WORKSPACES_CACHE_CONTAINER, null); if (workspacesInfinispanConfig != null && !workspacesInfinispanConfig.toLowerCase().equalsIgnoreCase(infinispanConfig)) { workspacesDoc.set(FieldName.WORKSPACE_CACHE_CONFIGURATION, workspacesInfinispanConfig); } repositoryServiceBuilder.addDependency( Services.JBOSS_SERVICE_MODULE_LOADER, ModuleLoader.class, repositoryService.getModuleLoaderInjector()); // Set up the JNDI binder service ... final ReferenceFactoryService<JcrRepository> referenceFactoryService = new ReferenceFactoryService<JcrRepository>(); ServiceName referenceFactoryServiceName = ModeShapeServiceNames.referenceFactoryServiceName(repositoryName); final ServiceBuilder<?> referenceBuilder = target.addService(referenceFactoryServiceName, referenceFactoryService); referenceBuilder.addDependency( repositoryServiceName, JcrRepository.class, referenceFactoryService.getInjector()); referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE); ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); BinderService binder = new BinderService(bindInfo.getBindName()); ServiceBuilder<?> binderBuilder = target.addService(bindInfo.getBinderServiceName(), binder); if (jndiAlias != null) { ContextNames.BindInfo aliasInfo = ContextNames.bindInfoFor(jndiAlias); ServiceName alias = aliasInfo.getBinderServiceName(); binderBuilder.addAliases(alias); LOG.debugv( "Binding repository {0} to JNDI name {1} and {2}", repositoryName, bindInfo.getAbsoluteJndiName(), aliasInfo.getAbsoluteJndiName()); } else { LOG.debugv( "Binding repository {0} to JNDI name {1}", repositoryName, bindInfo.getAbsoluteJndiName()); } binderBuilder.addDependency( referenceFactoryServiceName, ManagedReferenceFactory.class, binder.getManagedObjectInjector()); binderBuilder.addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binder.getNamingStoreInjector()); binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE); // Add dependency to the data directory ... ServiceName dataDirServiceName = ModeShapeServiceNames.dataDirectoryServiceName(repositoryName); ServiceController<String> dataDirServiceController = RelativePathService.addService( dataDirServiceName, "modeshape/" + repositoryName, ModeShapeExtension.JBOSS_DATA_DIR_VARIABLE, target); newControllers.add(dataDirServiceController); repositoryServiceBuilder.addDependency( dataDirServiceName, String.class, repositoryService.getDataDirectoryPathInjector()); // Add the default binary storage service which will provide the binary configuration BinaryStorageService defaultBinaryService = BinaryStorageService.createDefault(); ServiceName defaultBinaryStorageServiceName = ModeShapeServiceNames.binaryStorageDefaultServiceName(repositoryName); ServiceBuilder<BinaryStorage> binaryStorageBuilder = target.addService(defaultBinaryStorageServiceName, defaultBinaryService); binaryStorageBuilder.setInitialMode(ServiceController.Mode.ACTIVE); // Add dependency to the binaries storage service, which captures the properties for the // binaries storage repositoryServiceBuilder.addDependency( defaultBinaryStorageServiceName, BinaryStorage.class, repositoryService.getBinaryStorageInjector()); // Add monitor service final MonitorService monitorService = new MonitorService(); final ServiceBuilder<RepositoryMonitor> monitorBuilder = target.addService(ModeShapeServiceNames.monitorServiceName(repositoryName), monitorService); monitorBuilder.addDependency( ModeShapeServiceNames.repositoryServiceName(repositoryName), JcrRepository.class, monitorService.getJcrRepositoryInjector()); monitorBuilder.setInitialMode(ServiceController.Mode.ACTIVE); // Now add the controller for the RepositoryService ... newControllers.add(repositoryServiceBuilder.install()); newControllers.add(referenceBuilder.install()); newControllers.add(binderBuilder.install()); newControllers.add(binaryStorageBuilder.install()); newControllers.add(monitorBuilder.install()); }
private void startDataSource( final AbstractDataSourceService dataSourceService, final ContextNames.BindInfo bindInfo, final EEModuleDescription moduleDescription, final ResolutionContext context, final ServiceTarget serviceTarget, final ServiceBuilder valueSourceServiceBuilder, final Injector<ManagedReferenceFactory> injector, boolean securityEnabled) { final ServiceName dataSourceServiceName = AbstractDataSourceService.getServiceName(bindInfo); final ServiceBuilder<?> dataSourceServiceBuilder = Services.addServerExecutorDependency( serviceTarget.addService(dataSourceServiceName, dataSourceService), dataSourceService.getExecutorServiceInjector(), false) .addDependency( ConnectorServices.IRONJACAMAR_MDR, MetadataRepository.class, dataSourceService.getMdrInjector()) .addDependency( ConnectorServices.RA_REPOSITORY_SERVICE, ResourceAdapterRepository.class, dataSourceService.getRaRepositoryInjector()) .addDependency(ConnectorServices.BOOTSTRAP_CONTEXT_SERVICE.append(DEFAULT_NAME)) .addDependency( ConnectorServices.TRANSACTION_INTEGRATION_SERVICE, TransactionIntegration.class, dataSourceService.getTransactionIntegrationInjector()) .addDependency( ConnectorServices.MANAGEMENT_REPOSITORY_SERVICE, ManagementRepository.class, dataSourceService.getManagementRepositoryInjector()) .addDependency( ConnectorServices.CCM_SERVICE, CachedConnectionManager.class, dataSourceService.getCcmInjector()) .addDependency( ConnectorServices.JDBC_DRIVER_REGISTRY_SERVICE, DriverRegistry.class, dataSourceService.getDriverRegistryInjector()) .addDependency(NamingService.SERVICE_NAME); if (securityEnabled) { dataSourceServiceBuilder.addDependency( SubjectFactoryService.SERVICE_NAME, SubjectFactory.class, dataSourceService.getSubjectFactoryInjector()); } final DataSourceReferenceFactoryService referenceFactoryService = new DataSourceReferenceFactoryService(); final ServiceName referenceFactoryServiceName = DataSourceReferenceFactoryService.SERVICE_NAME_BASE.append(bindInfo.getBinderServiceName()); final ServiceBuilder<?> referenceBuilder = serviceTarget .addService(referenceFactoryServiceName, referenceFactoryService) .addDependency( dataSourceServiceName, javax.sql.DataSource.class, referenceFactoryService.getDataSourceInjector()); final BinderService binderService = new BinderService(bindInfo.getBindName(), this); final ServiceBuilder<?> binderBuilder = serviceTarget .addService(bindInfo.getBinderServiceName(), binderService) .addDependency( referenceFactoryServiceName, ManagedReferenceFactory.class, binderService.getManagedObjectInjector()) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .addListener( new AbstractServiceListener<Object>() { public void transition( final ServiceController<? extends Object> controller, final ServiceController.Transition transition) { switch (transition) { case STARTING_to_UP: { SUBSYSTEM_DATASOURCES_LOGGER.boundDataSource(jndiName); break; } case START_REQUESTED_to_DOWN: { SUBSYSTEM_DATASOURCES_LOGGER.unboundDataSource(jndiName); break; } case REMOVING_to_REMOVED: { SUBSYSTEM_DATASOURCES_LOGGER.debugf( "Removed JDBC Data-source [%s]", jndiName); break; } } } }); dataSourceServiceBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install(); referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install(); binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install(); valueSourceServiceBuilder.addDependency( bindInfo.getBinderServiceName(), ManagedReferenceFactory.class, injector); }
/** * Make any runtime changes necessary to effect the changes indicated by the given {@code * operation}. E * * <p>It constructs a MailSessionService that provides mail session and registers it to Naming * service. * * @param context the operation context * @param operation the operation being executed * @param model persistent configuration model node that corresponds to the address of {@code * operation} * @param verificationHandler step handler that can be added as a listener to any new services * installed in order to validate the services installed correctly during the {@link * org.jboss.as.controller.OperationContext.Stage#VERIFY VERIFY stage} * @param controllers holder for the {@link org.jboss.msc.service.ServiceController} for any new * services installed by the method. The method should add the {@code ServiceController} for * any new services to this list. If the overall operation needs to be rolled back, the list * will be used in {@link #rollbackRuntime(org.jboss.as.controller.OperationContext, * org.jboss.dmr.ModelNode, org.jboss.dmr.ModelNode, java.util.List)} to automatically removed * the newly added services * @throws org.jboss.as.controller.OperationFailedException if {@code operation} is invalid or * updating the runtime otherwise fails */ @Override protected void performRuntime( OperationContext context, ModelNode operation, ModelNode model, ServiceVerificationHandler verificationHandler, List<ServiceController<?>> controllers) throws OperationFailedException { final String jndiName = getJndiName(operation); final ServiceTarget serviceTarget = context.getServiceTarget(); ModelNode fullTree = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS)); final MailSessionConfig config = from(context, fullTree); final MailSessionService service = new MailSessionService(config); final ServiceName serviceName = SERVICE_NAME_BASE.append(jndiName); final ServiceBuilder<?> mailSessionBuilder = serviceTarget.addService(serviceName, service); addOutboundSocketDependency(service, mailSessionBuilder, config.getImapServer()); addOutboundSocketDependency(service, mailSessionBuilder, config.getPop3Server()); addOutboundSocketDependency(service, mailSessionBuilder, config.getSmtpServer()); for (CustomServerConfig server : config.getCustomServers()) { if (server.getOutgoingSocketBinding() != null) { addOutboundSocketDependency(service, mailSessionBuilder, server); } } final ManagedReferenceFactory valueManagedReferenceFactory = new ContextListAndJndiViewManagedReferenceFactory() { @Override public String getJndiViewInstanceValue() { return String.valueOf(getReference().getInstance()); } @Override public String getInstanceClassName() { final Object value = getReference().getInstance(); return value != null ? value.getClass().getName() : ContextListManagedReferenceFactory.DEFAULT_INSTANCE_CLASS_NAME; } @Override public ManagedReference getReference() { return new ValueManagedReference(new ImmediateValue<Object>(service.getValue())); } }; final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); final BinderService binderService = new BinderService(bindInfo.getBindName()); final ServiceBuilder<?> binderBuilder = serviceTarget .addService(bindInfo.getBinderServiceName(), binderService) .addInjection(binderService.getManagedObjectInjector(), valueManagedReferenceFactory) .addDependency( bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .addListener( new AbstractServiceListener<Object>() { public void transition( final ServiceController<? extends Object> controller, final ServiceController.Transition transition) { switch (transition) { case STARTING_to_UP: { MailLogger.ROOT_LOGGER.boundMailSession(jndiName); break; } case START_REQUESTED_to_DOWN: { MailLogger.ROOT_LOGGER.unboundMailSession(jndiName); break; } case REMOVING_to_REMOVED: { MailLogger.ROOT_LOGGER.removedMailSession(jndiName); break; } } } }); mailSessionBuilder .setInitialMode(ServiceController.Mode.ACTIVE) .addListener(verificationHandler); binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE).addListener(verificationHandler); controllers.add(mailSessionBuilder.install()); controllers.add(binderBuilder.install()); }