superflowapi

package
v1.38.0 Latest Latest
Warning

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

Go to latest
Published: Jun 14, 2026 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source
const Hostname = "superflow.verify"

Hostname is the default hostname of the microservice.

Variables

View Source
var (
	// HINT: Insert endpoint definitions here
	TaskA        = Def{Method: "POST", Route: ":428/task-a"}        // MARKER: TaskA
	TaskB        = Def{Method: "POST", Route: ":428/task-b"}        // MARKER: TaskB
	TaskC        = Def{Method: "POST", Route: ":428/task-c"}        // MARKER: TaskC
	TaskD        = Def{Method: "POST", Route: ":428/task-d"}        // MARKER: TaskD
	TaskE        = Def{Method: "POST", Route: ":428/task-e"}        // MARKER: TaskE
	TaskZ        = Def{Method: "POST", Route: ":428/task-z"}        // MARKER: TaskZ
	ErrorHandler = Def{Method: "POST", Route: ":428/error-handler"} // MARKER: ErrorHandler
	SubTaskA     = Def{Method: "POST", Route: ":428/sub-task-a"}    // MARKER: SubTaskA
	SubTaskB     = Def{Method: "POST", Route: ":428/sub-task-b"}    // MARKER: SubTaskB
	RunSuperSub  = Def{Method: "POST", Route: ":428/run-super-sub"} // MARKER: RunSuperSub
	Super        = Def{Method: "GET", Route: ":428/super"}          // MARKER: Super
	SuperSub     = Def{Method: "GET", Route: ":428/super-sub"}      // MARKER: SuperSub
)

Functions

This section is empty.

Types

type Client

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

Client is a lightweight proxy for making unicast calls to the microservice.

func NewClient

func NewClient(caller service.Publisher) Client

NewClient creates a new unicast client proxy to the microservice.

func (Client) ForHost

func (_c Client) ForHost(host string) Client

ForHost returns a copy of the client with a different hostname to be applied to requests.

func (Client) WithOptions

func (_c Client) WithOptions(opts ...pub.Option) Client

WithOptions returns a copy of the client with options to be applied to requests.

type Def

type Def struct {
	Method string
	Route  string
}

Def is the routing identity of an endpoint exposed by this microservice.

func (Def) URL

func (d Def) URL() string

URL is the full URL of the endpoint, joined with the package-level Hostname.

type ErrorHandlerIn

type ErrorHandlerIn struct{} // MARKER: ErrorHandler

ErrorHandlerIn are the input arguments of ErrorHandler.

type ErrorHandlerOut

type ErrorHandlerOut struct{} // MARKER: ErrorHandler

ErrorHandlerOut are the output arguments of ErrorHandler.

type Executor

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

Executor runs tasks and workflows synchronously, blocking until termination. It is primarily intended for integration tests.

func NewExecutor

func NewExecutor(caller service.Publisher) Executor

NewExecutor creates a new executor proxy to the microservice.

func (Executor) ErrorHandler

func (_c Executor) ErrorHandler(ctx context.Context) (err error)

ErrorHandler creates and runs the ErrorHandler task.

func (Executor) ForHost

func (_c Executor) ForHost(host string) Executor

ForHost returns a copy of the executor with a different hostname to be applied to requests.

func (Executor) SubTaskA

func (_c Executor) SubTaskA(ctx context.Context) (err error)

SubTaskA creates and runs the SubTaskA task.

func (Executor) SubTaskB

func (_c Executor) SubTaskB(ctx context.Context) (err error)

SubTaskB creates and runs the SubTaskB task.

func (Executor) Super

func (_c Executor) Super(ctx context.Context, items []string, useSubgraph bool, behaviors map[string]TaskBehavior) (status string, err error)

Super creates and runs the Super workflow, blocking until termination.

func (Executor) SuperSub

func (_c Executor) SuperSub(ctx context.Context, behaviors map[string]TaskBehavior) (status string, err error)

SuperSub creates and runs the SuperSub workflow, blocking until termination.

func (Executor) TaskA

func (_c Executor) TaskA(ctx context.Context) (err error)

TaskA creates and runs the TaskA task.

func (Executor) TaskB

func (_c Executor) TaskB(ctx context.Context) (err error)

TaskB creates and runs the TaskB task.

func (Executor) TaskC

func (_c Executor) TaskC(ctx context.Context) (err error)

TaskC creates and runs the TaskC task.

func (Executor) TaskD

func (_c Executor) TaskD(ctx context.Context) (err error)

TaskD creates and runs the TaskD task.

func (Executor) TaskE

func (_c Executor) TaskE(ctx context.Context) (err error)

TaskE creates and runs the TaskE task.

func (Executor) TaskZ

func (_c Executor) TaskZ(ctx context.Context) (err error)

TaskZ creates and runs the TaskZ task.

func (Executor) WithFlowOptions

func (_c Executor) WithFlowOptions(flowOptions *workflow.FlowOptions) Executor

WithFlowOptions returns a copy of the executor that creates workflows with the given flow options.

func (Executor) WithInputFlow

func (_c Executor) WithInputFlow(flow *workflow.Flow) Executor

WithInputFlow returns a copy of the executor with an input flow to use for task execution.

func (Executor) WithOptions

func (_c Executor) WithOptions(opts ...pub.Option) Executor

WithOptions returns a copy of the executor with options to be applied to requests.

func (Executor) WithOutputFlow

func (_c Executor) WithOutputFlow(flow *workflow.Flow) Executor

WithOutputFlow returns a copy of the executor with an output flow to populate after task execution.

func (Executor) WithWorkflowRunner

func (_c Executor) WithWorkflowRunner(runner WorkflowRunner) Executor

WithWorkflowRunner returns a copy of the executor with a workflow runner for executing workflows.

type Hook

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

Hook assists in the subscription to the events of the microservice.

func NewHook

func NewHook(listener service.Subscriber) Hook

NewHook creates a new hook to the events of the microservice.

func (Hook) ForHost

func (c Hook) ForHost(host string) Hook

ForHost returns a copy of the hook with a different hostname to be applied to the subscription.

func (Hook) WithOptions

func (c Hook) WithOptions(opts ...sub.Option) Hook

WithOptions returns a copy of the hook with options to be applied to subscriptions.

type MulticastClient

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

MulticastClient is a lightweight proxy for making multicast calls to the microservice.

func NewMulticastClient

func NewMulticastClient(caller service.Publisher) MulticastClient

NewMulticastClient creates a new multicast client proxy to the microservice.

func (MulticastClient) ForHost

func (_c MulticastClient) ForHost(host string) MulticastClient

ForHost returns a copy of the client with a different hostname to be applied to requests.

func (MulticastClient) WithOptions

func (_c MulticastClient) WithOptions(opts ...pub.Option) MulticastClient

WithOptions returns a copy of the client with options to be applied to requests.

type MulticastTrigger

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

MulticastTrigger is a lightweight proxy for triggering the events of the microservice.

func NewMulticastTrigger

func NewMulticastTrigger(caller service.Publisher) MulticastTrigger

NewMulticastTrigger creates a new multicast trigger of events of the microservice.

func (MulticastTrigger) ForHost

func (_c MulticastTrigger) ForHost(host string) MulticastTrigger

ForHost returns a copy of the trigger with a different hostname to be applied to requests.

func (MulticastTrigger) WithOptions

func (_c MulticastTrigger) WithOptions(opts ...pub.Option) MulticastTrigger

WithOptions returns a copy of the trigger with options to be applied to requests.

type RunSuperSubIn added in v1.37.0

type RunSuperSubIn struct{} // MARKER: RunSuperSub

RunSuperSubIn are the input arguments of RunSuperSub.

type RunSuperSubOut added in v1.37.0

type RunSuperSubOut struct{} // MARKER: RunSuperSub

RunSuperSubOut are the output arguments of RunSuperSub.

type SubTaskAIn

type SubTaskAIn struct{} // MARKER: SubTaskA

SubTaskAIn are the input arguments of SubTaskA.

type SubTaskAOut

type SubTaskAOut struct{} // MARKER: SubTaskA

SubTaskAOut are the output arguments of SubTaskA.

type SubTaskBIn

type SubTaskBIn struct{} // MARKER: SubTaskB

SubTaskBIn are the input arguments of SubTaskB.

type SubTaskBOut

type SubTaskBOut struct{} // MARKER: SubTaskB

SubTaskBOut are the output arguments of SubTaskB.

type SuperIn

type SuperIn struct {
	Items       []string                `json:"items,omitzero"`
	UseSubgraph bool                    `json:"useSubgraph,omitzero"`
	Behaviors   map[string]TaskBehavior `json:"behaviors,omitzero"`
}

SuperIn are the input arguments of the Super workflow.

type SuperOut

type SuperOut struct{} // MARKER: Super

SuperOut are the output arguments of the Super workflow.

type SuperSubIn

type SuperSubIn struct {
	Behaviors map[string]TaskBehavior `json:"behaviors,omitzero"`
}

SuperSubIn are the input arguments of the SuperSub workflow.

type SuperSubOut

type SuperSubOut struct{} // MARKER: SuperSub

SuperSubOut are the output arguments of the SuperSub workflow.

type SuperflowState

type SuperflowState struct {
	Items       []string                `json:"items,omitzero" jsonschema:"description=Items drives TaskB's forEach fan-out into TaskC"`
	UseSubgraph bool                    `json:"useSubgraph,omitzero" jsonschema:"description=UseSubgraph routes TaskD through SuperSub when true"`
	Behaviors   map[string]TaskBehavior `json:"behaviors,omitzero" jsonschema:"description=Behaviors maps a task name to a per-task behavior knob"`
}

SuperflowState is the shape of the Super workflow's shared state. Tasks read it via flow.ParseState to decide their behavior.

type TaskAIn

type TaskAIn struct{} // MARKER: TaskA

TaskAIn are the input arguments of TaskA.

type TaskAOut

type TaskAOut struct{} // MARKER: TaskA

TaskAOut are the output arguments of TaskA.

type TaskBIn

type TaskBIn struct{} // MARKER: TaskB

TaskBIn are the input arguments of TaskB.

type TaskBOut

type TaskBOut struct{} // MARKER: TaskB

TaskBOut are the output arguments of TaskB.

type TaskBehavior

type TaskBehavior struct {
	SleepMs     int    `json:"sleepMs,omitzero" jsonschema:"description=SleepMs delays the task by this many milliseconds before returning"`
	ErrorStatus int    `json:"errorStatus,omitzero" jsonschema:"description=ErrorStatus returns an error with this HTTP status code"`
	Interrupt   bool   `json:"interrupt,omitzero" jsonschema:"description=Interrupt calls flow.Interrupt(payload) instead of returning normally"`
	Goto        string `json:"goto,omitzero" jsonschema:"description=Goto calls flow.Goto(target) before returning"`
	Retry       bool   `json:"retry,omitzero" jsonschema:"description=Retry calls flow.Retry with an unlimited cap and returns nil"`
}

TaskBehavior parameterizes one task's runtime behavior. Tests set behaviors per task to drive specific control paths (sleep, error, interrupt, goto, retry) without changing the graph.

type TaskCIn

type TaskCIn struct{} // MARKER: TaskC

TaskCIn are the input arguments of TaskC.

type TaskCOut

type TaskCOut struct{} // MARKER: TaskC

TaskCOut are the output arguments of TaskC.

type TaskDIn

type TaskDIn struct{} // MARKER: TaskD

TaskDIn are the input arguments of TaskD.

type TaskDOut

type TaskDOut struct{} // MARKER: TaskD

TaskDOut are the output arguments of TaskD.

type TaskEIn

type TaskEIn struct{} // MARKER: TaskE

TaskEIn are the input arguments of TaskE.

type TaskEOut

type TaskEOut struct{} // MARKER: TaskE

TaskEOut are the output arguments of TaskE.

type TaskZIn

type TaskZIn struct{} // MARKER: TaskZ

TaskZIn are the input arguments of TaskZ.

type TaskZOut

type TaskZOut struct{} // MARKER: TaskZ

TaskZOut are the output arguments of TaskZ.

type WorkflowRunner

type WorkflowRunner interface {
	Run(ctx context.Context, workflowName string, initialState any, opts *workflow.FlowOptions) (outcome *workflow.FlowOutcome, err error)
}

WorkflowRunner executes a workflow by name with initial state, blocking until termination. foremanapi.Client satisfies this interface.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL