public async Task StartAsync(CancellationToken cancellationToken)
{
using (await singletonLifecycleLock.AcquireAsync())
{
if (!isSharedWorkerStarted)
{
await sharedOrchestrationService.CreateIfNotExistsAsync();
await sharedWorker.StartAsync();
isSharedWorkerStarted = true;
}
}
}
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}");
}
}
public void Configure(out TaskHubClient taskHubClient, out TaskHubWorker taskHub)
{
string storageConnectionString = "UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://127.0.0.1:10002/";
string taskHubName = "ScopeSample";
var orchestrationServiceAndClient =
new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = storageConnectionString,
TaskHubName = taskHubName
});
taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
taskHub = new TaskHubWorker(orchestrationServiceAndClient);
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
}
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());
}
}
static async Task Main(string[] args)
{
var listener = new CustomEventListener();
listener.EnableEvents(DefaultEventSource.Log, EventLevel.Warning);
string storageConnectionString = Storage.StorageConnectionString;
var settings = new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = storageConnectionString,
//TaskHubName = "PartitionTest",
TaskHubName = "PartitionTest",
PartitionCount = 1,
//MaxConcurrentTaskOrchestrationWorkItems = 100,
//MaxConcurrentTaskActivityWorkItems = 10,
//MaxStorageOperationConcurrency = Environment.ProcessorCount * 25,
};
var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings);
//just for test
await orchestrationServiceAndClient.DeleteAsync();
//await Task.Delay(TimeSpan.FromSeconds(60));
await orchestrationServiceAndClient.CreateIfNotExistsAsync();
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHubWorker = new TaskHubWorker(orchestrationServiceAndClient);
//1.create 1000** instance
await Test.CreateMockOrchestrationInstancesAsync(40, 5, taskHubClient);
//
await Test.StartWorker(taskHubWorker);
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
}
static void Main(string[] args)
{
AzureStorageOrchestrationService orchestrationService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings()
{
StorageConnectionString = "DefaultEndpointsProtocol=https;AccountName=kanodaprototype;AccountKey=0OiZiF8Xd2R8GvUxUh+cnganiM2LPIff/yfaHeyaMsjm8kG2VECV4XfZBWE84DVtyqkxiMNRalFexul9j+1tmA==;EndpointSuffix=core.windows.net",
TaskHubName = "Prototype"
});
orchestrationService.CreateIfNotExistsAsync().Wait();
TaskHubWorker taskHub = new TaskHubWorker(orchestrationService);
try
{
taskHub.AddTaskOrchestrations(
typeof(LetterCountOrchestration)
);
taskHub.AddTaskActivities(
new AddTask(),
new LogTask()
);
taskHub.StartAsync().Wait();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhadled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
static void Main(string[] args)
{
AzureStorageOrchestrationService orchestrationService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings()
{
StorageConnectionString = ServiceSettings.StorageConnectionString,
TaskHubName = ServiceSettings.TaskHubName
});
orchestrationService.CreateIfNotExistsAsync().Wait();
TaskHubWorker taskHub = new TaskHubWorker(orchestrationService);
try
{
taskHub.AddTaskOrchestrations(
typeof(LetterCountOrchestration)
);
taskHub.AddTaskActivities(
new AddTask(),
new LogTask()
);
taskHub.StartAsync().Wait();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
taskHub.StopAsync(true).Wait();
}
catch (Exception e)
{
// silently eat any unhadled exceptions.
Console.WriteLine($"worker exception: {e}");
}
}
async Task <AzureStorageOrchestrationService> EnsureTaskHubAsync(
string testName,
bool testDeletion,
bool deleteBeforeCreate = true,
string workerId = "test")
{
string storageConnectionString = TestHelpers.GetTestStorageAccountConnectionString();
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
string taskHubName = testName;
var settings = new AzureStorageOrchestrationServiceSettings
{
TaskHubName = taskHubName,
StorageConnectionString = storageConnectionString,
WorkerId = workerId,
};
Trace.TraceInformation($"Task Hub name: {taskHubName}");
var service = new AzureStorageOrchestrationService(settings);
if (deleteBeforeCreate)
{
await service.CreateAsync();
}
else
{
await service.CreateIfNotExistsAsync();
}
// Control queues
Assert.IsNotNull(service.AllControlQueues, "Control queue collection was not initialized.");
ControlQueue[] controlQueues = service.AllControlQueues.ToArray();
Assert.AreEqual(4, controlQueues.Length, "Expected to see the default four control queues created.");
foreach (ControlQueue queue in controlQueues)
{
Assert.IsTrue(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not created.");
}
// Work-item queue
WorkItemQueue workItemQueue = service.WorkItemQueue;
Assert.IsNotNull(workItemQueue, "Work-item queue client was not initialized.");
Assert.IsTrue(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not created.");
// TrackingStore
ITrackingStore trackingStore = service.TrackingStore;
Assert.IsNotNull(trackingStore, "Tracking Store was not initialized.");
try
{
Assert.IsTrue(trackingStore.ExistsAsync().Result, $"Tracking Store was not created.");
}
catch (NotSupportedException)
{ }
string expectedContainerName = taskHubName.ToLowerInvariant() + "-leases";
CloudBlobContainer taskHubContainer = storageAccount.CreateCloudBlobClient().GetContainerReference(expectedContainerName);
Assert.IsTrue(await taskHubContainer.ExistsAsync(), $"Task hub blob container {expectedContainerName} was not created.");
// Task Hub config blob
CloudBlob infoBlob = taskHubContainer.GetBlobReference("taskhub.json");
Assert.IsTrue(await infoBlob.ExistsAsync(), $"The blob {infoBlob.Name} was not created.");
// Task Hub lease container
CloudBlobDirectory leaseDirectory = taskHubContainer.GetDirectoryReference("default");
IListBlobItem[] leaseBlobs = (await this.ListBlobsAsync(leaseDirectory)).ToArray();
Assert.AreEqual(controlQueues.Length, leaseBlobs.Length, "Expected to see the same number of control queues and lease blobs.");
foreach (IListBlobItem blobItem in leaseBlobs)
{
string path = blobItem.Uri.AbsolutePath;
Assert.IsTrue(
controlQueues.Where(q => path.Contains(q.Name)).Any(),
$"Could not find any known control queue name in the lease name {path}");
}
if (testDeletion)
{
await service.DeleteAsync();
foreach (ControlQueue queue in controlQueues)
{
Assert.IsFalse(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not deleted.");
}
Assert.IsFalse(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not deleted.");
try
{
Assert.IsFalse(trackingStore.ExistsAsync().Result, $"Tracking Store was not deleted.");
}
catch (NotSupportedException)
{ }
Assert.IsFalse(await taskHubContainer.ExistsAsync(), $"Task hub blob container {taskHubContainer.Name} was not deleted.");
}
return(service);
}
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}");
}
}
