/// <summary>
/// Construct a HttpParallelDownloader.
/// </summary>
/// <param name="task">Download task, must with HttpRangedTarget.</param>
/// <param name="folderProvider">Folder provider must not be null.</param>
/// <param name="cacheProvider">Cache provider must not be null.</param>
/// <param name="bufferProvider">Buffer provider must not be null.</param>
/// <param name="checkPoint">Set the downloader to start at given checkPoint.</param>
/// <param name="threadNum">Number of threads used.</param>
/// <param name="threadSegmentSize">Downloading task is divided as segments
/// before assigned to each thread. Segment size defines the approximate
/// size of each segment.</param>
public HttpParallelDownloader(
DownloadTask task,
IFolderProvider folderProvider,
ICacheStorageProvider cacheProvider,
IBufferProvider bufferProvider,
byte[] checkPoint = null,
int threadNum = 8,
long threadSegmentSize = 8 * 1024 * 1024
) : base(task)
{
Ensure.That(task.Target is HttpRangableTarget, null, opts => opts.WithMessage(
$"type of {nameof(task.Target)} must be {nameof(HttpRangableTarget)}")
).IsTrue();
Ensure.That(folderProvider, nameof(folderProvider)).IsNotNull();
Ensure.That(cacheProvider, nameof(cacheProvider)).IsNotNull();
Ensure.That(bufferProvider, nameof(bufferProvider)).IsNotNull();
Ensure.That(threadNum, nameof(threadNum)).IsGte(1);
Ensure.That(threadSegmentSize, nameof(threadSegmentSize)).IsGt(1024 * 1024);
this.folderProvider = folderProvider;
this.cacheProvider = cacheProvider;
this.bufferProvider = bufferProvider;
this.threadNum = threadNum;
this.threadSegmentSize = threadSegmentSize;
Progress = new CompositeProgress((task.Target as HttpRangableTarget).DataLength);
Speed = SharedSpeedCalculatorFactory.NewSpeedCalculator();
Progress.ProgressChanged += (sender, arg) => Speed.CurrentValue = Progress.DownloadedSize;
if (checkPoint != null)
{
ApplyCheckPoint(checkPoint);
}
}
private async Task UploadRecordingDataAsync(SessionRecordingData recording, IProgress <UploadStatus> progress, CancellationToken cancellationToken)
{
CompositeProgress <UploadStatus, int> progressStatus = new CompositeProgress <UploadStatus, int>(progress, UploadStatus.CreatePreparing(), (i, p) => p.Update(i));
string uploadSegmentsDirectoryPath = PrepareDirectoryForUploadSegments(recording);
var segments = await PrepareUploadSegmentsAsync(recording, uploadSegmentsDirectoryPath, progressStatus, cancellationToken);
if (segments.Any())
{
//segments = await FilterAlreadyUploadedSegmentsAsync(segments, recording);
// upload all segments
progressStatus.Report(UploadStatus.CreateUploading());
bool uploaded = await UploadMultipleSegmentsAsync(segments, recording, progressStatus, cancellationToken);
if (uploaded)
{
// verify if all segments are uploaded
progressStatus.Report(UploadStatus.CreateVerifying());
bool verified = await VerifyAllSegmentsAreUploadedAsync(segments, recording);
if (verified)
{ // if all segments are uploaded
// commit the upload
progressStatus.Report(UploadStatus.CreateCompleting());
bool saved = await _uxrClient.SaveSessionRecordingAsync(_uxrNode.NodeId, recording.StartTime, recording.SessionId);
if (saved)
{
progressStatus.Report(UploadStatus.CreateCompleted());
// delete upload files
Directory.Delete(uploadSegmentsDirectoryPath, true);
//if (recording.DeleteData)
//{
// // TODO Uploader: delete recording data?
// // Directory.Delete(recording.Path, true);
//}
}
}
}
}
}
