public void SingleSegmentUploader_UploadNonBinaryFile()
{
var fe = new InMemoryFrontEnd();
var metadata = CreateMetadata(_textFilePath, _textFileContents.Length);
metadata.IsBinary = false;
var progressTracker = new TestProgressTracker();
var ssu = new SingleSegmentUploader(0, metadata, fe, progressTracker);
ssu.UseBackOffRetryStrategy = false;
ssu.Upload();
//verify the entire file is identical to the source file
var actualContents = fe.GetStreamContents(StreamPath);
AssertExtensions.AreEqual(_textFileContents, actualContents, "Unexpected uploaded stream contents.");
//verify the append blocks start/end on record boundaries
var appendBlocks = fe.GetAppendBlocks(StreamPath);
int lengthSoFar = 0;
foreach (var append in appendBlocks)
{
lengthSoFar += append.Length;
if (lengthSoFar < actualContents.Length)
{
Assert.Equal('\n', (char)append[append.Length - 1]);
}
}
VerifyTracker(progressTracker, true);
}
/// <summary>
/// Verifies the file was successfully uploaded.
/// </summary>
/// <param name="up">The upload parameters.</param>
/// <param name="frontEnd">The front end.</param>
/// <param name="fileContents">The file contents.</param>
private void VerifyFileUploadedSuccessfully(UploadParameters up, InMemoryFrontEnd frontEnd, byte[] fileContents)
{
Assert.True(frontEnd.StreamExists(up.TargetStreamPath), "Uploaded stream does not exist");
Assert.Equal(1, frontEnd.StreamCount);
Assert.Equal(fileContents.Length, frontEnd.GetStreamLength(up.TargetStreamPath));
var uploadedData = frontEnd.GetStreamContents(up.TargetStreamPath);
AssertExtensions.AreEqual(fileContents, uploadedData, "Uploaded stream is not binary identical to input file");
}
private void VerifyTargetStreamIsComplete(UploadSegmentMetadata segmentMetadata, UploadMetadata metadata, InMemoryFrontEnd frontEnd)
{
Assert.Equal(SegmentUploadStatus.Complete, segmentMetadata.Status);
Assert.True(frontEnd.StreamExists(segmentMetadata.Path), string.Format("Segment {0} was not uploaded", segmentMetadata.SegmentNumber));
Assert.Equal(segmentMetadata.Length, frontEnd.GetStreamLength(segmentMetadata.Path));
var actualContents = frontEnd.GetStreamContents(segmentMetadata.Path);
var expectedContents = GetExpectedContents(segmentMetadata, metadata);
AssertExtensions.AreEqual(expectedContents, actualContents, "Segment {0} has unexpected contents", segmentMetadata.SegmentNumber);
}
/// <summary>
/// Verifies the file was successfully uploaded.
/// </summary>
/// <param name="targetPathsAndData">The target paths and data for each path.</param>
/// <param name="frontEnd">The front end to use.</param>
private void VerifyFileUploadedSuccessfully(Dictionary <string, byte[]> targetPathsAndData, InMemoryFrontEnd frontEnd, bool isDownload)
{
var streamCount = targetPathsAndData.Keys.Count;
Assert.Equal(streamCount, frontEnd.StreamCount);
foreach (var path in targetPathsAndData.Keys)
{
Assert.True(frontEnd.StreamExists(path, isDownload), "Uploaded stream does not exist");
Assert.Equal(targetPathsAndData[path].Length, frontEnd.GetStreamLength(path, isDownload));
var uploadedData = frontEnd.GetStreamContents(path, isDownload);
AssertExtensions.AreEqual(targetPathsAndData[path], uploadedData, "Uploaded stream is not binary identical to input file");
}
}
public void TestRetryBlock(int failCount)
{
bool expectSuccess = failCount < SingleSegmentUploader.MaxBufferUploadAttemptCount;
int callCount = 0;
var workingFrontEnd = new InMemoryFrontEnd();
var fe = new MockableFrontEnd(workingFrontEnd);
fe.CreateStreamImplementation =
(streamPath, overwrite, data, byteCount) =>
{
callCount++;
if (callCount <= failCount)
{
throw new IntentionalException();
}
workingFrontEnd.CreateStream(streamPath, overwrite, data, byteCount);
};
fe.AppendToStreamImplementation =
(streamPath, data, offset, byteCount) =>
{
callCount++;
if (callCount <= failCount)
{
throw new IntentionalException();
}
workingFrontEnd.AppendToStream(streamPath, data, offset, byteCount);
};
var metadata = CreateMetadata(_smallFilePath, _smallFileContents.Length);
var progressTracker = new TestProgressTracker();
var ssu = new SingleSegmentUploader(0, metadata, fe, progressTracker);
ssu.UseBackOffRetryStrategy = false;
if (expectSuccess)
{
ssu.Upload();
var actualContents = workingFrontEnd.GetStreamContents(StreamPath);
AssertExtensions.AreEqual(_smallFileContents, actualContents, "Unexpected uploaded stream contents.");
}
else
{
Assert.Throws <IntentionalException>(() => { ssu.Upload(); });
}
VerifyTracker(progressTracker, expectSuccess);
}
public void SingleSegmentUploader_UploadSingleBlockStream()
{
var fe = new InMemoryFrontEnd();
var metadata = CreateMetadata(_smallFilePath, _smallFileContents.Length);
var progressTracker = new TestProgressTracker();
var ssu = new SingleSegmentUploader(0, metadata, fe, progressTracker);
ssu.UseBackOffRetryStrategy = false;
ssu.Upload();
var actualContents = fe.GetStreamContents(StreamPath);
AssertExtensions.AreEqual(_smallFileContents, actualContents, "Unexpected uploaded stream contents.");
VerifyTracker(progressTracker, true);
}
public void SingleSegmentUploader_UploadFileRange()
{
int length = _smallFileContents.Length / 3;
var fe = new InMemoryFrontEnd();
var metadata = CreateMetadata(_smallFilePath, length);
var progressTracker = new TestProgressTracker();
var ssu = new SingleSegmentUploader(0, metadata, fe, progressTracker);
ssu.UseBackOffRetryStrategy = false;
ssu.Upload();
var actualContents = fe.GetStreamContents(StreamPath);
var expectedContents = new byte[length];
Array.Copy(_smallFileContents, 0, expectedContents, 0, length);
AssertExtensions.AreEqual(expectedContents, actualContents, "Unexpected uploaded stream contents.");
VerifyTracker(progressTracker, true);
}
public void SingleSegmentUploader_TargetStreamExists()
{
var fe = new InMemoryFrontEnd();
//load up an existing stream
fe.CreateStream(StreamPath, true, null, 0);
var data = Encoding.UTF8.GetBytes("random");
fe.AppendToStream(StreamPath, data, 0, (int)data.Length);
//force a re-upload of the stream
var metadata = CreateMetadata(_smallFilePath, _smallFileContents.Length);
var ssu = new SingleSegmentUploader(0, metadata, fe);
ssu.UseBackOffRetryStrategy = false;
ssu.Upload();
var actualContents = fe.GetStreamContents(StreamPath);
AssertExtensions.AreEqual(_smallFileContents, actualContents, "Unexpected uploaded stream contents.");
}
/// <summary>
/// Verifies the file was successfully uploaded.
/// </summary>
/// <param name="up">The upload parameters.</param>
/// <param name="frontEnd">The front end.</param>
/// <param name="fileContents">The file contents.</param>
private void VerifyFileUploadedSuccessfully(UploadParameters up, InMemoryFrontEnd frontEnd, byte[] fileContents)
{
Assert.True(frontEnd.StreamExists(up.TargetStreamPath), "Uploaded stream does not exist");
Assert.Equal(1, frontEnd.StreamCount);
Assert.Equal(fileContents.Length, frontEnd.GetStreamLength(up.TargetStreamPath));
var uploadedData = frontEnd.GetStreamContents(up.TargetStreamPath);
AssertExtensions.AreEqual(fileContents, uploadedData, "Uploaded stream is not binary identical to input file");
}
private void VerifyTargetStreamIsComplete(UploadSegmentMetadata segmentMetadata, UploadMetadata metadata, InMemoryFrontEnd frontEnd)
{
Assert.Equal(SegmentUploadStatus.Complete, segmentMetadata.Status);
Assert.True(frontEnd.StreamExists(segmentMetadata.Path), string.Format("Segment {0} was not uploaded", segmentMetadata.SegmentNumber));
Assert.Equal(segmentMetadata.Length, frontEnd.GetStreamLength(segmentMetadata.Path));
var actualContents = frontEnd.GetStreamContents(segmentMetadata.Path);
var expectedContents = GetExpectedContents(segmentMetadata, metadata);
AssertExtensions.AreEqual(expectedContents, actualContents, "Segment {0} has unexpected contents", segmentMetadata.SegmentNumber);
}
