zarfmod

type Args struct {
	Control Control
	// contains filtered or unexported fields
}

type Control struct {
	CheckMode bool `json:"_ansible_check_mode"`
	Diff      bool `json:"_ansible_diff"`
	NoLog     bool `json:"_ansible_no_log"`
	Verbosity int  `json:"_ansible_verbosity"`
}

type Detail struct {
	// Module is the action that ran, so a failure in a playbook that loops over several says which
	// one.
	Module string `json:"module,omitempty"`
	// CheckMode says whether this was a dry run, so a playbook cannot mistake a check-mode result
	// for a real one.
	CheckMode bool `json:"checkMode,omitempty"`
	// Command is the zarf command line the wrapper ran, for an operator reproducing it by hand.
	// Credential flag values are replaced before this is reported; see redact.
	Command []string `json:"command,omitempty"`
	// Directory is where that command ran. Zarf init finds the init package relative to the
	// working directory, so the directory is part of what the command means.
	Directory string `json:"directory,omitempty"`
	// ExitCode is zarf's exit status. It is reported for a failure, where the message alone does
	// not distinguish a zarf that refused from a zarf that was killed.
	ExitCode int `json:"exitCode,omitempty"`
	// ComponentsRan names the init components zarf reported deploying, in the order it reported
	// them. Ansible shows one result for the whole run, so this is what a playbook has in place of
	// per-component tasks.
	ComponentsRan []string `json:"componentsRan,omitempty"`
	// ChangedSignal says how much the changed field above is worth.
	ChangedSignal string `json:"changedSignal,omitempty"`
	// ChangedUndeclared names what did not say. It is what makes a partial signal actionable
	// rather than a warning with nothing behind it.
	ChangedUndeclared []string `json:"changedUndeclared,omitempty"`
	// Version is what `zarf version` printed, when the wrapper was able to read it. The modules
	// have a floor -- see MinZarfVersion -- so a run that failed on an older zarf has the version
	// attached to the result rather than only in whatever zarf said.
	Version string `json:"version,omitempty"`
	// StatusFile is the heartbeat file the run wrote progress to, when one was asked for. It is
	// reported so a failed run leaves a trail even if the monitor that was watching it is gone.
	StatusFile string `json:"statusFile,omitempty"`
}

type ExecRunner struct{}

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

type Invocation struct {
	// Binary is the zarf to run.
	Binary string
	// Args is the argument vector after the binary.
	Args []string
	// Dir is the working directory. Zarf init resolves the init package relative to it, so this is
	// load-bearing rather than cosmetic.
	Dir string
	// Env is added to the wrapper's own environment, as KEY=VALUE.
	Env []string
	// OnLine is called with each line zarf writes, if set. It is how progress is read back out of
	// the log stream.
	OnLine func(string)
}

type Response struct {
	Changed bool `json:"changed"`
	Failed  bool `json:"failed,omitempty"`
	// Skipped is how a module says it did not run at all. It is set when an operator asked for
	// check mode, because zarf init has no dry run to answer with.
	Skipped bool    `json:"skipped,omitempty"`
	Msg     string  `json:"msg,omitempty"`
	Zarf    *Detail `json:"zarf,omitempty"`
}

type Result struct {
	ExitCode int
}

type Runner interface {
	Run(ctx context.Context, in Invocation) (Result, error)
}

type Status struct {
	Phase     string    `json:"phase"`
	Index     int       `json:"index"`
	Total     int       `json:"total"`
	Status    string    `json:"status"` // running, completed, failed
	Timestamp time.Time `json:"timestamp"`
	Error     string    `json:"error,omitempty"`
}