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 ByReadTime DeviceCache

type Device struct {
	Type       string         `json:"type"`
	Path       string         `json:"name"`
	Label      string         `json:"label"`
	Filesystem FSType         `json:"fstype"`
	Children   []Device       `json:"children"`
	DiskType   pkg.DeviceType `json:"-"`
	ReadTime   uint64         `json:"-"`
	Subsystems string         `json:"subsystems"`
	//HasPartions is different from children, because once the
	//devices are flattend in the device, cache, the children list is
	//zeroed (since all devices are flat), then has partions is set to
	//make sure the device is not altered.
	HasPartions   bool `json:"-"`
	ShutdownCount *expvar.Int
}

type DeviceCache []Device

type DeviceManager interface {
	// Device returns the device at the specified path
	Device(ctx context.Context, device string) (*Device, error)
	// Devices finds all devices on a system
	Devices(ctx context.Context) (DeviceCache, error)
	// ByLabel finds all devices with the specified label
	ByLabel(ctx context.Context, label string) ([]*Device, error)
	// Raw returns the devices as represented in the kernel
	// without using the internal cache, nor flattened
	Raw(ctx context.Context) (DeviceCache, error)
	// Reset returns a "clean" instace of the device manager
	// The implementation must take care to clean any caching
	// or other in-memory states and starting fresh. It's called
	// by some routines to make sure a listing of devices will
	// always return the real state of the system.
	Reset() DeviceManager
}

type DiskUsage struct {
	Profile pkg.RaidProfile `json:"profile"`
	Total   uint64          `json:"total"`
	Used    uint64          `json:"used"`
}

type FSType string

type Filesystem interface {
	// Create a new filesystem.
	//
	// name: name of the filesystem
	// devices: list of devices to use in the filesystem
	// profile: Raid profile of the filesystem
	Create(ctx context.Context, name string, profile pkg.RaidProfile, devices ...*Device) (Pool, error)

	// CreateForce creates a new filesystem with force
	// It will delete existing data and partition tables
	CreateForce(ctx context.Context, name string, profile pkg.RaidProfile, devices ...*Device) (Pool, error)
	// List all existing filesystems on the node
	List(ctx context.Context, filter Filter) ([]Pool, error)
}

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, bool)
	// Mount the pool, the mountpoint is returned
	Mount() (string, error)
	// MountWithoutScan the pool, the mountpoint is returned.
	// Does not scan for btrfs
	MountWithoutScan() (string, error)
	// UnMount the pool
	UnMount() error
	//AddDevice to the pool
	AddDevice(device *Device) error
	// RemoveDevice from the pool
	RemoveDevice(device *Device) error
	// Type of the physical storage in this pool
	Type() pkg.DeviceType
	// Reserved is reserved size of the devices in bytes
	Reserved() (uint64, 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
	// Devices list attached devices
	Devices() []*Device

	// Shutdown spins down the device where the pool is mounted
	Shutdown() error
}

type Usage struct {
	Size uint64
	Used 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
}