/** * <p>Creates a new configuration.</p> <p>If a configuration with the given <code>configurationName</code> already * exists, this method will return the same instance instead of creating a new one.</p> * * @param configurationName * @return */ public NamedIdentityConfigurationBuilder named(String configurationName) { // Check if config with this name is already here if (this.namedIdentityConfigurationBuilders.containsKey(configurationName)) { return this.namedIdentityConfigurationBuilders.get(configurationName); } NamedIdentityConfigurationBuilder namedIdentityConfiguration = new NamedIdentityConfigurationBuilder(configurationName, this); this.namedIdentityConfigurationBuilders.put(configurationName, namedIdentityConfiguration); return namedIdentityConfiguration; }
@Override protected void validate() throws SecurityConfigurationException { if (this.namedIdentityConfigurationBuilders.isEmpty()) { throw MESSAGES.configNoConfigurationProvided(); } for (NamedIdentityConfigurationBuilder identityConfigBuilder : this.namedIdentityConfigurationBuilders.values()) { try { identityConfigBuilder.validate(); } catch (Exception e) { throw MESSAGES.configInvalidConfiguration(identityConfigBuilder.getName(), e); } } }
@Override protected Builder<List<IdentityConfiguration>> readFrom(List<IdentityConfiguration> fromConfiguration) throws SecurityConfigurationException { if (fromConfiguration == null || fromConfiguration.isEmpty()) { throw MESSAGES.nullArgument("Configuration to read from."); } for (IdentityConfiguration identityConfiguration : fromConfiguration) { named(identityConfiguration.getName()).readFrom(identityConfiguration); } return this; }
private void configureIdentityStores(IdentityConfigurationBuilder builder) { for (NamedIdentityConfigurationBuilder identityConfigurationBuilder : builder.getNamedIdentityConfigurationBuilders()) { IdentityStoresConfigurationBuilder stores = identityConfigurationBuilder.stores(); for (IdentityStoreConfigurationBuilder storeBuilder : stores.getIdentityStoresConfigurationBuilder()) { storeBuilder.addContextInitializer(this.authenticatedAccountContextInitializer); if (JPAStoreConfigurationBuilder.class.isInstance(storeBuilder)) { JPAStoreConfigurationBuilder jpaBuilder = (JPAStoreConfigurationBuilder) storeBuilder; if (jpaBuilder.getMappedEntities().isEmpty()) { Class<?>[] mappedEntities = this.entityManagerProvider.getMappedEntities(); if (mappedEntities.length == 0) { throw new SecurityConfigurationException("You provided a configuration for the JPA Identity Store, but no mapped entities were found."); } jpaBuilder.mappedEntity(mappedEntities); } jpaBuilder.addContextInitializer(this.entityManagerContextInitializer); } if (TokenStoreConfigurationBuilder.class.isInstance(storeBuilder)) { TokenStoreConfigurationBuilder tokenBuilder = (TokenStoreConfigurationBuilder) storeBuilder; if (!this.tokenConsumerInstance.isUnsatisfied()) { tokenBuilder.tokenConsumer(this.tokenConsumerInstance.get()); } } } } }
@Override protected List<IdentityConfiguration> create() throws SecurityConfigurationException { List<IdentityConfiguration> configurations = new ArrayList<IdentityConfiguration>(); try { validate(); for (NamedIdentityConfigurationBuilder identityConfigBuilder : this.namedIdentityConfigurationBuilders.values()) { IdentityConfiguration configuration = identityConfigBuilder.create(); if (configurations.contains(configuration)) { throw MESSAGES.configMultipleConfigurationsFoundWithSameName(configuration.getName()); } boolean supportCredentials = false; for (IdentityStoreConfiguration storeConfiguration : configuration.getStoreConfiguration()) { if (storeConfiguration.supportsCredential()) { if (supportCredentials) { throw MESSAGES.configMultipleConfigurationsFoundWithCredentialSupport(); } supportCredentials = true; } } configurations.add(configuration); } } catch (Exception sce) { throw MESSAGES.configCouldNotCreateConfiguration(sce); } return configurations; }
private void configureIdentityStores(IdentityConfigurationBuilder builder) { for (NamedIdentityConfigurationBuilder identityConfigurationBuilder : builder.getNamedIdentityConfigurationBuilders()) { IdentityStoresConfigurationBuilder stores = identityConfigurationBuilder.stores(); for (IdentityStoreConfigurationBuilder storeBuilder : stores.getIdentityStoresConfigurationBuilder()) { storeBuilder.addContextInitializer(this.authenticatedAccountContextInitializer); if (JPAStoreConfigurationBuilder.class.isInstance(storeBuilder)) { JPAStoreConfigurationBuilder jpaBuilder = (JPAStoreConfigurationBuilder) storeBuilder; if (jpaBuilder.getMappedEntities().isEmpty()) { Class<?>[] mappedEntities = this.entityManagerProvider.getMappedEntities(); if (mappedEntities.length == 0) { throw new SecurityConfigurationException("You provided a configuration for the JPA Identity Store, but no mapped entities were found."); } jpaBuilder.mappedEntity(mappedEntities); } jpaBuilder.addContextInitializer(this.entityManagerContextInitializer); } if (TokenStoreConfigurationBuilder.class.isInstance(storeBuilder)) { TokenStoreConfigurationBuilder tokenBuilder = (TokenStoreConfigurationBuilder) storeBuilder; if (!this.tokenConsumerInstance.isUnsatisfied()) { tokenBuilder.tokenConsumer(this.tokenConsumerInstance.get()); } } } } }
@Override protected List<IdentityConfiguration> create() throws SecurityConfigurationException { List<IdentityConfiguration> configurations = new ArrayList<IdentityConfiguration>(); try { validate(); for (NamedIdentityConfigurationBuilder identityConfigBuilder : this.namedIdentityConfigurationBuilders.values()) { IdentityConfiguration configuration = identityConfigBuilder.create(); if (configurations.contains(configuration)) { throw MESSAGES.configMultipleConfigurationsFoundWithSameName(configuration.getName()); } boolean supportCredentials = false; for (IdentityStoreConfiguration storeConfiguration : configuration.getStoreConfiguration()) { if (storeConfiguration.supportsCredential()) { if (supportCredentials) { throw MESSAGES.configMultipleConfigurationsFoundWithCredentialSupport(); } supportCredentials = true; } } configurations.add(configuration); } } catch (Exception sce) { throw MESSAGES.configCouldNotCreateConfiguration(sce); } return configurations; }
private void configureIdentityStores(IdentityConfigurationBuilder builder) { for (NamedIdentityConfigurationBuilder identityConfigurationBuilder : builder.getNamedIdentityConfigurationBuilders()) { IdentityStoresConfigurationBuilder stores = identityConfigurationBuilder.stores(); for (IdentityStoreConfigurationBuilder storeBuilder : stores.getIdentityStoresConfigurationBuilder()) { storeBuilder.addContextInitializer(this.authenticatedAccountContextInitializer); if (JPAStoreConfigurationBuilder.class.isInstance(storeBuilder)) { JPAStoreConfigurationBuilder jpaBuilder = (JPAStoreConfigurationBuilder) storeBuilder; if (jpaBuilder.getMappedEntities().isEmpty()) { Class<?>[] mappedEntities = this.entityManagerProvider.getMappedEntities(); if (mappedEntities.length == 0) { throw new SecurityConfigurationException("You provided a configuration for the JPA Identity Store, but no mapped entities were found."); } jpaBuilder.mappedEntity(mappedEntities); } jpaBuilder.addContextInitializer(this.entityManagerContextInitializer); } if (TokenStoreConfigurationBuilder.class.isInstance(storeBuilder)) { TokenStoreConfigurationBuilder tokenBuilder = (TokenStoreConfigurationBuilder) storeBuilder; if (!this.tokenConsumerInstance.isUnsatisfied()) { tokenBuilder.tokenConsumer(this.tokenConsumerInstance.get()); } } } } }
@Override protected void validate() throws SecurityConfigurationException { if (this.namedIdentityConfigurationBuilders.isEmpty()) { throw MESSAGES.configNoConfigurationProvided(); } for (NamedIdentityConfigurationBuilder identityConfigBuilder : this.namedIdentityConfigurationBuilders.values()) { try { identityConfigBuilder.validate(); } catch (Exception e) { throw MESSAGES.configInvalidConfiguration(identityConfigBuilder.getName(), e); } } }
@Override protected Builder<List<IdentityConfiguration>> readFrom(List<IdentityConfiguration> fromConfiguration) throws SecurityConfigurationException { if (fromConfiguration == null || fromConfiguration.isEmpty()) { throw MESSAGES.nullArgument("Configuration to read from."); } for (IdentityConfiguration identityConfiguration : fromConfiguration) { named(identityConfiguration.getName()).readFrom(identityConfiguration); } return this; }
/** * <p>Creates a new configuration.</p> <p>If a configuration with the given <code>configurationName</code> already * exists, this method will return the same instance instead of creating a new one.</p> * * @param configurationName * @return */ public NamedIdentityConfigurationBuilder named(String configurationName) { // Check if config with this name is already here if (this.namedIdentityConfigurationBuilders.containsKey(configurationName)) { return this.namedIdentityConfigurationBuilders.get(configurationName); } NamedIdentityConfigurationBuilder namedIdentityConfiguration = new NamedIdentityConfigurationBuilder(configurationName, this); this.namedIdentityConfigurationBuilders.put(configurationName, namedIdentityConfiguration); return namedIdentityConfiguration; }
private JPAStoreSubsystemConfigurationBuilder configureJPAIdentityStore(OperationContext context, ServiceBuilder<PartitionManager> serviceBuilder, PartitionManagerService partitionManagerService, final ModelNode identityStore, String configurationName, final NamedIdentityConfigurationBuilder builder) throws OperationFailedException { JPAStoreSubsystemConfigurationBuilder storeConfig = builder.stores() .add(JPAStoreSubsystemConfiguration.class, JPAStoreSubsystemConfigurationBuilder.class);
.stores() .jpa().mappedEntity( AccountTypeEntity.class,
private static JPAStoreSubsystemConfigurationBuilder configureJPAIdentityStore(final ResourceEntry resource, final NamedIdentityConfigurationBuilder builder, final PartitionManagerService partitionManagerService) { JPAStoreSubsystemConfigurationBuilder storeConfig = builder.stores().add(JPAStoreSubsystemConfiguration.class, JPAStoreSubsystemConfigurationBuilder.class); ModelNode jpaDataSourceNode = resource.getModel().get(ModelElement.JPA_STORE_DATASOURCE.getName()); ModelNode jpaEntityModule = resource.getModel().get(ModelElement.JPA_STORE_ENTITY_MODULE.getName()); ModelNode jpaEntityModuleUnitName = resource.getModel().get( ModelElement.JPA_STORE_ENTITY_MODULE_UNIT_NAME.getName()); ModelNode jpaEntityManagerFactoryNode = resource.getModel().get( ModelElement.JPA_STORE_ENTITY_MANAGER_FACTORY.getName()); if (jpaEntityModule.isDefined()) { storeConfig.entityModule(jpaEntityModule.asString()); } if (jpaEntityModuleUnitName.isDefined()) { storeConfig.entityModuleUnitName(jpaEntityModuleUnitName.asString()); } if (jpaDataSourceNode.isDefined()) { storeConfig.dataSourceJndiUrl(toJndiName(jpaDataSourceNode.asString())); } if (jpaEntityManagerFactoryNode.isDefined()) { storeConfig.entityManagerFactoryJndiName(jpaEntityManagerFactoryNode.asString()); } storeConfig.transactionManager(partitionManagerService.getTransactionManager()); return storeConfig; }
private static IdentityStoreConfigurationBuilder configureFileIdentityStore(ResourceEntry resource, final NamedIdentityConfigurationBuilder builder) { ModelNode modelNode = resource.getModel(); FileStoreConfigurationBuilder fileStoreBuilder = builder.stores().file(); ModelNode workingDir = modelNode.get(ModelElement.FILE_STORE_WORKING_DIR.getName()); ModelNode alwaysCreateFiles = modelNode.get(ModelElement.FILE_STORE_ALWAYS_CREATE_FILE.getName()); ModelNode asyncWrite = modelNode.get(ModelElement.FILE_STORE_ASYNC_WRITE.getName()); ModelNode asyncWriteThreadPool = modelNode.get(ModelElement.FILE_STORE_ASYNC_THREAD_POOL.getName()); if (workingDir.isDefined()) { fileStoreBuilder.workingDirectory(workingDir.asString()); } if (alwaysCreateFiles.isDefined()) { fileStoreBuilder.preserveState(!alwaysCreateFiles.asBoolean()); } if (asyncWrite.isDefined()) { fileStoreBuilder.asyncWrite(asyncWrite.asBoolean()); } if (asyncWriteThreadPool.isDefined()) { fileStoreBuilder.asyncWriteThreadPool(asyncWriteThreadPool.asInt()); } return fileStoreBuilder; }
private static LDAPStoreConfigurationBuilder configureLDAPIdentityStore(Module alternativeModule, ResourceEntry resource, NamedIdentityConfigurationBuilder builder) { ModelNode modelNode = resource.getModel(); LDAPStoreConfigurationBuilder storeConfig = builder.stores().ldap();
private JPAStoreSubsystemConfigurationBuilder configureJPAIdentityStore(OperationContext context, ServiceBuilder<PartitionManager> serviceBuilder, PartitionManagerService partitionManagerService, final ModelNode identityStore, String configurationName, final NamedIdentityConfigurationBuilder builder) throws OperationFailedException { JPAStoreSubsystemConfigurationBuilder storeConfig = builder.stores() .add(JPAStoreSubsystemConfiguration.class, JPAStoreSubsystemConfigurationBuilder.class);
private IdentityStoreConfigurationBuilder<?, ?> configureFileIdentityStore(OperationContext context, ServiceBuilder<PartitionManager> serviceBuilder, PartitionManagerService partitionManagerService, ModelNode resource, String configurationName, final NamedIdentityConfigurationBuilder builder) throws OperationFailedException { FileStoreConfigurationBuilder fileStoreBuilder = builder.stores().file(); String workingDir = FileStoreResourceDefinition.WORKING_DIR.resolveModelAttribute(context, resource).asString(); String relativeTo = FileStoreResourceDefinition.RELATIVE_TO.resolveModelAttribute(context, resource).asString(); ModelNode alwaysCreateFiles = FileStoreResourceDefinition.ALWAYS_CREATE_FILE.resolveModelAttribute(context, resource); ModelNode asyncWrite = FileStoreResourceDefinition.ASYNC_WRITE.resolveModelAttribute(context, resource); ModelNode asyncWriteThreadPool = FileStoreResourceDefinition.ASYNC_WRITE_THREAD_POOL .resolveModelAttribute(context, resource); fileStoreBuilder.preserveState(!alwaysCreateFiles.asBoolean()); fileStoreBuilder.asyncWrite(asyncWrite.asBoolean()); fileStoreBuilder.asyncWriteThreadPool(asyncWriteThreadPool.asInt()); if (serviceBuilder != null) { FileIdentityStoreService storeService = new FileIdentityStoreService(fileStoreBuilder, workingDir, relativeTo); ServiceName storeServiceName = PartitionManagerService .createIdentityStoreServiceName(partitionManagerService.getName(), configurationName, ModelElement.FILE_STORE .getName()); ServiceBuilder<FileIdentityStoreService> storeServiceBuilder = context.getServiceTarget() .addService(storeServiceName, storeService); storeServiceBuilder.addDependency(PathManagerService.SERVICE_NAME, PathManager.class, storeService.getPathManager()); serviceBuilder.addDependency(storeServiceName); ServiceController<FileIdentityStoreService> controller = storeServiceBuilder .setInitialMode(Mode.PASSIVE) .install(); } return fileStoreBuilder; }
builder .named("SIMPLE_LDAP_STORE_CONFIG") .stores() .ldap() .connectionProperties(connectionProps)
private void configureDefaults(IdentityConfigurationBuilder builder) { if (ROOT_LOGGER.isDebugEnabled()) { ROOT_LOGGER.debugf("No configuration provided by the application. Configuring defaults."); } if (this.entityManagerProvider.hasMappedEntities()) { builder .named(DEFAULT_CONFIGURATION_NAME) .stores() .jpa() .supportAllFeatures(); if (ROOT_LOGGER.isDebugEnabled()) { ROOT_LOGGER.debugf("Auto configuring JPA Identity Store."); } } else { builder .named(DEFAULT_CONFIGURATION_NAME) .stores() .file() .supportAllFeatures(); if (ROOT_LOGGER.isDebugEnabled()) { ROOT_LOGGER.debugf("Auto configuring File Identity Store."); } } }