LOG.debug( "Starting DS {}...", dsBuilder.name() );
Class<?> factory = dsBuilder.factory();
DirectoryServiceFactory dsf = ( DirectoryServiceFactory ) factory
.newInstance();
DirectoryService service = dsf.getDirectoryService();
service.setAccessControlEnabled( dsBuilder.enableAccessControl() );
service.setAllowAnonymousAccess( dsBuilder.allowAnonAccess() );
service.getChangeLog().setEnabled( dsBuilder.enableChangeLog() );
dsf.init( dsBuilder.name() );
for ( Class<?> interceptorClass : dsBuilder.additionalInterceptors() )
{
service.addLast( ( Interceptor ) interceptorClass.newInstance() );
}
List<Interceptor> interceptorList = service.getInterceptors();
if ( dsBuilder.authenticators().length != 0 )
{
AuthenticationInterceptor authenticationInterceptor = null;
for ( Interceptor interceptor : interceptorList )
{
if ( interceptor instanceof AuthenticationInterceptor )
{
authenticationInterceptor = ( AuthenticationInterceptor ) interceptor;
break;
}
}
if ( authenticationInterceptor == null )
{
throw new IllegalStateException(
"authentication interceptor not found" );
}
Set<Authenticator> authenticators = new HashSet<Authenticator>();
for ( CreateAuthenticator createAuthenticator : dsBuilder
.authenticators() )
{
Authenticator auth = createAuthenticator.type().newInstance();
if ( auth instanceof DelegatingAuthenticator )
{
DelegatingAuthenticator dauth = ( DelegatingAuthenticator ) auth;
dauth.setDelegateHost( createAuthenticator.delegateHost() );
dauth.setDelegatePort( createAuthenticator.delegatePort() );
dauth.setDelegateSsl( createAuthenticator.delegateSsl() );
dauth.setDelegateTls( createAuthenticator.delegateTls() );
dauth.setDelegateBaseDn( createAuthenticator.delegateBaseDn() );
dauth.setDelegateSslTrustManagerFQCN( createAuthenticator.delegateSslTrustManagerFQCN() );
dauth.setDelegateTlsTrustManagerFQCN( createAuthenticator.delegateTlsTrustManagerFQCN() );
}
authenticators.add( auth );
}
authenticationInterceptor.setAuthenticators( authenticators );
authenticationInterceptor.init( service );
}
service.setInterceptors( interceptorList );
SchemaManager schemaManager = service.getSchemaManager();
// process the schemas
for ( LoadSchema loadedSchema : dsBuilder.loadedSchemas() )
{
String schemaName = loadedSchema.name();
Boolean enabled = loadedSchema.enabled();
// Check if the schema is loaded or not
boolean isLoaded = schemaManager.isSchemaLoaded( schemaName );
if ( !isLoaded )
{
// We have to load the schema, if it exists
try
{
isLoaded = schemaManager.load( schemaName );
}
catch ( LdapUnwillingToPerformException lutpe )
{
// Cannot load the schema, it does not exists
LOG.error( lutpe.getMessage() );
continue;
}
}
if ( isLoaded )
{
if ( enabled )
{
schemaManager.enable( schemaName );
if ( schemaManager.isDisabled( schemaName ) )
{
LOG.error( "Cannot enable " + schemaName );
}
}
else
{
schemaManager.disable( schemaName );
if ( schemaManager.isEnabled( schemaName ) )
{
LOG.error( "Cannot disable " + schemaName );
}
}
}
LOG.debug( "Loading schema {}, enabled= {}", schemaName, enabled );
}
// Process the Partition, if any.
for ( CreatePartition createPartition : dsBuilder.partitions() )
{
Partition partition;
// Determine the partition type
if ( createPartition.type() == Partition.class )
{
// The annotation does not specify a specific partition type.
// We use the partition factory to create partition and index
// instances.
PartitionFactory partitionFactory = dsf.getPartitionFactory();
partition = partitionFactory.createPartition(
schemaManager,
createPartition.name(),
createPartition.suffix(),
createPartition.cacheSize(),
new File( service.getInstanceLayout().getPartitionsDirectory(), createPartition.name() ) );
CreateIndex[] indexes = createPartition.indexes();
for ( CreateIndex createIndex : indexes )
{
partitionFactory.addIndex( partition,
createIndex.attribute(), createIndex.cacheSize() );
}
partition.initialize();
}
else
{
// The annotation contains a specific partition type, we use
// that type.
Class<?> partypes[] = new Class[]
{ SchemaManager.class };
Constructor<?> constructor = createPartition.type().getConstructor( partypes );
partition = ( Partition ) constructor.newInstance( new Object[]
{ schemaManager } );
partition.setId( createPartition.name() );
partition.setSuffixDn( new Dn( schemaManager, createPartition.suffix() ) );
if ( partition instanceof AbstractBTreePartition )
{
AbstractBTreePartition btreePartition = ( AbstractBTreePartition ) partition;
btreePartition.setCacheSize( createPartition.cacheSize() );
btreePartition.setPartitionPath( new File( service
.getInstanceLayout().getPartitionsDirectory(),
createPartition.name() ).toURI() );
// Process the indexes if any
CreateIndex[] indexes = createPartition.indexes();
for ( CreateIndex createIndex : indexes )
{
// The annotation does not specify a specific index
// type.
// We use the generic index implementation.
JdbmIndex index = new JdbmIndex( createIndex.attribute(), false );
btreePartition.addIndexedAttributes( index );
}
}
}
partition.setSchemaManager( schemaManager );
// Inject the partition into the DirectoryService
service.addPartition( partition );
// Last, process the context entry
ContextEntry contextEntry = createPartition.contextEntry();
if ( contextEntry != null )