/// <summary> /// Creates a typed workflow stub that can be used to start as well as /// query and signal the workflow via the type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="options">Optionally specifies the workflow options.</param> /// <param name="workflowTypeName"> /// Optionally specifies the workflow type name by overriding the fully /// qualified <typeparamref name="TWorkflowInterface"/> type name or the name /// specified by a <see cref="WorkflowAttribute"/>. /// </param> /// <param name="domain">Optionally overrides the client's default domain.</param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(WorkflowOptions options = null, string workflowTypeName = null, string domain = null) where TWorkflowInterface : WorkflowBase { CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); throw new NotImplementedException(); }
/// <summary> /// Creates a typed workflow stub that can be used to start as well as /// query and signal the workflow via the type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="options">Optionally specifies the workflow options.</param> /// <param name="workflowTypeName"> /// Optionally specifies the workflow type name by overriding the fully /// qualified <typeparamref name="TWorkflowInterface"/> type name or the name /// specified by a <see cref="WorkflowAttribute"/>. /// </param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// <para> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </para> /// <note> /// <para> /// .NET and Java workflows can implement multiple workflow method using attributes /// and annotations to assign unique names to each. Each workflow method is actually /// registered with Cadence as a distinct workflow type. Workflow methods with a blank /// or <c>null</c> name will simply be registered using the workflow type name. /// </para> /// <para> /// Workflow methods with a name will be registered using a combination of the workflow /// type name and the method name, using <b>"::"</b> as the separator, like: /// </para> /// <code> /// WORKFLOW-TYPENAME::METHOD-NAME /// </code> /// </note> /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(WorkflowOptions options = null, string workflowTypeName = null) where TWorkflowInterface : class { CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, options: options, workflowTypeName: workflowTypeName)); }
/// <summary> /// Creates a typed workflow stub connected to a known workflow execution. /// This can be used to signal and query the workflow via the type-safe /// interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="workflowId">Specifies the workflow ID.</param> /// <param name="runId">Optionally specifies the workflow's run ID.</param> /// <param name="workflowTypeName"> /// Optionally specifies the workflow type name by overriding the fully /// qualified <typeparamref name="TWorkflowInterface"/> type name or the name /// specified by a <see cref="WorkflowAttribute"/>. /// </param> /// <param name="domain">Optionally overrides the client's default domain.</param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(string workflowId, string runId = null, string workflowTypeName = null, string domain = null) where TWorkflowInterface : WorkflowBase { Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowId)); CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); throw new NotImplementedException(); }
/// <summary> /// Creates a typed workflow stub connected to a known workflow execution /// using IDs. This can be used to signal and query the workflow via the /// type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="workflowId">Specifies the workflow ID.</param> /// <param name="runId">Optionally specifies the workflow's run ID.</param> /// <param name="domain">Optionally specifies a domain that </param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(string workflowId, string runId = null, string domain = null) where TWorkflowInterface : class { Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowId), nameof(workflowId)); CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, workflowId, runId, domain)); }
/// <summary> /// Creates a stub suitable for starting an external workflow and then waiting /// for the result as separate operations. /// </summary> /// <typeparam name="TWorkflowInterface">The target workflow interface.</typeparam> /// <param name="methodName"> /// Optionally identifies the target workflow method. This is the name specified in /// <c>[WorkflowMethod]</c> attribute for the workflow method or <c>null</c>/empty for /// the default workflow method. /// </param> /// <param name="options">Optionally specifies custom <see cref="WorkflowOptions"/>.</param> /// <returns>A <see cref="ChildWorkflowStub{TWorkflowInterface}"/> instance.</returns> public WorkflowFutureStub <TWorkflowInterface> NewWorkflowFutureStub <TWorkflowInterface>(string methodName = null, WorkflowOptions options = null) where TWorkflowInterface : class { CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); options = WorkflowOptions.Normalize(this, options, typeof(TWorkflowInterface)); return(new WorkflowFutureStub <TWorkflowInterface>(this, methodName, options)); }
/// <summary> /// Creates a typed workflow stub connected to a known workflow execution /// using a <see cref="WorkflowExecution"/>. This can be used to signal and /// query the workflow via the type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="execution">Specifies the <see cref="WorkflowExecution"/>.</param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(WorkflowExecution execution) where TWorkflowInterface : class { Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(execution.WorkflowId), nameof(execution.WorkflowId)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(execution.RunId), nameof(execution.RunId)); CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, execution.WorkflowId, execution.RunId)); }
/// <summary> /// Internal constructor. /// </summary> /// <param name="client">The associated client.</param> /// <param name="methodName"> /// Optionally identifies the target workflow method by the name specified in /// the <c>[WorkflowMethod]</c> attribute tagging the method. Pass a <c>null</c> /// or empty string to target the default method. /// </param> /// <param name="options">Optional workflow options.</param> internal WorkflowFutureStub(CadenceClient client, string methodName = null, WorkflowOptions options = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); var workflowInterface = typeof(WorkflowInterface); CadenceHelper.ValidateWorkflowInterface(workflowInterface); this.client = client; this.workflowTypeName = CadenceHelper.GetWorkflowTarget(workflowInterface, methodName).WorkflowTypeName; this.options = WorkflowOptions.Normalize(client, options); }
//--------------------------------------------------------------------- // Static members /// <summary> /// <b>INTERNAL USE ONLY:</b> Normalizes the options passed by creating or cloning a new /// instance as required and filling unset properties using default client settings. /// </summary> /// <param name="client">The associated Cadence client.</param> /// <param name="options">The input options or <c>null</c>.</param> /// <param name="workflowInterface">Optionally specifies the workflow interface definition.</param> /// <returns>The normalized options.</returns> /// <exception cref="ArgumentNullException">Thrown if a valid task list is not specified.</exception> public static ChildWorkflowOptions Normalize(CadenceClient client, ChildWorkflowOptions options, Type workflowInterface = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); WorkflowInterfaceAttribute interfaceAttribute = null; if (workflowInterface != null) { CadenceHelper.ValidateWorkflowInterface(workflowInterface); interfaceAttribute = workflowInterface.GetCustomAttribute <WorkflowInterfaceAttribute>(); } if (options == null) { options = new ChildWorkflowOptions(); } else { options = options.Clone(); } if (!options.ScheduleToCloseTimeout.HasValue || options.ScheduleToCloseTimeout.Value <= TimeSpan.Zero) { options.ScheduleToCloseTimeout = client.Settings.WorkflowScheduleToCloseTimeout; } if (!options.ScheduleToStartTimeout.HasValue || options.ScheduleToStartTimeout.Value <= TimeSpan.Zero) { options.ScheduleToStartTimeout = client.Settings.WorkflowScheduleToStartTimeout; } if (!options.TaskStartToCloseTimeout.HasValue || options.TaskStartToCloseTimeout.Value <= TimeSpan.Zero) { options.TaskStartToCloseTimeout = client.Settings.WorkflowTaskStartToCloseTimeout; } if (string.IsNullOrEmpty(options.TaskList)) { if (interfaceAttribute != null && !string.IsNullOrEmpty(interfaceAttribute.TaskList)) { options.TaskList = interfaceAttribute.TaskList; } } return(options); }
/// <summary> /// Internal constructor. /// </summary> /// <param name="parentWorkflow">The associated parent workflow.</param> /// <param name="methodName">Identifies the target workflow method or <c>null</c> or empty.</param> /// <param name="options">The child workflow options or <c>null</c>.</param> internal ChildWorkflowStub(Workflow parentWorkflow, string methodName, ChildWorkflowOptions options) { Covenant.Requires <ArgumentNullException>(parentWorkflow != null, nameof(parentWorkflow)); var workflowInterface = typeof(TWorkflowInterface); CadenceHelper.ValidateWorkflowInterface(workflowInterface); this.parentWorkflow = parentWorkflow; this.options = ChildWorkflowOptions.Normalize(parentWorkflow.Client, options); this.hasStarted = false; var workflowTarget = CadenceHelper.GetWorkflowTarget(workflowInterface, methodName); this.workflowTypeName = workflowTarget.WorkflowTypeName; this.targetMethod = workflowTarget.TargetMethod; }
//--------------------------------------------------------------------- // Static members /// <summary> /// Normalizes the options passed by creating or cloning a new instance as /// required and filling unset properties using default client settings. /// </summary> /// <param name="client">The associated Cadence client.</param> /// <param name="options">The input options or <c>null</c>.</param> /// <param name="workflowInterface">Optionally specifies the workflow interface definition.</param> /// <returns>The normalized options.</returns> /// <exception cref="ArgumentNullException">Thrown if a valid task list is not specified.</exception> internal static WorkflowOptions Normalize(CadenceClient client, WorkflowOptions options, Type workflowInterface = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); WorkflowInterfaceAttribute interfaceAttribute = null; if (workflowInterface != null) { CadenceHelper.ValidateWorkflowInterface(workflowInterface); interfaceAttribute = workflowInterface.GetCustomAttribute <WorkflowInterfaceAttribute>(); } if (options == null) { options = new WorkflowOptions(); } else { options = options.Clone(); } if (string.IsNullOrEmpty(options.Domain)) { options.Domain = client.Settings.DefaultDomain; } if (!options.ScheduleToCloseTimeout.HasValue || options.ScheduleToCloseTimeout.Value <= TimeSpan.Zero) { options.ScheduleToCloseTimeout = client.Settings.WorkflowScheduleToCloseTimeout; } if (!options.ScheduleToStartTimeout.HasValue || options.ScheduleToStartTimeout.Value <= TimeSpan.Zero) { options.ScheduleToStartTimeout = client.Settings.WorkflowScheduleToStartTimeout; } if (!options.TaskStartToCloseTimeout.HasValue || options.TaskStartToCloseTimeout.Value <= TimeSpan.Zero) { options.TaskStartToCloseTimeout = client.Settings.WorkflowTaskStartToCloseTimeout; } if (options.WorkflowIdReusePolicy == Cadence.WorkflowIdReusePolicy.UseDefault) { options.WorkflowIdReusePolicy = client.Settings.WorkflowIdReusePolicy; } if (string.IsNullOrEmpty(options.TaskList)) { if (interfaceAttribute != null && !string.IsNullOrEmpty(interfaceAttribute.TaskList)) { options.TaskList = interfaceAttribute.TaskList; } } if (string.IsNullOrEmpty(options.TaskList)) { throw new ArgumentNullException(nameof(options), "You must specify a valid task list explicitly or via an [WorkflowInterface(TaskList = \"my-tasklist\")] attribute on the target workflow interface."); } return(options); }
//--------------------------------------------------------------------- // Static members /// <summary> /// <b>INTERNAL USE ONLY:</b> Normalizes the options passed by creating or cloning a new /// instance as required and filling unset properties using default client settings. /// </summary> /// <param name="client">The associated Cadence client.</param> /// <param name="options">The input options or <c>null</c>.</param> /// <param name="workflowInterface">Optionally specifies the workflow interface definition.</param> /// <param name="method">Optionally specifies the target workflow method.</param> /// <returns>The normalized options.</returns> /// <exception cref="ArgumentNullException">Thrown if a valid task list is not specified.</exception> public static ChildWorkflowOptions Normalize(CadenceClient client, ChildWorkflowOptions options, Type workflowInterface = null, MethodInfo method = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); WorkflowInterfaceAttribute interfaceAttribute = null; WorkflowMethodAttribute methodAttribute = null; if (options == null) { options = new ChildWorkflowOptions(); } else { options = options.Clone(); } if (workflowInterface != null) { CadenceHelper.ValidateWorkflowInterface(workflowInterface); interfaceAttribute = workflowInterface.GetCustomAttribute <WorkflowInterfaceAttribute>(); } if (method != null) { methodAttribute = method.GetCustomAttribute <WorkflowMethodAttribute>(); } if (string.IsNullOrEmpty(options.Domain)) { if (!string.IsNullOrEmpty(methodAttribute?.Domain)) { options.Domain = methodAttribute.Domain; } if (string.IsNullOrEmpty(options.Domain) && !string.IsNullOrEmpty(interfaceAttribute?.Domain)) { options.Domain = interfaceAttribute.Domain; } } if (string.IsNullOrEmpty(options.TaskList)) { if (!string.IsNullOrEmpty(methodAttribute?.TaskList)) { options.TaskList = methodAttribute.TaskList; } if (string.IsNullOrEmpty(options.TaskList) && !string.IsNullOrEmpty(interfaceAttribute?.TaskList)) { options.TaskList = interfaceAttribute.TaskList; } } if (options.StartToCloseTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.StartToCloseTimeoutSeconds > 0) { options.StartToCloseTimeout = TimeSpan.FromSeconds(methodAttribute.StartToCloseTimeoutSeconds); } if (options.StartToCloseTimeout <= TimeSpan.Zero) { options.StartToCloseTimeout = client.Settings.WorkflowStartToCloseTimeout; } } if (options.ScheduleToStartTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.ScheduleToStartTimeoutSeconds > 0) { options.ScheduleToStartTimeout = TimeSpan.FromSeconds(methodAttribute.ScheduleToStartTimeoutSeconds); } if (options.ScheduleToStartTimeout <= TimeSpan.Zero) { options.ScheduleToStartTimeout = client.Settings.WorkflowScheduleToStartTimeout; } } if (options.DecisionTaskTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.DecisionTaskTimeoutSeconds > 0) { options.DecisionTaskTimeout = TimeSpan.FromSeconds(methodAttribute.DecisionTaskTimeoutSeconds); } if (options.DecisionTaskTimeout <= TimeSpan.Zero) { options.DecisionTaskTimeout = client.Settings.WorkflowDecisionTaskTimeout; } } if (options.WorkflowIdReusePolicy == Cadence.WorkflowIdReusePolicy.UseDefault) { if (methodAttribute != null && methodAttribute.WorkflowIdReusePolicy != WorkflowIdReusePolicy.UseDefault) { options.WorkflowIdReusePolicy = methodAttribute.WorkflowIdReusePolicy; } if (options.WorkflowIdReusePolicy == Cadence.WorkflowIdReusePolicy.UseDefault) { options.WorkflowIdReusePolicy = client.Settings.WorkflowIdReusePolicy; } } return(options); }
//--------------------------------------------------------------------- // Static members /// <summary> /// Normalizes the options passed by creating or cloning a new instance as /// required and filling unset properties using default client settings. /// </summary> /// <param name="client">The associated Cadence client.</param> /// <param name="options">The input options or <c>null</c>.</param> /// <param name="workflowInterface">Optionally specifies the workflow interface definition.</param> /// <param name="method">Optionally specifies the target workflow method.</param> /// <returns>The normalized options.</returns> /// <exception cref="ArgumentNullException">Thrown if a valid task list is not specified.</exception> internal static WorkflowOptions Normalize(CadenceClient client, WorkflowOptions options, Type workflowInterface = null, MethodInfo method = null) { Covenant.Requires <ArgumentNullException>(client != null, nameof(client)); WorkflowInterfaceAttribute interfaceAttribute = null; WorkflowMethodAttribute methodAttribute = null; if (options == null) { options = new WorkflowOptions(); } else { options = options.Clone(); } if (workflowInterface != null) { CadenceHelper.ValidateWorkflowInterface(workflowInterface); interfaceAttribute = workflowInterface.GetCustomAttribute <WorkflowInterfaceAttribute>(); } if (method != null) { methodAttribute = method.GetCustomAttribute <WorkflowMethodAttribute>(); } if (string.IsNullOrEmpty(options.Domain)) { if (!string.IsNullOrEmpty(methodAttribute?.Domain)) { options.Domain = methodAttribute.Domain; } if (string.IsNullOrEmpty(options.Domain) && !string.IsNullOrEmpty(interfaceAttribute?.Domain)) { options.Domain = interfaceAttribute.Domain; } if (string.IsNullOrEmpty(options.Domain)) { options.Domain = client.Settings.DefaultDomain; } if (string.IsNullOrEmpty(options.Domain)) { throw new ArgumentNullException(nameof(options), "You must specify a valid domain explicitly in [CadenceSettings], [ActivityOptions] or via an [ActivityInterface] or [ActivityMethod] attribute on the target activity interface or method."); } } if (string.IsNullOrEmpty(options.TaskList)) { if (!string.IsNullOrEmpty(methodAttribute?.TaskList)) { options.TaskList = methodAttribute.TaskList; } if (string.IsNullOrEmpty(options.TaskList) && !string.IsNullOrEmpty(interfaceAttribute?.TaskList)) { options.TaskList = interfaceAttribute.TaskList; } if (string.IsNullOrEmpty(options.TaskList)) { options.TaskList = client.Settings.DefaultTaskList; } if (string.IsNullOrEmpty(options.TaskList)) { throw new ArgumentNullException(nameof(options), "You must specify a valid task list explicitly via [WorkflowOptions] or using an [WorkflowInterface] or [WorkflowMethod] attribute on the target workflow interface or method."); } } if (options.StartToCloseTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.StartToCloseTimeoutSeconds > 0) { options.StartToCloseTimeout = TimeSpan.FromSeconds(methodAttribute.StartToCloseTimeoutSeconds); } if (options.StartToCloseTimeout <= TimeSpan.Zero) { options.StartToCloseTimeout = client.Settings.WorkflowStartToCloseTimeout; } } if (options.ScheduleToStartTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.ScheduleToStartTimeoutSeconds > 0) { options.ScheduleToStartTimeout = TimeSpan.FromSeconds(methodAttribute.ScheduleToStartTimeoutSeconds); } if (options.ScheduleToStartTimeout <= TimeSpan.Zero) { options.ScheduleToStartTimeout = client.Settings.WorkflowScheduleToStartTimeout; } } if (options.DecisionTaskTimeout <= TimeSpan.Zero) { if (methodAttribute != null && methodAttribute.DecisionTaskTimeoutSeconds > 0) { options.DecisionTaskTimeout = TimeSpan.FromSeconds(methodAttribute.DecisionTaskTimeoutSeconds); } if (options.DecisionTaskTimeout <= TimeSpan.Zero) { options.DecisionTaskTimeout = client.Settings.WorkflowDecisionTaskTimeout; } } if (options.WorkflowIdReusePolicy == Cadence.WorkflowIdReusePolicy.UseDefault) { if (methodAttribute != null && methodAttribute.WorkflowIdReusePolicy != WorkflowIdReusePolicy.UseDefault) { options.WorkflowIdReusePolicy = methodAttribute.WorkflowIdReusePolicy; } if (options.WorkflowIdReusePolicy == Cadence.WorkflowIdReusePolicy.UseDefault) { options.WorkflowIdReusePolicy = client.Settings.WorkflowIdReusePolicy; } } if (string.IsNullOrEmpty(options.CronSchedule) && !string.IsNullOrEmpty(methodAttribute?.CronSchedule)) { options.CronSchedule = methodAttribute.CronSchedule; } return(options); }