public void Start_CancelledTask_NewTaskShouldBeCreated()
{
int count = 0;
Func <IEventNotification, Task> func = @event =>
{
count++;
return(Task.CompletedTask);
};
var subscription = Mock.Of <ISubscription>(s =>
s.Execution == Mock.Of <IExecution>(e =>
e.Delegate == func &&
e.MaxTake == 100 &&
e.Interval == TimeSpan.FromMilliseconds(100)) &&
s.Options == Mock.Of <IOptions>(o =>
o.QueueCapacity == 1000)
);
var handler = new SubscriptionHandler(subscription);
var sts = new SubscriptionTokenSource();
sts.Cancel();
handler.Start(sts);
Assert.False(Common.WaitUntil(() => count > 0, TimeSpan.FromSeconds(1)));
handler.Start();
Assert.True(Common.WaitUntil(() => count > 0, TimeSpan.FromSeconds(3)));
}
private SubscriptionTokenSource StartWithPausedState(SubscriptionHandler handler)
{
var sts = new SubscriptionTokenSource();
sts.Pause();
handler.Start(sts);
return(sts);
}
public void Dispose()
{
if (!_isDisposed)
{
SubscriptionTokenSource?.Dispose();
_isDisposed = true;
GC.SuppressFinalize(this);
}
}
private void InitiateTask(SubscriptionTokenSource subscriptionTokenSource)
{
bool state() => _task == null || _task.IsCompleted;
if (state())
{
lock (_taskSync)
{
if (state())
{
SubscriptionTokenSource?.Dispose();
SubscriptionTokenSource = subscriptionTokenSource;
_task = Task.Run(async() =>
{
//Initial delay
await Task.Delay(Subscription.Execution.Interval).ConfigureAwait(false);
while (!SubscriptionTokenSource.IsCancelled)
{
try
{
await SubscriptionTokenSource.PauseIfRequested().ConfigureAwait(false);
await OnTaskRun().ConfigureAwait(false);
}
catch (Exception)
{
//Catch all exceptions and never allow to throw that causes application to crash.
//TODO : internal logging
}
finally
{
_lastExecuted = DateTime.UtcNow;
await Task.Delay(Subscription.Execution.Interval).ConfigureAwait(false);
}
}
}, SubscriptionTokenSource.CancellationToken);
}
}
}
}
internal void Start(SubscriptionTokenSource subscriptionTokenSource)
{
InitiateTask(subscriptionTokenSource);
}
