feat(disk): add methods to retrieve block disk health info

longhorn/longhorn-12016

Signed-off-by: Chin-Ya Huang <[email protected]>

Author: c3y1huang

pkg/api/disk.go

@@ -35,3 +35,27 @@ type DiskMetrics struct {
 	ReadIOPS        uint64
 	WriteIOPS       uint64
 }
+
+type DiskHealth struct {
+	ModelNumber                             string
+	SerialNumber                            string
+	FirmwareRevision                        string
+	Traddr                                  string
+	CriticalWarning                         uint32
+	TemperatureCelsius                      float64
+	AvailableSparePercentage                uint32
+	AvailableSpareThresholdPercentage       uint32
+	PercentageUsed                          uint32
+	DataUnitsRead                           uint64
+	DataUnitsWritten                        uint64
+	HostReadCommands                        uint64
+	HostWriteCommands                       uint64
+	ControllerBusyTime                      uint64
+	PowerCycles                             uint64
+	PowerOnHours                            uint64
+	UnsafeShutdowns                         uint64
+	MediaErrors                             uint64
+	NumErrLogEntries                        uint64
+	WarningTemperatureTimeMinutes           uint64
+	CriticalCompositeTemperatureTimeMinutes uint64
+}

pkg/client/disk.go

@@ -172,6 +172,56 @@ func (c *DiskServiceClient) DiskGet(diskType, diskName, diskPath, diskDriver str
 	}, nil
 }
 
+// DiskHealthGet returns the disk health info with the given name, path and driver.
+func (c *DiskServiceClient) DiskHealthGet(diskType, diskName, diskPath, diskDriver string) (*api.DiskHealth, error) {
+	if diskName == "" {
+		return nil, fmt.Errorf("failed to get disk health info: missing required parameter diskName")
+	}
+
+	t, ok := rpc.DiskType_value[diskType]
+	if !ok {
+		return nil, fmt.Errorf("failed to get disk health info: invalid disk type %v", diskType)
+	}
+
+	client := c.getDiskServiceClient()
+	ctx, cancel := context.WithTimeout(context.Background(), types.GRPCServiceTimeout)
+	defer cancel()
+
+	resp, err := client.DiskHealthGet(ctx, &rpc.DiskHealthGetRequest{
+		DiskType:   rpc.DiskType(t),
+		DiskName:   diskName,
+		DiskPath:   diskPath,
+		DiskDriver: diskDriver,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.DiskHealth{
+		ModelNumber:                             resp.GetModelNumber(),
+		SerialNumber:                            resp.GetSerialNumber(),
+		FirmwareRevision:                        resp.GetFirmwareRevision(),
+		Traddr:                                  resp.GetTraddr(),
+		CriticalWarning:                         resp.GetCriticalWarning(),
+		TemperatureCelsius:                      resp.GetTemperatureCelsius(),
+		AvailableSparePercentage:                resp.GetAvailableSparePercentage(),
+		AvailableSpareThresholdPercentage:       resp.GetAvailableSpareThresholdPercentage(),
+		PercentageUsed:                          resp.GetPercentageUsed(),
+		DataUnitsRead:                           resp.GetDataUnitsRead(),
+		DataUnitsWritten:                        resp.GetDataUnitsWritten(),
+		HostReadCommands:                        resp.GetHostReadCommands(),
+		HostWriteCommands:                       resp.GetHostWriteCommands(),
+		ControllerBusyTime:                      resp.GetControllerBusyTime(),
+		PowerCycles:                             resp.GetPowerCycles(),
+		PowerOnHours:                            resp.GetPowerOnHours(),
+		UnsafeShutdowns:                         resp.GetUnsafeShutdowns(),
+		MediaErrors:                             resp.GetMediaErrors(),
+		NumErrLogEntries:                        resp.GetNumErrLogEntries(),
+		WarningTemperatureTimeMinutes:           resp.GetWarningTemperatureTimeMinutes(),
+		CriticalCompositeTemperatureTimeMinutes: resp.GetCriticalCompositeTemperatureTimeMinutes(),
+	}, nil
+}
+
 // DiskDelete deletes the disk with the given name, disk name, disk UUID, disk path and disk driver.
 func (c *DiskServiceClient) DiskDelete(diskType, diskName, diskUUID, diskPath, diskDriver string) error {
 	if diskName == "" {

pkg/disk/disk.go

@@ -33,6 +33,7 @@ type DiskOps interface {
 	DiskCreate(context.Context, *rpc.DiskCreateRequest) (*rpc.Disk, error)
 	DiskDelete(*rpc.DiskDeleteRequest) (*emptypb.Empty, error)
 	DiskGet(req *rpc.DiskGetRequest) (*rpc.Disk, error)
+	DiskHealthGet(req *rpc.DiskHealthGetRequest) (*rpc.DiskHealthGetResponse, error)
 	DiskReplicaInstanceList(*rpc.DiskReplicaInstanceListRequest) (*rpc.DiskReplicaInstanceListResponse, error)
 	DiskReplicaInstanceDelete(*rpc.DiskReplicaInstanceDeleteRequest) (*emptypb.Empty, error)
 	MetricsGet(*rpc.DiskGetRequest) (*rpc.DiskMetricsGetReply, error)
@@ -202,6 +203,53 @@ func (ops BlockDiskOps) DiskGet(req *rpc.DiskGetRequest) (*rpc.Disk, error) {
 	return spdkDiskToDisk(ret), nil
 }
 
+func (s *Server) DiskHealthGet(ctx context.Context, req *rpc.DiskHealthGetRequest) (*rpc.DiskHealthGetResponse, error) {
+	if req.DiskName == "" {
+		return nil, grpcstatus.Error(grpccodes.InvalidArgument, "disk name is required")
+	}
+
+	ops, ok := s.ops[req.DiskType]
+	if !ok {
+		return nil, grpcstatus.Errorf(grpccodes.Unimplemented, "unsupported disk type %v", req.DiskType)
+	}
+	return ops.DiskHealthGet(req)
+}
+
+func (op FilesystemDiskOps) DiskHealthGet(req *rpc.DiskHealthGetRequest) (*rpc.DiskHealthGetResponse, error) {
+	return nil, grpcstatus.Errorf(grpccodes.Unimplemented, "unsupported disk type %v", req.DiskType)
+}
+
+func (op BlockDiskOps) DiskHealthGet(req *rpc.DiskHealthGetRequest) (*rpc.DiskHealthGetResponse, error) {
+	health, err := op.spdkClient.DiskHealthGet(req.DiskName, req.DiskPath, req.DiskDriver)
+	if err != nil {
+		return nil, grpcstatus.Error(grpccodes.Internal, err.Error())
+	}
+
+	return &rpc.DiskHealthGetResponse{
+		ModelNumber:                             health.ModelNumber,
+		SerialNumber:                            health.SerialNumber,
+		FirmwareRevision:                        health.FirmwareRevision,
+		Traddr:                                  health.Traddr,
+		CriticalWarning:                         health.CriticalWarning,
+		TemperatureCelsius:                      health.TemperatureCelsius,
+		AvailableSparePercentage:                health.AvailableSparePercentage,
+		AvailableSpareThresholdPercentage:       health.AvailableSpareThresholdPercentage,
+		PercentageUsed:                          health.PercentageUsed,
+		DataUnitsRead:                           health.DataUnitsRead,
+		DataUnitsWritten:                        health.DataUnitsWritten,
+		HostReadCommands:                        health.HostReadCommands,
+		HostWriteCommands:                       health.HostWriteCommands,
+		ControllerBusyTime:                      health.ControllerBusyTime,
+		PowerCycles:                             health.PowerCycles,
+		PowerOnHours:                            health.PowerOnHours,
+		UnsafeShutdowns:                         health.UnsafeShutdowns,
+		MediaErrors:                             health.MediaErrors,
+		NumErrLogEntries:                        health.NumErrLogEntries,
+		WarningTemperatureTimeMinutes:           health.WarningTemperatureTimeMinutes,
+		CriticalCompositeTemperatureTimeMinutes: health.CriticalCompositeTemperatureTimeMinutes,
+	}, nil
+}
+
 func (s *Server) DiskReplicaInstanceList(ctx context.Context, req *rpc.DiskReplicaInstanceListRequest) (*rpc.DiskReplicaInstanceListResponse, error) {
 	log := logrus.WithFields(logrus.Fields{
 		"diskType": req.DiskType,