void cancel(Order order)
{
if (order != null)
{
//TODO enqueue order
order = null;
mode = WorkerMode.Idle;
}
}
/// <summary>
/// Internal constructor.
/// </summary>
/// <param name="client">The parent client.</param>
/// <param name="mode">Identifies whether the worker will process activities, workflows, or both.</param>
/// <param name="workerId">The ID of the worker as tracked by the <b>cadence-proxy</b>.</param>
/// <param name="domain">The Cadence domain where the worker is registered.</param>
/// <param name="taskList">The Cadence task list.</param>
internal Worker(CadenceClient client, WorkerMode mode, long workerId, string domain, string taskList)
{
this.Client = client;
this.Mode = mode;
this.WorkerId = workerId;
this.Domain = domain;
this.Tasklist = taskList;
this.RefCount = 1;
}
public void SetWorkerMode(WorkerMode mode)
{
var comboBoxPtr = this.GetChildWindow(1, "ComboBox");
if (comboBoxPtr == IntPtr.Zero)
{
this.OnWorkerErrorOccurred("An incompatible worker is running");
return;
}
WinAPIUtils.SetComboBoxSelectedIndex(comboBoxPtr, GetExternalWorkerModeIndex(mode));
}
private int GetExternalWorkerModeIndex(WorkerMode mode)
{
switch (mode)
{
case WorkerMode.Disabled: return(0);
case WorkerMode.WorkWhenIdle: return(1);
case WorkerMode.WorkProportional: return(3);
case WorkerMode.WorkAlways: return(2);
default:
Debug.Assert(false, "Unsupported worker mode");
return(0);
}
}
/// <summary>
/// Signals Cadence that the application is capable of executing workflows and/or activities for a specific
/// domain and task list.
/// </summary>
/// <param name="taskList">Specifies the task list implemented by the worker. This must not be empty.</param>
/// <param name="options">Optionally specifies additional worker options.</param>
/// <param name="domain">Optionally overrides the default <see cref="CadenceClient"/> domain.</param>
/// <returns>A <see cref="Worker"/> identifying the worker instance.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="taskList"/> is <c>null</c> or empty.</exception>
/// <exception cref="InvalidOperationException">
/// Thrown when an attempt is made to recreate a worker with the
/// same properties on a given client. See the note in the remarks.
/// </exception>
/// <remarks>
/// <note>
/// <see cref="CadenceClient"/> for more information on task lists.
/// </note>
/// <para>
/// Your workflow application will need to call this method so that Cadence will know
/// that it can schedule activities to run within the current process. You'll need
/// to specify the target Cadence domain and task list.
/// </para>
/// <para>
/// You may also specify an optional <see cref="WorkerOptions"/> parameter as well
/// as customize the name used to register the activity, which defaults to the
/// fully qualified name of the activity type.
/// </para>
/// <para>
/// This method returns a <see cref="Worker"/> which implements <see cref="IDisposable"/>.
/// It's a best practice to call <see cref="Dispose()"/> just before the a worker process
/// terminates, but this is optional. Advanced worker implementation that need to change
/// their configuration over time can also call <see cref="Dispose()"/> to stop workers
/// for specific domains and task lists.
/// </para>
/// <note>
/// The Cadence GOLANG client does not appear to support starting a worker with a given
/// set of parameters, stopping that workflow, and then restarting another worker
/// with the same parameters on the same client. This method detects this situation
/// and throws an <see cref="InvalidOperationException"/> when a restart is attempted.
/// </note>
/// </remarks>
public async Task <Worker> StartWorkerAsync(string taskList, WorkerOptions options = null, string domain = null)
{
await SyncContext.ClearAsync;
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(taskList), nameof(taskList), "Workers must be started with a non-empty workflow.");
EnsureNotDisposed();
options = options ?? new WorkerOptions();
domain = ResolveDomain(domain);
WorkerMode mode = options.Mode;
Worker worker;
try
{
using (await workerRegistrationMutex.AcquireAsync())
{
// Ensure that we haven't already registered a worker for the
// specified activity, domain, and task list. We'll just increment
// the reference count for the existing worker and return it
// in this case.
//
// I know that this is a linear search but the number of activity
// registrations per service will generally be very small and
// registrations will happen infrequently (typically just once
// per service, when it starts).
// $note(jefflill):
//
// If the worker exists but its RefCount==0, then we're going to
// throw an exception because Cadence doesn't support recreating
// a worker with the same parameters on the same client.
worker = workers.Values.SingleOrDefault(wf => wf.Mode == mode && wf.Domain == domain && wf.Tasklist == taskList);
if (worker != null)
{
if (worker.RefCount < 0)
{
throw new InvalidOperationException("A worker with these same parameters has already been started and stopped on this Cadence client. Cadence does not support recreating workers for a given client instance.");
}
Interlocked.Increment(ref worker.RefCount);
return(worker);
}
options = options ?? new WorkerOptions();
var reply = (NewWorkerReply)(await CallProxyAsync(
new NewWorkerRequest()
{
Domain = ResolveDomain(domain),
TaskList = taskList,
Options = options.ToInternal()
}));
reply.ThrowOnError();
worker = new Worker(this, mode, reply.WorkerId, domain, taskList);
workers.Add(reply.WorkerId, worker);
}
}
finally
{
switch (mode)
{
case WorkerMode.Activity:
activityWorkerStarted = true;
break;
case WorkerMode.Workflow:
workflowWorkerStarted = true;
break;
case WorkerMode.Both:
activityWorkerStarted = true;
workflowWorkerStarted = true;
break;
default:
throw new NotImplementedException();
}
}
// Fetch the stub for each registered workflow and activity type so that
// they'll be precompiled so compilation won't impact workflow and activity
// performance including potentially intruducing enough delay to cause
// decision tasks or activity heartbeats to fail (in very rare situations).
//
// Note that the compiled stubs are cached, so we don't need to worry
// about compiling stubs for types more than once causing a problem.
lock (registeredWorkflowTypes)
{
foreach (var workflowInterface in registeredWorkflowTypes)
{
// Workflows, we're going to compile both the external and child
// versions of the stubs.
StubManager.GetWorkflowStub(workflowInterface, isChild: false);
StubManager.GetWorkflowStub(workflowInterface, isChild: true);
}
}
lock (registeredActivityTypes)
{
foreach (var activityInterface in registeredActivityTypes)
{
StubManager.GetActivityStub(activityInterface);
}
}
return(worker);
}
private void SettingsPage_WorkerModeChanged(object sender, WorkerMode mode)
{
UpdateTrayIcon();
}
public void handle()
{
if (mode == WorkerMode.GoToProducer)
{
//TODO moveTo();
mode = WorkerMode.GoingToProducer;
}
if (mode == WorkerMode.GoingToProducer)
{
move();
if (next == null)
{
mode = WorkerMode = OrderRessources;
}
}
else if (mode == WorkerMode.OrderRessources)
{
//TODO
mode = WorkerMode.WaitForRessources;
}
else if (mode == WorkerMode.WaitForRessources)
{
//TODO
}
else if (mode == WorkerMode.ProduceProduct)
{
long productionReady = DateTime.Now.Ticks/TimeSpan.TicksPerMillisecond + order.recipe.time*order.number;
mode = WorkerMode.ProducingProduct;
}
else if (mode == WorkerMode.ProducingProduct)
{
if (DateTime.Now.Ticks/TimeSpan.TicksPerMillisecond >= productionReady)
{
mode = WorkerMode.LoadProducts;
}
}
else if (mode == WorkerMode.ImproveProducts)
{
//TODO
}
else if (mode == WorkerMode.ImproveingProducts)
{
//TODO
}
else if (mode == WorkerMode.LoadProducts)
{
//TODO
mode = WorkerMode.DeliverProducts;
}
else if (mode == WorkerMode.DeliverProducts)
{
//TODO moveTo();
mode = WorkerMode.DeliveringProducts;
}
else if (mode == WorkerMode.DeliveringProducts)
{
move();
if (next == null)
{
mode = WorkerMode.UnloadProducts;
}
}
else if (mode == WorkerMode.UnloadProducts)
{
//TODO
mode = WorkerMode.Idle;
order = null;
priority = Priority.Idle;
//TODO dequeue
//TODO enqueue
}
else if (mode == WorkerMode.Build)
{
}
else if (mode == WorkerMode.Idle)
{
}
}
void cancel(Order order)
{
if (order != null)
{
//TODO enqueue order
order = null;
mode = WorkerMode.Idle;
}
}
private void WorkerPage_WorkerModeChanged(object sender, WorkerMode mode)
{
ChangeWorkerMode((int)mode);
}
public void handle()
{
if (mode == WorkerMode.GoToProducer)
{
//TODO moveTo();
mode = WorkerMode.GoingToProducer;
}
if (mode == WorkerMode.GoingToProducer)
{
move();
if (next == null)
{
mode = WorkerMode = OrderRessources;
}
}
else if (mode == WorkerMode.OrderRessources)
{
//TODO
mode = WorkerMode.WaitForRessources;
}
else if (mode == WorkerMode.WaitForRessources)
{
//TODO
}
else if (mode == WorkerMode.ProduceProduct)
{
long productionReady = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond + order.recipe.time * order.number;
mode = WorkerMode.ProducingProduct;
}
else if (mode == WorkerMode.ProducingProduct)
{
if (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond >= productionReady)
{
mode = WorkerMode.LoadProducts;
}
}
else if (mode == WorkerMode.ImproveProducts)
{
//TODO
}
else if (mode == WorkerMode.ImproveingProducts)
{
//TODO
}
else if (mode == WorkerMode.LoadProducts)
{
//TODO
mode = WorkerMode.DeliverProducts;
}
else if (mode == WorkerMode.DeliverProducts)
{
//TODO moveTo();
mode = WorkerMode.DeliveringProducts;
}
else if (mode == WorkerMode.DeliveringProducts)
{
move();
if (next == null)
{
mode = WorkerMode.UnloadProducts;
}
}
else if (mode == WorkerMode.UnloadProducts)
{
//TODO
mode = WorkerMode.Idle;
order = null;
priority = Priority.Idle;
//TODO dequeue
//TODO enqueue
}
else if (mode == WorkerMode.Build)
{
}
else if (mode == WorkerMode.Idle)
{
}
}
/// <summary>
/// Signals Cadence that the application is capable of executing activities for a specific
/// domain and task list.
/// </summary>
/// <param name="taskList">Optionally specifies the target task list (defaults to <b>"default"</b>).</param>
/// <param name="options">Optionally specifies additional worker options.</param>
/// <param name="domain">Optionally overrides the default <see cref="CadenceClient"/> domain.</param>
/// <returns>A <see cref="Worker"/> identifying the worker instance.</returns>
/// <exception cref="InvalidOperationException">
/// Thrown when an attempt is made to recreate a worker with the
/// same properties on a given client. See the note in the remarks.
/// </exception>
/// <remarks>
/// <para>
/// Your workflow application will need to call this method so that Cadence will know
/// that it can schedule activities to run within the current process. You'll need
/// to specify the target Cadence domain and task list.
/// </para>
/// <para>
/// You may also specify an optional <see cref="WorkerOptions"/> parameter as well
/// as customize the name used to register the activity, which defaults to the
/// fully qualified name of the activity type.
/// </para>
/// <para>
/// This method returns a <see cref="Worker"/> which implements <see cref="IDisposable"/>.
/// It's a best practice to call <see cref="Dispose()"/> just before the a worker process
/// terminates, but this is optional. Advanced worker implementation that need to change
/// their configuration over time can also call <see cref="Dispose()"/> to stop workers
/// for specific domains and task lists.
/// </para>
/// <note>
/// The Cadence GOLANG client does not appear to support starting a worker with a given
/// set of parameters, stopping that workflow, and then restarting another worker
/// with the same parameters on the same client. This method detects this situation
/// and throws an <see cref="InvalidOperationException"/> when these restart attempts
/// are made.
/// </note>
/// </remarks>
private async Task <Worker> StartWorkerAsync(string taskList = "default", WorkerOptions options = null, string domain = null)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(taskList));
options = options ?? new WorkerOptions();
WorkerMode mode = options.Mode;
Worker worker;
try
{
using (await workerRegistrationMutex.AcquireAsync())
{
// Ensure that we haven't already registered a worker for the
// specified activity, domain, and task list. We'll just increment
// the reference count for the existing worker and return it
// in this case.
//
// I know that this is a linear search but the number of activity
// registrations per service will generally be very small and
// registrations will happen infrequently (typically just once
// per service, when it starts).
// $note(jeff.lill):
//
// If the worker exists but its refcount==0, then we're going to
// throw an exception because Cadence doesn't support recreating
// a worker with the same parameters on the same client.
worker = workers.Values.SingleOrDefault(wf => wf.Mode == mode && wf.Domain == domain && wf.Tasklist == taskList);
if (worker != null)
{
if (worker.RefCount == 0)
{
throw new InvalidOperationException("A worker with these same parameters has already been started and stopped on this Cadence client. Cadence does not support recreating workers for a given client instance.");
}
Interlocked.Increment(ref worker.RefCount);
return(worker);
}
options = options ?? new WorkerOptions();
var reply = (NewWorkerReply)(await CallProxyAsync(
new NewWorkerRequest()
{
Domain = ResolveDomain(domain),
TaskList = taskList,
Options = options.ToInternal()
}));
reply.ThrowOnError();
worker = new Worker(this, mode, reply.WorkerId, domain, taskList);
workers.Add(reply.WorkerId, worker);
}
}
finally
{
switch (mode)
{
case WorkerMode.Activity:
activityWorkerStarted = true;
break;
case WorkerMode.Workflow:
workflowWorkerStarted = true;
break;
case WorkerMode.Both:
activityWorkerStarted = true;
workflowWorkerStarted = true;
break;
default:
throw new NotImplementedException();
}
}
return(worker);
}