/// <summary> /// Registers the collection of services. /// </summary> /// <param name="services"></param> /// <returns></returns> public ICollection <MicroserviceInstance> LoadServices(ICollection <Microservice> services) { loadTypesFromQualifiedNames(services); m_TaskHubWorker.AddTaskOrchestrations(services.Select(s => s.Orchestration).ToArray()); List <Type> taskActivities = new List <Type>(); List <Type> interfaceActivities = new List <Type>(); foreach (var task in services.SelectMany(s => s.Activities)) { if (taskActivities.Contains(task) == false) { if (typeof(TaskActivity).IsAssignableFrom(task)) { taskActivities.Add(task); } else { interfaceActivities.Add(task); } } } // Interface based tasks (do not implement TaskActivity) if (interfaceActivities.Count > 0) { m_TaskHubWorker.AddTaskActivitiesFromInterface(interfaceActivities); } // Classic task activities. m_TaskHubWorker.AddTaskActivities(taskActivities.ToArray()); List <MicroserviceInstance> allRunningInstances = new List <MicroserviceInstance>(); foreach (var svc in services) { List <MicroserviceInstance> runningInstances; bool isRunning = loadRunningInstances(svc.OrchestrationQName, out runningInstances); if (runningInstances != null) { allRunningInstances.AddRange(runningInstances); } RegisterServiceConfiguration(svc); } return(allRunningInstances); }
/// <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()); }
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 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!!!"); }
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 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); }
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 static async Task StartWorker(TaskHubWorker worker) { worker.AddTaskOrchestrations(typeof(MockOrchestration)); worker.AddTaskActivities(new MockActivity()); await worker.StartAsync(); Counter.Start(); }
public async Task SimplestGreetingsJumpStartTest() { var sbService = (ServiceBusOrchestrationService)taskHub.orchestrationService; string name = NameVersionHelper.GetDefaultName(typeof(SimplestGreetingsOrchestration)); string version = NameVersionHelper.GetDefaultVersion(typeof(SimplestGreetingsOrchestration)); await taskHub.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration)) .AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask)) .StartAsync(); OrchestrationInstance id = await TestHelpers.CreateOrchestrationInstanceAsync(sbService, name, version, null, null, true, false); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("Greeting send to Gabbar", SimplestGreetingsOrchestration.Result, "Orchestration Result is wrong!!!"); }
public void RegisterOrchestrationAndActivities(TaskHubWorker taskHub, ServiceProvider serviceProvider) { taskHub.AddTaskOrchestrations( typeof(TypedOrchestration), typeof(Orchestration) ); taskHub.AddTaskOrchestrations( ServiceProviderObjectCreator.CreateOrchestrationCreator <ScopedOrchestration>(serviceProvider), ServiceProviderObjectCreator.CreateOrchestrationCreator <TransitiveOrchestration>(serviceProvider) ); taskHub.AddOrchestrationDispatcherMiddleware((context, next) => { var orchestration = context.GetProperty <TaskOrchestration>(); if (orchestration is IMyIdentity identity) { //Console.WriteLine("Middleware :" + identity.MyIdentity); } return(next()); }); taskHub.AddActivityDispatcherMiddleware((context, next) => { var activity = context.GetProperty <TaskActivity>(); if (activity is IMyIdentity identity) { //Console.WriteLine("Middleware :" + identity.MyIdentity); } return(next()); }); taskHub.AddTaskActivities(typeof(Activity)); taskHub.AddTaskActivities( ServiceProviderObjectCreator.CreateActivityCreator <ScopedActivity>(serviceProvider), ServiceProviderObjectCreator.CreateActivityCreator <TransitiveActivity>(serviceProvider) ); }
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!!!"); }
/// <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 is null) { OrchestrationService = serviceProvider.GetRequiredService <IOrchestrationService>(); } // Verify we still have our ServiceProvider middleware if (OrchestrationMiddleware.FirstOrDefault(x => x.Type == typeof(ServiceProviderOrchestrationMiddleware)) is null) { throw new InvalidOperationException(Strings.ExpectedMiddlewareMissing( typeof(ServiceProviderOrchestrationMiddleware), nameof(OrchestrationMiddleware))); } if (ActivityMiddleware.FirstOrDefault(x => x.Type == typeof(ServiceProviderActivityMiddleware)) is null) { throw new InvalidOperationException(Strings.ExpectedMiddlewareMissing( typeof(ServiceProviderActivityMiddleware), nameof(ActivityMiddleware))); } ILoggerFactory loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>(); var worker = new TaskHubWorker( OrchestrationService, new GenericObjectManager <TaskOrchestration>(), new GenericObjectManager <TaskActivity>(), loggerFactory); worker.AddTaskOrchestrations(Orchestrations.Select(x => new OrchestrationObjectCreator(x)).ToArray()); worker.AddTaskActivities(Activities.Select(x => new ActivityObjectCreator(x)).ToArray()); // The first middleware added begins the service scope for all further middleware, the orchestration, and // activities. worker.AddOrchestrationDispatcherMiddleware(BeginMiddlewareScope(serviceProvider)); foreach (TaskMiddlewareDescriptor middlewareDescriptor in OrchestrationMiddleware) { worker.AddOrchestrationDispatcherMiddleware(WrapMiddleware(middlewareDescriptor)); } worker.AddActivityDispatcherMiddleware(BeginMiddlewareScope(serviceProvider)); foreach (TaskMiddlewareDescriptor middlewareDescriptor in ActivityMiddleware) { worker.AddActivityDispatcherMiddleware(WrapMiddleware(middlewareDescriptor)); } return(worker); }
private static async Task startAsync() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse("UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://127.0.0.1;"); IOrchestrationServiceInstanceStore store = new AzureTableInstanceStore("TestTaskHub9", "UseDevelopmentStorage=true;DevelopmentStorageProxyUri= http://127.0.0.1;"); var settings = new ServiceBusOrchestrationServiceSettings(); var service = new ServiceBusOrchestrationService("<ServiceBUsConnectionString>", "TestTaskHub9", store, null, settings); TaskHubWorker hubWorker = new TaskHubWorker(service); hubWorker.AddTaskOrchestrations(typeof(TestOrchestration)); hubWorker.AddTaskActivities(typeof(TestActivity1)); hubWorker.AddTaskActivities(typeof(TestActivity2)); await service.CreateIfNotExistsAsync(); await hubWorker.StartAsync(); }
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}"); } }
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}"); } }
internal TaskHubWorker Build(IServiceProvider provider) { var orchestrationService = provider.GetRequiredService <IOrchestrationService>(); var extendedOrchestrationService = provider.GetService <IExtendedOrchestrationService>(); var serviceScopeFactory = provider.GetRequiredService <IServiceScopeFactory>(); var orchestrations = provider.GetServices <ObjectCreator <TaskOrchestration> >().ToArray(); var activities = provider.GetServices <ObjectCreator <TaskActivity> >().ToArray(); var serviceProviderOrchestrationService = new WorkerOrchestrationService( orchestrationService, extendedOrchestrationService, serviceScopeFactory, orchestrations, activities, HasAllOrchestrations, HasAllActivities); var loggerFactory = provider.GetService <ILoggerFactory>(); var taskHubWorker = new TaskHubWorker(serviceProviderOrchestrationService, loggerFactory); // Orchestration middlewares var serviceProviderOrchestrationMiddleware = provider.GetRequiredService <ServiceProviderOrchestrationMiddleware>(); taskHubWorker.AddOrchestrationDispatcherMiddleware(serviceProviderOrchestrationMiddleware.Execute); foreach (var middleware in _orchestrationMiddlewares) { taskHubWorker.AddOrchestrationDispatcherMiddleware(CreateMiddleware(middleware)); } // Activitie middlewares var serviceProviderActivityMiddleware = provider.GetRequiredService <ServiceProviderActivityMiddleware>(); taskHubWorker.AddActivityDispatcherMiddleware(serviceProviderActivityMiddleware.Execute); foreach (var factory in _activitiesMiddlewares) { taskHubWorker.AddActivityDispatcherMiddleware(CreateMiddleware(factory)); } // Orchestrations and activities taskHubWorker.AddTaskOrchestrations(orchestrations); taskHubWorker.AddTaskActivities(activities); return(taskHubWorker); }
public static void Register(this TaskHubWorker worker, IServiceProvider sp, Assembly assembly) { foreach (var t in assembly.GetExportedTypes()) { var w = t.GetCustomAttribute <WorkflowAttribute>(); if (w == null) { continue; } var(factory, name, activities) = ClrHelper.Instance.Factory(t); worker.AddTaskOrchestrations(new WFactory <TaskOrchestration>(name, sp, factory)); foreach (var a in activities) { worker.AddTaskActivities(new WFactory <TaskActivity>(a.Name, sp, factory)); } } }
private static async Task StartWorker() { var workerId = Guid.NewGuid().ToString(); Console.WriteLine("*****************************************************"); Console.WriteLine("**** Starting Worker Service: " + workerId); Console.WriteLine("*****************************************************"); var storageConnectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; var taskHubName = ConfigurationManager.AppSettings["TaskHubName"]; var azureStorageOrchestrationSetting = new AzureStorageOrchestrationServiceSettings() { TaskHubName = taskHubName, StorageConnectionString = storageConnectionString, WorkerId = workerId }; IOrchestrationService orchestrationService = new AzureStorageOrchestrationService(azureStorageOrchestrationSetting); IOrchestrationServiceClient orchestrationServiceClient = new AzureStorageOrchestrationService(azureStorageOrchestrationSetting); var taskHubWorker = new TaskHubWorker(orchestrationService); var taskHubClient = new TaskHubClient(orchestrationServiceClient); _ = taskHubWorker.AddTaskOrchestrations(typeof(ModelValidationOrchestration)); _ = taskHubWorker.AddTaskActivities(typeof(ExtractInterfacesActivity)); _ = taskHubWorker.AddTaskActivities(typeof(ValidateInterfaceActivity)); await orchestrationService.CreateIfNotExistsAsync().ConfigureAwait(true); Task.Run(async() => { await Start(taskHubWorker).ConfigureAwait(true); }).Wait(); while (true) { Thread.Sleep(1000); Console.ForegroundColor = ConsoleColor.DarkGreen; Console.WriteLine("Working: " + DateTime.Now.ToString()); } }
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); }
public void OpenAndStartServiceHostTest() { 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 rnts = ((AzureTableInstanceStore)instanceStore).GetJumpStartEntitiesAsync(1000).Result; var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(OrchestrationStatus.Pending); byNameQuery.AddNameVersionFilter(typeof(CounterOrchestration).FullName); var results = ((AzureTableInstanceStore)instanceStore).QueryOrchestrationStatesAsync(byNameQuery).Result; var instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CounterOrchestration), Guid.NewGuid().ToString(), new TestOrchestrationInput()).Result; taskHub.StartAsync().Wait(); var state = instanceStore.GetOrchestrationStateAsync(instance.InstanceId, true).Result; var res = taskHubClient.GetOrchestrationHistoryAsync(instance).Result; taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.MaxValue).Wait(); }
public static void StartWorker(TaskHubWorker taskHub) { try { Console.WriteLine("Starting DurableTask worker..."); IUtilitySignupActivities utilitySignupActivities = new UtilitySignupActivities(); taskHub.AddTaskActivitiesFromInterface <IUtilitySignupActivities>(utilitySignupActivities); taskHub.AddTaskOrchestrations(typeof(UtilitySignupOrchestration)); taskHub.Start(); Console.WriteLine("DurableTask worker successfully started. Press any key to quit."); Console.ReadLine(); taskHub.Stop(true); } catch (Exception) { // silently eat any unhandled exceptions. } }
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 = 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}"); } }
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}"); } }
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); } }
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 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(); } }
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. } } } }
/// <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}"); } }