bpmn

package module
v2.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 10, 2024 License: LGPL-2.1 Imports: 17 Imported by: 0

README

Introduce ｜ 中文

a lightweight bpmn engine

Download

go get -u github.com/olive-io/bpmn

Usage

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	DefaultTaskTimeoutKey  = "timeout"
	DefaultTaskExecTimeout = time.Second * 30
)
View Source 
var (
	GitCommit = ""
	GitTag    = ""
	BuildDate = ""
)

Functions

func ApplyTaskDataOutput 

func ApplyTaskDataOutput(element schema.BaseElementInterface, dataOutputs map[string]any) map[string]data.IItem

func ApplyTaskResult added in v2.2.0 

func ApplyTaskResult(element schema.BaseElementInterface, results map[string]any) map[string]data.IItem

func DistributeFlows 

func DistributeFlows(awaitingActions []chan IAction, sequenceFlows []*SequenceFlow)

func FetchTaskDataInput 

func FetchTaskDataInput(locator data.IFlowDataLocator, element schema.BaseElementInterface) (headers, properties, dataObjects map[string]any)

func GoV 

func GoV() string

func Version 

func Version() string

Types

type ActionTransformer 

type ActionTransformer func(sequenceFlowId *schema.IdRef, action IAction) IAction

type ActiveBoundaryTrace 

type ActiveBoundaryTrace struct {
	Start bool
	Node  schema.FlowNodeInterface
}

func (ActiveBoundaryTrace) Element 

func (b ActiveBoundaryTrace) Element() any

type ActiveListeningTrace 

type ActiveListeningTrace struct {
	Node *schema.CatchEvent
}

func (ActiveListeningTrace) Element 

func (t ActiveListeningTrace) Element() any

type Activity 

type Activity interface {
	IFlowNode
	Type() Type
	// Cancel initiates a cancellation of activity and returns a channel
	// that will signal a boolean (`true` if cancellation was successful,
	// `false` otherwise)
	Cancel() <-chan bool
}

Activity is a generic interface to flow nodes that are activities

type BusinessRuleTask 

type BusinessRuleTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*BusinessRuleTask) Cancel 

func (task *BusinessRuleTask) Cancel() <-chan bool

func (*BusinessRuleTask) Element 

func (task *BusinessRuleTask) Element() schema.FlowNodeInterface

func (*BusinessRuleTask) NextAction 

func (task *BusinessRuleTask) NextAction(T) chan IAction

func (*BusinessRuleTask) Type 

func (task *BusinessRuleTask) Type() Type

type BusinessRuleTaskKey 

type BusinessRuleTaskKey struct{}

type CallActivity 

type CallActivity struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*CallActivity) Cancel 

func (task *CallActivity) Cancel() <-chan bool

func (*CallActivity) Element 

func (task *CallActivity) Element() schema.FlowNodeInterface

func (*CallActivity) NextAction 

func (task *CallActivity) NextAction(T) chan IAction

func (*CallActivity) Type 

func (task *CallActivity) Type() Type

type CallActivityKey 

type CallActivityKey struct{}

type CancellationFlowNodeTrace 

type CancellationFlowNodeTrace struct {
	Node schema.FlowNodeInterface
}

func (CancellationFlowNodeTrace) Element 

func (t CancellationFlowNodeTrace) Element() any

type CancellationFlowTrace 

type CancellationFlowTrace struct {
	FlowId id.Id
}

func (CancellationFlowTrace) Element 

func (t CancellationFlowTrace) Element() any

type CatchEvent 

type CatchEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewCatchEvent 

func NewCatchEvent(ctx context.Context, wiring *Wiring, catchEvent *schema.CatchEvent) (evt *CatchEvent, err error)

func (*CatchEvent) ConsumeEvent 

func (evt *CatchEvent) ConsumeEvent(ev event.IEvent) (result event.ConsumptionResult, err error)

func (*CatchEvent) Element 

func (evt *CatchEvent) Element() schema.FlowNodeInterface

func (*CatchEvent) NextAction 

func (evt *CatchEvent) NextAction(flow T) chan IAction

type CeaseFlowTrace 

type CeaseFlowTrace struct {
	Process schema.Element
}

func (CeaseFlowTrace) Element 

func (t CeaseFlowTrace) Element() any

type CompleteAction 

type CompleteAction struct{}

type CompletionTrace 

type CompletionTrace struct {
	Node schema.FlowNodeInterface
}

func (CompletionTrace) Element 

func (t CompletionTrace) Element() any

type Constructor 

type Constructor = func(*Wiring) (node Activity, err error)

func NewBusinessRuleTask 

func NewBusinessRuleTask(ctx context.Context, task *schema.BusinessRuleTask) Constructor

func NewCallActivity 

func NewCallActivity(ctx context.Context, task *schema.CallActivity) Constructor

func NewManualTask 

func NewManualTask(ctx context.Context, task *schema.ManualTask) Constructor

func NewReceiveTask 

func NewReceiveTask(ctx context.Context, task *schema.ReceiveTask) Constructor

func NewScriptTask 

func NewScriptTask(ctx context.Context, task *schema.ScriptTask) Constructor

func NewSendTask 

func NewSendTask(ctx context.Context, task *schema.SendTask) Constructor

func NewServiceTask 

func NewServiceTask(ctx context.Context, task *schema.ServiceTask) Constructor

func NewSubProcess 

func NewSubProcess(ctx context.Context,
	eventDefinitionBuilder event.IDefinitionInstanceBuilder,
	idGenerator id.IGenerator,
	tracer tracing.ITracer,
	subProcess *schema.SubProcess) Constructor

func NewTask 

func NewTask(ctx context.Context, task *schema.Task) Constructor

func NewUserTask 

func NewUserTask(ctx context.Context, task *schema.UserTask) Constructor

type DeterminationMadeTrace 

type DeterminationMadeTrace struct {
	Node schema.FlowNodeInterface
}

func (DeterminationMadeTrace) Element 

func (t DeterminationMadeTrace) Element() any

type DoOption 

type DoOption func(*DoResponse)

func DoWithErr added in v2.2.0 

func DoWithErr(err error) DoOption

func DoWithErrHandle added in v2.2.0 

func DoWithErrHandle(err error, ch <-chan ErrHandler) DoOption

func DoWithObjects added in v2.2.0 

func DoWithObjects(dataObjects map[string]any) DoOption

func DoWithResults added in v2.2.0 

func DoWithResults(results map[string]any) DoOption

func DoWithValue added in v2.2.0 

func DoWithValue(key, value any) DoOption

type DoResponse 

type DoResponse struct {
	Context     context.Context
	DataObjects map[string]any
	Results     map[string]any
	Err         error
	HandlerCh   <-chan ErrHandler
}

type EndEvent 

type EndEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewEndEvent 

func NewEndEvent(ctx context.Context, wiring *Wiring, endEvent *schema.EndEvent) (evt *EndEvent, err error)

func (*EndEvent) Element 

func (evt *EndEvent) Element() schema.FlowNodeInterface

func (*EndEvent) NextAction 

func (evt *EndEvent) NextAction(T) chan IAction

type ErrHandleMode 

type ErrHandleMode int
const (
	RetryMode ErrHandleMode = iota + 1
	SkipMode
	ExitMode
)

type ErrHandler 

type ErrHandler struct {
	Mode    ErrHandleMode
	Retries int32
}

type ErrorTrace 

type ErrorTrace struct {
	Error error
}

func (ErrorTrace) Element 

func (t ErrorTrace) Element() any

type EventBasedGateway 

type EventBasedGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewEventBasedGateway 

func NewEventBasedGateway(ctx context.Context, wiring *Wiring, eventBasedGateway *schema.EventBasedGateway) (gw *EventBasedGateway, err error)

func (*EventBasedGateway) Element 

func (gw *EventBasedGateway) Element() schema.FlowNodeInterface

func (*EventBasedGateway) NextAction 

func (gw *EventBasedGateway) NextAction(flow T) chan IAction

type EventObservedTrace 

type EventObservedTrace struct {
	Node  *schema.CatchEvent
	Event event.IEvent
}

EventObservedTrace signals the fact that a particular event has been in fact observed by the node

func (EventObservedTrace) Element 

func (t EventObservedTrace) Element() any

type ExclusiveGateway 

type ExclusiveGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewExclusiveGateway 

func NewExclusiveGateway(ctx context.Context, wiring *Wiring, exclusiveGateway *schema.ExclusiveGateway) (gw *ExclusiveGateway, err error)

func (*ExclusiveGateway) Element 

func (gw *ExclusiveGateway) Element() schema.FlowNodeInterface

func (*ExclusiveGateway) NextAction 

func (gw *ExclusiveGateway) NextAction(flow T) chan IAction

type ExclusiveNoEffectiveSequenceFlows 

type ExclusiveNoEffectiveSequenceFlows struct {
	*schema.ExclusiveGateway
}

func (ExclusiveNoEffectiveSequenceFlows) Error 

func (e ExclusiveNoEffectiveSequenceFlows) Error() string

type Flow 

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

Flow Represents a flow

func NewFlow 

func NewFlow(definitions *schema.Definitions,
	current IFlowNode, tracer tracing.ITracer,
	flowNodeMapping *FlowNodeMapping, flowWaitGroup *sync.WaitGroup,
	idGenerator id.IGenerator, actionTransformer ActionTransformer,
	locator data.IFlowDataLocator,
) *Flow

NewFlow creates a new flow from a flow node

The flow does nothing until it is explicitly started.

func (*Flow) Id 

func (flow *Flow) Id() id.Id

func (*Flow) SequenceFlow 

func (flow *Flow) SequenceFlow() *SequenceFlow

func (*Flow) SetTerminate 

func (flow *Flow) SetTerminate(terminate Terminate)

func (*Flow) Start 

func (flow *Flow) Start(ctx context.Context)

Start starts the flow

type FlowAction 

type FlowAction struct {
	Response *FlowActionResponse

	SequenceFlows []*SequenceFlow
	// Index of sequence flows that should flow without
	// conditionExpression being evaluated
	UnconditionalFlows []int
	// The actions produced by the targets should be processed by
	// this function
	ActionTransformer ActionTransformer
	// If supplied channel sends a function that returns true, the flow action
	// is to be terminated if it wasn't already
	Terminate Terminate
}

type FlowActionResponse 

type FlowActionResponse struct {
	DataObjects map[string]data.IItem
	Variables   map[string]data.IItem
	Err         error
	Handler     <-chan ErrHandler
}

type FlowNodeMapping 

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

func NewLockedFlowNodeMapping 

func NewLockedFlowNodeMapping() *FlowNodeMapping

func (*FlowNodeMapping) Finalize 

func (mapping *FlowNodeMapping) Finalize()

func (*FlowNodeMapping) RegisterElementToFlowNode 

func (mapping *FlowNodeMapping) RegisterElementToFlowNode(element schema.FlowNodeInterface, flowNode IFlowNode) (err error)

func (*FlowNodeMapping) ResolveElementToFlowNode 

func (mapping *FlowNodeMapping) ResolveElementToFlowNode(element schema.FlowNodeInterface) (flowNode IFlowNode, found bool)

type FlowTrace 

type FlowTrace struct {
	Source schema.FlowNodeInterface
	Flows  []Snapshot
}

func (FlowTrace) Element 

func (t FlowTrace) Element() any

type Harness 

type Harness struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewHarness 

func NewHarness(ctx context.Context, wiring *Wiring, idGenerator id.IGenerator, constructor Constructor) (node *Harness, err error)

func (*Harness) Activity 

func (node *Harness) Activity() Activity

func (*Harness) ConsumeEvent 

func (node *Harness) ConsumeEvent(ev event.IEvent) (result event.ConsumptionResult, err error)

func (*Harness) Element 

func (node *Harness) Element() schema.FlowNodeInterface

func (*Harness) NextAction 

func (node *Harness) NextAction(flow T) chan IAction

func (*Harness) RegisterEventConsumer 

func (node *Harness) RegisterEventConsumer(consumer event.IConsumer) (err error)

type IAction 

type IAction interface {
	// contains filtered or unexported methods
}

type IFlowNode 

type IFlowNode interface {
	IOutgoing
	Element() schema.FlowNodeInterface
}

type IOutgoing 

type IOutgoing interface {
	NextAction(flow T) chan IAction
}

type InclusiveGateway 

type InclusiveGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewInclusiveGateway 

func NewInclusiveGateway(ctx context.Context, wiring *Wiring, inclusiveGateway *schema.InclusiveGateway) (gw *InclusiveGateway, err error)

func (*InclusiveGateway) Element 

func (gw *InclusiveGateway) Element() schema.FlowNodeInterface

func (*InclusiveGateway) NextAction 

func (gw *InclusiveGateway) NextAction(flow T) chan IAction

type InclusiveNoEffectiveSequenceFlows 

type InclusiveNoEffectiveSequenceFlows struct {
	*schema.InclusiveGateway
}

func (InclusiveNoEffectiveSequenceFlows) Error 

func (e InclusiveNoEffectiveSequenceFlows) Error() string

type IncomingFlowProcessedTrace 

type IncomingFlowProcessedTrace struct {
	Node *schema.ParallelGateway
	Flow T
}

IncomingFlowProcessedTrace signals that a particular flow has been processed. If any action have been taken, it already happened

func (IncomingFlowProcessedTrace) Element 

func (t IncomingFlowProcessedTrace) Element() any

type Instance 

type Instance struct {
	*Options
	// contains filtered or unexported fields
}

func NewInstance 

func NewInstance(element *schema.Process, definitions *schema.Definitions, options *Options) (instance *Instance, err error)

func (*Instance) ConsumeEvent 

func (ins *Instance) ConsumeEvent(ev event.IEvent) (result event.ConsumptionResult, err error)

func (*Instance) FlowNodeMapping 

func (ins *Instance) FlowNodeMapping() *FlowNodeMapping

func (*Instance) Id 

func (ins *Instance) Id() id.Id

func (*Instance) Locator 

func (ins *Instance) Locator() data.IFlowDataLocator

func (*Instance) Process 

func (ins *Instance) Process() *schema.Process

func (*Instance) RegisterEventConsumer 

func (ins *Instance) RegisterEventConsumer(ev event.IConsumer) (err error)

func (*Instance) StartAll 

func (ins *Instance) StartAll() (err error)

StartAll explicitly starts the instance by triggering all start events, if any

func (*Instance) StartWith 

func (ins *Instance) StartWith(ctx context.Context, startEvent schema.StartEventInterface) (err error)

StartWith explicitly starts the instance by triggering a given start event

func (*Instance) Tracer 

func (ins *Instance) Tracer() tracing.ITracer

func (*Instance) WaitUntilComplete 

func (ins *Instance) WaitUntilComplete(ctx context.Context) (complete bool)

WaitUntilComplete waits until the instance is complete. Returns true if the instance was complete, false if the context signalled `Done`

type InstanceTrace 

type InstanceTrace struct {
	InstanceId id.Id
	Trace      tracing.ITrace
}

InstanceTrace wraps any trace with process instance id

func (InstanceTrace) Element 

func (t InstanceTrace) Element() any

func (InstanceTrace) Unwrap 

func (t InstanceTrace) Unwrap() tracing.ITrace

type InstantiationTrace 

type InstantiationTrace struct {
	InstanceId id.Id
}

InstantiationTrace denotes instantiation of a given process

func (InstantiationTrace) Element 

func (i InstantiationTrace) Element() any

type LeaveTrace 

type LeaveTrace struct {
	Node schema.FlowNodeInterface
}

func (LeaveTrace) Element 

func (t LeaveTrace) Element() any

type ManualTask 

type ManualTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*ManualTask) Cancel 

func (task *ManualTask) Cancel() <-chan bool

func (*ManualTask) Element 

func (task *ManualTask) Element() schema.FlowNodeInterface

func (*ManualTask) NextAction 

func (task *ManualTask) NextAction(T) chan IAction

func (*ManualTask) Type 

func (task *ManualTask) Type() Type

type NewFlowNodeTrace 

type NewFlowNodeTrace struct {
	Node schema.FlowNodeInterface
}

func (NewFlowNodeTrace) Element 

func (t NewFlowNodeTrace) Element() any

type NewFlowTrace 

type NewFlowTrace struct {
	FlowId id.Id
}

func (NewFlowTrace) Element 

func (t NewFlowTrace) Element() any

type NoAction 

type NoAction struct{}

type Option 

type Option func(*Options)

Option allows to modify configuration of an instance in a flexible fashion (as it's just a modification function)

func WithContext 

func WithContext(ctx context.Context) Option

WithContext will pass a given context to a new instance instead of implicitly generated one

func WithDataObjects 

func WithDataObjects(dataObjects map[string]any) Option

func WithEventDefinitionInstanceBuilder 

func WithEventDefinitionInstanceBuilder(builder event.IDefinitionInstanceBuilder) Option

func WithEventEgress 

func WithEventEgress(source event.ISource) Option

func WithEventIngress 

func WithEventIngress(consumer event.IConsumer) Option

func WithIdGenerator 

func WithIdGenerator(builder id.IGeneratorBuilder) Option

func WithLocator 

func WithLocator(locator data.IFlowDataLocator) Option

func WithTracer 

func WithTracer(tracer tracing.ITracer) Option

WithTracer overrides instance's tracer

func WithVariables 

func WithVariables(variables map[string]any) Option

type Options 

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

func NewOptions 

func NewOptions(opts ...Option) *Options

type ParallelGateway 

type ParallelGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewParallelGateway 

func NewParallelGateway(ctx context.Context, wiring *Wiring, parallelGateway *schema.ParallelGateway) (gateway *ParallelGateway, err error)

func (*ParallelGateway) Element 

func (gw *ParallelGateway) Element() schema.FlowNodeInterface

func (*ParallelGateway) NextAction 

func (gw *ParallelGateway) NextAction(flow T) chan IAction

type ProbeAction 

type ProbeAction struct {
	SequenceFlows []*SequenceFlow
	// ProbeReport is a function that needs to be called
	// wth sequence flow indices that have successful
	// condition expressions (or none)
	ProbeReport func([]int)
}

type Process 

type Process struct {
	*Options

	Element     *schema.Process
	Definitions *schema.Definitions
	// contains filtered or unexported fields
}

func MakeProcess 

func MakeProcess(element *schema.Process, definitions *schema.Definitions, opts ...Option) Process

func NewProcess 

func NewProcess(element *schema.Process, definitions *schema.Definitions, opts ...Option) *Process

func (*Process) Instantiate 

func (p *Process) Instantiate(opts ...Option) (inst *Instance, err error)

func (*Process) Process 

func (p *Process) Process() *schema.Process

func (*Process) Tracer 

func (p *Process) Tracer() tracing.ITracer

type ProcessLandMarkTrace 

type ProcessLandMarkTrace struct {
	Node schema.FlowNodeInterface
}

ProcessLandMarkTrace denotes instantiation of a given sub process

func (ProcessLandMarkTrace) Element 

func (t ProcessLandMarkTrace) Element() any

type ProcessTrace 

type ProcessTrace struct {
	Process *schema.Process
	Trace   tracing.ITrace
}

ProcessTrace wraps any trace within a given process

func (ProcessTrace) Element 

func (t ProcessTrace) Element() any

func (ProcessTrace) Unwrap 

func (t ProcessTrace) Unwrap() tracing.ITrace

type ReceiveTask 

type ReceiveTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*ReceiveTask) Cancel 

func (task *ReceiveTask) Cancel() <-chan bool

func (*ReceiveTask) Element 

func (task *ReceiveTask) Element() schema.FlowNodeInterface

func (*ReceiveTask) NextAction 

func (task *ReceiveTask) NextAction(t T) chan IAction

func (*ReceiveTask) Type 

func (task *ReceiveTask) Type() Type

type Retry 

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

Retry describes the retry handler for Flow

func (*Retry) IsContinue 

func (r *Retry) IsContinue() bool

func (*Retry) Reset 

func (r *Retry) Reset(retries int32)

func (*Retry) Step 

func (r *Retry) Step()

Step Attempts += 1

type ScriptTask 

type ScriptTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*ScriptTask) Cancel 

func (task *ScriptTask) Cancel() <-chan bool

func (*ScriptTask) Element 

func (task *ScriptTask) Element() schema.FlowNodeInterface

func (*ScriptTask) NextAction 

func (task *ScriptTask) NextAction(t T) chan IAction

func (*ScriptTask) Type 

func (task *ScriptTask) Type() Type

type SendTask 

type SendTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*SendTask) Cancel 

func (task *SendTask) Cancel() <-chan bool

func (*SendTask) Element 

func (task *SendTask) Element() schema.FlowNodeInterface

func (*SendTask) NextAction 

func (task *SendTask) NextAction(t T) chan IAction

func (*SendTask) Type 

func (task *SendTask) Type() Type

type SequenceFlow 

type SequenceFlow struct {
	*schema.SequenceFlow
	// contains filtered or unexported fields
}

func AllSequenceFlows 

func AllSequenceFlows(sequenceFlows *[]SequenceFlow, exclusion ...func(*SequenceFlow) bool) (result []*SequenceFlow)

func MakeSequenceFlow 

func MakeSequenceFlow(sf *schema.SequenceFlow, process schema.Element) SequenceFlow

func NewSequenceFlow 

func NewSequenceFlow(sf *schema.SequenceFlow, process schema.Element) *SequenceFlow

func (*SequenceFlow) Source 

func (sf *SequenceFlow) Source() (schema.FlowNodeInterface, error)

func (*SequenceFlow) Target 

func (sf *SequenceFlow) Target() (schema.FlowNodeInterface, error)

func (*SequenceFlow) TargetIndex 

func (sf *SequenceFlow) TargetIndex() (index int, err error)

type ServiceTask 

type ServiceTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*ServiceTask) Cancel 

func (task *ServiceTask) Cancel() <-chan bool

func (*ServiceTask) Element 

func (task *ServiceTask) Element() schema.FlowNodeInterface

func (*ServiceTask) NextAction 

func (task *ServiceTask) NextAction(T) chan IAction

func (*ServiceTask) Type 

func (task *ServiceTask) Type() Type

type Snapshot 

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

func (*Snapshot) Id 

func (s *Snapshot) Id() id.Id

func (*Snapshot) SequenceFlow 

func (s *Snapshot) SequenceFlow() *SequenceFlow

type StartEvent 

type StartEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

func NewStartEvent 

func NewStartEvent(ctx context.Context, wiring *Wiring,
	startEvent *schema.StartEvent, idGenerator id.IGenerator,
) (evt *StartEvent, err error)

func (*StartEvent) ConsumeEvent 

func (evt *StartEvent) ConsumeEvent(ev event.IEvent) (result event.ConsumptionResult, err error)

func (*StartEvent) Element 

func (evt *StartEvent) Element() schema.FlowNodeInterface

func (*StartEvent) NextAction 

func (evt *StartEvent) NextAction(flow T) chan IAction

func (*StartEvent) Trigger 

func (evt *StartEvent) Trigger()

type SubProcess 

type SubProcess struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*SubProcess) Cancel 

func (p *SubProcess) Cancel() <-chan bool

func (*SubProcess) ConsumeEvent 

func (p *SubProcess) ConsumeEvent(ev event.IEvent) (result event.ConsumptionResult, err error)

func (*SubProcess) Element 

func (p *SubProcess) Element() schema.FlowNodeInterface

func (*SubProcess) NextAction 

func (p *SubProcess) NextAction(T) chan IAction

func (*SubProcess) RegisterEventConsumer 

func (p *SubProcess) RegisterEventConsumer(ev event.IConsumer) (err error)

func (*SubProcess) Type 

func (p *SubProcess) Type() Type

type T 

type T interface {
	// Id returns flow's unique identifier
	Id() id.Id
	// SequenceFlow returns an inbound sequence flow this flow
	// is currently at.
	SequenceFlow() *SequenceFlow
}

T specifies an interface for BPMN flows

type Task 

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

func (*Task) Cancel 

func (task *Task) Cancel() <-chan bool

func (*Task) Element 

func (task *Task) Element() schema.FlowNodeInterface

func (*Task) NextAction 

func (task *Task) NextAction(T) chan IAction

func (*Task) Type 

func (task *Task) Type() Type

type TaskTrace 

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

TaskTrace describes common channel handler for all tasks

func (*TaskTrace) Context 

func (t *TaskTrace) Context() context.Context

func (*TaskTrace) Do 

func (t *TaskTrace) Do(options ...DoOption)

func (*TaskTrace) Element 

func (t *TaskTrace) Element() any

func (*TaskTrace) GetActivity 

func (t *TaskTrace) GetActivity() Activity

func (*TaskTrace) GetDataObjects 

func (t *TaskTrace) GetDataObjects() map[string]any

func (*TaskTrace) GetHeaders 

func (t *TaskTrace) GetHeaders() map[string]any

func (*TaskTrace) GetProperties 

func (t *TaskTrace) GetProperties() map[string]any

type TaskTraceBuilder 

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

func NewTaskTraceBuilder 

func NewTaskTraceBuilder() *TaskTraceBuilder

func (*TaskTraceBuilder) Activity 

func (b *TaskTraceBuilder) Activity(activity Activity) *TaskTraceBuilder

func (*TaskTraceBuilder) Build 

func (b *TaskTraceBuilder) Build() *TaskTrace

func (*TaskTraceBuilder) Context 

func (b *TaskTraceBuilder) Context(ctx context.Context) *TaskTraceBuilder

func (*TaskTraceBuilder) DataObjects 

func (b *TaskTraceBuilder) DataObjects(dataObjects map[string]any) *TaskTraceBuilder

func (*TaskTraceBuilder) Headers 

func (b *TaskTraceBuilder) Headers(headers map[string]any) *TaskTraceBuilder

func (*TaskTraceBuilder) Properties 

func (b *TaskTraceBuilder) Properties(properties map[string]any) *TaskTraceBuilder

func (*TaskTraceBuilder) Timeout added in v2.0.2 

func (b *TaskTraceBuilder) Timeout(timeout time.Duration) *TaskTraceBuilder

func (*TaskTraceBuilder) Value 

func (b *TaskTraceBuilder) Value(key, value any) *TaskTraceBuilder

type Terminate 

type Terminate func(sequenceFlowId *schema.IdRef) chan bool

type TerminationTrace 

type TerminationTrace struct {
	FlowId id.Id
	Source schema.FlowNodeInterface
}

func (TerminationTrace) Element 

func (t TerminationTrace) Element() any

type Type 

type Type string
const (
	TaskType         Type = "Task"
	ServiceType      Type = "ServiceTask"
	ScriptType       Type = "ScriptTask"
	UserType         Type = "UserTask"
	ManualType       Type = "ManualTask"
	CallType         Type = "CallActivity"
	BusinessRuleType Type = "BusinessRuleTask"
	SendType         Type = "SendTask"
	ReceiveType      Type = "ReceiveTask"
	SubprocessType   Type = "Subprocess"
)

type TypeKey 

type TypeKey struct{}

type UserTask 

type UserTask struct {
	*Wiring
	// contains filtered or unexported fields
}

func (*UserTask) Cancel 

func (task *UserTask) Cancel() <-chan bool

func (*UserTask) Element 

func (task *UserTask) Element() schema.FlowNodeInterface

func (*UserTask) NextAction 

func (task *UserTask) NextAction(t T) chan IAction

func (*UserTask) Type 

func (task *UserTask) Type() Type

type VisitTrace 

type VisitTrace struct {
	Node schema.FlowNodeInterface
}

func (VisitTrace) Element 

func (t VisitTrace) Element() any

type Wiring 

type Wiring struct {
	ProcessInstanceId              id.Id
	FlowNodeId                     schema.Id
	Definitions                    *schema.Definitions
	Incoming                       []SequenceFlow
	Outgoing                       []SequenceFlow
	EventIngress                   event.IConsumer
	EventEgress                    event.ISource
	Tracer                         tracing.ITracer
	Process                        schema.Element
	FlowNodeMapping                *FlowNodeMapping
	FlowWaitGroup                  *sync.WaitGroup
	EventDefinitionInstanceBuilder event.IDefinitionInstanceBuilder
	Locator                        data.IFlowDataLocator
}

Wiring holds all necessary "wiring" for functioning of flow nodes: definitions, process, sequence flow, event management, tracer, flow node mapping and a flow wait group

func NewWiring 

func NewWiring(
	processInstanceId id.Id,
	process schema.Element,
	definitions *schema.Definitions,
	flowNode *schema.FlowNode,
	eventIngress event.IConsumer,
	eventEgress event.ISource,
	tracer tracing.ITracer,
	flowNodeMapping *FlowNodeMapping,
	flowWaitGroup *sync.WaitGroup,
	eventDefinitionInstanceBuilder event.IDefinitionInstanceBuilder,
	locator data.IFlowDataLocator,
) (node *Wiring, err error)

func (*Wiring) CloneFor 

func (wiring *Wiring) CloneFor(flowNode *schema.FlowNode) (result *Wiring, err error)

CloneFor copies receiver, overriding FlowNodeId, Incoming, Outgoing for a given flowNode

Source Files

View all Source files

Directories

Path Synopsis
examples
basic command
properties command
subprocess command
user_task command
pkg
clock
data
errors
event
expression
expression/expr
expression/xpath
id
logic
Package logic provides commonly shared "logic units" (or algorithms)
 Package logic provides commonly shared "logic units" (or algorithms)
timer
tracing
Package tracing is a capability to get an ordered stream of structured records of what has happened.
 Package tracing is a capability to get an ordered stream of structured records of what has happened.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.