/// <summary>
/// Fabrica un mensaje que ha provenido de la red
/// </summary>
/// <param name="messageData">Los datos del mensajes como un conjunto de bytes</param>
/// <returns>Un mensaje de alto nivel</returns>
public Message makeMessage(byte[] messageData)
{
Message message = null;
try
{
Int32 messageType = BitConverter.ToInt32(messageData, 4);
if (messageType < 100)
{
switch (messageType)
{
case MessageType.ACK:
{
message = new AckMessage();
message.byteArrayToProperties(messageData);
break;
}
case MessageType.IMALIVE:
{
message = new ImAliveMessage();
message.byteArrayToProperties(messageData);
break;
}
}
}
else
{
Type classType = (Type)messageTypes[messageType];
message = (Message)Activator.CreateInstance(classType);
message.byteArrayToProperties(messageData);
}
}
catch (ThreadAbortException e)
{
throw e;
}
catch (Exception e)
{
String s = e.Message;
}
return(message);
}
/// <summary>
/// Identifica un mensaje de bajo nivel recibido y lo retorna como mensaje de alto nivel, y/o lo rutea segun corresponde
/// </summary>
/// <param name="netMessage">El mensaje recibido de bajo nivel</param>
/// <returns>el mensaje de alto nivel recibido, o null si se ruteó hacia otra parte</returns>
public Message attendMessage(NetMessage netMessage)
{
Int32 messageMetaType = messageFactory.getMessageMetaType(netMessage.Body);
if (messageMetaType == MessageMetaType.MULTICAST)
{
Guid messageId = messageFactory.getMessageId(netMessage.Body);
if (!messageIdCollection.contains(messageId))
{
Message message = messageFactory.makeMessage(netMessage.Body);
if (message != null)
{
message.Jumps++;
if (message.Jumps > 1)
{
queueMessageToSend(message);
}
else
{
if (rand.NextDouble() < 0.5)
{
queueMessageToSend(message);
}
else
{
messageIdCollection.add(message.Id);
nMessagesCounted++;
}
}
return message;
}
}
}
else if (messageMetaType == MessageMetaType.SAFEMULTICAST)
{
Guid messageId = messageFactory.getMessageId(netMessage.Body);
if (!messageIdCollection.contains(messageId))
{
Message message = messageFactory.makeMessage(netMessage.Body);
if (message != null)
{
message.Jumps++;
queueMessageToSend(message);
return message;
}
}
}
else if (messageMetaType == MessageMetaType.UNICAST)
{
Message message = messageFactory.makeMessage(netMessage.Body);
if (message != null)
{
message.Jumps++;
UnicastMessage unicastMessage = (UnicastMessage)message;
if (unicastMessage.TargetNetUser.Id.Equals(netUser.Id))
{
return message;
}
else
{
//Parametrizar
if (notSentMessageQueue.size() > 50 || failedMessageQueue.size() > 50)
{
nMessagesFailed++;
unicastMessage.FailReason = MessageFailReason.DESTROY;
failedMessageQueue.put(unicastMessage);
}
else
{
nMessagesRouted++;
queueMessageToSend(unicastMessage);
}
}
}
}
else if (messageMetaType == MessageMetaType.SAFEUNICAST)
{
//Enviamos el ack primero que todo
NetUser targetNetUser = messageFactory.getTargetNetUser(netMessage.Body);
if (netUser.Id.Equals(targetNetUser.Id))
{
Guid messageId = messageFactory.getMessageId(netMessage.Body);
NetUser senderNetUser = messageFactory.getSenderNetUser(netMessage.Body);
if (senderNetUser != null)
{
AckMessage ackMessage = new AckMessage(senderNetUser, messageId);
ackMessage.SenderNetUser = netUser;
queueMessageToSend(ackMessage);
}
}
//PRocesamos en mensaje
Message message = messageFactory.makeMessage(netMessage.Body);
if (message != null)
{
message.Jumps++;
SafeUnicastMessage safeMessage = (SafeUnicastMessage)message;
if (safeMessage.TargetNetUser.Id.Equals(netUser.Id))
{
if (!messageIdCollection.contains(safeMessage.Id))
{
//statics
nMessagesReceived++;
messageIdCollection.add(safeMessage.Id);
nMessagesCounted++;
return message;
}
}
else
{
//Parametrizar
if (notSentMessageQueue.size() > 50 || failedMessageQueue.size() > 50)
{
nMessagesFailed++;
safeMessage.FailReason = MessageFailReason.DESTROY;
failedMessageQueue.put(safeMessage);
}
else
{
nMessagesRouted++;
queueMessageToSend(safeMessage);
}
}
}
}
else if (messageMetaType == MessageMetaType.FASTUNICAST)
{
Message message = messageFactory.makeMessage(netMessage.Body);
if (message != null)
{
message.Jumps++;
FastUnicastMessage fastUnicastMessage = (FastUnicastMessage)message;
if (fastUnicastMessage.TargetNetUser.Id.Equals(netUser.Id))
{
return message;
}
else
{
nMessagesRouted++;
queueMessageToSend(fastUnicastMessage);
}
}
}
return null;
}
/// <summary>
/// Procesa un mensaje de confirmación que se ha recibido
/// </summary>
/// <param name="ackMessage">el mensaje de confirmación</param>
public void proccessAckMessage(AckMessage ackMessage)
{
if (notConfirmedMessageList.remove(ackMessage.MessageId))
{
//statics
nMessagesConfirmed++;
}
}
/// <summary>
/// Fabrica un mensaje que ha provenido de la red
/// </summary>
/// <param name="messageData">Los datos del mensajes como un conjunto de bytes</param>
/// <returns>Un mensaje de alto nivel</returns>
public Message makeMessage(byte[] messageData)
{
Message message = null;
try
{
Int32 messageType = BitConverter.ToInt32(messageData, 4);
if (messageType < 100)
{
switch (messageType)
{
case MessageType.ACK:
{
message = new AckMessage();
message.byteArrayToProperties(messageData);
break;
}
case MessageType.IMALIVE:
{
message = new ImAliveMessage();
message.byteArrayToProperties(messageData);
break;
}
}
}
else
{
Type classType = (Type)messageTypes[messageType];
message = (Message)Activator.CreateInstance(classType);
message.byteArrayToProperties(messageData);
}
}
catch (ThreadAbortException e)
{
throw e;
}
catch (Exception e)
{
String s = e.Message;
}
return message;
}
