public BSPMessage(IPEndPoint address, BSPMessageType type, int sourceID, NetworkBuffer messageData)
{
this.address = address;
this.type = type;
this.sourceID = sourceID;
this.messageData = messageData;
}
private BSPMessage parse(Message message)
{
if (message == null)
{
Console.Error.WriteLine("Could not parse null message");
return(null);
}
NetworkBuffer buffer = new NetworkBuffer(message.data);
if (buffer.size() < HEADER_LENGTH)
{
throw new Exception("Invalid message: " + System.Text.Encoding.Default.GetString(buffer.getBuffer()));
}
int messageType = buffer.parseInt32(HEADER_TYPE_OFFSET);
BSPMessageType type = BSPMessageType.UNKNOWN;
if (Enum.IsDefined(typeof(BSPMessageType), messageType))
{
type = (BSPMessageType)messageType;
}
int sourceID = buffer.parseInt32(HEADER_SOURCE_OFFSET);
int bytesRemaining = buffer.size() - HEADER_LENGTH;
NetworkBuffer data = new NetworkBuffer(bytesRemaining);
if (bytesRemaining > 0)
{
data.writeBytes(buffer.getBuffer(), HEADER_LENGTH, 0, bytesRemaining);
}
return(new BSPMessage(message.address, type, sourceID, data));
}
public void synchronizeAllBeliefs()
{
if (protocol.getConnection().getRemoteAddress() == null)
{
return;
}
RepositoryStateSerializer serializer = new RepositoryStateSerializer();
NetworkBuffer buffer = serializer.serialize(repo.CurrentState());
BSPMessage message = new BSPMessage(protocol.getConnection().getRemoteAddress(),
BSPMessageType.SYNC,
protocol.getAgentID(),
buffer);
protocol.getConnection().send(message);
}
public RepositoryState deserialize(NetworkBuffer buffer)
{
int revisionNumber = buffer.parseInt32(COMMIT_OFFSET);
RepositoryState state = new RepositoryState(revisionNumber);
int numberOfBeliefs = buffer.parseInt32(NUM_BELIEFS_OFFSET);
int baseOffset = HEADER_SIZE;
for (int i = 0; i < numberOfBeliefs; ++i, baseOffset += BELIEF_SIZE)
{
int typeVal = buffer.readByte(baseOffset + TYPE_OFFSET);
Belief.BeliefType type = Belief.BeliefType.INVALID;
if (Enum.IsDefined(typeof(Belief.BeliefType), typeVal))
{
type = (Belief.BeliefType)typeVal;
}
else
{
Log.error("Invalid belief type: " + typeVal);
}
int customType = buffer.parseInt32(baseOffset + CUSTOM_TYPE_OFFSET);
int id = buffer.parseInt32(baseOffset + BELIEF_ID_OFFSET);
byte[] digest = buffer.readBytes(baseOffset + DIGEST_OFFSET, DIGEST_SIZE);
Hash hash = new Hash(digest);
Belief.Key key = null;
if (type == Belief.BeliefType.CUSTOM)
{
key = new Belief.Key(customType);
}
else
{
key = new Belief.Key(type);
}
state.Add(new CacheKey(key, id), hash);
}
return(state);
}
public NetworkBuffer serialize(RepositoryState state)
{
NetworkBuffer buffer = new NetworkBuffer(HEADER_SIZE + (state.Size() * BELIEF_SIZE));
buffer.writeInt32(COMMIT_OFFSET, state.RevisionNumber());
buffer.writeInt32(NUM_BELIEFS_OFFSET, state.Size());
int offset = HEADER_SIZE;
foreach (RepositoryState.RepositoryObject belief in state.GetObjects())
{
buffer.writeByte(offset + TYPE_OFFSET, (byte)belief.key.getBeliefType());
buffer.writeInt32(offset + CUSTOM_TYPE_OFFSET, belief.key.getCustomType());
buffer.writeInt32(offset + BELIEF_ID_OFFSET, belief.key.getBeliefID());
byte[] hashBytes = belief.hash.GetBytes();
buffer.writeBytes(hashBytes, 0, offset + DIGEST_OFFSET, hashBytes.Length);
}
return(buffer);
}
private Message formatMessage(BSPMessage data)
{
if (data == null)
{
Console.Error.WriteLine("Could not format null data");
return(null);
}
int messageLength = data.getData().size();
NetworkBuffer messageData = new NetworkBuffer(HEADER_LENGTH + messageLength);
messageData.writeInt32(HEADER_TYPE_OFFSET, (int)data.getType());
messageData.writeInt32(HEADER_SOURCE_OFFSET, data.getSourceID());
if (data.getData().size() > 0)
{
messageData.writeBytes(data.getData().getBuffer(), 0, HEADER_LENGTH, data.getData().size());
}
return(new Message(data.getAddress(), messageData.getBuffer()));
}
