/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
* add the following below this CDDL HEADER, with the fields enclosed
* by brackets "[]" replaced with your own identifying information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2009 Sun Microsystems, Inc.
* Portions Copyright 2013 ForgeRock AS.
*/
package org.opends.server.replication.protocol;
import java.io.UnsupportedEncodingException;
import java.util.zip.DataFormatException;
import org.opends.server.replication.common.ServerState;
/**
* This message is used by LDAP server when they first connect.
* to a replication server to let them know who they are and what is their state
* (their RUV)
*/
public class ServerStartECLMsg extends StartMsg
{
private String serverURL;
private int maxReceiveQueue;
private int maxSendQueue;
private int maxReceiveDelay;
private int maxSendDelay;
private int windowSize;
private ServerState serverState = null;
/**
* The time in milliseconds between heartbeats from the replication
* server. Zero means heartbeats are off.
*/
private long heartbeatInterval = 0;
/**
* Whether to continue using SSL to encrypt messages after the start
* messages have been exchanged.
*/
private boolean sslEncryption;
/**
* Creates a new ServerStartMsg. This message is to be sent by an LDAP
* Server after being connected to a replication server for a given
* replication domain.
*
* @param serverURL directory server URL
* @param maxReceiveDelay The max receive delay for this server.
* @param maxReceiveQueue The max receive Queue for this server.
* @param maxSendDelay The max Send Delay from this server.
* @param maxSendQueue The max send Queue from this server.
* @param windowSize The window size used by this server.
* @param heartbeatInterval The requested heartbeat interval.
* @param serverState The state of this server.
* @param generationId The generationId for this server.
* @param sslEncryption Whether to continue using SSL to encrypt messages
* after the start messages have been exchanged.
* @param groupId The group id of the DS for this DN
*/
public ServerStartECLMsg(String serverURL, int maxReceiveDelay,
int maxReceiveQueue, int maxSendDelay,
int maxSendQueue, int windowSize,
long heartbeatInterval,
ServerState serverState,
long generationId,
boolean sslEncryption,
byte groupId)
{
super((short) -1 /* version set when sending */, generationId);
this.serverURL = serverURL;
this.maxReceiveDelay = maxReceiveDelay;
this.maxReceiveQueue = maxReceiveQueue;
this.maxSendDelay = maxSendDelay;
this.maxSendQueue = maxSendQueue;
this.windowSize = windowSize;
this.heartbeatInterval = heartbeatInterval;
this.sslEncryption = sslEncryption;
this.serverState = serverState;
this.groupId = groupId;
}
/**
* Creates a new ServerStartMsg from its encoded form.
*
* @param in The byte array containing the encoded form of the
* ServerStartMsg.
* @throws DataFormatException If the byte array does not contain a valid
* encoded form of the ServerStartMsg.
*/
public ServerStartECLMsg(byte[] in) throws DataFormatException
{
byte[] allowedPduTypes = new byte[1];
allowedPduTypes[0] = MSG_TYPE_START_ECL;
headerLength = decodeHeader(allowedPduTypes, in);
try
{
/* first bytes are the header */
int pos = headerLength;
/*
* read the ServerURL
*/
int length = getNextLength(in, pos);
serverURL = new String(in, pos, length, "UTF-8");
pos += length +1;
/*
* read the maxReceiveDelay
*/
length = getNextLength(in, pos);
maxReceiveDelay = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the maxReceiveQueue
*/
length = getNextLength(in, pos);
maxReceiveQueue = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the maxSendDelay
*/
length = getNextLength(in, pos);
maxSendDelay = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the maxSendQueue
*/
length = getNextLength(in, pos);
maxSendQueue = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the windowSize
*/
length = getNextLength(in, pos);
windowSize = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the heartbeatInterval
*/
length = getNextLength(in, pos);
heartbeatInterval = Integer.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
/*
* read the sslEncryption setting
*/
length = getNextLength(in, pos);
sslEncryption = Boolean.valueOf(new String(in, pos, length, "UTF-8"));
pos += length +1;
// Read the ServerState
// Caution: ServerState MUST be the last field. Because ServerState can
// contain null character (string termination of sererid string ..) it
// cannot be decoded using getNextLength() like the other fields. The
// only way is to rely on the end of the input buffer : and that forces
// the ServerState to be the last. This should be changed and we want to
// have more than one ServerState field.
serverState = new ServerState(in, pos, in.length - 1);
} catch (UnsupportedEncodingException e)
{
throw new DataFormatException("UTF-8 is not supported by this jvm.");
}
}
/**
* get the Server URL from the message.
* @return the server URL
*/
public String getServerURL()
{
return serverURL;
}
/**
* Get the maxReceiveDelay.
* @return Returns the maxReceiveDelay.
*/
public int getMaxReceiveDelay()
{
return maxReceiveDelay;
}
/**
* Get the maxReceiveQueue.
* @return Returns the maxReceiveQueue.
*/
public int getMaxReceiveQueue()
{
return maxReceiveQueue;
}
/**
* Get the maxSendDelay.
* @return Returns the maxSendDelay.
*/
public int getMaxSendDelay()
{
return maxSendDelay;
}
/**
* Get the maxSendQueue.
* @return Returns the maxSendQueue.
*/
public int getMaxSendQueue()
{
return maxSendQueue;
}
/**
* Get the ServerState.
* @return The ServerState.
*/
public ServerState getServerState()
{
return serverState;
}
/**
* {@inheritDoc}
*/
@Override
public byte[] getBytes(short sessionProtocolVersion)
{
try {
byte[] byteServerUrl = serverURL.getBytes("UTF-8");
byte[] byteMaxRecvDelay =
String.valueOf(maxReceiveDelay).getBytes("UTF-8");
byte[] byteMaxRecvQueue =
String.valueOf(maxReceiveQueue).getBytes("UTF-8");
byte[] byteMaxSendDelay =
String.valueOf(maxSendDelay).getBytes("UTF-8");
byte[] byteMaxSendQueue =
String.valueOf(maxSendQueue).getBytes("UTF-8");
byte[] byteWindowSize =
String.valueOf(windowSize).getBytes("UTF-8");
byte[] byteHeartbeatInterval =
String.valueOf(heartbeatInterval).getBytes("UTF-8");
byte[] byteSSLEncryption =
String.valueOf(sslEncryption).getBytes("UTF-8");
byte[] byteServerState = serverState.getBytes();
int length = byteServerUrl.length + 1 +
byteMaxRecvDelay.length + 1 +
byteMaxRecvQueue.length + 1 +
byteMaxSendDelay.length + 1 +
byteMaxSendQueue.length + 1 +
byteWindowSize.length + 1 +
byteHeartbeatInterval.length + 1 +
byteSSLEncryption.length + 1 +
byteServerState.length + 1;
/* encode the header in a byte[] large enough to also contain the mods */
byte resultByteArray[] = encodeHeader(MSG_TYPE_START_ECL, length,
sessionProtocolVersion);
int pos = headerLength;
pos = addByteArray(byteServerUrl, resultByteArray, pos);
pos = addByteArray(byteMaxRecvDelay, resultByteArray, pos);
pos = addByteArray(byteMaxRecvQueue, resultByteArray, pos);
pos = addByteArray(byteMaxSendDelay, resultByteArray, pos);
pos = addByteArray(byteMaxSendQueue, resultByteArray, pos);
pos = addByteArray(byteWindowSize, resultByteArray, pos);
pos = addByteArray(byteHeartbeatInterval, resultByteArray, pos);
pos = addByteArray(byteSSLEncryption, resultByteArray, pos);
pos = addByteArray(byteServerState, resultByteArray, pos);
return resultByteArray;
}
catch (UnsupportedEncodingException e)
{
return null;
}
}
/**
* Get the window size for the ldap server that created the message.
*
* @return The window size for the ldap server that created the message.
*/
public int getWindowSize()
{
return windowSize;
}
/**
* Get the heartbeat interval requested by the ldap server that created the
* message.
*
* @return The heartbeat interval requested by the ldap server that created
* the message.
*/
public long getHeartbeatInterval()
{
return heartbeatInterval;
}
/**
* Get the SSL encryption value for the ldap server that created the
* message.
*
* @return The SSL encryption value for the ldap server that created the
* message.
*/
public boolean getSSLEncryption()
{
return sslEncryption;
}
/**
* {@inheritDoc}
*/
@Override
public String toString()
{
return this.getClass().getCanonicalName() + " content: " +
"\nprotocolVersion: " + protocolVersion +
"\ngenerationId: " + generationId +
"\ngroupId: " + groupId +
"\nheartbeatInterval: " + heartbeatInterval +
"\nmaxReceiveDelay: " + maxReceiveDelay +
"\nmaxReceiveQueue: " + maxReceiveQueue +
"\nmaxSendDelay: " + maxSendDelay +
"\nmaxSendQueue: " + maxSendQueue +
"\nserverState: " + serverState +
"\nserverURL: " + serverURL +
"\nsslEncryption: " + sslEncryption +
"\nwindowSize: " + windowSize;
}
}