/// <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}");
}
}
