public Result HandleOutboundFileTransferRejected(FileTransferResponse fileTransferResponse)
{
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return(getFileTransfer);
}
var outboundFileTransfer = getFileTransfer.Value;
outboundFileTransfer.Status = FileTransferStatus.Rejected;
outboundFileTransfer.ErrorMessage = "File transfer was rejected by remote server";
RejectPendingFileTransfer(outboundFileTransfer);
var error =
"File transfer was rejected by remote server:" +
Environment.NewLine + Environment.NewLine + outboundFileTransfer.OutboundRequestDetails();
ReportError(error);
return(Result.Ok());
}
public async Task <Result> SendNotificationFileTransferStalledAsync(int fileTransferId)
{
var handleTransferStalled = FileTransferHandler.HandleInboundFileTransferStalled(fileTransferId);
if (handleTransferStalled.Failure)
{
return(handleTransferStalled);
}
var fileTransfer = handleTransferStalled.Value;
var notifyTransferStalled = new FileTransferResponse(RequestType.FileTransferStalled)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileTransfer.RemoteServerInfo,
TransferResponseCode = fileTransfer.TransferResponseCode,
RemoteServerTransferId = fileTransfer.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
InboundFileTransferInProgress?.Invoke(this, false);
return(await _requestHandler.SendRequestAsync(notifyTransferStalled));
}
public FileTransferResponse GetFile(string name)
{
FileTransferRequest fileToDownload = proxy.GetFile(name);
FileTransferResponse fileTransferResponse = this.CheckFileTransferRequest(fileToDownload);
if (fileTransferResponse.ResponseStatus == "FileIsValed")
{
try
{
this.SaveFileStream(System.Configuration.ConfigurationManager.AppSettings["SavedLocation"].ToString() + "\\" + fileToDownload.FileName, new MemoryStream(fileToDownload.Content));
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = fileToDownload.FileName,
Message = "File was downloaded",
ResponseStatus = "Successful"
});
}
catch (Exception ex)
{
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = fileToDownload.FileName,
Message = ex.Message,
ResponseStatus = "Error"
});
}
}
return(fileTransferResponse);
}
public void FileTransferCanBeSetAndRetrieved()
{
var request = new FileTransferResponse();
var transfer = Mock.Of <IFileTransfer>(MockBehavior.Strict);
request.FileTransfer = transfer;
Assert.AreEqual(transfer, request.FileTransfer);
}
public void RequestConstructorInitialisesTheValues()
{
var request = new EncryptedRequest();
var response = new FileTransferResponse(request);
// Only check one property is set, since the properties are set by the base class
Assert.AreEqual(request.Identifier, response.RequestIdentifier);
}
public void FileTransferCanBeSetAndRetrieved()
{
var request = new FileTransferResponse();
var mocks = new MockRepository();
var transfer = mocks.StrictMock <IFileTransfer>();
request.FileTransfer = transfer;
Assert.AreEqual(transfer, request.FileTransfer);
}
public void FullConstructorInitialisesTheValues()
{
var response1 = new FileTransferResponse();
response1.RequestIdentifier = "12345";
var response2 = new FileTransferResponse(response1);
// Only check one property is set, since the properties are set by the base class
Assert.AreEqual(response1.RequestIdentifier, response2.RequestIdentifier);
}
public async Task ArchiveChannel(ISocketMessageChannel channel, [Remainder] string title)
{
var messages = await channel.GetMessagesAsync().Flatten();
using (ChannelArchive archive = new ChannelArchive(title))
{
string voteEmote = _settings.Has("brackeys-emote") ? _settings.Get("brackeys-emote").Split(':').First() : string.Empty;
foreach (IMessage msg in messages)
{
ArchiveMessage archiveMessage = new ArchiveEventSubmission(msg, voteEmote);
IEnumerable <ArchiveImage> archiveImages = archiveMessage.GetMessageImages();
archive.AddMessage(archiveMessage);
foreach (ArchiveImage image in archiveImages)
{
archive.AddImage(image);
}
}
archive.CloseArchive();
string zippedArchive = archive.ZipArchive();
WeTransferClient wt = new WeTransferClient(BrackeysBot.Configuration["wetransfer-api-key"]);
// Make sure we are authorized
await wt.Authorize();
var fileInfo = new System.IO.FileInfo(zippedArchive);
// Create Partial File Information so WeTransfer knows how many files
// you're going to upload, the names of those files and their sizes
PartialFileInfo[] partialFileInfos = new PartialFileInfo[]
{
new PartialFileInfo
{
Name = fileInfo.Name,
Path = fileInfo.FullName,
Size = (int)fileInfo.Length
}
};
// Create a File Transfer which informs WeTransfer that you're about to upload files
// The second parameter is the transfer message which will show on the download page
FileTransferResponse response = await wt.CreateTransfer(partialFileInfos, $"Download the archived channel #{channel.Name}!");
// Now you can upload the files!
// The first parameter is the transfer's ID
await wt.Upload(response.ID, response.Files);
// Now you need to tell WeTransfer that your files have been uploaded
FileUploadResult result = await wt.FinalizeUpload(response.ID, response.Files);
// FileUploadResult contains the url to the download page and the date of the expiry
StringBuilder reply = new StringBuilder()
.AppendLine($"I archived the channel <#{channel.Id}> for you{(title == channel.Name ? "!" : $", under the name **{title}**!")}")
private void button2_Click(object sender, EventArgs e)
{
FileTransferManager transfer = new FileTransferManager();
FileTransferResponse success = transfer.GetFile("App.config.transform");
FileDescription[] descs = transfer.GetServerFilesInfoFromTempFolder();
foreach (var item in descs)
{
listBox1.Items.Add(item.Name + " " + (item.SizeBytes / 1000000) + "Mb");
}
}
public void RetrieveFileTransfer()
{
var response = new FileTransferResponse();
response.Result = ResponseResult.Success;
response.FileTransfer = this.mocks.StrictMock <IFileTransfer>();
var client = new CruiseServerClient(
new ServerStub("RetrieveFileTransfer", typeof(FileTransferRequest), "Project #1", response));
var result = client.RetrieveFileTransfer("Project #1", "Build #1");
Assert.AreSame(response.FileTransfer, result);
}
private static void FileWatcher_Created(Object sender, FileSystemEventArgs e)
{
FileTransferResponse response = null;
try
{
if (!IsFileLocked(e.FullPath))
{
var startAt = DateTime.Now;
var createdFile = new FileTransferRequest()
{
FileName = e.Name,
Content = File.ReadAllBytes(e.FullPath)
};
response = new FileTransferClient().Put(createdFile);
if (response.ResponseStatus != "Successful")
{
MoveToFailedFolder(e);
}
else
{
if (File.Exists(e.FullPath))
{
File.Delete(e.FullPath);
}
}
Console.WriteLine(response.ResponseStatus + " at: " + DateTime.Now.Subtract(startAt));
new Logger().Create(e.Name, DateTime.Now, response.ResponseStatus, response.Message);
}
}
catch (CommunicationException ex)
{
MoveToFailedFolder(e);
Console.WriteLine(ex.Message);
new Logger().Create(e.Name, DateTime.Now, "Error", ex.Message);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
if (response != null)
{
new Logger().Create(e.Name, DateTime.Now, response.ResponseStatus, response.Message);
}
else
{
new Logger().Create(e.Name, DateTime.Now, "Error", ex.Message);
}
}
}
private void button1_Click(object sender, EventArgs e)
{
using (OpenFileDialog openFileDialog = new OpenFileDialog())
{
openFileDialog.Title = "Select File";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
byte[] bytes = File.ReadAllBytes(openFileDialog.FileName);
string name = openFileDialog.FileName.Substring(openFileDialog.FileName.LastIndexOf('\\') + 1);
FileTransferManager transfer = new FileTransferManager();
FileTransferResponse success = transfer.SendFileToServerTempFolder(name, bytes);
}
}
}
/// <summary>
/// Executes the specified cruise request.
/// </summary>
/// <param name="cruiseRequest">The cruise request.</param>
/// <returns></returns>
public IResponse Execute(ICruiseRequest cruiseRequest)
{
string fileName = cruiseRequest.Request.GetText("file");
string label = cruiseRequest.Request.GetText("label");
string path = fileName;
if (!string.IsNullOrEmpty(label))
{
path = Path.Combine(label, fileName);
}
RemotingFileTransfer fileTransfer = farmService.RetrieveFileTransfer(cruiseRequest.ProjectSpecifier, path, cruiseRequest.RetrieveSessionToken());
FileTransferResponse response = new FileTransferResponse(fileTransfer, fileName);
return(response);
}
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);
}
public async Task <Result> RejectInboundFileTransferAsync(FileTransfer fileTransfer)
{
FileTransferHandler.RejectInboundFileTransfer(fileTransfer);
var rejectTransfer = new FileTransferResponse(RequestType.FileTransferRejected)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileTransfer.RemoteServerInfo,
TransferResponseCode = fileTransfer.TransferResponseCode,
RemoteServerTransferId = fileTransfer.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
return(await _requestHandler.SendRequestAsync(rejectTransfer));
}
public void HandleRetryOutboundFileTransfer(FileTransferResponse fileTransferResponse)
{
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return;
}
var canceledFileTransfer = getFileTransfer.Value;
RetryStalledFileTransfer(canceledFileTransfer);
ReceivedRetryOutboundFileTransferRequest?.Invoke(this, canceledFileTransfer);
}
async Task SendNotificationFileTransferComplete(FileTransfer inboundFileTransfer)
{
var fileTransferComplete = new FileTransferResponse(RequestType.FileTransferComplete)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = inboundFileTransfer.RemoteServerInfo,
TransferResponseCode = inboundFileTransfer.TransferResponseCode,
RemoteServerTransferId = inboundFileTransfer.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
InboundFileTransferInProgress?.Invoke(this, false);
await _requestHandler.SendRequestAsync(fileTransferComplete);
}
public static FileTransferResponse PreapreToSend(string path)
{
path += ".xml";
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
byte[] bytes = System.IO.File.ReadAllBytes(path);
fs.Read(bytes, 0, System.Convert.ToInt32(fs.Length));
fs.Close();
FileTransferResponse file = new FileTransferResponse()
{
File = bytes,
NameFile = fs.Name.Substring(fs.Name.LastIndexOf("\\")).Replace("\\", string.Empty)
};
return(file);
}
}
public void AbortOutboundFileTransfer(FileTransferResponse fileTransferResponse, string error)
{
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return;
}
var fileTransfer = getFileTransfer.Value;
fileTransfer.Status = FileTransferStatus.Error;
fileTransfer.ErrorMessage = error;
PendingFileTransferHasFailed(fileTransfer);
}
public virtual async Task <Result> HandleOutboundFileTransferAccepted(
FileTransferResponse fileTransferResponse,
Socket socket,
CancellationToken token)
{
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return(getFileTransfer);
}
var outboundFileTransfer = getFileTransfer.Value;
outboundFileTransfer.Status = FileTransferStatus.Accepted;
StartProcessingPendingFileTransfer(outboundFileTransfer);
if (socket == null)
{
var error = "Unable to retrieve transfer socket, file transfer must be aborted";
outboundFileTransfer.Status = FileTransferStatus.Error;
outboundFileTransfer.ErrorMessage = error;
InProgressFileTransferHasFailed(outboundFileTransfer);
ReportError(error);
return(Result.Fail(error));
}
var sendFile = await FileSender.SendFileAsync(outboundFileTransfer, socket, token);
if (sendFile.Success)
{
return(Result.Ok());
}
outboundFileTransfer.Status = FileTransferStatus.Error;
outboundFileTransfer.ErrorMessage = sendFile.Error;
InProgressFileTransferHasFailed(outboundFileTransfer);
ReportError(sendFile.Error);
return(sendFile);
}
protected override async Task SendFile(string clientName, byte[] fileHash)
{
var fileInfo = new FileInfo(Path.Combine(StoragePath, Hasher.GetDirectoryNameFromHash(fileHash), Hasher.GetFileNameFromHash(fileHash)));
var buffer = new byte[BufferSize];
var totalBytes = fileInfo.Length;
await Communicator.SendMessage(clientName, new FileStartMessage(fileHash));
var chunkMessage = new FileChunckMessage {
FileHash = fileHash
};
if (FileTransferResponse.ContainsKey(fileHash))
{
FileTransferResponse.Remove(fileHash);
}
FileTransferResponse.Add(fileHash, false);
using (var fileStream = fileInfo.OpenRead())
{
var bytesRemaining = totalBytes;
while (bytesRemaining > 0)
{
var chunkSize = (int)((bytesRemaining < BufferSize) ? bytesRemaining : BufferSize);
if (chunkSize < BufferSize)
{
buffer = new byte[chunkSize];
}
var bytesRead = fileStream.Read(buffer, 0, chunkSize);
chunkMessage.FileData = buffer;
await Communicator.SendMessage(clientName, chunkMessage);
bytesRemaining -= bytesRead;
while (!FileTransferResponse[fileHash])
{
await Task.Delay(1);
}
FileTransferResponse[fileHash] = false;
}
}
await Communicator.SendMessage(clientName, new FileEndMessage(fileHash));
}
public Result HandleOutboundFileTransferComplete(FileTransferResponse fileTransferResponse)
{
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return(getFileTransfer);
}
var outboundFileTransfer = getFileTransfer.Value;
outboundFileTransfer.Status = FileTransferStatus.ConfirmedComplete;
SuccessfullySentFileTransfer(outboundFileTransfer);
return(Result.Ok());
}
public Result AbortInboundFileTransfer(FileTransferResponse fileTransferResponse, string error)
{
var getFileTransfer = GetFileTransferById(fileTransferResponse.RemoteServerTransferId);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return(getFileTransfer);
}
var fileTransfer = getFileTransfer.Value;
fileTransfer.Status = FileTransferStatus.Error;
fileTransfer.ErrorMessage = error;
PendingFileTransferHasFailed(fileTransfer);
ReportError(error);
return(Result.Ok());
}
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);
}
public Result HandleOutboundFileTransferStalled(FileTransferResponse fileTransferResponse)
{
const string fileTransferStalledErrorMessage =
"Aborting file transfer, client says that data is no longer being received (HandleStalledFileTransfer)";
var getFileTransfer = GetFileTransferByResponseCode(fileTransferResponse);
if (getFileTransfer.Failure)
{
ReportError(getFileTransfer.Error);
return(getFileTransfer);
}
var outboundFileTransfer = getFileTransfer.Value;
outboundFileTransfer.Status = FileTransferStatus.Cancelled;
outboundFileTransfer.ErrorMessage = fileTransferStalledErrorMessage;
outboundFileTransfer.OutboundFileTransferStalled = true;
FileTransferHasStalled(outboundFileTransfer);
ReportError(fileTransferStalledErrorMessage);
return(Result.Ok());
}
Result <FileTransfer> GetFileTransferByResponseCode(FileTransferResponse fileTransferResponse)
{
var responseCode = fileTransferResponse.TransferResponseCode;
var remoteServerInfo = fileTransferResponse.RemoteServerInfo;
var matches =
GetAllFileTransfers().Select(t => t)
.Where(t => t.TransferResponseCode == responseCode)
.ToList();
if (matches.Count == 0)
{
var error =
$"No file transfer was found with a response code value of {responseCode} " +
$"(Request received from {remoteServerInfo.SessionIpAddress}:{remoteServerInfo.PortNumber})";
return(Result.Fail <FileTransfer>(error));
}
return(matches.Count == 1
? Result.Ok(matches[0])
: Result.Fail <FileTransfer>(
$"Found {matches.Count} file transfers with the same response code value of {responseCode}"));
}
public async Task <Result> RetryFileTransferAsync(int fileTransferId)
{
var getFileTransfer = FileTransferHandler.RetryStalledInboundFileTransfer(fileTransferId);
if (getFileTransfer.Failure)
{
return(getFileTransfer);
}
var stalledFileTransfer = getFileTransfer.Value;
var retryTransfer = new FileTransferResponse(RequestType.RetryOutboundFileTransfer)
{
LocalServerInfo = MyInfo,
RemoteServerInfo = stalledFileTransfer.RemoteServerInfo,
TransferResponseCode = stalledFileTransfer.TransferResponseCode,
RemoteServerTransferId = stalledFileTransfer.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
FileHelper.DeleteFileIfAlreadyExists(stalledFileTransfer.LocalFilePath, 5);
return(await _requestHandler.SendRequestAsync(retryTransfer));
}
