hoststatus

type Availability string

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

type Bluetooth struct {
	// Powered is nil when the adapter's power state cannot be read.
	Powered *bool
	Present bool
}

type BluetoothController interface {
	Read(ctx context.Context) (BluetoothReading, error)
	// StartDiscovery and StopDiscovery start and end this process's own
	// discovery session. Other programs' sessions are left alone.
	StartDiscovery(ctx context.Context) error
	StopDiscovery(ctx context.Context) error
	// Pair bonds with the device, answering the stack's questions without
	// user input while the attempt lasts. It blocks until the device answers
	// or ctx ends.
	Pair(ctx context.Context, address string) error
	Trust(ctx context.Context, address string) error
	Connect(ctx context.Context, address string) error
	// Remove unpairs the device and forgets it.
	Remove(ctx context.Context, address string) error
	// Watch calls onChange whenever the stack reports a change, until ctx
	// ends. onChange must not block.
	Watch(ctx context.Context, onChange func())
}

type BluetoothDevice struct {
	// Address is the device's address in upper case, colon separated.
	Address string
	// Name is empty when the device has not said what it is called.
	Name string
	// VendorID and ProductID come from the device's modalias: four lowercase
	// hex digits, or empty.
	VendorID  string
	ProductID string
	Icon      string
	UUIDs     []string
	// Class is the Class of Device of a classic device, or zero.
	Class uint32
	// Appearance is a low energy device's appearance value, or zero.
	Appearance uint16
	Paired     bool
	Connected  bool
	Trusted    bool
	// InRange means the current discovery has heard from the device.
	InRange bool
}

type BluetoothReading struct {
	Devices     []BluetoothDevice
	Powered     bool
	Discovering bool
}

type Connector struct {
	Name      string
	Connected bool
	Enabled   bool
}

type Controller struct {
	Battery *ControllerBattery
	// ID identifies the controller only for as long as it stays connected.
	ID   string
	Name string
	// VendorID and ProductID are four lowercase hex digits, or empty.
	VendorID   string
	ProductID  string
	Connection string
	// Address is the controller's hardware address in lower case, as the
	// kernel reports it, or empty. A Bluetooth controller's is its Bluetooth
	// address. It is never sent to clients.
	Address string
}

type ControllerBattery struct {
	// Percent is nil when the hardware reports only a coarse level.
	Percent *int
	Level   string
	// ChargeState is empty when the hardware does not say.
	ChargeState power.ChargeState
}

type DefaultOptions struct {
	Executor command.Executor
	// VirtualGamepadSlots returns the controller slots held by gamepads Core
	// itself created, on systems that number controllers. May be nil.
	VirtualGamepadSlots func() []int
	// VirtualInputName is the name of the input device Core creates, which
	// must never be reported as a controller.
	VirtualInputName string
}

type DiskUsage struct {
	Total uint64
	// Free is every unallocated byte; Available is the part of it the calling
	// user may use.
	Free      uint64
	Available uint64
}

type Display struct {
	// Docked is nil on a device with no built-in panel, where the question
	// has no meaning.
	Docked            *bool
	InternalPanel     bool
	InternalActive    bool
	ExternalConnected bool
	ExternalActive    bool
}

type ExecPowerControl struct {
	Executor command.Executor
	// Commands maps each action the device supports to the program and
	// arguments that perform it.
	Commands map[PowerAction][]string
	// Permitted reports whether this process may run the commands. Nil means
	// it always may.
	Permitted func() bool
}

type InputModalias struct {
	Keys    []uint16
	Bus     uint16
	Vendor  uint16
	Product uint16
}

type Interface struct {
	Name string
	Type LinkType
	// Addresses excludes loopback and link-local addresses.
	Addresses []string
	Up        bool
}

type InternetState string

type LinkType string

type LinuxBluetooth struct {
	Fs afero.Fs

	SysRoot string
	// contains filtered or unexported fields
}

type LinuxControllers struct {
	Fs afero.Fs
	// Resolve returns the real device path behind a sysfs class entry.
	Resolve func(path string) (string, error)
	// Batteries returns the charge BlueZ reads from Bluetooth devices' own
	// battery service, keyed by lower-case address. It covers pads whose
	// kernel driver adds no battery, such as the Xbox Wireless Controller over
	// Bluetooth LE. It may be nil.
	Batteries   func() map[string]int
	InputRoot   string
	PowerRoot   string
	VirtualName string
}

type LinuxDisplay struct {
	Fs      afero.Fs
	DRMRoot string
}

type LinuxNetwork struct {
	Fs         afero.Fs
	Interfaces func() ([]RawInterface, error)

	ProcRoute string
	SysNet    string
	// contains filtered or unexported fields
}

type LinuxPowerControl struct {
	Fallback PowerController
	// contains filtered or unexported fields
}

type LinuxSystem struct {
	Fs         afero.Fs
	Hostname   func() (string, error)
	ModelPaths []string
}

type Network struct {
	// Type and Interface describe the link holding the default route.
	Type      LinkType
	Interface string
	// Internet is filled in by the reader only when InternetAuthoritative is
	// set; otherwise the caller decides it by probing.
	Internet   InternetState
	Interfaces []Interface
	// InternetAuthoritative means the operating system or the embedding host
	// already checks reachability and Internet is its answer.
	InternetAuthoritative bool
}

type NoPowerControl struct{}

type PowerAction string

type PowerController interface {
	// PowerActions reports which actions this device can carry out for this
	// process. An action missing from the map is unsupported.
	PowerActions(ctx context.Context) map[PowerAction]Availability
	// PreparePowerAction checks that the action can go ahead and returns the
	// function that performs it. Refusals are reported here, with
	// ErrUnsupported or ErrNotPermitted, because by the time commit runs the
	// caller has already been answered.
	PreparePowerAction(ctx context.Context, action PowerAction) (commit func() error, err error)
}

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

type RawInterface struct {
	Name      string
	Addresses []net.IP
	Loopback  bool
	Up        bool
}

type Readers struct {
	Power        func() (power.Detail, error)
	Network      func() (Network, error)
	Bluetooth    func() (Bluetooth, error)
	Storage      func(roots []StorageRoot) ([]Volume, error)
	Display      func() (Display, error)
	Controllers  func() ([]Controller, error)
	System       func() (System, error)
	PowerControl PowerController
	// BluetoothControl is nil when Core cannot manage Bluetooth devices here.
	BluetoothControl BluetoothController
}

type StorageReader struct {
	Usage func(path string) (DiskUsage, error)
	// FilesystemID returns the filesystem's identity and, where it is known,
	// its mount point.
	FilesystemID func(path string) (id, mountPoint string, err error)
	// IsEmpty reports whether a directory holds nothing. It is optional.
	IsEmpty func(path string) bool
	// Resolve follows the symlinks in a path, as FilesystemID does before it
	// names a mount point. It is optional.
	Resolve func(path string) (string, error)
}

type StorageRoot struct {
	Path string
	Role string
}

type System struct {
	Hostname string
	Model    string
}

type Volume struct {
	// Path is where the filesystem is mounted, or the first root found on it
	// when that is not known.
	Path  string
	Roles []string
	Total uint64
	// Free is the space available to the user Core runs as.
	Free uint64
	Used uint64
}