/// <summary>
/// Coloca un mensaje en la cola
/// </summary>
/// <param name="m">El mensaje a colocar en la cola</param>
public void put(Message m)
{
lock (thisLock)
{
queue.Enqueue(m);
}
}
/// <summary>
/// Atiende una solicitud de envío de parte
/// </summary>
public override void attendMessage(Message message)
{
if (message.Type == SubProtocol.FileTransfer.Types.FILECOMPLETEMESSAGE)
{
State = FileMessageHandlerState.COMPLETED;
close();
}
}
/// <summary>
/// Coloca un mensaje en la cola
/// </summary>
/// <param name="m">el mensaje a colocar en la cola</param>
public void put(Message m)
{
monitor.Enter();
queue.Enqueue(m);
itemCount++;
monitor.Pulse();
monitor.Exit();
}
/// <summary>
/// Coloca un mensaje en la cola
/// </summary>
/// <param name="m">el mensaje a colocar en la cola</param>
public void put(Message m)
{
lock (this)
{
queue.Enqueue(m);
itemCount++;
Monitor.Pulse(this);
}
}
/// <summary>
/// Agrega un mensaje a la lista
/// </summary>
/// <param name="message">el mensaje a agregar</param>
public void add(Message message)
{
lock (thisLock)
{
//Si no tengo el ip, entonces agrego al usuario como alguien nuevo
if (!messageCollection.Contains(message.Id))
{
messageCollection.Add(message.Id, message);
}
//Si ya la tengo, actualizo el objeto usuario
else
{
messageCollection.Remove(message.Id);
messageCollection.Add(message.Id, message);
}
}
}
/// <summary>
/// Procesa un mensaje que no se ha podido enviar
/// </summary>
/// <param name="message">El mensaje que no se ha podido enviar</param>
public void errorMessage(Message message)
{
switch (message.Type)
{
case SubProtocol.Chat.Types.CHATMESSAGE:
{
ChatMessage textMessage = (ChatMessage)message;
controlChatHandler.chatWarninglInformation("No se ha podido entregar el mensage: " + textMessage.Text + ". Al usuario: " + textMessage.TargetNetUser.Name);
break;
}
case SubProtocol.Chat.Types.GROUPCHATMESSAGE:
{
GroupChatMessage textMessage = (GroupChatMessage)message;
controlChatHandler.chatWarninglInformation("No se ha podido enviar el mensage: " + textMessage.Text);
break;
}
}
}
/// <summary>
/// retorna un array con la lista de mensajes
/// </summary>
/// <returns>un array de los mensajes listados</returns>
public Message[] messageListToArray()
{
lock (thisLock)
{
Message[] us = new Message[messageCollection.Count];
IDictionaryEnumerator en = messageCollection.GetEnumerator();
int i = 0;
while (en.MoveNext())
{
us[i] = (Message)en.Value;
i++;
}
return us;
}
}
/// <summary>
/// Procesa un mensaje que no se ha podido enviar
/// </summary>
/// <param name="message">El mensaje que no se ha podido enviar</param>
public void errorMessage(Message message)
{
}
/// <summary>
/// Procesa un mensaje recibido de la red
/// </summary>
/// <param name="message">El mensaje recibido</param>
public void proccessMessage(Message message)
{
switch (message.Type)
{
case SubProtocol.Ping.Types.PINGMESSAGE:
{
PingMessage pingMessage = (PingMessage)message;
PingResponseMessage pingResponseMessage = new PingResponseMessage(pingMessage.Timestamp, message.SenderNetUser);
sendMessageEvent(pingResponseMessage);
break;
}
case SubProtocol.Ping.Types.PINGRESPONSEMESSAGE:
{
PingResponseMessage pingResponseMessage = (PingResponseMessage)message;
controlPingHandler.pingResponseMessageReceived(pingResponseMessage.SenderNetUser, (new TimeSpan(DateTime.Now.Ticks - pingResponseMessage.Timestamp)).TotalMilliseconds);
break;
}
}
}
/// <summary> /// Ejecuta un paso en la iteración del transmisor /// </summary> public abstract void attendMessage(Message message);
/// <summary>
/// Envía un mensaje de petición de partes del archivo al usuario remoto y marca el estado del manejador como esperando
/// </summary>
public override void attendMessage(Message message)
{
if (message.Type == SubProtocol.FileTransfer.Types.FILEPARTMESSAGE)
{
FilePartMessage filePartMessage = (FilePartMessage)message;
receivePartMessage(filePartMessage);
}
}
/// <summary>
/// Se gatilla cuando se recibe un mensaje
/// </summary>
/// <param name="message">El mensaje recibido</param>
public void proccessMessage(Message message)
{
switch (message.Type)
{
case SubProtocol.FileTransfer.Types.FILEREQUESTMESSAGE:
{
FileRequestMessage fileRequestMessage = (FileRequestMessage)message;
FileInformation fileInformation = fileData.FileList.getFileInformation(fileRequestMessage.FileId);
if (fileInformation != null)
{
FileMessageSender fileMessageSender = new FileMessageSender(fileRequestMessage.SenderNetUser, fileRequestMessage.FileHandlerId, sendMessageDelegate, fileInformation, fileData);
lock (fileMessageHandlerLock)
{
if (!activeUploads.Contains(fileMessageSender.Id))
{
if (fileMessageUploadQueue.put(fileMessageSender))
{
controlFileHandler.uploadFileQueued(fileRequestMessage.SenderNetUser, fileMessageSender.Id.ToString(), fileInformation.Name);
}
}
}
}
else
{
FileErrorMessage fileErrorMessage = new FileErrorMessage(fileRequestMessage.SenderNetUser, fileRequestMessage.FileHandlerId);
sendMessageEvent(fileErrorMessage);
}
break;
}
case SubProtocol.FileTransfer.Types.FILEERRORMESSAGES:
{
FileErrorMessage fileErrorMessage = (FileErrorMessage)message;
lock (fileMessageHandlerLock)
{
if (activeUploads.Contains(fileErrorMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileErrorMessage.FileHandlerId];
controlFileHandler.uploadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeUploads.Remove(fileMessageHandler.Id);
}
else if (activeDownloads.Contains(fileErrorMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileErrorMessage.FileHandlerId];
controlFileHandler.downloadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeDownloads.Remove(fileMessageHandler.Id);
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILEPARTMESSAGE:
{
FilePartMessage filePartMessage = (FilePartMessage)message;
lock (fileMessageHandlerLock)
{
if (activeDownloads.Contains(filePartMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[filePartMessage.FileHandlerId];
fileMessageHandler.attendMessage(filePartMessage);
fileMessageHandler.waitUp(fileData.FileRiseUp);
}
else
{
FileErrorMessage fileErrorMessage = new FileErrorMessage(filePartMessage.SenderNetUser, filePartMessage.FileHandlerId);
sendMessageEvent(fileErrorMessage);
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILEWAITMESSAGE:
{
FileWaitMessage fileWaitMessage = (FileWaitMessage)message;
lock (fileMessageHandlerLock)
{
if (activeDownloads.Contains(fileWaitMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileWaitMessage.FileHandlerId];
fileMessageHandler.waitUp(fileData.FileRiseUp);
}
else if (activeUploads.Contains(fileWaitMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileWaitMessage.FileHandlerId];
fileMessageHandler.waitUp(fileData.FileRiseUp);
}
else
{
if (!fileMessageDownloadQueue.contains(fileWaitMessage.FileHandlerId) && !fileMessageUploadQueue.contains(fileWaitMessage.FileHandlerId))
{
FileErrorMessage fileErrorMessage = new FileErrorMessage(fileWaitMessage.SenderNetUser, fileWaitMessage.FileHandlerId);
sendMessageEvent(fileErrorMessage);
}
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILECOMPLETEMESSAGE:
{
FileCompleteMessage fileCompleteMessage = (FileCompleteMessage)message;
lock (fileMessageHandlerLock)
{
if (activeUploads.Contains(fileCompleteMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileCompleteMessage.FileHandlerId];
fileMessageHandler.State = FileMessageHandlerState.COMPLETED;
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILELISTREQUESTMESSAGE:
{
FileListRequestMessage fileListRequestMessage = (FileListRequestMessage)message;
FileListMessage fileListMessage = new FileListMessage(fileListRequestMessage.SenderNetUser, fileData.FileList);
sendMessageEvent(fileListMessage);
break;
}
case SubProtocol.FileTransfer.Types.FILELISTMESSAGE:
{
FileListMessage fileListMessage = (FileListMessage)message;
controlFileListHandler.addFileList(fileListMessage.SenderNetUser, fileListMessage.FileList);
break;
}
}
}
/// <summary>
/// Encola un mensaje a la lista de mensajes para enviar
/// </summary>
/// <param name="message">El mensaje a enviar</param>
public void queueMessageToSend(Message message)
{
if (message.MetaType == MessageMetaType.MULTICAST)
{
messageIdCollection.add(message.Id);
nMessagesCounted++;
send(message);
}
else if (message.MetaType == MessageMetaType.SAFEMULTICAST)
{
messageIdCollection.add(message.Id);
nMessagesCounted++;
notSentMessageQueue.put(message);
}
else if (message.MetaType == MessageMetaType.FASTUNICAST)
{
send(message);
}
else
{
notSentMessageQueue.put(message);
}
}
/// <summary>
/// Procesa un mensaje recibido de la red
/// </summary>
/// <param name="message">El mensaje recibido</param>
public void proccessMessage(Message message)
{
switch (message.Type)
{
case SubProtocol.Chat.Types.CHATMESSAGE:
{
ChatMessage textMessage = (ChatMessage)message;
controlChatHandler.chatMessageReceived(textMessage.SenderNetUser, textMessage.Text);
break;
}
case SubProtocol.Chat.Types.GROUPCHATMESSAGE:
{
GroupChatMessage textMessage = (GroupChatMessage)message;
controlChatHandler.groupChatMessageReceived(textMessage.SenderNetUser, textMessage.Text);
break;
}
}
}
/// <summary>
/// Procesa un mensaje que no ha podido ser envíado correctamente
/// </summary>
/// <param name="message">El mensaje</param>
internal void routerMessageErrorHandler(Message message)
{
//ImAliveMessage
if (message.Type == MessageType.IMALIVE)
{
ImAliveMessage imAliveMessage = (ImAliveMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + imAliveMessage.ToString());
}
//AckMessage
else if (message.Type == MessageType.ACK)
{
AckMessage ackMessage = (AckMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + ackMessage.ToString());
}
//Resto de los mensajes
else
{
SubProtocolI subProtocol = (SubProtocolI)subProtocols[message.ProtocolType];
if (subProtocol != null)
{
eventQueuePC.put(new Event(new MessageEvent(subProtocol.errorMessage), message));
}
else
{
produceEvent(CommunicationEvent.ERRORMESSAGE, message);
}
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + message.ToString());
}
}
/// <summary>
/// Envía un mensaje de forma interna aplicando filtros
/// </summary>
/// <param name="message">el mensaje a enviar</param>
internal void internalSendMessage(Message message)
{
try
{
if (configuration.NetUser.Ip != null)
{
message.SenderNetUser = configuration.NetUser;
router.queueMessageToSend(message);
if (message.Type != MessageType.IMALIVE && message.Type != MessageType.ACK)
{
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION: queued " + message.ToString());
}
}
}
catch (ThreadAbortException e)
{
throw e;
}
catch (Exception e)
{
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION: impossible to send this message " + e.Message);
}
}
/// <summary>
/// Envía un mensaje a la MANET
/// </summary>
/// <param name="message">el mensaje a enviar</param>
public void send(Message message)
{
//ImAliveMessage
if (message.Type == MessageType.IMALIVE)
{
ImAliveMessage imAliveMessage = (ImAliveMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION WARNING: reserved kind of message " + imAliveMessage.ToString());
}
//AckMessage
else if (message.Type == MessageType.ACK)
{
AckMessage ackMessage = (AckMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION WARNING: reserved kind of message " + ackMessage.ToString());
}
//Resto de los mensajes
else
{
internalSendMessage(message);
}
}
/// <summary>
/// Se gatilla cuando se quiere envíar un mensaje
/// Este parametro es para asignar a los handlers
/// </summary>
/// <param name="message">El mensaje a enviar</param>
internal void sendMessageDelegate(Message message)
{
sendMessageEvent(message);
}
/// <summary>
/// Identifica el tipo de mensaje a enviar y lo envia mediante un netHandler
/// </summary>
/// <param name="message">El mensaje e enviar</param>
private void send(Message message)
{
if (message.MetaType == MessageMetaType.MULTICAST)
{
MulticastMessage multicastMessage = (MulticastMessage)message;
multicastMessage.send(netHandler);
}
else if (message.MetaType == MessageMetaType.SAFEMULTICAST)
{
SafeMulticastMessage safeMulticastMessage = (SafeMulticastMessage)message;
safeMulticastMessage.send(netHandler);
}
else if (message.MetaType == MessageMetaType.UNICAST)
{
UnicastMessage unicastMessage = (UnicastMessage)message;
IPAddress ip = pathNextIp(unicastMessage.TargetNetUser);
NetUser listedNetUSer = netUserList.getUser(unicastMessage.TargetNetUser.Ip);
if (ip != null)
{
if (!unicastMessage.send(netHandler, ip))
{
unicastMessage.FailReason = MessageFailReason.TCPFAIL;
failedMessageQueue.put(unicastMessage);
}
}
else if (listedNetUSer != null && listedNetUSer.Id.Equals(unicastMessage.TargetNetUser.Id))
{
unicastMessage.FailReason = MessageFailReason.NOTROUTEBUTHOSTONNET;
failedMessageQueue.put(unicastMessage);
}
else
{
unicastMessage.FailReason = MessageFailReason.NOTROUTETOHOST;
failedMessageQueue.put(unicastMessage);
}
}
else if (message.MetaType == MessageMetaType.SAFEUNICAST)
{
SafeUnicastMessage safeMessage = (SafeUnicastMessage)message;
IPAddress ip = pathNextIp(safeMessage.TargetNetUser);
NetUser listedNetUser = netUserList.getUser(safeMessage.TargetNetUser.Ip);
if (ip != null)
{
if (safeMessage.send(netHandler, ip))
{
//statics
nMessagesSent++;
//si el mensaje enviado fue de este usuario se espera confirmación
if (safeMessage.SenderNetUser.Id.Equals(netUser.Id))
{
safeMessage.WaitTimeOut = waitForAck + 2 * safeMessage.TargetNetUser.JumpsAway;
notConfirmedMessageList.add(safeMessage);
}
}
else
{
//statics
nMessagesFailed++;
safeMessage.FailReason = MessageFailReason.TCPFAIL;
failedMessageQueue.put(safeMessage);
}
}
else if (listedNetUser != null && listedNetUser.Id.Equals(safeMessage.TargetNetUser.Id))
{
safeMessage.FailReason = MessageFailReason.NOTROUTEBUTHOSTONNET;
failedMessageQueue.put(safeMessage);
}
else
{
safeMessage.FailReason = MessageFailReason.DESTROY;
failedMessageQueue.put(safeMessage);
}
}
else if (message.MetaType == MessageMetaType.FASTUNICAST)
{
FastUnicastMessage fastUnicastMessage = (FastUnicastMessage)message;
IPAddress ip = pathNextIp(fastUnicastMessage.TargetNetUser);
NetUser listedNetUSer = netUserList.getUser(fastUnicastMessage.TargetNetUser.Ip);
if (ip != null)
{
fastUnicastMessage.send(netHandler, ip);
}
}
}
/// <summary>
/// Procesa un mensaje recibido
/// </summary>
/// <param name="message">El mensaje recibido</param>
private void proccessMessage(Message message)
{
if (message != null)
{
//registra la ip del mensaje recibido en el manejador de Ips, previo chequeo de que el mensaje no es de
//este mismo usuario
if (!message.SenderNetUser.Id.Equals(configuration.NetUser.Id))
{
netHandler.registerIp(message.SenderNetUser.Ip);
}
//verifica que se recibe el mensaje de un usuario conocido
NetUser listedNetUser = netUserList.getUser(message.SenderNetUser.Ip);
//ImAliveMessage
if (message.Type == MessageType.IMALIVE)
{
if (listedNetUser == null)
{
newNetUser(message.SenderNetUser);
}
else if (!listedNetUser.Id.Equals(message.SenderNetUser.Id))
{
disconnectNetUser(listedNetUser);
}
else
{
listedNetUser.qualityUp(configuration.NetData);
listedNetUser.NeighborhoodIds = message.SenderNetUser.NeighborhoodIds;
listedNetUser.JumpsAway = message.Jumps;
listedNetUser.State = message.SenderNetUser.State;
listedNetUser.UpLayerData = message.SenderNetUser.UpLayerData;
}
//produceEvent(CommunicationEvent.NETINFORMATION, "recibido: " + subProtocol.ToString());
}
//AckMessage
else if (message.Type == MessageType.ACK)
{
AckMessage ackMessage = (AckMessage)message;
router.proccessAckMessage(ackMessage);
//produceEvent(CommunicationEvent.NETINFORMATION, "recibidos: " + subProtocol.ToString());
}
//Resto de los mensajes
else
{
if (listedNetUser != null && listedNetUser.Id.Equals(message.SenderNetUser.Id))
{
message.SenderNetUser = listedNetUser;
SubProtocolI subProtocol = (SubProtocolI)subProtocols[message.ProtocolType];
if (subProtocol != null)
{
eventQueuePC.put(new Event(new MessageEvent(subProtocol.proccessMessage), message));
}
else
{
produceEvent(CommunicationEvent.PROCESSMESSAGE, message);
}
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION: received " + message.ToString());
}
else
{
message.SenderNetUser.Name = "Unknown (" + message.SenderNetUser.Ip.ToString() + ")";
SubProtocolI subProtocol = (SubProtocolI)subProtocols[message.ProtocolType];
if (subProtocol != null)
{
eventQueuePC.put(new Event(new MessageEvent(subProtocol.proccessMessage), message));
}
else
{
produceEvent(CommunicationEvent.PROCESSMESSAGE, message);
}
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION: unknown message " + message.ToString());
}
}
}
}
/// <summary>
/// Se gatilla cuando no es posible entregar un mensaje
/// </summary>
/// <param name="message">El mensaje no entregado</param>
public void errorMessage(Message message)
{
switch (message.Type)
{
case SubProtocol.FileTransfer.Types.FILEREQUESTMESSAGE:
{
FileRequestMessage fileRequestMessage = (FileRequestMessage)message;
lock (fileMessageHandlerLock)
{
if (activeDownloads.Contains(fileRequestMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileRequestMessage.FileHandlerId];
controlFileHandler.downloadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeDownloads.Remove(fileMessageHandler.Id);
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILEERRORMESSAGES:
{
break;
}
case SubProtocol.FileTransfer.Types.FILEPARTMESSAGE:
{
FilePartMessage filePartMessage = (FilePartMessage)message;
lock (fileMessageHandlerLock)
{
if (activeUploads.Contains(filePartMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[filePartMessage.FileHandlerId];
controlFileHandler.uploadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeUploads.Remove(fileMessageHandler.Id);
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILEWAITMESSAGE:
{
FileWaitMessage fileWaitMessage = (FileWaitMessage)message;
lock (fileMessageHandlerLock)
{
if (activeDownloads.Contains(fileWaitMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileWaitMessage.FileHandlerId];
controlFileHandler.downloadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeDownloads.Remove(fileMessageHandler.Id);
}
else if (activeUploads.Contains(fileWaitMessage.FileHandlerId))
{
FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileWaitMessage.FileHandlerId];
controlFileHandler.uploadFileFailed(fileMessageHandler.Id.ToString());
fileMessageHandler.close();
activeUploads.Remove(fileMessageHandler.Id);
}
}
break;
}
case SubProtocol.FileTransfer.Types.FILECOMPLETEMESSAGE:
{
break;
}
case SubProtocol.FileTransfer.Types.FILELISTREQUESTMESSAGE:
{
break;
}
case SubProtocol.FileTransfer.Types.FILELISTMESSAGE:
{
break;
}
}
}