runtime

type ActorIDCtxKey struct{}

type Board interface {
	Name() string
	Install(options BoardInstallOptions) error
	KernelArgs() procfs.Parameters
	PartitionOptions() *PartitionOptions
}

type BoardInstallOptions struct {
	InstallDisk     string
	MountPrefix     string
	DTBPath         string
	UBootPath       string
	RPiFirmwarePath string
	Printf          func(string, ...any)
}

type ClusterState interface{}

type Controller interface {
	Runtime() Runtime
	Sequencer() Sequencer
	Run(context.Context, Sequence, interface{}, ...LockOption) error
	V1Alpha2() V1Alpha2Controller
}

type DBusState interface {
	Start() error
	Stop() error
	WaitShutdown(ctx context.Context) error
}

type DrainEvent struct{}

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

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

type Event struct {
	TypeURL string
	ID      xid.ID
	Payload proto.Message
	ActorID string
}

type EventFatalSequencerError struct {
	Error    error
	Sequence Sequence
}

type EventInfo struct {
	Event
	Backlog int
}

type EventSequenceStart struct {
	Sequence Sequence
}

type EventStream interface {
	Watcher
	Publisher
}

type LockOption func(o *LockOptions) error

type LockOptions struct {
	Takeover bool
}

type LogEvent struct {
	Msg    string
	Time   time.Time
	Level  zapcore.Level
	Fields map[string]interface{}
}

type LogHandler interface {
	Writer() (io.WriteCloser, error)
	Reader(opt ...LogOption) (io.ReadCloser, error)
}

type LogOption func(*LogOptions) error

type LogOptions struct {
	Follow    bool
	TailLines *int
}

type LogSender interface {
	// Send tries to send the log event once, exiting on success, error, or context cancelation.
	//
	// Returned error is nil on success, non-nil otherwise.
	// As a special case, Send can return (possibly wrapped) ErrDontRetry if the log event should not be resent
	// (if it is invalid, if it was sent partially, etc).
	//
	// Send should be thread-safe.
	Send(ctx context.Context, e *LogEvent) error

	// Close stops the sender gracefully if possible, or forcefully on context cancelation.
	//
	// Close should be thread-safe.
	Close(ctx context.Context) error
}

type LoggingManager interface {
	// ServiceLog privides a log handler for a given service (that may not exist).
	ServiceLog(service string) LogHandler

	// SetSenders sets log senders for all derived log handlers
	// and returns the previous ones for closing.
	//
	// SetSenders should be thread-safe.
	SetSenders(senders []LogSender) []LogSender

	// RegisteredLogs returns a list of registered logs containers.
	RegisteredLogs() []string
}

type Machine interface {
	State() MachineState
	Config() config.MachineConfig
}

type MachineState interface {
	Disk(options ...disk.Option) *probe.ProbedBlockDevice
	Close() error
	Installed() bool
	IsInstallStaged() bool
	StagedInstallImageRef() string
	StagedInstallOptions() []byte
	KexecPrepared(bool)
	IsKexecPrepared() bool
	DBus() DBusState
	Meta() Meta
}

type Meta interface {
	ReadTag(t uint8) (val string, ok bool)
	ReadTagBytes(t uint8) (val []byte, ok bool)
	SetTag(ctx context.Context, t uint8, val string) (bool, error)
	SetTagBytes(ctx context.Context, t uint8, val []byte) (bool, error)
	DeleteTag(ctx context.Context, t uint8) (bool, error)
	Reload(ctx context.Context) error
	Flush() error
}

type Mode int

type ModeCapability uint64

type PartitionOptions struct {
	PartitionsOffset uint64
}

type PartitionTarget interface {
	fmt.Stringer
	Format(func(string, ...any)) error
	GetLabel() string
}

type Phase struct {
	Name      string
	Tasks     []TaskSetupFunc
	CheckFunc func() bool
}

type Platform interface {
	// Name returns platform name.
	Name() string

	// Mode returns platform mode (metal, cloud or container).
	Mode() Mode

	// Configuration fetches the machine configuration from platform-specific location.
	//
	// On cloud-like platform it is user-data in metadata service.
	// For metal platform that is either `talos.config=` URL or mounted ISO image.
	Configuration(context.Context, state.State) ([]byte, error)

	// KernelArgs returns additional kernel arguments which should be injected for the kernel boot.
	KernelArgs(arch string) procfs.Parameters

	// NetworkConfiguration fetches network configuration from the platform metadata.
	//
	// Controller will run this in function a separate goroutine, restarting it
	// on error. Platform is expected to deliver network configuration over the channel,
	// including updates to the configuration over time.
	NetworkConfiguration(context.Context, state.State, chan<- *PlatformNetworkConfig) error
}

type PlatformNetworkConfig struct {
	Addresses []network.AddressSpecSpec `yaml:"addresses"`
	Links     []network.LinkSpecSpec    `yaml:"links"`
	Routes    []network.RouteSpecSpec   `yaml:"routes"`

	Hostnames   []network.HostnameSpecSpec   `yaml:"hostnames"`
	Resolvers   []network.ResolverSpecSpec   `yaml:"resolvers"`
	TimeServers []network.TimeServerSpecSpec `yaml:"timeServers"`

	Operators []network.OperatorSpecSpec `yaml:"operators"`

	ExternalIPs []netip.Addr `yaml:"externalIPs"`

	Probes []network.ProbeSpecSpec `yaml:"probes,omitempty"`

	Metadata *runtime.PlatformMetadataSpec `yaml:"metadata,omitempty"`
}

type Publisher interface {
	Publish(context.Context, proto.Message)
}

type RebootError struct {
	Cmd int
}

type ResetOptions interface {
	GetGraceful() bool
	GetReboot() bool
	GetMode() machine.ResetRequest_WipeMode
	GetUserDisksToWipe() []string
	GetSystemDiskTargets() []PartitionTarget
}

type Runtime interface {
	Config() config.Config
	ConfigContainer() config.Container
	RollbackToConfigAfter(time.Duration) error
	CancelConfigRollbackTimeout()
	SetConfig(config.Provider) error
	CanApplyImmediate(config.Provider) error
	State() State
	Events() EventStream
	Logging() LoggingManager
	NodeName() (string, error)
	IsBootstrapAllowed() bool
	GetSystemInformation(ctx context.Context) (*hardware.SystemInformation, error)
}

type Sequence int

type Sequencer interface {
	Boot(Runtime) []Phase
	Initialize(Runtime) []Phase
	Install(Runtime) []Phase
	Reboot(Runtime) []Phase
	Reset(Runtime, ResetOptions) []Phase
	Shutdown(Runtime, *machine.ShutdownRequest) []Phase
	StageUpgrade(Runtime, *machine.UpgradeRequest) []Phase
	Upgrade(Runtime, *machine.UpgradeRequest) []Phase
	MaintenanceUpgrade(Runtime, *machine.UpgradeRequest) []Phase
}

type State interface {
	Platform() Platform
	Machine() MachineState
	Cluster() ClusterState
	V1Alpha2() V1Alpha2State
}

type TaskExecutionFunc func(context.Context, *log.Logger, Runtime) error

type TaskSetupFunc func(seq Sequence, data any) (TaskExecutionFunc, string)

type V1Alpha2Controller interface {
	Run(context.Context, *Drainer) error
	DependencyGraph() (*controller.DependencyGraph, error)
}

type V1Alpha2State interface {
	Resources() state.State

	NamespaceRegistry() *registry.NamespaceRegistry
	ResourceRegistry() *registry.ResourceRegistry

	SetConfig(configcore.Provider) error
}

type WatchFunc func(<-chan EventInfo)

type WatchOptionFunc func(opts *WatchOptions) error

type WatchOptions struct {
	// Return that many past events.
	//
	// If TailEvents is negative, return all the events available.
	TailEvents int
	// Start at ID > specified.
	TailID xid.ID
	// Start at timestamp Now() - TailDuration.
	TailDuration time.Duration
	// ActorID to ID of the actor to filter events by.
	ActorID string
}

type Watcher interface {
	Watch(WatchFunc, ...WatchOptionFunc) error
}