/// <summary>
/// Constructor Parametrizado
/// </summary>
/// <param name="remoteNetUser">El usuario remoto con el cual se intercambiará el archivo</param>
/// <param name="sendMessageDelegate">Un método con el cual se puedan envíar mensajes a la MANET</param>
/// <param name="fileInformation">La información del archivo</param>
/// <param name="FileData">Los parámetros de configuración</param>
public FileMessageReceiver(NetUser remoteNetUser, SendMessageDelegate sendMessageDelegate, FileInformation fileInformation, FileData fileData)
: base(remoteNetUser, sendMessageDelegate, fileInformation, fileData)
{
thisLock = new Object();
this.Type = FileMessageHandlerType.DOWNLOAD;
this.downloadDir = fileData.DownloadDir;
}
/// <summary>
/// Constructor parametrizado
/// </summary>
/// <param name="targetNetUser">El receptor de este mensaje</param>
/// <param name="fileId">El id del archivo</param>
/// <param name="fileHandlerId">El identificador de la transferencia</param>
public FileRequestMessage(NetUser targetNetUser, Guid fileId, Guid fileHandlerId)
: this()
{
this.TargetNetUser = targetNetUser;
this.FileId = fileId;
this.FileHandlerId = fileHandlerId;
}
/// <summary>
/// Constructor parametrizado
/// </summary>
/// <param name="targetNetUser">El receptor de este mensaje</param>
/// <param name="fileHandlerId">El id del archivo</param>
/// <param name="partId">El id de la parte del archivo</param>
/// <param name="filePart">El conjunto de bytes de la parte del archivo en formato string base 64</param>
public FilePartMessage(NetUser targetNetUser, Guid fileHandlerId, Int64 partId, byte[] filePart)
: this()
{
this.TargetNetUser = targetNetUser;
this.FileHandlerId = fileHandlerId;
this.PartId = partId;
this.FilePart = filePart;
}
/// <summary>
/// Constructor parametrizado
/// </summary>
/// <param name="remoteNetUser">El usuario con quien se intercambia el archivo</param>
/// <param name="remoteFileHandlerId">El id de la transferencia de archivo</param>
/// <param name="sendMessageDelegate">Una función por la que se pueda enviar un mensaje</param>
/// <param name="fileInformation">Información del archivo</param>
/// <param name="fileData">Datos de configuración de archivos</param>
public FileMessageSender(NetUser remoteNetUser, Guid remoteFileHandlerId, SendMessageDelegate sendMessageDelegate, FileInformation fileInformation, FileData fileData)
: base(remoteNetUser, sendMessageDelegate, fileInformation, fileData)
{
FileName = fileInformation.Path;
currentPart = 0;
this.Type = FileMessageHandlerType.UPLOAD;
this.Id = remoteFileHandlerId;
}
/// <summary>
/// Fabrica un array con la colección de usuarios
/// </summary>
/// <returns>Un array de usuarios</returns>
public NetUser[] userListToArray()
{
lock (thisLock)
{
NetUser[] us = new NetUser[usersCollection.Count];
IDictionaryEnumerator en = usersCollection.GetEnumerator();
int i = 0;
while (en.MoveNext())
{
us[i] = (NetUser)en.Value;
i++;
}
return us;
}
}
/// <summary>
/// Agrega un usuario a la colección (Asocia una IP a un usuario)
/// </summary>
/// <param name="ip">La ip del usuario</param>
/// <param name="newUser">El usuario</param>
/// <returns>true si efectivamente era un nuevo usuario, false si tuvo que borrar a uno ya existente</returns>
internal bool add(IPAddress ip, NetUser newUser)
{
lock (thisLock)
{
//Si no tengo el ip, entonces agrego al usuario como alguien nuevo
if (!usersCollection.Contains(ip))
{
usersCollection.Add(ip, newUser);
return true;
}
//Si ya la tengo, actualizo el objeto usuario
else
{
NetUser oldUser = getUser(ip);
usersCollection.Remove(ip);
usersCollection.Add(ip, newUser);
return false;
}
}
}
/// <summary>
/// Elimina la lista de archivos de un usuario de la red de la ventana
/// </summary>
/// <param name="netUser">El usuario de la red</param>
public void removeFileList(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(removeFileList);
this.Invoke(d, new object[] { netUser });
}
else
{
lock (thisLock)
{
for (int i = treeView.Nodes.Count - 1; i >= 0; i--)
{
TreeNode node = treeView.Nodes[i];
NetUserFile netUserFile = (NetUserFile)node.Tag;
if (netUserFile.NetUser.Name.Equals(netUser.Name))
{
treeView.Nodes.RemoveAt(i);
}
}
}
}
}
/// <summary>
/// Agrega una lista de archivos de un usuario de la red a la ventana
/// </summary>
/// <param name="netUser">El usuario dueño de la lista de archivo</param>
/// <param name="fileList">La lista de archivos</param>
public void addFileList(NetUser netUser, FileInformationList fileList)
{
if (treeView.InvokeRequired)
{
NetUserFilesCallback d = new NetUserFilesCallback(addFileList);
this.Invoke(d, new object[] { netUser, fileList });
}
else
{
removeFileList(netUser);
FileInformation[] fileListArray = fileList.toArray();
lock (thisLock)
{
foreach (FileInformation file in fileListArray)
{
TreeNode fileNode = new TreeNode(file.Name + " (" + (file.Size / 1024) + " KB) " + " [" + netUser.Name + "]");
fileNode.ImageIndex = 0;
fileNode.SelectedImageIndex = 0;
NetUserFile netUserFile = new NetUserFile();
netUserFile.NetUser = netUser;
netUserFile.FileInformation = file;
fileNode.Tag = netUserFile;
treeView.Nodes.Add(fileNode);
}
}
}
}
/// <summary>
/// Constructor parametrizado
/// </summary>
/// <param name="targetNetUser">El receptor de este mensaje</param>
/// <param name="fileList">La lista de archivos compartidos</param>
public FileListMessage(NetUser targetNetUser, FileInformationList fileList)
: this()
{
this.TargetNetUser = targetNetUser;
this.FileList = fileList;
}
/// <summary>
/// Actualiza los datos del usuario local en el grafo de la red
/// </summary>
/// <param name="netUser">El usario local</param>
public void refreshLocalUserHandler(NetUser netUser)
{
if (viewer.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(refreshLocalUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
TreeNode newNode = new TreeNode(netUser.ToString());
newNode.Tag = netUser;
newNode.ImageIndex = 0;
newNode.SelectedImageIndex = 0;
int index = netUsersNodes.IndexOf(new NetUserNode(netUser.Id));
if (index == -1)
{
addUserHandler(netUser);
}
else
{
refreshUserHandler(netUser);
}
}
}
/// <summary>
/// Constructor parametrizado
/// </summary>
/// <param name="targetNetUser">El usuario destinatario de este mensaje</param>
/// <param name="text">El texto del mensaje</param>
public ChatMessage(NetUser targetNetUser, String text)
: this()
{
this.TargetNetUser = targetNetUser;
this.Text = text;
}
/// <summary>
/// Envía un mensaje de ping a la red
/// </summary>
/// <param name="netUser">El usuario destino del mensaje</param>
public void sendPingMessage(NetUser netUser)
{
PingMessage pingMessage = new PingMessage(netUser);
sendMessageEvent(pingMessage);
}
/// <summary>
/// Elimina a un usuario de la red del arbol de usuarios
/// </summary>
/// <param name="netUser">El usuario que salido de la red</param>
public void removeUserHandler(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(removeUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
int index = -1;
foreach (TreeNode node in treeView.Nodes)
{
NetUser tagNetUser = (NetUser)node.Tag;
if (tagNetUser.Id == netUser.Id)
{
index = node.Index;
break;
}
}
if (index != -1)
{
treeView.Nodes.RemoveAt(index);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeStamp"></param>
/// <param name="targetNetUser"></param>
public PingResponseMessage(Int64 timeStamp, NetUser targetNetUser)
: this()
{
Timestamp = timeStamp;
TargetNetUser = targetNetUser;
}
/// <summary>
/// Agrega a un usuario de la red al árbol de usuarios
/// </summary>
/// <param name="netUser">El nuevo usuario que ha ingresado a la red</param>
public void addUserHandler(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(addUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
TreeNode newNode = new TreeNode(netUser.ToString());
newNode.Tag = netUser;
newNode.ImageIndex = netUser.SignalQuality;
newNode.SelectedImageIndex = netUser.SignalQuality;
int index = -1;
foreach (TreeNode node in treeView.Nodes)
{
NetUser tagNetUSer = (NetUser)node.Tag;
if (tagNetUSer.Id == netUser.Id)
{
index = node.Index;
break;
}
}
if (index == -1)
{
treeView.Nodes.Add(newNode);
}
else
{
refreshUserHandler(netUser);
}
}
}
/// <summary>
/// Constructor Parametrizado
/// </summary>
/// <param name="netUser">Datos del usuario</param>
/// <param name="netData">Datos de configuración de red</param>
public Configuration(NetUser netUser, NetData netData)
{
this.NetUser = netUser;
this.NetData = netData;
}
/// <summary>
/// Actualiza los parámetros del router
/// </summary>
/// <param name="netHandler">El manejador de la red</param>
/// <param name="netUser">Los datos del usuario local</param>
/// <param name="netUserList">La lista de usuarios de la red</param>
public void updateRouterTable(NetHandler netHandler, NetUser netUser, NetUserList netUserList)
{
this.netHandler = netHandler;
this.netUser = netUser;
this.netUserList = netUserList;
int newMessageNumber = nMessagesCounted;
nMessagesCounted = 0;
int neighborhoodSize = netUser.NeighborhoodIds.Length;
//se incrementa el numero de iteraciones
iterations++;
//actualizo el promedio de cada registro
messageAverage = ((messageAverage * (iterations - 1) + newMessageNumber) / iterations);
if (messageAverage > 1)
{
//calculo el nuevo tamaño optimo de la lista,
int size = 1 + (int)(((Math.Log(duplicationProbability, Math.E) / (Math.Log(messageAverage - 1, Math.E) - Math.Log(messageAverage, Math.E)))));
//si el nuevo tamaño optimo es mayor, se debe aumentar el tamaño de la lista
if (size > messageIdCollection.MaxSize)
{
messageIdCollection.MaxSize = size;
}
}
}
/// <summary>
/// Agrega a un usuario al grafo de la red
/// </summary>
/// <param name="netUser">El usuario de la red</param>
public void addUserHandler(NetUser netUser)
{
if (viewer.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(addUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
NetUserNode netUserNode = new NetUserNode();
netUserNode.Id = netUser.Id;
netUserNode.Name = netUser.Name;
netUserNode.State = netUser.State;
netUserNode.Quality = netUser.SignalQuality;
for (int j = 0; j < netUser.NeighborhoodIds.Length; j++)
{
int index = netUsersNodes.IndexOf(new NetUserNode(netUser.NeighborhoodIds[j]));
if (index != -1)
{
netUserNode.Links.Add(netUsersNodes[index]);
}
}
netUsersNodes.Add(netUserNode);
}
}
/// <summary>
/// Elimina a un usuario del grafo de la red
/// </summary>
/// <param name="netUser">El usuario de la red</param>
public void removeUserHandler(NetUser netUser)
{
if (viewer.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(removeUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
int index = netUsersNodes.IndexOf(new NetUserNode(netUser.Id));
if (index != -1)
{
netUsersNodes.RemoveAt(index);
}
}
}
/// <summary>
/// Ingresa o actualiza los datos del usuario local en el Árbol de usuarios
/// </summary>
/// <param name="netUser">El usario local</param>
public void refreshLocalUserHandler(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(refreshLocalUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
TreeNode newNode = new TreeNode(netUser.ToString());
newNode.Tag = netUser;
newNode.ImageIndex = 0;
newNode.SelectedImageIndex = 0;
int index = -1;
foreach (TreeNode node in treeView.Nodes)
{
NetUser tagNetUSer = (NetUser)node.Tag;
if (tagNetUSer.Id == netUser.Id)
{
index = node.Index;
break;
}
}
if (index == -1)
{
treeView.Nodes.Add(newNode);
}
else
{
TreeNode node = treeView.Nodes[index];
NetUser tagNetUSer = (NetUser)node.Tag;
if (!node.Text.Equals(netUser.ToString()))
{
node.Text = netUser.ToString();
}
if (!node.Tag.Equals(netUser))
{
node.Tag = netUser;
}
}
}
}
/// <summary>
/// Actualiza los datos de un usuario en el Árbol de usuarios
/// </summary>
/// <param name="netUser">El usuario que ha actualizado sus datos o estado</param>
public void refreshUserHandler(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(refreshUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
foreach (TreeNode node in treeView.Nodes)
{
NetUser tagNetUSer = (NetUser)node.Tag;
if (tagNetUSer.Id == netUser.Id)
{
if (!node.Text.Equals(netUser.ToString()))
{
node.Text = netUser.ToString();
}
if (!node.Tag.Equals(netUser))
{
node.Tag = netUser;
}
if (!node.ImageIndex.Equals(tagNetUSer.SignalQuality))
{
node.ImageIndex = tagNetUSer.SignalQuality;
node.SelectedImageIndex = tagNetUSer.SignalQuality;
}
break;
}
}
}
}
/// <summary>
/// Agrega un nuevo usuario de la red a la lista
/// </summary>
/// <param name="netUser">El usuario de la red</param>
private void newNetUser(NetUser netUser)
{
lock (userListLock)
{
if (!netUser.Id.Equals(configuration.NetUser.Id))
{
NetUser newNetUser = new NetUser(netUser.Id, netUser.Name, netUser.Ip, netUser.NeighborhoodIds, configuration.NetData);
newNetUser.State = netUser.State;
newNetUser.UpLayerData = netUser.UpLayerData;
newNetUser.JumpsAway = netUser.JumpsAway;
if (netUserList.add(netUser.Ip, newNetUser))
{
produceEvent(CommunicationEvent.ADDUSER, newNetUser);
}
else
{
produceEvent(CommunicationEvent.REFRESHUSER, newNetUser);
}
produceEvent(CommunicationEvent.NETINFORMATION, "COMMUNICATION: [" + netUser.Name + "] connected");
}
}
}
/// <summary>
/// Agrega a un usuario de la red al árbol de usuarios
/// </summary>
/// <param name="netUser">El nuevo usuario que ha ingresado a la red</param>
public void addUserHandler(NetUser netUser)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(addUserHandler);
this.Invoke(d, new object[] { netUser });
}
else
{
TreeNode newNode = new TreeNode(netUser.ToString());
newNode.Tag = netUser;
newNode.ImageIndex = netUser.SignalQuality;
newNode.SelectedImageIndex = netUser.SignalQuality;
treeView.Nodes.Add(newNode);
}
}
/// <summary>
/// Encola a un archivo para transferencia (upload)
/// </summary>
/// <param name="netUser">El usuario de la red al cual se le debe transferir el archivo</param>
/// <param name="fileHandlerId">El id de la transferencia</param>
/// <param name="fileName">El nombre del archivo</param>
public void uploadFileQueued(NetUser netUser, String fileHandlerId, String fileName)
{
if (treeView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(uploadFileQueued);
this.Invoke(d, new object[] { netUser, fileHandlerId, fileName });
}
else
{
FileItem fileItem = new FileItem();
fileItem.NetUserName = netUser.Name;
fileItem.FileName = fileName;
fileItem.Percent = 0;
fileItem.State = FileControlState.QUEUED;
fileItem.Type = FileControlStateType.UPLOAD;
fileItem.FileHandlerId = fileHandlerId;
fileList.Add(fileItem);
refreshList(fileItem);
}
}
/// <summary>
/// Encola a un archivo para transferencia (upload)
/// </summary>
/// <param name="netUser">El usuario de la red al cual se le debe transferir el archivo</param>
/// <param name="fileHandlerId">El id de la transferencia</param>
/// <param name="fileName">El nombre del archivo</param>
public void uploadFileQueued(NetUser netUser, String fileHandlerId, String fileName)
{
if (dataGridView.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(uploadFileQueued);
this.Invoke(d, new object[] { netUser, fileHandlerId, fileName });
}
else
{
DataGridViewRow dataGridViewRow = new DataGridViewRow();
dataGridView.Rows.Add(new Object[] { netUser.Name, fileName, 0, FileControlState.QUEUED, FileControlStateType.UPLOAD, fileHandlerId });
}
}
/// <summary>
/// Identifica un mensaje de bajo nivel recibido y lo retorna como mensajede 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>
/// Agrega un mensaje de texto a la ventana de un usuario
/// TODO por implmentar, ventanas de usuarios para conversaciones privadas
/// </summary>
/// <param name="netUser">El usuario autor del mensaje</param>
/// <param name="message">El mensaje de texto</param>
public void chatMessageReceived(NetUser netUser, String message)
{
if (textBoxText.InvokeRequired)
{
NetUserCallback d = new NetUserCallback(chatMessageReceived);
this.Invoke(d, new object[] { netUser, message });
}
else
{
textBoxText.AppendText("[" + (netUser != null ? netUser.Name : "unknown") + "] say: " + message + Environment.NewLine);
}
}
/// <summary>
/// Encuentra el camino mas corto hacia el destinatario de un mensaje y retorna la ip del vecino que se encuentra en el camino
/// </summary>
/// <param name="receiverNetUser">El usuario destinatario del mensaje</param>
/// <returns>Un string con la IP del remote machine vecino que se encuentra en el camino óptimo</returns>
private IPAddress pathNextIp(NetUser receiverNetUser)
{
NetUser[] listedNodes = netUserList.userListToArray();
//Se chequea que existan al menos dos usuarios mas
if (listedNodes.Length < 2)
{
for(int i = 0; i < netUser.NeighborhoodIds.Length; i++) {
if (netUser.NeighborhoodIds[i].Equals(receiverNetUser.Id))
{
return receiverNetUser.Ip;
}
}
//no existe conexion con ese usuario
return null;
}
IPAddress ip = null;
//Se crea el array de nodos del grafo
List<NetUser> nodes = new List<NetUser>();
nodes.Add(netUser);
int receiberIndex = -1;
for (int i = 0; i < listedNodes.Length; i++)
{
nodes.Add(listedNodes[i]);
if(receiverNetUser.Id.Equals(listedNodes[i].Id))
{
receiberIndex = i + 1;
}
}
if (receiberIndex != -1)
{
//Se ejecuta el algoritmo de Dijkstra para encontrar el orden de los indices de los nodos con el camino optimo
Dijkstra dijkstra = new Dijkstra(nodes, netHandler.NetData);
int[] nodeIndexes = dijkstra.GetMinimumPath(0, receiberIndex);
if (nodeIndexes.Length > 0)
{
ip = nodes[nodeIndexes[0]].Ip;
if (ip.Equals(receiverNetUser.Ip))
{
for (int i = 0; i < netUser.NeighborhoodIds.Length; i++)
{
if (netUser.NeighborhoodIds[i].Equals(receiverNetUser.Id))
{
return receiverNetUser.Ip;
}
}
return null;
}
}
}
return ip;
}
/// <summary>
/// Agrega un mensaje de texto a la ventana grupal
/// </summary>
/// <param name="netUser">El usuario autor del mensaje</param>
/// <param name="message">El mensaje de texto</param>
public void groupChatMessageReceived(NetUser netUser, String message)
{
if (textBoxText.InvokeRequired)
{
NetUserStringCallback d = new NetUserStringCallback(groupChatMessageReceived);
this.Invoke(d, new object[] { netUser, message });
}
else
{
textBoxText.Text = ("[" + (netUser != null ? netUser.Name : "unknown") + "] say: " + message) + Environment2.NewLine + textBoxText.Text;
}
}
/// <summary>
/// Constructor Parametrizado
/// </summary>
/// <param name="targetNetUser">El destinatario de este mensaje</param>
/// <param name="fileHandlerId">El id del archivo</param>
public FileErrorMessage(NetUser targetNetUser, Guid fileHandlerId)
: this()
{
this.TargetNetUser = targetNetUser;
this.FileHandlerId = fileHandlerId;
}
public FileMessageHandler(NetUser remoteNetUser, SendMessageDelegate sendMessage, FileInformation fileInformation, FileData fileData)
{
this.Id = Guid.NewGuid();
this.RemoteNetUser = remoteNetUser;
this.sendMessage = sendMessage;
this.FileInformation = fileInformation;
this.PartSize = fileData.PartSize;
State = FileMessageHandlerState.WAITING;
MaxTimeOut = fileData.FileTimeOut;
resetTimeOut();
}
/// <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);
}
}
}