filesystem

type Btrfs struct {
	Label        string        `json:"label"`
	UUID         string        `json:"uuid"`
	TotalDevices int           `json:"total_devices"`
	Used         int64         `json:"used"`
	Devices      []BtrfsDevice `json:"devices"`
	Warnings     string        `json:"warnings"`
}

type BtrfsDevice struct {
	Missing bool   `json:"missing,omitempty"`
	DevID   int    `json:"dev_id"`
	Size    int64  `json:"size"`
	Used    int64  `json:"used"`
	Path    string `json:"path"`
}

type BtrfsDiskUsage struct {
	Data          DiskUsage `json:"data"`
	System        DiskUsage `json:"system"`
	Metadata      DiskUsage `json:"metadata"`
	GlobalReserve DiskUsage `json:"globalreserve"`
}

type BtrfsQGroup struct {
	ID      string
	Rfer    uint64
	Excl    uint64
	MaxRfer uint64
	MaxExcl uint64
}

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

type BtrfsVolume struct {
	Path       string
	ID         int
	Generation int
	ParentID   int
}

type DeviceInfo struct {
	Path       string       `json:"path"`
	Label      string       `json:"label"`
	Size       uint64       `json:"size"`
	Filesystem FSType       `json:"fstype"`
	Rota       bool         `json:"rota"`
	Subsystems string       `json:"subsystems"`
	UUID       string       `json:"uuid"`
	Children   []DeviceInfo `json:"children,omitempty"`
	// contains filtered or unexported fields
}

type DeviceManager interface {
	// Device returns the device at the specified path
	Device(ctx context.Context, device string) (DeviceInfo, error)
	// Devices finds all devices on a system
	Devices(ctx context.Context) (Devices, error)
	// ByLabel finds all devices with the specified label
	ByLabel(ctx context.Context, label string) (Devices, error)
	// Mountpoint returns mount point of a device
	Mountpoint(ctx context.Context, device string) (string, error)
	// Seektime checks device seektime
	Seektime(ctx context.Context, device string) (zos.DeviceType, error)
	// ClearCache clears the cached devices to refresh
	ClearCache()
}

type Devices []DeviceInfo

type DiskSpace struct {
	Number int    `json:"number"`
	Start  string `json:"start"`
	End    string `json:"end"`
	Type   string `json:"type"`
	Size   string `json:"size"`
}

type DiskUsage struct {
	Total uint64 `json:"total"`
	Used  uint64 `json:"used"`
}

type FSType string

type Filter func(pool Pool) bool

type Pool interface {
	Volume
	// Mounted returns whether the pool is mounted or not. If it is mounted,
	// the mountpoint is returned
	Mounted() (string, error)
	// Mount the pool, the mountpoint is returned
	Mount() (string, error)
	// UnMount the pool
	UnMount() error
	// Volumes are all subvolumes of this volume
	Volumes() ([]Volume, error)
	// AddVolume adds a new subvolume with the given name
	AddVolume(name string) (Volume, error)
	// RemoveVolume removes a subvolume with the given name
	RemoveVolume(name string) error
	// Shutdown spins down the device where the pool is mounted
	Shutdown() error
	// Device return device associated with pool
	Device() DeviceInfo
	// SetType sets a device type on the pool. this will make
	// sure that the detected device type is reported
	// correctly by calling the Type() method.
	SetType(typ zos.DeviceType) error
	// Type returns the device type set by a previous call
	// to SetType.
	Type() (zos.DeviceType, bool, error)
}

type Usage struct {
	// Size is allocated space for this Volume
	// if 0 it means it has no limit.
	// if it has no-limit, the Used attribute
	// will be the total size of actual files
	// inside the volume. It also means the Used
	// can keep growing to the max possible which
	// is the size of the pool
	Size uint64
	// Used can be one of 2 things:
	// - If Size is not zero (so size is limited), Used will always equal to size
	//   because that's the total reserved space for that volume.
	// - If Size is zero, (no limit) Used will be the total actual size of all
	//   files in that volume.
	// The reason Used is done this way, it will make it easier to compute
	// all allocated space in a pool by going over all volumes and add the
	// used on each. It does not matter if this space is reserved but not used
	// because it means we can't allocate over that.
	//
	// NOTE: Special case, if this is a `zdb` volume the Used is instead
	// have the total size of reserved namespaces in that volume
	Used uint64

	// In case of `limited` volume (with quota) Excl will have a "guessed"
	// value of the total used space by files. This value is not accurate
	// and Used should be used instead for all capacity planning.
	Excl uint64
}

type Volume interface {
	// Volume ID
	ID() int
	// Path of the volume
	Path() string
	// Usage reports the current usage of the volume
	Usage() (Usage, error)
	// Limit the maximum size of the volume
	Limit(size uint64) error
	// Name of the volume
	Name() string
	// FsType of the volume
	FsType() string
}