megaraid: Properly handle permanent Path and device Path

pkg/domain/entities/physicaldrive/types.go

@@ -2,11 +2,14 @@
 package physicaldrive
 
 import (
+	"fmt"
+	"path/filepath"
 	"strings"
 
 	"github.com/pkg/errors"
 
 	"github.com/scality/raidmgmt/pkg/domain/entities/raidcontroller"
+	"github.com/scality/raidmgmt/pkg/utils"
 )
 
 const (
@@ -23,6 +26,7 @@ type (
 		Vendor        string   `json:"vendor,omitempty"`         // Vendor
 		Model         string   `json:"model,omitempty"`          // Model
 		Serial        string   `json:"serial,omitempty"`         // Serial number
+		WWN           string   `json:"wwn,omitempty"`            // World Wide Name
 		Size          uint64   `json:"size,omitempty"`           // Size in bytes
 		Type          DiskType `json:"type,omitempty"`           // Type (e.g.: HDD, SSD)
 		JBOD          bool     `json:"jbod,omitempty"`           // Is the disk in JBOD mode
@@ -110,6 +114,71 @@ func (pd *PhysicalDrive) IsAvailable() bool {
 	return pd.Status == PDStatusUnassignedGood
 }
 
+// ComputePermanentPath computes the permanent path of the physical drive.
+// NOTE: For physical drives backed by hardware RAID controllers this might not
+// be available.
+// nolint: funlen,nestif // This function is pretty simple to follow.
+func (pd *PhysicalDrive) ComputePaths() error {
+	if pd.PermanentPath == "" {
+		if pd.Type == DiskTypeNVMe {
+			if pd.Model != "" && pd.Serial != "" {
+				permanentPath := fmt.Sprintf(
+					"/dev/disk/by-id/nvme-%s_%s",
+					strings.ReplaceAll(pd.Model, " ", "_"),
+					strings.ReplaceAll(pd.Serial, " ", "_"),
+				)
+				if utils.FileExists(permanentPath) {
+					pd.PermanentPath = permanentPath
+				}
+			}
+		} else {
+			if pd.WWN != "" {
+				permanentPath := fmt.Sprintf("/dev/disk/by-id/wwn-%s", pd.WWN)
+				if utils.FileExists(permanentPath) {
+					pd.PermanentPath = permanentPath
+				}
+			}
+
+			if pd.PermanentPath == "" && pd.Vendor != "" && pd.Model != "" && pd.Serial != "" {
+				permanentPath := fmt.Sprintf(
+					"/dev/disk/by-id/scsi-S%s_%s_%s",
+					strings.ReplaceAll(pd.Vendor, " ", "_"),
+					strings.ReplaceAll(pd.Model, " ", "_"),
+					strings.ReplaceAll(pd.Serial, " ", "_"),
+				)
+				if utils.FileExists(permanentPath) {
+					pd.PermanentPath = permanentPath
+				}
+			}
+		}
+
+		if pd.PermanentPath == "" {
+			return errors.New("failed to compute permanent path")
+		}
+	}
+
+	if pd.DevicePath == "" {
+		resolvedPath, err := filepath.EvalSymlinks(pd.PermanentPath)
+		if err != nil {
+			return errors.Wrap(err, "failed to resolve permanent path symlink")
+		}
+
+		pd.DevicePath = resolvedPath
+	} else {
+		// Verify that device path matches the resolved symlink of permanent path
+		resolvedPath, err := filepath.EvalSymlinks(pd.PermanentPath)
+		if err != nil {
+			return errors.Wrap(err, "failed to resolve permanent path symlink")
+		}
+
+		if resolvedPath != pd.DevicePath {
+			return errors.New("device path does not match resolved permanent path")
+		}
+	}
+
+	return nil
+}
+
 // IsEqualTo checks if the Slot instance is equal to another Slot instance.
 func (s *Slot) IsEqualTo(other *Slot) bool {
 	if s == nil && other == nil {

pkg/implementation/raidcontroller/megaraid/logicalvolume.go

@@ -573,10 +573,12 @@ func getPaths(vdp *VDProperties, pdrives []*physicaldrive.PhysicalDrive) (
 
 		pd := pdrives[0]
 
-		permanentPath = computePermanentPath(pd)
-		if !CustomFileExists(permanentPath) {
-			return devicePath, "", errors.New("failed to get permanent path from physical drive")
+		err = pd.ComputePaths()
+		if err != nil {
+			return devicePath, "", errors.Wrap(err, "failed to compute paths from physical drive")
 		}
+
+		return pd.DevicePath, pd.PermanentPath, nil
 	}
 
 	// If the devicePath is empty let's retrieve it from the permanent path

pkg/implementation/raidcontroller/megaraid/physicaldrive.go

@@ -2,7 +2,6 @@ package megaraid
 
 import (
 	"fmt"
-	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@@ -119,6 +118,7 @@ func (a *Adapter) physicalDrive(
 		Vendor:   strings.TrimSpace(ddAttributes.ManufacturerID),
 		Model:    strings.TrimSpace(pd.Model),
 		Serial:   strings.TrimSpace(ddAttributes.SerialNumber),
+		WWN:      fmt.Sprintf("0x%s", strings.TrimSpace(ddAttributes.WWN)),
 		Size:     size,
 		Type:     pd.DiskType(),
 		Status:   pd.PDStatus(),
@@ -128,14 +128,9 @@ func (a *Adapter) physicalDrive(
 	}
 
 	if physicalDrive.JBOD {
-		physicalDrive.PermanentPath = computePermanentPath(physicalDrive)
-		if !utils.FileExists((physicalDrive.PermanentPath)) {
-			return nil, errors.New("permanent path does not exist")
-		}
-
-		physicalDrive.DevicePath, err = filepath.EvalSymlinks(physicalDrive.PermanentPath)
+		err := physicalDrive.ComputePaths()
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to evaluate symlinks")
+			return nil, errors.Wrap(err, "failed to compute paths")
 		}
 	}
 
@@ -258,10 +253,3 @@ func (a *Adapter) setJBOD(
 
 	return nil
 }
-
-// computePermanentPath computes the permanent path for a given physical drive.
-// The permanent path is a string that represents the physical drive
-// this may not exists if the drive is not in JBOD.
-func computePermanentPath(pd *physicaldrive.PhysicalDrive) string {
-	return fmt.Sprintf("/dev/disk/by-id/scsi-S%s_%s_%s", pd.Vendor, pd.Model, pd.Serial)
-}