@Override public void configureDependency(final ServiceBuilder<?> serviceBuilder, ComponentStartService service) throws DeploymentUnitProcessingException { serviceBuilder.requires(serviceName); } });
@Override public void configureDependency(final ServiceBuilder<?> serviceBuilder, ComponentStartService service) { for (ServiceName dependencyName : description.getDependencies()) { serviceBuilder.requires(dependencyName); } } });
@Override public <T> ServiceBuilder<T> register(ServiceBuilder<T> builder) { this.supplier = builder.requires(this.getServiceName()); return builder; } }
@Override public <T> ServiceBuilder<T> register(ServiceBuilder<T> builder) { builder.requires(this.getServiceName()); return builder; } }
void install() { assertState(); createDestroyServiceBuilder.install(); startStopServiceBuilder.install(); // Add service to register the mbean in the mbean server final ServiceBuilder<?> sb = target.addService(MBeanRegistrationService.SERVICE_NAME.append(mBeanName)); final Supplier<MBeanServer> mBeanServerSupplier = sb.requires(mbeanServerServiceName); final Supplier<Object> objectSupplier = sb.requires(startStopServiceName); sb.setInstance(new MBeanRegistrationService(mBeanName, setupActions, mBeanServerSupplier, objectSupplier)); sb.install(); installed = true; }
@Override public void configure(DeploymentPhaseContext context, ComponentDescription description, ComponentConfiguration componentConfiguration) throws DeploymentUnitProcessingException { if (this.hasRemoteView((EJBComponentDescription) description)) { // add a dependency on local transaction service componentConfiguration.getCreateDependencies().add((sb, cs) -> sb.requires(TxnServices.JBOSS_TXN_REMOTE_TRANSACTION_SERVICE)); } }
@Override public void addDependency(String bean, BeanState state, Injector injector) { if (state != BeanState.DESCRIBED) builder.requires(BeanMetaDataConfig.toBeanName(bean, BeanState.DESCRIBED)); builder.addDependency(BeanMetaDataConfig.toBeanName(bean, state), Object.class, injector); } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Supplier<Executor> executor = builder.requires(EXECUTOR_SERVICE_NAME); return new AsyncServiceBuilder<>(builder, executor, this.asyncStart, this.asyncStop); }
private static ServiceName addWeldInterceptorBindingService(final ServiceTarget target, final ComponentConfiguration configuration, final Class<?> componentClass, final String beanName, final ServiceName weldServiceName, final ServiceName weldStartService, final String beanDeploymentArchiveId, final ComponentInterceptorSupport componentInterceptorSupport) { ServiceName bindingServiceName = configuration.getComponentDescription().getServiceName().append(WeldInterceptorBindingsService.SERVICE_NAME); final ServiceBuilder<?> sb = target.addService(bindingServiceName); final Consumer<InterceptorBindings> interceptorBindingsConsumer = sb.provides(bindingServiceName); final Supplier<WeldBootstrapService> weldContainerSupplier = sb.requires(weldServiceName); sb.requires(weldStartService); sb.setInstance(new WeldInterceptorBindingsService(interceptorBindingsConsumer, weldContainerSupplier, beanDeploymentArchiveId, beanName, componentClass, componentInterceptorSupport)); sb.install(); return bindingServiceName; }
/** * {@inheritDoc} */ public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) { if(serviceName != null) { serviceBuilder.requires(serviceName); } final RemoteViewManagedReferenceFactory factory = new RemoteViewManagedReferenceFactory(appName, moduleName, distinctName, beanName, viewClass, stateful, viewClassLoader, appclient); injector.inject(factory); }
public static void install(final DeploymentUnit deploymentUnit, final ServiceTarget serviceTarget) { final ServiceName sn = serviceName(deploymentUnit); final ServiceBuilder<?> sb = serviceTarget.addService(sn); final Consumer<EEClassIntrospector> eeClassIntrospectorConsumer = sb.provides(sn); final Supplier<BeanManager> beanManagerSupplier = sb.requires(BeanManagerService.serviceName(deploymentUnit)); sb.requires(Utils.getRootDeploymentUnit(deploymentUnit).getServiceName().append(WeldStartService.SERVICE_NAME)); sb.setInstance(new WeldClassIntrospector(eeClassIntrospectorConsumer, beanManagerSupplier)); sb.install(); }
void addAttribute(final String attributeMBeanName, final Method setter, final DelegatingSupplier propertySupplier) { assertState(); final ServiceName injectedMBeanCreateDestroyServiceName = ServiceNameFactory.newCreateDestroy(attributeMBeanName); final Supplier<Object> injectedMBeanSupplier = createDestroyServiceBuilder.requires(injectedMBeanCreateDestroyServiceName); propertySupplier.setObjectSupplier(injectedMBeanSupplier); createDestroyService.inject(setter, propertySupplier); final ServiceName injectedMBeanStartStopServiceName = ServiceNameFactory.newStartStop(attributeMBeanName); startStopServiceBuilder.requires(injectedMBeanStartStopServiceName); }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<Module> module = builder.provides(this.getServiceName()); this.loader = builder.requires(Services.JBOSS_SERVICE_MODULE_LOADER); Service service = new FunctionalService<>(module, Function.identity(), this); return builder.setInstance(service); }
@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); } }
@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 <T> ServiceBuilder<T> build(ServiceTarget target, ServiceName name, Service<T> service) { ServiceBuilder<T> builder = this.policy.createSingletonServiceBuilder(name, service).build(target).setInitialMode(ServiceController.Mode.ACTIVE); if (this.support.hasCapability(EJB_REMOTE_CAPABILITY)) { builder.requires(this.support.getCapabilityServiceName(EJB_REMOTE_CAPABILITY)); } return builder; } }
private static void addClusteringServices(final OperationContext context, final boolean appclient) { ServiceTarget target = context.getServiceTarget(); if (appclient) { return; } if (context.hasOptionalCapability(SingletonDefaultRequirement.POLICY.getName(), CLUSTERED_SINGLETON_CAPABILITY.getName(), null)) { ServiceBuilder<?> builder = target.addService(SingletonBarrierService.SERVICE_NAME); Supplier<SingletonPolicy> policy = builder.requires(context.getCapabilityServiceName(SingletonDefaultRequirement.POLICY.getName(), SingletonDefaultRequirement.POLICY.getType())); builder.setInstance(new SingletonBarrierService(policy)).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); } } }
@Override public ServiceBuilder<?> build(ServiceTarget target) { ServiceBuilder<?> builder = target.addService(this.getServiceName()); Consumer<ChannelFactory> factory = new CompositeDependency(this.transport, this.relay, this.socketBindingManager).register(builder).provides(this.getServiceName()); this.environment = builder.requires(ServerEnvironmentService.SERVICE_NAME); for (Dependency dependency : this.protocols) { dependency.register(builder); } Service service = Service.newInstance(factory, new JChannelFactory(this)); return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND); }
private void addCommonHostListenerDeps(OperationContext context, ServiceBuilder<WebServerService> builder, final PathElement listenerPath) { ModelNode listeners = Resource.Tools.readModel(context.readResource(PathAddress.pathAddress(listenerPath)), 1); if (listeners.isDefined()) { for (Property p : listeners.asPropertyList()) { for (Property listener : p.getValue().asPropertyList()) { builder.requires(ListenerResourceDefinition.LISTENER_CAPABILITY.getCapabilityServiceName(listener.getName())); } } } } }