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); } }
@Override public Lifecycle apply(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.name); for (Map.Entry<ServiceName[], DeferredInjector<?>> entry : this.injectors) { entry.getValue().setConsumer(builder.provides(entry.getKey())); } return new ServiceLifecycle(builder.setInstance(this.service).setInitialMode(ServiceController.Mode.NEVER).install()); } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceName name = this.getServiceName(); ServiceBuilder<?> builder = target.addService(name); Consumer<CacheFactoryBuilder<K, V>> cacheFactoryBuilder = builder.provides(name); Service service = Service.newInstance(cacheFactoryBuilder, this); return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND); }
protected void install(OperationContext context, ModelNode operation, final int maxSize, final String containerName, final String cacheName) { final String name = context.getCurrentAddressValue(); BeanManagerFactoryServiceConfiguratorConfiguration config = new BeanManagerFactoryServiceConfiguratorConfiguration() { @Override public String getContainerName() { return containerName; } @Override public String getCacheName() { return cacheName; } @Override public int getMaxSize() { return maxSize; } }; new DistributableCacheFactoryBuilderServiceConfigurator<>(name, config).build(context.getServiceTarget()) .setInitialMode(ServiceController.Mode.ON_DEMAND) .install(); } }
CapabilityServiceTarget target = context.getCapabilityServiceTarget(); final String securityDomain = SECURITY_DOMAIN.resolveModelAttribute(context, model).asStringOrNull(); final String httpServerMechanismFactory = HTTP_AUTHENTICATION_FACTORY.resolveModelAttribute(context, model).asStringOrNull(); boolean overrideDeploymentConfig = OVERRIDE_DEPLOYMENT_CONFIG.resolveModelAttribute(context, model).asBoolean(); boolean enableJacc = ENABLE_JACC.resolveModelAttribute(context, model).asBoolean(); boolean enableJaspi = ENABLE_JASPI.resolveModelAttribute(context, model).asBoolean(); .setInitialMode(Mode.LAZY); .map(provider -> provider.getServiceConfigurator(managerServiceName, securityDomainName, generator)) .orElse(new SimpleCapabilityServiceConfigurator<>(managerServiceName, new DefaultSingleSignOnManager(new ConcurrentHashMap<>(), generator::createSessionId))) .configure(context).build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); factoryConfigurator.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); ApplicationSecurityDomainService service = new ApplicationSecurityDomainService(overrideDeploymentConfig, enableJacc, enableJaspi, integratedJaspi, factoryFunction, transformerSupplier, valueConsumer); serviceBuilder.setInstance(service); serviceBuilder.install();
@Override protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { final PathAddress hostAddress = context.getCurrentAddress().getParent(); final PathAddress serverAddress = hostAddress.getParent(); final String name = context.getCurrentAddressValue(); final String handler = LocationDefinition.HANDLER.resolveModelAttribute(context, model).asString(); final LocationService service = new LocationService(name); final String serverName = serverAddress.getLastElement().getValue(); final String hostName = hostAddress.getLastElement().getValue(); final ServiceName serviceName = UndertowService.locationServiceName(serverName, hostName, name); final ServiceBuilder<LocationService> builder = context.getCapabilityServiceTarget().addCapability(LocationDefinition.LOCATION_CAPABILITY, service) .addCapabilityRequirement(Capabilities.CAPABILITY_HANDLER, HttpHandler.class, service.getHttpHandler(),handler) .addCapabilityRequirement(Capabilities.CAPABILITY_HOST, Host.class, service.getHost(), serverName, hostName); builder.setInitialMode(ServiceController.Mode.ACTIVE) .addAliases(serviceName) .install(); } }
@Override public Lifecycle apply(ServiceTarget target) { Lifecycle primaryLifecycle = new ServiceLifecycle(target.addService(this.name.append("primary"), this.primaryService).setInitialMode(ServiceController.Mode.NEVER).install()); Lifecycle backupLifecycle = new ServiceLifecycle(target.addService(this.name.append("backup"), this.backupService).setInitialMode(ServiceController.Mode.ACTIVE).install()); return new PrimaryBackupLifecycle(primaryLifecycle, backupLifecycle); } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<T> consumer = this.requirement.register(builder).provides(this.getServiceName()); Service service = new FunctionalService<>(consumer, Function.identity(), this.requirement); return builder.setInstance(service).setInitialMode(ServiceController.Mode.PASSIVE); } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { this.configurationConfigurator.build(target).install(); this.cacheConfigurator.build(target).install(); ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<SessionManagerFactory<L, TransactionBatch>> factory = new CompositeDependency(this.group, this.affinityFactory, this.dispatcherFactory).register(builder).provides(this.getServiceName()); this.cache = builder.requires(this.cacheConfigurator.getServiceName()); Service service = new FunctionalService<>(factory, Function.identity(), this, Consumers.close()); return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND); }
@Override public void installServices(OperationContext context, ModelNode model) throws OperationFailedException { super.installServices(context, model); PathAddress address = context.getCurrentAddress(); String name = context.getCurrentAddressValue(); ServiceTarget target = context.getServiceTarget(); new ModuleServiceConfigurator(RemoteCacheContainerComponent.MODULE.getServiceName(address), MODULE).configure(context, model).build(target).setInitialMode(ServiceController.Mode.PASSIVE).install(); ServiceConfigurator containerBuilder = new RemoteCacheContainerServiceConfigurator(address).configure(context, model); containerBuilder.build(target).install(); new BinderServiceConfigurator(InfinispanBindingFactory.createRemoteCacheContainerBinding(name), containerBuilder.getServiceName()).build(target).install(); }
@Override protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { final String name = context.getCurrentAddressValue(); final FilterService service = new FilterService(handler, getResolvedModel(context, model)); final ServiceTarget target = context.getServiceTarget(); target.addService(UndertowService.FILTER.append(name), service) .setInitialMode(ServiceController.Mode.ON_DEMAND) .install(); }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<Group> group = this.factory.register(builder).provides(this.getServiceName()); Service service = new FunctionalService<>(group, Function.identity(), this); return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND); } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { this.configurationConfigurator.build(target).install(); this.cacheConfigurator.build(target).install(); ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<SSOManagerFactory<A, D, S, TransactionBatch>> factory = this.affinityFactory.register(builder).provides(this.getServiceName()); this.cache = builder.requires(this.cacheConfigurator.getServiceName()); Service service = Service.newInstance(factory, new InfinispanSSOManagerFactory<>(this)); return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND); }
ModelNode proxyModel = Resource.Tools.readModel(proxyResource); ServiceTarget target = context.getServiceTarget(); ProxyConfigurationServiceConfigurator configurationBuilder = new ProxyConfigurationServiceConfigurator(proxyAddress); configurationBuilder.configure(context, proxyModel).build(target).install(); int statusInterval = STATUS_INTERVAL.resolveModelAttribute(context, proxyModel).asInt(); new ContainerEventHandlerServiceConfigurator(proxyAddress, loadProvider).build(target).install(); provider.getServiceConfigurator(proxyName, listenerName, Duration.ofSeconds(statusInterval)).configure(context).build(target).setInitialMode(Mode.PASSIVE).install();
@Override protected void performBoottime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { Map<String, Object> vaultOptions = new HashMap<String, Object>(); ModelNode vaultClassNode = CODE.resolveModelAttribute(context, model); String vaultClass = vaultClassNode.getType() == ModelType.UNDEFINED ? null : vaultClassNode.asString(); if (operation.hasDefined(Constants.VAULT_OPTIONS)) { for (Map.Entry<String,String> vaultOption : OPTIONS.unwrap(context,model).entrySet()) { vaultOptions.put(vaultOption.getKey(), vaultOption.getValue()); } } // add security vault service if (vaultClass != null || !vaultOptions.isEmpty()) { final SecurityVaultService vaultService = new SecurityVaultService(vaultClass, vaultOptions); context.getServiceTarget() .addService(SecurityVaultService.SERVICE_NAME, vaultService) .setInitialMode(ServiceController.Mode.ACTIVE).install(); } } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<T> injector = builder.provides(this.getServiceName()); Supplier<T> requirement = builder.requires(this.requirementName); Service service = new FunctionalService<>(injector, Function.identity(), requirement); return builder.setInstance(service).setInitialMode(this.initialMode); } }
protected void describeBean(final Module module, final ServiceTarget serviceTarget, DeploymentReflectionIndex deploymentIndex, BeanMetaDataConfig beanConfig) { final BeanState state = BeanState.NOT_INSTALLED; final ServiceName describedServiceName = BeanMetaDataConfig.toBeanName(beanConfig.getName(), state.next()); final DescribedPojoPhase describedService = new DescribedPojoPhase(deploymentIndex, beanConfig); final ServiceBuilder describedServiceBuilder = serviceTarget.addService(describedServiceName, describedService); describedService.registerAliases(describedServiceBuilder); final ConfigVisitor visitor = new DefaultConfigVisitor(describedServiceBuilder, state, module, deploymentIndex); beanConfig.visit(visitor); describedServiceBuilder.setInitialMode(beanConfig.getMode().getMode()); describedServiceBuilder.install(); } }
@Override public void installServices(OperationContext context, ModelNode model) throws OperationFailedException { PathAddress address = context.getCurrentAddress(); String name = context.getCurrentAddressValue(); String stack = STACK.resolveModelAttribute(context, model).asString(); ServiceTarget target = context.getServiceTarget(); new ChannelClusterServiceConfigurator(address).configure(context, model).build(target).install(); new ChannelServiceConfigurator(JCHANNEL, address).statisticsEnabled(STATISTICS_ENABLED.resolveModelAttribute(context, model).asBoolean()).configure(context, model).build(target).install(); new IdentityServiceConfigurator<>(JCHANNEL_FACTORY.getServiceName(address), JGroupsRequirement.CHANNEL_FACTORY.getServiceName(context, stack)).build(target).install(); new ForkChannelFactoryServiceConfigurator(FORK_CHANNEL_FACTORY, address.append(ForkResourceDefinition.pathElement(name))).configure(context, new ModelNode()).build(target).install(); new ModuleServiceConfigurator(JCHANNEL_MODULE.getServiceName(address), MODULE).configure(context, model).build(target).setInitialMode(ServiceController.Mode.PASSIVE).install(); new BinderServiceConfigurator(JGroupsBindingFactory.createChannelBinding(name), JGroupsRequirement.CHANNEL.getServiceName(context, name)).build(target).install(); new BinderServiceConfigurator(JGroupsBindingFactory.createChannelFactoryBinding(name), JGroupsRequirement.CHANNEL_FACTORY.getServiceName(context, name)).build(target).install(); // Install group services for channel ServiceNameRegistry<ClusteringRequirement> registry = new CapabilityServiceNameRegistry<>(CLUSTERING_CAPABILITIES, address); for (GroupServiceConfiguratorProvider provider : ServiceLoader.load(DistributedGroupServiceConfiguratorProvider.class, DistributedGroupServiceConfiguratorProvider.class.getClassLoader())) { for (CapabilityServiceConfigurator configurator : provider.getServiceConfigurators(registry, name)) { JGroupsLogger.ROOT_LOGGER.debugf("Installing %s for channel %s", configurator.getServiceName(), name); configurator.configure(context).build(target).install(); } } }
@Override protected void performBoottime(final OperationContext context, final ModelNode operation, final ModelNode model) throws OperationFailedException { final boolean enabled = JcaBeanValidationDefinition.BeanValidationParameters.BEAN_VALIDATION_ENABLED.getAttribute().resolveModelAttribute(context, model).asBoolean(); ServiceName serviceName = ConnectorServices.BEAN_VALIDATION_CONFIG_SERVICE; ServiceName jcaConfigServiceName = ConnectorServices.CONNECTOR_CONFIG_SERVICE; final ServiceTarget serviceTarget = context.getServiceTarget(); final BeanValidationService.BeanValidation config = new BeanValidationService.BeanValidation(enabled); final BeanValidationService service = new BeanValidationService(config); ServiceController<?> controller = serviceTarget.addService(serviceName, service).setInitialMode(ServiceController.Mode.ACTIVE) .addDependency(jcaConfigServiceName, JcaSubsystemConfiguration.class, service.getJcaConfigInjector() ) .install(); } }