/// <summary>
/// Transmits a signal to a workflow, starting the workflow if it's not currently running.
/// </summary>
/// <param name="signalName">Identifies the signal.</param>
/// <param name="signalArgs">Optionally specifies the signal arguments as a byte array.</param>
/// <param name="startArgs">Optionally specifies the workflow arguments.</param>
/// <param name="options">Optionally specifies the options to be used for starting the workflow when required.</param>
/// <param name="taskList">Optionally specifies the task list. This defaults to <b>"default"</b>.</param>
/// <param name="domain">Optionally specifies the domain. This defaults to the client domain.</param>
/// <returns>The <see cref="WorkflowExecution"/>.</returns>
/// <exception cref="CadenceEntityNotExistsException">Thrown if the domain does not exist.</exception>
/// <exception cref="CadenceBadRequestException">Thrown if the request is invalid.</exception>
/// <exception cref="CadenceInternalServiceException">Thrown for internal Cadence problems.</exception>
internal async Task <WorkflowExecution> SignalWorkflowWithStartAsync(string signalName, byte[] signalArgs = null, byte[] startArgs = null, string taskList = null, WorkflowOptions options = null, string domain = null)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(signalName));
options = options ?? new WorkflowOptions();
var reply = (WorkflowSignalWithStartReply) await CallProxyAsync(
new WorkflowSignalWithStartRequest()
{
WorkflowId = options.WorkflowId,
Options = options.ToInternal(this, taskList),
SignalName = signalName,
SignalArgs = signalArgs,
WorkflowArgs = startArgs,
Domain = ResolveDomain(domain)
});
reply.ThrowOnError();
return(reply.Execution.ToPublic());
}
//---------------------------------------------------------------------
// Internal workflow related methods used by dynamically generated workflow stubs.
/// <summary>
/// Starts an external workflow using a specific workflow type name, returning a <see cref="WorkflowExecution"/>
/// that can be used to track the workflow and also wait for its result via <see cref="GetWorkflowResultAsync(WorkflowExecution, string)"/>.
/// </summary>
/// <param name="workflowTypeName">
/// The type name used when registering the workers that will handle this workflow.
/// This name will often be the fully qualified name of the workflow type but
/// this may have been customized when the workflow worker was registered.
/// </param>
/// <param name="args">Optionally specifies the workflow arguments encoded into a byte array.</param>
/// <param name="taskList">Optionally specifies the target task list. This defaults to the client task list.</param>
/// <param name="options">Specifies the workflow options.</param>
/// <param name="domain">Optionally specifies the Cadence domain where the workflow will run. This defaults to the client domain.</param>
/// <returns>A <see cref="WorkflowExecution"/> identifying the new running workflow instance.</returns>
/// <exception cref="CadenceEntityNotExistsException">Thrown if there is no workflow registered for <paramref name="workflowTypeName"/>.</exception>
/// <exception cref="CadenceBadRequestException">Thrown if the request is not valid.</exception>
/// <exception cref="CadenceWorkflowRunningException">Thrown if a workflow with this ID is already running.</exception>
/// <remarks>
/// This method kicks off a new workflow instance and returns after Cadence has
/// queued the operation but the method <b>does not</b> wait for the workflow to
/// complete.
/// </remarks>
internal async Task <WorkflowExecution> StartWorkflowAsync(string workflowTypeName, byte[] args = null, string taskList = null, WorkflowOptions options = null, string domain = null)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowTypeName));
options = options ?? new WorkflowOptions();
var reply = (WorkflowExecuteReply) await CallProxyAsync(
new WorkflowExecuteRequest()
{
Workflow = workflowTypeName,
Domain = domain ?? Settings.DefaultDomain,
Args = args,
Options = options.ToInternal(this, taskList)
});
reply.ThrowOnError();
var execution = reply.Execution;
return(new WorkflowExecution(execution.ID, execution.RunID));
}
//---------------------------------------------------------------------
// Internal workflow related methods used by dynamically generated workflow stubs.
/// <summary>
/// Starts an external workflow using a specific workflow type name, returning a <see cref="WorkflowExecution"/>
/// that can be used to track the workflow and also wait for its result via <see cref="GetWorkflowResultAsync(WorkflowExecution, string)"/>.
/// </summary>
/// <param name="workflowTypeName">
/// The type name used when registering the workers that will handle this workflow.
/// This name will often be the fully qualified name of the workflow type but
/// this may have been customized when the workflow worker was registered.
/// </param>
/// <param name="args">Specifies the workflow arguments encoded into a byte array.</param>
/// <param name="options">Specifies the workflow options.</param>
/// <returns>A <see cref="WorkflowExecution"/> identifying the new running workflow instance.</returns>
/// <exception cref="EntityNotExistsException">Thrown if there is no workflow registered for <paramref name="workflowTypeName"/>.</exception>
/// <exception cref="BadRequestException">Thrown if the request is not valid.</exception>
/// <exception cref="WorkflowRunningException">Thrown if a workflow with this ID is already running.</exception>
/// <remarks>
/// This method kicks off a new workflow instance and returns after Cadence has
/// queued the operation but the method <b>does not</b> wait for the workflow to
/// complete.
/// </remarks>
internal async Task <WorkflowExecution> StartWorkflowAsync(string workflowTypeName, byte[] args, WorkflowOptions options)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowTypeName), nameof(workflowTypeName));
EnsureNotDisposed();
options = WorkflowOptions.Normalize(this, options);
var reply = (WorkflowExecuteReply) await CallProxyAsync(
new WorkflowExecuteRequest()
{
Workflow = workflowTypeName,
Domain = options.Domain,
Args = args,
Options = options.ToInternal()
});
reply.ThrowOnError();
var execution = reply.Execution;
return(new WorkflowExecution(execution.ID, execution.RunID));
}
/// <summary>
/// Transmits a signal to an external workflow, starting the workflow if it's not currently running.
/// This low-level method accepts a byte array with the already encoded parameters.
/// </summary>
/// <param name="workflowTypeName">The target workflow type name.</param>
/// <param name="signalName">Identifies the signal.</param>
/// <param name="signalArgs">Optionally specifies the signal arguments as a byte array.</param>
/// <param name="startArgs">Optionally specifies the workflow arguments.</param>
/// <param name="options">Optionally specifies the options to be used for starting the workflow when required.</param>
/// <returns>The <see cref="WorkflowExecution"/>.</returns>
/// <exception cref="EntityNotExistsException">Thrown if the domain does not exist.</exception>
/// <exception cref="BadRequestException">Thrown if the request is invalid.</exception>
/// <exception cref="InternalServiceException">Thrown for internal Cadence problems.</exception>
internal async Task <WorkflowExecution> SignalWorkflowWithStartAsync(string workflowTypeName, string signalName, byte[] signalArgs, byte[] startArgs, WorkflowOptions options)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowTypeName), nameof(workflowTypeName));
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(signalName), nameof(signalName));
EnsureNotDisposed();
options = WorkflowOptions.Normalize(this, options);
var reply = (WorkflowSignalWithStartReply) await CallProxyAsync(
new WorkflowSignalWithStartRequest()
{
Workflow = workflowTypeName,
WorkflowId = options.WorkflowId,
Options = options.ToInternal(),
SignalName = signalName,
SignalArgs = signalArgs,
WorkflowArgs = startArgs,
Domain = options.Domain
});
reply.ThrowOnError();
return(reply.Execution.ToPublic());
}