org.jboss.msc.inject.Injector Java Examples

private static void injectRoleMapper(String roleMapper, OperationContext context, ServiceBuilder<SecurityDomain> domainBuilder, Injector<RoleMapper> injector) {
    if (roleMapper == null) {
        return;
    }

    if (injector == null) {
        // Service did not supply one as one is already present for this name.
        return;
    }

    String runtimeCapability = RuntimeCapability.buildDynamicCapabilityName(ROLE_MAPPER_CAPABILITY, roleMapper);
    ServiceName roleMapperServiceName = context.getCapabilityServiceName(runtimeCapability, RoleMapper.class);

    domainBuilder.addDependency(roleMapperServiceName, RoleMapper.class, injector);
}
 

private Injector<RoleMapper> createRoleMapperInjector(final String roleMapperName) {
    if (roleMappers.containsKey(roleMapperName)) {
        return null; // i.e. should already be injected for this name.
    }

    InjectedValue<RoleMapper> roleMapperInjector = new InjectedValue<>();
    roleMappers.put(roleMapperName, roleMapperInjector);
    return roleMapperInjector;
}
 

private Injector<RoleDecoder> createRoleDecoderInjector(final String roleDecoderName) {
    if (roleDecoders.containsKey(roleDecoderName)) {
        return null; // i.e. should already be injected for this name.
    }

    InjectedValue<RoleDecoder> roleDecoderInjector = new InjectedValue<>();
    roleDecoders.put(roleDecoderName, roleDecoderInjector);
    return roleDecoderInjector;
}
 

private static void injectRoleDecoder(String roleDecoder, OperationContext context, ServiceBuilder<SecurityDomain> domainBuilder, Injector<RoleDecoder> injector) {
    if (roleDecoder == null) {
        return;
    }
    if (injector == null) {
        return;
    }
    String runtimeCapability = RuntimeCapability.buildDynamicCapabilityName(ROLE_DECODER_CAPABILITY, roleDecoder);
    ServiceName roleDecoderServiceName = context.getCapabilityServiceName(runtimeCapability, RoleDecoder.class);
    domainBuilder.addDependency(roleDecoderServiceName, RoleDecoder.class, injector);
}
 

private Injector<PrincipalTransformer> createPrincipalTransformerInjector(final String principalTransformerName) {
    if (principalTransformers.containsKey(principalTransformerName)) {
        return null; // i.e. should already be injected for this name.
    }

    InjectedValue<PrincipalTransformer> principalTransformerInjector = new InjectedValue<>();
    principalTransformers.put(principalTransformerName, principalTransformerInjector);
    return principalTransformerInjector;
}
 

private static void injectRealmMapper(SimpleAttributeDefinition realmMapperAttribute, ServiceBuilder<?> serviceBuilder, OperationContext context, ModelNode model, Injector<RealmMapper> realmMapperInjector) throws OperationFailedException {
    String realmMapper = realmMapperAttribute.resolveModelAttribute(context, model).asStringOrNull();
    if (realmMapper != null) {
        serviceBuilder.addDependency(context.getCapabilityServiceName(
                buildDynamicCapabilityName(REALM_MAPPER_CAPABILITY, realmMapper), RealmMapper.class),
                RealmMapper.class, realmMapperInjector);
    }
}
 

private static void injectSecurityFactory(SimpleAttributeDefinition securityFactoryAttribute, ServiceBuilder<?> serviceBuilder, OperationContext context, ModelNode model, Injector<SecurityFactory> securityFactoryInjector) throws OperationFailedException {
    String securityFactory = securityFactoryAttribute.resolveModelAttribute(context, model).asStringOrNull();
    if (securityFactory != null) {
        serviceBuilder.addDependency(context.getCapabilityServiceName(
                buildDynamicCapabilityName(SECURITY_FACTORY_CREDENTIAL_CAPABILITY, securityFactory), SecurityFactory.class),
                SecurityFactory.class, securityFactoryInjector);
    }
}
 

static <T> void installThreadPoolService(final Service<T> threadPoolService,
                                         final String threadPoolName,
                                         final ServiceName serviceNameBase,
                                         final String threadFactoryName,
                                         final ThreadFactoryResolver threadFactoryResolver,
                                         final Injector<ThreadFactory> threadFactoryInjector,
                                         final ServiceTarget target) {
    installThreadPoolService(threadPoolService, threadPoolName, serviceNameBase,
            threadFactoryName, threadFactoryResolver, threadFactoryInjector,
            null, null, null,
            target);
}
 

private static void injectPrincipalTransformer(String principalTransformer, OperationContext context, ServiceBuilder<SecurityDomain> domainBuilder, Injector<PrincipalTransformer> injector) {
    if (principalTransformer == null) {
        return;
    }

    if (injector == null) {
        // Service did not supply one as one is already present for this name.
        return;
    }

    String runtimeCapability = RuntimeCapability.buildDynamicCapabilityName(PRINCIPAL_TRANSFORMER_CAPABILITY, principalTransformer);
    ServiceName principalTransformerServiceName = context.getCapabilityServiceName(runtimeCapability, PrincipalTransformer.class);

    domainBuilder.addDependency(principalTransformerServiceName, PrincipalTransformer.class, injector);
}
 

@Override
protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
        throws OperationFailedException {
    ServiceTarget serviceTarget = context.getServiceTarget();
    RuntimeCapability<Void> runtimeCapability = SECURITY_REALM_RUNTIME_CAPABILITY.fromBaseCapability(context.getCurrentAddressValue());
    ServiceName realmName = runtimeCapability.getCapabilityServiceName(SecurityRealm.class);
    ModelNode principalQueries = PrincipalQueryAttributes.PRINCIPAL_QUERIES_7_0.resolveModelAttribute(context, operation);
    final JdbcSecurityRealmBuilder builder = JdbcSecurityRealm.builder();

    TrivialService<SecurityRealm> service = new TrivialService<SecurityRealm>(builder::build);
    ServiceBuilder<SecurityRealm> serviceBuilder = serviceTarget.addService(realmName, service);

    for (ModelNode query : principalQueries.asList()) {
        String authenticationQuerySql = PrincipalQueryAttributes.SQL.resolveModelAttribute(context, query).asString();
        QueryBuilder queryBuilder = builder.principalQuery(authenticationQuerySql)
                .withMapper(resolveAttributeMappers(context, query))
                .withMapper(resolveKeyMappers(context, query));

        String dataSourceName = PrincipalQueryAttributes.DATA_SOURCE.resolveModelAttribute(context, query).asString();
        String capabilityName = Capabilities.DATA_SOURCE_CAPABILITY_NAME + "." + dataSourceName;
        ServiceName dataSourceServiceName = context.getCapabilityServiceName(capabilityName, DataSource.class);

        serviceBuilder.addDependency(dataSourceServiceName, DataSource.class, new Injector<DataSource>() {

            @Override
            public void inject(DataSource value) throws InjectionException {
                queryBuilder.from(value);
            }

            @Override
            public void uninject() {
                // no-op
            }
        });
    }

    commonDependencies(serviceBuilder)
            .setInitialMode(context.getRunningMode() == RunningMode.ADMIN_ONLY ? ServiceController.Mode.LAZY : ServiceController.Mode.ACTIVE)
            .install();
}
 

private void addRealmDependency(OperationContext context, ServiceBuilder<SecurityRealm> serviceBuilder, String realmName, Injector<SecurityRealm> securityRealmInjector) {
    String runtimeCapability = RuntimeCapability.buildDynamicCapabilityName(SECURITY_REALM_CAPABILITY, realmName);
    ServiceName realmServiceName = context.getCapabilityServiceName(runtimeCapability, SecurityRealm.class);
    REALM_SERVICE_UTIL.addInjection(serviceBuilder, securityRealmInjector, realmServiceName);
}
 

ServiceBuilder<?> addInjection(ServiceBuilder<?> sb, Injector<T> injector, ServiceName serviceName) {
    sb.addDependency(serviceName, clazz, injector);
    return sb;
}
 

static <T> void installThreadPoolService(final Service<T> threadPoolService,
                                         final String threadPoolName,
                                         final RuntimeCapability<Void> cap,
                                         final PathAddress address,
                                         final ServiceName serviceNameBase,
                                         final String threadFactoryName,
                                         final ThreadFactoryResolver threadFactoryResolver,
                                         final Injector<ThreadFactory> threadFactoryInjector,
                                         final String handoffExecutorName,
                                         final HandoffExecutorResolver handoffExecutorResolver,
                                         final Injector<Executor> handoffExecutorInjector,
                                         final ServiceTarget target) {
    final ServiceName threadPoolServiceName;
    final ServiceName aliasServiceName;
    if(cap != null) {
        threadPoolServiceName = cap.getCapabilityServiceName(address);
        if(serviceNameBase != null) {
            aliasServiceName = serviceNameBase.append(threadPoolName);
        } else {
            aliasServiceName = null;
        }
    } else {
        threadPoolServiceName = serviceNameBase.append(threadPoolName);
        aliasServiceName = null;
    }
    final ServiceBuilder<?> serviceBuilder = target.addService(threadPoolServiceName, threadPoolService);
    if(aliasServiceName != null) {
        serviceBuilder.addAliases(aliasServiceName);
    }
    final ServiceName threadFactoryServiceName = threadFactoryResolver.resolveThreadFactory(threadFactoryName,
            threadPoolName, threadPoolServiceName, target);
    serviceBuilder.addDependency(threadFactoryServiceName, ThreadFactory.class, threadFactoryInjector);

    if (handoffExecutorInjector != null) {
        ServiceName handoffServiceName = handoffExecutorResolver.resolveHandoffExecutor(handoffExecutorName,
                threadPoolName, threadPoolServiceName, target);
        if (handoffServiceName != null) {
            serviceBuilder.addDependency(handoffServiceName, Executor.class, handoffExecutorInjector);
        }
    }

    serviceBuilder.install();

}
 

Injector<RoleMapper> getRoleMapperInjector(final String name) {
    this.roleMapper = name;
    return createRoleMapperInjector(name);
}
 

Injector<RoleDecoder> getRoleDecoderInjector(final String name) {
    this.roleDecoder = name;
    return createRoleDecoderInjector(name);
}
 

Injector<PrincipalTransformer> getPrincipalTransformerInjector(final String name) {
    this.principalTransformer = name;
    return createPrincipalTransformerInjector(name);
}
 

Injector<KeyStore> getKeyStoreInjector() {
    return keyStoreInjector;
}
 

public Injector<CommandDispatcherFactory> getCommandDispatcherFactoryInjector() {
    return this.commandDispatcherFactoryInjector;
}
 

Injector<Provider[]> getProvidersInjector() {
    return providers;
}
 

Injector<Provider[]> getOtherProvidersInjector() {
    return otherProviders;
}
 

Injector<ExceptionSupplier<CredentialSource, Exception>> getCredentialSourceSupplierInjector() {
    return credentialSourceSupplier;
}
 

Injector<PathManager> getPathManagerInjector() {
    return pathManager;
}
 

Injector<PathManager> getPathManagerInjector() {
    return pathManager;
}
 

public Injector<ThreadFactory> getThreadFactoryInjector() {
    return threadFactoryValue;
}
 

@Deprecated // TODO: eliminate this method when WildFly codebase is migrated to new constructor
public Injector<String> getTmpDirPathInjector() {
    return tmpDirPath;
}
 

private void addRealmDependency(OperationContext context, ServiceBuilder<SecurityRealm> serviceBuilder, String realmName, Injector<SecurityRealm> securityRealmInjector) {
    String runtimeCapability = RuntimeCapability.buildDynamicCapabilityName(SECURITY_REALM_CAPABILITY, realmName);
    ServiceName realmServiceName = context.getCapabilityServiceName(runtimeCapability, SecurityRealm.class);

    REALM_SERVICE_UTIL.addInjection(serviceBuilder, securityRealmInjector, realmServiceName);
}
 

public Injector<ThreadFactory> getThreadFactoryInjector() {
    return threadFactoryValue;
}
 

Injector<Provider[]> getInitialProivders() {
    return initialProviders;
}
 

Injector<DirContextSupplier> getDirContextSupplierInjector() {
    return dirContextSupplierInjector;
}
 

Injector<ExceptionSupplier<CredentialSource, Exception>> getCredentialSourceSupplierInjector() {
    return credentialSourceSupplier;
}