runner

type CapabilityBoot[T any] struct {
	Component *boot.Component
	Output    boot.Output[T]
}

type ClusterAccess struct {
	RunnerConfig
	Log *slog.Logger
	// contains filtered or unexported fields
}

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

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

type Runner struct {
	Access       *ClusterAccess
	Storage      *NodeStorage
	Host         *SandboxHost
	StorageAgent *StorageAgent
	SandboxAgent *SandboxAgent
	Presence     *NodePresence
}

type RunnerConfig struct {
	Id            string `json:"id" cbor:"id" yaml:"id"`
	Name          string `json:"name" cbor:"name" yaml:"name"`
	ListenAddress string `json:"listen_address" cbor:"listen_address" yaml:"listen_address"`
	Workers       int    `json:"workers" cbor:"workers" yaml:"workers"`
	DataPath      string `json:"data_path" cbor:"data_path" yaml:"data_path"`

	// Optional RPC configuration for advanced setups
	// If not provided, a default insecure connection will be used
	// to connect to the server address.
	Config *clientconfig.Config `json:"config" cbor:"config" yaml:"config"`

	// Optional cloud authentication configuration for disk replication
	CloudAuth *coordinate.CloudAuthConfig `json:"cloud_auth,omitempty" cbor:"cloud_auth,omitempty" yaml:"cloud_auth,omitempty"`

	// DiskMode configures disk I/O mode ("", "auto", "universal", "accelerator")
	DiskMode string `json:"disk_mode,omitempty" cbor:"disk_mode,omitempty" yaml:"disk_mode,omitempty"`
}

type RunnerDeps struct {
	CC        *containerd.Client
	Namespace string
	Bridge    string
	Tempdir   string
	Subnet    *netdb.Subnet

	// Network dependencies
	NetServ *network.ServiceManager

	// Observability dependencies
	LogsMaintainer *observability.LogsMaintainer
	LogWriter      observability.LogWriter
	StatusMon      *observability.StatusMonitor

	// MetricsWriter is also where host-level resource series are published. It
	// is the same writer the sandbox collectors use, taken directly rather than
	// through them because node series are labeled by node rather than by
	// sandbox. Nil disables host metrics, as it does for sandbox metrics.
	MetricsWriter *metrics.VictoriaMetricsWriter

	// Network config
	IPv4Routable    netip.Prefix
	ServicePrefixes []netip.Prefix
	DisableLocalNet bool

	// Resolver
	Resolver netresolve.Resolver

	// Sandbox metrics
	SandboxMetrics *sandbox.Metrics

	// IsCoordinator indicates this runner is the coordinator node.
	// Affects scheduling: stateful sandboxes are routed to the coordinator.
	IsCoordinator bool

	// Flannel network configuration (for distributed runners)
	// If EtcdEndpoints is non-empty, the runner will join the Flannel network
	EtcdEndpoints []string
	EtcdPrefix    string

	// TLS configuration for etcd mTLS (for distributed runners, file paths)
	EtcdTLSCertFile string // Client certificate file path
	EtcdTLSKeyFile  string // Client private key file path
	EtcdTLSCAFile   string // CA certificate file path

	// WorkloadIssuer mints workload identity tokens for sandbox containers. On
	// the coordinator this is the concrete *workloadidentity.Issuer; on a
	// distributed runner it is a remote issuer that proxies minting to the
	// coordinator over RPC.
	WorkloadIssuer workloadidentity.TokenIssuer

	// ApiAddress is where sandboxes on this host reach the cluster API, as a
	// literal IP:port. On the coordinator that is the local bridge router; on a
	// distributed runner it is the coordinator itself. Empty disables
	// in-cluster API access.
	ApiAddress string

	// CACert is the cluster CA in PEM form, mounted into sandboxes so they can
	// verify the API certificate.
	CACert []byte

	// Secrets materializes the secret references a sandbox spec carries, at
	// container creation. On the coordinator this is the local backend
	// registry, where the keyring lives. A distributed runner holds no key
	// material, so it must resolve over RPC instead; until that exists, a
	// sandbox on such a runner fails rather than starting without its secret.
	Secrets secret.Resolver
}

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

type SandboxHost struct {
	RunnerConfig

	Log *slog.Logger
	// contains filtered or unexported fields
}

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