actionrpc

type Action interface {
	Run(with map[string]any) (map[string]any, error)
}

type Call struct {
	// With holds the step's with parameters, as Action.Run is given them.
	With map[string]any
	// State is the state the action left in the job, or nil when it left
	// none. The runner keeps the state the action returns without reading
	// it, and gives it to the action again in the next step of the job that
	// uses it. The state starts empty in each run of a job, and a nil state
	// returned keeps it as it was.
	State map[string]any
	// Step is the step the action runs for.
	Step Step
	// Guard is what the run allows the action to do. An action that keeps
	// to it returns a Refused error for what it does not allow.
	Guard Guard
	// Actions are the names the workflow gives its external actions, each
	// with the action it stands for in full, for an action that runs steps
	// of its own, as embedded does, to read a uses by. A local action is an
	// absolute path here.
	Actions map[string]string
	// Cleanups is not nil when the runner cleans up once the run is over:
	// it calls Cleanup of the action, when its action.yml sets cleanup, and
	// of those named here. It is nil for a runner that does not, such as a
	// Probe from before there was a cleanup, under which what a step leaves
	// behind stays; an action can refuse to leave anything then.
	Cleanups *Cleanups
}

type Cleaner interface {
	Action
	Cleanup(call CleanupCall) error
}

type CleanupCall struct {
	// RunID names the run that is over, as Step.RunID named it to each of
	// its steps.
	RunID string
}

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

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

type Guard struct {
	// ReadOnly allows only what reads, and nothing that writes, such as an
	// HTTP POST or an UPDATE.
	ReadOnly bool
	// AllowHosts are the hosts actions may connect to: a name or an address,
	// with a port or without one for any port, or *.example.com for the
	// names under example.com. Empty allows any host.
	AllowHosts []string
	// AllowActions are the actions run under the guard although they do not
	// keep to it, as the person running probe asks.
	AllowActions []string
	// Keeps holds the kinds of guard each action says it keeps to itself,
	// keyed by the action as a step's uses names it: a built-in action by
	// what its package declares, an external one by its action.yml. An
	// action is refused under a guard it does not keep to every kind of,
	// unless AllowActions names it.
	Keeps map[string][]string
}

type Plugin struct {
	plugin.Plugin
	Impl Action
}

type Refused struct {
	Reason string
}

type Server struct {
	Impl Action
	// contains filtered or unexported fields
}

type Step struct {
	// RunID names the run of probe, the same for every step of every job in
	// it, and for a job run by the embedded action.
	RunID   string
	JobID   string
	JobName string
	// Index is the position of the step in the job, from 0.
	Index int
	// ID is the id the step is given, or empty.
	ID   string
	Name string
	// Repeat is which run of a repeated job this is, from 0.
	Repeat int
	// Attempt is which attempt of a retried step this is, from 1.
	Attempt int
}

type StepAction interface {
	Action
	RunStep(call Call) (result, newState map[string]any, err error)
}