@Override public ServiceBuilder<T> build(ServiceTarget target) { return target.addService(this.name, this).addDependency(EXECUTOR_SERVICE_NAME, ExecutorService.class, this.executor); }
public static ServiceController<JdrReportCollector> addService(final ServiceTarget target) { JdrReportService service = new JdrReportService(); return target.addService(SERVICE_NAME, service) .addDependency(ServerEnvironmentService.SERVICE_NAME, ServerEnvironment.class, service.serverEnvironmentValue) .addDependency(Services.JBOSS_SERVER_CONTROLLER, ModelController.class, service.modelControllerValue) .setInitialMode(ServiceController.Mode.ACTIVE) .install(); }
@Override public ServiceBuilder<T> build(ServiceTarget target) { return target.addService(this.name, new ValueService<>(this.value)) .addDependency(this.targetName, this.targetClass, this.value) .setInitialMode(ServiceController.Mode.PASSIVE); } }
public static ServiceController<TransactionManager> addService(final ServiceTarget target) { final TransactionManagerService service = new TransactionManagerService(); ServiceBuilder<TransactionManager> serviceBuilder = target.addService(INTERNAL_SERVICE_NAME, service); // This is really a dependency on the global context. TODO: Break this later; no service is needed for TM really serviceBuilder.requires(TxnServices.JBOSS_TXN_LOCAL_TRANSACTION_CONTEXT); serviceBuilder.addDependency(UserTransactionRegistryService.SERVICE_NAME, UserTransactionRegistry.class, service.registryInjector); return serviceBuilder.install(); }
@Override protected void startConfigAndAddDependency(ServiceBuilder<?> dataSourceServiceBuilder, AbstractDataSourceService dataSourceService, String jndiName, ServiceTarget serviceTarget, final ModelNode operation) throws OperationFailedException { final ServiceName dataSourceCongServiceName = XADataSourceConfigService.SERVICE_NAME_BASE.append(jndiName); dataSourceServiceBuilder.addDependency(dataSourceCongServiceName, ModifiableXaDataSource.class, ((XaDataSourceService) dataSourceService).getDataSourceConfigInjector()); } }
builder.addDependency(PathManagerService.SERVICE_NAME, PathManager.class, objStoreEnvironmentService.getPathManagerInjector()); builder.requires(TxnServices.JBOSS_TXN_CORE_ENVIRONMENT); if (useJdbcStore) { builder.requires(bindInfo.getBinderServiceName()); builder.setInitialMode(ServiceController.Mode.ACTIVE).install(); .setInitialMode(ServiceController.Mode.ACTIVE).install(); TransactionSynchronizationRegistryService.addService(target);
public static void initializeServiceBuilder(ManagedProcessEngineMetadata processEngineConfiguration, MscManagedProcessEngineController service, ServiceBuilder<ProcessEngine> serviceBuilder, String jobExecutorName) { ContextNames.BindInfo datasourceBindInfo = ContextNames.bindInfoFor(processEngineConfiguration.getDatasourceJndiName()); serviceBuilder.addDependency(ServiceName.JBOSS.append("txn").append("TransactionManager"), TransactionManager.class, service.getTransactionManagerInjector()) .addDependency(datasourceBindInfo.getBinderServiceName(), DataSourceReferenceFactoryService.class, service.getDatasourceBinderServiceInjector()) .addDependency(ServiceNames.forMscRuntimeContainerDelegate(), MscRuntimeContainerDelegate.class, service.getRuntimeContainerDelegateInjector()) .addDependency(ServiceNames.forMscRuntimeContainerJobExecutorService(jobExecutorName), MscRuntimeContainerJobExecutor.class, service.getMscRuntimeContainerJobExecutorInjector()) .addDependency(ServiceNames.forMscExecutorService()) .setInitialMode(Mode.ACTIVE); if(processEngineConfiguration.isDefault()) { serviceBuilder.addAliases(ServiceNames.forDefaultProcessEngine()); } JBossCompatibilityExtension.addServerExecutorDependency(serviceBuilder, service.getExecutorInjector(), false); }
public static ServiceController<TransactionSynchronizationRegistry> addService(final CapabilityServiceTarget target) { TransactionSynchronizationRegistryService service = new TransactionSynchronizationRegistryService(); ServiceBuilder<TransactionSynchronizationRegistry> serviceBuilder = target.addCapability(TRANSACTION_SYNCHRONIZATION_REGISTRY_CAPABILITY, service); serviceBuilder.requires(TxnServices.JBOSS_TXN_LOCAL_TRANSACTION_CONTEXT); serviceBuilder.addDependency(ArjunaTransactionManagerService.SERVICE_NAME, com.arjuna.ats.jbossatx.jta.TransactionManagerService.class, service.injectedArjunaTM); serviceBuilder.addAliases(INTERNAL_SERVICE_NAME); return serviceBuilder.install(); }
void installRuntimeServices(final OperationContext context) throws OperationFailedException { final RemoteNamingServerService remoteNamingServerService = new RemoteNamingServerService(); final ServiceBuilder<RemoteNamingService> builder = context.getServiceTarget().addService(RemoteNamingServerService.SERVICE_NAME, remoteNamingServerService); builder.addDependency(RemotingServices.SUBSYSTEM_ENDPOINT, Endpoint.class, remoteNamingServerService.getEndpointInjector()) .addDependency(ContextNames.EXPORTED_CONTEXT_SERVICE_NAME, NamingStore.class, remoteNamingServerService.getNamingStoreInjector()) .install(); }
/** * <p> * Adds a {@code BinderService} to the specified target. The service binds the specified value to JNDI under the * {@code java:/jboss/contextName} context. * </p> * * @param target the {@code ServiceTarget} where the service will be added. * @param contextName the JNDI context name where the value will be bound. * @param value the value to be bound. */ public static void bindObject(final ServiceTarget target, final String contextName, final Object value) { final BinderService binderService = new BinderService(contextName); binderService.getManagedObjectInjector().inject(new ValueManagedReferenceFactory(Values.immediateValue(value))); target.addService(ContextNames.buildServiceName(ContextNames.JBOSS_CONTEXT_SERVICE_NAME, contextName), binderService) .addDependency(ContextNames.JBOSS_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .install(); } }
@Override protected void startConfigAndAddDependency(ServiceBuilder<?> dataSourceServiceBuilder, AbstractDataSourceService dataSourceService, String jndiName, ServiceTarget serviceTarget, final ModelNode operation) throws OperationFailedException { final ServiceName dataSourceCongServiceName = DataSourceConfigService.SERVICE_NAME_BASE.append(jndiName); dataSourceServiceBuilder.addDependency(dataSourceCongServiceName, ModifiableDataSource.class, ((LocalDataSourceService) dataSourceService).getDataSourceConfigInjector()); }
private void bindBeanManager(ServiceTarget serviceTarget, ServiceName beanManagerServiceName, ServiceName contextServiceName, final Collection<ServiceName> dependencies, final ServiceRegistry serviceRegistry) { final ServiceName beanManagerBindingServiceName = contextServiceName.append("BeanManager"); dependencies.add(beanManagerBindingServiceName); BinderService beanManagerBindingService = new BinderService("BeanManager"); final BeanManagerManagedReferenceFactory referenceFactory = new BeanManagerManagedReferenceFactory(); beanManagerBindingService.getManagedObjectInjector().inject(referenceFactory); serviceTarget.addService(beanManagerBindingServiceName, beanManagerBindingService) .addDependency(contextServiceName, ServiceBasedNamingStore.class, beanManagerBindingService.getNamingStoreInjector()) .addDependency(beanManagerServiceName, BeanManager.class, referenceFactory.beanManager) .install(); }
private void setupPolicyRegistration(final StartContext context) { ServiceTarget target = context.getChildTarget(); final BinderService binderService = new BinderService(POLICY_REGISTRATION); binderService.getManagedObjectInjector().inject(new ValueManagedReferenceFactory( Values.immediateValue(new JBossPolicyRegistration()))); target.addService(ContextNames.buildServiceName(ContextNames.JAVA_CONTEXT_SERVICE_NAME, POLICY_REGISTRATION), binderService) .addDependency(ContextNames.JAVA_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .install(); }
@Override public void configureDependency(ServiceBuilder<?> serviceBuilder, Service<Component> service) throws DeploymentUnitProcessingException { final StatelessSessionComponentCreateService statelessSessionComponentService = (StatelessSessionComponentCreateService) service; final String poolName = this.statelessComponentDescription.getPoolConfigName(); // if no pool name has been explicitly set, then inject the *optional* "default slsb pool config". // If the default slsb pool config itself is not configured, then the pooling is disabled for the bean if (poolName == null) { if (statelessComponentDescription.isDefaultSlsbPoolAvailable()) { serviceBuilder.addDependency(StrictMaxPoolConfigService.DEFAULT_SLSB_POOL_CONFIG_SERVICE_NAME, PoolConfig.class, statelessSessionComponentService.getPoolConfigInjector()); } } else { // pool name has been explicitly set so the pool config is a required dependency serviceBuilder.addDependency(StrictMaxPoolConfigService.EJB_POOL_CONFIG_BASE_SERVICE_NAME.append(poolName), PoolConfig.class, statelessSessionComponentService.getPoolConfigInjector()); } } }
@Override protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { IdentityService identityService = new IdentityService(); ServiceBuilder<Function<SecurityIdentity, Set<SecurityIdentity>>> serviceBuilder = context.getServiceTarget() .addService(IDENTITY_RUNTIME_CAPABILITY.getCapabilityServiceName(), identityService) .setInitialMode(Mode.ACTIVE); for (String outflowSecurityDomain : outflowSecurityDomains) { serviceBuilder.addDependency(context.getCapabilityServiceName( SECURITY_DOMAIN_CAPABILITY, outflowSecurityDomain, SecurityDomain.class), SecurityDomain.class, identityService.createOutflowSecurityDomainInjector()); } serviceBuilder.install(); } }
private void bindValueToJndi(final StartContext context) { final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); final BinderService binderService = new BinderService(bindInfo.getBindName()); binderService.getManagedObjectInjector().inject(new ImmediateManagedReferenceFactory(getValue())); context.getChildTarget().addService(bindInfo.getBinderServiceName(),binderService) .addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()) .install(); }
@Override public void configureDependency(ServiceBuilder<?> serviceBuilder, Service<Component> service) { final MessageDrivenComponentCreateService mdbComponentCreateService = (MessageDrivenComponentCreateService) service; final String poolName = this.mdbComponentDescription.getPoolConfigName(); // if no pool name has been explicitly set, then inject the *optional* "default mdb pool config" // If the default mdb pool config itself is not configured, then pooling is disabled for the bean if (poolName == null) { if (mdbComponentDescription.isDefaultMdbPoolAvailable()) { serviceBuilder.addDependency(StrictMaxPoolConfigService.DEFAULT_MDB_POOL_CONFIG_SERVICE_NAME, PoolConfig.class, mdbComponentCreateService.getPoolConfigInjector()); } } else { // pool name has been explicitly set so the pool config is a required dependency serviceBuilder.addDependency(StrictMaxPoolConfigService.EJB_POOL_CONFIG_BASE_SERVICE_NAME.append(poolName), PoolConfig.class, mdbComponentCreateService.getPoolConfigInjector()); } } }
@Override public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ServiceName serviceName = deploymentUnit.getServiceName().append(SERVICE_NAME); final CachedConnectionManagerSetupAction action = new CachedConnectionManagerSetupAction(serviceName); phaseContext.getServiceTarget().addService(serviceName, action) .addDependency(ConnectorServices.CCM_SERVICE, CachedConnectionManager.class, action.cachedConnectionManager) .addDependency(ConnectorServices.NON_TX_CCM_SERVICE, CachedConnectionManager.class, action.noTxCcmValue) .install(); deploymentUnit.addToAttachmentList(Attachments.WEB_SETUP_ACTIONS, action); deploymentUnit.addToAttachmentList(Attachments.OTHER_EE_SETUP_ACTIONS, action); }
@Override public void configureDependency(ServiceBuilder<?> serviceBuilder, Service<Component> service) throws DeploymentUnitProcessingException { final EJBComponentCreateService ejbComponentCreateService = (EJBComponentCreateService) service; final String securityDomainName = SecurityDomainDependencyConfigurator.this.ejbComponentDescription.getSecurityDomain(); if (SecurityDomainDependencyConfigurator.this.ejbComponentDescription.isSecurityDomainKnown()) { final DeploymentUnit deploymentUnit = context.getDeploymentUnit(); final CapabilityServiceSupport support = deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.CAPABILITY_SERVICE_SUPPORT); if (securityDomainName != null && ! securityDomainName.isEmpty()) { serviceBuilder.addDependency(support.getCapabilityServiceName(ApplicationSecurityDomainDefinition.APPLICATION_SECURITY_DOMAIN_CAPABILITY, securityDomainName), ApplicationSecurityDomain.class, ejbComponentCreateService.getApplicationSecurityDomainInjector()); } if (SecurityDomainDependencyConfigurator.this.ejbComponentDescription.isOutflowSecurityDomainsConfigured()) { serviceBuilder.addDependency(support.getCapabilityServiceName(IDENTITY_CAPABILITY), Function.class, ejbComponentCreateService.getIdentityOutflowFunctionInjector()); } } else { if (securityDomainName != null && !securityDomainName.isEmpty()) { final ServiceName securityDomainServiceName = SecurityDomainService.SERVICE_NAME.append(securityDomainName); serviceBuilder.requires(securityDomainServiceName); } serviceBuilder.requires(SecurityDomainService.SERVICE_NAME.append(SecurityConstants.DEFAULT_EJB_APPLICATION_POLICY)); } } });
@Override protected void performRuntime(final OperationContext context, final ModelNode operation, final ModelNode model) throws OperationFailedException { String name = JcaBootstrapContextDefinition.BootstrapCtxParameters.NAME.getAttribute().resolveModelAttribute(context, model).asString(); String workmanager = JcaBootstrapContextDefinition.BootstrapCtxParameters.WORKMANAGER.getAttribute().resolveModelAttribute(context, model).asString(); boolean usingDefaultWm = false; CloneableBootstrapContext ctx; if (DEFAULT_NAME.equals(workmanager)) { usingDefaultWm = true; ctx = new NamedBootstrapContext(name); } else { ctx = new NamedBootstrapContext(name, workmanager); } ServiceTarget serviceTarget = context.getServiceTarget(); final BootStrapContextService bootCtxService = new BootStrapContextService(ctx, name, usingDefaultWm); serviceTarget .addService(ConnectorServices.BOOTSTRAP_CONTEXT_SERVICE.append(name), bootCtxService) .addDependency(ConnectorServices.WORKMANAGER_SERVICE.append(workmanager), WorkManager.class, bootCtxService.getWorkManagerValueInjector()) .addDependency(TxnServices.JBOSS_TXN_CONTEXT_XA_TERMINATOR, JBossContextXATerminator.class, bootCtxService.getXaTerminatorInjector()) .addDependency(TxnServices.JBOSS_TXN_ARJUNA_TRANSACTION_MANAGER, com.arjuna.ats.jbossatx.jta.TransactionManagerService.class, bootCtxService.getTxManagerInjector()) .addDependency(ConnectorServices.CONNECTOR_CONFIG_SERVICE, JcaSubsystemConfiguration.class, bootCtxService.getJcaConfigInjector()) .setInitialMode(ServiceController.Mode.ACTIVE) .install(); } }