How to use

RenameOperationContext

in

org.apache.directory.server.core.api.interceptor.context

/**
 * {@inheritDoc}
 */
@Override
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  Entry serverEntry = null;
  if ( renameContext.getEntry() != null )
  {
    serverEntry = ( ( ClonedServerEntry ) renameContext.getEntry() ).getOriginalEntry();
  }
  next( renameContext );
  // After this point, the entry has been modified. The cloned entry contains
  // the modified entry, the originalEntry has changed
  if ( !changeLog.isEnabled() )
  {
    return;
  }
  LdifEntry forward = new LdifEntry();
  forward.setChangeType( ChangeType.ModRdn );
  forward.setDn( renameContext.getDn() );
  forward.setNewRdn( renameContext.getNewRdn().getName() );
  forward.setDeleteOldRdn( renameContext.getDeleteOldRdn() );
  List<LdifEntry> reverses = LdifRevertor.reverseRename(
    serverEntry, renameContext.getNewRdn(), renameContext.getDeleteOldRdn() );
  renameContext.setChangeLogEvent( changeLog.log( getPrincipal( renameContext ), forward, reverses ) );
}

/**
 * {@inheritDoc}
 */
@Override
public void rename( ModifyDnRequest modifyDnRequest, LogChange log ) throws LdapException
{
  RenameOperationContext renameContext = new RenameOperationContext( this, modifyDnRequest );
  renameContext.setLogChange( log );
  OperationManager operationManager = directoryService.getOperationManager();
  try
  {
    operationManager.rename( renameContext );
  }
  catch ( LdapException e )
  {
    modifyDnRequest.getResultResponse().addAllControls( renameContext.getResponseControls() );
    throw e;
  }
  modifyDnRequest.getResultResponse().addAllControls( renameContext.getResponseControls() );
}

/**
 * {@inheritDoc}
 */
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  PartitionTxn partitionTxn = renameContext.getTransaction(); 
  Dn oldDn = renameContext.getDn();
  String entryId = getEntryId( partitionTxn, oldDn );
  // Create the new entry
  super.rename( renameContext );
  // Get the modified entry and store it in the context for post usage
  Dn newDn = oldDn.getParent().add( renameContext.getNewRdn() );
  Entry modifiedEntry = fetch( renameContext.getTransaction(), entryId, newDn );
  renameContext.setModifiedEntry( modifiedEntry );
  // Now move the potential children for the old entry
  // and remove the old entry
  try
  {
    entryMoved( partitionTxn, oldDn, modifiedEntry, entryId );
  }
  catch ( Exception e )
  {
    throw new LdapOperationErrorException( e.getMessage(), e );
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void rename( Dn dn, Rdn newRdn, boolean deleteOldRdn, LogChange log ) throws LdapException
{
  RenameOperationContext renameContext = new RenameOperationContext( this, dn, newRdn, deleteOldRdn );
  renameContext.setLogChange( log );
  OperationManager operationManager = directoryService.getOperationManager();
  operationManager.rename( renameContext );
}

public void rename( RenameOperationContext renameContext ) throws LdapException
  Dn oldDn = renameContext.getDn();
  Entry entry = ( ( ClonedServerEntry ) renameContext.getEntry() ).getClonedEntry();
    Dn newName = oldDn.getParent();
    newName = newName.add( renameContext.getNewRdn() );
    SearchOperationContext searchOperationContext = new SearchOperationContext( renameContext.getSession(),
      baseDn,
      filter, controls );
    searchOperationContext.setAliasDerefMode( AliasDerefMode.NEVER_DEREF_ALIASES );
    searchOperationContext.setPartition( renameContext.getPartition() );
    searchOperationContext.setTransaction( renameContext.getTransaction() );
          nexus.modify( new ModifyOperationContext( renameContext.getSession(), dn,
            getOperationalModsForReplace(
              oldDn, newName, subentry, candidate ) ) );
    Dn newName = renameContext.getNewDn();
      ModifyOperationContext newModifyContext = new ModifyOperationContext( renameContext.getSession(), newName, mods );
      newModifyContext.setPartition( renameContext.getPartition() );
      newModifyContext.setTransaction( renameContext.getTransaction() );
      nexus.modify( newModifyContext );

ldif.setDn( renameContext.getDn() );
ldif.setNewRdn( renameContext.getNewRdn().getName() );
ldif.setDeleteOldRdn( renameContext.getDeleteOldRdn() );

  public void entryRenamed( RenameOperationContext renameContext )
  {
    try
    {
      if ( listener instanceof NamespaceChangeListener )
      {
        Binding newBinding = new Binding( renameContext.getDn().getName(),
          ServerEntryUtils.toBasicAttributes( renameContext.getEntry() ), false );
        Binding oldBinding = new Binding( renameContext.getDn().getName(),
          ServerEntryUtils.toBasicAttributes( ( ( ClonedServerEntry ) renameContext.getEntry() )
            .getOriginalEntry() ), false );
        NamingEvent evt = new NamingEvent( source, NamingEvent.OBJECT_RENAMED,
          newBinding, oldBinding, null );
        ( ( NamespaceChangeListener ) listener ).objectRenamed( evt );
      }
    }
    catch ( Exception e )
    {
      deliverNamingExceptionEvent( e );
    }
  }
}

/**
 * Rename a Schema Object.
 *
 * @param renameContext The contect contaoning the rename informations
 * @param doCascadeModify unused
 * @throws LdapException If the rename failed
 */
public void rename( RenameOperationContext renameContext, boolean doCascadeModify )
  throws LdapException
{
  Entry originalEntry = ( ( ClonedServerEntry ) renameContext.getEntry() ).getOriginalEntry();
  Attribute oc = originalEntry.get( objectClassAT );
  for ( Value value : oc )
  {
    String oid = schemaManager.getObjectClassRegistry().getOidByName( value.getValue() );
    if ( objectClass2synchronizerMap.containsKey( oid ) )
    {
      RegistrySynchronizer synchronizer = objectClass2synchronizerMap.get( oid );
      synchronizer.rename( originalEntry, renameContext.getNewRdn(), doCascadeModify );
      return;
    }
  }
  if ( oc.contains( MetaSchemaConstants.META_SCHEMA_OC ) )
  {
    schemaSynchronizer.rename( originalEntry, renameContext.getNewRdn(), doCascadeModify );
    return;
  }
  throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM );
}

  /**
   * @see Object#toString()
   */
  public String toString()
  {
    return "RenameContext for old Dn '" + getDn().getName() + "'" + ", new Rdn '" + newRdn + "'"
      + ( deleteOldRdn ? ", delete old Rdn" : "" );
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  Entry entry = ( ( ClonedServerEntry ) renameContext.getEntry() ).getClonedEntry();
  entry.put( SchemaConstants.MODIFIERS_NAME_AT, getPrincipal( renameContext ).getName() );
  entry.put( SchemaConstants.MODIFY_TIMESTAMP_AT, DateUtils.getGeneralizedTime() );
  Entry modifiedEntry = renameContext.getOriginalEntry().clone();
  modifiedEntry.put( SchemaConstants.MODIFIERS_NAME_AT, getPrincipal( renameContext ).getName() );
  modifiedEntry.put( SchemaConstants.MODIFY_TIMESTAMP_AT, DateUtils.getGeneralizedTime() );
  Attribute csnAt = new DefaultAttribute( directoryService.getAtProvider().getEntryCSN(), directoryService
    .getCSN().toString() );
  modifiedEntry.put( csnAt );
  renameContext.setModifiedEntry( modifiedEntry );
  next( renameContext );
}

  /**
   * {@inheritDoc}
   */
  @Override
  public void rename( RenameOperationContext renameContext ) throws LdapException
  {
    LOG.debug( ">>> Entering into the Administrative Interceptor, renameRequest" );
    Entry entry = renameContext.getEntry();

    // Check if we are renaming an Administrative Point
    Attribute adminPoint = entry.get( directoryService.getAtProvider().getAdministrativeRole() );

    if ( adminPoint == null )
    {
      // Nope, go on.
      next( renameContext );

      LOG.debug( "Exit from Administrative Interceptor" );

      return;
    }

    // Else throw an UnwillingToPerform exception ATM
    String message = "Cannot rename an Administrative Point in the current version";
    LOG.error( message );
    throw new LdapUnwillingToPerformException( message );
  }
}

/**
 * Used to encapsulate [de]marshalling of controls before and after rename operations.
 * 
 * @param oldDn The old Dn
 * @param newRdn The new Rdn
 * @param delOldRdn If we should delete the old Rdn
 * @throws Exception If the rename failed
 */
protected void doRename( Dn oldDn, Rdn newRdn, boolean delOldRdn ) throws Exception
{
  // setup the op context and populate with request controls
  RenameOperationContext renameContext = new RenameOperationContext( session, oldDn, newRdn, delOldRdn );
  renameContext.addRequestControls( convertControls( true, requestControls ) );
  // Inject the referral handling into the operation context
  injectReferralControl( renameContext );
  // execute rename operation
  OperationManager operationManager = service.getOperationManager();
  operationManager.rename( renameContext );
  // clear the request controls and set the response controls
  requestControls = EMPTY_CONTROLS;
  responseControls = JndiUtils.toJndiControls( getDirectoryService().getLdapCodecService(),
    renameContext.getResponseControls() );
}

  localDn.getName(), remoteRdn.getName(), String.valueOf( deleteOldRdn ) );
RenameOperationContext renCtx = new RenameOperationContext( session, localDn, remoteRdn,
  deleteOldRdn );
renCtx.setReplEvent( true );
renCtx.setRid( rid );
directoryService.getOperationManager().rename( renCtx );

/**
 * {@inheritDoc}
 */
@Override
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  synchronized ( lock )
  {
    super.rename( renameContext );
    dirty = true;
    rewritePartitionData( renameContext.getTransaction() );
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  Partition partition = getPartition( renameContext.getDn() );
  partition.rename( renameContext );
}

/**
 * {@inheritDoc}
 */
@Override
public void rename( Dn dn, Rdn newRdn, boolean deleteOldRdn, boolean ignoreReferral, LogChange log )
  throws LdapException
{
  OperationManager operationManager = directoryService.getOperationManager();
  RenameOperationContext renameContext = new RenameOperationContext( this, dn, newRdn, deleteOldRdn );
  renameContext.setLogChange( log );
  setReferralHandling( renameContext, ignoreReferral );
  operationManager.rename( renameContext );
}

public void rename( RenameOperationContext renameContext ) throws LdapException
  Dn name = renameContext.getDn();
  Rdn newRdn = renameContext.getNewRdn();
  boolean deleteOldRn = renameContext.getDeleteOldRdn();
  Entry renamedEntry = ( ( ClonedServerEntry ) renameContext.getEntry() ).getClonedEntry();

/**
 * {@inheritDoc}
 */
@Override
public void rename( RenameOperationContext renameContext ) throws LdapException
{
  if ( IS_DEBUG )
  {
    LOG.debug( "Operation Context: {}", renameContext );
  }
  checkAuthenticated( renameContext );
  checkPwdReset( renameContext );
  next( renameContext );
  invalidateAuthenticatorCaches( renameContext.getDn() );
}