process

type Factory ¶

type Factory interface {
	Start(ctx context.Context, spec LaunchSpec) (Handle, error)
}

Factory starts agent processes.

type FakeFactory ¶

type FakeFactory struct {
	// OnStart, if non-nil, is invoked synchronously inside Start with the
	// freshly-constructed FakeHandle. Use it to install scripted I/O.
	OnStart func(context.Context, LaunchSpec, *FakeHandle)
	// contains filtered or unexported fields
}

FakeFactory is the test Factory. It never spawns a real process; instead each call to Start produces a FakeHandle whose stdin/stdout are wired to in-memory pipes. Tests script the handle's behavior either via [OnStart] or by calling helpers on the returned FakeHandle directly.

func NewFakeFactory() *FakeFactory

func (f *FakeFactory) Handles() []*FakeHandle

func (f *FakeFactory) Start(ctx context.Context, spec LaunchSpec) (Handle, error)

func (f *FakeFactory) Starts() []LaunchSpec

type FakeHandle ¶

type FakeHandle struct {
	// StdinR exposes the read end of the stdin pipe so tests can observe
	// what the system under test wrote to the child.
	StdinR *io.PipeReader
	// contains filtered or unexported fields
}

FakeHandle is the Handle returned by FakeFactory.

Its Stdin and Stdout are connected to in-memory pipes:

• Bytes the system under test writes to Stdin can be read from StdinR.
• Bytes pushed via WriteOutput appear on Stdout.

A FakeHandle starts in the running state. Call SignalExit (with optional error) or Kill to transition it to exited.

func (h *FakeHandle) Done() <-chan struct{}

func (h *FakeHandle) FinishOutput()

func (h *FakeHandle) Kill() error

func (h *FakeHandle) SignalExit(err error)

func (h *FakeHandle) Spec() LaunchSpec

func (h *FakeHandle) Stdin() io.WriteCloser

func (h *FakeHandle) Stdout() io.ReadCloser

func (h *FakeHandle) Wait() error

func (h *FakeHandle) WriteOutput(p []byte) (int, error)

type Handle ¶

type Handle interface {
	Stdin() io.WriteCloser
	Stdout() io.ReadCloser
	Wait() error
	Kill() error
	Done() <-chan struct{}
}

Handle is a running process with attached stdin/stdout pipes.

Lifecycle invariants:

• Stdin and Stdout are valid until Wait returns.
• Done is closed after the process has exited; Wait then returns immediately with the exit error.
• Kill is idempotent and safe to call concurrently with Wait.

type LaunchSpec ¶

type LaunchSpec struct {
	Path    string
	Args    []string
	Env     []string
	WorkDir string
}

LaunchSpec describes how to start an agent process.

It intentionally mirrors the subset of os/exec.Cmd that an agent driver needs to populate, so that drivers can be unit-tested against any Factory.

type OSExecFactory ¶

type OSExecFactory struct {
	// Stderr, if non-nil, receives the child process's stderr stream.
	// Defaults to os.Stderr.
	Stderr io.Writer
}

OSExecFactory is the production Factory backed by os/exec.

func NewOSExecFactory() *OSExecFactory

func (f *OSExecFactory) Start(ctx context.Context, spec LaunchSpec) (Handle, error)