public static void VerifyWaitForDurableTasks(
DurableTaskHandler durableTaskHandler,
TimeSpan delayBeforeStopping,
bool expectedWaitForStop,
Action action
)
{
// action() call may block until Stop is invoked from another thread.
var thread = new Thread(() =>
{
Thread.Sleep(delayBeforeStopping);
durableTaskHandler.Stop();
});
thread.Start();
try
{
var elapsedMilliseconds = MeasureExecutionTimeInMilliseconds(action);
if (expectedWaitForStop)
{
Assert.True(elapsedMilliseconds > delayBeforeStopping.TotalMilliseconds * 0.8);
}
else
{
Assert.True(elapsedMilliseconds < delayBeforeStopping.TotalMilliseconds * 0.2);
}
}
finally
{
thread.Join();
}
}
public static void EmulateStop(DurableTaskHandler durableTaskHandler)
{
// In the actual usage, Stop is supposed to be invoked from another thread.
// However, in order to simplify tests and avoid spawning threads, waiting for
// them to finish, and handling potentially non-deterministic behavior,
// we cheat a little and invoke Stop _before_ invoking WaitAll/WaitAny,
// just to let WaitAll/WaitAny finish soon.
// The fact that WaitAll/WaitAny _actually_ blocks until Stop is invoked
// is verified by dedicated tests.
durableTaskHandler.Stop();
}
public void WaitAll_And_WaitAny_StartNewActivityBatch(bool invokeWaitAll, bool invokeWaitAny, int expectedNumberOfBatches)
{
var orchestrationContext = new OrchestrationContext {
History = new HistoryEvent[0]
};
var durableTaskHandler = new DurableTaskHandler();
durableTaskHandler.StopAndInitiateDurableTaskOrReplay(
new ActivityInvocationTask("Function", "Input"),
orchestrationContext,
noWait: true,
output: _ => {},
onFailure: _ => {}
);
if (invokeWaitAll)
{
durableTaskHandler.Stop(); // just to avoid the next call getting stuck waiting for a stop event
durableTaskHandler.WaitAll(new DurableTask[0], orchestrationContext, output: _ => {});
}
if (invokeWaitAny)
{
durableTaskHandler.Stop(); // just to avoid the next call getting stuck waiting for a stop event
durableTaskHandler.WaitAny(new DurableTask[0], orchestrationContext, output: _ => {});
}
durableTaskHandler.StopAndInitiateDurableTaskOrReplay(
new ActivityInvocationTask("Function", "Input"),
orchestrationContext,
noWait: true,
output: _ => {},
onFailure: _ => {}
);
var(_, actions) = orchestrationContext.OrchestrationActionCollector.WaitForActions(new AutoResetEvent(initialState: true));
Assert.Equal(expectedNumberOfBatches, actions.Count);
}
public void StopAndInitiateDurableTaskOrReplay_AddsActivityBatch_UnlessNoWait(bool noWait, int numberOfActions, int expectedNumberOfBatches)
{
var orchestrationContext = new OrchestrationContext {
History = new HistoryEvent[0]
};
var durableTaskHandler = new DurableTaskHandler();
for (var i = 0; i < numberOfActions; ++i)
{
durableTaskHandler.Stop(); // just to avoid the next call getting stuck waiting for a stop event
durableTaskHandler.StopAndInitiateDurableTaskOrReplay(
new ActivityInvocationTask("Function", "Input"),
orchestrationContext,
noWait: noWait,
output: _ => {},
onFailure: _ => {}
);
}
var(_, actions) = orchestrationContext.OrchestrationActionCollector.WaitForActions(new AutoResetEvent(initialState: true));
Assert.Equal(expectedNumberOfBatches, actions.Count);
}
protected override void StopProcessing()
{
_durableTaskHandler.Stop();
}