public void SessionConstructorInitialisesTheValues()
{
var sessionId = "MyNewSession";
var request = new FileTransferRequest(sessionId);
Assert.AreEqual(sessionId, request.SessionToken);
}
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 FileNameCanBeSetAndRetrieved()
{
var request = new FileTransferRequest();
var projectName = "projectName";
request.FileName = projectName;
Assert.AreEqual(projectName, request.FileName);
}
public FileTransferResponse SendFileToServerTempFolder(string fileName, byte[] bytes)
{
FileTransferRequest createdFile = new FileTransferRequest()
{
FileName = fileName,
Content = bytes
};
return(proxy.Receive(createdFile, true));
}
public static byte[] GetResponse(byte[] receivedData)
{
FileTransferRequest request = RequestHandler.RestoreRequest <FileTransferRequest>(receivedData);
IEnumerable <BasicDataset> predictions = GetPrediction(request);
PredictionResponse response = CreateResponse(predictions);
return(ResponseManager.CreateByteResponse(response));
}
/// <summary>
/// Retrieve a file transfer object.
/// </summary>
/// <param name="project">The project to retrieve the file for.</param>
/// <param name="fileName">The name of the file.</param>
public virtual RemotingFileTransfer RetrieveFileTransfer(string project, string fileName)
{
var request = new FileTransferRequest();
request.ProjectName = project;
request.FileName = fileName;
var response = cruiseServer.RetrieveFileTransfer(request);
ValidateResponse(response);
return(response.FileTransfer as RemotingFileTransfer);
}
public byte[] GetFile(string name, FileType type)
{
FileTransferRequest request = new FileTransferRequest()
{
FileName = name,
FileType = type
};
var result = proxy.GetFile(request);
return(result.File);
}
public void FullConstructorInitialisesTheValues()
{
var sessionId = "MyNewSession";
var projectName = "projectName";
var fileName = "fileName";
var request = new FileTransferRequest(sessionId, projectName, fileName);
Assert.AreEqual(sessionId, request.SessionToken);
Assert.AreEqual(projectName, request.ProjectName);
Assert.AreEqual(fileName, request.FileName);
}
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 Execute(ISender client, FileTransferRequest message)
{
new Thread(() =>
{
_limitThreads.WaitOne();
try
{
using (var srcFile = new FileSplit(message.RemotePath, FileAccess.Read))
{
_activeTransfers[message.Id] = srcFile;
foreach (var chunk in srcFile)
{
if (_token.IsCancellationRequested || !_activeTransfers.ContainsKey(message.Id))
{
break;
}
// blocking sending might not be required, needs further testing
_client.SendBlocking(new FileTransferChunk
{
Id = message.Id,
FilePath = message.RemotePath,
FileSize = srcFile.FileSize,
Chunk = chunk
});
}
client.Send(new FileTransferComplete
{
Id = message.Id,
FilePath = message.RemotePath
});
}
}
catch (Exception)
{
client.Send(new FileTransferCancel
{
Id = message.Id,
Reason = "Error reading file"
});
}
finally
{
RemoveFileTransfer(message.Id);
_limitThreads.Release();
}
}).Start();
}
/// <summary>
/// Retrieves a file transfer instance.
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="fileName">The name of the file.</param>
/// <returns>The file transfer instance.</returns>
public override IFileTransfer RetrieveFileTransfer(string projectName, string fileName)
{
if (string.IsNullOrEmpty(projectName))
{
throw new ArgumentNullException("projectName");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
var request = new FileTransferRequest(SessionToken, projectName, fileName);
request.ServerName = TargetServer;
var response = connection.SendMessage("RetrieveFileTransfer", request);
ValidateResponse(response);
return((response as FileTransferResponse).FileTransfer);
}
private FileTransferResponse CheckFileTransferRequest(FileTransferRequest fileToPush)
{
if (fileToPush != null)
{
if (!string.IsNullOrEmpty(fileToPush.FileName))
{
if (fileToPush.Content != null)
{
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = fileToPush.FileName,
Message = string.Empty,
ResponseStatus = "FileIsValed"
});
}
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = "No Name",
Message = " File Content is null",
ResponseStatus = "Error"
});
}
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = "No Name",
Message = " File Name Can't be Null",
ResponseStatus = "Error"
});
}
return(new FileTransferResponse
{
CreateAt = DateTime.Now,
FileName = "No Name",
Message = " File Can't be Null",
ResponseStatus = "Error"
});
}
public void RestoreFileTransfer_InitialRequest_SameRequestExpected()
{
// arrange
byte[] fileBytes = File.ReadAllBytes("fortests/XTSE-AAB.csv");
FileTransferRequest request = new FileTransferRequest(fileBytes);
byte[] requestBytes = new RequestManager().CreateByteRequest <FileTransferRequest>(request);
// act
Request restoredRequest = RequestHandler.RestoreRequest <FileTransferRequest>(requestBytes);
// assert
CompareLogic compareLogic = new CompareLogic();
var comparsionResult = compareLogic.Compare(request, restoredRequest);
Assert.IsTrue(comparsionResult.AreEqual);
}
public static void HandleDoDownloadFile(FileTransferRequest command, Networking.Client client)
{
new Thread(() =>
{
LimitThreads.WaitOne();
try
{
using (var srcFile = new FileSplit(command.RemotePath, FileAccess.Read))
{
ActiveTransfers[command.Id] = srcFile;
foreach (var chunk in srcFile)
{
if (!client.Connected || !ActiveTransfers.ContainsKey(command.Id))
{
break;
}
// blocking sending might not be required, needs further testing
client.SendBlocking(new FileTransferChunk
{
Id = command.Id,
FilePath = command.RemotePath,
FileSize = srcFile.FileSize,
Chunk = chunk
});
}
}
}
catch (Exception)
{
client.Send(new FileTransferCancel
{
Id = command.Id,
Reason = "Error reading file"
});
}
finally
{
RemoveFileTransfer(command.Id);
LimitThreads.Release();
}
}).Start();
}
public FileTransferRequest GenerateTransferRequest(FileBlockInfo info, int randomSeed)
{
var request = new FileTransferRequest()
{
BlockIndex = 0,
BlockCount = info.BlockCount,
LastBlockSize = info.LastBlockSize,
EachBlockSize = info.BlockSize,
FileMd5 = info.FileMd5,
FileName = info.FileName,
FileSuffix = Path.GetExtension(info.FileName),
FileSize = info.FileLength,
IsSendingOver = false,
SeekOffset = 0,
BlockData = null,
RequestId = randomSeed
};
return(request);
}
/// <summary>
/// 检查是否处于断点续传状态
/// </summary>
/// <param name="responsed"></param>
/// <param name="request"></param>
/// <param name="info"></param>
/// <param name="fsPosition"></param>
/// <param name="positionOffset"></param>
/// <param name="sendBlockSize"></param>
private void OfflineReSendCheck(FileTransferResponsed responsed, FileTransferRequest request, FileBlockInfo info, long fsPosition, ref long positionOffset, ref int sendBlockSize)
{
if (responsed.RemoteStreamPosition == fsPosition)
{
request.BlockIndex++;
}
else
{
int rBlockIndex = 0;
long rPosition = 0;
ClacBlockIndex(info, responsed.RemoteStreamPosition, out rBlockIndex, out rPosition);
request.BlockIndex = rBlockIndex;
positionOffset = rPosition;
}
if (info.BlockSize > info.FileLength - positionOffset)
{
sendBlockSize = (int)(info.FileLength - positionOffset);
}
}
public FileTransferResponsed WriteFile(FileTransferRequest transferData)
{
var id = transferData.RequestId;
if (!_contextDic.ContainsKey(transferData.RequestId))//若同一个服务同时上传多个文件，则创建多个维护状态模式的Context，通过RequestID识别
{
_contextDic.Add(id, new FileWriteHandleContext(new StateFileFirstUpdate()));
ContextRequest contextRequest = new ContextRequest(this._receiveProgressHandler)
{
WorkingPath = FileNameTools.GetDownloadingFullPath(transferData.FileName)
};
_contextRequestDic.Add(id, contextRequest);
}
_contextRequestDic[id].FileRequest = transferData;
#if DEBUG
//Console.WriteLine($"Data ID={id}");
#endif
var responsed = _contextDic[id].Request(_contextRequestDic[id]);
transferData.BlockData = null;//销毁缓存
return(responsed);
}
public FileTransferResponse GetFile(FileTransferRequest request)
{
string path = DirectoryPath + request.FileName;
try
{
if (request.FileType == FileType.XML)
{
return(Helpers.PreapreToSend(path));
}
else
{
Helpers.ToCsv(path, DirectoryPath);
var result = Helpers.PreapreToSend(DirectoryPath + "tmp.csv");
File.Delete(DirectoryPath + "tmp.csv");
return(result);
}
}
catch (Exception)
{
Helpers.ReturnRequest();
return(null);
}
}
public FileTransferResponsed TransferFileData(FileTransferRequest transferData)
{
return(_fileWriter.WriteFile(transferData));
}
/// <summary>
/// 根据反馈，重发文件
/// </summary>
/// <param name="path"></param>
/// <param name="fileBlockInfo"></param>
/// <param name="request"></param>
/// <param name="checkResponsed"></param>
private bool ReSendFile(string path, FileBlockInfo fileBlockInfo, FileTransferRequest request, FileTransferResponsed checkResponsed)
{
return(ReSendFile(path, _fileStreamDic[path], fileBlockInfo, request, checkResponsed));
}
/// <summary>
/// 根据反馈结果，重发文件
/// </summary>
/// <param name="path"></param>
/// <param name="fs"></param>
/// <param name="fileBlockInfo"></param>
/// <param name="request"></param>
/// <param name="checkResponsed"></param>
public bool ReSendFile(string path, FileStream fs, FileBlockInfo fileBlockInfo, FileTransferRequest request, FileTransferResponsed checkResponsed)
{
int resendCountOut = 0;
while (!checkResponsed.FileMd5CheckResult && resendCountOut < 3)//最多重发三次
{
#if DEBUG
Console.WriteLine("ReSending File, count " + resendCountOut);
#endif
//MD5检查失败重发
var blockMsgList = ClacFileEachBlockMd5(fileBlockInfo, fs);
if (blockMsgList.Count != fileBlockInfo.BlockCount)
{
throw new Exception("校准MD5时，Block数量计算错误!");
}
int size = request.EachBlockSize;
request.IsSendingOver = false;
for (int i = 0; i < blockMsgList.Count; i++)
{
var blockCheck = _sendAdapter.UpdateFileBlockMessage(blockMsgList[i]);
if (blockCheck.IsError)
{
if (i == blockMsgList.Count - 1)
{
size = request.LastBlockSize;
}
request.BlockIndex = i;
request.SeekOffset = i * fileBlockInfo.BlockSize;
request.BlockData = ReadFileBytes(path, request.SeekOffset, size);
_sendAdapter.UpdateFileData(request);
}
}
request.IsSendingOver = true;
checkResponsed = _sendAdapter.UpdateFileData(request);
resendCountOut++;
}
return(checkResponsed.FileMd5CheckResult);
}
/// <summary>
/// 传输文件
/// </summary>
/// <param name="path"></param>
/// <param name="progress"></param>
/// <param name="fileBlockInfo"></param>
/// <param name="request"></param>
private void OnSendFile(string path, ProgressMessage progress, FileBlockInfo fileBlockInfo, FileTransferRequest request)
{
var fs = _fileStreamDic[path];
OnSendFile(path, fs, progress, fileBlockInfo, request);
}
private void OnSendFile(string path, FileStream fs, ProgressMessage progress, FileBlockInfo fileBlockInfo, FileTransferRequest request)
{
fs.Position = 0;
long positionOffset = 0;
int sendBlockSize = request.EachBlockSize;
if (progress != null)
{
progress.Title = fileBlockInfo.FileName;
progress.MaxValue = fileBlockInfo.BlockCount;
progress.StateMsg = "Prepare OK";
try
{
_progressHandler?.OnSendStart(fileBlockInfo.FileName, progress);
#if DEBUG
Console.WriteLine(progress.StateMsg);
#endif
}
catch
{
// ignored
}
}
//普通循环读取和发送文件
while (fs.Position < fs.Length)
{
request.BlockData = null;
request.SeekOffset = positionOffset;
var buffer = ReadFileBytes(path, fs.Position, sendBlockSize);
request.BlockData = buffer;
var responsed = _sendAdapter.UpdateFileData(request);
_responsedHandler?.HandleResponsed(responsed);//等待外部对回应进行处理
positionOffset = responsed.RemoteStreamPosition;
OfflineReSendCheck(responsed, request, fileBlockInfo, fs.Position, ref positionOffset, ref sendBlockSize); //文件离线重传检查
fs.Position = positionOffset; //进度对齐
if (progress != null)
{
progress.ProgressValue = request.BlockIndex;
try
{
_progressHandler?.OnSending(fileBlockInfo.FileName);
#if DEBUG
Console.Write($"{progress.ProgressValue}/{progress.MaxValue}");
Console.SetCursorPosition(0, Console.CursorTop);
ClearCurrentConsoleLine();
#endif
}
catch
{
// ignored
}
}
}
}
public FileTransferResponsed UpdateFileData(FileTransferRequest transferData)
{
return(Channel.UpdateFile(transferData));
}
public Task <FileTransferResponsed> UpdateFileAsync(FileTransferRequest transferData)
{
return(Channel.UpdateFileAsync(transferData));
}
public Task <FileTransferResponsed> UpdateFileDataAsync(int prot, FileTransferRequest request)
{
return(Channel.UpdateFileDataAsync(prot, request));
}
public FileTransferResponsed UpdateFileData(FileTransferRequest transferData)
{
return(writer.WriteFile(transferData));
}
/// <summary>
/// Retrieve a file transfer object.
/// </summary>
public FileTransferResponse RetrieveFileTransfer(FileTransferRequest request)
{
return(cruiseServer.RetrieveFileTransfer(request));
}
public FileTransferResponsed UpdateFileData(FileTransferRequest transferData)
{
return(_proxy.UpdateFileData(_targetPort, transferData));
}
public void TransferFiles(FileTransferRequest transfer)
{
Log.InfoFormat("TransferFiles: {0}", transfer);
this.LastRequest = transfer;
}
