public async void prefetchImage(string uriString, int requestId, IPromise promise)
{
if (string.IsNullOrEmpty(uriString))
{
promise.Reject(ErrorInvalidUri, "Cannot prefetch an image for an empty URI.");
return;
}
try
{
var imagePipeline = ImagePipelineFactory.Instance.GetImagePipeline();
var uri = new Uri(uriString);
await _prefetchRequests.AddAndInvokeAsync(
requestId,
async token => await imagePipeline.PrefetchToDiskCacheAsync(uri, token).ConfigureAwait(false))
.ConfigureAwait(false);
promise.Resolve(true);
}
catch (Exception ex)
{
promise.Reject(ErrorPrefetchFailure, ex.Message);
}
}
public async void downloadFile(JObject options, IPromise promise)
{
var filepath = options.Value <string>("toFile");
try
{
var url = new Uri(options.Value <string>("fromUrl"));
var jobId = options.Value <int>("jobId");
var headers = (JObject)options["headers"];
var progressDivider = options.Value <int>("progressDivider");
var request = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value.Value <string>());
}
await _tasks.AddAndInvokeAsync(jobId, token =>
ProcessRequestAsync(promise, request, filepath, jobId, progressDivider, token));
}
catch (Exception ex)
{
Reject(promise, filepath, ex);
}
}
public void prefetchImage(string uriString, int requestId, IPromise promise)
{
if (string.IsNullOrEmpty(uriString))
{
promise.Reject(ErrorInvalidUri, "Cannot prefetch an image for an empty URI.");
return;
}
DispatcherHelpers.RunOnDispatcher(async() =>
{
try
{
var uri = new Uri(uriString);
await _prefetchRequests.AddAndInvokeAsync(
requestId,
async token => await ImageCache.Instance.PreCacheAsync(uri, true, true, token).ConfigureAwait(false))
.ConfigureAwait(false);
promise.Resolve(true);
}
catch (Exception ex)
{
promise.Reject(ErrorPrefetchFailure, ex.Message);
}
});
}
public async Task TaskCancellationManager_CancelAllTasks_Many()
{
var count = 100;
using (var enter = new CountdownEvent(count))
using (var exit = new CountdownEvent(count))
{
var mgr = new TaskCancellationManager <int>();
var tasks = new List <Task>(count);
for (var i = 0; i < count; ++i)
{
tasks.Add(mgr.AddAndInvokeAsync(i, async token =>
{
var tcs = new TaskCompletionSource <bool>();
using (token.Register(() => tcs.SetResult(true)))
{
enter.Signal();
await tcs.Task;
exit.Signal();
}
}));
}
Assert.IsTrue(enter.WaitHandle.WaitOne());
Assert.AreEqual(count, mgr.PendingOperationCount);
mgr.CancelAllTasks();
Assert.IsTrue(exit.WaitHandle.WaitOne());
await Task.WhenAll(tasks);
Assert.AreEqual(0, mgr.PendingOperationCount);
}
}
public async Task TaskCancellationManager_CancelledAfterCompleted()
{
var mgr = new TaskCancellationManager <int>();
await mgr.AddAndInvokeAsync(42, _ => Task.CompletedTask);
mgr.Cancel(42);
// Not throwing implies success
}
public async Task TaskCancellationManager_CleanedUpAfterComplete()
{
using (var enter = new AutoResetEvent(false))
{
var mgr = new TaskCancellationManager <int>();
var t = mgr.AddAndInvokeAsync(42, token =>
{
return(Task.Run(() =>
{
enter.WaitOne();
}));
});
Assert.IsNotNull(t);
Assert.AreEqual(1, mgr.PendingOperationCount);
enter.Set();
await t;
Assert.AreEqual(0, mgr.PendingOperationCount);
}
}
public async void downloadFile(JObject options, JObject fileOptions, IPromise promise)
{
var filepath = options.Value <string>("toFile");
try
{
var url = new Uri(options.Value <string>("fromUrl"));
var jobId = options.Value <int>("jobId");
var headers = (JObject)options["headers"];
var progressDivider = options.Value <int>("progressDivider");
var request = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value.Value <string>());
}
Stream outputStream;
using (var fileStream = new FileStream(filepath, FileMode.Create, FileAccess.Write))
{
if (fileOptions.Value <bool>("encrypted"))
{
var base64Key = fileOptions.Value <string>("passphrase");
outputStream = encryptionManager.getCryptoWriteStream(fileStream, base64Key);
}
else
{
outputStream = fileStream;
}
await _tasks.AddAndInvokeAsync(jobId, token => ProcessRequestAsync(promise, request, filepath, jobId, progressDivider, outputStream, token));
outputStream.Flush();
outputStream.Dispose();
}
}
catch (Exception ex)
{
Reject(promise, filepath, ex);
}
}
public async Task TaskCancellationManager_CleanedUpAfterError()
{
using (var enter = new AutoResetEvent(false))
{
var mgr = new TaskCancellationManager <int>();
var t = mgr.AddAndInvokeAsync(42, token =>
{
return(Task.Run(() =>
{
enter.WaitOne();
throw new InvalidOperationException();
}));
});
Assert.IsNotNull(t);
Assert.AreEqual(1, mgr.PendingOperationCount);
enter.Set();
await AssertEx.ThrowsAsync <InvalidOperationException>(async() => await t);
Assert.AreEqual(0, mgr.PendingOperationCount);
}
}
public async Task TaskCancellationManager_CancelTask()
{
using (var enter = new AutoResetEvent(false))
using (var exit = new AutoResetEvent(false))
{
var mgr = new TaskCancellationManager <int>();
var t = mgr.AddAndInvokeAsync(42, async token =>
{
var tcs = new TaskCompletionSource <bool>();
using (token.Register(() => tcs.SetResult(true)))
{
enter.Set();
await tcs.Task;
exit.Set();
}
});
Assert.IsTrue(enter.WaitOne());
mgr.Cancel(42);
Assert.IsTrue(exit.WaitOne());
await t;
}
}