runner

type DefaultDispatcher struct{}

type DefaultScheduler struct {
	ExecutorDispatcher executor.Dispatcher
	NodeDispatcher     NodeDispatcher
	Store              wfruntime.Store
	Sink               EventSink
	ResultReporter     ResultReporter
	HeartbeatReporter  HeartbeatReporter
	RunController      RunController
}

type Dispatcher = NodeDispatcher

type Engine struct {
	Compiler  planning.Compiler
	Scheduler Scheduler
}

type EventSink interface {
	Emit(ctx context.Context, event wfruntime.RunEvent)
}

type ExecutorResolver interface {
	Resolve(execType string) (executor.Executor, bool)
}

type Heartbeat struct {
	RunID          string          `json:"run_id"`
	NodeID         string          `json:"node_id"`
	ExecutorType   string          `json:"executor_type,omitempty"`
	ExternalTaskID string          `json:"external_task_id,omitempty"`
	Status         executor.Status `json:"status,omitempty"`
	Message        string          `json:"message,omitempty"`
	At             time.Time       `json:"at"`
	Metadata       map[string]any  `json:"metadata,omitempty"`
}

type HeartbeatReporter interface {
	ReportHeartbeat(ctx context.Context, beat Heartbeat) error
}

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

type NodeDispatcher interface {
	Dispatch(plan *planning.ExecutionPlan, run *wfruntime.WorkflowRun) []string
}

type NopHeartbeatReporter struct{}

type NopResultReporter struct{}

type ResultReporter interface {
	ReportResult(ctx context.Context, task executor.ExecuteTask, result executor.ExecuteResult) error
}

type RunCommand string

type RunController interface {
	Get(runID string) RunCommand
	Set(runID string, cmd RunCommand)
	Clear(runID string)
}

type Scheduler interface {
	Run(ctx context.Context, plan *planning.ExecutionPlan, run *wfruntime.WorkflowRun) (*wfruntime.WorkflowRun, error)
}

type StoreResultReporter struct {
	Store wfruntime.Store
}