- pre-operation plugins are not called anymore when processing synchronizat...

gbellato

12.23.2006 f0f4caa7b330807252d8a86d8ff499e16f9ddd33

 opendj-sdk/opends/src/server/org/opends/server/synchronization/SynchronizationMessage.java

@@ -27,13 +27,26 @@
package org.opends.server.synchronization;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.zip.DataFormatException;

/**
 * Abstract class that must be used when defining messages that can
 * be sent for synchronization purpose between servers.
 *
 * When extending this class one should also create a new MSG_TYPE
 * and should update the generateMsg() method.
 */
public abstract class SynchronizationMessage implements Serializable
{
  static final byte MSG_TYPE_MODIFY_REQUEST = 1;
  static final byte MSG_TYPE_ADD_REQUEST = 2;
  static final byte MSG_TYPE_DELETE_REQUEST = 3;
  static final byte MSG_TYPE_MODIFYDN_REQUEST = 4;
  static final byte MSG_TYPE_ACK = 5;
  static final byte MSG_TYPE_SERVER_START = 6;
  static final byte MSG_TYPE_CHANGELOG_START = 7;

  /**
   * Do the processing necessary when the message is received.
   *
@@ -41,4 +54,101 @@
   * @return an UpdateMessage if the processing result is an UpdateMessage.
   */
  public abstract UpdateMessage processReceive(SynchronizationDomain domain);

  /**
   * Return the byte[] representation of this message.
   * Depending on the message type, the first byte of the byte[] must be.
   * MSG_TYPE_MODIFY_REQUEST
   * MSG_TYPE_ADD_REQUEST
   * MSG_TYPE_DELETE_REQUEST
   * MSG_TYPE_MODIFY_DN_REQUEST
   * MSG_TYPE_ACK
   * MSG_TYPE_SERVER_START
   * MSG_TYPE_CHANGELOG_START
   *
   * @return the byte[] representation of this message.
   */
  public abstract byte[] getBytes();


  /**
   * Generates a SynchronizationMessage from its encoded form.
   *
   * @param buffer The encode form of the SynchronizationMessage.
   * @return the generated SycnhronizationMessage.
   * @throws DataFormatException if the encoded form was not a valid msg.
   * @throws UnsupportedEncodingException if UTF8 is not supported.
   */
  public static SynchronizationMessage generateMsg(byte[] buffer)
                throws DataFormatException, UnsupportedEncodingException
  {
    SynchronizationMessage msg = null;
    switch (buffer[0])
    {
      case MSG_TYPE_MODIFY_REQUEST:
          msg = new ModifyMsg(buffer);
      break;
      case MSG_TYPE_ADD_REQUEST:
          msg = new AddMsg(buffer);
      break;
      case MSG_TYPE_DELETE_REQUEST:
          msg = new DeleteMsg(buffer);
      break;
      case MSG_TYPE_MODIFYDN_REQUEST:
          msg = new ModifyDNMsg(buffer);
      break;
      case MSG_TYPE_ACK:
        msg = new AckMessage(buffer);
      break;
      case MSG_TYPE_SERVER_START:
        msg = new ServerStartMessage(buffer);
      break;
      case MSG_TYPE_CHANGELOG_START:
        msg = new ChangelogStartMessage(buffer);
      break;
      default:
        throw new DataFormatException("received message with unknown type");
    }
    return msg;
  }

  /**
   * Concatenate the tail byte array into the resultByteArray.
   * The resultByteArray must be large enough before calling this method.
   *
   * @param tail the byte array to concatenate.
   * @param resultByteArray The byte array to concatenate to.
   * @param pos the position where to concatenate.
   * @return the next position to use in the resultByteArray.
   */
  protected int addByteArray(byte[] tail, byte[] resultByteArray, int pos)
  {
    for (int i=0; i<tail.length; i++,pos++)
    {
      resultByteArray[pos] = tail[i];
    }
    resultByteArray[pos++] = 0;
    return pos;
  }

  /**
   * Get the length of the next String encoded in the in byte array.
   *
   * @param in the byte array where to calculate the string.
   * @param pos the position whre to start from in the byte array.
   * @return the length of the next string.
   * @throws DataFormatException If the byte array does not end with null.
   */
  protected int getNextLength(byte[] in, int pos) throws DataFormatException
  {
    int offset = pos;
    int length = 0;
    while (in[offset++] != 0)
    {
      if (offset >= in.length)
        throw new DataFormatException("byte[] is not a valid modify msg");
      length++;
    }
    return length;
  }
}