public async Task RecreateFailedInstance(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
string singletonInstanceId = $"HelloSingleton_{Guid.NewGuid():N}";
var client = await host.StartOrchestrationAsync(
typeof(Orchestrations.SayHelloWithActivity),
input : null, // this will cause the orchestration to fail
instanceId : singletonInstanceId);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Failed, status?.OrchestrationStatus);
client = await host.StartOrchestrationAsync(
typeof(Orchestrations.SayHelloWithActivity),
input : "NotNull",
instanceId : singletonInstanceId);
status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual("Hello, NotNull!", JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task LargeTextMessagePayloads(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Generate a medium random string payload
const int TargetPayloadSize = 128 * 1024; // 128 KB
const string Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 {}/<>.-";
var sb = new StringBuilder();
var random = new Random();
while (Encoding.Unicode.GetByteCount(sb.ToString()) < TargetPayloadSize)
{
for (int i = 0; i < 1000; i++)
{
sb.Append(Chars[random.Next(Chars.Length)]);
}
}
string message = sb.ToString();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Echo), message);
var status = await client.WaitForCompletionAsync(TimeSpan.FromMinutes(2));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(message, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task OrchestrationConcurrency(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
Func <Task> orchestrationStarter = async delegate()
{
var timeout = TimeSpan.FromSeconds(10);
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Approval), timeout);
await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
// Don't send any notification - let the internal timeout expire
};
int iterations = 50;
var tasks = new Task[iterations];
for (int i = 0; i < iterations; i++)
{
tasks[i] = orchestrationStarter();
}
// The 50 orchestrations above (which each delay for 10 seconds) should all complete in less than 60 seconds.
Task parallelOrchestrations = Task.WhenAll(tasks);
Task timeoutTask = Task.Delay(TimeSpan.FromSeconds(60));
Task winner = await Task.WhenAny(parallelOrchestrations, timeoutTask);
Assert.AreEqual(parallelOrchestrations, winner);
await host.StopAsync();
}
}
public async Task ActorOrchestration(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
int initialValue = 0;
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Counter), initialValue);
// Need to wait for the instance to start before sending events to it.
// TODO: This requirement may not be ideal and should be revisited.
await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
// Perform some operations
await client.RaiseEventAsync("operation", "incr");
// TODO: Sleeping to avoid a race condition where multiple ContinueAsNew messages
// are processed by the same instance at the same time, resulting in a corrupt
// storage failure in DTFx.
await Task.Delay(2000);
await client.RaiseEventAsync("operation", "incr");
await Task.Delay(2000);
await client.RaiseEventAsync("operation", "incr");
await Task.Delay(2000);
await client.RaiseEventAsync("operation", "decr");
await Task.Delay(2000);
await client.RaiseEventAsync("operation", "incr");
await Task.Delay(2000);
// Make sure it's still running and didn't complete early (or fail).
var status = await client.GetStatusAsync();
Assert.IsTrue(
status?.OrchestrationStatus == OrchestrationStatus.Running ||
status?.OrchestrationStatus == OrchestrationStatus.ContinuedAsNew);
// The end message will cause the actor to complete itself.
await client.RaiseEventAsync("operation", "end");
status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(3, JToken.Parse(status?.Output));
// When using ContinueAsNew, the original input is discarded and replaced with the most recent state.
Assert.AreNotEqual(initialValue, JToken.Parse(status?.Input));
await host.StopAsync();
}
}
public async Task RecreateTerminatedInstance(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
string singletonInstanceId = $"SingletonCounter_{Guid.NewGuid():N}";
// Using the counter orchestration because it will wait indefinitely for input.
var client = await host.StartOrchestrationAsync(
typeof(Orchestrations.Counter),
input : -1,
instanceId : singletonInstanceId);
// Need to wait for the instance to start before we can terminate it.
await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
await client.TerminateAsync("sayōnara");
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Terminated, status?.OrchestrationStatus);
Assert.AreEqual("-1", status?.Input);
Assert.AreEqual("sayōnara", status?.Output);
client = await host.StartOrchestrationAsync(
typeof(Orchestrations.Counter),
input : 0,
instanceId : singletonInstanceId);
status = await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Running, status?.OrchestrationStatus);
Assert.AreEqual("0", status?.Input);
await host.StopAsync();
}
}
public async Task RecreateRunningInstance(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(
enableExtendedSessions,
extendedSessionTimeoutInSeconds: 15))
{
await host.StartAsync();
string singletonInstanceId = $"SingletonCounter_{DateTime.Now:o}";
// Using the counter orchestration because it will wait indefinitely for input.
var client = await host.StartOrchestrationAsync(
typeof(Orchestrations.Counter),
input : 0,
instanceId : singletonInstanceId);
var status = await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Running, status?.OrchestrationStatus);
Assert.AreEqual("0", status?.Input);
Assert.AreEqual(null, status?.Output);
client = await host.StartOrchestrationAsync(
typeof(Orchestrations.Counter),
input : 99,
instanceId : singletonInstanceId);
// Note that with extended sessions, the startup time may take longer because the dispatcher
// will wait for the current extended session to expire before the new create message is accepted.
status = await client.WaitForStartupAsync(TimeSpan.FromSeconds(20));
Assert.AreEqual(OrchestrationStatus.Running, status?.OrchestrationStatus);
Assert.AreEqual("99", status?.Input);
await host.StopAsync();
}
}
public async Task ExtendedSessions_SessionTimeout()
{
const int SessionTimeoutInseconds = 5;
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(
enableExtendedSessions: true,
extendedSessionTimeoutInSeconds: SessionTimeoutInseconds))
{
await host.StartAsync();
string singletonInstanceId = $"SingletonCounter_{DateTime.Now:o}";
// Using the counter orchestration because it will wait indefinitely for input.
var client = await host.StartOrchestrationAsync(
typeof(Orchestrations.Counter),
input : 0,
instanceId : singletonInstanceId);
var status = await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Running, status?.OrchestrationStatus);
Assert.AreEqual("0", status?.Input);
Assert.AreEqual(null, status?.Output);
// Delay long enough for the session to expire
await Task.Delay(TimeSpan.FromSeconds(SessionTimeoutInseconds + 1));
await client.RaiseEventAsync("operation", "incr");
await Task.Delay(TimeSpan.FromSeconds(2));
// Make sure it's still running and didn't complete early (or fail).
status = await client.GetStatusAsync();
Assert.IsTrue(
status?.OrchestrationStatus == OrchestrationStatus.Running ||
status?.OrchestrationStatus == OrchestrationStatus.ContinuedAsNew);
// The end message will cause the actor to complete itself.
await client.RaiseEventAsync("operation", "end");
status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(1, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task LargeFanOutOrchestration(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.FanOutFanIn), 1000);
var status = await client.WaitForCompletionAsync(TimeSpan.FromMinutes(5));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
await host.StopAsync();
}
}
public async Task UnhandledActivityException(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
string message = "Kah-BOOOOM!!!";
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Throw), message);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Failed, status?.OrchestrationStatus);
Assert.IsTrue(status?.Output.Contains(message) == true);
await host.StopAsync();
}
}
public async Task UnhandledOrchestrationException(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Empty string input should result in ArgumentNullException in the orchestration code.
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Throw), "");
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Failed, status?.OrchestrationStatus);
Assert.IsTrue(status?.Output.Contains("null") == true);
await host.StopAsync();
}
}
public async Task HandledActivityException(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Empty string input should result in ArgumentNullException in the orchestration code.
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.TryCatchLoop), 5);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(5, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task ParallelOrchestration(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.DiskUsage), Environment.CurrentDirectory);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(90));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(Environment.CurrentDirectory, JToken.Parse(status?.Input));
Assert.IsTrue(long.Parse(status?.Output) > 0L);
await host.StopAsync();
}
}
public async Task SequentialOrchestration()
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions: false))
{
await host.StartAsync();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Factorial), 10);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(10, JToken.Parse(status?.Input));
Assert.AreEqual(3628800, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task HelloWorldOrchestration_Activity(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.SayHelloWithActivity), "World");
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual("World", JToken.Parse(status?.Input));
Assert.AreEqual("Hello, World!", JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task FanOutToTableStorage(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
int iterations = 100;
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.MapReduceTableStorage), iterations);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(120));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(iterations, int.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task SequentialOrchestrationNoReplay()
{
// Enable extended sesisons to ensure that the orchestration never gets replayed
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions: true))
{
await host.StartAsync();
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.FactorialNoReplay), 10);
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(10, JToken.Parse(status?.Input));
Assert.AreEqual(3628800, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task TerminateOrchestration(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Using the counter orchestration because it will wait indefinitely for input.
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Counter), 0);
// Need to wait for the instance to start before we can terminate it.
// TODO: This requirement may not be ideal and should be revisited.
await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
await client.TerminateAsync("sayōnara");
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(10));
Assert.AreEqual(OrchestrationStatus.Terminated, status?.OrchestrationStatus);
Assert.AreEqual("sayōnara", status?.Output);
await host.StopAsync();
}
}
public async Task TimerExpiration(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
var timeout = TimeSpan.FromSeconds(10);
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Approval), timeout);
// Need to wait for the instance to start before sending events to it.
// TODO: This requirement may not be ideal and should be revisited.
await client.WaitForStartupAsync(TimeSpan.FromSeconds(10));
// Don't send any notification - let the internal timeout expire
var status = await client.WaitForCompletionAsync(TimeSpan.FromSeconds(20));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual("Expired", JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task LargeBinaryStringMessagePayloads(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Construct string message from large binary file of size 826KB
string originalFileName = "large.jpeg";
string currentDirectory = Directory.GetCurrentDirectory();
string originalFilePath = Path.Combine(currentDirectory, originalFileName);
byte[] readBytes = File.ReadAllBytes(originalFilePath);
string message = Convert.ToBase64String(readBytes);
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.Echo), message);
var status = await client.WaitForCompletionAsync(TimeSpan.FromMinutes(1));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
Assert.AreEqual(message, JToken.Parse(status?.Output));
await host.StopAsync();
}
}
public async Task LargeBinaryByteMessagePayloads(bool enableExtendedSessions)
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(enableExtendedSessions))
{
await host.StartAsync();
// Construct byte array from large binary file of size 826KB
string originalFileName = "large.jpeg";
string currentDirectory = Directory.GetCurrentDirectory();
string originalFilePath = Path.Combine(currentDirectory, originalFileName);
byte[] readBytes = File.ReadAllBytes(originalFilePath);
var client = await host.StartOrchestrationAsync(typeof(Orchestrations.EchoBytes), readBytes);
var status = await client.WaitForCompletionAsync(TimeSpan.FromMinutes(1));
Assert.AreEqual(OrchestrationStatus.Completed, status?.OrchestrationStatus);
byte[] outputBytes = JToken.Parse(status?.Output).ToObject <byte[]>();
Assert.IsTrue(readBytes.SequenceEqual(outputBytes), "Original message byte array and returned messages byte array are not equal");
await host.StopAsync();
}
}
