*  Licensed to the Apache Software Foundation (ASF) under one

*  or more contributor license agreements.  See the NOTICE file

*  distributed with this work for additional information

*  regarding copyright ownership.  The ASF licenses this file

*  to you 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.

*

*/

* Base implementation of {@link DirectoryService}.

* This is a copy of org.apache.directory.server.core.DefaultDirectoryService

* created to make showSecurityWarnings protected.  This can be removed

* when http://svn.apache.org/r1546144 in ApacheDS 2.0.0-M16 is available.

*

* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>

*/

  /** The logger */

  private static final Logger LOG = LoggerFactory.getLogger( BaseDirectoryService.class );

  private SchemaPartition schemaPartition;

  /** A reference on the SchemaManager */

  private SchemaManager schemaManager;

  /** The LDAP Codec Service */

  private LdapApiService ldapCodecService = LdapApiServiceFactory.getSingleton();

  /** the root nexus */

  private DefaultPartitionNexus partitionNexus;

  /** whether or not server is started for the first time */

  private boolean firstStart;

  /** whether or not this instance has been shutdown */

  private boolean started;

  /** the change log service */

  private ChangeLog changeLog;

  /** the journal service */

  private Journal journal;

  /**

   * the interface used to perform various operations on this

   * DirectoryService

   */

  private OperationManager operationManager = new DefaultOperationManager( this );

  /** the distinguished name of the administrative user */

  private Dn adminDn;

  /** session used as admin for internal operations */

  private CoreSession adminSession;

  /** The referral manager */

  private ReferralManager referralManager;

  /** A flag to tell if the userPassword attribute's value must be hidden */

  private boolean passwordHidden = false;

  /** The service's CSN factory */

  private CsnFactory csnFactory;

  /** The directory instance replication ID */

  private int replicaId;

  /** remove me after implementation is completed */

  private static final String PARTIAL_IMPL_WARNING =

      "WARNING: the changelog is only partially operational and will revert\n" +

          "state without consideration of who made the original change.  All reverting " +

          "changes are made by the admin user.\n Furthermore the used controls are not at " +

          "all taken into account";

  /** The delay to wait between each sync on disk */

  private long syncPeriodMillis;

  /** The default delay to wait between sync on disk : 15 seconds */

  private static final long DEFAULT_SYNC_PERIOD = 15000;

  /** */

  private Thread workerThread;

  /** The default timeLimit : 100 entries */

  public static final int MAX_SIZE_LIMIT_DEFAULT = 100;

  /** The default timeLimit : 10 seconds */

  public static final int MAX_TIME_LIMIT_DEFAULT = 10000;

  /** The instance Id */

  private String instanceId;

  /** The server directory layout*/

  private InstanceLayout instanceLayout;

  /**

   * A flag used to shutdown the VM when stopping the server. Useful

   * when the server is standalone. If the server is embedded, we don't

   * want to shutdown the VM

   */

  private boolean exitVmOnShutdown = true; // allow by default

  /** A flag used to indicate that a shutdown hook has been installed */

  private boolean shutdownHookEnabled = true; // allow by default

  /** Manage anonymous access to entries other than the RootDSE */

  private boolean allowAnonymousAccess = false; // forbid by default

  /** Manage the basic access control checks */

  private boolean accessControlEnabled; // off by default

  /** Manage the operational attributes denormalization */

  private boolean denormalizeOpAttrsEnabled; // off by default

  /** The list of declared interceptors */

  private List<Interceptor> interceptors;

  private Map<String, Interceptor> interceptorNames;

  /** A lock to protect the interceptors List */

  private ReadWriteLock interceptorsLock = new ReentrantReadWriteLock();

  /** The read and write locks */

  private Lock readLock = interceptorsLock.readLock();

  private Lock writeLock = interceptorsLock.writeLock();

  /** A map associating a list of interceptor to each operation */

  private Map<OperationEnum, List<String>> operationInterceptors;

  /** The System partition */

  private Partition systemPartition;

  /** The set of all declared partitions */

  private Set<Partition> partitions = new HashSet<Partition>();

  /** A list of LDIF entries to inject at startup */

  private List<? extends LdifEntry> testEntries = new ArrayList<LdifEntry>(); // List<Attributes>

  /** The event service */

  private EventService eventService;

  /** The maximum size for an incoming PDU */

  private int maxPDUSize = Integer.MAX_VALUE;

  /** the value of last successful add/update operation's CSN */

  private String contextCsn;

  /** lock file for directory service's working directory */

  private RandomAccessFile lockFile = null;

  private static final String LOCK_FILE_NAME = ".dirservice.lock";

  /** the ehcache based cache service */

  private CacheService cacheService;

  /** The AccessControl AdministrativePoint cache */

  private DnNode<AccessControlAdministrativePoint> accessControlAPCache;

  /** The CollectiveAttribute AdministrativePoint cache */

  private DnNode<CollectiveAttributeAdministrativePoint> collectiveAttributeAPCache;

  /** The Subschema AdministrativePoint cache */

  private DnNode<SubschemaAdministrativePoint> subschemaAPCache;

  /** The TriggerExecution AdministrativePoint cache */

  private DnNode<TriggerExecutionAdministrativePoint> triggerExecutionAPCache;

  /** The Dn factory */

  private DnFactory dnFactory;

  /** The Subentry cache */

  SubentryCache subentryCache = new SubentryCache();

  /** The Subtree evaluator instance */

  private SubtreeEvaluator evaluator;

  // ------------------------------------------------------------------------

  // Constructor

  // ------------------------------------------------------------------------

  /**

   * Creates a new instance of the directory service.

   */

  public BaseDirectoryService() throws Exception

  {

    changeLog = new DefaultChangeLog();

    journal = new DefaultJournal();

    syncPeriodMillis = DEFAULT_SYNC_PERIOD;

    csnFactory = new CsnFactory( replicaId );

    evaluator = new SubtreeEvaluator( schemaManager );

    setDefaultInterceptorConfigurations();

  }

  // ------------------------------------------------------------------------

  // C O N F I G U R A T I O N   M E T H O D S

  // ------------------------------------------------------------------------

  public void setInstanceId( String instanceId )

  {

    this.instanceId = instanceId;

  }

  public String getInstanceId()

  {

    return instanceId;

  }

  /**

   * Gets the {@link Partition}s used by this DirectoryService.

   *

   * @return the set of partitions used

   */

  public Set<? extends Partition> getPartitions()

  {

    Set<Partition> cloned = new HashSet<Partition>();

    cloned.addAll( partitions );

    return cloned;

  }

  /**

   * Sets {@link Partition}s used by this DirectoryService.

   *

   * @param partitions the partitions to used

   */

  public void setPartitions( Set<? extends Partition> partitions )

  {

    Set<Partition> cloned = new HashSet<Partition>();

    cloned.addAll( partitions );

    Set<String> names = new HashSet<String>();

    for ( Partition partition : cloned )

    {

      String id = partition.getId();

      if ( names.contains( id ) )

      {

        LOG.warn( "Encountered duplicate partition {} identifier.", id );

      }

      names.add( id );

    }

    this.partitions = cloned;

  }

  /**

   * Returns <tt>true</tt> if access control checks are enabled.

   *

   * @return true if access control checks are enabled, false otherwise

   */

  public boolean isAccessControlEnabled()

  {

    return accessControlEnabled;

  }

  /**

   * Sets whether to enable basic access control checks or not.

   *

   * @param accessControlEnabled true to enable access control checks, false otherwise

   */

  public void setAccessControlEnabled( boolean accessControlEnabled )

  {

    this.accessControlEnabled = accessControlEnabled;

  }

  /**

   * Returns <tt>true</tt> if anonymous access is allowed on entries besides the RootDSE.

   * If the access control subsystem is enabled then access to some entries may not be

   * allowed even when full anonymous access is enabled.

   *

   * @return true if anonymous access is allowed on entries besides the RootDSE, false

   * if anonymous access is allowed to all entries.

   */

  public boolean isAllowAnonymousAccess()

  {

    return allowAnonymousAccess;

  }

  /**

   * Sets whether to allow anonymous access to entries other than the RootDSE.  If the

   * access control subsystem is enabled then access to some entries may not be allowed

   * even when full anonymous access is enabled.

   *

   * @param enableAnonymousAccess true to enable anonymous access, false to disable it

   */

  public void setAllowAnonymousAccess( boolean enableAnonymousAccess )

  {

    this.allowAnonymousAccess = enableAnonymousAccess;

  }

  /**

   * Returns interceptors in the server.

   *

   * @return the interceptors in the server.

   */

  public List<Interceptor> getInterceptors()

  {

    List<Interceptor> cloned = new ArrayList<Interceptor>();

    readLock.lock();

    try

    {

      cloned.addAll( interceptors );

      return cloned;

    }

    finally

    {

      readLock.unlock();

    }

  }

  /**

   * Returns interceptors in the server for a given operation.

   *

   * @return the interceptors in the server for the given operation.

   */

  public List<String> getInterceptors( OperationEnum operation )

  {

    List<String> cloned = new ArrayList<String>();

    readLock.lock();

    try

    {

      cloned.addAll( operationInterceptors.get( operation ) );

      return cloned;

    }

    finally

    {

      readLock.unlock();

    }

  }

  /**

   * Compute the list of  to call for each operation

   */

  private void initOperationsList()

  {

    writeLock.lock();

    try

    {

      operationInterceptors = new ConcurrentHashMap<OperationEnum, List<String>>();

      for ( OperationEnum operation : OperationEnum.getOperations() )

      {

        List<String> operationList = new ArrayList<String>();

        for ( Interceptor interceptor : interceptors )

        {

          gatherInterceptors( interceptor, interceptor.getClass(), operation, operationList );

        }

        operationInterceptors.put( operation, operationList );

      }

    }

    finally

    {

      writeLock.unlock();

    }

  }

  /**

   * Recursively checks if the given interceptor can be added to the list of interceptors for a given

   * operation and adds to the list of interceptors if it implements the respective operation

   *

   * @param interceptor the instance of the interceptor

   * @param interceptorClz the class of the interceptor

   * @param operation type of operation

   * @param selectedInterceptorList the list of selected interceptors

   */

  private void gatherInterceptors( Interceptor interceptor, Class<?> interceptorClz, OperationEnum operation,

                                   List<String> selectedInterceptorList )

  {

    // We stop recursing when we reach the Base class

    if ( ( interceptorClz == null ) || ( interceptorClz == BaseInterceptor.class ) )

    {

      return;

    }

    // We don't call getMethods() because it would get back the default methods

    // from the BaseInterceptor, something we don't want.

    Method[] methods = interceptorClz.getDeclaredMethods();

    for ( Method method : methods )

    {

      Class<?>[] param = method.getParameterTypes();

      boolean hasCorrestSig = false;

      // check for the correct signature

      if ( ( param == null ) || ( param.length > 1 ) || ( param.length == 0 ) )

      {

        continue;

      }

      if ( OperationContext.class.isAssignableFrom( param[0] ) )

      {

        hasCorrestSig = true;

      }

      else

      {

        continue;

      }

      if ( hasCorrestSig && method.getName().equals( operation.getMethodName() ) )

      {

        if ( !selectedInterceptorList.contains( interceptor.getName() ) )

        {

          selectedInterceptorList.add( interceptor.getName() );

        }

        break;

      }

    }

    // Recurse on extended classes, as we have used getDeclaredMethods() instead of getmethods()

    gatherInterceptors( interceptor, interceptorClz.getSuperclass(), operation, selectedInterceptorList );

  }

  /**

   * Add an interceptor to the list of interceptors to call for each operation

   * @throws LdapException

   */

  private void addInterceptor( Interceptor interceptor, int position ) throws LdapException

  {

    // First, init the interceptor

    interceptor.init( this );

    writeLock.lock();

    try

    {

      for ( OperationEnum operation : OperationEnum.getOperations() )

      {

        List<String> operationList = operationInterceptors.get( operation );

        Method[] methods = interceptor.getClass().getDeclaredMethods();

        for ( Method method : methods )

        {

          if ( method.getName().equals( operation.getMethodName() ) )

          {

            if ( position == -1 )

            {

              operationList.add( interceptor.getName() );

            }

            else

            {

              operationList.add( position, interceptor.getName() );

            }

            break;

          }

        }

      }

      interceptorNames.put( interceptor.getName(), interceptor );

      if ( position == -1 )

      {

        interceptors.add( interceptor );

      }

      else

      {

        interceptors.add( position, interceptor );

      }

    }

    finally

    {

      writeLock.unlock();

    }

  }

  /**

   * Remove an interceptor to the list of interceptors to call for each operation

   */

  private void removeOperationsList( String interceptorName )

  {

    Interceptor interceptor = interceptorNames.get( interceptorName );

    writeLock.lock();

    try

    {

      for ( OperationEnum operation : OperationEnum.getOperations() )

      {

        List<String> operationList = operationInterceptors.get( operation );

        Method[] methods = interceptor.getClass().getDeclaredMethods();

        for ( Method method : methods )

        {

          if ( method.getName().equals( operation.getMethodName() ) )

          {

            operationList.remove( interceptor.getName() );

            break;

          }

        }

      }

      interceptorNames.remove( interceptorName );

      interceptors.remove( interceptor );

    }

    finally

    {

      writeLock.unlock();

    }

  }

  /**

   * Sets the interceptors in the server.

   *

   * @param interceptors the interceptors to be used in the server.

   */

  public void setInterceptors( List<Interceptor> interceptors )

  {

    Map<String, Interceptor> interceptorNames = new HashMap<String, Interceptor>();

    // Check if we don't have duplicate names in the interceptors list

    for ( Interceptor interceptor : interceptors )

    {

      if ( interceptorNames.containsKey( interceptor.getName() ) )

      {

        LOG.warn( "Encountered duplicate definitions for {} interceptor", interceptor.getName() );

        continue;

      }

      interceptorNames.put( interceptor.getName(), interceptor );

    }

    this.interceptors = interceptors;

    this.interceptorNames = interceptorNames;

    // Now update the Map that connect each operation with the list of interceptors.

    initOperationsList();

  }

  /**

   * Initialize the interceptors

   */

  private void initInterceptors() throws LdapException

  {

    for ( Interceptor interceptor : interceptors )

    {

      interceptor.init( this );

    }

  }

  /**

   * Returns test directory entries({@link LdifEntry}) to be loaded while

   * bootstrapping.

   *

   * @return test entries to load during bootstrapping

   */

  public List<LdifEntry> getTestEntries()

  {

    List<LdifEntry> cloned = new ArrayList<LdifEntry>();

    cloned.addAll( testEntries );

    return cloned;

  }

  /**

   * Sets test directory entries({@link javax.naming.directory.Attributes}) to be loaded while

   * bootstrapping.

   *

   * @param testEntries the test entries to load while bootstrapping

   */

  public void setTestEntries( List<? extends LdifEntry> testEntries )

  {

    //noinspection MismatchedQueryAndUpdateOfCollection

    List<LdifEntry> cloned = new ArrayList<LdifEntry>();

    cloned.addAll( testEntries );

    this.testEntries = testEntries;

  }

  /**

   * {@inheritDoc}

   */

  public InstanceLayout getInstanceLayout()

  {

    return instanceLayout;

  }

  /**

   * {@inheritDoc}

   */

  public void setInstanceLayout( InstanceLayout instanceLayout ) throws IOException

  {

    this.instanceLayout = instanceLayout;

    // Create the directories if they are missing

    if ( !instanceLayout.getInstanceDirectory().exists() )

    {

      if ( !instanceLayout.getInstanceDirectory().mkdirs() )

      {

        throw new IOException( I18n.err( I18n.ERR_112_COULD_NOT_CREATE_DIRECORY,

            instanceLayout.getInstanceDirectory() ) );

      }

    }

    if ( !instanceLayout.getLogDirectory().exists() )

    {

      if ( !instanceLayout.getLogDirectory().mkdirs() )

      {

        throw new IOException( I18n.err( I18n.ERR_112_COULD_NOT_CREATE_DIRECORY,

            instanceLayout.getLogDirectory() ) );

      }

    }

    if ( !instanceLayout.getRunDirectory().exists() )

    {

      if ( !instanceLayout.getRunDirectory().mkdirs() )

      {

        throw new IOException( I18n.err( I18n.ERR_112_COULD_NOT_CREATE_DIRECORY,

            instanceLayout.getRunDirectory() ) );

      }

    }

    if ( !instanceLayout.getPartitionsDirectory().exists() )

    {

      if ( !instanceLayout.getPartitionsDirectory().mkdirs() )

      {

        throw new IOException( I18n.err( I18n.ERR_112_COULD_NOT_CREATE_DIRECORY,

            instanceLayout.getPartitionsDirectory() ) );

      }

    }

    if ( !instanceLayout.getConfDirectory().exists() )

    {

      if ( !instanceLayout.getConfDirectory().mkdirs() )

      {

        throw new IOException( I18n.err( I18n.ERR_112_COULD_NOT_CREATE_DIRECORY,

            instanceLayout.getConfDirectory() ) );

      }

    }

  }

  public void setShutdownHookEnabled( boolean shutdownHookEnabled )

  {

    this.shutdownHookEnabled = shutdownHookEnabled;

  }

  public boolean isShutdownHookEnabled()

  {

    return shutdownHookEnabled;

  }

  public void setExitVmOnShutdown( boolean exitVmOnShutdown )

  {

    this.exitVmOnShutdown = exitVmOnShutdown;

  }

  public boolean isExitVmOnShutdown()

  {

    return exitVmOnShutdown;

  }

  public void setSystemPartition( Partition systemPartition )

  {

    this.systemPartition = systemPartition;

  }

  public Partition getSystemPartition()

  {

    return systemPartition;

  }

  /**

   * return true if the operational attributes must be normalized when returned

   */

  public boolean isDenormalizeOpAttrsEnabled()

  {

    return denormalizeOpAttrsEnabled;

  }

  /**

   * Sets whether the operational attributes are denormalized when returned

   * @param denormalizeOpAttrsEnabled The flag value

   */

  public void setDenormalizeOpAttrsEnabled( boolean denormalizeOpAttrsEnabled )

  {

    this.denormalizeOpAttrsEnabled = denormalizeOpAttrsEnabled;

  }

  /**

   * {@inheritDoc}

   */

  public ChangeLog getChangeLog()

  {

    return changeLog;

  }

  /**

   * {@inheritDoc}

   */

  public Journal getJournal()

  {

    return journal;

  }

  /**

   * {@inheritDoc}

   */

  public void setChangeLog( ChangeLog changeLog )

  {

    this.changeLog = changeLog;

  }

  /**

   * {@inheritDoc}

   */

  public void setJournal( Journal journal )

  {

    this.journal = journal;

  }

  public void addPartition( Partition partition ) throws Exception

  {

    partition.setSchemaManager( schemaManager );

    try

    {

      // can be null when called before starting up

      if ( partitionNexus != null )

      {

        partitionNexus.addContextPartition( partition );

      }

    }

    catch ( LdapException le )

    {

      // We've got an exception, we cannot add the partition to the partitions

      throw le;

    }

    // Now, add the partition to the set of managed partitions

    partitions.add( partition );

  }

  public void removePartition( Partition partition ) throws Exception

  {

    // Do the backend cleanup first

    try

    {

      // can be null when called before starting up

      if ( partitionNexus != null )

      {

        partitionNexus.removeContextPartition( partition.getSuffixDn() );

      }

    }

    catch ( LdapException le )

    {

      // Bad ! We can't go any further

      throw le;

    }

    // And update the set of managed partitions

    partitions.remove( partition );

  }

  // ------------------------------------------------------------------------

  // BackendSubsystem Interface Method Implementations

  // ------------------------------------------------------------------------

  /**

   * Define a default list of interceptors that has to be used if no other

   * configuration is defined.

   */

  private void setDefaultInterceptorConfigurations()

  {

    // Set default interceptor chains

    List<Interceptor> list = new ArrayList<Interceptor>();

    list.add( new NormalizationInterceptor() );

    list.add( new AuthenticationInterceptor() );

    list.add( new ReferralInterceptor() );

    list.add( new AciAuthorizationInterceptor() );

    list.add( new DefaultAuthorizationInterceptor() );

    list.add( new AdministrativePointInterceptor() );

    list.add( new ExceptionInterceptor() );

    list.add( new SchemaInterceptor() );

    list.add( new OperationalAttributeInterceptor() );

    list.add( new CollectiveAttributeInterceptor() );

    list.add( new SubentryInterceptor() );

    list.add( new EventInterceptor() );

    list.add( new TriggerInterceptor() );

    list.add( new ChangeLogInterceptor() );

    list.add( new JournalInterceptor() );

    setInterceptors( list );

  }

  public CoreSession getAdminSession()

  {

    return adminSession;

  }

  /**

   * Get back an anonymous session

   */

  public CoreSession getSession()

  {

    return new DefaultCoreSession( new LdapPrincipal( schemaManager ), this );

  }

  /**

   * Get back a session for a given principal

   */

  public CoreSession getSession( LdapPrincipal principal )

  {

    return new DefaultCoreSession( principal, this );

  }

  /**

   * Get back a session for the give user and credentials bound with Simple Bind

   */

  public CoreSession getSession( Dn principalDn, byte[] credentials ) throws LdapException

  {

    synchronized ( this )

    {

      if ( !started )

      {

        throw new IllegalStateException( "Service has not started." );

      }

    }

    BindOperationContext bindContext = new BindOperationContext( null );

    bindContext.setCredentials( credentials );

    bindContext.setDn( principalDn.apply( schemaManager ) );

    bindContext.setInterceptors( getInterceptors( OperationEnum.BIND ) );

    operationManager.bind( bindContext );

    return bindContext.getSession();

  }

  /**

   * Get back a session for a given user bound with SASL Bind

   */

  public CoreSession getSession( Dn principalDn, byte[] credentials, String saslMechanism, String saslAuthId )

      throws Exception

  {

    synchronized ( this )

    {

      if ( !started )

      {

        throw new IllegalStateException( "Service has not started." );

      }

    }

    BindOperationContext bindContext = new BindOperationContext( null );

    bindContext.setCredentials( credentials );

    bindContext.setDn( principalDn.apply( schemaManager ) );

    bindContext.setSaslMechanism( saslMechanism );

    bindContext.setInterceptors( getInterceptors( OperationEnum.BIND ) );

    operationManager.bind( bindContext );

    return bindContext.getSession();

  }

  public long revert() throws LdapException

  {

    if ( changeLog == null || !changeLog.isEnabled() )

    {

      throw new IllegalStateException( I18n.err( I18n.ERR_310 ) );

    }

    Tag latest = changeLog.getLatest();

    if ( null != latest )

    {

      if ( latest.getRevision() < changeLog.getCurrentRevision() )

      {

        return revert( latest.getRevision() );

      }

      else

      {

        LOG.info( "Ignoring request to revert without changes since the latest tag." );

        return changeLog.getCurrentRevision();

      }

    }

    throw new IllegalStateException( I18n.err( I18n.ERR_311 ) );

  }

  /**

   * We handle the ModDN/ModRDN operation for the revert here.

   */

  private void moddn( Dn oldDn, Dn newDn, boolean delOldRdn ) throws LdapException

  {

    if ( oldDn.size() == 0 )

    {

      throw new LdapNoPermissionException( I18n.err( I18n.ERR_312 ) );

    }

    // calculate parents

    Dn oldBase = oldDn.getParent();

    Dn newBase = newDn.getParent();

    // Compute the Rdn for each of the Dn

    Rdn newRdn = newDn.getRdn();

    Rdn oldRdn = oldDn.getRdn();

        /*

         * We need to determine if this rename operation corresponds to a simple

         * Rdn name change or a move operation.  If the two names are the same

         * except for the Rdn then it is a simple modifyRdn operation.  If the

         * names differ in size or have a different baseDN then the operation is

         * a move operation.  Furthermore if the Rdn in the move operation

         * changes it is both an Rdn change and a move operation.

         */

    if ( ( oldDn.size() == newDn.size() ) && oldBase.equals( newBase ) )

    {

      adminSession.rename( oldDn, newRdn, delOldRdn );

    }

    else

    {

      Dn target = newDn.getParent();

      if ( newRdn.equals( oldRdn ) )

      {

        adminSession.move( oldDn, target );

      }

      else

      {

        adminSession.moveAndRename( oldDn, target, new Rdn( newRdn ), delOldRdn );

      }

    }

  }

  public long revert( long revision ) throws LdapException

  {

    if ( changeLog == null || !changeLog.isEnabled() )

    {

      throw new IllegalStateException( I18n.err( I18n.ERR_310 ) );

    }

    if ( revision < 0 )

    {

      throw new IllegalArgumentException( I18n.err( I18n.ERR_239 ) );

    }

    if ( revision >= changeLog.getChangeLogStore().getCurrentRevision() )

    {

      throw new IllegalArgumentException( I18n.err( I18n.ERR_314 ) );

    }

    Cursor<ChangeLogEvent> cursor = changeLog.getChangeLogStore().findAfter( revision );

        /*

         * BAD, BAD, BAD!!!

         *

         * No synchronization no nothing.  Just getting this to work for now

         * so we can revert tests.  Any production grade use of this feature

         * needs to synchronize on all changes while the revert is in progress.

         *

         * How about making this operation transactional?

         *

         * First of all just stop using JNDI and construct the operations to

         * feed into the interceptor pipeline.

         *

         * TODO review this code.

         */

    try

    {

      LOG.warn( PARTIAL_IMPL_WARNING );

      cursor.afterLast();

      while ( cursor.previous() ) // apply ldifs in reverse order

      {

        ChangeLogEvent event = cursor.get();

        List<LdifEntry> reverses = event.getReverseLdifs();

        for ( LdifEntry reverse : reverses )

        {

          switch ( reverse.getChangeType().getChangeType() )

          {

            case ChangeType.ADD_ORDINAL:

              adminSession.add(

                  new DefaultEntry( schemaManager, reverse.getEntry() ), true );