protected override void Given()
{
TaskSource = Substitute.For<TaskSource>();
ExecTaskGenerator = Substitute.For<ExecTaskGenerator>();
Pipeline = new Pipeline(TaskSource, ExecTaskGenerator);
ObservingEvents();
}
public async Task <StorageFile> EnqueueFileDownload(StorageFolder root, Uri uri, string extension = "")
{
var filename = Path.GetFileName(uri.LocalPath) + extension;
var file = await root.TryGetFileAsync(filename).ConfigureAwait(false);
if (file != null)
{
return(file);
}
var tcs = new TaskCompletionSource <StorageFile>();
var taskSource = new TaskSource {
uri = uri, folder = root, filename = filename, tcs = tcs
};
lock (HolderLock)
{
if (Stack.Count == 0 && Queue.Count < FIFO_THRESHOLD)
{
Queue.Enqueue(taskSource);
}
else
{
Stack.Push(taskSource);
}
}
TryRunTask();
return(await tcs.Task.ConfigureAwait(false));
}
public void BasicTest()
{
var ts = TaskSource.New <int>(TaskCreationOptions.None);
ts.Task.IsCompleted.Should().BeFalse();
ts.SetResult(1);
ts.TrySetResult(2).Should().BeFalse();
ts.Task.IsCompletedSuccessfully().Should().BeTrue();
ts.Task.Result.Should().Be(1);
ts = TaskSource.New <int>(TaskCreationOptions.None);
ts.Task.IsCompleted.Should().BeFalse();
var e = new InvalidOperationException();
ts.SetException(e);
ts.TrySetException(new InvalidOperationException()).Should().BeFalse();
ts.Task.IsCompleted.Should().BeTrue();
ts.Task.IsFaulted.Should().BeTrue();
ts.Task.Exception.Should().NotBeNull();
ts = TaskSource.New <int>(TaskCreationOptions.None);
ts.Task.IsCompleted.Should().BeFalse();
using var cts = new CancellationTokenSource();
ts.SetCanceled();
ts.TrySetCanceled(cts.Token).Should().BeFalse();
ts.Task.IsCompleted.Should().BeTrue();
ts.Task.IsFaulted.Should().BeFalse();
ts.Task.IsCanceled.Should().BeTrue();
}
internal WhenInvalidatedClosure(TaskSource <Unit> taskSource, IComputed computed, CancellationToken cancellationToken)
{
_taskSource = taskSource;
_computed = computed;
_onInvalidatedHandler = OnInvalidated;
_computed.Invalidated += _onInvalidatedHandler;
_cancellationTokenRegistration = cancellationToken.Register(OnUnregister);
}
private void Reset()
{
_nextMessageTask = TaskSource.New <RedisValue>(true).Task;
if (IsDisposeStarted)
{
TaskSource.For(_nextMessageTask).TrySetCanceled();
}
}
public static void Run([BlobTrigger(BlobPath)] BlobBaseClient blob,
string blobTrigger, Uri uri, BlobProperties properties, IDictionary <string, string> metadata)
{
TaskSource.TrySetResult(blob);
BlobTrigger = blobTrigger;
Uri = uri;
Properties = properties;
Metadata = metadata;
}
public SyncAction(OperationQueue operationQueue, IMobileServiceLocalStore store, CancellationToken cancellationToken)
{
this.OperationQueue = operationQueue;
this.Store = store;
this.TaskSource = new TaskCompletionSource <object>();
this.CancellationToken = cancellationToken;
cancellationToken.Register(() => TaskSource.TrySetCanceled());
}
public static Task InvalidatedAsync <T>(this IComputed <T> computed, CancellationToken cancellationToken = default)
{
if (computed.State == ComputedState.Invalidated)
{
return(Task.CompletedTask);
}
var ts = TaskSource.New <Unit>(true);
computed.Invalidated += c => ts.SetResult(default);
private static TaskCompletionSource <T> Create <T>(SourceOrign origin)
{
switch (origin)
{
case SourceOrign.NewTCS: return(new TaskCompletionSource <T>());
case SourceOrign.Create: return(TaskSource.Create <T>(null));
default: throw new ArgumentOutOfRangeException(nameof(origin));
}
}
public StateSnapshot(IState <T> state, IComputed <T> computed)
{
State = state;
Computed = computed;
LatestNonErrorComputed = computed;
WhenUpdatingSource = TaskSource.New <Unit>(true);
WhenUpdatedSource = TaskSource.New <Unit>(true);
UpdateCount = 0;
ErrorCount = 0;
RetryCount = 0;
}
public bool TryCancel(CancellationToken cancellationToken = default)
{
if (CancellationToken.IsCancellationRequested)
{
TaskSource.For(OutputTask).TrySetCanceled(CancellationToken);
}
else if (cancellationToken.IsCancellationRequested)
{
TaskSource.For(OutputTask).TrySetCanceled(cancellationToken);
}
return(OutputTask.IsCanceled);
}
protected override void Given()
{
task1 = Substitute.For<TaskSource>();
bool stop;
task1.Detect(Arg.Any<string>(), out stop).Returns(info =>
{
info[1] = true;
return new List<TaskDescription>();
});
task2 = Substitute.For<TaskSource>();
compoundTaskSource = new CompoundTaskSource(task1, task2);
}
public void VerifyIsSyncSafe(SourceOrign origin)
{
var source = Create <int>(origin);
// Yes this looks stupid, but it's the proper pattern for how we statically init now
// ...and if we're dropping NET45 support, we can just nuke it all.
#if NET462
Assert.True(TaskSource.IsSyncSafe(source.Task));
#elif NETCOREAPP2_0
Assert.True(TaskSource.IsSyncSafe(source.Task));
#endif
}
protected async ValueTask <Releaser> FastInternalLockAsync(
ReentryCounter?reentryCounter, CancellationToken cancellationToken = default)
{
var newLockSrc = TaskSource.New <Unit>(_taskCreationOptions);
var cancellationTask = (Task?)null;
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
if (reentryCounter?.TryReenter(ReentryMode) == true)
{
return(new Releaser(this, default, reentryCounter));
protected static void EndDelay(ref Task <Unit> task, TimeSpan withDelay = default)
{
var newTask = TaskSource.New <Unit>(true).Task;
var oldTask = Interlocked.Exchange(ref task, newTask);
if (oldTask == null)
{
return;
}
if (withDelay == default)
{
TaskSource.For(oldTask).SetResult(default);
// ToTask (typed)
public static Disposable <Task <T>, CancellationTokenRegistration> ToTask <T>(
this CancellationToken token,
TaskCreationOptions taskCreationOptions = default)
{
var ts = TaskSource.New <T>(taskCreationOptions);
var r = token.Register(() => ts.SetCanceled(token));
#if NETSTANDARD
return(Disposable.New(ts.Task, r, (_, r1) => r1.Dispose()));
#else
return(Disposable.New(ts.Task, r, (_, r1) => r1.Unregister()));
#endif
}
protected override void Given()
{
customTasks = new CustomTasksDetector(taskFileFinder, s => @"{ pipeline: [{
stage : ""Build"",
tasks : [""task 1"", ""task 2""]
},
{
stage : ""Deploy to staging"",
tasks : [""task 3"", ""task 4""]
}]}
");
taskFileFinder.FindFiles("basefolder").Returns(As.List("runz.me"));
}
protected async ValueTask <Releaser> FastInternalLock(
ReentryCounter?reentryCounter, CancellationToken cancellationToken = default)
{
var newLockSrc = TaskSource.New <Unit>(_taskCreationOptions);
var dCancellationTokenTask = new Disposable <Task, CancellationTokenRegistration>();
try {
for (;;)
{
cancellationToken.ThrowIfCancellationRequested();
if (reentryCounter?.TryReenter(ReentryMode) == true)
{
return(new Releaser(this, default, reentryCounter));
TaskSource RemoveOrStartTask(QueryETag etag)
{
lock (_tasksByETag)
{
if (!_tasksByETag.Remove(etag, out var task))
{
task = new TaskSource();
_tasksByETag[etag] = task;
}
return(task);
}
}
public void ExecuteTasks()
{
var context = ContextFactory.CreateEntitiesContext();
var taskManager = context.GetManager <TaskManager>();
var task1 = new TaskSource();
for (int i = 0; i < 10; i++)
{
taskManager.ScheduleFrom(task1);
taskManager.Wait();
// Assert.AreEqual(1000, task1.sum);
}
context.Dispose();
}
// (Try)SetFromTask
public static void SetFromTask <T>(this TaskSource <T> target, Task <T> source, CancellationToken candidateToken)
{
if (source.IsCanceled)
{
target.SetCanceled(candidateToken.IsCancellationRequested ? candidateToken : CancellationToken.None);
}
else if (source.Exception != null)
{
target.SetException(source.Exception);
}
else
{
target.SetResult(source.Result);
}
}
// (Try)SetFromResult
public static void SetFromResult <T>(this TaskSource <T> target, Result <T> source, CancellationToken candidateToken)
{
if (source.IsValue(out var v, out var e))
{
target.SetResult(v);
}
else if (e is OperationCanceledException && candidateToken.IsCancellationRequested)
{
target.SetCanceled(candidateToken);
}
else
{
target.SetException(e);
}
}
public void CancelDelays(bool immediately = false)
{
if (!immediately)
{
Clock
.DelayAsync(CancelDelaysDelay, CancellationToken.None)
.ContinueWith(_ => CancelDelays(true));
return;
}
var newTask = TaskSource.New <Unit>(true).Task;
var oldTask = Interlocked.Exchange(ref _cancelDelaysTask, newTask);
if (oldTask != null)
{
TaskSource.For(oldTask).SetResult(default);
//
// Points
//
public void Enqueue(TimelinePoint point)
{
lock (_queue)
{
if (_resumeQueue == null && _pendingDequeue != null)
{
_pendingDequeue.SetResult(point);
_pendingDequeue = null;
}
else
{
_queue.Enqueue(point);
}
}
}
public void CancelDelays(TimeSpan?cancellationDelay = null)
{
var delay = Math.Max(0, (cancellationDelay ?? CancellationDelay).TotalSeconds);
if (delay > 0)
{
Clock.DelayAsync(TimeSpan.FromSeconds(delay)).ContinueWith(_ => CancelDelays(TimeSpan.Zero));
return;
}
var newTask = TaskSource.New <Unit>(true).Task;
var oldTask = Interlocked.Exchange(ref _cancelDelaysTask, newTask);
if (oldTask != null)
{
TaskSource.For(oldTask).SetResult(default);
async Task ConnectInitially()
{
_connectInitially = new TaskSource();
try
{
await Connection.ConnectAsync();
await _connectInitially.Task;
}
finally
{
_connectInitially = null;
}
}
/// <summary>
/// Asynchronously download thumbnail image and return local storage file.
/// </summary>
/// <param name="uuid">UUID of the target device.</param>
/// <param name="content">Source of thumbnail image.</param>
/// <returns>Local storage file</returns>
public async Task <StorageFile> LoadCacheFileAsync(string uuid, ContentInfo content)
{
var uri = new Uri(content.ThumbnailUrl);
var directory = uuid.Replace(":", "-") + "/";
var filename = content.CreatedTime.Replace(":", "-").Replace("/", "-") + "--" + Path.GetFileName(uri.LocalPath);
if (!filename.Contains("."))
{
filename += ".jpg";
}
else if (filename.EndsWith(".arw", StringComparison.OrdinalIgnoreCase))
{
filename = filename.Substring(0, filename.Length - 3) + "jpg";
}
DebugUtil.LogSensitive(() => "Loading {0} into {1}", content.ThumbnailUrl, directory);
await LoadCacheRoot().ConfigureAwait(false);
var folder = await CacheFolder.CreateFolderAsync(directory, CreationCollisionOption.OpenIfExists);
var file = await folder.TryGetFileAsync(filename).ConfigureAwait(false);
if (file != null)
{
return(file);
}
var tcs = new TaskCompletionSource <StorageFile>();
var taskSource = new TaskSource {
uri = uri, folder = folder, filename = filename, tcs = tcs
};
lock (HolderLock)
{
if (Stack.Count == 0 && Queue.Count < FIFO_THRESHOLD)
{
Queue.Enqueue(taskSource);
}
else
{
Stack.Push(taskSource);
}
}
TryRunTask();
return(await tcs.Task.ConfigureAwait(false));
}
public async Task BasicTest()
{
if (TestRunnerInfo.IsBuildAgent())
{
return; // No Redis on build agent for now
}
var db = GetRedisDb();
var started = TaskSource.New <Unit>(true);
var streamer = db.GetStreamer <int>("s");
await streamer.Remove();
var streamerCopy = db.GetStreamer <int>("s");
var writeTask = streamer.Write(
Delays(new[] { 0.1, 0.2, 0.3, 0.1 }),
_ => started.SetResult(default));
/// <summary>
/// Runs a sequence of Actions so that it can be awaited.
/// </summary>
/// <param name="actions">An array of FiniteTimeAction objects.</param>
public Task <ActionState> RunActionsAsync(params FiniteTimeAction[] actions)
{
if (actions.Length == 0)
{
return(Task.FromResult <ActionState>(null));
}
var tcs = new TaskCompletionSource <ActionState>();
FiniteTimeAction completion = new TaskSource(tcs);
var asyncAction = actions.Length > 0 ? new Sequence(actions, completion)
{
CancelAction = s => tcs.TrySetCanceled()
} : completion;
Application.Current.ActionManager.AddAction(asyncAction, this);
return(tcs.Task);
}
public static Disposable <Task, CancellationTokenRegistration> ToTask(
this CancellationToken token,
Exception exceptionWhenCancelled,
TaskCreationOptions taskCreationOptions = default)
{
// ReSharper disable once HeapView.PossibleBoxingAllocation
var ts = TaskSource.New <Unit>(exceptionWhenCancelled, taskCreationOptions);
var r = token.Register(arg => {
var ts1 = TaskSource.For((Task <Unit>)arg !);
ts1.SetException((Exception)ts1.Task.AsyncState !);
}, ts.Task);
#if NETSTANDARD
return(Disposable.New((Task)ts.Task, r, (_, r1) => r1.Dispose()));
#else
return(Disposable.New((Task)ts.Task, r, (_, r1) => r1.Unregister()));
#endif
}
protected virtual async Task Run(TimeSpan duration, CancellationToken cancellationToken)
{
Counters.Clear();
var startTaskSource = TaskSource.New <Unit>(true);
var tasks = Enumerable.Range(0, ConcurrencyLevel)
.Select(async i => {
await startTaskSource.Task.ConfigureAwait(false);
return(await Benchmark(i, duration, cancellationToken).ConfigureAwait(false));
})
.ToArray();
await Task.Delay(100, cancellationToken).ConfigureAwait(false); // Wait to make sure all the tasks are created & scheduled
if (ForceGCCollect)
{
GC.Collect();
}
Stopwatch = Stopwatch.StartNew();
startTaskSource.SetResult(default);
/// <summary>
/// Find the Task from the Windows Task Scheduler
/// </summary>
public Task FindTask()
{
Task result = Report.TaskFolder.GetTasks().FirstOrDefault(i => i.Definition.RegistrationInfo.Source == TaskSource);
foreach (var task in Report.TaskFolder.GetTasks())
{
if (task.Definition.RegistrationInfo.Source.ToLower().Trim() == TaskSource.ToLower().Trim())
{
result = task;
}
}
if (result == null)
{
//check if the task is still existing (typically if the report was moved or renamed)
foreach (Task task in Report.TaskFolder.GetTasks().Where(i => i.Name.EndsWith(GUID) && i.Definition.RegistrationInfo.Source.EndsWith(GUID)))
{
bool ok = true;
string reportPath = GetTaskSourceDetail(task.Definition.RegistrationInfo.Source, 0);
if (File.Exists(reportPath))
{
try
{
//probably a report copy, the task should stay attached on the initial report
Report report = Report.LoadFromFile(reportPath, Report.Repository);
if (report.GUID == GetTaskSourceDetail(task.Definition.RegistrationInfo.Source, 1) && report.Schedules.Exists(i => i.GUID == GUID))
{
ok = false;
}
}
catch { }
}
if (ok)
{
//take this task
result = task;
break;
}
}
}
return(result);
}
public PublicationState(IPublication <T> publication, IComputed <T> computed, Moment createdAt, bool isDisposed,
TaskSource <Unit> whenInvalidatedSource = default,
TaskSource <Unit> whenOutdatedSource = default)
{
if (whenInvalidatedSource.IsEmpty)
{
whenInvalidatedSource = TaskSource.New <Unit>(true);
}
if (whenOutdatedSource.IsEmpty)
{
whenOutdatedSource = TaskSource.New <Unit>(true);
}
Publication = publication;
CreatedAt = createdAt;
IsDisposed = isDisposed;
WhenInvalidatedSource = whenInvalidatedSource;
WhenOutdatedSource = whenOutdatedSource;
Computed = computed;
computed.Invalidated += _ => WhenInvalidatedSource.TrySetResult(default);
public void Dispose()
{
complete.WaitOne();
task = null;
start.Set();
thread.Join();
}
void Process()
{
parent.Application.SetApplicationThreadInstance();
#if XBOX360
thread.SetProcessorAffinity(new int[] { threadAffinity });
#else
//match culture with the creation thread
Thread.CurrentThread.CurrentCulture = culture;
#endif
while (!temporary)
{
complete.Set();
start.WaitOne();
TaskSource task = this.task;
if (task == null)
break;
this.task = null;
complete.Reset();
running.Set();
IAction action = Interlocked.Exchange(ref task.action, null);
if (action != null) // set action to null when a task in in flight
{
action.PerformAction(task.data);
parent.ClearTask(task);
}
if (!temporary)
{
while (parent.RunQueueTask())
continue;
}
}
complete.Set();
}
public Pipeline(TaskSource tasksSource, ExecTaskGenerator execTaskGenerator)
{
this.tasksSource = tasksSource;
this.execTaskGenerator = execTaskGenerator;
}
protected override void Given()
{
customTasks = new CustomTasksDetector(taskFileFinder, null);
taskFileFinder.FindFiles("basefolder").Returns(new List<string>());
}
public void Run(TaskSource task)
{
complete.WaitOne();
this.task = task;
start.Set();
running.WaitOne();
}
