/// <summary>
/// Envía el mensaje al usuario remoto de petición de archivo y marca el estado del manejador como abierto
/// </summary>
public override void open()
{
createFile();
FileRequestMessage fileRequestMessage = new FileRequestMessage(RemoteNetUser, FileInformation.Id, Id);
sendMessage(fileRequestMessage);
}
protected IMessage ProcessData(Connection connection, BinaryReader reader)
{
IMessage result = new NullMessage();
IMessage currentMessage = MessageFactory.FromStream(reader);
switch (currentMessage.MessageId)
{
case MessageIdentifier.FileChanged:
{
if (ClientHasBeenValidated == true)
{
FileChangedMessage message = currentMessage as FileChangedMessage;
string filePath = Path.Join(connection.LocalSyncPath, message.FileData.Path);
FileInfo localFile = new FileInfo(filePath);
//we only need the file data when a file on the client was changed and that file is newer than our local copy
if (message.FileData.OperationType == WatcherChangeTypes.Changed || message.FileData.OperationType == WatcherChangeTypes.Created)
{
if (localFile.Exists == false || localFile.LastWriteTimeUtc < message.FileData.LastWriteTimeUtc)
{
FileMetaData = message.FileData;
result = new FileRequestMessage(message.FileData);
}
else
{
result = new NullMessage();
}
}
else
{
if (message.FileData.OperationType == WatcherChangeTypes.Renamed)
{
string oldFilePath = Path.Join(connection.LocalSyncPath, message.FileData.OldPath);
if (File.Exists(oldFilePath))
{
File.Move(oldFilePath, filePath);
}
}
if (message.FileData.OperationType == WatcherChangeTypes.Deleted)
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
result = new NullMessage();
}
}
break;
}
case MessageIdentifier.FileData:
{
if (ClientHasBeenValidated == true && FileMetaData != null)
{
FileDataMessage message = currentMessage as FileDataMessage;
message.FilePath = Path.Join(connection.LocalSyncPath, FileMetaData.Path);
ReceiveBegin(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath
});
try
{
message.FromBinaryStream(reader);
//change last write to match client file
File.SetLastWriteTimeUtc(message.FilePath, FileMetaData.LastWriteTimeUtc);
File.SetLastAccessTimeUtc(message.FilePath, FileMetaData.LastAccessTimeUtc);
File.SetCreationTimeUtc(message.FilePath, FileMetaData.CreateTimeUtc);
ReceiveEnd(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath, Success = true
});
}
catch (Exception ex)
{
Logger.Log(LogPriority.High, "Server #{0} error writing file: {1}", ServerId, message.FilePath);
ReceiveEnd(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath, Success = false
});
}
}
break;
}
case MessageIdentifier.Verification:
{
VerificationMessage message = currentMessage as VerificationMessage;
if (message != null)
{
if (message.Key == connection.LocalAccessKey)
{
result = new VerificationMessage(connection.RemoteAccessKey, NetworkResponse.Valid);
//store validation result for later use
ClientHasBeenValidated = true;
}
}
break;
}
}
return(result);
}
/// <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;
}
}
}
//Negotiator Id only required (currently) in ReadyToReceive, so Protocol -> Factory -> Service knows where to send received chunks to
private void InternalSendFileRequestResponse(FileDescriptor file, FileRequestMode response, string negotiatorId, long chunkIndex)
{
FileRequestHeader header = new FileRequestHeader();
header.Response = response;
header.Id = negotiatorId;
header.ChunkIndex = chunkIndex;
using (FileRequestMessage message = new FileRequestMessage(header))
{
AddValueToMessage(message, file);
SendMessage(message);
}
}
/// <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;
}
}
}
private void HandleRequestedFileMessage(FileRequestMessage requestMessage)
{
FileRequestEventArgs e = new FileRequestEventArgs(requestMessage.RequestedFile);
if (FileRequestReceived != null)
{
FileRequestReceived(this, e);
}
ClientProtocol.SendFileRequestResponse(requestMessage.RequestedFile, e.Allow);
}
private void HandleFileSend(FileRequestMessage requestMessage)
{
if (!requestMessage.RequestedFile.Exists)
{
ClientProtocol.SendFileTransferFailure(requestMessage.RequestedFile);
return;
}
long chunkIndex = requestMessage.Header.ChunkIndex;
using (FileStream file = requestMessage.RequestedFile.OpenForRead())
{
FileChunkHeader header = new FileChunkHeader();
header.ChunkCount = (int)Math.Ceiling((double)file.Length / Settings.FileChunkSize);
header.ChunkIndex = chunkIndex;
header.Id = requestMessage.Header.Id;
header.Hash = requestMessage.RequestedFile.Hash;
using (FileChunkMessage message = new FileChunkMessage(header))
{
long offset = chunkIndex * Settings.FileChunkSize;
int length = (int) (offset + Settings.FileChunkSize > file.Length ? file.Length - offset : Settings.FileChunkSize);
byte[] chunk = new byte[length];
file.Seek(offset, SeekOrigin.Begin);
file.Read(chunk, 0, chunk.Length);
try
{
ClientProtocol.AddDataToMessage(message, chunk);
ClientProtocol.SendMessage(message);
}
catch (Exception e)
{
throw e;
}
}
}
}
private void HandleFileRequestResponse(FileRequestMessage requestMessage)
{
if (FileRequestResponseReceived != null)
{
FileRequestResponseReceived(this, new FileRequestResponseEventArgs(requestMessage.RequestedFile, requestMessage.Header.Response));
}
if (requestMessage.Header.Response == FileRequestMode.Available)
{
PrepareForPendingFile(requestMessage.RequestedFile);
}
else
{
_requestedFiles.Remove(requestMessage.RequestedFile.Hash);
}
}
internal void SendFileRequest(FileDescriptor file, long requestedChunkIndex)
{
using (FileRequestMessage message = new FileRequestMessage())
{
message.Header.ChunkIndex = requestedChunkIndex;
ClientProtocol.AddValueToMessage(message, file);
ClientProtocol.SendMessage(message);
}
}
