internal TaskOrchestrationDispatcher(MessagingFactory messagingFactory,
TrackingDispatcher trackingDispatcher,
TaskHubDescription taskHubDescription,
TaskHubWorkerSettings workerSettings,
string orchestratorEntityName,
string workerEntityName,
string trackingEntityName,
NameVersionObjectManager <TaskOrchestration> objectManager)
: base("TaskOrchestration Dispatcher", item => item.Session == null ? string.Empty : item.Session.SessionId)
{
this.taskHubDescription = taskHubDescription;
settings = workerSettings.Clone();
this.orchestratorEntityName = orchestratorEntityName;
this.workerEntityName = workerEntityName;
this.trackingEntityName = trackingEntityName;
this.messagingFactory = messagingFactory;
this.messagingFactory.PrefetchCount = PrefetchCount;
this.objectManager = objectManager;
orchestratorQueueClient = this.messagingFactory.CreateQueueClient(this.orchestratorEntityName);
workerSender = this.messagingFactory.CreateMessageSender(this.workerEntityName, this.orchestratorEntityName);
trackingDipatcher = trackingDispatcher;
if (trackingDipatcher != null)
{
isTrackingEnabled = true;
trackingSender = this.messagingFactory.CreateMessageSender(this.trackingEntityName,
this.orchestratorEntityName);
}
maxConcurrentWorkItems = settings.TaskOrchestrationDispatcherSettings.MaxConcurrentOrchestrations;
}
public static TaskHubWorkerSettings CreateTestWorkerSettings(CompressionStyle style = CompressionStyle.Threshold)
{
var settings = new TaskHubWorkerSettings();
settings.TaskOrchestrationDispatcherSettings.CompressOrchestrationState = true;
settings.MessageCompressionSettings = new CompressionSettings {Style = style, ThresholdInBytes = 1024};
return settings;
}
/// <summary>
/// Create a new TaskHubWorker with given name, Service Bus and Azure Storage connection string
/// </summary>
/// <param name="hubName">Name of the Task Hub</param>
/// <param name="connectionString">Service Bus connection string</param>
/// <param name="tableStoreConnectionString">Azure Storage connection string</param>
/// <param name="workerSettings">Settings for various task hub worker options</param>
public TaskHubWorker(string hubName, string connectionString, string tableStoreConnectionString,
TaskHubWorkerSettings workerSettings)
{
if (string.IsNullOrEmpty(hubName))
{
throw new ArgumentException("hubName");
}
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentException("connectionString");
}
if (workerSettings == null)
{
throw new ArgumentException("workerSettings");
}
this.hubName = hubName.ToLower();
this.connectionString = connectionString;
workerEntityName = string.Format(FrameworkConstants.WorkerEndpointFormat, this.hubName);
orchestratorEntityName = string.Format(FrameworkConstants.OrchestratorEndpointFormat, this.hubName);
trackingEntityName = string.Format(FrameworkConstants.TrackingEndpointFormat, this.hubName);
orchestrationManager = new NameVersionObjectManager <TaskOrchestration>();
activityManager = new NameVersionObjectManager <TaskActivity>();
this.tableStoreConnectionString = tableStoreConnectionString;
this.workerSettings = workerSettings;
}
/// <summary>
/// Create a new TaskHubWorker with given name, Service Bus and Azure Storage connection string
/// </summary>
/// <param name="hubName">Name of the Task Hub</param>
/// <param name="connectionString">Service Bus connection string</param>
/// <param name="tableStoreConnectionString">Azure Storage connection string</param>
/// <param name="workerSettings">Settings for various task hub worker options</param>
public TaskHubWorker(string hubName, string connectionString, string tableStoreConnectionString,
TaskHubWorkerSettings workerSettings)
: this(hubName, connectionString, tableStoreConnectionString,
new NameVersionObjectManager <TaskOrchestration>(),
new NameVersionObjectManager <TaskActivity>(),
workerSettings)
{
}
internal TrackingDispatcher(MessagingFactory messagingFactory,
TaskHubDescription taskHubDescription,
TaskHubWorkerSettings workerSettings,
string tableConnectionString,
string hubName,
string trackingEntityName)
: base("Tracking Dispatcher", item => item == null ? string.Empty : item.Session.SessionId)
{
this.taskHubDescription = taskHubDescription;
settings = workerSettings.TrackingDispatcherSettings.Clone();
this.trackingEntityName = trackingEntityName;
this.messagingFactory = messagingFactory;
this.messagingFactory.PrefetchCount = PrefetchCount;
tableClient = new TableClient(hubName, tableConnectionString);
maxConcurrentWorkItems = settings.MaxConcurrentTrackingSessions;
}
internal TaskActivityDispatcher(MessagingFactory messagingFactory,
TaskHubDescription taskHubDescription,
TaskHubWorkerSettings workerSettings,
string orchestratorQueueName,
string workerQueueName,
NameVersionObjectManager <TaskActivity> objectManager)
: base("TaskActivityDispatcher", item => item.MessageId)
{
this.taskHubDescription = taskHubDescription;
settings = workerSettings.Clone();
this.orchestratorQueueName = orchestratorQueueName;
this.workerQueueName = workerQueueName;
this.messagingFactory = messagingFactory;
this.objectManager = objectManager;
maxConcurrentWorkItems = settings.TaskActivityDispatcherSettings.MaxConcurrentActivities;
}
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();
}
}
/// <summary>
/// Create a new TaskHubWorker with given name and Service Bus connection string
/// </summary>
/// <param name="hubName">Name of the Task Hub</param>
/// <param name="connectionString">Service Bus connection string</param>
public TaskHubWorker(string hubName, string connectionString, TaskHubWorkerSettings workerSettings)
: this(hubName, connectionString, null, workerSettings)
{
}
