core/src/main/java/org/apache/ldap/server/partition/DefaultContextPartitionNexus.java - directory-server - Git at Google

 /*
  *   Copyright 2004 The Apache Software Foundation
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
  *   You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License is distributed on an "AS IS" BASIS,
  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  *
  */
 package org.apache.ldap.server.partition;


 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.naming.ConfigurationException;
 import javax.naming.Name;
 import javax.naming.NameNotFoundException;
 import javax.naming.NamingEnumeration;
 import javax.naming.NamingException;
 import javax.naming.directory.Attribute;
 import javax.naming.directory.Attributes;
 import javax.naming.directory.BasicAttribute;
 import javax.naming.directory.BasicAttributes;
 import javax.naming.directory.ModificationItem;
 import javax.naming.directory.SearchControls;
 import javax.naming.directory.SearchResult;
 import javax.naming.ldap.LdapContext;

 import org.apache.ldap.common.MultiException;
 import org.apache.ldap.common.NotImplementedException;
 import org.apache.ldap.common.exception.LdapNameNotFoundException;
 import org.apache.ldap.common.filter.ExprNode;
 import org.apache.ldap.common.filter.PresenceNode;
 import org.apache.ldap.common.message.LockableAttributeImpl;
 import org.apache.ldap.common.message.LockableAttributes;
 import org.apache.ldap.common.message.LockableAttributesImpl;
 import org.apache.ldap.common.name.LdapName;
 import org.apache.ldap.common.util.DateUtils;
 import org.apache.ldap.common.util.NamespaceTools;
 import org.apache.ldap.common.util.SingletonEnumeration;
 import org.apache.ldap.server.configuration.ContextPartitionConfiguration;
 import org.apache.ldap.server.configuration.MutableContextPartitionConfiguration;
 import org.apache.ldap.server.jndi.ContextFactoryConfiguration;
 import org.apache.ldap.server.partition.impl.btree.jdbm.JdbmContextPartition;


 /**
  * A nexus for partitions dedicated for storing entries specific to a naming
  * context.
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  * @version $Rev$
  */
 public class DefaultContextPartitionNexus extends ContextPartitionNexus
 {
     /** the vendorName string proudly set to: Apache Software Foundation*/
     private static final String ASF = "Apache Software Foundation";

     /** the vendorName DSE operational attribute */
     private static final String VENDORNAME_ATTR = "vendorName";

     /** the namingContexts DSE operational attribute */
     private static final String NAMINGCTXS_ATTR = "namingContexts";

     /** the closed state of this partition */
     private boolean initialized;

     /** the system backend */
     private ContextPartition system;

     /** the backends keyed by normalized suffix strings */
     private HashMap partitions = new HashMap();

     /** the read only rootDSE attributes */
     private final Attributes rootDSE;


     /**
      * Creates the root nexus singleton of the entire system.  The root DSE has
      * several attributes that are injected into it besides those that may
      * already exist.  As partitions are added to the system more namingContexts
      * attributes are added to the rootDSE.
      *
      * @see <a href="http://www.faqs.org/rfcs/rfc3045.html">Vendor Information</a>
      */
     public DefaultContextPartitionNexus( Attributes rootDSE )
     {
         // setup that root DSE
         this.rootDSE = rootDSE;
         Attribute attr = new LockableAttributeImpl( "subschemaSubentry" );
         attr.add( "cn=schema,ou=system" );
         rootDSE.put( attr );

         attr = new LockableAttributeImpl( "supportedLDAPVersion" );
         rootDSE.put( attr );
         attr.add( "3" );

         attr = new LockableAttributeImpl( "objectClass" );
         rootDSE.put( attr );
         attr.add( "top" );
         attr.add( "extensibleObject" );

         attr = new LockableAttributeImpl( NAMINGCTXS_ATTR );
         rootDSE.put( attr );

         attr = new LockableAttributeImpl( VENDORNAME_ATTR );
         attr.add( ASF );
         rootDSE.put( attr );
     }


     public void init( ContextFactoryConfiguration factoryCfg, ContextPartitionConfiguration cfg ) throws NamingException
     {
         // NOTE: We ignore ContextPartitionConfiguration parameter here.
         if( initialized )
         {
             return;
         }

         List initializedPartitions = new ArrayList();
         initializeSystemPartition( factoryCfg );
         initializedPartitions.add( system );

         Iterator i = factoryCfg.getStartupConfiguration().getContextPartitionConfigurations().iterator();
         try
         {
             while( i.hasNext() )
             {
                 cfg = ( ContextPartitionConfiguration ) i.next();
                 ContextPartition partition = cfg.getContextPartition();

                 // Turn on default indices
                 MutableContextPartitionConfiguration mcfg =
                     new MutableContextPartitionConfiguration();
                 mcfg.setName( cfg.getName() );
                 mcfg.setSuffix( cfg.getSuffix() );
                 mcfg.setContextEntry( cfg.getContextEntry() );
                 mcfg.setContextPartition( partition );

                 Set indexedAttrs = cfg.getIndexedAttributes();
                 indexedAttrs.add( Oid.ALIAS );
                 indexedAttrs.add( Oid.EXISTANCE );
                 indexedAttrs.add( Oid.HIERARCHY );
                 indexedAttrs.add( Oid.NDN );
                 indexedAttrs.add( Oid.ONEALIAS );
                 indexedAttrs.add( Oid.SUBALIAS );
                 indexedAttrs.add( Oid.UPDN );
                 mcfg.setIndexedAttributes( indexedAttrs );

                 partition.init( factoryCfg, mcfg );
                 initializedPartitions.add( 0, partition );
                 register( partition );
             }
             initialized = true;
         }
         finally
         {
             if( !initialized )
             {
                 i = initializedPartitions.iterator();
                 while( i.hasNext() )
                 {
                     ContextPartition partition = ( ContextPartition ) i.next();
                     i.remove();
                     try
                     {
                         partition.destroy();
                     }
                     catch( Exception e )
                     {
                         e.printStackTrace();
                     }
                     finally
                     {
                         unregister( partition );
                     }
                 }
             }
         }
     }


     private void initializeSystemPartition( ContextFactoryConfiguration factoryCfg ) throws NamingException
     {
         // initialize system partition first
         MutableContextPartitionConfiguration systemCfg = new MutableContextPartitionConfiguration();
         system = new JdbmContextPartition(); // using default implementation.
         systemCfg.setName( "system" );
         systemCfg.setSuffix( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX );
         systemCfg.setContextPartition( system );

         // Add indexed attributes for system partition
         Set indexedSystemAttrs = new HashSet();
         indexedSystemAttrs.add( Oid.ALIAS );
         indexedSystemAttrs.add( Oid.EXISTANCE );
         indexedSystemAttrs.add( Oid.HIERARCHY );
         indexedSystemAttrs.add( Oid.NDN );
         indexedSystemAttrs.add( Oid.ONEALIAS );
         indexedSystemAttrs.add( Oid.SUBALIAS );
         indexedSystemAttrs.add( Oid.UPDN );
         systemCfg.setIndexedAttributes( indexedSystemAttrs );

         // Add context entry for system partition
         Attributes systemEntry = new BasicAttributes();
         Attribute objectClassAttr = new BasicAttribute( "objectClass" );
         objectClassAttr.add( "top" );
         objectClassAttr.add( "organizationalUnit" );
         systemEntry.put( objectClassAttr );
         systemEntry.put( "creatorsName", ContextPartitionNexus.ADMIN_PRINCIPAL ) ;
         systemEntry.put( "createTimestamp", DateUtils.getGeneralizedTime() ) ;
         systemEntry.put(
                 NamespaceTools.getRdnAttribute( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX ),
                 NamespaceTools.getRdnValue( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX ) ) ;
         systemCfg.setContextEntry( systemEntry );

         system.init( factoryCfg, systemCfg );
         register( system );
     }


     public boolean isInitialized()
     {
         return initialized;
     }


     public synchronized void destroy()
     {
         if ( !initialized )
         {
             return;
         }

         MultiException error = null;

         Iterator list = this.partitions.values().iterator();

         // make sure this loop is not fail fast so all backing stores can
         // have an attempt at closing down and synching their cached entries
         while ( list.hasNext() )
         {
             ContextPartition partition = ( ContextPartition ) list.next();

             try
             {
                 partition.sync();
                 partition.destroy();
             }
             catch ( NamingException e )
             {
                 e.printStackTrace();

                 if ( error == null )
                 {
                     error = new MultiException( "Grouping many exceptions on root nexus close()" );
                 }

                 // @todo really need to send this info to a monitor
                 error.addThrowable( e );
             }
         }

         initialized = false;

         if ( error != null )
         {
             String msg = "Encountered failures while performing a close() operation on backing stores";

             NamingException total = new NamingException( msg );

             total.setRootCause( error );
             total.printStackTrace();
         }
     }


     /**
      * @see ContextPartition#sync()
      */
     public void sync() throws NamingException
     {
         MultiException error = null;

         Iterator list = this.partitions.values().iterator();

         while ( list.hasNext() )
         {
             ContextPartition store = ( ContextPartition ) list.next();

             try
             {
                 store.sync();
             }
             catch ( NamingException e )
             {
                 e.printStackTrace();

                 if ( error == null )
                 {
                     error = new MultiException( "Grouping many exceptions on root nexus sync()" );
                 }

                 // @todo really need to send this info to a monitor
                 error.addThrowable( e );
             }
         }

         if ( error != null )
         {
             String msg = "Encountered failures while performing a sync() operation on backing stores";

             NamingException total = new NamingException( msg );

             total.setRootCause( error );
         }
     }


     // ------------------------------------------------------------------------
     // BackendNexus Interface Method Implementations
     // ------------------------------------------------------------------------


     public ContextPartition getSystemPartition()
     {
         return system;
     }

     /**
      * @see ContextPartitionNexus#getLdapContext()
      */
     public LdapContext getLdapContext()
     {
         throw new NotImplementedException();
     }


     /**
      * @see ContextPartitionNexus#getMatchedName(javax.naming.Name, boolean)
      */
     public Name getMatchedName( Name dn, boolean normalized ) throws NamingException
     {
         dn = ( Name ) dn.clone();

         while ( dn.size() > 0 )
         {
             if ( hasEntry( dn ) )
             {
                 return dn;
             }

             dn = dn.getSuffix( 1 );
         }

         return dn;
     }


     public Name getSuffix( boolean normalized )
     {
         return new LdapName();
     }


     /**
      * @see org.apache.ldap.server.partition.ContextPartitionNexus#getSuffix(javax.naming.Name, boolean)
      */
     public Name getSuffix( Name dn, boolean normalized ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         return backend.getSuffix( normalized );
     }


     /**
      * @see org.apache.ldap.server.partition.ContextPartitionNexus#listSuffixes(boolean)
      */
     public Iterator listSuffixes( boolean normalized ) throws NamingException
     {
         return Collections.unmodifiableSet( partitions.keySet() ).iterator();
     }


     public Attributes getRootDSE()
     {
         return rootDSE;
     }


     /**
      * Registers an ContextPartition with this BackendManager.  Called by each
      * ContextPartition implementation after it has started to register for
      * backend operation calls.  This method effectively puts the
      * ContextPartition's naming context online.
      *
      * Operations against the naming context should result in an LDAP BUSY
      * result code in the returnValue if the naming context is not online.
      *
      * @param partition ContextPartition component to register with this
      * BackendNexus.
      * @throws ConfigurationException
      */
     private void register( ContextPartition partition ) throws NamingException
     {
         String key = partition.getSuffix( true ).toString();
         if( partitions.containsKey( key ) )
         {
             throw new ConfigurationException( "Duplicate partition suffix: " + key );
         }
         partitions.put( key, partition );

         Attribute namingContexts = rootDSE.get( NAMINGCTXS_ATTR );
         namingContexts.add( partition.getSuffix( false ).toString() );
     }


     /**
      * Unregisters an ContextPartition with this BackendManager.  Called for each
      * registered Backend right befor it is to be stopped.  This prevents
      * protocol server requests from reaching the Backend and effectively puts
      * the ContextPartition's naming context offline.
      *
      * Operations against the naming context should result in an LDAP BUSY
      * result code in the returnValue if the naming context is not online.
      *
      * @param partition ContextPartition component to unregister with this
      * BackendNexus.
      */
     private void unregister( ContextPartition partition ) throws NamingException
     {
         Attribute namingContexts = rootDSE.get( NAMINGCTXS_ATTR );
         namingContexts.remove( partition.getSuffix( false ).toString() );
         partitions.remove( partition.getSuffix( true ).toString() );
     }


     // ------------------------------------------------------------------------
     // Backend Interface Method Implementations
     // ------------------------------------------------------------------------


     /**
      * @see ContextPartition#delete(javax.naming.Name)
      */
     public void delete( Name dn ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         backend.delete( dn );
     }


     /**
      * Looks up the backend corresponding to the entry first, then checks to
      * see if the entry already exists.  If so an exception is thrown.  If not
      * the add operation against the backend proceeds.  This check is performed
      * here so backend implementors do not have to worry about performing these
      * kinds of checks.
      *
      * @see org.apache.ldap.server.partition.ContextPartition#add(String, Name, Attributes)
      */
     public void add( String updn, Name dn, Attributes an_entry ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         backend.add( updn, dn, an_entry );
     }


     /**
      * @see ContextPartition#modify(Name, int,Attributes)
      */
     public void modify( Name dn, int modOp, Attributes mods ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         backend.modify( dn, modOp, mods );
     }


     /**
      * @see ContextPartition#modify(javax.naming.Name,
      * javax.naming.directory.ModificationItem[])
      */
     public void modify( Name dn, ModificationItem[] mods ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         backend.modify( dn, mods );
     }


     /**
      * @see ContextPartition#list(javax.naming.Name)
      */
     public NamingEnumeration list( Name base ) throws NamingException
     {
         ContextPartition backend = getBackend( base );

         return backend.list( base );
     }


     /**
      * @see ContextPartition#search(Name, Map, ExprNode, SearchControls)
      */
     public NamingEnumeration search( Name base, Map env, ExprNode filter, SearchControls searchCtls )
             throws NamingException
     {

         if ( base.size() == 0 )
         {
             boolean isObjectScope = searchCtls.getSearchScope() == SearchControls.OBJECT_SCOPE;

             boolean isSearchAll = ( ( PresenceNode ) filter ).getAttribute().equalsIgnoreCase( "objectclass" );

             /*
              * if basedn is "", filter is "(objectclass=*)" and scope is object
              * then we have a request for the rootDSE
              */
             if ( filter instanceof PresenceNode && isObjectScope && isSearchAll )
             {
                 Attributes attrs = ( Attributes ) getRootDSE().clone();

                 String[] ids = searchCtls.getReturningAttributes();

                 if ( ids != null && ids.length > 0 )
                 {
                     boolean doSwap = true;

                     Attributes askedFor = new LockableAttributesImpl();

                     for ( int ii = 0; ii < ids.length; ii++ )
                     {
                         if ( ids[ii].trim().equals( "*" ) )
                         {
                             doSwap = false;

                             break;
                         }

                         if ( attrs.get( ids[ii] ) != null )
                         {
                             askedFor.put( attrs.get( ids[ii] ) );
                         }
                     }

                     if ( doSwap )
                     {
                         attrs = askedFor;
                     }
                 }

                 SearchResult result = new SearchResult( "", null, attrs, false );

                 return new SingletonEnumeration( result );
             }

             throw new LdapNameNotFoundException();
         }

         ContextPartition backend = getBackend( base );

         return backend.search( base, env, filter, searchCtls );
     }


     /**
      * @see ContextPartition#lookup(javax.naming.Name)
      */
     public Attributes lookup( Name dn )  throws NamingException
     {
         if ( dn.size() == 0 )
         {
             LockableAttributes retval = ( LockableAttributes ) rootDSE.clone();

             retval.setLocked( true );

             return retval;
         }

         ContextPartition backend = getBackend( dn );

         return backend.lookup( dn );
     }


     /**
      * @see org.apache.ldap.server.partition.ContextPartition#lookup(javax.naming.Name, String[])
      */
     public Attributes lookup( Name dn, String[] attrIds )  throws NamingException
     {
         if ( dn.size() == 0 )
         {
             LockableAttributes retval = new LockableAttributesImpl();

             NamingEnumeration list = rootDSE.getIDs();

             while ( list.hasMore() )
             {
                 String id = ( String ) list.next();

                 Attribute attr = rootDSE.get( id );

                 retval.put( ( Attribute ) attr.clone() );
             }

             retval.setLocked( true );

             return retval;
         }

         ContextPartition backend = getBackend( dn );

         return backend.lookup( dn, attrIds );
     }


     /**
      * @see ContextPartition#hasEntry(javax.naming.Name)
      */
     public boolean hasEntry( Name dn ) throws NamingException
     {
         if ( dn.size() == 0 )
         {
             return true;
         }

         ContextPartition backend = getBackend( dn );

         return backend.hasEntry( dn );
     }


     /**
      * @see ContextPartition#isSuffix(javax.naming.Name)
      */
     public boolean isSuffix( Name dn )
     {
         return partitions.containsKey( dn.toString() );
     }


     /**
      * @see ContextPartition#modifyRn(Name, String, boolean)
      */
     public void modifyRn( Name dn, String newRdn, boolean deleteOldRdn ) throws NamingException
     {
         ContextPartition backend = getBackend( dn );

         backend.modifyRn( dn, newRdn, deleteOldRdn );
     }


     /**
      * @see ContextPartition#move(Name, Name)
      */
     public void move( Name oriChildName, Name newParentName ) throws NamingException
     {
         ContextPartition backend = getBackend( oriChildName );

         backend.move( oriChildName, newParentName );
     }


     /**
      * @see ContextPartition#move(javax.naming.Name,
      * javax.naming.Name, java.lang.String, boolean)
      */
     public void move( Name oldChildDn, Name newParentDn, String newRdn,
         boolean deleteOldRdn ) throws NamingException
     {
         ContextPartition backend = getBackend( oldChildDn );

         backend.move( oldChildDn, newParentDn, newRdn, deleteOldRdn );
     }


     // ------------------------------------------------------------------------
     // Private Methods
     // ------------------------------------------------------------------------


     /**
      * Gets the backend partition associated with a normalized dn.
      *
      * @param dn the normalized distinguished name to resolve to a backend
      * @return the backend partition associated with the normalized dn
      * @throws NamingException if the name cannot be resolved to a backend
      */
     private ContextPartition getBackend( Name dn ) throws NamingException
     {
         Name clonedDn = ( Name ) dn.clone();

         while ( clonedDn.size() > 0 )
         {
             if ( partitions.containsKey( clonedDn.toString() ) )
             {
                 return ( ContextPartition ) partitions.get( clonedDn.toString() );
             }

             clonedDn.remove( clonedDn.size() - 1 );
         }

         throw new NameNotFoundException( dn.toString() );
     }
 }
	/*
	* Copyright 2004 The Apache Software Foundation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/
	package org.apache.ldap.server.partition;


	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import javax.naming.ConfigurationException;
	import javax.naming.Name;
	import javax.naming.NameNotFoundException;
	import javax.naming.NamingEnumeration;
	import javax.naming.NamingException;
	import javax.naming.directory.Attribute;
	import javax.naming.directory.Attributes;
	import javax.naming.directory.BasicAttribute;
	import javax.naming.directory.BasicAttributes;
	import javax.naming.directory.ModificationItem;
	import javax.naming.directory.SearchControls;
	import javax.naming.directory.SearchResult;
	import javax.naming.ldap.LdapContext;

	import org.apache.ldap.common.MultiException;
	import org.apache.ldap.common.NotImplementedException;
	import org.apache.ldap.common.exception.LdapNameNotFoundException;
	import org.apache.ldap.common.filter.ExprNode;
	import org.apache.ldap.common.filter.PresenceNode;
	import org.apache.ldap.common.message.LockableAttributeImpl;
	import org.apache.ldap.common.message.LockableAttributes;
	import org.apache.ldap.common.message.LockableAttributesImpl;
	import org.apache.ldap.common.name.LdapName;
	import org.apache.ldap.common.util.DateUtils;
	import org.apache.ldap.common.util.NamespaceTools;
	import org.apache.ldap.common.util.SingletonEnumeration;
	import org.apache.ldap.server.configuration.ContextPartitionConfiguration;
	import org.apache.ldap.server.configuration.MutableContextPartitionConfiguration;
	import org.apache.ldap.server.jndi.ContextFactoryConfiguration;
	import org.apache.ldap.server.partition.impl.btree.jdbm.JdbmContextPartition;


	/**
	* A nexus for partitions dedicated for storing entries specific to a naming
	* context.
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	* @version $Rev$
	*/
	public class DefaultContextPartitionNexus extends ContextPartitionNexus
	{
	/** the vendorName string proudly set to: Apache Software Foundation*/
	private static final String ASF = "Apache Software Foundation";

	/** the vendorName DSE operational attribute */
	private static final String VENDORNAME_ATTR = "vendorName";

	/** the namingContexts DSE operational attribute */
	private static final String NAMINGCTXS_ATTR = "namingContexts";

	/** the closed state of this partition */
	private boolean initialized;

	/** the system backend */
	private ContextPartition system;

	/** the backends keyed by normalized suffix strings */
	private HashMap partitions = new HashMap();

	/** the read only rootDSE attributes */
	private final Attributes rootDSE;


	/**
	* Creates the root nexus singleton of the entire system. The root DSE has
	* several attributes that are injected into it besides those that may
	* already exist. As partitions are added to the system more namingContexts
	* attributes are added to the rootDSE.
	*
	* @see <a href="http://www.faqs.org/rfcs/rfc3045.html">Vendor Information</a>
	*/
	public DefaultContextPartitionNexus( Attributes rootDSE )
	{
	// setup that root DSE
	this.rootDSE = rootDSE;
	Attribute attr = new LockableAttributeImpl( "subschemaSubentry" );
	attr.add( "cn=schema,ou=system" );
	rootDSE.put( attr );

	attr = new LockableAttributeImpl( "supportedLDAPVersion" );
	rootDSE.put( attr );
	attr.add( "3" );

	attr = new LockableAttributeImpl( "objectClass" );
	rootDSE.put( attr );
	attr.add( "top" );
	attr.add( "extensibleObject" );

	attr = new LockableAttributeImpl( NAMINGCTXS_ATTR );
	rootDSE.put( attr );

	attr = new LockableAttributeImpl( VENDORNAME_ATTR );
	attr.add( ASF );
	rootDSE.put( attr );
	}


	public void init( ContextFactoryConfiguration factoryCfg, ContextPartitionConfiguration cfg ) throws NamingException
	{
	// NOTE: We ignore ContextPartitionConfiguration parameter here.
	if( initialized )
	{
	return;
	}

	List initializedPartitions = new ArrayList();
	initializeSystemPartition( factoryCfg );
	initializedPartitions.add( system );

	Iterator i = factoryCfg.getStartupConfiguration().getContextPartitionConfigurations().iterator();
	try
	{
	while( i.hasNext() )
	{
	cfg = ( ContextPartitionConfiguration ) i.next();
	ContextPartition partition = cfg.getContextPartition();

	// Turn on default indices
	MutableContextPartitionConfiguration mcfg =
	new MutableContextPartitionConfiguration();
	mcfg.setName( cfg.getName() );
	mcfg.setSuffix( cfg.getSuffix() );
	mcfg.setContextEntry( cfg.getContextEntry() );
	mcfg.setContextPartition( partition );

	Set indexedAttrs = cfg.getIndexedAttributes();
	indexedAttrs.add( Oid.ALIAS );
	indexedAttrs.add( Oid.EXISTANCE );
	indexedAttrs.add( Oid.HIERARCHY );
	indexedAttrs.add( Oid.NDN );
	indexedAttrs.add( Oid.ONEALIAS );
	indexedAttrs.add( Oid.SUBALIAS );
	indexedAttrs.add( Oid.UPDN );
	mcfg.setIndexedAttributes( indexedAttrs );

	partition.init( factoryCfg, mcfg );
	initializedPartitions.add( 0, partition );
	register( partition );
	}
	initialized = true;
	}
	finally
	{
	if( !initialized )
	{
	i = initializedPartitions.iterator();
	while( i.hasNext() )
	{
	ContextPartition partition = ( ContextPartition ) i.next();
	i.remove();
	try
	{
	partition.destroy();
	}
	catch( Exception e )
	{
	e.printStackTrace();
	}
	finally
	{
	unregister( partition );
	}
	}
	}
	}
	}


	private void initializeSystemPartition( ContextFactoryConfiguration factoryCfg ) throws NamingException
	{
	// initialize system partition first
	MutableContextPartitionConfiguration systemCfg = new MutableContextPartitionConfiguration();
	system = new JdbmContextPartition(); // using default implementation.
	systemCfg.setName( "system" );
	systemCfg.setSuffix( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX );
	systemCfg.setContextPartition( system );

	// Add indexed attributes for system partition
	Set indexedSystemAttrs = new HashSet();
	indexedSystemAttrs.add( Oid.ALIAS );
	indexedSystemAttrs.add( Oid.EXISTANCE );
	indexedSystemAttrs.add( Oid.HIERARCHY );
	indexedSystemAttrs.add( Oid.NDN );
	indexedSystemAttrs.add( Oid.ONEALIAS );
	indexedSystemAttrs.add( Oid.SUBALIAS );
	indexedSystemAttrs.add( Oid.UPDN );
	systemCfg.setIndexedAttributes( indexedSystemAttrs );

	// Add context entry for system partition
	Attributes systemEntry = new BasicAttributes();
	Attribute objectClassAttr = new BasicAttribute( "objectClass" );
	objectClassAttr.add( "top" );
	objectClassAttr.add( "organizationalUnit" );
	systemEntry.put( objectClassAttr );
	systemEntry.put( "creatorsName", ContextPartitionNexus.ADMIN_PRINCIPAL ) ;
	systemEntry.put( "createTimestamp", DateUtils.getGeneralizedTime() ) ;
	systemEntry.put(
	NamespaceTools.getRdnAttribute( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX ),
	NamespaceTools.getRdnValue( ContextPartitionNexus.SYSTEM_PARTITION_SUFFIX ) ) ;
	systemCfg.setContextEntry( systemEntry );

	system.init( factoryCfg, systemCfg );
	register( system );
	}


	public boolean isInitialized()
	{
	return initialized;
	}


	public synchronized void destroy()
	{
	if ( !initialized )
	{
	return;
	}

	MultiException error = null;

	Iterator list = this.partitions.values().iterator();

	// make sure this loop is not fail fast so all backing stores can
	// have an attempt at closing down and synching their cached entries
	while ( list.hasNext() )
	{
	ContextPartition partition = ( ContextPartition ) list.next();

	try
	{
	partition.sync();
	partition.destroy();
	}
	catch ( NamingException e )
	{
	e.printStackTrace();

	if ( error == null )
	{
	error = new MultiException( "Grouping many exceptions on root nexus close()" );
	}

	// @todo really need to send this info to a monitor
	error.addThrowable( e );
	}
	}

	initialized = false;

	if ( error != null )
	{
	String msg = "Encountered failures while performing a close() operation on backing stores";

	NamingException total = new NamingException( msg );

	total.setRootCause( error );
	total.printStackTrace();
	}
	}


	/**
	* @see ContextPartition#sync()
	*/
	public void sync() throws NamingException
	{
	MultiException error = null;

	Iterator list = this.partitions.values().iterator();

	while ( list.hasNext() )
	{
	ContextPartition store = ( ContextPartition ) list.next();

	try
	{
	store.sync();
	}
	catch ( NamingException e )
	{
	e.printStackTrace();

	if ( error == null )
	{
	error = new MultiException( "Grouping many exceptions on root nexus sync()" );
	}

	// @todo really need to send this info to a monitor
	error.addThrowable( e );
	}
	}

	if ( error != null )
	{
	String msg = "Encountered failures while performing a sync() operation on backing stores";

	NamingException total = new NamingException( msg );

	total.setRootCause( error );
	}
	}


	// ------------------------------------------------------------------------
	// BackendNexus Interface Method Implementations
	// ------------------------------------------------------------------------


	public ContextPartition getSystemPartition()
	{
	return system;
	}

	/**
	* @see ContextPartitionNexus#getLdapContext()
	*/
	public LdapContext getLdapContext()
	{
	throw new NotImplementedException();
	}


	/**
	* @see ContextPartitionNexus#getMatchedName(javax.naming.Name, boolean)
	*/
	public Name getMatchedName( Name dn, boolean normalized ) throws NamingException
	{
	dn = ( Name ) dn.clone();

	while ( dn.size() > 0 )
	{
	if ( hasEntry( dn ) )
	{
	return dn;
	}

	dn = dn.getSuffix( 1 );
	}

	return dn;
	}


	public Name getSuffix( boolean normalized )
	{
	return new LdapName();
	}


	/**
	* @see org.apache.ldap.server.partition.ContextPartitionNexus#getSuffix(javax.naming.Name, boolean)
	*/
	public Name getSuffix( Name dn, boolean normalized ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	return backend.getSuffix( normalized );
	}


	/**
	* @see org.apache.ldap.server.partition.ContextPartitionNexus#listSuffixes(boolean)
	*/
	public Iterator listSuffixes( boolean normalized ) throws NamingException
	{
	return Collections.unmodifiableSet( partitions.keySet() ).iterator();
	}


	public Attributes getRootDSE()
	{
	return rootDSE;
	}


	/**
	* Registers an ContextPartition with this BackendManager. Called by each
	* ContextPartition implementation after it has started to register for
	* backend operation calls. This method effectively puts the
	* ContextPartition's naming context online.
	*
	* Operations against the naming context should result in an LDAP BUSY
	* result code in the returnValue if the naming context is not online.
	*
	* @param partition ContextPartition component to register with this
	* BackendNexus.
	* @throws ConfigurationException
	*/
	private void register( ContextPartition partition ) throws NamingException
	{
	String key = partition.getSuffix( true ).toString();
	if( partitions.containsKey( key ) )
	{
	throw new ConfigurationException( "Duplicate partition suffix: " + key );
	}
	partitions.put( key, partition );

	Attribute namingContexts = rootDSE.get( NAMINGCTXS_ATTR );
	namingContexts.add( partition.getSuffix( false ).toString() );
	}


	/**
	* Unregisters an ContextPartition with this BackendManager. Called for each
	* registered Backend right befor it is to be stopped. This prevents
	* protocol server requests from reaching the Backend and effectively puts
	* the ContextPartition's naming context offline.
	*
	* Operations against the naming context should result in an LDAP BUSY
	* result code in the returnValue if the naming context is not online.
	*
	* @param partition ContextPartition component to unregister with this
	* BackendNexus.
	*/
	private void unregister( ContextPartition partition ) throws NamingException
	{
	Attribute namingContexts = rootDSE.get( NAMINGCTXS_ATTR );
	namingContexts.remove( partition.getSuffix( false ).toString() );
	partitions.remove( partition.getSuffix( true ).toString() );
	}


	// ------------------------------------------------------------------------
	// Backend Interface Method Implementations
	// ------------------------------------------------------------------------


	/**
	* @see ContextPartition#delete(javax.naming.Name)
	*/
	public void delete( Name dn ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	backend.delete( dn );
	}


	/**
	* Looks up the backend corresponding to the entry first, then checks to
	* see if the entry already exists. If so an exception is thrown. If not
	* the add operation against the backend proceeds. This check is performed
	* here so backend implementors do not have to worry about performing these
	* kinds of checks.
	*
	* @see org.apache.ldap.server.partition.ContextPartition#add(String, Name, Attributes)
	*/
	public void add( String updn, Name dn, Attributes an_entry ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	backend.add( updn, dn, an_entry );
	}


	/**
	* @see ContextPartition#modify(Name, int,Attributes)
	*/
	public void modify( Name dn, int modOp, Attributes mods ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	backend.modify( dn, modOp, mods );
	}


	/**
	* @see ContextPartition#modify(javax.naming.Name,
	* javax.naming.directory.ModificationItem[])
	*/
	public void modify( Name dn, ModificationItem[] mods ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	backend.modify( dn, mods );
	}


	/**
	* @see ContextPartition#list(javax.naming.Name)
	*/
	public NamingEnumeration list( Name base ) throws NamingException
	{
	ContextPartition backend = getBackend( base );

	return backend.list( base );
	}


	/**
	* @see ContextPartition#search(Name, Map, ExprNode, SearchControls)
	*/
	public NamingEnumeration search( Name base, Map env, ExprNode filter, SearchControls searchCtls )
	throws NamingException
	{

	if ( base.size() == 0 )
	{
	boolean isObjectScope = searchCtls.getSearchScope() == SearchControls.OBJECT_SCOPE;

	boolean isSearchAll = ( ( PresenceNode ) filter ).getAttribute().equalsIgnoreCase( "objectclass" );

	/*
	* if basedn is "", filter is "(objectclass=*)" and scope is object
	* then we have a request for the rootDSE
	*/
	if ( filter instanceof PresenceNode && isObjectScope && isSearchAll )
	{
	Attributes attrs = ( Attributes ) getRootDSE().clone();

	String[] ids = searchCtls.getReturningAttributes();

	if ( ids != null && ids.length > 0 )
	{
	boolean doSwap = true;

	Attributes askedFor = new LockableAttributesImpl();

	for ( int ii = 0; ii < ids.length; ii++ )
	{
	if ( ids[ii].trim().equals( "*" ) )
	{
	doSwap = false;

	break;
	}

	if ( attrs.get( ids[ii] ) != null )
	{
	askedFor.put( attrs.get( ids[ii] ) );
	}
	}

	if ( doSwap )
	{
	attrs = askedFor;
	}
	}

	SearchResult result = new SearchResult( "", null, attrs, false );

	return new SingletonEnumeration( result );
	}

	throw new LdapNameNotFoundException();
	}

	ContextPartition backend = getBackend( base );

	return backend.search( base, env, filter, searchCtls );
	}


	/**
	* @see ContextPartition#lookup(javax.naming.Name)
	*/
	public Attributes lookup( Name dn ) throws NamingException
	{
	if ( dn.size() == 0 )
	{
	LockableAttributes retval = ( LockableAttributes ) rootDSE.clone();

	retval.setLocked( true );

	return retval;
	}

	ContextPartition backend = getBackend( dn );

	return backend.lookup( dn );
	}


	/**
	* @see org.apache.ldap.server.partition.ContextPartition#lookup(javax.naming.Name, String[])
	*/
	public Attributes lookup( Name dn, String[] attrIds ) throws NamingException
	{
	if ( dn.size() == 0 )
	{
	LockableAttributes retval = new LockableAttributesImpl();

	NamingEnumeration list = rootDSE.getIDs();

	while ( list.hasMore() )
	{
	String id = ( String ) list.next();

	Attribute attr = rootDSE.get( id );

	retval.put( ( Attribute ) attr.clone() );
	}

	retval.setLocked( true );

	return retval;
	}

	ContextPartition backend = getBackend( dn );

	return backend.lookup( dn, attrIds );
	}


	/**
	* @see ContextPartition#hasEntry(javax.naming.Name)
	*/
	public boolean hasEntry( Name dn ) throws NamingException
	{
	if ( dn.size() == 0 )
	{
	return true;
	}

	ContextPartition backend = getBackend( dn );

	return backend.hasEntry( dn );
	}


	/**
	* @see ContextPartition#isSuffix(javax.naming.Name)
	*/
	public boolean isSuffix( Name dn )
	{
	return partitions.containsKey( dn.toString() );
	}


	/**
	* @see ContextPartition#modifyRn(Name, String, boolean)
	*/
	public void modifyRn( Name dn, String newRdn, boolean deleteOldRdn ) throws NamingException
	{
	ContextPartition backend = getBackend( dn );

	backend.modifyRn( dn, newRdn, deleteOldRdn );
	}


	/**
	* @see ContextPartition#move(Name, Name)
	*/
	public void move( Name oriChildName, Name newParentName ) throws NamingException
	{
	ContextPartition backend = getBackend( oriChildName );

	backend.move( oriChildName, newParentName );
	}


	/**
	* @see ContextPartition#move(javax.naming.Name,
	* javax.naming.Name, java.lang.String, boolean)
	*/
	public void move( Name oldChildDn, Name newParentDn, String newRdn,
	boolean deleteOldRdn ) throws NamingException
	{
	ContextPartition backend = getBackend( oldChildDn );

	backend.move( oldChildDn, newParentDn, newRdn, deleteOldRdn );
	}


	// ------------------------------------------------------------------------
	// Private Methods
	// ------------------------------------------------------------------------


	/**
	* Gets the backend partition associated with a normalized dn.
	*
	* @param dn the normalized distinguished name to resolve to a backend
	* @return the backend partition associated with the normalized dn
	* @throws NamingException if the name cannot be resolved to a backend
	*/
	private ContextPartition getBackend( Name dn ) throws NamingException
	{
	Name clonedDn = ( Name ) dn.clone();

	while ( clonedDn.size() > 0 )
	{
	if ( partitions.containsKey( clonedDn.toString() ) )
	{
	return ( ContextPartition ) partitions.get( clonedDn.toString() );
	}

	clonedDn.remove( clonedDn.size() - 1 );
	}

	throw new NameNotFoundException( dn.toString() );
	}
	}