Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

mocks

package

Go to main page

Versions in this module

v1

v1.1.129

Sep 29, 2023

v1.1.128

Sep 29, 2023

v1.1.127

Sep 26, 2023

v1.1.126

Sep 22, 2023

v1.1.125

Sep 19, 2023

v1.1.124

Sep 12, 2023

v1.1.123

Sep 11, 2023

v1.1.122

Sep 11, 2023

v1.1.121

Sep 11, 2023

v1.1.120

Aug 30, 2023

v1.1.119

Aug 23, 2023

v1.1.118

Aug 22, 2023

v1.1.117

Aug 14, 2023

Changes in this version

+ type CacheableNodeHandler struct

+ func (_m *CacheableNodeHandler) Abort(ctx context.Context, executionContext interfaces.NodeExecutionContext, ...) error

+ func (_m *CacheableNodeHandler) Finalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) error

+ func (_m *CacheableNodeHandler) FinalizeRequired() bool

+ func (_m *CacheableNodeHandler) GetCatalogKey(ctx context.Context, executionContext interfaces.NodeExecutionContext) (catalog.Key, error)

+ func (_m *CacheableNodeHandler) Handle(ctx context.Context, executionContext interfaces.NodeExecutionContext) (handler.Transition, error)

+ func (_m *CacheableNodeHandler) IsCacheable(ctx context.Context, executionContext interfaces.NodeExecutionContext) (bool, bool, error)

+ func (_m *CacheableNodeHandler) OnAbort(ctx context.Context, executionContext interfaces.NodeExecutionContext, ...) *CacheableNodeHandler_Abort

+ func (_m *CacheableNodeHandler) OnAbortMatch(matchers ...interface{}) *CacheableNodeHandler_Abort

+ func (_m *CacheableNodeHandler) OnFinalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_Finalize

+ func (_m *CacheableNodeHandler) OnFinalizeMatch(matchers ...interface{}) *CacheableNodeHandler_Finalize

+ func (_m *CacheableNodeHandler) OnFinalizeRequired() *CacheableNodeHandler_FinalizeRequired

+ func (_m *CacheableNodeHandler) OnFinalizeRequiredMatch(matchers ...interface{}) *CacheableNodeHandler_FinalizeRequired

+ func (_m *CacheableNodeHandler) OnGetCatalogKey(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_GetCatalogKey

+ func (_m *CacheableNodeHandler) OnGetCatalogKeyMatch(matchers ...interface{}) *CacheableNodeHandler_GetCatalogKey

+ func (_m *CacheableNodeHandler) OnHandle(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_Handle

+ func (_m *CacheableNodeHandler) OnHandleMatch(matchers ...interface{}) *CacheableNodeHandler_Handle

+ func (_m *CacheableNodeHandler) OnIsCacheable(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_IsCacheable

+ func (_m *CacheableNodeHandler) OnIsCacheableMatch(matchers ...interface{}) *CacheableNodeHandler_IsCacheable

+ func (_m *CacheableNodeHandler) OnSetup(ctx context.Context, setupContext interfaces.SetupContext) *CacheableNodeHandler_Setup

+ func (_m *CacheableNodeHandler) OnSetupMatch(matchers ...interface{}) *CacheableNodeHandler_Setup

+ func (_m *CacheableNodeHandler) Setup(ctx context.Context, setupContext interfaces.SetupContext) error

+ type CacheableNodeHandler_Abort struct

+ func (_m CacheableNodeHandler_Abort) Return(_a0 error) *CacheableNodeHandler_Abort

+ type CacheableNodeHandler_Finalize struct

+ func (_m CacheableNodeHandler_Finalize) Return(_a0 error) *CacheableNodeHandler_Finalize

+ type CacheableNodeHandler_FinalizeRequired struct

+ func (_m CacheableNodeHandler_FinalizeRequired) Return(_a0 bool) *CacheableNodeHandler_FinalizeRequired

+ type CacheableNodeHandler_GetCatalogKey struct

+ func (_m CacheableNodeHandler_GetCatalogKey) Return(_a0 catalog.Key, _a1 error) *CacheableNodeHandler_GetCatalogKey

+ type CacheableNodeHandler_Handle struct

+ func (_m CacheableNodeHandler_Handle) Return(_a0 handler.Transition, _a1 error) *CacheableNodeHandler_Handle

+ type CacheableNodeHandler_IsCacheable struct

+ func (_m CacheableNodeHandler_IsCacheable) Return(_a0 bool, _a1 bool, _a2 error) *CacheableNodeHandler_IsCacheable

+ type CacheableNodeHandler_Setup struct

+ func (_m CacheableNodeHandler_Setup) Return(_a0 error) *CacheableNodeHandler_Setup

v1.1.116

Aug 8, 2023

v1.1.115

Aug 8, 2023

v1.1.114

Aug 8, 2023

v1.1.113

Aug 6, 2023

v1.1.112

Aug 4, 2023

v1.1.111

Aug 3, 2023

Changes in this version

+ type EventRecorder struct

+ func (_m *EventRecorder) OnRecordNodeEvent(ctx context.Context, _a1 *event.NodeExecutionEvent, ...) *EventRecorder_RecordNodeEvent

+ func (_m *EventRecorder) OnRecordNodeEventMatch(matchers ...interface{}) *EventRecorder_RecordNodeEvent

+ func (_m *EventRecorder) OnRecordTaskEvent(ctx context.Context, _a1 *event.TaskExecutionEvent, ...) *EventRecorder_RecordTaskEvent

+ func (_m *EventRecorder) OnRecordTaskEventMatch(matchers ...interface{}) *EventRecorder_RecordTaskEvent

+ func (_m *EventRecorder) RecordNodeEvent(ctx context.Context, _a1 *event.NodeExecutionEvent, ...) error

+ func (_m *EventRecorder) RecordTaskEvent(ctx context.Context, _a1 *event.TaskExecutionEvent, ...) error

+ type EventRecorder_RecordNodeEvent struct

+ func (_m EventRecorder_RecordNodeEvent) Return(_a0 error) *EventRecorder_RecordNodeEvent

+ type EventRecorder_RecordTaskEvent struct

+ func (_m EventRecorder_RecordTaskEvent) Return(_a0 error) *EventRecorder_RecordTaskEvent

+ type HandlerFactory struct

+ func (_m *HandlerFactory) GetHandler(kind v1alpha1.NodeKind) (interfaces.NodeHandler, error)

+ func (_m *HandlerFactory) OnGetHandler(kind v1alpha1.NodeKind) *HandlerFactory_GetHandler

+ func (_m *HandlerFactory) OnGetHandlerMatch(matchers ...interface{}) *HandlerFactory_GetHandler

+ func (_m *HandlerFactory) OnSetup(ctx context.Context, executor interfaces.Node, setup interfaces.SetupContext) *HandlerFactory_Setup

+ func (_m *HandlerFactory) OnSetupMatch(matchers ...interface{}) *HandlerFactory_Setup

+ func (_m *HandlerFactory) Setup(ctx context.Context, executor interfaces.Node, setup interfaces.SetupContext) error

+ type HandlerFactory_GetHandler struct

+ func (_m HandlerFactory_GetHandler) Return(_a0 interfaces.NodeHandler, _a1 error) *HandlerFactory_GetHandler

+ type HandlerFactory_Setup struct

+ func (_m HandlerFactory_Setup) Return(_a0 error) *HandlerFactory_Setup

+ type Node struct

+ func (_m *Node) AbortHandler(ctx context.Context, execContext executors.ExecutionContext, ...) error

+ func (_m *Node) FinalizeHandler(ctx context.Context, execContext executors.ExecutionContext, ...) error

+ func (_m *Node) GetNodeExecutionContextBuilder() interfaces.NodeExecutionContextBuilder

+ func (_m *Node) Initialize(ctx context.Context) error

+ func (_m *Node) OnAbortHandler(ctx context.Context, execContext executors.ExecutionContext, ...) *Node_AbortHandler

+ func (_m *Node) OnAbortHandlerMatch(matchers ...interface{}) *Node_AbortHandler

+ func (_m *Node) OnFinalizeHandler(ctx context.Context, execContext executors.ExecutionContext, ...) *Node_FinalizeHandler

+ func (_m *Node) OnFinalizeHandlerMatch(matchers ...interface{}) *Node_FinalizeHandler

+ func (_m *Node) OnGetNodeExecutionContextBuilder() *Node_GetNodeExecutionContextBuilder

+ func (_m *Node) OnGetNodeExecutionContextBuilderMatch(matchers ...interface{}) *Node_GetNodeExecutionContextBuilder

+ func (_m *Node) OnInitialize(ctx context.Context) *Node_Initialize

+ func (_m *Node) OnInitializeMatch(matchers ...interface{}) *Node_Initialize

+ func (_m *Node) OnRecursiveNodeHandler(ctx context.Context, execContext executors.ExecutionContext, ...) *Node_RecursiveNodeHandler

+ func (_m *Node) OnRecursiveNodeHandlerMatch(matchers ...interface{}) *Node_RecursiveNodeHandler

+ func (_m *Node) OnSetInputsForStartNode(ctx context.Context, execContext executors.ExecutionContext, ...) *Node_SetInputsForStartNode

+ func (_m *Node) OnSetInputsForStartNodeMatch(matchers ...interface{}) *Node_SetInputsForStartNode

+ func (_m *Node) OnWithNodeExecutionContextBuilder(_a0 interfaces.NodeExecutionContextBuilder) *Node_WithNodeExecutionContextBuilder

+ func (_m *Node) OnWithNodeExecutionContextBuilderMatch(matchers ...interface{}) *Node_WithNodeExecutionContextBuilder

+ func (_m *Node) RecursiveNodeHandler(ctx context.Context, execContext executors.ExecutionContext, ...) (interfaces.NodeStatus, error)

+ func (_m *Node) SetInputsForStartNode(ctx context.Context, execContext executors.ExecutionContext, ...) (interfaces.NodeStatus, error)

+ func (_m *Node) WithNodeExecutionContextBuilder(_a0 interfaces.NodeExecutionContextBuilder) interfaces.Node

+ type NodeExecutionContext struct

+ func (_m *NodeExecutionContext) ContextualNodeLookup() executors.NodeLookup

+ func (_m *NodeExecutionContext) CurrentAttempt() uint32

+ func (_m *NodeExecutionContext) DataStore() *storage.DataStore

+ func (_m *NodeExecutionContext) EnqueueOwnerFunc() func() error

+ func (_m *NodeExecutionContext) EventsRecorder() interfaces.EventRecorder

+ func (_m *NodeExecutionContext) ExecutionContext() executors.ExecutionContext

+ func (_m *NodeExecutionContext) InputReader() io.InputReader

+ func (_m *NodeExecutionContext) MaxDatasetSizeBytes() int64

+ func (_m *NodeExecutionContext) Node() v1alpha1.ExecutableNode

+ func (_m *NodeExecutionContext) NodeExecutionMetadata() interfaces.NodeExecutionMetadata

+ func (_m *NodeExecutionContext) NodeID() string

+ func (_m *NodeExecutionContext) NodeStateReader() interfaces.NodeStateReader

+ func (_m *NodeExecutionContext) NodeStateWriter() interfaces.NodeStateWriter

+ func (_m *NodeExecutionContext) NodeStatus() v1alpha1.ExecutableNodeStatus

+ func (_m *NodeExecutionContext) OnContextualNodeLookup() *NodeExecutionContext_ContextualNodeLookup

+ func (_m *NodeExecutionContext) OnContextualNodeLookupMatch(matchers ...interface{}) *NodeExecutionContext_ContextualNodeLookup

+ func (_m *NodeExecutionContext) OnCurrentAttempt() *NodeExecutionContext_CurrentAttempt

+ func (_m *NodeExecutionContext) OnCurrentAttemptMatch(matchers ...interface{}) *NodeExecutionContext_CurrentAttempt

+ func (_m *NodeExecutionContext) OnDataStore() *NodeExecutionContext_DataStore

+ func (_m *NodeExecutionContext) OnDataStoreMatch(matchers ...interface{}) *NodeExecutionContext_DataStore

+ func (_m *NodeExecutionContext) OnEnqueueOwnerFunc() *NodeExecutionContext_EnqueueOwnerFunc

+ func (_m *NodeExecutionContext) OnEnqueueOwnerFuncMatch(matchers ...interface{}) *NodeExecutionContext_EnqueueOwnerFunc

+ func (_m *NodeExecutionContext) OnEventsRecorder() *NodeExecutionContext_EventsRecorder

+ func (_m *NodeExecutionContext) OnEventsRecorderMatch(matchers ...interface{}) *NodeExecutionContext_EventsRecorder

+ func (_m *NodeExecutionContext) OnExecutionContext() *NodeExecutionContext_ExecutionContext

+ func (_m *NodeExecutionContext) OnExecutionContextMatch(matchers ...interface{}) *NodeExecutionContext_ExecutionContext

+ func (_m *NodeExecutionContext) OnInputReader() *NodeExecutionContext_InputReader

+ func (_m *NodeExecutionContext) OnInputReaderMatch(matchers ...interface{}) *NodeExecutionContext_InputReader

+ func (_m *NodeExecutionContext) OnMaxDatasetSizeBytes() *NodeExecutionContext_MaxDatasetSizeBytes

+ func (_m *NodeExecutionContext) OnMaxDatasetSizeBytesMatch(matchers ...interface{}) *NodeExecutionContext_MaxDatasetSizeBytes

+ func (_m *NodeExecutionContext) OnNode() *NodeExecutionContext_Node

+ func (_m *NodeExecutionContext) OnNodeExecutionMetadata() *NodeExecutionContext_NodeExecutionMetadata

+ func (_m *NodeExecutionContext) OnNodeExecutionMetadataMatch(matchers ...interface{}) *NodeExecutionContext_NodeExecutionMetadata

+ func (_m *NodeExecutionContext) OnNodeID() *NodeExecutionContext_NodeID

+ func (_m *NodeExecutionContext) OnNodeIDMatch(matchers ...interface{}) *NodeExecutionContext_NodeID

+ func (_m *NodeExecutionContext) OnNodeMatch(matchers ...interface{}) *NodeExecutionContext_Node

+ func (_m *NodeExecutionContext) OnNodeStateReader() *NodeExecutionContext_NodeStateReader

+ func (_m *NodeExecutionContext) OnNodeStateReaderMatch(matchers ...interface{}) *NodeExecutionContext_NodeStateReader

+ func (_m *NodeExecutionContext) OnNodeStateWriter() *NodeExecutionContext_NodeStateWriter

+ func (_m *NodeExecutionContext) OnNodeStateWriterMatch(matchers ...interface{}) *NodeExecutionContext_NodeStateWriter

+ func (_m *NodeExecutionContext) OnNodeStatus() *NodeExecutionContext_NodeStatus

+ func (_m *NodeExecutionContext) OnNodeStatusMatch(matchers ...interface{}) *NodeExecutionContext_NodeStatus

+ func (_m *NodeExecutionContext) OnOutputShardSelector() *NodeExecutionContext_OutputShardSelector

+ func (_m *NodeExecutionContext) OnOutputShardSelectorMatch(matchers ...interface{}) *NodeExecutionContext_OutputShardSelector

+ func (_m *NodeExecutionContext) OnRawOutputPrefix() *NodeExecutionContext_RawOutputPrefix

+ func (_m *NodeExecutionContext) OnRawOutputPrefixMatch(matchers ...interface{}) *NodeExecutionContext_RawOutputPrefix

+ func (_m *NodeExecutionContext) OnTaskReader() *NodeExecutionContext_TaskReader

+ func (_m *NodeExecutionContext) OnTaskReaderMatch(matchers ...interface{}) *NodeExecutionContext_TaskReader

+ func (_m *NodeExecutionContext) OutputShardSelector() ioutils.ShardSelector

+ func (_m *NodeExecutionContext) RawOutputPrefix() storage.DataReference

+ func (_m *NodeExecutionContext) TaskReader() interfaces.TaskReader

+ type NodeExecutionContextBuilder struct

+ func (_m *NodeExecutionContextBuilder) BuildNodeExecutionContext(ctx context.Context, executionContext executors.ExecutionContext, ...) (interfaces.NodeExecutionContext, error)

+ func (_m *NodeExecutionContextBuilder) OnBuildNodeExecutionContext(ctx context.Context, executionContext executors.ExecutionContext, ...) *NodeExecutionContextBuilder_BuildNodeExecutionContext

+ func (_m *NodeExecutionContextBuilder) OnBuildNodeExecutionContextMatch(matchers ...interface{}) *NodeExecutionContextBuilder_BuildNodeExecutionContext

+ type NodeExecutionContextBuilder_BuildNodeExecutionContext struct

+ func (_m NodeExecutionContextBuilder_BuildNodeExecutionContext) Return(_a0 interfaces.NodeExecutionContext, _a1 error) *NodeExecutionContextBuilder_BuildNodeExecutionContext

+ type NodeExecutionContext_ContextualNodeLookup struct

+ func (_m NodeExecutionContext_ContextualNodeLookup) Return(_a0 executors.NodeLookup) *NodeExecutionContext_ContextualNodeLookup

+ type NodeExecutionContext_CurrentAttempt struct

+ func (_m NodeExecutionContext_CurrentAttempt) Return(_a0 uint32) *NodeExecutionContext_CurrentAttempt

+ type NodeExecutionContext_DataStore struct

+ func (_m NodeExecutionContext_DataStore) Return(_a0 *storage.DataStore) *NodeExecutionContext_DataStore

+ type NodeExecutionContext_EnqueueOwnerFunc struct

+ func (_m NodeExecutionContext_EnqueueOwnerFunc) Return(_a0 func() error) *NodeExecutionContext_EnqueueOwnerFunc

+ type NodeExecutionContext_EventsRecorder struct

+ func (_m NodeExecutionContext_EventsRecorder) Return(_a0 interfaces.EventRecorder) *NodeExecutionContext_EventsRecorder

+ type NodeExecutionContext_ExecutionContext struct

+ func (_m NodeExecutionContext_ExecutionContext) Return(_a0 executors.ExecutionContext) *NodeExecutionContext_ExecutionContext

+ type NodeExecutionContext_InputReader struct

+ func (_m NodeExecutionContext_InputReader) Return(_a0 io.InputReader) *NodeExecutionContext_InputReader

+ type NodeExecutionContext_MaxDatasetSizeBytes struct

+ func (_m NodeExecutionContext_MaxDatasetSizeBytes) Return(_a0 int64) *NodeExecutionContext_MaxDatasetSizeBytes

+ type NodeExecutionContext_Node struct

+ func (_m NodeExecutionContext_Node) Return(_a0 v1alpha1.ExecutableNode) *NodeExecutionContext_Node

+ type NodeExecutionContext_NodeExecutionMetadata struct

+ func (_m NodeExecutionContext_NodeExecutionMetadata) Return(_a0 interfaces.NodeExecutionMetadata) *NodeExecutionContext_NodeExecutionMetadata

+ type NodeExecutionContext_NodeID struct

+ func (_m NodeExecutionContext_NodeID) Return(_a0 string) *NodeExecutionContext_NodeID

+ type NodeExecutionContext_NodeStateReader struct

+ func (_m NodeExecutionContext_NodeStateReader) Return(_a0 interfaces.NodeStateReader) *NodeExecutionContext_NodeStateReader

+ type NodeExecutionContext_NodeStateWriter struct

+ func (_m NodeExecutionContext_NodeStateWriter) Return(_a0 interfaces.NodeStateWriter) *NodeExecutionContext_NodeStateWriter

+ type NodeExecutionContext_NodeStatus struct

+ func (_m NodeExecutionContext_NodeStatus) Return(_a0 v1alpha1.ExecutableNodeStatus) *NodeExecutionContext_NodeStatus

+ type NodeExecutionContext_OutputShardSelector struct

+ func (_m NodeExecutionContext_OutputShardSelector) Return(_a0 ioutils.ShardSelector) *NodeExecutionContext_OutputShardSelector

+ type NodeExecutionContext_RawOutputPrefix struct

+ func (_m NodeExecutionContext_RawOutputPrefix) Return(_a0 storage.DataReference) *NodeExecutionContext_RawOutputPrefix

+ type NodeExecutionContext_TaskReader struct

+ func (_m NodeExecutionContext_TaskReader) Return(_a0 interfaces.TaskReader) *NodeExecutionContext_TaskReader

+ type NodeExecutionMetadata struct

+ func (_m *NodeExecutionMetadata) GetAnnotations() map[string]string

+ func (_m *NodeExecutionMetadata) GetInterruptibleFailureThreshold() uint32

+ func (_m *NodeExecutionMetadata) GetK8sServiceAccount() string

+ func (_m *NodeExecutionMetadata) GetLabels() map[string]string

+ func (_m *NodeExecutionMetadata) GetNamespace() string

+ func (_m *NodeExecutionMetadata) GetNodeExecutionID() *core.NodeExecutionIdentifier

+ func (_m *NodeExecutionMetadata) GetOwnerID() types.NamespacedName

+ func (_m *NodeExecutionMetadata) GetOwnerReference() v1.OwnerReference

+ func (_m *NodeExecutionMetadata) GetSecurityContext() core.SecurityContext

+ func (_m *NodeExecutionMetadata) IsInterruptible() bool

+ func (_m *NodeExecutionMetadata) OnGetAnnotations() *NodeExecutionMetadata_GetAnnotations

+ func (_m *NodeExecutionMetadata) OnGetAnnotationsMatch(matchers ...interface{}) *NodeExecutionMetadata_GetAnnotations

+ func (_m *NodeExecutionMetadata) OnGetInterruptibleFailureThreshold() *NodeExecutionMetadata_GetInterruptibleFailureThreshold

+ func (_m *NodeExecutionMetadata) OnGetInterruptibleFailureThresholdMatch(matchers ...interface{}) *NodeExecutionMetadata_GetInterruptibleFailureThreshold

+ func (_m *NodeExecutionMetadata) OnGetK8sServiceAccount() *NodeExecutionMetadata_GetK8sServiceAccount

+ func (_m *NodeExecutionMetadata) OnGetK8sServiceAccountMatch(matchers ...interface{}) *NodeExecutionMetadata_GetK8sServiceAccount

+ func (_m *NodeExecutionMetadata) OnGetLabels() *NodeExecutionMetadata_GetLabels

+ func (_m *NodeExecutionMetadata) OnGetLabelsMatch(matchers ...interface{}) *NodeExecutionMetadata_GetLabels

+ func (_m *NodeExecutionMetadata) OnGetNamespace() *NodeExecutionMetadata_GetNamespace

+ func (_m *NodeExecutionMetadata) OnGetNamespaceMatch(matchers ...interface{}) *NodeExecutionMetadata_GetNamespace

+ func (_m *NodeExecutionMetadata) OnGetNodeExecutionID() *NodeExecutionMetadata_GetNodeExecutionID

+ func (_m *NodeExecutionMetadata) OnGetNodeExecutionIDMatch(matchers ...interface{}) *NodeExecutionMetadata_GetNodeExecutionID

+ func (_m *NodeExecutionMetadata) OnGetOwnerID() *NodeExecutionMetadata_GetOwnerID

+ func (_m *NodeExecutionMetadata) OnGetOwnerIDMatch(matchers ...interface{}) *NodeExecutionMetadata_GetOwnerID

+ func (_m *NodeExecutionMetadata) OnGetOwnerReference() *NodeExecutionMetadata_GetOwnerReference

+ func (_m *NodeExecutionMetadata) OnGetOwnerReferenceMatch(matchers ...interface{}) *NodeExecutionMetadata_GetOwnerReference

+ func (_m *NodeExecutionMetadata) OnGetSecurityContext() *NodeExecutionMetadata_GetSecurityContext

+ func (_m *NodeExecutionMetadata) OnGetSecurityContextMatch(matchers ...interface{}) *NodeExecutionMetadata_GetSecurityContext

+ func (_m *NodeExecutionMetadata) OnIsInterruptible() *NodeExecutionMetadata_IsInterruptible

+ func (_m *NodeExecutionMetadata) OnIsInterruptibleMatch(matchers ...interface{}) *NodeExecutionMetadata_IsInterruptible

+ type NodeExecutionMetadata_GetAnnotations struct

+ func (_m NodeExecutionMetadata_GetAnnotations) Return(_a0 map[string]string) *NodeExecutionMetadata_GetAnnotations

+ type NodeExecutionMetadata_GetInterruptibleFailureThreshold struct

+ func (_m NodeExecutionMetadata_GetInterruptibleFailureThreshold) Return(_a0 uint32) *NodeExecutionMetadata_GetInterruptibleFailureThreshold

+ type NodeExecutionMetadata_GetK8sServiceAccount struct

+ func (_m NodeExecutionMetadata_GetK8sServiceAccount) Return(_a0 string) *NodeExecutionMetadata_GetK8sServiceAccount

+ type NodeExecutionMetadata_GetLabels struct

+ func (_m NodeExecutionMetadata_GetLabels) Return(_a0 map[string]string) *NodeExecutionMetadata_GetLabels

+ type NodeExecutionMetadata_GetNamespace struct

+ func (_m NodeExecutionMetadata_GetNamespace) Return(_a0 string) *NodeExecutionMetadata_GetNamespace

+ type NodeExecutionMetadata_GetNodeExecutionID struct

+ func (_m NodeExecutionMetadata_GetNodeExecutionID) Return(_a0 *core.NodeExecutionIdentifier) *NodeExecutionMetadata_GetNodeExecutionID

+ type NodeExecutionMetadata_GetOwnerID struct

+ func (_m NodeExecutionMetadata_GetOwnerID) Return(_a0 types.NamespacedName) *NodeExecutionMetadata_GetOwnerID

+ type NodeExecutionMetadata_GetOwnerReference struct

+ func (_m NodeExecutionMetadata_GetOwnerReference) Return(_a0 v1.OwnerReference) *NodeExecutionMetadata_GetOwnerReference

+ type NodeExecutionMetadata_GetSecurityContext struct

+ func (_m NodeExecutionMetadata_GetSecurityContext) Return(_a0 core.SecurityContext) *NodeExecutionMetadata_GetSecurityContext

+ type NodeExecutionMetadata_IsInterruptible struct

+ func (_m NodeExecutionMetadata_IsInterruptible) Return(_a0 bool) *NodeExecutionMetadata_IsInterruptible

+ type NodeExecutor struct

+ func (_m *NodeExecutor) Abort(ctx context.Context, h interfaces.NodeHandler, ...) error

+ func (_m *NodeExecutor) Finalize(ctx context.Context, h interfaces.NodeHandler, ...) error

+ func (_m *NodeExecutor) HandleNode(ctx context.Context, dag executors.DAGStructure, ...) (interfaces.NodeStatus, error)

+ func (_m *NodeExecutor) OnAbort(ctx context.Context, h interfaces.NodeHandler, ...) *NodeExecutor_Abort

+ func (_m *NodeExecutor) OnAbortMatch(matchers ...interface{}) *NodeExecutor_Abort

+ func (_m *NodeExecutor) OnFinalize(ctx context.Context, h interfaces.NodeHandler, ...) *NodeExecutor_Finalize

+ func (_m *NodeExecutor) OnFinalizeMatch(matchers ...interface{}) *NodeExecutor_Finalize

+ func (_m *NodeExecutor) OnHandleNode(ctx context.Context, dag executors.DAGStructure, ...) *NodeExecutor_HandleNode

+ func (_m *NodeExecutor) OnHandleNodeMatch(matchers ...interface{}) *NodeExecutor_HandleNode

+ type NodeExecutor_Abort struct

+ func (_m NodeExecutor_Abort) Return(_a0 error) *NodeExecutor_Abort

+ type NodeExecutor_Finalize struct

+ func (_m NodeExecutor_Finalize) Return(_a0 error) *NodeExecutor_Finalize

+ type NodeExecutor_HandleNode struct

+ func (_m NodeExecutor_HandleNode) Return(_a0 interfaces.NodeStatus, _a1 error) *NodeExecutor_HandleNode

+ type NodeHandler struct

+ func (_m *NodeHandler) Abort(ctx context.Context, executionContext interfaces.NodeExecutionContext, ...) error

+ func (_m *NodeHandler) Finalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) error

+ func (_m *NodeHandler) FinalizeRequired() bool

+ func (_m *NodeHandler) Handle(ctx context.Context, executionContext interfaces.NodeExecutionContext) (handler.Transition, error)

+ func (_m *NodeHandler) OnAbort(ctx context.Context, executionContext interfaces.NodeExecutionContext, ...) *NodeHandler_Abort

+ func (_m *NodeHandler) OnAbortMatch(matchers ...interface{}) *NodeHandler_Abort

+ func (_m *NodeHandler) OnFinalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) *NodeHandler_Finalize

+ func (_m *NodeHandler) OnFinalizeMatch(matchers ...interface{}) *NodeHandler_Finalize

+ func (_m *NodeHandler) OnFinalizeRequired() *NodeHandler_FinalizeRequired

+ func (_m *NodeHandler) OnFinalizeRequiredMatch(matchers ...interface{}) *NodeHandler_FinalizeRequired

+ func (_m *NodeHandler) OnHandle(ctx context.Context, executionContext interfaces.NodeExecutionContext) *NodeHandler_Handle

+ func (_m *NodeHandler) OnHandleMatch(matchers ...interface{}) *NodeHandler_Handle

+ func (_m *NodeHandler) OnSetup(ctx context.Context, setupContext interfaces.SetupContext) *NodeHandler_Setup

+ func (_m *NodeHandler) OnSetupMatch(matchers ...interface{}) *NodeHandler_Setup

+ func (_m *NodeHandler) Setup(ctx context.Context, setupContext interfaces.SetupContext) error

+ type NodeHandler_Abort struct

+ func (_m NodeHandler_Abort) Return(_a0 error) *NodeHandler_Abort

+ type NodeHandler_Finalize struct

+ func (_m NodeHandler_Finalize) Return(_a0 error) *NodeHandler_Finalize

+ type NodeHandler_FinalizeRequired struct

+ func (_m NodeHandler_FinalizeRequired) Return(_a0 bool) *NodeHandler_FinalizeRequired

+ type NodeHandler_Handle struct

+ func (_m NodeHandler_Handle) Return(_a0 handler.Transition, _a1 error) *NodeHandler_Handle

+ type NodeHandler_Setup struct

+ func (_m NodeHandler_Setup) Return(_a0 error) *NodeHandler_Setup

+ type NodeStateReader struct

+ func (_m *NodeStateReader) GetArrayNodeState() handler.ArrayNodeState

+ func (_m *NodeStateReader) GetBranchNodeState() handler.BranchNodeState

+ func (_m *NodeStateReader) GetDynamicNodeState() handler.DynamicNodeState

+ func (_m *NodeStateReader) GetGateNodeState() handler.GateNodeState

+ func (_m *NodeStateReader) GetTaskNodeState() handler.TaskNodeState

+ func (_m *NodeStateReader) GetWorkflowNodeState() handler.WorkflowNodeState

+ func (_m *NodeStateReader) HasArrayNodeState() bool

+ func (_m *NodeStateReader) HasBranchNodeState() bool

+ func (_m *NodeStateReader) HasDynamicNodeState() bool

+ func (_m *NodeStateReader) HasGateNodeState() bool

+ func (_m *NodeStateReader) HasTaskNodeState() bool

+ func (_m *NodeStateReader) HasWorkflowNodeState() bool

+ func (_m *NodeStateReader) OnGetArrayNodeState() *NodeStateReader_GetArrayNodeState

+ func (_m *NodeStateReader) OnGetArrayNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetArrayNodeState

+ func (_m *NodeStateReader) OnGetBranchNodeState() *NodeStateReader_GetBranchNodeState

+ func (_m *NodeStateReader) OnGetBranchNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetBranchNodeState

+ func (_m *NodeStateReader) OnGetDynamicNodeState() *NodeStateReader_GetDynamicNodeState

+ func (_m *NodeStateReader) OnGetDynamicNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetDynamicNodeState

+ func (_m *NodeStateReader) OnGetGateNodeState() *NodeStateReader_GetGateNodeState

+ func (_m *NodeStateReader) OnGetGateNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetGateNodeState

+ func (_m *NodeStateReader) OnGetTaskNodeState() *NodeStateReader_GetTaskNodeState

+ func (_m *NodeStateReader) OnGetTaskNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetTaskNodeState

+ func (_m *NodeStateReader) OnGetWorkflowNodeState() *NodeStateReader_GetWorkflowNodeState

+ func (_m *NodeStateReader) OnGetWorkflowNodeStateMatch(matchers ...interface{}) *NodeStateReader_GetWorkflowNodeState

+ func (_m *NodeStateReader) OnHasArrayNodeState() *NodeStateReader_HasArrayNodeState

+ func (_m *NodeStateReader) OnHasArrayNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasArrayNodeState

+ func (_m *NodeStateReader) OnHasBranchNodeState() *NodeStateReader_HasBranchNodeState

+ func (_m *NodeStateReader) OnHasBranchNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasBranchNodeState

+ func (_m *NodeStateReader) OnHasDynamicNodeState() *NodeStateReader_HasDynamicNodeState

+ func (_m *NodeStateReader) OnHasDynamicNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasDynamicNodeState

+ func (_m *NodeStateReader) OnHasGateNodeState() *NodeStateReader_HasGateNodeState

+ func (_m *NodeStateReader) OnHasGateNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasGateNodeState

+ func (_m *NodeStateReader) OnHasTaskNodeState() *NodeStateReader_HasTaskNodeState

+ func (_m *NodeStateReader) OnHasTaskNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasTaskNodeState

+ func (_m *NodeStateReader) OnHasWorkflowNodeState() *NodeStateReader_HasWorkflowNodeState

+ func (_m *NodeStateReader) OnHasWorkflowNodeStateMatch(matchers ...interface{}) *NodeStateReader_HasWorkflowNodeState

+ type NodeStateReader_GetArrayNodeState struct

+ func (_m NodeStateReader_GetArrayNodeState) Return(_a0 handler.ArrayNodeState) *NodeStateReader_GetArrayNodeState

+ type NodeStateReader_GetBranchNodeState struct

+ func (_m NodeStateReader_GetBranchNodeState) Return(_a0 handler.BranchNodeState) *NodeStateReader_GetBranchNodeState

+ type NodeStateReader_GetDynamicNodeState struct

+ func (_m NodeStateReader_GetDynamicNodeState) Return(_a0 handler.DynamicNodeState) *NodeStateReader_GetDynamicNodeState

+ type NodeStateReader_GetGateNodeState struct

+ func (_m NodeStateReader_GetGateNodeState) Return(_a0 handler.GateNodeState) *NodeStateReader_GetGateNodeState

+ type NodeStateReader_GetTaskNodeState struct

+ func (_m NodeStateReader_GetTaskNodeState) Return(_a0 handler.TaskNodeState) *NodeStateReader_GetTaskNodeState

+ type NodeStateReader_GetWorkflowNodeState struct

+ func (_m NodeStateReader_GetWorkflowNodeState) Return(_a0 handler.WorkflowNodeState) *NodeStateReader_GetWorkflowNodeState

+ type NodeStateReader_HasArrayNodeState struct

+ func (_m NodeStateReader_HasArrayNodeState) Return(_a0 bool) *NodeStateReader_HasArrayNodeState

+ type NodeStateReader_HasBranchNodeState struct

+ func (_m NodeStateReader_HasBranchNodeState) Return(_a0 bool) *NodeStateReader_HasBranchNodeState

+ type NodeStateReader_HasDynamicNodeState struct

+ func (_m NodeStateReader_HasDynamicNodeState) Return(_a0 bool) *NodeStateReader_HasDynamicNodeState

+ type NodeStateReader_HasGateNodeState struct

+ func (_m NodeStateReader_HasGateNodeState) Return(_a0 bool) *NodeStateReader_HasGateNodeState

+ type NodeStateReader_HasTaskNodeState struct

+ func (_m NodeStateReader_HasTaskNodeState) Return(_a0 bool) *NodeStateReader_HasTaskNodeState

+ type NodeStateReader_HasWorkflowNodeState struct

+ func (_m NodeStateReader_HasWorkflowNodeState) Return(_a0 bool) *NodeStateReader_HasWorkflowNodeState

+ type NodeStateWriter struct

+ func (_m *NodeStateWriter) ClearNodeStatus()

+ func (_m *NodeStateWriter) OnPutArrayNodeState(s handler.ArrayNodeState) *NodeStateWriter_PutArrayNodeState

+ func (_m *NodeStateWriter) OnPutArrayNodeStateMatch(matchers ...interface{}) *NodeStateWriter_PutArrayNodeState

+ func (_m *NodeStateWriter) OnPutBranchNode(s handler.BranchNodeState) *NodeStateWriter_PutBranchNode

+ func (_m *NodeStateWriter) OnPutBranchNodeMatch(matchers ...interface{}) *NodeStateWriter_PutBranchNode

+ func (_m *NodeStateWriter) OnPutDynamicNodeState(s handler.DynamicNodeState) *NodeStateWriter_PutDynamicNodeState

+ func (_m *NodeStateWriter) OnPutDynamicNodeStateMatch(matchers ...interface{}) *NodeStateWriter_PutDynamicNodeState

+ func (_m *NodeStateWriter) OnPutGateNodeState(s handler.GateNodeState) *NodeStateWriter_PutGateNodeState

+ func (_m *NodeStateWriter) OnPutGateNodeStateMatch(matchers ...interface{}) *NodeStateWriter_PutGateNodeState

+ func (_m *NodeStateWriter) OnPutTaskNodeState(s handler.TaskNodeState) *NodeStateWriter_PutTaskNodeState

+ func (_m *NodeStateWriter) OnPutTaskNodeStateMatch(matchers ...interface{}) *NodeStateWriter_PutTaskNodeState

+ func (_m *NodeStateWriter) OnPutWorkflowNodeState(s handler.WorkflowNodeState) *NodeStateWriter_PutWorkflowNodeState

+ func (_m *NodeStateWriter) OnPutWorkflowNodeStateMatch(matchers ...interface{}) *NodeStateWriter_PutWorkflowNodeState

+ func (_m *NodeStateWriter) PutArrayNodeState(s handler.ArrayNodeState) error

+ func (_m *NodeStateWriter) PutBranchNode(s handler.BranchNodeState) error

+ func (_m *NodeStateWriter) PutDynamicNodeState(s handler.DynamicNodeState) error

+ func (_m *NodeStateWriter) PutGateNodeState(s handler.GateNodeState) error

+ func (_m *NodeStateWriter) PutTaskNodeState(s handler.TaskNodeState) error

+ func (_m *NodeStateWriter) PutWorkflowNodeState(s handler.WorkflowNodeState) error

+ type NodeStateWriter_PutArrayNodeState struct

+ func (_m NodeStateWriter_PutArrayNodeState) Return(_a0 error) *NodeStateWriter_PutArrayNodeState

+ type NodeStateWriter_PutBranchNode struct

+ func (_m NodeStateWriter_PutBranchNode) Return(_a0 error) *NodeStateWriter_PutBranchNode

+ type NodeStateWriter_PutDynamicNodeState struct

+ func (_m NodeStateWriter_PutDynamicNodeState) Return(_a0 error) *NodeStateWriter_PutDynamicNodeState

+ type NodeStateWriter_PutGateNodeState struct

+ func (_m NodeStateWriter_PutGateNodeState) Return(_a0 error) *NodeStateWriter_PutGateNodeState

+ type NodeStateWriter_PutTaskNodeState struct

+ func (_m NodeStateWriter_PutTaskNodeState) Return(_a0 error) *NodeStateWriter_PutTaskNodeState

+ type NodeStateWriter_PutWorkflowNodeState struct

+ func (_m NodeStateWriter_PutWorkflowNodeState) Return(_a0 error) *NodeStateWriter_PutWorkflowNodeState

+ type Node_AbortHandler struct

+ func (_m Node_AbortHandler) Return(_a0 error) *Node_AbortHandler

+ type Node_FinalizeHandler struct

+ func (_m Node_FinalizeHandler) Return(_a0 error) *Node_FinalizeHandler

+ type Node_GetNodeExecutionContextBuilder struct

+ func (_m Node_GetNodeExecutionContextBuilder) Return(_a0 interfaces.NodeExecutionContextBuilder) *Node_GetNodeExecutionContextBuilder

+ type Node_Initialize struct

+ func (_m Node_Initialize) Return(_a0 error) *Node_Initialize

+ type Node_RecursiveNodeHandler struct

+ func (_m Node_RecursiveNodeHandler) Return(_a0 interfaces.NodeStatus, _a1 error) *Node_RecursiveNodeHandler

+ type Node_SetInputsForStartNode struct

+ func (_m Node_SetInputsForStartNode) Return(_a0 interfaces.NodeStatus, _a1 error) *Node_SetInputsForStartNode

+ type Node_WithNodeExecutionContextBuilder struct

+ func (_m Node_WithNodeExecutionContextBuilder) Return(_a0 interfaces.Node) *Node_WithNodeExecutionContextBuilder

+ type SetupContext struct

+ func (_m *SetupContext) EnqueueOwner() func(string)

+ func (_m *SetupContext) MetricsScope() promutils.Scope

+ func (_m *SetupContext) OnEnqueueOwner() *SetupContext_EnqueueOwner

+ func (_m *SetupContext) OnEnqueueOwnerMatch(matchers ...interface{}) *SetupContext_EnqueueOwner

+ func (_m *SetupContext) OnMetricsScope() *SetupContext_MetricsScope

+ func (_m *SetupContext) OnMetricsScopeMatch(matchers ...interface{}) *SetupContext_MetricsScope

+ func (_m *SetupContext) OnOwnerKind() *SetupContext_OwnerKind

+ func (_m *SetupContext) OnOwnerKindMatch(matchers ...interface{}) *SetupContext_OwnerKind

+ func (_m *SetupContext) OwnerKind() string

+ type SetupContext_EnqueueOwner struct

+ func (_m SetupContext_EnqueueOwner) Return(_a0 func(string)) *SetupContext_EnqueueOwner

+ type SetupContext_MetricsScope struct

+ func (_m SetupContext_MetricsScope) Return(_a0 promutils.Scope) *SetupContext_MetricsScope

+ type SetupContext_OwnerKind struct

+ func (_m SetupContext_OwnerKind) Return(_a0 string) *SetupContext_OwnerKind

+ type TaskReader struct

+ func (_m *TaskReader) GetTaskID() *core.Identifier

+ func (_m *TaskReader) GetTaskType() string

+ func (_m *TaskReader) OnGetTaskID() *TaskReader_GetTaskID

+ func (_m *TaskReader) OnGetTaskIDMatch(matchers ...interface{}) *TaskReader_GetTaskID

+ func (_m *TaskReader) OnGetTaskType() *TaskReader_GetTaskType

+ func (_m *TaskReader) OnGetTaskTypeMatch(matchers ...interface{}) *TaskReader_GetTaskType

+ func (_m *TaskReader) OnRead(ctx context.Context) *TaskReader_Read

+ func (_m *TaskReader) OnReadMatch(matchers ...interface{}) *TaskReader_Read

+ func (_m *TaskReader) Read(ctx context.Context) (*core.TaskTemplate, error)

+ type TaskReader_GetTaskID struct

+ func (_m TaskReader_GetTaskID) Return(_a0 *core.Identifier) *TaskReader_GetTaskID

+ type TaskReader_GetTaskType struct

+ func (_m TaskReader_GetTaskType) Return(_a0 string) *TaskReader_GetTaskType

+ type TaskReader_Read struct

+ func (_m TaskReader_Read) Return(_a0 *core.TaskTemplate, _a1 error) *TaskReader_Read