public async Task SignalAsync(WorkflowExecution execution, string signalName, params object[] args) { await SyncContext.Clear; var dataConverter = Activity.Client.DataConverter; await Activity.Client.SignalWorkflowAsync(execution, signalName, TemporalHelper.ArgsToBytes(dataConverter, args)); }
/// <summary> /// Used to construct an untyped workflow stub that can manage an existing external workflow. /// </summary> /// <param name="client">The associated client.</param> /// <param name="execution">The workflow execution.</param> /// <param name="withinWorkflow"> /// Optionally indicates that the stub was created from within a workflow and that /// operations such as get result, query, signal, and cancel must be performed /// within local activities such that that can be replayed from history correctly. /// </param> internal WorkflowStub(TemporalClient client, WorkflowExecution execution, bool withinWorkflow = false) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); this.client = client; this.Execution = execution; this.withinWorkflow = withinWorkflow; }
/// <summary> /// Internal constructor for use outside of a workflow. /// </summary> /// <param name="client">Specifies the associated client.</param> /// <param name="execution">Specifies the target workflow execution.</param> /// <param name="namespace">Optionally specifies the target namespace (defaults to the client's default namespace).</param> internal ExternalWorkflowStub(TemporalClient client, WorkflowExecution execution, string @namespace = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); this.client = client; this.@namespace = client.ResolveNamespace(@namespace); this.Execution = execution; }
/// <summary> /// Internal constructor for use within a workflow. /// </summary> /// <param name="parentWorkflow">Specifies the parent workflow.</param> /// <param name="execution">Specifies the target workflow execution.</param> /// <param name="namespace">Optionally specifies the target namespace (defaults to the client's default namespace).</param> internal ExternalWorkflowStub(Workflow parentWorkflow, WorkflowExecution execution, string @namespace = null) { Covenant.Requires <ArgumentNullException>(parentWorkflow != null, nameof(parentWorkflow)); Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); this.parentWorkflow = parentWorkflow; this.client = parentWorkflow.Client; this.@namespace = client.ResolveNamespace(@namespace); this.Execution = execution; }
/// <summary> /// Used to construct an untyped workflow stub that can be used to start an external workflow. /// </summary> /// <param name="client">The associated client.</param> /// <param name="workflowTypeName">The workflow type name.</param> /// <param name="execution">The workflow execution.</param> /// <param name="options">The workflow options.</param> internal WorkflowStub(TemporalClient client, string workflowTypeName, WorkflowExecution execution, StartWorkflowOptions options) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowTypeName), nameof(workflowTypeName)); Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); Covenant.Requires <ArgumentNullException>(options != null, nameof(options)); this.client = client; this.WorkflowTypeName = workflowTypeName; this.Execution = execution; this.Options = options; this.withinWorkflow = false; }
/// <summary> /// Starts the workflow, returning an <see cref="IAsyncFuture"/> that can be used /// to wait for the the workflow to complete and obtain its result. /// </summary> /// <typeparam name="TResult">The workflow result type.</typeparam> /// <param name="args">The workflow arguments.</param> /// <returns>An <see cref="ExternalWorkflowFuture{TResult}"/> that can be used to retrieve the workflow result as an <c>object</c>.</returns> /// <exception cref="InvalidOperationException">Thrown if the workflow has already been started.</exception> /// <remarks> /// <note> /// <b>IMPORTANT:</b> You need to take care to ensure that the parameters passed /// and the result type are compatible with the target workflow method. /// </note> /// </remarks> public async Task <ExternalWorkflowFuture <TResult> > StartAsync <TResult>(params object[] args) { await SyncContext.Clear; Covenant.Requires <ArgumentNullException>(args != null, nameof(args)); if (execution != null) { throw new InvalidOperationException("Cannot start a future stub more than once."); } execution = await client.StartWorkflowAsync(workflowTypeName, TemporalHelper.ArgsToBytes(client.DataConverter, args), options); // Create and return the future. return(new ExternalWorkflowFuture <TResult>(client, execution, options.Namespace)); }
/// <summary> /// Used to externally complete an activity identified by <see cref="WorkflowExecution"/> and activity ID. /// </summary> /// <param name="execution">The workflow execution.</param> /// <param name="activityId">The activity ID.</param> /// <param name="result">Passed as the activity result for activity success.</param> /// <param name="namespace">Optionally overrides the default <see cref="TemporalClient"/> namespace.</param> /// <returns>The tracking <see cref="Task"/>.</returns> /// <exception cref="EntityNotExistsException">Thrown if the activity no longer exists.</exception> public async Task ActivityCompleteByIdAsync(WorkflowExecution execution, string activityId, object result = null, string @namespace = null) { await SyncContext.Clear; Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(activityId), nameof(activityId)); EnsureNotDisposed(); var reply = (ActivityCompleteReply) await CallProxyAsync( new ActivityCompleteRequest() { Namespace = ResolveNamespace(@namespace), WorkflowId = execution.WorkflowId, RunId = execution.RunId, ActivityId = activityId, Result = GetClient(ClientId).DataConverter.ToData(result) }); reply.ThrowOnError(); }
/// <summary> /// Used to externally fail an activity by <see cref="WorkflowExecution"/> and activity ID. /// </summary> /// <param name="execution">The workflowm execution.</param> /// <param name="activityId">The activity ID.</param> /// <param name="error">Specifies the activity error.</param> /// <param name="namespace">Optionally overrides the default <see cref="TemporalClient"/> namespace.</param> /// <returns>The tracking <see cref="Task"/>.</returns> /// <exception cref="EntityNotExistsException">Thrown if the activity no longer exists.</exception> public async Task ActivityErrorByIdAsync(WorkflowExecution execution, string activityId, Exception error, string @namespace = null) { await SyncContext.Clear; Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(activityId), nameof(activityId)); Covenant.Requires <ArgumentNullException>(error != null, nameof(error)); EnsureNotDisposed(); var reply = (ActivityCompleteReply) await CallProxyAsync( new ActivityCompleteRequest() { Namespace = ResolveNamespace(@namespace), WorkflowId = execution.WorkflowId, RunId = execution.RunId, ActivityId = activityId, Error = new TemporalError(error) }); reply.ThrowOnError(); }
/// <summary> /// Constructor. /// </summary> /// <param name="client">The associated client.</param> /// <param name="execution">The workflow execution.</param> /// /// <param name="namespace">Optionally specifies the target namespace. This defaults to the default client namespace.</param> internal ExternalWorkflowFuture(TemporalClient client, WorkflowExecution execution, string @namespace) { this.client = client; this.Execution = execution; this.@namespace = @namespace; }
public async Task <byte[]> GetResultBytesAsync(WorkflowExecution execution) { await SyncContext.Clear; return(await Activity.Client.GetWorkflowResultAsync(execution)); }
public async Task GetResultAsync(WorkflowExecution execution) { await SyncContext.Clear; await Activity.Client.GetWorkflowResultAsync(execution); }
public async Task CancelAsync(WorkflowExecution execution) { await SyncContext.Clear; await Activity.Client.CancelWorkflowAsync(execution); }