Refine search
public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { resolve(); if (error != null) { throw new DeploymentUnitProcessingException(error); } if (remoteFactory != null) { //because we are using the ejb: lookup namespace we do not need a dependency injector.inject(remoteFactory); } else if (!appclient) { //we do not add a dependency if this is the appclient //as local injections are simply ignored serviceBuilder.addDependency(resolvedViewName, ComponentView.class, new ViewManagedReferenceFactory.Injector(injector)); } }
@Override public void uninject() { targetInjector.uninject(); } @Override
if (ssl.hasDefined(KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE_NAME)) { trustManagerService.getCredentialSourceSupplierInjector() .inject(CredentialReference.getCredentialSourceSupplier(context, KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE, ssl, serviceBuilder)); if (ssl.hasDefined(KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE_NAME)) { trustManagerService.getCredentialSourceSupplierInjector() .inject(CredentialReference.getCredentialSourceSupplier(context, KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE, ssl, serviceBuilder)); serviceBuilder.addDependency(context.getCapabilityServiceName(PATH_MANAGER_CAPABILITY, PathManager.class), PathManager.class, trustManagerService.getPathManagerInjector()); serviceBuilder.requires(pathName(relativeTo)); serviceBuilder.setInitialMode(ON_DEMAND).install();
private void addUsersService(OperationContext context, ModelNode users, String realmName, ServiceTarget serviceTarget, ServiceBuilder<?> realmBuilder, Injector<CallbackHandlerService> injector) throws OperationFailedException { ServiceName usersServiceName = UserDomainCallbackHandler.ServiceUtil.createServiceName(realmName); UserDomainCallbackHandler usersCallbackHandler = new UserDomainCallbackHandler(realmName, unmaskUsersPasswords(context, users)); ServiceBuilder<CallbackHandlerService> serviceBuilder = serviceTarget.addService(usersServiceName, usersCallbackHandler) .setInitialMode(ServiceController.Mode.ON_DEMAND); usersCallbackHandler.getCredentialSourceSupplierInjector().inject(unmaskUsersCredentials(context, serviceBuilder, users.clone())); serviceBuilder.install(); CallbackHandlerService.ServiceUtil.addDependency(realmBuilder, injector, usersServiceName); }
public static ServiceController<ManagedReferenceFactory> createJndiBindings(ServiceTarget target, ServiceName serviceName, String binderServiceName, ManagedReferenceFactory managedReferenceFactory) { BinderService binderService = new BinderService(binderServiceName); ServiceBuilder<ManagedReferenceFactory> serviceBuilder = target .addService(serviceName, binderService) .addDependency(ContextNames.GLOBAL_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()); binderService.getManagedObjectInjector().inject(managedReferenceFactory); return serviceBuilder.install(); }
@Override public void start(final StartContext context) throws StartException { JAXRConfiguration config = injectedConfig.getValue(); if (config.getConnectionFactoryBinding() != null) { try { String jndiName = config.getConnectionFactoryBinding(); ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName); BinderService binderService = new BinderService(bindInfo.getBindName()); ConnectionFactory jaxrFactory = loadConnectionFactoryImplementation(config); //set jaxr properties from the config if there are any setJAXRFactoryProperies(jaxrFactory, config.getProperties()); ImmediateValue<ConnectionFactory> value = new ImmediateValue<ConnectionFactory>(jaxrFactory); binderService.getManagedObjectInjector().inject(new ValueManagedReferenceFactory(value)); binderService.getNamingStoreInjector().inject((ServiceBasedNamingStore) injectedJavaContext.getValue()); ServiceBuilder<?> builder = context.getChildTarget().addService(bindInfo.getBinderServiceName(), binderService); JAXR_LOGGER.bindingJAXRConnectionFactory(config.getConnectionFactoryBinding()); builder.install(); } catch (Exception ex) { JAXR_LOGGER.bindingJAXRConnectionFactoryFailed(); } } }
/** * {@inheritDoc} */ public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) { injector.inject(managedReferenceFactory); }
/** * {@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); }
private <D extends Destination> void inject(ServiceBuilder<?> serviceBuilder, Injector<ManagedReferenceFactory> injector, Service<D> destinationService) { final ContextListAndJndiViewManagedReferenceFactory referenceFactoryService = new MessagingJMSDestinationManagedReferenceFactory(destinationService); injector.inject(referenceFactoryService); serviceBuilder.addListener(new LifecycleListener() { public void handleEvent(final ServiceController<?> controller, final LifecycleEvent event) { switch (event) { case UP: { ROOT_LOGGER.boundJndiName(jndiName); break; } case DOWN: { ROOT_LOGGER.unboundJndiName(jndiName); break; } case REMOVED: { ROOT_LOGGER.debugf("Removed messaging object [%s]", jndiName); break; } } } }); }
public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { serviceBuilder.addDependencies(puServiceName); injector.inject(injectable); }
if (ssl.hasDefined(KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE_NAME)) { trustManagerService.getCredentialSourceSupplierInjector() .inject(CredentialReference.getCredentialSourceSupplier(context, KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE, ssl, serviceBuilder)); if (ssl.hasDefined(KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE_NAME)) { trustManagerService.getCredentialSourceSupplierInjector() .inject(CredentialReference.getCredentialSourceSupplier(context, KeystoreAttributes.KEYSTORE_PASSWORD_CREDENTIAL_REFERENCE, ssl, serviceBuilder)); serviceBuilder.addDependency(context.getCapabilityServiceName(PATH_MANAGER_CAPABILITY, PathManager.class), PathManager.class, trustManagerService.getPathManagerInjector()); serviceBuilder.requires(pathName(relativeTo)); serviceBuilder.setInitialMode(ON_DEMAND).install();
private void addUsersService(OperationContext context, ModelNode users, String realmName, ServiceTarget serviceTarget, ServiceBuilder<?> realmBuilder, Injector<CallbackHandlerService> injector) throws OperationFailedException { ServiceName usersServiceName = UserDomainCallbackHandler.ServiceUtil.createServiceName(realmName); UserDomainCallbackHandler usersCallbackHandler = new UserDomainCallbackHandler(realmName, unmaskUsersPasswords(context, users)); ServiceBuilder<CallbackHandlerService> serviceBuilder = serviceTarget.addService(usersServiceName, usersCallbackHandler) .setInitialMode(ServiceController.Mode.ON_DEMAND); usersCallbackHandler.getCredentialSourceSupplierInjector().inject(unmaskUsersCredentials(context, serviceBuilder, users.clone())); serviceBuilder.install(); CallbackHandlerService.ServiceUtil.addDependency(realmBuilder, injector, usersServiceName); }
/** * * @param factory The ValidatorFactory to bind * @param serviceTarget The service target * @param contextServiceName The service name of the context to bind to */ private void bindServices(LazyValidatorFactory factory, ServiceTarget serviceTarget, EEModuleDescription description, String componentName, ServiceName contextServiceName) { BinderService validatorFactoryBindingService = new BinderService("ValidatorFactory"); validatorFactoryBindingService.getManagedObjectInjector().inject(new ValueManagedReferenceFactory(new ImmediateValue<Object>(factory))); serviceTarget.addService(contextServiceName.append("ValidatorFactory"), validatorFactoryBindingService) .addDependency(contextServiceName, ServiceBasedNamingStore.class, validatorFactoryBindingService.getNamingStoreInjector()) .install(); BinderService validatorBindingService = new BinderService("Validator"); validatorBindingService.getManagedObjectInjector().inject(new ValidatorJndiInjectable(factory)); serviceTarget.addService(contextServiceName.append("Validator"), validatorBindingService) .addDependency(contextServiceName, ServiceBasedNamingStore.class, validatorBindingService.getNamingStoreInjector()) .install(); } @Override
@Override public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { injector.inject(ejbContextManagedReferenceFactory); }
public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { serviceBuilder.requires(puServiceName); injector.inject(injectable); }
public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { serviceBuilder.addDependencies(puServiceName); injector.inject(injectable); }
binderService.getManagedObjectInjector().inject(new ContextListAndJndiViewManagedReferenceFactory() { @Override public ManagedReference getReference() { .addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector()); builder.addListener(verificationHandler); builder.install()); } else { builder.install();
private void addSecretService(OperationContext context, ModelNode secret, String realmName, ServiceTarget serviceTarget, ServiceBuilder<?> realmBuilder, Injector<CallbackHandlerFactory> injector) throws OperationFailedException { ServiceName secretServiceName = SecretIdentityService.ServiceUtil.createServiceName(realmName); ModelNode resolvedValueNode = SecretServerIdentityResourceDefinition.VALUE.resolveModelAttribute(context, secret); boolean base64 = secret.get(SecretServerIdentityResourceDefinition.VALUE.getName()).getType() != ModelType.EXPRESSION; SecretIdentityService sis; if (secret.hasDefined(CredentialReference.CREDENTIAL_REFERENCE)) { sis = new SecretIdentityService(resolvedValueNode.asString(), false); } else { sis = new SecretIdentityService(resolvedValueNode.asString(), base64); } final ServiceBuilder<CallbackHandlerFactory> serviceBuilder = serviceTarget.addService(secretServiceName, sis) .setInitialMode(ON_DEMAND); if (secret.hasDefined(CredentialReference.CREDENTIAL_REFERENCE)) { sis.getCredentialSourceSupplierInjector() .inject(CredentialReference.getCredentialSourceSupplier(context, SecretServerIdentityResourceDefinition.CREDENTIAL_REFERENCE, secret, serviceBuilder)); } serviceBuilder.install(); CallbackHandlerFactory.ServiceUtil.addDependency(realmBuilder, injector, secretServiceName); }
ServiceBuilder<ManagedReferenceFactory> processEngineServiceBuilder = serviceContainer .addService(processEngineServiceBindingServiceName, processEngineServiceBinder); processEngineServiceBuilder.addDependency(ContextNames.GLOBAL_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, processEngineServiceBinder.getNamingStoreInjector()); processEngineServiceBinder.getManagedObjectInjector().inject(new PlatformServiceReferenceFactory(this)); processArchiveServiceBuilder.addDependency(ContextNames.GLOBAL_CONTEXT_SERVICE_NAME, ServiceBasedNamingStore.class, processArchiveServiceBinder.getNamingStoreInjector()); processArchiveServiceBinder.getManagedObjectInjector().inject(new PlatformServiceReferenceFactory(this)); processEngineServiceBinding = processEngineServiceBuilder.install(); processArchiveServiceBinding = processArchiveServiceBuilder.install();
@Override public void getResourceValue(final ResolutionContext resolutionContext, final ServiceBuilder<?> serviceBuilder, final DeploymentPhaseContext phaseContext, final Injector<ManagedReferenceFactory> injector) throws DeploymentUnitProcessingException { final ContextManagedReferenceFactory managedReferenceFactory = new ContextManagedReferenceFactory(name); final ServiceName contextServiceName; if(fullName.startsWith("java:app")) { contextServiceName = ContextNames.contextServiceNameOfApplication(resolutionContext.getApplicationName()); } else if (fullName.startsWith("java:module") || (fullName.startsWith("java:comp") && resolutionContext.isCompUsesModule())) { contextServiceName = ContextNames.contextServiceNameOfModule(resolutionContext.getApplicationName(), resolutionContext.getModuleName()); } else if(fullName.startsWith("java:comp")) { contextServiceName = ContextNames.contextServiceNameOfComponent(resolutionContext.getApplicationName(), resolutionContext.getModuleName(), resolutionContext.getComponentName()); } else { throw NamingLogger.ROOT_LOGGER.invalidNameForContextBinding(fullName); } serviceBuilder.addDependency(contextServiceName, NamingStore.class, managedReferenceFactory.getNamingStoreInjectedValue()); injector.inject(managedReferenceFactory); } }