hoststatus

type Availability string

type Bluetooth struct {
	// Powered is nil when the adapter's power state cannot be read.
	Powered *bool
	Present 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
}

type ControllerBattery struct {
	// Percent is nil when the hardware reports only a coarse level.
	Percent *int
	Level   string
}

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)
	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
}

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
}