blockdevice

type BlockDevice struct {

	// Identifier is the unique identifiers that can be used to identify this
	// blockdevice
	Identifier

	// NodeAttributes contains the details of the node on which
	// the BlockDevice is attached
	NodeAttributes NodeAttribute

	// Labels for this blockdevice. These labels will be used on the k8s resource that is created
	// optional
	Labels map[string]string

	// FSInfo contains the file system related information of this
	// BlockDevice if it exists
	FSInfo FileSystemInformation

	// Capacity contains the capacity related information for this blockdevice
	Capacity CapacityInformation

	// DevLinks contain the devlinks of this blockdevice
	DevLinks []DevLink

	// DeviceAttributes contains the attributes of this device, like hardcoded
	// information on the disk
	DeviceAttributes DeviceAttribute

	// DMInfo is filled if the device is a DM device
	DMInfo DeviceMapperInformation

	DevUse DeviceUsage

	// PartitionInfo contains details if this blockdevice is a partition
	PartitionInfo PartitionInformation

	// DependentDevices stores the dependent devices
	DependentDevices DependentBlockDevices

	SMARTInfo SMARTStats

	// Status contains the state of the blockdevice
	Status Status
}

type CapacityInformation struct {
	// Storage is the storage capacity of this blockdevice
	// in bytes
	Storage uint64
}

type DependentBlockDevices struct {
	// Parent is the parent device of this blockdevice, if it exists.
	// It will always be a single device.
	Parent string

	// Partitions is the list of partitions(again blockdevices) for
	// this blockdevice, if it exists.
	Partitions []string

	// Holders is the list of blockdevices that are held by this blockdevice.
	// eg: sda1 can hold dm-0. Then the list of sda1 will contain dm-0.
	Holders []string

	// Slaves is the list of blockdevices to which this blockdevice is a slave.
	// Slaves are represented in SysFS under the block device layer,
	// so they are dependent on the device
	// eg: dm-0 is a slave to sda1. Then the list of dm-0 will contain sda1
	Slaves []string
}

type DevLink struct {
	// Kind is the type of devlink.
	// Eg: by-id, by-path, by-uuid, by-partuuid
	Kind string

	// Links is the list of actual links that point to the device
	Links []string
}

type DeviceAttribute struct {
	// DeviceType is the type of the blockdevice.
	// Values can be sparse/disk/partition/loop/lvm/raid etc
	DeviceType string

	// DriveType is the type of backing drive for this blockdevice. HDD/SSD
	DriveType string

	// IDType is the udev ID_TYPE field. This is solely used for purpose of UUID generation
	// using the old algorithm
	IDType string

	// PhysicalBlockSize is the physical block size in bytes
	// reported by /sys/class/block/sda/queue/physical_block_size
	//
	// This is the unit in which the disk actually reads and writes
	// the data atomically. Certain 4K sector devices may use a
	// 4K 'physical_block_size' internally but expose a finer-grained
	// 512 byte 'logical_block_size' to Linux. Also the current HDDs
	// are advanced format (https://en.wikipedia.org/wiki/Advanced_Format)
	// so they support 4k physical sector size.
	PhysicalBlockSize uint32

	// LogicalBlockSize is the logical block size in bytes
	// reported by /sys/class/block/sda/queue/logical_block_size
	//
	// The smallest size the drive is able to write. This can be
	// different than hw_sector_size as disks may lie about this
	// to support lower/higher sector size. This is important for
	// direct IOs, as IOs should be aligned on a 'logical_block_size'
	// boundaries.
	LogicalBlockSize uint32

	// HardwareSectorSize is the hardware sector size in bytes
	// reported by /sys/class/block/sda/queue/hw_sector_size
	//
	// This is the actual sector size of the disk
	HardwareSectorSize uint32

	// WWN
	WWN string

	// Vendor
	Vendor string

	// Model of the device
	// Eg : PersistentDisk, Virtaul_disk, QEMU_HARDDISK, EphemeralDisk
	Model string

	// Serial number of the device
	Serial string

	// FirmwareRevision
	FirmwareRevision string

	// Compliance is implemented specifications version i.e. SPC-1, SPC-2, etc
	Compliance string
}

type DeviceMapperInformation struct {
	// DMUUID is the UUID of the device as present in <dev-sys-path>/dm/uuid
	DMUUID string

	// DevMapperPath is the device mapper path. It will be of the format /dev/mapper/<mapper>
	// This path will be a symlink to the actual dm-X device node
	DevMapperPath string
}

type DeviceUsage struct {
	InUse  bool
	UsedBy StorageEngine
}

type FileSystemInformation struct {
	// FileSystemUUID is the UUID of the filesystem on the blockdevice
	FileSystemUUID string

	// FileSystem is the filesystem present on the blockdevice
	FileSystem string

	// MountPoint is the list of mountpoints at which this blockdevice is mounted
	MountPoint []string
}

type Hierarchy map[string]BlockDevice

type Identifier struct {
	// UUID is a system generated unique ID for this blockdevice
	UUID string

	// SysPath is the syspath of this device.
	// Eg : /sys/dev/block/8:1
	SysPath string

	// DevPath is the name of the device in /dev
	DevPath string
}

type NodeAttribute map[string]string

type PartitionInformation struct {
	// PartitionNumber is the partition number
	PartitionNumber uint8

	// PartitionEntryUUID is the UUID of the partition
	PartitionEntryUUID string

	// PartitionTableUUID is the UUID of the partition table
	PartitionTableUUID string

	// PartitionTableType is the type of the partition (dos/gpt)
	PartitionTableType string
}

type SMARTStats struct {

	// RotationRate stores the rotation rate of a block device, only applicable for HDD
	RotationRate uint16

	// RotationalLatency stores the latency of the drive, only applicable for HDD
	RotationalLatency float64

	// TemperatureInfo stores the temperature information of the drive
	TemperatureInfo TemperatureInformation

	// TotalBytesRead stores the total amount of bytes read by a block device
	TotalBytesRead uint64

	// TotalBytesWritten stores the total amount of bytes written by a block device
	TotalBytesWritten uint64

	// UtilizationRate stores the rate of utilization of a block device
	UtilizationRate float64

	// PercentEnduranceUsed stores the endurance used in percent
	PercentEnduranceUsed float64
}

type Status struct {
	// State is the state of this BD like Active(Online), Inactive(Offline) or
	// Unknown
	State string

	// ClaimPhase is the phase of this BD when is it is being used by NDM consumers
	ClaimPhase string
}

type StorageEngine string

type TemperatureInformation struct {
	// CurrentTemperatureDataValid specifies whether the current temperature
	// data reported is valid or not
	CurrentTemperatureDataValid bool

	// LowestTemperatureDataValid specifies whether the lowest temperature
	// data reported is valid or not
	LowestTemperatureDataValid bool

	// HighestTemperatureDataValid specifies whether the highest temperature
	// data reported is valid or not
	HighestTemperatureDataValid bool

	// CurrentTemperature is the temperature of the drive in celsius
	CurrentTemperature int16

	// LowestTemperature is the lowest temperature of the drive recorded in celsius
	LowestTemperature int16

	// HighestTemperature is the highest temperature of the drive recorded in celsius
	HighestTemperature int16
}