public async Task MockSuborchestrationTest()
{
LocalOrchestrationService orchService = new LocalOrchestrationService();
TaskHubWorker worker = new TaskHubWorker(orchService);
TaskHubClient client = new TaskHubClient(orchService);
await worker.AddTaskOrchestrations(typeof(ParentWorkflow), typeof(ChildWorkflow))
.StartAsync();
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(ParentWorkflow), true);
OrchestrationState result = await client.WaitForOrchestrationAsync(id,
TimeSpan.FromSeconds(40), CancellationToken.None);
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.AreEqual(
"Child '0' completed.Child '1' completed.Child '2' completed.Child '3' completed.Child '4' completed.",
ParentWorkflow.Result, "Orchestration Result is wrong!!!");
ParentWorkflow.Result = string.Empty;
id = await client.CreateOrchestrationInstanceAsync(typeof(ParentWorkflow), false);
result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(40), CancellationToken.None);
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.AreEqual(
"Child '0' completed.Child '1' completed.Child '2' completed.Child '3' completed.Child '4' completed.",
ParentWorkflow.Result, "Orchestration Result is wrong!!!");
await worker.StopAsync(true);
}
public async Task SimpleGreetingOrchestration()
{
var orchestrationService = TestHelpers.GetTestOrchestrationService(nameof(SimpleGreetingOrchestration));
var worker = new TaskHubWorker(orchestrationService);
try
{
await worker.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration))
.AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask))
.StartAsync();
var client = new TaskHubClient(orchestrationService);
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), null);
OrchestrationState result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(Debugger.IsAttached ? 300 : 20), new CancellationToken());
Assert.Equal(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.Equal("Greeting send to Gabbar", SimplestGreetingsOrchestration.Result);
}
finally
{
await worker.StopAsync(true);
await orchestrationService.DeleteAsync();
}
}
public async Task MockRecreateOrchestrationTest()
{
LocalOrchestrationService orchService = new LocalOrchestrationService();
TaskHubWorker worker = new TaskHubWorker(orchService);
await worker.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration))
.AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask))
.StartAsync();
TaskHubClient client = new TaskHubClient(orchService);
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), null);
OrchestrationState result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(30), new CancellationToken());
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
await Assert.ThrowsExceptionAsync <OrchestrationAlreadyExistsException>(() => client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), id.InstanceId, null));
await Assert.ThrowsExceptionAsync <OrchestrationAlreadyExistsException>(() => client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), id.InstanceId, null, new OrchestrationStatus[] { OrchestrationStatus.Completed }));
SimplestGreetingsOrchestration.Result = String.Empty;
OrchestrationInstance id2 = await client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), id.InstanceId, null, new OrchestrationStatus[] {});
result = await client.WaitForOrchestrationAsync(id2, TimeSpan.FromSeconds(30), new CancellationToken());
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.AreEqual("Greeting send to Gabbar", SimplestGreetingsOrchestration.Result,
"Orchestration Result on Re-Create is wrong!!!");
await worker.StopAsync(true);
}
public async Task MockTimerTest()
{
LocalOrchestrationService orchService = new LocalOrchestrationService();
TaskHubWorker worker = new TaskHubWorker(orchService);
await worker.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration))
.AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask))
.StartAsync();
TaskHubClient client = new TaskHubClient(orchService);
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), "6");
Stopwatch sw = Stopwatch.StartNew();
OrchestrationState result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(40), new CancellationToken());
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.IsTrue(sw.Elapsed.Seconds > 6);
Assert.AreEqual("Greeting send to Gabbar", SimplestGreetingsOrchestration.Result,
"Orchestration Result is wrong!!!");
await worker.StopAsync(true);
}
public void TestCleanup()
{
if (!TestContext.TestName.Contains("TestHost"))
{
taskHub.StopAsync(true).Wait();
taskHub.orchestrationService.DeleteAsync(true).Wait();
}
}
/// <inheritdoc />
public async Task StopAsync(CancellationToken cancellationToken)
{
var cancel = Task.Delay(Timeout.Infinite, cancellationToken);
Task task = await Task.WhenAny(_worker.StopAsync(), cancel).ConfigureAwait(false);
if (cancel == task)
{
_logger.LogWarning(Strings.ForcedShutdown);
}
}
public async Task SimpleFanOutOrchestration_DurabilityTest()
{
int numToIterateTo = 500;
var orchestrationService = TestHelpers.GetTestOrchestrationService(nameof(SimpleFanOutOrchestration_DurabilityTest));
var worker = new TaskHubWorker(orchestrationService);
try
{
await worker.AddTaskOrchestrations(typeof(FanOutOrchestration))
.AddTaskActivities(typeof(SquareIntTask), typeof(SumIntTask))
.StartAsync();
var client = new TaskHubClient(orchestrationService);
int[] numsToSum = new int[numToIterateTo];
for (int i = 0; i < numToIterateTo; i++)
{
numsToSum[i] = i + 1;
}
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(FanOutOrchestration), numsToSum);
try
{
await client.WaitForOrchestrationAsync(id, TimeSpan.FromMilliseconds(500), new CancellationToken());
}
catch
{
//Timeout is expected in this case. 500 activities can't finish that fast.
await worker.StopAsync(true);
}
// Resume orchestration on "new" client
orchestrationService = TestHelpers.GetTestOrchestrationService(nameof(SimpleFanOutOrchestration_DurabilityTest));
worker = new TaskHubWorker(orchestrationService);
await worker.AddTaskOrchestrations(typeof(FanOutOrchestration))
.AddTaskActivities(typeof(SquareIntTask), typeof(SumIntTask))
.StartAsync();
client = new TaskHubClient(orchestrationService);
OrchestrationState result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(Debugger.IsAttached ? 20 : 20), new CancellationToken());
Assert.Equal(OrchestrationStatus.Completed, result.OrchestrationStatus);
// Sum of square numbers 1 to n = n * (n+1) * (2n+1) / 6
int expectedResult = (numToIterateTo * (numToIterateTo + 1) * (2 * numToIterateTo + 1)) / 6;
Assert.Equal(expectedResult, FanOutOrchestration.Result);
}
finally
{
await worker.StopAsync(true);
await orchestrationService.DeleteAsync();
}
}
private static async Task Main(string[] args)
{
foreach (DictionaryEntry env in Environment.GetEnvironmentVariables())
{
var name = (string)env.Key;
var value = (string)env.Value;
Console.WriteLine("{0}={1}", name, value);
}
var storageConnectionString = Environment.GetEnvironmentVariable("StorageConnectionString");
var taskHubName = Environment.GetEnvironmentVariable("TaskHubName");
var durationInSeconds = Environment.GetEnvironmentVariable("DurationInSeconds");
var mre = new ManualResetEvent(false);
var settings = new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = storageConnectionString,
TaskHubName = taskHubName
};
var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings);
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHub = new TaskHubWorker(orchestrationServiceAndClient);
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
try
{
await taskHub
.AddTaskOrchestrations(typeof(CronOrchestration))
.AddTaskActivities(new CronTask())
.StartAsync();
var orchestrationInstance = await taskHubClient.CreateOrchestrationInstanceAsync(
typeof(CronOrchestration),
TimeSpan.FromSeconds(double.Parse(durationInSeconds ?? "5")));
Console.WriteLine($"ExecutionId: {orchestrationInstance.ExecutionId}. Blocking main thread.");
mre.WaitOne();
await taskHub.StopAsync(true);
Console.WriteLine("Done!!");
}
catch (Exception e)
{
Console.WriteLine($"worker exception: {e}");
}
}
static async Task Main(string[] args)
{
//Use Azurite emulator
string storageConnectionString = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;" +
"BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1";
string taskHubName = "RetryTest";
var settings = new AzureStorageOrchestrationServiceSettings();
settings.StorageConnectionString = storageConnectionString;
settings.TaskHubName = taskHubName;
settings.UseDataContractSerialization = true;
var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings);
await orchestrationServiceAndClient.CreateIfNotExistsAsync();
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHub = new TaskHubWorker(orchestrationServiceAndClient);
// add instance
_ = Task.Run(async() =>
{
OrchestrationInstance ins = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(HelloOrchestration), "b", "");
});
// add worker
try
{
taskHub.AddTaskOrchestrations(
typeof(HelloOrchestration)
);
taskHub.AddTaskActivitiesFromInterface <IFailedTask>(new FailedTask());
await taskHub.StartAsync();
//Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhandled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
public async Task ScheduledStart_NotSupported()
{
var orchestrationService = TestHelpers.GetTestOrchestrationService(nameof(ScheduledStart_NotSupported));
var worker = new TaskHubWorker(orchestrationService);
try
{
await worker.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration))
.AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask))
.StartAsync();
var client = new TaskHubClient(orchestrationService);
var expectedStartTime = DateTime.UtcNow.AddSeconds(30);
await Assert.ThrowsAsync <NotSupportedException>(() => client.CreateScheduledOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), null, expectedStartTime));
}
finally
{
await worker.StopAsync(true);
await orchestrationService.DeleteAsync();
}
}
public async Task SimpleFanOutOrchestration()
{
// Using 1 more than the maximum concurrent count.
int numToIterateTo = 101;
var orchestrationService = TestHelpers.GetTestOrchestrationService(nameof(SimpleFanOutOrchestration));
var worker = new TaskHubWorker(orchestrationService);
try
{
await worker.AddTaskOrchestrations(typeof(FanOutOrchestration))
.AddTaskActivities(typeof(SquareIntTask), typeof(SumIntTask))
.StartAsync();
var client = new TaskHubClient(orchestrationService);
int[] numsToSum = new int[numToIterateTo];
for (int i = 0; i < numToIterateTo; i++)
{
numsToSum[i] = i + 1;
}
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(FanOutOrchestration), numsToSum);
OrchestrationState result = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(Debugger.IsAttached ? 20 : 20), new CancellationToken());
Assert.Equal(OrchestrationStatus.Completed, result.OrchestrationStatus);
// Sum of square numbers 1 to n = n * (n+1) * (2n+1) / 6
int expectedResult = (numToIterateTo * (numToIterateTo + 1) * (2 * numToIterateTo + 1)) / 6;
Assert.Equal(expectedResult, FanOutOrchestration.Result);
}
finally
{
await worker.StopAsync(true);
await orchestrationService.DeleteAsync();
}
}
static void Main(string[] args)
{
AzureStorageOrchestrationService orchestrationService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings()
{
StorageConnectionString = "DefaultEndpointsProtocol=https;AccountName=kanodaprototype;AccountKey=0OiZiF8Xd2R8GvUxUh+cnganiM2LPIff/yfaHeyaMsjm8kG2VECV4XfZBWE84DVtyqkxiMNRalFexul9j+1tmA==;EndpointSuffix=core.windows.net",
TaskHubName = "Prototype"
});
orchestrationService.CreateIfNotExistsAsync().Wait();
TaskHubWorker taskHub = new TaskHubWorker(orchestrationService);
try
{
taskHub.AddTaskOrchestrations(
typeof(LetterCountOrchestration)
);
taskHub.AddTaskActivities(
new AddTask(),
new LogTask()
);
taskHub.StartAsync().Wait();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhadled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
static void Main(string[] args)
{
AzureStorageOrchestrationService orchestrationService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings()
{
StorageConnectionString = ServiceSettings.StorageConnectionString,
TaskHubName = ServiceSettings.TaskHubName
});
orchestrationService.CreateIfNotExistsAsync().Wait();
TaskHubWorker taskHub = new TaskHubWorker(orchestrationService);
try
{
taskHub.AddTaskOrchestrations(
typeof(LetterCountOrchestration)
);
taskHub.AddTaskActivities(
new AddTask(),
new LogTask()
);
taskHub.StartAsync().Wait();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhadled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
/// <summary>
/// This is the main entry point for your service replica.
/// This method executes when this replica of your service becomes primary and has write status.
/// </summary>
/// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service replica.</param>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
try
{
var taskProvider = (new FabricOrchestrationProviderFactory(StateManager)).CreateProvider();
var taskHubClient = new TaskHubClient(taskProvider.OrchestrationServiceClient);
var taskHub = new TaskHubWorker(taskProvider.OrchestrationService);
OrchestrationInstance instance = null;
var instanceId = Guid.NewGuid().ToString();
ServiceEventSource.Current.Message($"Start orchestration");
// instance = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(CronOrchestration), instanceId,
// "0 12 **/2 Mon");
int[] input = { 10, 50, 10 };
instance = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(AverageCalculatorOrchestration),
instanceId, input);
// instance = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(MigrateOrchestration),
// instanceId,
// new MigrateOrchestrationData
// {SubscriptionId = "03a1cd39-47ac-4a57-9ff5-a2c2a2a76088", IsDisabled = false});
taskHub.AddTaskOrchestrations(
typeof(CronOrchestration),
typeof(AverageCalculatorOrchestration),
typeof(ErrorHandlingOrchestration),
typeof(SignalOrchestration),
typeof(MigrateOrchestration));
taskHub.AddTaskActivities(
new CronTask(),
new ComputeSumTask(),
new GoodTask(),
new BadTask(),
new CleanupTask());
taskHub.AddTaskActivitiesFromInterface <IManagementSqlOrchestrationTasks>(
new ManagementSqlOrchestrationTasks());
taskHub.AddTaskActivitiesFromInterface <IMigrationTasks>(new MigrationTasks());
taskHub.StartAsync().Wait();
ServiceEventSource.Current.Message("Waiting up to 60 seconds for completion");
var taskResult =
await taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.FromSeconds(60),
CancellationToken.None);
ServiceEventSource.Current.Message($"Task done: {taskResult.OrchestrationStatus}");
await taskHub.StopAsync(true);
}
catch (Exception ex)
{
ServiceEventSource.Current.Message($"worker exception: {ex}");
}
}
static void Main(string[] args)
{
eventListener = new ObservableEventListener();
eventListener.LogToFlatFile("Trace.log");
eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Warning);
string tableConnectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options))
{
string connectionString = ConfigurationManager.ConnectionStrings["Microsoft.ServiceBus.ConnectionString"].ConnectionString;
string taskHubName = ConfigurationManager.AppSettings["TaskHubName"];
IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(taskHubName, tableConnectionString);
ServiceBusOrchestrationServiceSettings settings = new ServiceBusOrchestrationServiceSettings
{
TaskOrchestrationDispatcherSettings =
{
CompressOrchestrationState = bool.Parse(ConfigurationManager.AppSettings["CompressOrchestrationState"]),
MaxConcurrentOrchestrations = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentOrchestrations"])
},
TaskActivityDispatcherSettings =
{
MaxConcurrentActivities = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentActivities"])
}
};
ServiceBusOrchestrationService orchestrationServiceAndClient =
new ServiceBusOrchestrationService(connectionString, taskHubName, instanceStore, null, settings);
TaskHubClient taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
TaskHubWorker taskHub = new TaskHubWorker(orchestrationServiceAndClient);
if (options.CreateHub)
{
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
}
OrchestrationInstance instance = null;
string instanceId = options.StartInstance;
if (!string.IsNullOrWhiteSpace(instanceId))
{
var driverConfig = new DriverOrchestrationData
{
NumberOfIteration = int.Parse(ConfigurationManager.AppSettings["DriverOrchestrationIterations"]),
NumberOfParallelTasks = int.Parse(ConfigurationManager.AppSettings["DriverOrchestrationParallelTasks"]),
SubOrchestrationData = new TestOrchestrationData
{
NumberOfParallelTasks = int.Parse(ConfigurationManager.AppSettings["ChildOrchestrationParallelTasks"]),
NumberOfSerialTasks = int.Parse(ConfigurationManager.AppSettings["ChildOrchestrationSerialTasks"]),
MaxDelayInMinutes = int.Parse(ConfigurationManager.AppSettings["TestTaskMaxDelayInMinutes"]),
}
};
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(DriverOrchestration), instanceId, driverConfig).Result;
}
else
{
instance = new OrchestrationInstance {
InstanceId = options.InstanceId
};
}
Console.WriteLine($"Orchestration starting: {DateTime.Now}");
Stopwatch stopWatch = Stopwatch.StartNew();
TestTask testTask = new TestTask();
taskHub.AddTaskActivities(testTask);
taskHub.AddTaskOrchestrations(typeof(DriverOrchestration));
taskHub.AddTaskOrchestrations(typeof(TestOrchestration));
taskHub.StartAsync().Wait();
int testTimeoutInSeconds = int.Parse(ConfigurationManager.AppSettings["TestTimeoutInSeconds"]);
OrchestrationState state = WaitForInstance(taskHubClient, instance, testTimeoutInSeconds);
stopWatch.Stop();
Console.WriteLine($"Orchestration Status: {state.OrchestrationStatus}");
Console.WriteLine($"Orchestration Result: {state.Output}");
Console.WriteLine($"Counter: {testTask.counter}");
TimeSpan totalTime = stopWatch.Elapsed;
string elapsedTime = $"{totalTime.Hours:00}:{totalTime.Minutes:00}:{totalTime.Seconds:00}.{totalTime.Milliseconds/10:00}";
Console.WriteLine($"Total Time: {elapsedTime}");
Console.ReadLine();
taskHub.StopAsync().Wait();
}
}
public async Task StopAsync(CancellationToken cancellationToken)
{
await _taskHubWorker.StopAsync();
}
static void Main(string[] args)
{
eventListener = new ObservableEventListener();
eventListener.LogToConsole();
eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.LogAlways);
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, ArgumentOptions))
{
string serviceBusConnectionString = GetSetting("ServiceBusConnectionString");
string storageConnectionString = GetSetting("StorageConnectionString");
string taskHubName = ConfigurationManager.AppSettings["taskHubName"];
//IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(taskHubName, storageConnectionString);
//var orchestrationServiceAndClient =
// new ServiceBusOrchestrationService(serviceBusConnectionString, taskHubName, instanceStore, null, null);
var orchestrationServiceAndClient =
new DurableTask.Emulator.LocalOrchestrationService();
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHub = new TaskHubWorker(orchestrationServiceAndClient);
if (ArgumentOptions.CreateHub)
{
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
}
OrchestrationInstance instance = null;
if (!string.IsNullOrWhiteSpace(ArgumentOptions.StartInstance))
{
string instanceId = ArgumentOptions.InstanceId ?? Guid.NewGuid().ToString();
Console.WriteLine($"Start Orchestration: {ArgumentOptions.StartInstance}");
switch (ArgumentOptions.StartInstance)
{
case "Greetings":
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(GreetingsOrchestration), instanceId, null).Result;
break;
case "Greetings2":
if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1)
{
throw new ArgumentException("parameters");
}
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(GreetingsOrchestration2), instanceId,
int.Parse(ArgumentOptions.Parameters[0])).Result;
break;
case "Cron":
// Sample Input: "0 12 * */2 Mon"
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CronOrchestration), instanceId,
(ArgumentOptions.Parameters != null && ArgumentOptions.Parameters.Length > 0) ? ArgumentOptions.Parameters[0] : null).Result;
break;
case "Average":
// Sample Input: "1 50 10"
if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 3)
{
throw new ArgumentException("parameters");
}
int[] input = ArgumentOptions.Parameters.Select(p => int.Parse(p)).ToArray();
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(AverageCalculatorOrchestration), instanceId, input).Result;
break;
case "ErrorHandling":
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(ErrorHandlingOrchestration), instanceId, null).Result;
break;
case "SumOfSquares":
instance = taskHubClient.CreateOrchestrationInstanceAsync(
"SumOfSquaresOrchestration",
"V1",
instanceId,
File.ReadAllText("SumofSquares\\BagOfNumbers.json"),
new Dictionary <string, string>(1)
{
{ "Category", "testing" }
}).Result;
break;
case "Signal":
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(SignalOrchestration), instanceId, null).Result;
break;
case "SignalAndRaise":
if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1)
{
throw new ArgumentException("parameters");
}
instance = taskHubClient.CreateOrchestrationInstanceWithRaisedEventAsync(typeof(SignalOrchestration), instanceId, null, ArgumentOptions.Signal, ArgumentOptions.Parameters[0]).Result;
break;
case "Replat":
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(MigrateOrchestration), instanceId,
new MigrateOrchestrationData {
SubscriptionId = "03a1cd39-47ac-4a57-9ff5-a2c2a2a76088", IsDisabled = false
}).Result;
break;
default:
throw new Exception("Unsupported Orchestration Name: " + ArgumentOptions.StartInstance);
}
Console.WriteLine("Workflow Instance Started: " + instance);
}
else if (!string.IsNullOrWhiteSpace(ArgumentOptions.Signal))
{
Console.WriteLine("Run RaiseEvent");
if (string.IsNullOrWhiteSpace(ArgumentOptions.InstanceId))
{
throw new ArgumentException("instanceId");
}
if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1)
{
throw new ArgumentException("parameters");
}
string instanceId = ArgumentOptions.InstanceId;
instance = new OrchestrationInstance {
InstanceId = instanceId
};
taskHubClient.RaiseEventAsync(instance, ArgumentOptions.Signal, ArgumentOptions.Parameters[0]).Wait();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
}
if (!ArgumentOptions.SkipWorker)
{
try
{
taskHub.AddTaskOrchestrations(
typeof(GreetingsOrchestration),
typeof(GreetingsOrchestration2),
typeof(CronOrchestration),
typeof(AverageCalculatorOrchestration),
typeof(ErrorHandlingOrchestration),
typeof(SignalOrchestration),
typeof(MigrateOrchestration),
typeof(SumOfSquaresOrchestration)
);
taskHub.AddTaskOrchestrations(
new NameValueObjectCreator <TaskOrchestration>("SumOfSquaresOrchestration", "V1", typeof(SumOfSquaresOrchestration)));
taskHub.AddTaskActivities(
new GetUserTask(),
new SendGreetingTask(),
new CronTask(),
new ComputeSumTask(),
new GoodTask(),
new BadTask(),
new CleanupTask(),
new EmailTask(),
new SumOfSquaresTask()
);
taskHub.AddTaskActivitiesFromInterface <IManagementSqlOrchestrationTasks>(new ManagementSqlOrchestrationTasks());
taskHub.AddTaskActivitiesFromInterface <IMigrationTasks>(new MigrationTasks());
taskHub.StartAsync().Wait();
Console.WriteLine("Waiting up to 60 seconds for completion.");
OrchestrationState taskResult = taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.FromSeconds(60), CancellationToken.None).Result;
Console.WriteLine($"Task done: {taskResult?.OrchestrationStatus}");
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhandled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
else
{
Console.WriteLine("Skip Worker");
}
}
}
static async Task Main(string[] args)
{
//Use Azurite emulator
string storageConnectionString = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;" +
"BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1";
string taskHubName = "Hello";
var settings = new AzureStorageOrchestrationServiceSettings();
settings.StorageConnectionString = storageConnectionString;
settings.TaskHubName = taskHubName;
settings.UseDataContractSerialization = true;
var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings);
await orchestrationServiceAndClient.CreateIfNotExistsAsync();
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHub = new TaskHubWorker(orchestrationServiceAndClient);
// add instance
_ = Task.Run(async() =>
{
OrchestrationInstance ins = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(HelloOrchestration), "");
});
// add worker
try
{
taskHub.AddTaskOrchestrations(
typeof(HelloOrchestration)
);
taskHub.AddTaskActivities(typeof(HelloTask));
taskHub.AddOrchestrationDispatcherMiddleware(async(context, next) =>
{
OrchestrationRuntimeState runtimeState = context.GetProperty <OrchestrationRuntimeState>();
var customInstance = OrchestrationInstanceEx.Initialize(runtimeState);
customInstance.Dic["a"] = "a";
customInstance.Dic["b"] = "b";
customInstance.Dic["c"] = "c";
context.SetProperty <OrchestrationInstance>(customInstance);
await next();
});
taskHub.AddOrchestrationDispatcherMiddleware(async(context, next) =>
{
var customInstance = OrchestrationInstanceEx.Get(context.GetProperty <OrchestrationInstance>());
context.SetProperty <OrchestrationInstance>(customInstance);
//Dic data can get here. But missed in HelloOrchestration context and ActivityDispatcherMiddleware
await next();
});
taskHub.AddActivityDispatcherMiddleware(async(context, next) =>
{
var customInstance = OrchestrationInstanceEx.Get(context.GetProperty <OrchestrationInstance>());
context.SetProperty <OrchestrationInstance>(customInstance);
//Dic data missed
await next();
});
await taskHub.StartAsync();
//Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhandled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
public async Task TestInstanceAndMessageDistribution()
{
const int InstanceCount = 50;
// Create a service and enqueue N messages.
// Make sure each partition has messages in it.
var settings = new AzureStorageOrchestrationServiceSettings()
{
StorageConnectionString = TestHelpers.GetTestStorageAccountConnectionString(),
TaskHubName = nameof(TestInstanceAndMessageDistribution),
PartitionCount = 4,
};
var service = new AzureStorageOrchestrationService(settings);
await service.CreateAsync();
var client = new TaskHubClient(service);
Trace.TraceInformation($"Starting {InstanceCount} orchestrations...");
var createTasks = new Task <OrchestrationInstance> [InstanceCount];
for (int i = 0; i < InstanceCount; i++)
{
createTasks[i] = client.CreateOrchestrationInstanceAsync(typeof(NoOpOrchestration), input: null);
}
OrchestrationInstance[] instances = await Task.WhenAll(createTasks);
ControlQueue[] controlQueues = service.AllControlQueues.ToArray();
Assert.AreEqual(settings.PartitionCount, controlQueues.Length, "Unexpected number of control queues");
foreach (ControlQueue cloudQueue in controlQueues)
{
await cloudQueue.InnerQueue.FetchAttributesAsync();
int messageCount = cloudQueue.InnerQueue.ApproximateMessageCount.GetValueOrDefault(-1);
Trace.TraceInformation($"Queue {cloudQueue.Name} has {messageCount} message(s).");
Assert.IsTrue(messageCount > 0, $"Queue {cloudQueue.Name} didn't receive any messages");
}
Trace.TraceInformation("Success. All queue partitions have orchestration start messages.");
// Start the service and let it process the previously enqueued messages.
// Check that there are exactly N unique partition keys in the table
Trace.TraceInformation("Starting the worker to consume the messages and run the orchestrations...");
var worker = new TaskHubWorker(service);
worker.AddTaskOrchestrations(typeof(NoOpOrchestration));
await worker.StartAsync();
try
{
// Wait for the instances to run and complete
OrchestrationState[] states = await Task.WhenAll(
instances.Select(i => client.WaitForOrchestrationAsync(i, TimeSpan.FromSeconds(30))));
Assert.IsTrue(
Array.TrueForAll(states, s => s?.OrchestrationStatus == OrchestrationStatus.Completed),
"Not all orchestrations completed successfully!");
var tableTrackingStore = service.TrackingStore as AzureTableTrackingStore;
if (tableTrackingStore != null)
{
DynamicTableEntity[] entities = (await tableTrackingStore.HistoryTable.ExecuteQuerySegmentedAsync(new TableQuery(), new TableContinuationToken())).ToArray();
int uniquePartitions = entities.GroupBy(e => e.PartitionKey).Count();
Trace.TraceInformation($"Found {uniquePartitions} unique partition(s) in table storage.");
Assert.AreEqual(InstanceCount, uniquePartitions, "Unexpected number of table partitions.");
}
}
finally
{
await worker.StopAsync(isForced : true);
}
}
// ReSharper disable once UnusedMember.Local
static void Main(string[] args)
{
using (DiagnosticPipelineFactory.CreatePipeline("eventFlowConfig.json"))
{
var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
string tableConnectionString = config.AppSettings.Settings["StorageConnectionString"].Value;
ParserResult <Options> parserResult = Parser.Default.ParseArguments <Options>(args);
parserResult.WithParsed(
options =>
{
string connectionString = config.ConnectionStrings.ConnectionStrings["Microsoft.ServiceBus.ConnectionString"].ConnectionString;
string taskHubName = config.AppSettings.Settings["TaskHubName"].Value;
IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(taskHubName, tableConnectionString);
var settings = new ServiceBusOrchestrationServiceSettings
{
TaskOrchestrationDispatcherSettings =
{
CompressOrchestrationState = bool.Parse(config.AppSettings.Settings["CompressOrchestrationState"].Value),
MaxConcurrentOrchestrations = int.Parse(config.AppSettings.Settings["MaxConcurrentOrchestrations"].Value)
},
TaskActivityDispatcherSettings =
{
MaxConcurrentActivities = int.Parse(config.AppSettings.Settings["MaxConcurrentActivities"].Value)
}
};
var orchestrationServiceAndClient =
new ServiceBusOrchestrationService(connectionString, taskHubName, instanceStore, null, settings);
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHub = new TaskHubWorker(orchestrationServiceAndClient);
if (options.CreateHub)
{
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
}
OrchestrationInstance instance;
string instanceId = options.StartInstance;
if (!string.IsNullOrWhiteSpace(instanceId))
{
var driverConfig = new DriverOrchestrationData
{
NumberOfIteration = int.Parse(config.AppSettings.Settings["DriverOrchestrationIterations"].Value),
NumberOfParallelTasks = int.Parse(config.AppSettings.Settings["DriverOrchestrationParallelTasks"].Value),
SubOrchestrationData = new TestOrchestrationData
{
NumberOfParallelTasks = int.Parse(config.AppSettings.Settings["ChildOrchestrationParallelTasks"].Value),
NumberOfSerialTasks = int.Parse(config.AppSettings.Settings["ChildOrchestrationSerialTasks"].Value),
MaxDelayInMinutes = int.Parse(config.AppSettings.Settings["TestTaskMaxDelayInMinutes"].Value),
}
};
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(DriverOrchestration), instanceId, driverConfig).Result;
}
else
{
instance = new OrchestrationInstance {
InstanceId = options.InstanceId
};
}
Console.WriteLine($"Orchestration starting: {DateTime.Now}");
Stopwatch stopWatch = Stopwatch.StartNew();
var testTask = new TestTask();
taskHub.AddTaskActivities(testTask);
taskHub.AddTaskOrchestrations(typeof(DriverOrchestration));
taskHub.AddTaskOrchestrations(typeof(TestOrchestration));
taskHub.StartAsync().Wait();
int testTimeoutInSeconds = int.Parse(config.AppSettings.Settings["TestTimeoutInSeconds"].Value);
OrchestrationState state = WaitForInstance(taskHubClient, instance, testTimeoutInSeconds);
stopWatch.Stop();
Console.WriteLine($"Orchestration Status: {state.OrchestrationStatus}");
Console.WriteLine($"Orchestration Result: {state.Output}");
Console.WriteLine($"Counter: {testTask.Counter}");
TimeSpan totalTime = stopWatch.Elapsed;
string elapsedTime = $"{totalTime.Hours:00}:{totalTime.Minutes:00}:{totalTime.Seconds:00}.{totalTime.Milliseconds / 10:00}";
Console.WriteLine($"Total Time: {elapsedTime}");
Console.ReadLine();
taskHub.StopAsync().Wait();
})
.WithNotParsed(errors => Console.Error.WriteLine(Options.GetUsage(parserResult)));
}
}
