async void HandleServerInfoRequest(object sender, Request serverInfoRequest)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedServerInfoRequest,
RemoteServerIpAddress = serverInfoRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = serverInfoRequest.RemoteServerInfo.PortNumber
});
EventOccurred?.Invoke(this, _eventLog.Last());
var serverInfoResponse = new ServerInfoResponse
{
LocalServerInfo = MyInfo,
RemoteServerInfo = serverInfoRequest.RemoteServerInfo,
LocalIpAddress = MyInfo.LocalIpAddress,
PublicIpAddress = MyInfo.PublicIpAddress,
PortNumber = MyInfo.PortNumber,
Platform = MyInfo.Platform,
TransferFolderPath = MyInfo.TransferFolder,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
var sendRequest = await _requestHandler.SendRequestAsync(serverInfoResponse);
if (sendRequest.Failure)
{
ReportError(this, sendRequest.Error);
return;
}
SuccessfullyProcessedRequest?.Invoke(this, serverInfoResponse);
}
void HandleRetryLimitExceeded(object sender, RetryLimitExceeded retryLimitExceeded)
{
var getFileTransfer = FileTransferHandler.HandleRetryLimitExceeded(retryLimitExceeded);
if (getFileTransfer.Failure)
{
return;
}
var inboundFileTransfer = getFileTransfer.Value;
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedRetryLimitExceeded,
LocalFolder = inboundFileTransfer.LocalFolderPath,
FileName = inboundFileTransfer.FileName,
FileSizeInBytes = inboundFileTransfer.FileSizeInBytes,
RemoteServerIpAddress = inboundFileTransfer.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = inboundFileTransfer.RemoteServerInfo.PortNumber,
RetryCounter = inboundFileTransfer.RetryCounter,
RemoteServerRetryLimit = inboundFileTransfer.RemoteServerRetryLimit,
RetryLockoutExpireTime = inboundFileTransfer.RetryLockoutExpireTime,
FileTransferId = inboundFileTransfer.Id
});
EventOccurred?.Invoke(this, _eventLog.Last());
SuccessfullyProcessedRequest?.Invoke(this, retryLimitExceeded);
}
private void HandleRequestedFolderIsEmpty(object sender, Request requestedFolderIsEmpty)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedNotificationFolderIsEmpty,
RemoteServerIpAddress = requestedFolderIsEmpty.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = requestedFolderIsEmpty.RemoteServerInfo.PortNumber
});
EventOccurred?.Invoke(this, _eventLog.Last());
SuccessfullyProcessedRequest?.Invoke(this, requestedFolderIsEmpty);
}
protected async void SendNotificationRequestedFileDoesNotExist(object sender, GetFileRequest getFileRequest)
{
var requestedFileDoesNotExist = new FileTransferResponse(RequestType.RequestedFileDoesNotExist)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = getFileRequest.RemoteServerInfo,
RemoteServerTransferId = getFileRequest.RemoteServerTransferId,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
await _requestHandler.SendRequestAsync(requestedFileDoesNotExist);
SuccessfullyProcessedRequest?.Invoke(this, getFileRequest);
}
async void HandleOutboundFileTransferRequest(object sender, GetFileRequest getFileRequest)
{
// TODO: Create logic to check file transfers that are under lockout and if this request matches remoteserver info + localfilepath, send a new filetranserresponse = rejected_retrylimitexceeded. maybe we should penalize them for trying to subvert our lockout policy?
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedOutboundFileTransferRequest,
RemoteFolder = getFileRequest.RemoteFolderPath,
LocalFolder = getFileRequest.LocalFolderPath,
FileName = getFileRequest.FileName,
RemoteServerIpAddress = getFileRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = getFileRequest.RemoteServerInfo.PortNumber
});
EventOccurred?.Invoke(this, _eventLog.Last());
var handleTransferRequest =
FileTransferHandler.HandleOutboundFileTransferRequest(getFileRequest);
if (handleTransferRequest.Failure)
{
return;
}
var fileTransfer = handleTransferRequest.Value;
var sendFileRequest = new SendFileRequest
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileTransfer.RemoteServerInfo,
FileName = fileTransfer.FileName,
FileSizeInBytes = fileTransfer.FileSizeInBytes,
RemoteFolderPath = fileTransfer.RemoteFolderPath,
LocalFolderPath = fileTransfer.LocalFolderPath,
FileTransferResponseCode = fileTransfer.TransferResponseCode,
RemoteServerTransferId = fileTransfer.RemoteServerTransferId,
RetryLimit = fileTransfer.RemoteServerRetryLimit,
RetryCounter = fileTransfer.RetryCounter,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
await _requestHandler.SendRequestAsync(sendFileRequest);
SuccessfullyProcessedRequest?.Invoke(this, getFileRequest);
}
private void HandleFileListResponse(object sender, FileListResponse fileListResponse)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedFileList,
LocalIpAddress = MyInfo.LocalIpAddress,
LocalPortNumber = MyInfo.PortNumber,
RemoteServerIpAddress = fileListResponse.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = fileListResponse.RemoteServerInfo.PortNumber,
RemoteFolder = fileListResponse.RemoteServerInfo.TransferFolder,
RemoteServerFileList = fileListResponse.FileInfoList,
});
EventOccurred?.Invoke(this, _eventLog.Last());
SuccessfullyProcessedRequest?.Invoke(this, fileListResponse);
}
void HandleServerInfoResponse(object sender, ServerInfoResponse serverInfoResponse)
{
serverInfoResponse.RemoteServerInfo.DetermineSessionIpAddress(Settings.LocalNetworkCidrIp);
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedServerInfo,
RemoteServerIpAddress = serverInfoResponse.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = serverInfoResponse.RemoteServerInfo.PortNumber,
RemoteServerPlatform = serverInfoResponse.RemoteServerInfo.Platform,
RemoteFolder = serverInfoResponse.RemoteServerInfo.TransferFolder,
LocalIpAddress = serverInfoResponse.RemoteServerInfo.LocalIpAddress,
PublicIpAddress = serverInfoResponse.RemoteServerInfo.PublicIpAddress
});
EventOccurred?.Invoke(this, _eventLog.Last());
SuccessfullyProcessedRequest?.Invoke(this, serverInfoResponse);
}
protected async void SendNotificationFileAlreadyExists(object sender, SendFileRequest sendFileRequest)
{
var rejectFileTransfer = new FileTransferResponse(RequestType.FileTransferRejected)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = sendFileRequest.RemoteServerInfo,
TransferResponseCode = sendFileRequest.FileTransferResponseCode,
RemoteServerTransferId = sendFileRequest.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
var sendRequest = await _requestHandler.SendRequestAsync(rejectFileTransfer);
if (sendRequest.Failure)
{
return;
}
SuccessfullyProcessedRequest?.Invoke(this, sendFileRequest);
}
void HandleOutboundFileTransferComplete(object sender, FileTransferResponse fileTransferResponse)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.RemoteServerConfirmedFileTransferCompleted,
RemoteServerIpAddress = fileTransferResponse.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = fileTransferResponse.RemoteServerInfo.PortNumber,
FileTransferId = fileTransferResponse.Id
});
EventOccurred?.Invoke(this, _eventLog.Last());
var transferComplete =
FileTransferHandler.HandleOutboundFileTransferComplete(fileTransferResponse);
if (transferComplete.Failure)
{
return;
}
SuccessfullyProcessedRequest?.Invoke(this, fileTransferResponse);
}
async void HandleOutboundFileTransferAccepted(object sender, FileTransferResponse fileTransferResponse)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.RemoteServerAcceptedFileTransfer,
RemoteServerIpAddress = fileTransferResponse.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = fileTransferResponse.RemoteServerInfo.PortNumber,
FileTransferId = fileTransferResponse.RemoteServerTransferId
});
EventOccurred?.Invoke(this, _eventLog.Last());
var socket = _requestHandler.GetSocketForOutboundFileTransfer();
if (socket == null)
{
var error = "Unable to retrieve transfer socket, file transfer must be aborted";
FileTransferHandler.AbortOutboundFileTransfer(fileTransferResponse, error);
return;
}
OutboundFileTransferInProgress?.Invoke(this, true);
var sendFile = await
FileTransferHandler.HandleOutboundFileTransferAccepted(
fileTransferResponse,
socket,
_token);
if (sendFile.Failure)
{
OutboundFileTransferInProgress?.Invoke(this, false);
return;
}
OutboundFileTransferInProgress?.Invoke(this, false);
SuccessfullyProcessedRequest?.Invoke(this, fileTransferResponse);
}
void HandleRequestedFileDoesNotExist(object sender, FileTransferResponse fileTransferResponse)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedNotificationFileDoesNotExist,
RemoteServerIpAddress = fileTransferResponse.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = fileTransferResponse.RemoteServerInfo.PortNumber,
FileTransferId = fileTransferResponse.RemoteServerTransferId
});
EventOccurred?.Invoke(this, _eventLog.Last());
var rejectTransfer =
FileTransferHandler.HandleRequestedFileDoesNotExist(
fileTransferResponse.RemoteServerTransferId);
if (rejectTransfer.Failure)
{
return;
}
SuccessfullyProcessedRequest?.Invoke(this, fileTransferResponse);
}
void HandleInboundFileTransferRequest(object sender, SendFileRequest sendFileRequest)
{
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedInboundFileTransferRequest,
LocalFolder = sendFileRequest.LocalFolderPath,
FileName = sendFileRequest.FileName,
FileSizeInBytes = sendFileRequest.FileSizeInBytes,
RemoteServerIpAddress = sendFileRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = sendFileRequest.RemoteServerInfo.PortNumber
});
EventOccurred?.Invoke(this, _eventLog.Last());
var handleTransferRequest =
FileTransferHandler.HandleInboundFileTransferRequest(sendFileRequest);
if (handleTransferRequest.Failure)
{
return;
}
SuccessfullyProcessedRequest?.Invoke(this, sendFileRequest);
}
private void HandleShutdownServerCommand(object sender, Request pendingRequest)
{
if (!MyInfo.IsEqualTo(pendingRequest.RemoteServerInfo))
{
var error =
"Server shutdown command was received, but the command was not sent " +
"by this server. Aborting shutdown process.";
ReportError(this, error);
return;
}
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedShutdownServerCommand,
RemoteServerIpAddress = pendingRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = pendingRequest.RemoteServerInfo.PortNumber,
RequestId = pendingRequest.Id
});
EventOccurred?.Invoke(this, _eventLog.Last());
ShutdownInitiated?.Invoke(this, new EventArgs());
SuccessfullyProcessedRequest?.Invoke(this, pendingRequest);
}
void ReceivedNewMessage(object sender, MessageRequest messageRequest)
{
_messageHandler.AddNewReceivedMessage(messageRequest);
SuccessfullyProcessedRequest?.Invoke(this, messageRequest);
}
async void HandleFileListRequest(object sender, FileListRequest fileListRequest)
{
MyInfo.TransferFolder = fileListRequest.TransferFolderPath;
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedFileListRequest,
RemoteServerIpAddress = fileListRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = fileListRequest.RemoteServerInfo.PortNumber,
LocalFolder = MyInfo.TransferFolder
});
EventOccurred?.Invoke(this, _eventLog.Last());
if (!Directory.Exists(MyInfo.TransferFolder))
{
var foldesDoesNotExist = new Request(RequestType.RequestedFolderDoesNotExist)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileListRequest.RemoteServerInfo,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
await _requestHandler.SendRequestAsync(foldesDoesNotExist);
return;
}
var fileInfoList = new FileInfoList(MyInfo.TransferFolder);
if (fileInfoList.Count == 0)
{
var folderIsEmpty = new Request(RequestType.RequestedFolderIsEmpty)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileListRequest.RemoteServerInfo,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
await _requestHandler.SendRequestAsync(folderIsEmpty);
return;
}
var fileListResponse = new FileListResponse
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileListRequest.RemoteServerInfo,
FileInfoList = fileInfoList,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
var sendRequest = await _requestHandler.SendRequestAsync(fileListResponse);
if (sendRequest.Failure)
{
return;
}
SuccessfullyProcessedRequest?.Invoke(this, fileListRequest);
}
