You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@directory.apache.org by Emmanuel Lecharny <el...@apache.org> on 2009/09/09 01:05:06 UTC
Directory startup : what needs to be done...
Hi,
I was working on the DirectoryService startup process yesturday. This is
called by the DirectoryServiceFactory, and when you launch the
integration tests, you get a NPE.
The reason we get it is because at some point, we don't have a working
directory to look at for the schema.
In order to fix this, we just have to inject the SchemaPartition working
directory, and we will be set. The question is now to determinate how we
will inject this property.
The schema partition is initialized only once : if its working directory
is empty. In this case, we extract all the existing schema files from a
jar, into a directory. Otherwise, we just read this directory, and load
the registries. The problem is that we must have a pointer to this
working directory, and we don't have any atm.
Questions :
1) how do we set the working directory ?
2) when do we set it, assuming that it may be a part of the configuration ?
3) shouldn't it be a static definition ?
Right now, all the partitions are stored into the DirectoryService
working directory (default to 'server-work'), under a subdirectory using
the partition Id (ie, "schema" here for the schema partition). That
sounds good to me atm.
wdyt ?
--
--
cordialement, regards,
Emmanuel Lécharny
www.iktek.com
directory.apache.org
Re: Directory startup : what needs to be done...
Posted by Alex Karasulu <ak...@gmail.com>.
On Wed, Sep 9, 2009 at 10:16 AM, Emmanuel Lecharny <el...@apache.org>wrote:
> Alex Karasulu wrote:
>
>> On Wed, Sep 9, 2009 at 2:05 AM, Emmanuel Lecharny <elecharny@apache.org
>> >wrote:
>>
>>
>>
>>> Hi,
>>>
>>> I was working on the DirectoryService startup process yesturday. This is
>>> called by the DirectoryServiceFactory, and when you launch the
>>> integration
>>> tests, you get a NPE.
>>>
>>> The reason we get it is because at some point, we don't have a working
>>> directory to look at for the schema.
>>>
>>> In order to fix this, we just have to inject the SchemaPartition working
>>> directory, and we will be set. The question is now to determinate how we
>>> will inject this property.
>>>
>>>
>>>
>>>
>> The SchemaPartition does not need a workingDirectory property necessarily.
>> Just add the workingDirectory property to the LdifPartition or whatever is
>> wrapped by the SchemaPartition.
>>
>>
> See my answer in your next response.
>
>>
>>
>>
>>
>>> The schema partition is initialized only once : if its working directory
>>> is
>>> empty. In this case, we extract all the existing schema files from a jar,
>>> into a directory. Otherwise, we just read this directory, and load the
>>> registries. The problem is that we must have a pointer to this working
>>> directory, and we don't have any atm.
>>>
>>>
>>>
>>>
>> Question is do we make the SchemaPartition unzip the schema files (only
>> done
>> for LdifPartition at this point) or do we have the Partition which is
>> wrapped handle this? The OraclePartition if used as the wrapped Partition
>> will not need this I think.
>>
>>
> I think that the SchemaPartition should be responsible for the
> initialization of the wrapped partition.
This is exactly the kind of thought process that is an impediment to
establishing a solid component based model with a container driving
initialization. The reason why we refactored and decoupled things out of
the core was to make sure the DefaultDirectoryService and it's internals
were not involved in configuration of contained components.
We must let the container configure components: not other components that
contain them. This is utterly going in the opposite direction.
> If you start a brand new server, the schema partition does not exist yet
> (on disk, or in oracle). You then have to extract the schema objects from
> the jar, and inject those into the wrapped partition. If we are using a ldif
> partition, it's easy, as we just have to extract the data on disk. For an
> Oracle partition, we have to inject the objects one by one, to initialize
> the database. In the first case, and if the extraction of the initial
> schemas is done by the schemaPartition, then the SchemaPartition must know
> what is the working directory.
>
> On the other hand, if we delegate to the ldif partition the extraction of
> the initial schemas, then we have to implement this function, which is not
> used by any other LdifPartition.
>
> So the SchemaPartition has to have a knowledge about the working directory
> when it does this initial extraction. Question : can we get this working
> directory from the wrapped LdifPartition? Something like :
>
> LdifPartition ldifPartition = new LdifPartition();
> ldifPartition.setWorkingDirectory( blah );
>
> SchemaPartition schemaPartition = new SchemaPartition();
> schemaPartition.setWrappedPartition( ldifPartition );
> ...
> schemaPartition.initialize();
> ...
> void initialize()
> {
> String workingDirectory = wrappedPartition.getWorkingDirectory();
>
> // Check if the schemas have already been extracted
> // If not, do the initial extraction using the Jar
> // otherwise call the ldifPartition.initialize() method
> }
>
> I think so, and will try to implement it this way.
>
>
Let's get a chance to talk before we go down this road.
--
Alex Karasulu
My Blog :: http://www.jroller.com/akarasulu/
Apache Directory Server :: http://directory.apache.org
Apache MINA :: http://mina.apache.org
Re: Directory startup : what needs to be done...
Posted by Emmanuel Lecharny <el...@apache.org>.
Alex Karasulu wrote:
> On Wed, Sep 9, 2009 at 2:05 AM, Emmanuel Lecharny <el...@apache.org>wrote:
>
>
>> Hi,
>>
>> I was working on the DirectoryService startup process yesturday. This is
>> called by the DirectoryServiceFactory, and when you launch the integration
>> tests, you get a NPE.
>>
>> The reason we get it is because at some point, we don't have a working
>> directory to look at for the schema.
>>
>> In order to fix this, we just have to inject the SchemaPartition working
>> directory, and we will be set. The question is now to determinate how we
>> will inject this property.
>>
>>
>>
> The SchemaPartition does not need a workingDirectory property necessarily.
> Just add the workingDirectory property to the LdifPartition or whatever is
> wrapped by the SchemaPartition.
>
See my answer in your next response.
>
>
>
>> The schema partition is initialized only once : if its working directory is
>> empty. In this case, we extract all the existing schema files from a jar,
>> into a directory. Otherwise, we just read this directory, and load the
>> registries. The problem is that we must have a pointer to this working
>> directory, and we don't have any atm.
>>
>>
>>
> Question is do we make the SchemaPartition unzip the schema files (only done
> for LdifPartition at this point) or do we have the Partition which is
> wrapped handle this? The OraclePartition if used as the wrapped Partition
> will not need this I think.
>
I think that the SchemaPartition should be responsible for the
initialization of the wrapped partition. If you start a brand new
server, the schema partition does not exist yet (on disk, or in oracle).
You then have to extract the schema objects from the jar, and inject
those into the wrapped partition. If we are using a ldif partition, it's
easy, as we just have to extract the data on disk. For an Oracle
partition, we have to inject the objects one by one, to initialize the
database. In the first case, and if the extraction of the initial
schemas is done by the schemaPartition, then the SchemaPartition must
know what is the working directory.
On the other hand, if we delegate to the ldif partition the extraction
of the initial schemas, then we have to implement this function, which
is not used by any other LdifPartition.
So the SchemaPartition has to have a knowledge about the working
directory when it does this initial extraction. Question : can we get
this working directory from the wrapped LdifPartition? Something like :
LdifPartition ldifPartition = new LdifPartition();
ldifPartition.setWorkingDirectory( blah );
SchemaPartition schemaPartition = new SchemaPartition();
schemaPartition.setWrappedPartition( ldifPartition );
...
schemaPartition.initialize();
...
void initialize()
{
String workingDirectory = wrappedPartition.getWorkingDirectory();
// Check if the schemas have already been extracted
// If not, do the initial extraction using the Jar
// otherwise call the ldifPartition.initialize() method
}
I think so, and will try to implement it this way.
--
--
cordialement, regards,
Emmanuel Lécharny
www.iktek.com
directory.apache.org
Re: Directory startup : what needs to be done...
Posted by Alex Karasulu <ak...@gmail.com>.
Let's get you into this branch working to incorporate your OraclePartition
into the build properly. Let's make sure the build does not bomb or
requires a profile switch otherwise if the required Oracle jar dependencies
are not present or need to be manually installed in local maven
repositories.
Thanks,
Alex
On Wed, Sep 9, 2009 at 10:12 AM, Andrea Gariboldi <
andrea.gariboldi@gmail.com> wrote:
> The way it works with oracle (dsorapart) actually is : the SchemaPartition
> is an OraclePartition that stores the schema data into the database. So
> actually to handle this the first time, i have to do is:
>
> 1. extract the files into some directory
> 2. create the JdbmPartition from those files
> 3. copy the JdbmPartition into the OraclePartition
> 4. never use the extracted files again... (i check if i have already loaded
> schema data into the database)
>
> Obviously the working directory for an OraclePartition is useless.
>
> cheers,
> Andrea
>
> The code of my modified DirectoryService.initialize():
>
> OraclePartition schemaPartition = new OraclePartition(registries,
> config);
> schemaPartition.setId( "schema" );
> schemaPartition.setCacheSize( 0 );
> LdapDN contextDn = new LdapDN( "ou=schema" );
> contextDn.normalize(
> registries.getAttributeTypeRegistry().getNormalizerMapping() );
> schemaPartition.setSuffix( contextDn.toString() );
>
> ServerEntry entry = new DefaultServerEntry( registries, contextDn
> );
> entry.put( SchemaConstants.OBJECT_CLASS_AT,
> SchemaConstants.TOP_OC,
> SchemaConstants.ORGANIZATIONAL_UNIT_OC );
> entry.put( SchemaConstants.OU_AT, "schema" );
> schemaPartition.setContextEntry( entry );
> schemaPartition.init( this );
>
> boolean loadSchema= !schemaPartition.hasEntry(new
> EntryOperationContext(registries, entry.getDn()));
>
> if (loadSchema)
> {
> File schemaDirectory = new File( workingDirectory,
> "schema" );
> SchemaPartitionExtractor extractor;
> if ( ! schemaDirectory.exists() )
> {
> try
> {
> extractor = new SchemaPartitionExtractor(
> workingDirectory );
> extractor.extract();
> }
> catch ( IOException e )
> {
> NamingException ne = new NamingException(
> "Failed to extract pre-loaded schema partition." );
> ne.setRootCause( e );
> throw ne;
> }
> }
>
> //
> --------------------------------------------------------------------
> // Initialize schema partition
> //
> --------------------------------------------------------------------
>
> JdbmPartition defaultschemaPartition = new
> JdbmPartition();
> defaultschemaPartition.setId( "schema" );
> defaultschemaPartition.setCacheSize( 1000 );
> DbFileListing listing;
>
> try
> {
> listing = new DbFileListing();
> }
> catch( IOException e )
> {
> throw new LdapNamingException( "Got IOException
> while trying to read DBFileListing: " + e.getMessage(),
> ResultCodeEnum.OTHER );
> }
>
> Set<Index> indexedAttributes = new HashSet<Index>();
>
> for ( String attributeId :
> listing.getIndexedAttributes() )
> {
> indexedAttributes.add( new JdbmIndex( attributeId )
> );
> }
>
> defaultschemaPartition.setIndexedAttributes(
> indexedAttributes );
> defaultschemaPartition.setSuffix(
> ServerDNConstants.OU_SCHEMA_DN );
>
> entry = new DefaultServerEntry( registries, new LdapDN(
> ServerDNConstants.OU_SCHEMA_DN ) );
> entry.put( SchemaConstants.OBJECT_CLASS_AT,
> SchemaConstants.TOP_OC,
> SchemaConstants.ORGANIZATIONAL_UNIT_OC );
> entry.put( SchemaConstants.OU_AT, "schema" );
> defaultschemaPartition.setContextEntry( entry );
> defaultschemaPartition.init( this );
>
> LdapDN base = new LdapDN(
> ServerDNConstants.OU_SCHEMA_DN );
>
> base.normalize(registries.getAttributeTypeRegistry().getNormalizerMapping());
> ExprNode filter = new PresenceNode(
> registries.getOidRegistry().getOid( SchemaConstants.OBJECT_CLASS_AT ));
> SearchControls searchControls = new SearchControls();
> searchControls.setSearchScope(
> SearchControls.SUBTREE_SCOPE );
> searchControls.setReturningAttributes(new
> String[]{"*","+"});
>
> NamingEnumeration<ServerSearchResult> all=
> defaultschemaPartition.search( new SearchOperationContext( registries, base,
> AliasDerefMode.DEREF_ALWAYS, filter,
> searchControls ) );
>
> while (all.hasMore())
> {
> ServerSearchResult ssr= all.next();
> schemaPartition.add(new
> AddOperationContext(registries,ssr.getServerEntry()));
> }
>
> defaultschemaPartition.destroy();
> }
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> 2009/9/9 Alex Karasulu <ak...@gmail.com>
>
> On Wed, Sep 9, 2009 at 2:05 AM, Emmanuel Lecharny <el...@apache.org>wrote:
>>
>>> Hi,
>>>
>>> I was working on the DirectoryService startup process yesturday. This is
>>> called by the DirectoryServiceFactory, and when you launch the integration
>>> tests, you get a NPE.
>>>
>>> The reason we get it is because at some point, we don't have a working
>>> directory to look at for the schema.
>>>
>>> In order to fix this, we just have to inject the SchemaPartition working
>>> directory, and we will be set. The question is now to determinate how we
>>> will inject this property.
>>>
>>>
>> The SchemaPartition does not need a workingDirectory property
>> necessarily. Just add the workingDirectory property to the LdifPartition or
>> whatever is wrapped by the SchemaPartition.
>>
>>
>>
>>> The schema partition is initialized only once : if its working directory
>>> is empty. In this case, we extract all the existing schema files from a jar,
>>> into a directory. Otherwise, we just read this directory, and load the
>>> registries. The problem is that we must have a pointer to this working
>>> directory, and we don't have any atm.
>>>
>>>
>> Question is do we make the SchemaPartition unzip the schema files (only
>> done for LdifPartition at this point) or do we have the Partition which is
>> wrapped handle this? The OraclePartition if used as the wrapped Partition
>> will not need this I think.
>>
>
>
>
>
>
>
>>
>>
>>> Questions :
>>> 1) how do we set the working directory ?
>>>
>>
>> Set it programmatically on the LdifPartition.
>>
>>
>>> 2) when do we set it, assuming that it may be a part of the configuration
>>> ?
>>>
>>
>> After instantiation of the LdifPartition, then call
>> SchemaPartition.setWrappedPartition( ldifPartition) so the SchemaPartition
>> has the reference to the LdifPartition.
>>
>> 3) shouldn't it be a static definition ?
>>>
>>
>> NO STATICS ! ! ! BAD JUJU WITH STATICS.
>>
>>
>>> Right now, all the partitions are stored into the DirectoryService
>>> working directory (default to 'server-work'), under a subdirectory using the
>>> partition Id (ie, "schema" here for the schema partition). That sounds good
>>> to me atm.
>>>
>>> wdyt ?
>>>
>>>
>> That's because tests default to setting the workingDirectory property of
>> the DS to this server-work directory. When they do that the Partitions have
>> a base to create their own work directories for their data.
>>
>> --
>> Alex Karasulu
>> My Blog :: http://www.jroller.com/akarasulu/
>> Apache Directory Server :: http://directory.apache.org
>> Apache MINA :: http://mina.apache.org
>>
>>
>
--
Alex Karasulu
My Blog :: http://www.jroller.com/akarasulu/
Apache Directory Server :: http://directory.apache.org
Apache MINA :: http://mina.apache.org
Re: Directory startup : what needs to be done...
Posted by Emmanuel Lecharny <el...@apache.org>.
Andrea Gariboldi wrote:
> The way it works with oracle (dsorapart) actually is : the SchemaPartition
> is an OraclePartition that stores the schema data into the database. So
> actually to handle this the first time, i have to do is:
>
> 1. extract the files into some directory
> 2. create the JdbmPartition from those files
> 3. copy the JdbmPartition into the OraclePartition
> 4. never use the extracted files again... (i check if i have already loaded
> schema data into the database)
>
Thanks Andrea.
I think you can save the JDBM step, as once the schema is extracted on
disk, using a LdifPartition to read it will allow you to avoid the JDBM
creation (all the index are created in memory, the search is done in
memory).
Let me code that and send it back to the ML.
Thanks !
--
--
cordialement, regards,
Emmanuel Lécharny
www.iktek.com
directory.apache.org
Re: Directory startup : what needs to be done...
Posted by Andrea Gariboldi <an...@gmail.com>.
The way it works with oracle (dsorapart) actually is : the SchemaPartition
is an OraclePartition that stores the schema data into the database. So
actually to handle this the first time, i have to do is:
1. extract the files into some directory
2. create the JdbmPartition from those files
3. copy the JdbmPartition into the OraclePartition
4. never use the extracted files again... (i check if i have already loaded
schema data into the database)
Obviously the working directory for an OraclePartition is useless.
cheers,
Andrea
The code of my modified DirectoryService.initialize():
OraclePartition schemaPartition = new OraclePartition(registries, config);
schemaPartition.setId( "schema" );
schemaPartition.setCacheSize( 0 );
LdapDN contextDn = new LdapDN( "ou=schema" );
contextDn.normalize(
registries.getAttributeTypeRegistry().getNormalizerMapping() );
schemaPartition.setSuffix( contextDn.toString() );
ServerEntry entry = new DefaultServerEntry( registries, contextDn );
entry.put( SchemaConstants.OBJECT_CLASS_AT,
SchemaConstants.TOP_OC,
SchemaConstants.ORGANIZATIONAL_UNIT_OC );
entry.put( SchemaConstants.OU_AT, "schema" );
schemaPartition.setContextEntry( entry );
schemaPartition.init( this );
boolean loadSchema= !schemaPartition.hasEntry(new
EntryOperationContext(registries, entry.getDn()));
if (loadSchema)
{
File schemaDirectory = new File( workingDirectory,
"schema" );
SchemaPartitionExtractor extractor;
if ( ! schemaDirectory.exists() )
{
try
{
extractor = new SchemaPartitionExtractor(
workingDirectory );
extractor.extract();
}
catch ( IOException e )
{
NamingException ne = new NamingException(
"Failed to extract pre-loaded schema partition." );
ne.setRootCause( e );
throw ne;
}
}
//
--------------------------------------------------------------------
// Initialize schema partition
//
--------------------------------------------------------------------
JdbmPartition defaultschemaPartition = new
JdbmPartition();
defaultschemaPartition.setId( "schema" );
defaultschemaPartition.setCacheSize( 1000 );
DbFileListing listing;
try
{
listing = new DbFileListing();
}
catch( IOException e )
{
throw new LdapNamingException( "Got IOException
while trying to read DBFileListing: " + e.getMessage(),
ResultCodeEnum.OTHER );
}
Set<Index> indexedAttributes = new HashSet<Index>();
for ( String attributeId :
listing.getIndexedAttributes() )
{
indexedAttributes.add( new JdbmIndex( attributeId )
);
}
defaultschemaPartition.setIndexedAttributes(
indexedAttributes );
defaultschemaPartition.setSuffix(
ServerDNConstants.OU_SCHEMA_DN );
entry = new DefaultServerEntry( registries, new LdapDN(
ServerDNConstants.OU_SCHEMA_DN ) );
entry.put( SchemaConstants.OBJECT_CLASS_AT,
SchemaConstants.TOP_OC,
SchemaConstants.ORGANIZATIONAL_UNIT_OC );
entry.put( SchemaConstants.OU_AT, "schema" );
defaultschemaPartition.setContextEntry( entry );
defaultschemaPartition.init( this );
LdapDN base = new LdapDN( ServerDNConstants.OU_SCHEMA_DN
);
base.normalize(registries.getAttributeTypeRegistry().getNormalizerMapping());
ExprNode filter = new PresenceNode(
registries.getOidRegistry().getOid( SchemaConstants.OBJECT_CLASS_AT ));
SearchControls searchControls = new SearchControls();
searchControls.setSearchScope(
SearchControls.SUBTREE_SCOPE );
searchControls.setReturningAttributes(new
String[]{"*","+"});
NamingEnumeration<ServerSearchResult> all=
defaultschemaPartition.search( new SearchOperationContext( registries, base,
AliasDerefMode.DEREF_ALWAYS, filter,
searchControls ) );
while (all.hasMore())
{
ServerSearchResult ssr= all.next();
schemaPartition.add(new
AddOperationContext(registries,ssr.getServerEntry()));
}
defaultschemaPartition.destroy();
}
2009/9/9 Alex Karasulu <ak...@gmail.com>
> On Wed, Sep 9, 2009 at 2:05 AM, Emmanuel Lecharny <el...@apache.org>wrote:
>
>> Hi,
>>
>> I was working on the DirectoryService startup process yesturday. This is
>> called by the DirectoryServiceFactory, and when you launch the integration
>> tests, you get a NPE.
>>
>> The reason we get it is because at some point, we don't have a working
>> directory to look at for the schema.
>>
>> In order to fix this, we just have to inject the SchemaPartition working
>> directory, and we will be set. The question is now to determinate how we
>> will inject this property.
>>
>>
> The SchemaPartition does not need a workingDirectory property necessarily.
> Just add the workingDirectory property to the LdifPartition or whatever is
> wrapped by the SchemaPartition.
>
>
>
>> The schema partition is initialized only once : if its working directory
>> is empty. In this case, we extract all the existing schema files from a jar,
>> into a directory. Otherwise, we just read this directory, and load the
>> registries. The problem is that we must have a pointer to this working
>> directory, and we don't have any atm.
>>
>>
> Question is do we make the SchemaPartition unzip the schema files (only
> done for LdifPartition at this point) or do we have the Partition which is
> wrapped handle this? The OraclePartition if used as the wrapped Partition
> will not need this I think.
>
>
>
>> Questions :
>> 1) how do we set the working directory ?
>>
>
> Set it programmatically on the LdifPartition.
>
>
>> 2) when do we set it, assuming that it may be a part of the configuration
>> ?
>>
>
> After instantiation of the LdifPartition, then call
> SchemaPartition.setWrappedPartition( ldifPartition) so the SchemaPartition
> has the reference to the LdifPartition.
>
> 3) shouldn't it be a static definition ?
>>
>
> NO STATICS ! ! ! BAD JUJU WITH STATICS.
>
>
>> Right now, all the partitions are stored into the DirectoryService working
>> directory (default to 'server-work'), under a subdirectory using the
>> partition Id (ie, "schema" here for the schema partition). That sounds good
>> to me atm.
>>
>> wdyt ?
>>
>>
> That's because tests default to setting the workingDirectory property of
> the DS to this server-work directory. When they do that the Partitions have
> a base to create their own work directories for their data.
>
> --
> Alex Karasulu
> My Blog :: http://www.jroller.com/akarasulu/
> Apache Directory Server :: http://directory.apache.org
> Apache MINA :: http://mina.apache.org
>
>
Re: Directory startup : what needs to be done...
Posted by Alex Karasulu <ak...@gmail.com>.
On Wed, Sep 9, 2009 at 2:05 AM, Emmanuel Lecharny <el...@apache.org>wrote:
> Hi,
>
> I was working on the DirectoryService startup process yesturday. This is
> called by the DirectoryServiceFactory, and when you launch the integration
> tests, you get a NPE.
>
> The reason we get it is because at some point, we don't have a working
> directory to look at for the schema.
>
> In order to fix this, we just have to inject the SchemaPartition working
> directory, and we will be set. The question is now to determinate how we
> will inject this property.
>
>
The SchemaPartition does not need a workingDirectory property necessarily.
Just add the workingDirectory property to the LdifPartition or whatever is
wrapped by the SchemaPartition.
> The schema partition is initialized only once : if its working directory is
> empty. In this case, we extract all the existing schema files from a jar,
> into a directory. Otherwise, we just read this directory, and load the
> registries. The problem is that we must have a pointer to this working
> directory, and we don't have any atm.
>
>
Question is do we make the SchemaPartition unzip the schema files (only done
for LdifPartition at this point) or do we have the Partition which is
wrapped handle this? The OraclePartition if used as the wrapped Partition
will not need this I think.
> Questions :
> 1) how do we set the working directory ?
>
Set it programmatically on the LdifPartition.
> 2) when do we set it, assuming that it may be a part of the configuration ?
>
After instantiation of the LdifPartition, then call
SchemaPartition.setWrappedPartition( ldifPartition) so the SchemaPartition
has the reference to the LdifPartition.
3) shouldn't it be a static definition ?
>
NO STATICS ! ! ! BAD JUJU WITH STATICS.
> Right now, all the partitions are stored into the DirectoryService working
> directory (default to 'server-work'), under a subdirectory using the
> partition Id (ie, "schema" here for the schema partition). That sounds good
> to me atm.
>
> wdyt ?
>
>
That's because tests default to setting the workingDirectory property of the
DS to this server-work directory. When they do that the Partitions have a
base to create their own work directories for their data.
--
Alex Karasulu
My Blog :: http://www.jroller.com/akarasulu/
Apache Directory Server :: http://directory.apache.org
Apache MINA :: http://mina.apache.org