private void CreateDownloader(string token, byte[] checkPoint = null)
{
AbstractDownloader downloader = null;
try
{
var task = tasks.First(t => t.Key.Equals(token));
if (task.Target is HttpRangableTarget httpRangableTarget)
{
downloader = new HttpParallelDownloader(
task,
coreFolderManager,
coreCacheManager.GetCacheProviderForTask(token),
coreBufferProvider,
checkPoint,
settingEntries.ThreadNumber);
}
else if (task.Target is HttpTarget httpTarget)
{
downloader = new HttpDownloader(
task, coreFolderManager,
coreCacheManager.GetCacheProviderForTask(token),
coreBufferProvider);
}
else if (task.Target is TorrentTarget torrentTarget)
{
downloader = new TorrentDownloader(
task, torrentProvider.Engine, coreFolderManager,
coreCacheManager.GetCacheProviderForTask(token),
checkPoint: checkPoint,
maximumConnections: settingEntries.MaximumConnections,
maximumDownloadSpeed: settingEntries.MaximumDownloadSpeed,
maximumUploadSpeed: settingEntries.MaximumUploadSpeed,
announceUrls: announceUrls);
}
}
catch (Exception e)
{
D($"Downloader with task {token} creation failed, {e.Message}");
}
if (downloader != null)
{
D($"Downloader with task {token} created");
downloader.MaximumRetries = settingEntries.MaximumRetries;
downloader.StatusChanged += AnyDownloader_StatusChanged;
downloaders.Add(downloader);
}
}
private async Task TestWithSize(long size)
{
var targetBytes = new byte[size];
random.NextBytes(targetBytes);
int port = 8080;
using (var server = new FakeHttpServer(port, targetBytes))
{
var folderProvider = new FakeFolderProvider();
var cacheProvider = new FakeCacheProvider();
var bufferProvider = new FakeBufferProvider();
var downloader = new HttpParallelDownloader(
new DownloadTask(
"test-task",
new HttpRangableTarget(
new Uri($"http://localhost:{port}/"),
"test-file",
size
),
"test-destination-file",
"test-destination-folder",
DateTime.Now,
false
),
folderProvider,
cacheProvider,
bufferProvider
);
downloader.Start();
TimeSpan cancellationStep = TimeSpan.FromSeconds(1);
CancellationTokenSource completeTokenSource = new CancellationTokenSource();
downloader.StatusChanged += async(sender, newStatus) =>
{
switch (downloader.Status)
{
case DownloaderStatus.Running:
var step = cancellationStep;
cancellationStep *= 2;
await Task.Delay(step);
if (downloader.CanCancel)
{
downloader.Cancel();
}
break;
case DownloaderStatus.Ready:
downloader.Start();
break;
case DownloaderStatus.Completed:
completeTokenSource.Cancel();
break;
case DownloaderStatus.Pending:
break;
case DownloaderStatus.Disposed:
break;
case DownloaderStatus.Error:
throw downloader.Errors.First();
default:
throw new Exception($"unknown status {downloader.Status}");
}
};
try
{
await Task.Delay(TimeSpan.FromMinutes(5), completeTokenSource.Token);
}
catch (TaskCanceledException) { }
Assert.AreEqual(DownloaderStatus.Completed, downloader.Status);
if (downloader.Result is StorageFile file)
{
using (var istream = await file.OpenReadAsync())
{
using (var ostream = new MemoryStream(targetBytes))
{
Assert.IsTrue(istream.AsStream().Compare(ostream));
}
}
}
await downloader.Result.DeleteAsync();
await downloader.DisposeAsync();
}
}
