v1alpha1

type BlockDevice struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   DeviceSpec   `json:"spec,omitempty"`
	Status DeviceStatus `json:"status,omitempty"`
}

type BlockDeviceClaim struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   DeviceClaimSpec   `json:"spec,omitempty"`
	Status DeviceClaimStatus `json:"status,omitempty"`
}

type BlockDeviceClaimList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BlockDeviceClaim `json:"items"`
}

type BlockDeviceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BlockDevice `json:"items"`
}

type BlockDeviceNodeAttributes struct {
	// NodeName represents the name of the Kubernetes node resource
	// where the BD should be present
	NodeName string `json:"nodeName,omitempty"`

	// HostName represents the hostname of the Kubernetes node resource
	// where the BD should be present
	HostName string `json:"hostName,omitempty"`
}

type BlockDeviceState string

type BlockDeviceVolumeMode string

type DeviceCapacity struct {
	// Storage is the blockdevice capacity in bytes
	Storage uint64 `json:"storage"`

	// PhysicalSectorSize is blockdevice physical-Sector size in bytes
	PhysicalSectorSize uint32 `json:"physicalSectorSize"`

	// LogicalSectorSize is blockdevice logical-sector size in bytes
	LogicalSectorSize uint32 `json:"logicalSectorSize"`
}

type DeviceClaimDetails struct {
	// BlockVolumeMode represents whether to claim a device in Block mode or Filesystem mode.
	// These are use cases of BlockVolumeMode:
	// 1) Not specified: VolumeMode check will not be effective
	// 2) VolumeModeBlock: BD should not have any filesystem or mountpoint
	// 3) VolumeModeFileSystem: BD should have a filesystem and mountpoint. If DeviceFormat is
	//    specified then the format should match with the FSType in BD
	BlockVolumeMode BlockDeviceVolumeMode `json:"blockVolumeMode,omitempty"`

	//Format of the device required, eg:ext4, xfs
	DeviceFormat string `json:"formatType,omitempty"`

	//AllowPartition represents whether to claim a full block device or a device that is a partition
	AllowPartition bool `json:"allowPartition,omitempty"`
}

type DeviceClaimPhase string

type DeviceClaimResources struct {
	// Requests describes the minimum resources required. eg: if storage resource of 10G is
	// requested minimum capacity of 10G should be available
	Requests v1.ResourceList `json:"requests"`
}

type DeviceClaimSpec struct {

	// Selector is used to find block devices to be considered for claiming
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// Resources will help with placing claims on Capacity, IOPS
	Resources DeviceClaimResources `json:"resources"`

	// DeviceType represents the type of drive like SSD, HDD etc.,
	DeviceType string `json:"deviceType"`

	// Node name from where blockdevice has to be claimed.
	// TODO @akhilerm to be deprecated. Use NodeAttributes.HostName instead
	HostName string `json:"hostName"`

	// Details of the device to be claimed
	Details DeviceClaimDetails `json:"deviceClaimDetails,omitempty"`

	// BlockDeviceName is the reference to the block-device backing this claim
	BlockDeviceName string `json:"blockDeviceName,omitempty"`

	// BlockDeviceNodeAttributes is the attributes on the node from which a BD should
	// be selected for this claim. It can include nodename, failure domain etc.
	BlockDeviceNodeAttributes BlockDeviceNodeAttributes `json:"blockDeviceNodeAttributes,omitempty"`
}

type DeviceClaimState string

type DeviceClaimStatus struct {
	// Phase represents the current phase of the claim
	Phase DeviceClaimPhase `json:"phase"`
}

type DeviceDetails struct {
	// DeviceType represents the type of device like
	// sparse, disk, partition, lvm, raid
	DeviceType string `json:"deviceType"`

	// DriveType is the type of backing drive, HDD/SSD
	DriveType string `json:"driveType"`

	// LogicalBlockSize is the logical block size in bytes
	// reported by /sys/class/block/sda/queue/logical_block_size
	LogicalBlockSize uint32 `json:"logicalBlockSize"`

	// PhysicalBlockSize is the physical block size in bytes
	// reported by /sys/class/block/sda/queue/physical_block_size
	PhysicalBlockSize uint32 `json:"physicalBlockSize"`

	// HardwareSectorSize is the hardware sector size in bytes
	HardwareSectorSize uint32 `json:"hardwareSectorSize"`

	// Model is model of disk
	Model string `json:"model"`

	// Compliance is standards/specifications version implemented by device firmware
	//  such as SPC-1, SPC-2, etc
	Compliance string `json:"compliance"`

	// Serial is serial number of disk
	Serial string `json:"serial"`

	// Vendor is vendor of disk
	Vendor string `json:"vendor"`

	// FirmwareRevision is the disk firmware revision
	FirmwareRevision string `json:"firmwareRevision"`
}

type DeviceDevLink struct {
	// Kind is the type of link like by-id or by-path.
	Kind string `json:"kind,omitempty"`

	// Links are the soft links
	Links []string `json:"links,omitempty"`
}

type DeviceInfo struct {
	// DeviceUID is the NDM generated UID of the backed block device
	DeviceUID string `json:"blockDeviceUID"`
}

type DeviceSpec struct {
	// NodeAttributes has the details of the node on which BD is attached
	NodeAttributes NodeAttribute `json:"nodeAttributes"`

	// Path contain devpath (e.g. /dev/sdb)
	Path string `json:"path"`

	// Capacity
	Capacity DeviceCapacity `json:"capacity"`

	// Details contain static attributes of BD like model,serial, and so forth
	Details DeviceDetails `json:"details"`

	// ClaimRef is the reference to the BDC which has claimed this BD
	ClaimRef *v1.ObjectReference `json:"claimRef,omitempty"`

	// DevLinks contains soft links of a block device like
	// /dev/by-id/...
	// /dev/by-uuid/...
	DevLinks []DeviceDevLink `json:"devlinks"`

	// FileSystem contains mountpoint and filesystem type
	FileSystem FileSystemInfo `json:"filesystem,omitempty"`

	// Partitioned represents if BlockDevice has partitions or not (Yes/No)
	// Currently always default to No.
	// TODO @kmova to be implemented/deprecated
	Partitioned string `json:"partitioned"`

	// ParentDevice was intended to store the UUID of the parent
	// Block Device as is the case for partitioned block devices.
	//
	// For example:
	// /dev/sda is the parent for /dev/sdap1
	// TODO @kmova to be implemented/deprecated
	ParentDevice string `json:"parentDevice,omitempty"`

	// AggregateDevice was intended to store the hierachical
	// information in cases of LVM. However this is currently
	// not implemented and may need to be re-looked into for
	// better design.
	// TODO @kmova to be implemented/deprecated
	AggregateDevice string `json:"aggregateDevice,omitempty"`
}

type DeviceStatus struct {
	// ClaimState represents the claim state of the block device
	ClaimState DeviceClaimState `json:"claimState"`

	// State is the current state of the blockdevice (Active/Inactive)
	State BlockDeviceState `json:"state"`
}

type Disk struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   DiskSpec   `json:"spec,omitempty"`
	Status DiskStatus `json:"status,omitempty"`
	Stats  DiskStat   `json:"stats,omitempty"`
	Device DeviceInfo `json:"deviceInfo"`
}

type DiskCapacity struct {
	// Storage is the disk capacity in bytes
	Storage uint64 `json:"storage"`

	// PhysicalSectorSize is disk physical-Sector size in bytes
	PhysicalSectorSize uint32 `json:"physicalSectorSize"`

	// LogicalSectorSize is disk logical-sector size in bytes
	LogicalSectorSize uint32 `json:"logicalSectorSize"`
}

type DiskDetails struct {
	// RotationRate is the rotation rate in RPM of the disk if not an SSD
	RotationRate uint16 `json:"rotationRate"`

	// DriveType represents the type of the drive like SSD, HDD etc.
	DriveType string `json:"driveType"`

	// Model is model of disk
	Model string `json:"model"`

	// Compliance is standards/specifications version implemented by device firmware
	//  such as SPC-1, SPC-2, etc
	Compliance string `json:"compliance"`

	// Serial is serial number of disk
	Serial string `json:"serial"`

	// Vendor is vendor of disk
	Vendor string `json:"vendor"`

	// FirmwareRevision is the disk firmware revision
	FirmwareRevision string `json:"firmwareRevision"`
}

type DiskDevLink struct {
	// Kind is the type of link like by-id or by-path.
	Kind string `json:"kind"`

	// Links are the soft links
	Links []string `json:"links"`
}

type DiskList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Disk `json:"items"`
}

type DiskSpec struct {
	// Path contain devpath (e.g. /dev/sdb)
	Path string `json:"path"`

	// Capacity of the
	Capacity DiskCapacity `json:"capacity"`

	// Details contains static attributes (model, serial ..)
	Details DiskDetails `json:"details"`

	// DevLinks contains soft links of one disk
	DevLinks []DiskDevLink `json:"devlinks"`

	// Contains the data about filesystem on the disk
	FileSystem FileSystemInfo `json:"fileSystem,omitempty"`

	// Details of partitions in the disk (filesystem, partition type)
	PartitionDetails []Partition `json:"partitionDetails,omitempty"`
}

type DiskStat struct {
	// TempInfo is the reported temperate of the disk
	TempInfo Temperature `json:"diskTemperature"`

	// TotalBytesRead
	// TODO @akhilerm document on what TotalBytesRead represent in a drive
	TotalBytesRead uint64 `json:"totalBytesRead"`

	// TotalBytesWritten
	// TODO @akhilerm document on what TotalBytesWritten represent in a drive
	TotalBytesWritten uint64 `json:"totalBytesWritten"`

	// DeviceUtilizationRate is utilization rate of the drive
	// ACS4 or SBC4 required for this to be valid
	DeviceUtilizationRate float64 `json:"deviceUtilizationRate"`

	// PercentEnduranceUsed
	// TODO @akhilerm document on what PercentEnduranceUsed represent in a drive
	PercentEnduranceUsed float64 `json:"percentEnduranceUsed"`
}

type DiskState string

type DiskStatus struct {
	// State is the current state of the disk (Active/Inactive)
	State DiskState `json:"state"`
}

type FileSystemInfo struct {
	//Type represents the FileSystem type of the block device
	Type string `json:"fsType,omitempty"`

	//MountPoint represents the mountpoint of the block device.
	Mountpoint string `json:"mountPoint,omitempty"`
}

type NodeAttribute struct {
	// NodeName is the name of the Kubernetes node resource on which the device is attached
	NodeName string `json:"nodeName"`
}

type Partition struct {
	// PartitionType is the partition type of this partition.
	// LinuxLVM, SWAP, EFI are all partition types. They will be represented by
	// their corresponding code depending on the Partition table.
	//
	// Depending on the partition table on parent disk:
	// 1. For DOS partition table, two hexadecimal digits will be
	//    used for partition type
	// 2. For GPT partition table, a GUID will be present which corresponds to
	//    partition type in the format of `00000000-0000-0000-0000-000000000000`
	PartitionType string `json:"partitionType"`

	// FileSystem contains mountpoint and filesystem type
	FileSystem FileSystemInfo `json:"fileSystem,omitempty"`
}

type Temperature struct {
	// CurrentTemperature is the current reported temperature of the drive
	CurrentTemperature int16 `json:"currentTemperature"`

	// HighestTemperature is the highest measured temperature of the drive in its lifetime
	HighestTemperature int16 `json:"highestTemperature"`

	// LowestTemperature is the lowest measured temperature of the drive in its lifetime
	LowestTemperature int16 `json:"lowestTemperature"`
}