public void Can_Get_Correct_Chunk_Transfer_File_Bytes_Request_Message(uint chunks)
{
int byteLengthForChunks = (int) (Constants.FileTransferChunkSize * chunks);
byte[] expectedBytes =
Enumerable.Range(0, byteLengthForChunks).Select(i => (byte) i).ToArray();
using (MemoryStream ms = new MemoryStream(expectedBytes))
{
var uploadFileInformation = new UploadFileTransferInformation(
ms,
PeerIdHelper.GetPeerId("test1"),
PeerIdHelper.GetPeerId("test2"),
null,
CorrelationId.GenerateCorrelationId());
for (uint chunkToTest = 0; chunkToTest < chunks; chunkToTest++)
{
var startIdx = (int) chunkToTest * Constants.FileTransferChunkSize;
var expectedChunk = expectedBytes.Skip(startIdx).Take(Constants.FileTransferChunkSize);
var uploadDto = uploadFileInformation.GetUploadMessageDto(chunkToTest);
var transferRequest = uploadDto.Content.FromProtocolMessage<TransferFileBytesRequest>();
transferRequest.ChunkBytes.ToArray()
.SequenceEqual(expectedChunk).Should().BeTrue();
}
}
}
private async Task AddFileToDfs(long byteSize)
{
var fakeNode = Substitute.For <IRpcClient>();
var sender = PeerIdHelper.GetPeerId("sender");
var recipient = PeerIdHelper.GetPeerId("recipient");
var senderPeerId = sender;
var peerSettings = senderPeerId.ToSubstitutedPeerSettings();
var recipientPeerId = recipient;
var fileToTransfer = FileHelper.CreateRandomTempFile(byteSize);
var addFileToDfsRequestHandler =
new AddFileToDfsRequestObserver(_dfs, peerSettings, _nodeFileTransferFactory, _logger);
var transferBytesRequestHandler =
new TransferFileBytesRequestObserver(_nodeFileTransferFactory, peerSettings, _logger);
var uniqueFileKey = CorrelationId.GenerateCorrelationId();
var crcValue = FileHelper.GetCrcValue(fileToTransfer);
//Create a response object and set its return value
var request = new AddFileToDfsRequest
{
Node = "node1",
FileName = fileToTransfer,
FileSize = (ulong)byteSize
}.ToProtocolMessage(sender, uniqueFileKey);
request.SendToHandler(_fakeContext, addFileToDfsRequestHandler);
Assert.Single(_nodeFileTransferFactory.Keys);
var fileTransferInformation =
_nodeFileTransferFactory.GetFileTransferInformation(uniqueFileKey);
Assert.True(fileTransferInformation.Initialised, "File transfer not initialised");
using (var fs = File.Open(fileToTransfer, FileMode.Open))
{
var fileUploadInformation = new UploadFileTransferInformation(fs, senderPeerId, recipientPeerId,
fakeNode.Channel, uniqueFileKey);
for (uint i = 0; i < fileTransferInformation.MaxChunk; i++)
{
fileUploadInformation.GetUploadMessageDto(i).Content
.SendToHandler(_fakeContext, transferBytesRequestHandler);
}
}
Assert.True(fileTransferInformation.ChunkIndicatorsTrue());
await TaskHelper.WaitForAsync(() => fileTransferInformation.DfsHash != null, TimeSpan.FromSeconds(15));
Assert.NotNull(fileTransferInformation.DfsHash);
long ipfsCrcValue;
using (var ipfsStream = await _dfs.ReadAsync(fileTransferInformation.DfsHash))
{
ipfsCrcValue = FileHelper.GetCrcValue(ipfsStream);
}
Assert.Equal(crcValue, ipfsCrcValue);
}
public async Task Get_File_Rpc(long byteSize)
{
var addedIpfsHash = AddFileToDfs(byteSize, out var crcValue, out var stream);
Stream fileStream = null;
try
{
var nodePeerId = PeerIdHelper.GetPeerId("sender");
var rpcPeerId = PeerIdHelper.GetPeerId("recipient");
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.PeerId.Returns(rpcPeerId);
var nodePeer = nodePeerId;
var rpcPeer = rpcPeerId;
var correlationId = CorrelationId.GenerateCorrelationId();
var fakeFileOutputPath = Path.GetTempFileName();
IDownloadFileInformation fileDownloadInformation = new DownloadFileTransferInformation(rpcPeer,
nodePeer,
_fakeContext.Channel, correlationId, fakeFileOutputPath, 0);
var getFileFromDfsResponseHandler =
new GetFileFromDfsResponseObserver(_logger, _fileDownloadFactory);
var transferBytesHandler =
new TransferFileBytesRequestObserver(_fileDownloadFactory, peerSettings, _logger);
_fileDownloadFactory.RegisterTransfer(fileDownloadInformation);
var getFileResponse = new GetFileFromDfsResponse
{
FileSize = (ulong)byteSize,
ResponseCode = ByteString.CopyFrom((byte)FileTransferResponseCodeTypes.Successful.Id)
}.ToProtocolMessage(nodePeer, correlationId);
getFileResponse.SendToHandler(_fakeContext, getFileFromDfsResponseHandler);
fileStream = await _dfsService.UnixFsApi.ReadFileAsync(addedIpfsHash.ToString());
IUploadFileInformation fileUploadInformation = new UploadFileTransferInformation(
fileStream,
rpcPeer,
nodePeer,
_fakeContext.Channel,
correlationId);
for (uint i = 0; i < fileUploadInformation.MaxChunk; i++)
{
var transferMessage = fileUploadInformation
.GetUploadMessageDto(i);
transferMessage.Content.SendToHandler(_fakeContext, transferBytesHandler);
}
await TaskHelper.WaitForAsync(() => fileDownloadInformation.IsCompleted, TimeSpan.FromSeconds(10));
Assert.AreEqual(crcValue, FileHelper.GetCrcValue(fileDownloadInformation.TempPath));
}
finally
{
stream.Close();
fileStream?.Close();
}
}
public void Should_Not_Be_Able_To_Retry_After_Max_Retry()
{
using (var memoryStream = new MemoryStream())
{
var uploadFileInformation = new UploadFileTransferInformation(
memoryStream,
PeerIdHelper.GetPeerId("test1"),
PeerIdHelper.GetPeerId("test2"),
null,
CorrelationId.GenerateCorrelationId());
uploadFileInformation.RetryCount += Constants.FileTransferMaxChunkRetryCount + 1;
uploadFileInformation.CanRetry().Should().BeFalse();
}
}
/// <summary>
/// </summary>
/// <param name="getFileFromDfsRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override GetFileFromDfsResponse HandleRequest(GetFileFromDfsRequest getFileFromDfsRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getFileFromDfsRequest, nameof(getFileFromDfsRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
long fileLen = 0;
FileTransferResponseCodeTypes responseCodeType;
var response = Task.Run(async() =>
{
try
{
responseCodeType = await Task.Run(async() =>
{
var stream = await _dfsService.UnixFsApi.ReadFileAsync(Cid.Decode(getFileFromDfsRequest.DfsHash))
.ConfigureAwait(false);
fileLen = stream.Length;
using (var fileTransferInformation = new UploadFileTransferInformation(
stream,
senderPeerId,
PeerSettings.PeerId,
channelHandlerContext.Channel,
correlationId
))
{
return(_fileTransferFactory.RegisterTransfer(fileTransferInformation));
}
}).ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Error(e,
"Failed to handle GetFileFromDfsRequestHandler after receiving message {0}",
getFileFromDfsRequest);
responseCodeType = FileTransferResponseCodeTypes.Error;
}
return(ReturnResponse(responseCodeType, fileLen));
}).ConfigureAwait(false).GetAwaiter().GetResult();
return(response);
}
public override void SendMessage(AddFileOptions options)
{
var request = GetMessage(options);
using (var fileStream = File.Open(options.File, FileMode.Open))
{
request.FileSize = (ulong)fileStream.Length;
}
var protocolMessage = request.ToProtocolMessage(SenderPeerId);
var requestMessage = new MessageDto(
protocolMessage,
RecipientPeerId
);
IUploadFileInformation fileTransfer = new UploadFileTransferInformation(
File.Open(options.File, FileMode.Open),
SenderPeerId,
RecipientPeerId,
Target.Channel,
requestMessage.CorrelationId);
_uploadFileTransferFactory.RegisterTransfer(fileTransfer);
Target.SendMessage(requestMessage);
while (!fileTransfer.ChunkIndicatorsTrue() && !fileTransfer.IsExpired())
{
CommandContext.UserOutput.Write($"\rUploaded: {fileTransfer.GetPercentage().ToString()}%");
Thread.Sleep(500);
}
if (fileTransfer.ChunkIndicatorsTrue())
{
CommandContext.UserOutput.Write($"\rUploaded: {fileTransfer.GetPercentage().ToString()}%\n");
}
else
{
CommandContext.UserOutput.WriteLine("\nFile transfer expired.");
}
}
