Skip to main content

workflow

workflow

import "github.com/conductor-sdk/conductor-go/sdk/workflow"

Index​

Constants​

const (
    JavascriptEvaluator = "javascript"
)

type ConductorWorkflow​

type ConductorWorkflow struct {
    // contains filtered or unexported fields
}

func NewConductorWorkflow​

func NewConductorWorkflow(executor *executor.WorkflowExecutor) *ConductorWorkflow

func (*ConductorWorkflow) Add​

func (workflow *ConductorWorkflow) Add(task TaskInterface) *ConductorWorkflow

func (*ConductorWorkflow) Description​

func (workflow *ConductorWorkflow) Description(description string) *ConductorWorkflow

func (*ConductorWorkflow) FailureWorkflow​

func (workflow *ConductorWorkflow) FailureWorkflow(failureWorkflow string) *ConductorWorkflow

FailureWorkflow name of the workflow to execute when this workflow fails. Failure workflows can be used for handling compensation logic

func (*ConductorWorkflow) GetName​

func (workflow *ConductorWorkflow) GetName() (name string)

func (*ConductorWorkflow) GetVersion​

func (workflow *ConductorWorkflow) GetVersion() (version int32)

func (*ConductorWorkflow) InputParameters​

func (workflow *ConductorWorkflow) InputParameters(inputParameters ...string) *ConductorWorkflow

InputParameters List of the input parameters to the workflow. Used ONLY for the documentation purpose.

func (*ConductorWorkflow) InputTemplate​

func (workflow *ConductorWorkflow) InputTemplate(inputTemplate interface{}) *ConductorWorkflow

InputTemplate template input to the workflow. Can have combination of variables (e.g. ${workflow.input.abc}) and static values

func (*ConductorWorkflow) Name​

func (workflow *ConductorWorkflow) Name(name string) *ConductorWorkflow

func (*ConductorWorkflow) OutputParameters​

func (workflow *ConductorWorkflow) OutputParameters(outputParameters interface{}) *ConductorWorkflow

OutputParameters Workflow outputs. Workflow output follows similar structure as task inputs See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for more details

func (*ConductorWorkflow) OwnerEmail​

func (workflow *ConductorWorkflow) OwnerEmail(ownerEmail string) *ConductorWorkflow

func (*ConductorWorkflow) Register​

func (workflow *ConductorWorkflow) Register(overwrite bool) error

Register the workflow definition with the server. If overwrite is set\, the definition on the server will be overwritten. When not set\, the call fails if there is any change in the workflow definition between the server and what is being registered.

func (*ConductorWorkflow) Restartable​

func (workflow *ConductorWorkflow) Restartable(restartable bool) *ConductorWorkflow

Restartable if the workflow can be restarted after it has reached terminal state. Set this to false if restarting workflow can have side effects

func (*ConductorWorkflow) StartWorkflow​

func (workflow *ConductorWorkflow) StartWorkflow(startWorkflowRequest *model.StartWorkflowRequest) (workflowId string, err error)

StartWorkflow starts the workflow execution with startWorkflowRequest that allows you to specify more details like task domains\, correlationId etc. Returns the ID of the newly created workflow

func (*ConductorWorkflow) StartWorkflowWithInput​

func (workflow *ConductorWorkflow) StartWorkflowWithInput(input interface{}) (workflowId string, err error)

StartWorkflowWithInput ExecuteWorkflowWithInput Execute the workflow with specific input. The input struct MUST be serializable to JSON Returns the workflow Id that can be used to monitor and get the status of the workflow execution

func (*ConductorWorkflow) StartWorkflowsAndMonitorExecution​

func (workflow *ConductorWorkflow) StartWorkflowsAndMonitorExecution(startWorkflowRequest *model.StartWorkflowRequest) (executionChannel executor.WorkflowExecutionChannel, err error)

StartWorkflowsAndMonitorExecution Starts the workflow execution and returns a channel that can be used to monitor the workflow execution This method is useful for short duration workflows that are expected to complete in few seconds. For long-running workflows use GetStatus APIs to periodically check the status

func (*ConductorWorkflow) TimeoutPolicy​

func (workflow *ConductorWorkflow) TimeoutPolicy(timeoutPolicy TimeoutPolicy, timeoutSeconds int64) *ConductorWorkflow

func (*ConductorWorkflow) TimeoutSeconds​

func (workflow *ConductorWorkflow) TimeoutSeconds(timeoutSeconds int64) *ConductorWorkflow

func (*ConductorWorkflow) ToWorkflowDef​

func (workflow *ConductorWorkflow) ToWorkflowDef() *model.WorkflowDef

ToWorkflowDef converts the workflow to the JSON serializable format

func (*ConductorWorkflow) Variables​

func (workflow *ConductorWorkflow) Variables(variables interface{}) *ConductorWorkflow

Variables Workflow variables are set using SET_VARIABLE task. Excellent way to maintain business state e.g. Variables can maintain business/user specific states which can be queried and inspected to find out the state of the workflow

func (*ConductorWorkflow) Version​

func (workflow *ConductorWorkflow) Version(version int32) *ConductorWorkflow

type DoWhileTask​

DoWhileTask Do...While task

type DoWhileTask struct {
    Task
    // contains filtered or unexported fields
}

func NewDoWhileTask​

func NewDoWhileTask(taskRefName string, terminationCondition string, tasks ...TaskInterface) *DoWhileTask

NewDoWhileTask DoWhileTask Crate a new DoWhile task. terminationCondition is a Javascript expression that evaluates to True or False

func NewLoopTask​

func NewLoopTask(taskRefName string, iterations int32, tasks ...TaskInterface) *DoWhileTask

NewLoopTask Loop over N times when N is specified as iterations

func (*DoWhileTask) Description​

func (task *DoWhileTask) Description(description string) *DoWhileTask

Description of the task

func (*DoWhileTask) Input​

func (task *DoWhileTask) Input(key string, value interface{}) *DoWhileTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*DoWhileTask) InputMap​

func (task *DoWhileTask) InputMap(inputMap map[string]interface{}) *DoWhileTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*DoWhileTask) Optional​

func (task *DoWhileTask) Optional(optional bool) *DoWhileTask

Optional if set to true\, the task will not fail the workflow if the task fails

type DynamicForkInput​

DynamicForkInput struct that represents the output of the dynamic fork preparatory task​

DynamicFork requires inputs that specifies the list of tasks to be executed in parallel along with the inputs to each of these tasks. This usually means having another task before the dynamic task whose output contains the tasks to be forked.

This struct represents the output of such a task

type DynamicForkInput struct {
    Tasks     []model.WorkflowTask
    TaskInput map[string]interface{}
}

type DynamicForkTask​

type DynamicForkTask struct {
    Task
    // contains filtered or unexported fields
}

func NewDynamicForkTask​

func NewDynamicForkTask(taskRefName string, forkPrepareTask TaskInterface) *DynamicForkTask

func NewDynamicForkWithJoinTask​

func NewDynamicForkWithJoinTask(taskRefName string, forkPrepareTask TaskInterface, join JoinTask) *DynamicForkTask

func (*DynamicForkTask) Description​

func (task *DynamicForkTask) Description(description string) *DynamicForkTask

Description of the task

func (*DynamicForkTask) Input​

func (task *DynamicForkTask) Input(key string, value interface{}) *DynamicForkTask

Input to the task

func (*DynamicForkTask) InputMap​

func (task *DynamicForkTask) InputMap(inputMap map[string]interface{}) *DynamicForkTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*DynamicForkTask) Optional​

func (task *DynamicForkTask) Optional(optional bool) *DynamicForkTask

Optional if set to true\, the task will not fail the workflow if the task fails

type DynamicTask​

type DynamicTask struct {
    Task
}

func NewDynamicTask​

func NewDynamicTask(taskRefName string, taskNameParameter string) *DynamicTask

NewDynamicTask - taskRefName Reference name for the task. MUST be unique within the workflow - taskNameParameter Parameter that contains the expression for the dynamic task name. e.g. ${workflow.input.dynamicTask}

func (*DynamicTask) Description​

func (task *DynamicTask) Description(description string) *DynamicTask

Description of the task

func (*DynamicTask) Input​

func (task *DynamicTask) Input(key string, value interface{}) *DynamicTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*DynamicTask) InputMap​

func (task *DynamicTask) InputMap(inputMap map[string]interface{}) *DynamicTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*DynamicTask) Optional​

func (task *DynamicTask) Optional(optional bool) *DynamicTask

Optional if set to true\, the task will not fail the workflow if the task fails

type EventTask​

EventTask Task to publish Events to external queuing systems like SQS\, NATS\, AMQP etc.

type EventTask struct {
    Task
    // contains filtered or unexported fields
}

func NewConductorEventTask​

func NewConductorEventTask(taskRefName string, eventName string) *EventTask

func NewSqsEventTask​

func NewSqsEventTask(taskRefName string, queueName string) *EventTask

func (*EventTask) Description​

func (task *EventTask) Description(description string) *EventTask

Description of the task

func (*EventTask) Input​

func (task *EventTask) Input(key string, value interface{}) *EventTask

Input to the task

func (*EventTask) InputMap​

func (task *EventTask) InputMap(inputMap map[string]interface{}) *EventTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*EventTask) Optional​

func (task *EventTask) Optional(optional bool) *EventTask

Optional if set to true\, the task will not fail the workflow if the task fails

type ForkTask​

type ForkTask struct {
    Task
    // contains filtered or unexported fields
}

func NewForkTask​

func NewForkTask(taskRefName string, forkedTask ...[]TaskInterface) *ForkTask
execute task specified in the forkedTasks parameter in parallel. forkedTask is a two-dimensional list that executes the outermost list in parallel and list within that is executed sequentially. e.g. [[task1, task2],[task3, task4],[task5]] are executed as: --------------- |     fork    | --------------- |       |     | |       |     | task1  task3  task5 task2  task4    | |      |      | --------------------- |       join        | --------------------- This method automatically adds a join that waits for all the last tasks in the fork (e.g. task2, task4 and task5 in the above example) to be completed.

func (*ForkTask) Description​

func (task *ForkTask) Description(description string) *ForkTask

Description of the task

func (*ForkTask) Input​

func (task *ForkTask) Input(key string, value interface{}) *ForkTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*ForkTask) InputMap​

func (task *ForkTask) InputMap(inputMap map[string]interface{}) *ForkTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*ForkTask) Optional​

func (task *ForkTask) Optional(optional bool) *ForkTask

Optional if set to true\, the task will not fail the workflow if one of the loop task fails

type HttpInput​

HttpInput Input to the HTTP task

type HttpInput struct {
    Method            HttpMethod          `json:"method"`
    Uri               string              `json:"uri"`
    Headers           map[string][]string `json:"headers,omitempty"`
    Accept            string              `json:"accept,omitempty"`
    ContentType       string              `json:"contentType,omitempty"`
    ConnectionTimeOut int16               `json:"ConnectionTimeOut,omitempty"`
    ReadTimeout       int16               `json:"readTimeout,omitempty"`
    Body              interface{}         `json:"body,omitempty"`
}

type HttpMethod​

type HttpMethod string
const (
    GET     HttpMethod = "GET"
    PUT     HttpMethod = "PUT"
    POST    HttpMethod = "POST"
    DELETE  HttpMethod = "DELETE"
    HEAD    HttpMethod = "HEAD"
    OPTIONS HttpMethod = "OPTIONS"
)

type HttpTask​

type HttpTask struct {
    Task
}

func NewHttpTask​

func NewHttpTask(taskRefName string, input *HttpInput) *HttpTask

NewHttpTask Create a new HTTP Task

func (*HttpTask) Description​

func (task *HttpTask) Description(description string) *HttpTask

Description of the task

func (*HttpTask) Input​

func (task *HttpTask) Input(key string, value interface{}) *HttpTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*HttpTask) InputMap​

func (task *HttpTask) InputMap(inputMap map[string]interface{}) *HttpTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*HttpTask) Optional​

func (task *HttpTask) Optional(optional bool) *HttpTask

Optional if set to true\, the task will not fail the workflow if the task fails

type HumanTask​

type HumanTask struct {
    Task
}

func NewHumanTask​

func NewHumanTask(taskRefName string) *HumanTask

func (*HumanTask) Description​

func (task *HumanTask) Description(description string) *HumanTask

Description of the task

func (*HumanTask) Input​

func (task *HumanTask) Input(key string, value interface{}) *HumanTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*HumanTask) InputMap​

func (task *HumanTask) InputMap(inputMap map[string]interface{}) *HumanTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*HumanTask) Optional​

func (task *HumanTask) Optional(optional bool) *HumanTask

Optional if set to true\, the task will not fail the workflow if the task fails

type InlineTask​

type InlineTask struct {
    Task
}

func NewInlineTask​

func NewInlineTask(name string, script string) *InlineTask

func (*InlineTask) Description​

func (task *InlineTask) Description(description string) *InlineTask

Description of the task

func (*InlineTask) Input​

func (task *InlineTask) Input(key string, value interface{}) *InlineTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*InlineTask) InputMap​

func (task *InlineTask) InputMap(inputMap map[string]interface{}) *InlineTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*InlineTask) Optional​

func (task *InlineTask) Optional(optional bool) *InlineTask

Optional if set to true\, the task will not fail the workflow if the task fails

type JQTask​

type JQTask struct {
    Task
}

func NewJQTask​

func NewJQTask(name string, script string) *JQTask

func (*JQTask) Description​

func (task *JQTask) Description(description string) *JQTask

Description of the task

func (*JQTask) Input​

func (task *JQTask) Input(key string, value interface{}) *JQTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*JQTask) InputMap​

func (task *JQTask) InputMap(inputMap map[string]interface{}) *JQTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*JQTask) Optional​

func (task *JQTask) Optional(optional bool) *JQTask

Optional if set to true\, the task will not fail the workflow if the task fails

type JoinTask​

type JoinTask struct {
    Task
    // contains filtered or unexported fields
}

func NewJoinTask​

func NewJoinTask(taskRefName string, joinOn ...string) *JoinTask

func (*JoinTask) Description​

func (task *JoinTask) Description(description string) *JoinTask

Description of the task

func (*JoinTask) Optional​

func (task *JoinTask) Optional(optional bool) *JoinTask

Optional if set to true\, the task will not fail the workflow if the task fails

type KafkaPublishTask​

type KafkaPublishTask struct {
    Task
}

func NewKafkaPublishTask​

func NewKafkaPublishTask(taskRefName string, kafkaPublishTaskInput *KafkaPublishTaskInput) *KafkaPublishTask

func (*KafkaPublishTask) Description​

func (task *KafkaPublishTask) Description(description string) *KafkaPublishTask

Description of the task

func (*KafkaPublishTask) Input​

func (task *KafkaPublishTask) Input(key string, value interface{}) *KafkaPublishTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*KafkaPublishTask) InputMap​

func (task *KafkaPublishTask) InputMap(inputMap map[string]interface{}) *KafkaPublishTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*KafkaPublishTask) Optional​

func (task *KafkaPublishTask) Optional(optional bool) *KafkaPublishTask

Optional if set to true\, the task will not fail the workflow if the task fails

type KafkaPublishTaskInput​

type KafkaPublishTaskInput struct {
    BootStrapServers string                 `json:"bootStrapServers"`
    Key              string                 `json:"key"`
    KeySerializer    string                 `json:"keySerializer,omitempty"`
    Value            string                 `json:"value"`
    RequestTimeoutMs string                 `json:"requestTimeoutMs,omitempty"`
    MaxBlockMs       string                 `json:"maxBlockMs,omitempty"`
    Headers          map[string]interface{} `json:"headers,omitempty"`
    Topic            string                 `json:"topic"`
}

type SetVariableTask​

type SetVariableTask struct {
    Task
}

func NewSetVariableTask​

func NewSetVariableTask(taskRefName string) *SetVariableTask

func (*SetVariableTask) Description​

func (task *SetVariableTask) Description(description string) *SetVariableTask

Description of the task

func (*SetVariableTask) Input​

func (task *SetVariableTask) Input(key string, value interface{}) *SetVariableTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SetVariableTask) InputMap​

func (task *SetVariableTask) InputMap(inputMap map[string]interface{}) *SetVariableTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SetVariableTask) Optional​

func (task *SetVariableTask) Optional(optional bool) *SetVariableTask

Optional if set to true\, the task will not fail the workflow if the task fails

type SimpleTask​

type SimpleTask struct {
    Task
}

func NewSimpleTask​

func NewSimpleTask(taskType string, taskRefName string) *SimpleTask

func (*SimpleTask) Description​

func (task *SimpleTask) Description(description string) *SimpleTask

Description of the task

func (*SimpleTask) Input​

func (task *SimpleTask) Input(key string, value interface{}) *SimpleTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SimpleTask) InputMap​

func (task *SimpleTask) InputMap(inputMap map[string]interface{}) *SimpleTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SimpleTask) Optional​

func (task *SimpleTask) Optional(optional bool) *SimpleTask

Optional if set to true\, the task will not fail the workflow if the task fails

type StartWorkflowTask​

type StartWorkflowTask struct {
    Task
}

func NewStartWorkflowTask​

func NewStartWorkflowTask(taskRefName string, workflowName string, version *int32, startWorkflowRequest *model.StartWorkflowRequest) *StartWorkflowTask

func (*StartWorkflowTask) Description​

func (task *StartWorkflowTask) Description(description string) *StartWorkflowTask

Description of the task

func (*StartWorkflowTask) Input​

func (task *StartWorkflowTask) Input(key string, value interface{}) *StartWorkflowTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*StartWorkflowTask) InputMap​

func (task *StartWorkflowTask) InputMap(inputMap map[string]interface{}) *StartWorkflowTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*StartWorkflowTask) Optional​

func (task *StartWorkflowTask) Optional(optional bool) *StartWorkflowTask

Optional if set to true\, the task will not fail the workflow if the task fails

type SubWorkflowTask​

type SubWorkflowTask struct {
    Task
    // contains filtered or unexported fields
}

func NewSubWorkflowInlineTask​

func NewSubWorkflowInlineTask(taskRefName string, workflow *ConductorWorkflow) *SubWorkflowTask

func NewSubWorkflowTask​

func NewSubWorkflowTask(taskRefName string, workflowName string, version *int32) *SubWorkflowTask

func (*SubWorkflowTask) Description​

func (task *SubWorkflowTask) Description(description string) *SubWorkflowTask

Description of the task

func (*SubWorkflowTask) Input​

func (task *SubWorkflowTask) Input(key string, value interface{}) *SubWorkflowTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SubWorkflowTask) InputMap​

func (task *SubWorkflowTask) InputMap(inputMap map[string]interface{}) *SubWorkflowTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SubWorkflowTask) Optional​

func (task *SubWorkflowTask) Optional(optional bool) *SubWorkflowTask

Optional if set to true\, the task will not fail the workflow if the task fails

func (*SubWorkflowTask) TaskToDomain​

func (task *SubWorkflowTask) TaskToDomain(taskToDomainMap map[string]string) *SubWorkflowTask

type SwitchTask​

type SwitchTask struct {
    Task
    DecisionCases map[string][]TaskInterface
    // contains filtered or unexported fields
}

func NewSwitchTask​

func NewSwitchTask(taskRefName string, caseExpression string) *SwitchTask

func (*SwitchTask) DefaultCase​

func (task *SwitchTask) DefaultCase(tasks ...TaskInterface) *SwitchTask

func (*SwitchTask) Description​

func (task *SwitchTask) Description(description string) *SwitchTask

Description of the task

func (*SwitchTask) Input​

func (task *SwitchTask) Input(key string, value interface{}) *SwitchTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SwitchTask) InputMap​

func (task *SwitchTask) InputMap(inputMap map[string]interface{}) *SwitchTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*SwitchTask) Optional​

func (task *SwitchTask) Optional(optional bool) *SwitchTask

Optional if set to true\, the task will not fail the workflow if the task fails

func (*SwitchTask) SwitchCase​

func (task *SwitchTask) SwitchCase(caseName string, tasks ...TaskInterface) *SwitchTask

func (*SwitchTask) UseJavascript​

func (task *SwitchTask) UseJavascript(use bool) *SwitchTask

UseJavascript If set to to true\, the caseExpression parameter is treated as a Javascript. If set to false\, the caseExpression follows the regular task input mapping format as described in https://conductor.netflix.com/how-tos/Tasks/task-inputs.html

type Task​

type Task struct {
    // contains filtered or unexported fields
}

func (*Task) Description​

func (task *Task) Description(description string) *Task

Description of the task

func (*Task) Input​

func (task *Task) Input(key string, value interface{}) *Task

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*Task) InputMap​

func (task *Task) InputMap(inputMap map[string]interface{}) *Task

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*Task) Optional​

func (task *Task) Optional(optional bool) *Task

Optional if set to true\, the task will not fail the workflow if the task fails

func (*Task) OutputRef​

func (task *Task) OutputRef(path string) string

func (*Task) ReferenceName​

func (task *Task) ReferenceName() string

func (*Task) ToTaskDef​

func (task *Task) ToTaskDef() *model.TaskDef

type TaskInterface​

type TaskInterface interface {
    OutputRef(path string) string
    ToTaskDef() *model.TaskDef
    // contains filtered or unexported methods
}

type TaskType​

type TaskType string
const (
    SIMPLE            TaskType = "SIMPLE"
    DYNAMIC           TaskType = "DYNAMIC"
    FORK_JOIN         TaskType = "FORK_JOIN"
    FORK_JOIN_DYNAMIC TaskType = "FORK_JOIN_DYNAMIC"
    SWITCH            TaskType = "SWITCH"
    JOIN              TaskType = "JOIN"
    DO_WHILE          TaskType = "DO_WHILE"
    SUB_WORKFLOW      TaskType = "SUB_WORKFLOW"
    START_WORKFLOW    TaskType = "START_WORKFLOW"
    EVENT             TaskType = "EVENT"
    WAIT              TaskType = "WAIT"
    HUMAN             TaskType = "HUMAN"
    HTTP              TaskType = "HTTP"
    INLINE            TaskType = "INLINE"
    TERMINATE         TaskType = "TERMINATE"
    KAFKA_PUBLISH     TaskType = "KAFKA_PUBLISH"
    JSON_JQ_TRANSFORM TaskType = "JSON_JQ_TRANSFORM"
    SET_VARIABLE      TaskType = "SET_VARIABLE"
)

type TerminateTask​

type TerminateTask struct {
    Task
}

func NewTerminateTask​

func NewTerminateTask(taskRefName string, status model.WorkflowStatus, terminationReason string) *TerminateTask

func (*TerminateTask) Description​

func (task *TerminateTask) Description(description string) *TerminateTask

Description of the task

func (*TerminateTask) Input​

func (task *TerminateTask) Input(key string, value interface{}) *TerminateTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*TerminateTask) InputMap​

func (task *TerminateTask) InputMap(inputMap map[string]interface{}) *TerminateTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

type TimeoutPolicy​

type TimeoutPolicy string
const (
    TimeOutWorkflow TimeoutPolicy = "TIME_OUT_WF"
    AlertOnly       TimeoutPolicy = "ALERT_ONLY"
)

type WaitTask​

type WaitTask struct {
    Task
}

func NewWaitForDurationTask​

func NewWaitForDurationTask(taskRefName string, duration time.Duration) *WaitTask

func NewWaitTask​

func NewWaitTask(taskRefName string) *WaitTask

NewWaitTask creates WAIT task used to wait until an external event or a timeout occurs

func NewWaitUntilTask​

func NewWaitUntilTask(taskRefName string, dateTime string) *WaitTask

func (*WaitTask) Description​

func (task *WaitTask) Description(description string) *WaitTask

Description of the task

func (*WaitTask) Input​

func (task *WaitTask) Input(key string, value interface{}) *WaitTask

Input to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*WaitTask) InputMap​

func (task *WaitTask) InputMap(inputMap map[string]interface{}) *WaitTask

InputMap to the task. See https://conductor.netflix.com/how-tos/Tasks/task-inputs.html for details

func (*WaitTask) Optional​

func (task *WaitTask) Optional(optional bool) *WaitTask

Optional if set to true\, the task will not fail the workflow if the task fails

Generated by gomarkdoc