bench

type Exec struct{}

type MirrorStage struct {
	// Mirror is the bare mirror on the bench, relative to the login's home or absolute
	// (MirrorDir).
	Mirror string
	// Remote is the URL the ref is fetched from when the mirror names no origin of its
	// own; the mirror's origin is preferred, since that is the URL the bench can read.
	Remote string
	// Ref is the temporary ref the lander pushed (GateRef); Sha the commit it names, the
	// tree the run's command runs in.
	Ref, Sha string
}

type Options struct {
	// Hosts are the benches in the order they are tried: the host, then the
	// fallback. Only a host that does not answer moves the run to the next.
	Hosts []string
	// Dir is the local tree to copy; unread when Stage is set.
	Dir string
	// Stage, when set, stages the tree from the bench's mirror in place of the copy.
	Stage *MirrorStage
	// Root is the directory on the bench the run directory is made in, and
	// Cache is GOCACHE there; each is relative to the login's home or
	// absolute. Empty is the default.
	Root, Cache string
	// WithGit copies the tree's .git as well.
	WithGit bool
	// Argv is the command, run in the copy.
	Argv []string
	// Stdout and Stderr receive the command's output as it arrives; Notes
	// receives the run's own lines (a host passed over).
	Stdout, Stderr, Notes io.Writer
	// Now is the run's clock, for the stage's wall time; nil is the wall's.
	Now func() time.Time
	// Staged, when set, is told the stage as it ends, refused or not, before the
	// command runs: the lander's beat says it while the command runs.
	Staged func(Stage)
}

type RefGit interface {
	Push(ctx context.Context, sha, ref string) error
	Delete(ctx context.Context, ref string) error
}

type Result struct {
	// Host is the bench that ran the command; RunDir the directory made there.
	Host, RunDir string
	// Code is the command's exit status.
	Code int
	// Removed is whether the run directory was removed; RemoveErr says why not.
	Removed   bool
	RemoveErr error
	// Stage is what the copy or the mirror stage did (Stage.Line).
	Stage Stage
}

type Stage struct {
	// Host is the bench; Via how the tree got there: "mirror" or "tar".
	Host, Via string
	// Bytes is what crossed the wire from this machine (the tar stream; nothing but the
	// line for a mirror stage); Wall the stage's time on the run's clock.
	Bytes int64
	Wall  time.Duration
	// Err is the stage's refusal, nil when the tree is staged.
	Err *StageError
}

type StageError struct {
	Host, Step string
	Code       int
	Tail       string
	Wall       time.Duration
	Err        error
}

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

type Transport interface {
	// Shell runs one line under the login shell on host, streaming its output.
	// The int is the remote status (NoAnswer when ssh itself failed); the error
	// is only for a transport that could not start at all.
	Shell(ctx context.Context, host, line string, stdout, stderr io.Writer) (int, error)
	// Copy copies the contents of the local directory src into dst on host
	// (dst is created; its parent exists), leaving .git out unless withGit.
	Copy(ctx context.Context, host, src, dst string, withGit bool, stderr io.Writer) error
}