action

type ActionPlan ¶

type ActionPlan struct {
	Name_     string      // what this action considers itself named.
	Label     string      // user defined label, which may appear in output log decorations.
	Details   interface{} // used in String() if provided
	Stdin     io.ReadCloser
	Stdout    io.WriteCloser
	Stderr    io.WriteCloser
	IsExec    bool             // if two siblings in a pipe are both true for this, use MkPipe to wire them together instead of application level buffer bouncing.
	Run       func() error     // note: do be prepared for this to be run in a goroutine; it very well might be (e.g. pipe will tend to do this); or, it might not.
	Ignorable func(error) bool // NYI.  we'll see if this is a plausible idea or not.
}

ActionPlan is something that a wfx script is ready to "do". The action described by the ActionPlan can have side effects. Several essential action plan constructors are exported to wfx scripts by default, and form the basis for most, if not all, effects.

ActionPlan are produced by various constructor functions. They can be forced to execute manually by giving them to `do()`; otherwise, simply letting them fall to the ground as the unused result of a starlark statement will cause them to be executed(!). (Any use of the value -- either handing it to other functions, or simply assigning it to a variable -- prevents execution.)

When executed, action will resolve to produce success or an error code; while in motion, the action can consume a stdin stream, and produce stdout and stderr streams. This sounds a lot like a posix process -- and indeed, it's modeled on it! -- and often even backed by a posix process! But can also be implemented without full subprocess execution.

In starlark, execution of the action doesn't return anything. It only succeeds or fails. If it fails, the program as a whole will halt. Other "controller" actions can wrap an action plan and modify it in order configure behaviors other than halt-on-error. The "pipe", "gather", "test", and "ignorantly" controller actions are all examples of things that can tweak the halt conditions in various ways. ("test" is an especially interesting one, in that it actually _does_ return a result -- a boolean.)

Stdout (unless rewired by a piping) goes to dev null, unless verbose mode is on; then, it's decorated and emitted to the user. Stderr goes to dev null, unless the action fails; then it's likely to get included in the error message.

Most ActionPlan are produced by builtin constructors, but they can be defined in Starlark code too. The main reason to consider doing so is to take advantage of the IO streaming conventions, so that the Starlark code can be composed with "pipe" and other action controllers. (Not yet implemented!)

func (a *ActionPlan) Freeze()

func (a *ActionPlan) Hash() (uint32, error)

func (a *ActionPlan) Name() string

func (a *ActionPlan) String() string

func (a *ActionPlan) Truth() starlark.Bool

func (a *ActionPlan) Type() string

type CmdPlanConstructor ¶

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

func (a *CmdPlanConstructor) CallInternal(thread *starlark.Thread, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (a *CmdPlanConstructor) Freeze()

func (a *CmdPlanConstructor) Hash() (uint32, error)

func (a *CmdPlanConstructor) Name() string

func (a *CmdPlanConstructor) String() string

func (a *CmdPlanConstructor) Truth() starlark.Bool

func (a *CmdPlanConstructor) Type() string

type Do ¶

type Do struct{}

func (a *Do) CallInternal(thread *starlark.Thread, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (a *Do) Freeze()

func (a *Do) Hash() (uint32, error)

func (a *Do) Name() string

func (a *Do) String() string

func (a *Do) Truth() starlark.Bool

func (a *Do) Type() string

type PanicAction ¶

type PanicAction struct {
}

func (a *PanicAction) CallInternal(thread *starlark.Thread, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (a *PanicAction) Freeze()

func (a *PanicAction) Hash() (uint32, error)

func (a *PanicAction) Name() string

func (a *PanicAction) String() string

func (a *PanicAction) Truth() starlark.Bool

func (a *PanicAction) Type() string

type PipeControllerConstructor ¶

type PipeControllerConstructor struct{}

func (a *PipeControllerConstructor) CallInternal(thread *starlark.Thread, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (a *PipeControllerConstructor) Freeze()

func (a *PipeControllerConstructor) Hash() (uint32, error)

func (a *PipeControllerConstructor) Name() string

func (a *PipeControllerConstructor) String() string

func (a *PipeControllerConstructor) Truth() starlark.Bool

func (a *PipeControllerConstructor) Type() string