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); }
private static async Task Start(TaskHubWorker taskHubWorker) { _ = await taskHubWorker.StartAsync().ConfigureAwait(true); Console.ForegroundColor = ConsoleColor.Blue; Console.WriteLine("Worker Initialized ...."); }
/// <summary> /// Gets the list of services and their states in runtime repository. /// </summary> /// <param name="microserviceStateQuery"></param> /// <returns>List of microservice states.</returns> /// //public IEnumerable<MicroserviceState> QueryServices(MicroserviceStateQuery microserviceStateQuery) //{ // var result = m_HubClient.QueryOrchestrationStates(microserviceStateQuery.Query) // .Select(s => new MicroserviceState() { OrchestrationState = s }); // return result; //} /// <summary> /// Starts HubWorker. /// </summary> /// <param name="resetHub"></param> public async Task OpenAsync(bool resetHub = false) { // Includes details of inner exceptions. // throw new Ex() from task will be attached as serialized Details property of exception. //m_TaskHubWorker.TaskActivityDispatcher?.IncludeDetails = true; await m_TaskHubWorker.StartAsync(); }
public static async Task StartWorker(TaskHubWorker worker) { worker.AddTaskOrchestrations(typeof(MockOrchestration)); worker.AddTaskActivities(new MockActivity()); await worker.StartAsync(); Counter.Start(); }
/// <inheritdoc /> public async Task StartAsync(CancellationToken cancellationToken) { _logger.LogDebug(Strings.TaskHubWorkerStarting); if (Options.CreateIfNotExists) { await _worker.orchestrationService.CreateIfNotExistsAsync().ConfigureAwait(false); } await _worker.StartAsync().ConfigureAwait(false); _worker.TaskActivityDispatcher.IncludeDetails = Options.IncludeDetails.HasFlag(IncludeDetails.Activities); _worker.TaskOrchestrationDispatcher.IncludeDetails = Options.IncludeDetails.HasFlag(IncludeDetails.Orchestrations); }
public async Task StartAsync(CancellationToken cancellationToken) { using (await singletonLifecycleLock.AcquireAsync()) { if (!isSharedWorkerStarted) { await sharedOrchestrationService.CreateIfNotExistsAsync(); await sharedWorker.StartAsync(); isSharedWorkerStarted = true; } } }
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}"); } }
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(); }
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}"); } }
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"); } } }
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); } }
public async Task StartAsync(CancellationToken cancellationToken) { await _orchestrationService.CreateIfNotExistsAsync(); await _taskHubWorker.StartAsync(); }
/// <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(); } }
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}"); } }
// 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))); } }