public async Task InitializeAsync(bool startWorker = true)
{
// The initialization requires administrative credentials (default)
await new SqlOrchestrationService(this.OrchestrationServiceOptions).CreateIfNotExistsAsync();
// Enable multitenancy to isolate each test using low-privilege credentials
await this.EnableMultitenancyAsync();
// The runtime will use low-privilege credentials
string taskHubConnectionString = await this.CreateTaskHubLoginAsync();
this.OrchestrationServiceOptions = new SqlOrchestrationServiceSettings(taskHubConnectionString)
{
LoggerFactory = this.loggerFactory,
};
this.OrchestrationServiceMock = new Mock <SqlOrchestrationService>(this.OrchestrationServiceOptions)
{
CallBase = true
};
this.worker = new TaskHubWorker(this.OrchestrationServiceMock.Object, this.loggerFactory);
if (startWorker)
{
await this.worker.StartAsync();
}
this.client = new TaskHubClient(this.OrchestrationServiceMock.Object, loggerFactory: this.loggerFactory);
}
/// <inheritdoc/>
public void RegisterOrchestrations(TaskHubWorker taskHubWorker)
{
taskHubWorker
.AddTaskOrchestrations(this.GetOrchestrationTypes().ToArray())
.AddTaskOrchestrations(this.GetTaskOrchestrations().Select(instance => new DefaultObjectCreator <TaskOrchestration>(instance.Value)).ToArray())
.AddTaskActivities(GetActivityTypes().ToArray());
}
async Task StartAsync()
{
try
{
EnsureFabricOrchestrationProviderIsInitialized();
this.worker = new TaskHubWorker(this.fabricOrchestrationProvider.OrchestrationService, this.fabricOrchestrationProviderSettings.LoggerFactory);
if (this.registerOrchestrations2 != null)
{
this.localClient = new TaskHubClient(this.fabricOrchestrationProvider.OrchestrationServiceClient, loggerFactory: this.fabricOrchestrationProviderSettings.LoggerFactory);
this.registerOrchestrations2(this.worker, this.localClient);
}
else
{
this.registerOrchestrations(this.worker);
}
await this.worker.StartAsync();
this.worker.TaskActivityDispatcher.IncludeDetails = true;
}
catch (Exception exception)
{
ServiceFabricProviderEventSource.Tracing.ServiceRequestFailed("RunAsync failed", $"Exception Details Type: {exception.GetType()}, Message: {exception.Message}, StackTrace: {exception.StackTrace}");
throw;
}
}
static void Main(string[] args)
{
AppSettingsReader reader = new AppSettingsReader();
string servicebusConnectionString = reader.GetValue("Microsoft.ServiceBus.ConnectionString", typeof(string)).ToString();
string taskHubName = reader.GetValue("TaskHubName", typeof(string)).ToString();
TaskHubClient taskHubClient = new TaskHubClient(taskHubName, servicebusConnectionString);
TaskHubWorker taskHub = new TaskHubWorker(taskHubName, servicebusConnectionString);
taskHub.DeleteHub();
taskHub.CreateHubIfNotExists();
OrchestrationInstance instance = null;
string instanceId = "TestTaskHub : " + Guid.NewGuid();
taskHub.AddTaskOrchestrations((typeof(TaskHubProcessingOrchestration)));
taskHub.AddTaskActivitiesFromInterface <IActivityFunction>(new ActivityImplementor(), true);
taskHub.AddTaskActivities(new GetUserTask());
instance = taskHubClient.CreateOrchestrationInstance(typeof(TaskHubProcessingOrchestration), instanceId, "hello");
taskHub.Start();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.Stop(true);
}
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 MockGenerationTest()
{
GenerationBasicOrchestration.Result = 0;
GenerationBasicTask.GenerationCount = 0;
LocalOrchestrationService orchService = new LocalOrchestrationService();
TaskHubWorker worker = new TaskHubWorker(orchService);
TaskHubClient client = new TaskHubClient(orchService);
await worker.AddTaskOrchestrations(typeof(GenerationBasicOrchestration))
.AddTaskActivities(new GenerationBasicTask())
.StartAsync();
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(GenerationBasicOrchestration), 4);
// strip out the eid so we wait for the latest one always
OrchestrationInstance masterid = new OrchestrationInstance {
InstanceId = id.InstanceId
};
OrchestrationState result1 = await client.WaitForOrchestrationAsync(id, TimeSpan.FromSeconds(10), CancellationToken.None);
OrchestrationState result2 = await client.WaitForOrchestrationAsync(masterid, TimeSpan.FromSeconds(20), CancellationToken.None);
Assert.AreEqual(OrchestrationStatus.ContinuedAsNew, result1.OrchestrationStatus);
Assert.AreEqual(OrchestrationStatus.Completed, result2.OrchestrationStatus);
Assert.AreEqual(4, GenerationBasicOrchestration.Result, "Orchestration Result is wrong!!!");
}
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);
}
private static async Task Start(TaskHubWorker taskHubWorker)
{
_ = await taskHubWorker.StartAsync().ConfigureAwait(true);
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Worker Initialized ....");
}
public void TestInitialize()
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
taskHub.orchestrationService.CreateAsync(true).Wait();
}
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 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();
}
}
/// <summary>
/// Builds and returns a <see cref="TaskHubWorker"/> using the configurations from this instance.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>A new <see cref="TaskHubWorker"/>.</returns>
public TaskHubWorker Build(IServiceProvider serviceProvider)
{
Check.NotNull(serviceProvider, nameof(serviceProvider));
if (OrchestrationService == null)
{
throw new InvalidOperationException(Strings.OrchestrationInstanceNull);
}
var worker = new TaskHubWorker(
OrchestrationService,
new WrapperObjectManager <TaskOrchestration>(_orchestrations, type => new WrapperOrchestration(type)),
new WrapperObjectManager <TaskActivity>(_activities, type => new WrapperActivity(type)));
// The first middleware added begins the service scope for all further middleware, the orchestration, and activities.
worker.AddOrchestrationDispatcherMiddleware(BeginMiddlewareScope(serviceProvider));
worker.AddOrchestrationDispatcherMiddleware(WrapMiddleware(typeof(ServiceProviderOrchestrationMiddleware)));
foreach (Type middlewareType in _orchestrationsMiddleware)
{
worker.AddOrchestrationDispatcherMiddleware(WrapMiddleware(middlewareType));
}
worker.AddActivityDispatcherMiddleware(BeginMiddlewareScope(serviceProvider));
worker.AddActivityDispatcherMiddleware(WrapMiddleware(typeof(ServiceProviderActivityMiddleware)));
foreach (Type middlewareType in _activitiesMiddleware)
{
worker.AddActivityDispatcherMiddleware(WrapMiddleware(middlewareType));
}
return(worker);
}
static void Main(string[] args)
{
eventListener = new ObservableEventListener();
eventListener.LogToConsole();
eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.LogAlways);
TraceSource source = new TraceSource("DurableTask");
source.Listeners.AddRange(Trace.Listeners);
IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(TaskHubName, StorageConnectionString);
ServiceBusOrchestrationService orchestrationServiceAndClient =
new ServiceBusOrchestrationService(ServiceBusConnectionString, TaskHubName, instanceStore, null, null);
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
TaskHubClient taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
TaskHubWorker taskHub = new TaskHubWorker(orchestrationServiceAndClient);
taskHub.AddTaskOrchestrations(typeof(CounterOrchestration));
taskHub.AddTaskActivities(typeof(Task1), typeof(Task2));
var instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CounterOrchestration), Guid.NewGuid().ToString(), new TestOrchestrationInput()).Result;
taskHub.StartAsync().Wait();
//taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.MaxValue).Wait();
Thread.Sleep(int.MaxValue);
}
public TestOrchestrationHost(AzureStorageOrchestrationService service)
{
this.worker = new TaskHubWorker(service);
this.client = new TaskHubClient(service);
this.addedOrchestrationTypes = new HashSet <Type>();
this.addedActivityTypes = new HashSet <Type>();
}
public ExceptionHandlingIntegrationTests()
{
var service = new LocalOrchestrationService();
this.worker = new TaskHubWorker(service);
this.client = new TaskHubClient(service);
}
public WorkerHostedService(
IOrchestrationService orchestrationService,
TaskHubWorker taskHubWorker)
{
_orchestrationService = orchestrationService;
_taskHubWorker = taskHubWorker;
}
public void TestInitialize()
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
taskHub.CreateHub();
}
public static async Task StartWorker(TaskHubWorker worker)
{
worker.AddTaskOrchestrations(typeof(MockOrchestration));
worker.AddTaskActivities(new MockActivity());
await worker.StartAsync();
Counter.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskHubBackgroundService"/> class.
/// </summary>
/// <param name="worker">The task hub worker. Not null.</param>
/// <param name="logger">The logger. Not null.</param>
/// <param name="options">The task hub options.</param>
public TaskHubBackgroundService(
TaskHubWorker worker,
ILogger <TaskHubBackgroundService> logger,
IOptions <TaskHubOptions> options)
{
_worker = Check.NotNull(worker, nameof(worker));
_logger = Check.NotNull(logger, nameof(logger));
_options = Check.NotNull(options, nameof(options));
}
public void TestInitialize()
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
taskHub.DeleteHub();
taskHub.CreateHubIfNotExists();
}
/// <summary>
/// Internal initialization call from the WebJobs host.
/// </summary>
/// <param name="context">Extension context provided by WebJobs.</param>
void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
{
ConfigureLoaderHooks();
// Functions V1 has it's configuration initialized at startup time (now).
// For Functions V2 (and for some unit tests) configuration happens earlier in the pipeline.
if (!this.isOptionsConfigured)
{
this.InitializeForFunctionsV1(context);
}
// Throw if any of the configured options are invalid
this.Options.Validate();
// For 202 support
if (this.Options.NotificationUrl == null)
{
#pragma warning disable CS0618 // Type or member is obsolete
this.Options.NotificationUrl = context.GetWebhookHandler();
#pragma warning restore CS0618 // Type or member is obsolete
}
this.TraceConfigurationSettings();
var bindings = new BindingHelper(this, this.TraceHelper);
// Note that the order of the rules is important
var rule = context.AddBindingRule <DurableClientAttribute>()
.AddConverter <string, StartOrchestrationArgs>(bindings.StringToStartOrchestrationArgs)
.AddConverter <JObject, StartOrchestrationArgs>(bindings.JObjectToStartOrchestrationArgs)
.AddConverter <IDurableClient, string>(bindings.DurableOrchestrationClientToString);
rule.BindToCollector <StartOrchestrationArgs>(bindings.CreateAsyncCollector);
rule.BindToInput <IDurableOrchestrationClient>(this.GetClient);
rule.BindToInput <IDurableEntityClient>(this.GetClient);
rule.BindToInput <IDurableClient>(this.GetClient);
string storageConnectionString = null;
var providerFactory = this.durabilityProviderFactory as AzureStorageDurabilityProviderFactory;
if (providerFactory != null)
{
storageConnectionString = providerFactory.GetDefaultStorageConnectionString();
}
context.AddBindingRule <OrchestrationTriggerAttribute>()
.BindToTrigger(new OrchestrationTriggerAttributeBindingProvider(this, context, storageConnectionString, this.TraceHelper));
context.AddBindingRule <ActivityTriggerAttribute>()
.BindToTrigger(new ActivityTriggerAttributeBindingProvider(this, context, storageConnectionString, this.TraceHelper));
context.AddBindingRule <EntityTriggerAttribute>()
.BindToTrigger(new EntityTriggerAttributeBindingProvider(this, context, storageConnectionString, this.TraceHelper));
this.taskHubWorker = new TaskHubWorker(this.defaultDurabilityProvider, this, this);
this.taskHubWorker.AddOrchestrationDispatcherMiddleware(this.EntityMiddleware);
this.taskHubWorker.AddOrchestrationDispatcherMiddleware(this.OrchestrationMiddleware);
}
public void TestInitialize()
{
this.client = TestHelpers.CreateTaskHubClient();
this.taskHub = TestHelpers.CreateTaskHub();
this.taskHub.orchestrationService.CreateAsync(true).Wait();
this.taskHubNoCompression = TestHelpers.CreateTaskHubNoCompression();
}
public void TestInitialize()
{
if (!TestContext.TestName.Contains("TestHost"))
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub(TimeSpan.FromSeconds(30));
taskHub.orchestrationService.CreateAsync(true).Wait();
}
}
public void TestInitialize()
{
if (!TestContext.TestName.Contains("TestHost"))
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
taskHubNoCompression = TestHelpers.CreateTaskHubNoCompression();
taskHub.orchestrationService.CreateAsync(true).Wait();
}
}
public void TestInitialize()
{
this.client = TestHelpers.CreateTaskHubClient();
this.orchestrationService = this.client.ServiceClient as ServiceBusOrchestrationService;
this.queryClient = this.orchestrationService?.InstanceStore as AzureTableInstanceStore;
this.taskHub = TestHelpers.CreateTaskHub();
this.taskHub.orchestrationService.CreateAsync(true).Wait();
}
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();
}
}
public async Task MockRaiseEventTest()
{
LocalOrchestrationService orchService = new LocalOrchestrationService();
TaskHubWorker worker = new TaskHubWorker(orchService);
TaskHubClient client = new TaskHubClient(orchService);
await worker.AddTaskOrchestrations(typeof(GenerationSignalOrchestration))
.StartAsync();
OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(
typeof(GenerationSignalOrchestration), 5);
var signalId = new OrchestrationInstance {
InstanceId = id.InstanceId
};
await Task.Delay(2 * 500);
await client.RaiseEventAsync(signalId, "Count", "1");
GenerationSignalOrchestration.signal.Set();
await Task.Delay(2 * 500);
GenerationSignalOrchestration.signal.Reset();
await client.RaiseEventAsync(signalId, "Count", "2");
await Task.Delay(2 * 500);
await client.RaiseEventAsync(signalId, "Count", "3"); // will be recieved by next generation
GenerationSignalOrchestration.signal.Set();
await Task.Delay(2 * 500);
GenerationSignalOrchestration.signal.Reset();
await client.RaiseEventAsync(signalId, "Count", "4");
await Task.Delay(2 * 500);
await client.RaiseEventAsync(signalId, "Count", "5"); // will be recieved by next generation
await client.RaiseEventAsync(signalId, "Count", "6"); // lost
await client.RaiseEventAsync(signalId, "Count", "7"); // lost
GenerationSignalOrchestration.signal.Set();
OrchestrationState result = await client.WaitForOrchestrationAsync(new OrchestrationInstance { InstanceId = id.InstanceId },
TimeSpan.FromSeconds(40), CancellationToken.None);
Assert.AreEqual(OrchestrationStatus.Completed, result.OrchestrationStatus);
Assert.AreEqual("5", GenerationSignalOrchestration.Result, "Orchestration Result is wrong!!!");
}
public async Task MultipleConcurrentRoleStartsTestNoInitialHub()
{
// Make sure we cleanup we start from scratch
await this.taskHub.StopAsync(true);
await this.taskHub.orchestrationService.DeleteAsync();
const int ConcurrentClientsAndHubs = 4;
var rnd = new Random();
var clients = new List <TaskHubClient>(ConcurrentClientsAndHubs);
var workers = new List <TaskHubWorker>(ConcurrentClientsAndHubs);
IList <Task> tasks = new List <Task>();
for (var i = 0; i < ConcurrentClientsAndHubs; i++)
{
clients.Add(TestHelpers.CreateTaskHubClient());
workers.Add(TestHelpers.CreateTaskHub(new ServiceBusOrchestrationServiceSettings
{
TaskOrchestrationDispatcherSettings = { DispatcherCount = 4 },
TrackingDispatcherSettings = { DispatcherCount = 4 },
TaskActivityDispatcherSettings = { DispatcherCount = 4 }
}));
tasks.Add(workers[i].orchestrationService.CreateIfNotExistsAsync());
}
await Task.WhenAll(tasks);
GenerationBasicOrchestration.Result = 0;
GenerationBasicTask.GenerationCount = 0;
// ReSharper disable once UnusedVariable
TaskHubWorker selectedHub = workers[(rnd.Next(ConcurrentClientsAndHubs))];
TaskHubClient selectedClient = clients[(rnd.Next(ConcurrentClientsAndHubs))];
tasks.Clear();
for (var i = 0; i < ConcurrentClientsAndHubs; i++)
{
tasks.Add(workers[i].AddTaskOrchestrations(typeof(GenerationBasicOrchestration))
.AddTaskActivities(new GenerationBasicTask())
.StartAsync());
}
await Task.WhenAll(tasks);
OrchestrationInstance instance = await selectedClient.CreateOrchestrationInstanceAsync(typeof(GenerationBasicOrchestration), 4);
OrchestrationState state = await selectedClient.WaitForOrchestrationAsync(instance, TimeSpan.FromSeconds(60), CancellationToken.None);
Assert.IsNotNull(state);
Assert.AreEqual(OrchestrationStatus.Completed, state.OrchestrationStatus, TestHelpers.GetInstanceNotCompletedMessage(this.client, instance, 60));
Assert.AreEqual(4, GenerationBasicOrchestration.Result, "Orchestration Result is wrong!!!");
await Task.WhenAll(workers.Select(worker => worker.StopAsync(true)));
}
public void TestInitialize()
{
if (!TestContext.TestName.Contains("TestHost"))
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
taskHubNoCompression = TestHelpers.CreateTaskHubNoCompression();
taskHub.DeleteHub();
taskHub.CreateHubIfNotExists();
}
}
public TestOrchestrationHost(AzureStorageOrchestrationServiceSettings settings)
{
this.service = new AzureStorageOrchestrationService(settings);
this.service.CreateAsync().GetAwaiter().GetResult();
this.settings = settings;
this.worker = new TaskHubWorker(service, loggerFactory: settings.LoggerFactory);
this.client = new TaskHubClient(service, loggerFactory: settings.LoggerFactory);
this.addedOrchestrationTypes = new HashSet <Type>();
this.addedActivityTypes = new HashSet <Type>();
}
private static void run()
{
string connectionString = ConfigurationManager.AppSettings["SbConnStr"];
string taskHubName = ConfigurationManager.AppSettings["TaskHubName"];
TaskHubClient taskHubClient = new TaskHubClient(taskHubName, connectionString);
TaskHubWorker taskHubWorker = new TaskHubWorker(taskHubName, connectionString);
taskHubWorker.CreateHub();
OrchestrationInstance instance = taskHubClient.CreateOrchestrationInstance(typeof(WfTaskOrchestration), "Hello");
taskHubWorker.AddTaskOrchestrations(typeof(WfTaskOrchestration));
taskHubWorker.AddTaskActivities(new WOEIDLookupTask(), new WForecastsTask());
taskHubWorker.Start();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHubWorker.Stop(true);
}
static void Main(string[] args)
{
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options))
{
string servicebusConnectionString = Program.GetSetting("ServiceBusConnectionString");
string storageConnectionString = Program.GetSetting("StorageConnectionString");
string taskHubName = ConfigurationManager.AppSettings["taskHubName"];
TaskHubClient taskHubClient = new TaskHubClient(taskHubName, servicebusConnectionString, storageConnectionString);
TaskHubWorker taskHub = new TaskHubWorker(taskHubName, servicebusConnectionString, storageConnectionString);
if (options.CreateHub)
{
taskHub.CreateHub();
}
if (!string.IsNullOrWhiteSpace(options.StartInstance))
{
string instanceId = options.InstanceId;
OrchestrationInstance instance = null;
switch (options.StartInstance)
{
case "Greetings":
instance = taskHubClient.CreateOrchestrationInstance(typeof(GreetingsOrchestration), instanceId, null);
break;
case "Greetings2":
if (options.Parameters == null || options.Parameters.Length != 1)
{
throw new ArgumentException("parameters");
}
instance = taskHubClient.CreateOrchestrationInstance(typeof(GreetingsOrchestration2), instanceId,
int.Parse(options.Parameters[0]));
break;
case "Cron":
// Sample Input: "0 12 * */2 Mon"
instance = taskHubClient.CreateOrchestrationInstance(typeof(CronOrchestration), instanceId,
(options.Parameters != null && options.Parameters.Length > 0) ? options.Parameters[0] : null);
break;
case "Average":
// Sample Input: "1 50 10"
if (options.Parameters == null || options.Parameters.Length != 3)
{
throw new ArgumentException("parameters");
}
int[] input = options.Parameters.Select(p => int.Parse(p)).ToArray();
instance = taskHubClient.CreateOrchestrationInstance(typeof(AverageCalculatorOrchestration), instanceId, input);
break;
case "ErrorHandling":
instance = taskHubClient.CreateOrchestrationInstance(typeof(ErrorHandlingOrchestration), instanceId, null);
break;
case "Signal":
instance = taskHubClient.CreateOrchestrationInstance(typeof(SignalOrchestration), instanceId, null);
break;
case "Replat":
instance = taskHubClient.CreateOrchestrationInstance(typeof(MigrateOrchestration), instanceId,
new MigrateOrchestrationData() { SubscriptionId = "03a1cd39-47ac-4a57-9ff5-a2c2a2a76088", IsDisabled = false });
break;
default:
throw new Exception("Unsupported Orchestration Name: " + options.StartInstance);
}
Console.WriteLine("Workflow Instance Started: " + instance);
}
else if (!string.IsNullOrWhiteSpace(options.Signal))
{
if (string.IsNullOrWhiteSpace(options.InstanceId))
{
throw new ArgumentException("instantceId");
}
if (options.Parameters == null || options.Parameters.Length != 1)
{
throw new ArgumentException("parameters");
}
string instanceId = options.InstanceId;
OrchestrationInstance instance = new OrchestrationInstance { InstanceId = instanceId };
taskHubClient.RaiseEvent(instance, options.Signal, options.Parameters[0]);
}
if (!options.SkipWorker)
{
try
{
taskHub.AddTaskOrchestrations(typeof(GreetingsOrchestration), typeof(GreetingsOrchestration2), typeof(CronOrchestration),
typeof (AverageCalculatorOrchestration), typeof (ErrorHandlingOrchestration), typeof (SignalOrchestration));
taskHub.AddTaskOrchestrations(typeof(MigrateOrchestration));
taskHub.AddTaskActivities(new GetUserTask(), new SendGreetingTask(), new CronTask(), new ComputeSumTask(), new GoodTask(), new BadTask(), new CleanupTask(),
new EmailTask());
taskHub.AddTaskActivitiesFromInterface<IManagementSqlOrchestrationTasks>(new ManagementSqlOrchestrationTasks());
taskHub.AddTaskActivitiesFromInterface<IMigrationTasks>(new MigrationTasks());
taskHub.Start();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.Stop(true);
}
catch (Exception)
{
// silently eat any unhadled exceptions.
}
}
}
}
public void TestInitialize()
{
client = TestHelpers.CreateTaskHubClient();
taskHub = TestHelpers.CreateTaskHub();
}
static void Main(string[] args)
{
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"];
TaskHubClient taskHubClient = new TaskHubClient(taskHubName, connectionString, tableConnectionString);
TaskHubWorkerSettings settings = new TaskHubWorkerSettings();
settings.TaskOrchestrationDispatcherSettings.CompressOrchestrationState = bool.Parse(ConfigurationManager.AppSettings["CompressOrchestrationState"]);
settings.TaskActivityDispatcherSettings.MaxConcurrentActivities = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentActivities"]);
settings.TaskOrchestrationDispatcherSettings.MaxConcurrentOrchestrations = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentOrchestrations"]);
TaskHubWorker taskHub = new TaskHubWorker(taskHubName, connectionString, tableConnectionString, settings);
if (options.CreateHub)
{
taskHub.CreateHub();
}
OrchestrationInstance instance = null;
string instanceId = options.StartInstance;
if (!string.IsNullOrWhiteSpace(instanceId))
{
instance = taskHubClient.CreateOrchestrationInstance(typeof(DriverOrchestration), instanceId, 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"]),
MaxDelayInSeconds = int.Parse(ConfigurationManager.AppSettings["TestTaskMaxDelayInMinutes"]),
},
});
}
else
{
instance = new OrchestrationInstance { InstanceId = options.InstanceId };
}
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
TestTask testTask = new TestTask();
taskHub.AddTaskActivities(testTask);
taskHub.AddTaskOrchestrations(typeof(DriverOrchestration));
taskHub.AddTaskOrchestrations(typeof(TestOrchestration));
taskHub.Start();
int testTimeoutInSeconds = int.Parse(ConfigurationManager.AppSettings["TestTimeoutInSeconds"]);
OrchestrationState state = WaitForInstance(taskHubClient, instance, testTimeoutInSeconds);
stopWatch.Stop();
Console.WriteLine("Orchestration Status: " + state.OrchestrationStatus.ToString());
Console.WriteLine("Orchestration Result: " + state.Output);
Console.WriteLine("Counter: " + testTask.counter);
TimeSpan totalTime = stopWatch.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
totalTime.Hours, totalTime.Minutes, totalTime.Seconds,
totalTime.Milliseconds / 10);
Console.WriteLine("Total Time: " + elapsedTime);
taskHub.Stop();
}
}
