runtime

Documentation

Overview

Package runtime defines interfaces for accessing runtime specific settings, and state.

Index

• Variables
• type ClusterState
• type Controller
• type ControllerOption
  • func WithForce() ControllerOption
• type ControllerOptions
  • func DefaultControllerOptions() ControllerOptions
• type Event
  • func (event *Event) ToMachineEvent() (*machine.Event, error)
• type EventFatalSequencerError
• type EventSequenceStart
• type EventStream
• type LogHandler
• type LogOption
  • func WithFollow() LogOption
  • func WithTailLines(lines int) LogOption
• type LogOptions
• type LoggingManager
• type Machine
• type MachineState
• type Mode
  • func ParseMode(s string) (mod Mode, err error)
  • func (m Mode) RequiresInstall() bool
  • func (m Mode) String() string
  • func (m Mode) Supports(feature ModeCapability) bool
• type ModeCapability
• type Phase
• type Platform
• type Publisher
• type Runtime
• type Sequence
  • func ParseSequence(s string) (seq Sequence, err error)
  • func (s Sequence) String() string
• type Sequencer
• type State
• type TaskExecutionFunc
• type TaskSetupFunc
• type WatchFunc
• type WatchOptionFunc
  • func WithTailDuration(dur time.Duration) WatchOptionFunc
  • func WithTailEvents(number int) WatchOptionFunc
  • func WithTailID(id xid.ID) WatchOptionFunc
• type WatchOptions
• type Watcher

Variables

var (
	// ErrLocked indicates that the sequencer is currently locked, and processing
	// another sequence.
	ErrLocked = errors.New("locked")

	// ErrReboot indicates that a task is requesting a reboot.
	ErrReboot = errors.New("reboot")

	// ErrInvalidSequenceData indicates that the sequencer got data the wrong
	// data type for a sequence.
	ErrInvalidSequenceData = errors.New("invalid sequence data")

	// ErrUndefinedRuntime indicates that the sequencer's runtime is not defined.
	ErrUndefinedRuntime = errors.New("undefined runtime")
)

Types

type ClusterState

type ClusterState interface{}

ClusterState defines the cluster state.

type Controller

type Controller interface {
	Runtime() Runtime
	Sequencer() Sequencer
	Run(Sequence, interface{}, ...ControllerOption) error
}

Controller represents the controller responsible for managing the execution of sequences.

type ControllerOption

type ControllerOption func(o *ControllerOptions) error

ControllerOption represents an option setter.

func WithForce

func WithForce() ControllerOption

WithForce sets the force option to true.

type ControllerOptions

type ControllerOptions struct {
	Force bool
}

ControllerOptions represents the options for a controller.

func DefaultControllerOptions

func DefaultControllerOptions() ControllerOptions

DefaultControllerOptions returns the default controller options.

type Event

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

Event is what is sent on the wire.

func (*Event) ToMachineEvent

func (event *Event) ToMachineEvent() (*machine.Event, error)

ToMachineEvent serializes Event as proto message machine.Event.

type EventFatalSequencerError

type EventFatalSequencerError struct {
	Error    error
	Sequence Sequence
}

EventFatalSequencerError represents a fatal sequencer error.

type EventSequenceStart

type EventSequenceStart struct {
	Sequence Sequence
}

EventSequenceStart represents the sequence start event.

type EventStream

type EventStream interface {
	Watcher
	Publisher
}

EventStream defines the runtime event stream.

type LogHandler

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

LogHandler provides interface to access particular log file.

type LogOption

type LogOption func(*LogOptions) error

LogOption provides functional options for LogHandler.Reader.

func WithFollow

func WithFollow() LogOption

WithFollow enables follow mode for the logs.

func WithTailLines

func WithTailLines(lines int) LogOption

WithTailLines starts log reading from lines from the tail of the log.

type LogOptions

type LogOptions struct {
	Follow    bool
	TailLines *int
}

LogOptions for LogHandler.Reader.

type LoggingManager

type LoggingManager interface {
	ServiceLog(service string) LogHandler
}

LoggingManager provides unified interface to publish and consume logs.

type Machine

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

Machine defines the runtime parameters.

type MachineState

type MachineState interface {
	Disk() *probe.ProbedBlockDevice
	Close() error
	Installed() bool
}

MachineState defines the machined state.

type Mode

type Mode int

Mode is a runtime mode.

const (
	// ModeCloud is the cloud runtime mode.
	ModeCloud Mode = iota
	// ModeContainer is the container runtime mode.
	ModeContainer
	// ModeMetal is the metal runtime mode.
	ModeMetal
)

func ParseMode

func ParseMode(s string) (mod Mode, err error)

ParseMode returns a `Mode` that matches the specified string.

func (Mode) RequiresInstall

func (m Mode) RequiresInstall() bool

RequiresInstall implements config.RuntimeMode.

func (Mode) String

func (m Mode) String() string

String returns the string representation of a Mode.

func (Mode) Supports

func (m Mode) Supports(feature ModeCapability) bool

Supports returns mode capability.

type ModeCapability

type ModeCapability uint64

ModeCapability describes mode capability flags.

const (
	// Reboot node reboot.
	Reboot ModeCapability = 1 << iota
	// Rollback node rollback.
	Rollback
	// Shutdown node shutdown.
	Shutdown
	// Upgrade node upgrade.
	Upgrade
)

type Phase

type Phase struct {
	Name  string
	Tasks []TaskSetupFunc
}

Phase represents a collection of tasks to be performed concurrently.

type Platform

type Platform interface {
	Name() string
	Configuration(context.Context) ([]byte, error)
	Hostname(context.Context) ([]byte, error)
	Mode() Mode
	ExternalIPs(context.Context) ([]net.IP, error)
	KernelArgs() procfs.Parameters
}

Platform defines the requirements for a platform.

type Publisher

type Publisher interface {
	Publish(proto.Message)
}

Publisher defines a runtime event publisher.

type Runtime

type Runtime interface {
	Config() config.Provider
	SetConfig([]byte) error
	State() State
	Events() EventStream
	Logging() LoggingManager
}

Runtime defines the runtime parameters.

type Sequence

type Sequence int

Sequence represents a sequence type.

const (
	// SequenceApplyConfiguration is the apply configuration sequence.
	SequenceApplyConfiguration Sequence = iota
	// SequenceBoot is the boot sequence.
	SequenceBoot
	// SequenceBootstrap is the boot sequence.
	SequenceBootstrap
	// SequenceInitialize is the initialize sequence.
	SequenceInitialize
	// SequenceInstall is the install sequence.
	SequenceInstall
	// SequenceShutdown is the shutdown sequence.
	SequenceShutdown
	// SequenceUpgrade is the upgrade sequence.
	SequenceUpgrade
	// SequenceReset is the reset sequence.
	SequenceReset
	// SequenceReboot is the reboot sequence.
	SequenceReboot
	// SequenceRecover is the recover sequence.
	SequenceRecover
	// SequenceNoop is the noop sequence.
	SequenceNoop
)

func ParseSequence

func ParseSequence(s string) (seq Sequence, err error)

ParseSequence returns a `Sequence` that matches the specified string.

nolint: gocyclo

func (Sequence) String

func (s Sequence) String() string

String returns the string representation of a `Sequence`.

type Sequencer

type Sequencer interface {
	ApplyConfiguration(Runtime, *machine.ApplyConfigurationRequest) []Phase
	Boot(Runtime) []Phase
	Bootstrap(Runtime) []Phase
	Initialize(Runtime) []Phase
	Install(Runtime) []Phase
	Reboot(Runtime) []Phase
	Recover(Runtime, *machine.RecoverRequest) []Phase
	Reset(Runtime, *machine.ResetRequest) []Phase
	Shutdown(Runtime) []Phase
	Upgrade(Runtime, *machine.UpgradeRequest) []Phase
}

Sequencer describes the set of sequences required for the lifecycle management of the operating system.

type State

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

State defines the state.

type TaskExecutionFunc

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

TaskExecutionFunc defines the function that a task will execute for a specific runtime mode.

type TaskSetupFunc

type TaskSetupFunc func(seq Sequence, data interface{}) (TaskExecutionFunc, string)

TaskSetupFunc defines the function that a task will execute for a specific runtime mode.

type WatchFunc

type WatchFunc func(<-chan Event)

WatchFunc defines the watcher callback function.

type WatchOptionFunc

type WatchOptionFunc func(opts *WatchOptions) error

WatchOptionFunc defines the options for the watcher.

func WithTailDuration

func WithTailDuration(dur time.Duration) WatchOptionFunc

WithTailDuration sets up Watcher to return events with timestamp >= (now - tailDuration).

func WithTailEvents

func WithTailEvents(number int) WatchOptionFunc

WithTailEvents sets up Watcher to return specified number of past events.

If number is negative, all the available past events are returned.

func WithTailID

func WithTailID(id xid.ID) WatchOptionFunc

WithTailID sets up Watcher to return events with ID > TailID.

type WatchOptions

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
}

WatchOptions defines options for the watch call.

Only one of TailEvents, TailID or TailDuration should be non-zero.

type Watcher

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

Watcher defines a runtime event watcher.