public void DataLakeUploader_CancelUpload()
{
CancellationTokenSource myTokenSource = new CancellationTokenSource();
var cancelToken = myTokenSource.Token;
var frontEnd = new InMemoryFrontEnd();
var mockedFrontend = new MockableFrontEnd(frontEnd);
mockedFrontend.GetStreamLengthImplementation = (streamPath, isDownload) =>
{
// sleep for 2 second to allow for the cancellation to actual happen
Thread.Sleep(2000);
return(frontEnd.GetStreamLength(streamPath, isDownload));
};
mockedFrontend.StreamExistsImplementation = (streamPath, isDownload) =>
{
// sleep for 2 second to allow for the cancellation to actual happen
Thread.Sleep(2000);
return(frontEnd.StreamExists(streamPath, isDownload));
};
var up = CreateParameters(isResume: false);
UploadProgress progress = null;
var syncRoot = new object();
IProgress <UploadProgress> progressTracker = new Progress <UploadProgress>(
(p) =>
{
lock (syncRoot)
{
//it is possible that these come out of order because of race conditions (multiple threads reporting at the same time); only update if we are actually making progress
if (progress == null || progress.UploadedByteCount < p.UploadedByteCount)
{
progress = p;
}
}
});
var uploader = new DataLakeStoreUploader(up, mockedFrontend, cancelToken, progressTracker);
Task uploadTask = Task.Run(() =>
{
uploader.Execute();
Thread.Sleep(2000);
}, cancelToken);
myTokenSource.Cancel();
Assert.True(cancelToken.IsCancellationRequested);
while (uploadTask.Status == TaskStatus.Running || uploadTask.Status == TaskStatus.WaitingToRun)
{
Thread.Sleep(250);
}
// Verify that the file did not get uploaded completely.
Assert.False(frontEnd.StreamExists(up.TargetStreamPath), "Uploaded stream exists when it should not yet have been completely created");
}
/// <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 DataLakeUploader_CancelUpload()
{
CancellationTokenSource myTokenSource = new CancellationTokenSource();
var cancelToken = myTokenSource.Token;
var frontEnd = new InMemoryFrontEnd();
var up = CreateParameters(isResume: false);
UploadProgress progress = null;
var syncRoot = new object();
IProgress <UploadProgress> progressTracker = new Progress <UploadProgress>(
(p) =>
{
lock (syncRoot)
{
//it is possible that these come out of order because of race conditions (multiple threads reporting at the same time); only update if we are actually making progress
if (progress == null || progress.UploadedByteCount < p.UploadedByteCount)
{
progress = p;
}
}
});
var uploader = new DataLakeStoreUploader(up, frontEnd, cancelToken, progressTracker);
Task uploadTask = Task.Run(() => uploader.Execute(), cancelToken);
Assert.True(!uploadTask.IsCompleted, "The task finished before we could cancel it");
myTokenSource.Cancel();
Assert.True(cancelToken.IsCancellationRequested);
while (uploadTask.Status == TaskStatus.Running || uploadTask.Status == TaskStatus.WaitingToRun)
{
Thread.Sleep(250);
}
Assert.True(uploadTask.IsCanceled, "The task was not cancelled as expected. Actual task state: " + uploadTask.Status);
// Verify that the file did not get uploaded completely.
Assert.False(frontEnd.StreamExists(up.TargetStreamPath), "Uploaded stream exists when it should not yet have been completely created");
}
/// <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");
}
public void DataLakeUploader_CancelUpload()
{
CancellationTokenSource myTokenSource = new CancellationTokenSource();
var cancelToken = myTokenSource.Token;
var frontEnd = new InMemoryFrontEnd();
var up = CreateParameters(isResume: false);
UploadProgress progress = null;
var syncRoot = new object();
IProgress<UploadProgress> progressTracker = new Progress<UploadProgress>(
(p) =>
{
lock (syncRoot)
{
//it is possible that these come out of order because of race conditions (multiple threads reporting at the same time); only update if we are actually making progress
if (progress == null || progress.UploadedByteCount < p.UploadedByteCount)
{
progress = p;
}
}
});
var uploader = new DataLakeStoreUploader(up, frontEnd, cancelToken, progressTracker);
Task uploadTask = Task.Run(() => uploader.Execute(), cancelToken);
Assert.True(!uploadTask.IsCompleted, "The task finished before we could cancel it");
myTokenSource.Cancel();
Assert.True(cancelToken.IsCancellationRequested);
while (uploadTask.Status == TaskStatus.Running || uploadTask.Status == TaskStatus.WaitingToRun)
{
Thread.Sleep(250);
}
Assert.True(uploadTask.IsCanceled, "The task was not cancelled as expected. Actual task state: " + uploadTask.Status);
// Verify that the file did not get uploaded completely.
Assert.False(frontEnd.StreamExists(up.TargetStreamPath), "Uploaded stream exists when it should not yet have been completely created");
}
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);
}
