node

type Child struct {
	// Run is the Run to execute on Node.
	Run

	// Node is the node to execute Run on. It must be a valid, nonzero value.
	Node Node
}

type Command struct {
	// Command is the command to run. The string is split into command name and
	// arguments using space as a delimiter, with no support for escaping. If
	// spaces are needed in arguments, use the Arg field instead, or in
	// addition to Command.
	Command string

	// Arg is a slice of arguments for the command. If Command is empty, then
	// Arg[0] is the command name, otherwise the Arg slice is appended to the
	// slice obtained by splitting Command.
	Arg []string
}

type CommandError struct {
	Err     error
	Command string
	Out     []byte
}

type CommandOutput struct {
	Out    []byte // the combined output from the command
	String string // the command string per Cmd.String()
}

type Direction string

type Download struct {
	Transfer
}

type Env struct {
	// Vars lists the environment variables. Each entry must be of the form
	// "key=value". This field is an array so Node can remain a valid map key.
	Vars [EnvMax]string

	// Inherit indicates whether to include the parent process's environment
	// (true), or not (false).
	Inherit bool
}

type EnvVar string

type EnvVars []string

type Error struct {
	LogEntry
}

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

type ExeName string

type ExeSource interface {
	// Reader returns a ReadCloser for the given platform's node executable.
	Reader(platform string) (io.ReadCloser, error)

	// Size returns the size of the given platform's node executable.
	Size(platform string) (int64, error)

	// Platforms returns the platforms for which executables are available.
	Platforms() ([]string, error)
}

type Feedback map[string]any

type File string

type FileData struct {
	Name string // the name of the file
	Data []byte // the data
}

type Flow string

type Flower interface {
	Flow() Flow
}

type ID string

type Local struct {
}

type Location string

type LogEntry struct {
	Time   time.Time // the time the entry was logged, per the node's clock
	NodeID ID        // the ID of the node that created the entry
	Tag    string    // tags the entry for categorization
	Text   string    // the entry's text
}

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

type MessageFilter struct {
	// File is a valid glob pattern of FileData names to accept. Use '*' to
	// select all files. The pattern format is documented here:
	// https://pkg.go.dev/path/filepath#Match
	File []string

	// Log indicates whether to accept (true) or reject (false) LogEntry's.
	Log bool

	// Flows to accept.
	Flow []Flow

	// All indicates whether to accept all messages (true) or not (false).
	All bool
}

type Netns struct {
	// Name is the name of the namespace. If set, this namespace will either be
	// created or used, depending on the value of the Create field.
	Name string

	// Create indicates whether to create a namespace (true) or use an existing
	// one (false). If Create is true with no Name set, the Node ID will be used
	// as the network namespace name.
	Create bool
}

type Node struct {
	ID       ID        // identifies the Node
	Platform string    // the Node's platform (e.g. linux-amd64)
	Launcher launchers // union of available launchers
	Netns    Netns     // parameters for Linux network namespaces
	Env      Env       // process environment
}

type Packet struct {
	PacketHeader

	// Len is the total length of the packet, in bytes, including the header.
	Len int
	// contains filtered or unexported fields
}

type PacketClient struct {
	// Addr is the dial address, as specified to the address parameter in
	// net.Dial (e.g. "addr:port").
	Addr string

	// Protocol is the protocol to use (udp, udp4 or udp6).
	Protocol string

	// Flow is the flow identifier for traffic between the client and server.
	Flow Flow

	// MaxPacketSize is the maximum size of a received packet.
	MaxPacketSize int

	Sender []PacketSenders

	// Sockopts provides support for socket options.
	Sockopts
}

type PacketFlag byte

type PacketHeader struct {
	// Flag contains the packet flags.
	Flag PacketFlag

	// Seq is the sequence number assigned by the client.
	Seq Seq

	// Flow is the flow identifier, and corresponds to a client and server pair.
	Flow Flow
}

type PacketIO struct {
	// Packet is the packet.
	Packet

	// T is the node-relative time this PacketIO was recorded.
	T metric.RelativeTime

	// Sent is true for a sent packet, and false for received.
	Sent bool
}

type PacketInfo struct {
	// Tinit is the base time for the flow's RelativeTime values.
	Tinit time.Time

	// Flow is the flow identifier.
	Flow Flow

	// Server indicates if this is from the server (true) or client (false).
	Server bool
}

type PacketSenders struct {
	Unresponsive *Unresponsive
}

type PacketServer struct {
	// ListenAddr is the listen address, as specified to the address parameter
	// in net.ListenPacket (e.g. ":port" or "addr:port").
	ListenAddr string

	// Protocol is the protocol to use (udp, udp4 or udp6).
	Protocol string

	// MaxPacketSize is the maximum size of a received packet.
	MaxPacketSize int
	// contains filtered or unexported fields
}

type Parallel []Run

type ResultStream struct {
	// Include accepts messages to stream.
	Include *MessageFilter

	// Exclude rejects messages to stream, and buffers them instead.
	Exclude *MessageFilter
}

type Run struct {
	// Serial lists Runs to be executed sequentially
	Serial Serial

	// Parallel lists Runs to be executed concurrently
	Parallel Parallel

	// Schedule lists Runs to be executed on a schedule.
	Schedule *Schedule

	// Child is a Run to be executed on a child Node
	Child *Child

	// Runners is a union of the available runner implementations.
	//
	// NOTE: In the future, this may be an interface field, if CUE can be made
	// to choose a concrete type without using a field for each runner.
	Runners
}

type Runners struct {
	ResultStream *ResultStream
	Setup        *setup
	Sleep        *Sleep
	SysInfo      *SysInfo
	System       *System
	StreamClient *StreamClient
	StreamServer *StreamServer
	PacketServer *PacketServer
	PacketClient *PacketClient
}

type SSH struct {
	Destination string // ssh destination (man ssh(1))
}

type Schedule struct {
	// Wait lists the wait Durations to use. If Random is false, the chosen
	// Durations cycle repeatedly through Wait.
	Wait []metric.Duration

	// WaitFirst, if true, indicates to wait before the first Run as well.
	WaitFirst bool

	// Random, if true, indicates to select wait times from Wait randomly.
	// Otherwise, wait times are taken from Wait sequentially.
	Random bool

	// Sequential, if true, indicates to run the Runs in serial.
	Sequential bool

	// Run lists the Runs.
	Run []Run
	// contains filtered or unexported fields
}

type Seq uint64

type Serial []Run

type Sleep metric.Duration

type Sockopt struct {
	// Type identifies the type of the option, and may be one of "string",
	// "int" or "byte".
	Type string

	// Level is the level argument passed to setsockopt().
	Level int

	// Opt is the option argument passed to setsockopt().
	Opt int

	// Name is a label for the socket option, used only for debugging purposes.
	Name string

	// Value is the value to set. For Type string, this must be a string. For
	// Type int or byte, this must be an int.
	Value any
}

type Sockopts struct {
	// Sockopt lists the generic socket options to set.
	Sockopt []Sockopt

	// DS is the value to set for the DS (ToS/Traffic Class) byte.
	DS int

	// CCA is the sender's Congestion Control Algorithm (TCP only).
	CCA string
}

type Stream struct {
	// Flow is the Stream's flow identifier.
	Flow Flow

	// Direction is the client to server sense.
	Direction Direction

	// Sockopts provides support for socket options.
	Sockopts
}

type StreamClient struct {
	// Addr is the dial address, as specified to the address parameter in
	// net.Dial (e.g. "addr:port").
	Addr string

	// AddrKey is a key used to obtain the dial address from the incoming
	// Feedback, if Addr is not specified.
	AddrKey string

	// Protocol is the protocol to use (tcp, tcp4 or tcp6).
	Protocol string

	Streamers
}

type StreamIO struct {
	// Flow is the flow that this StreamIO is for.
	Flow Flow

	// T is the relative time this StreamIO was recorded.
	T metric.RelativeTime

	// Total is the total number of sent or received bytes.
	Total metric.Bytes

	// Sent is true for sent bytes, and false for received.
	Sent bool
}

type StreamInfo struct {
	// Tinit is the base time for the flow's RelativeTime values.
	Tinit time.Time

	Stream

	// Server indicates if this is from the server (true) or client (false).
	Server bool
}

type StreamServer struct {
	// ListenAddr is the listen address, as specified to the address parameter
	// in net.Listen (e.g. ":port" or "addr:port").
	ListenAddr string

	// ListenAddrKey is the key used in the returned Feedback for the listen
	// address, obtained using Listen.Addr.String(). If empty, the listen
	// address will not be included in the Feedback.
	ListenAddrKey string

	// Protocol is the protocol to use (tcp, tcp4 or tcp6).
	Protocol string
	// contains filtered or unexported fields
}

type Streamers struct {
	Upload   *Upload
	Download *Download
}

type SysInfo struct {
	// OS is a source that returns the operating system name / version.
	OS Texters

	// KernSrcInfo returns info on the kernel source code.
	KernSrcInfo Texters

	// KernSrcVer returns a version number or tag for the kernel source code.
	KernSrcVer Texters

	// Command lists the system commands to run.
	Command []Command

	// File lists the files to read.
	File []File

	// Env lists regex patterns of environment variables to retrieve.
	Env EnvVars

	// Sysctl lists regex pattern of sysctl parameters to retrieve.
	Sysctl Sysctls
}

type SysInfoData struct {
	NodeID         ID                       // the ID of the Node the data comes from
	Hostname       string                   // hostname from os.Hostname()
	GoVersion      string                   // Go version from runtime.Version()
	GoOS           string                   // Go OS from runtime.GOOS
	GoArch         string                   // Go Arch from runtime.GOARCH
	NumCPU         int                      // number of CPUs from runtime.NumCPU()
	GoBuildVersion string                   // BuildInfo.GoVersion
	BuildSetting   map[string]string        // BuildInfo.Setting
	AntlerVersion  string                   // Antler version from version.Version
	OS             string                   // OS name / version
	KernSrcInfo    string                   // kernel source info
	KernSrcVer     string                   // kernel source version
	Command        map[string]CommandOutput // map of command key to output
	File           map[string]FileData      // map of file key to data
	Env            map[string]string        // map of environment var name to value
	Sysctl         map[string]string        // map of sysctl params name to value
}

type Sysctl string

type Sysctls []string

type System struct {
	// Command is the embedded system command.
	Command

	// Background indicates whether to run this command in the background (true)
	// or foreground (false). If true, Run will return as soon as the command is
	// started, and with an error if it could not be started and IgnoreErrors is
	// false. The Context will be cancelled after the rest of the Run tree is
	// complete, at which time the process will be interrupted or killed
	// (according to Kill), and the node will wait for it to complete.
	Background bool

	// IgnoreErrors indicates whether to discard any errors (true) or not
	// (false).
	IgnoreErrors bool

	// Stdout selects the treatment for stdout. If empty, stdout is gathered and
	// emitted to the log as a single line when the command completes. If
	// "stream", stdout is emitted to the log a line at a time. If "quiet",
	// stdout is discarded. Otherwise, stdout is written to a file of the given
	// name.
	Stdout string

	// Stderr selects the treatment for stderr, with the same semantics as for
	// Stdout.
	Stderr string

	// Kill indicates whether to kill the process on cancellation (true) or
	// signal it with an interrupt (false).
	Kill bool
	// contains filtered or unexported fields
}

type Texter interface {
	Text(context.Context) (string, error)
}

type Texters struct {
	Command *Command
	File    *File
	Env     *EnvVar
	Sysctl  *Sysctl
}

type Transfer struct {
	// Duration is the length of time after which the sender stops writing.
	Duration metric.Duration

	// Length is the number of bytes after which the sender stops writing.
	Length metric.Bytes

	// IOSampleInterval is the minimum time between IO samples. Zero means a
	// sample will be recorded for every read and write.
	IOSampleInterval metric.Duration

	// BufLen is the size of the buffer used to read and write from the conn.
	BufLen int

	Stream
}

type Tree map[Node]Tree

type Unresponsive struct {
	// Wait lists the wait times between packets, which are cycled through
	// either sequentially or randomly (according to RandomWait) until all
	// packets are sent.
	Wait []metric.Duration

	// WaitFirst, if true, indicates to wait before sending the first packet as
	// well.
	WaitFirst bool

	// RandomWait, if true, indicates to use random wait times from the list.
	// Otherwise, the wait times are taken from Wait sequentially.
	RandomWait bool

	// Length lists the lengths of the packets, which are cycled through either
	// sequentially or randomly (according to RandomLength) until all packets
	// are sent.
	Length []int

	// RandomLength, if true, indicates to use random lengths from the list.
	// Otherwise, the lengths are taken from Length sequentially.
	RandomLength bool

	// Duration is how long to send packets.
	Duration metric.Duration

	// Echo, if true, requests mirrored replies from the server.
	Echo bool
	// contains filtered or unexported fields
}

type Upload struct {
	Transfer
}