diff --git a/pkg/domain/entities/physicaldrive/types.go b/pkg/domain/entities/physicaldrive/types.go index 3446662..a13a5ce 100644 --- a/pkg/domain/entities/physicaldrive/types.go +++ b/pkg/domain/entities/physicaldrive/types.go @@ -19,7 +19,7 @@ type ( PhysicalDrive struct { *Metadata // Metadata of the disk - ID string `json:"id,omitempty"` // ID + Slot *Slot `json:"slot,omitempty"` // Slot Vendor string `json:"vendor,omitempty"` // Vendor Model string `json:"model,omitempty"` // Model Serial string `json:"serial,omitempty"` // Serial number @@ -28,6 +28,7 @@ type ( JBOD bool `json:"jbod,omitempty"` // Is the disk in JBOD mode Status PDStatus `json:"status,omitempty"` // State (e.g.: Online, Offline, Failed) Reason string `json:"reason,omitempty"` // Reason for the disk state + DevicePath string `json:"device_path,omitempty"` // Device path of the disk PermanentPath string `json:"permanent_path,omitempty"` // Permanent path of the array (e.g.: /dev/disk/by-id/...) } @@ -41,8 +42,7 @@ type ( // Metadata represents the metadata of a physical drive. Metadata struct { CtrlMetadata *raidcontroller.Metadata `json:"controller_metadata,omitempty"` // Controller metadata of the disk - DevicePath string `json:"device_path,omitempty"` // Device path of the disk - Slot *Slot `json:"slot,omitempty"` // Slot + ID string `json:"id,omitempty"` // ID } ) @@ -133,16 +133,33 @@ func (m *Metadata) Validate() error { return errors.Wrap(err, "controller metadata is invalid") } - // Detailed validation of the slot is done in each adapter - // as the validation rules may vary between different adapters - // Some fields may be optional or mandatory depending on the adapter - if m.Slot == nil { - return errors.New("slot is nil") + if m.ID == "" { + return errors.New("ID is empty") } - if m.Slot.String() == emptySlot { - return errors.New("slot is empty") + return nil +} + +// ParseSlot parses a string into a Slot instance. +func ParseSlot(slot string) (*Slot, error) { + if slot == "" { + return nil, errors.New("slot is empty") } - return nil + res := &Slot{} + + parts := strings.Split(slot, ":") + if len(parts) > 3 { //nolint:mnd // just the number of parts + return nil, errors.New("invalid slot format (too many parts)") + } + + if len(parts) > 2 { //nolint:mnd // just the number of parts + res.Port, parts = parts[0], parts[1:] + } + if len(parts) > 1 { + res.Enclosure, parts = parts[0], parts[1:] + } + res.Bay = parts[0] + + return res, nil } diff --git a/pkg/implementation/blinker/ssacli.go b/pkg/implementation/blinker/ssacli.go index 3607365..a07eec1 100644 --- a/pkg/implementation/blinker/ssacli.go +++ b/pkg/implementation/blinker/ssacli.go @@ -44,20 +44,18 @@ func (s *SSACLI) StopBlink(metadata *physicaldrive.Metadata) error { // blink makes a physical drive blink. func (s *SSACLI) blink(metadata *physicaldrive.Metadata, action string) error { - slot := metadata.Slot.Format() - args := []string{ "controller", "slot=" + strconv.Itoa(metadata.CtrlMetadata.ID), "physicaldrive", - slot, + metadata.ID, "modify", "led=" + action, } _, err := s.SSACLI.Run(args) if err != nil { - return errors.Wrapf(err, "failed to blink physical drive %s", slot) + return errors.Wrapf(err, "failed to blink physical drive %s", metadata.ID) } return nil diff --git a/pkg/implementation/commandrunner/ssacli.go b/pkg/implementation/commandrunner/ssacli.go index df6699a..2be828f 100644 --- a/pkg/implementation/commandrunner/ssacli.go +++ b/pkg/implementation/commandrunner/ssacli.go @@ -6,7 +6,7 @@ import ( "github.com/pkg/errors" ) -const SSACLIPath = "/opt/hp/hp_ssacli/bin/hp_ssacli" +const SSACLIPath = "ssacli" type SSACLI struct { cliPath string diff --git a/pkg/implementation/logicalvolumegetter/mdadm.go b/pkg/implementation/logicalvolumegetter/mdadm.go index 7b16626..365c07b 100644 --- a/pkg/implementation/logicalvolumegetter/mdadm.go +++ b/pkg/implementation/logicalvolumegetter/mdadm.go @@ -152,7 +152,7 @@ func (m *MDADM) LogicalVolume( for _, device := range details[0].Devices { logicalVolume.PDrivesMetadata = append(logicalVolume.PDrivesMetadata, &physicaldrive.Metadata{ - DevicePath: device.Path, + ID: device.Path, // FIXME Add a const in the controller metadata to identify the controller CtrlMetadata: metadata.CtrlMetadata, }) diff --git a/pkg/implementation/logicalvolumegetter/ssacli.go b/pkg/implementation/logicalvolumegetter/ssacli.go index 386cb4e..74beb7c 100644 --- a/pkg/implementation/logicalvolumegetter/ssacli.go +++ b/pkg/implementation/logicalvolumegetter/ssacli.go @@ -2,6 +2,7 @@ package logicalvolumegetter import ( + "fmt" "regexp" "strconv" "strings" @@ -254,12 +255,8 @@ func extractInfoFromConfig( // Create the PhysicalDrive metadata pDriveMetadata := &physicaldrive.Metadata{ + ID: fmt.Sprintf("%s:%s:%s", matches[1], matches[2], matches[3]), CtrlMetadata: logicalVolume.CtrlMetadata, - Slot: &physicaldrive.Slot{ - Port: matches[1], - Enclosure: matches[2], - Bay: matches[3], - }, } pDrivesMetadata = append(pDrivesMetadata, pDriveMetadata) diff --git a/pkg/implementation/logicalvolumemanager/mdadm.go b/pkg/implementation/logicalvolumemanager/mdadm.go index be0dcf1..6689341 100644 --- a/pkg/implementation/logicalvolumemanager/mdadm.go +++ b/pkg/implementation/logicalvolumemanager/mdadm.go @@ -41,7 +41,7 @@ func (m *MDADM) CreateLV(request *logicalvolume.Request) (*logicalvolume.Logical for _, drive := range request.PDrivesMetadata { physicalDrive, err := m.PhysicalDrive(drive) if err != nil { - return nil, errors.Wrapf(err, "failed to get physical drive : %s", drive.DevicePath) + return nil, errors.Wrapf(err, "failed to get physical drive : %s", drive.ID) } if physicalDrive.Status == physicaldrive.PDStatusFailed { @@ -50,7 +50,7 @@ func (m *MDADM) CreateLV(request *logicalvolume.Request) (*logicalvolume.Logical return nil, errors.New("cannot create a logical volume with a used physical drive") } - physicalDrivesName = append(physicalDrivesName, drive.DevicePath) + physicalDrivesName = append(physicalDrivesName, drive.ID) } devicePath := fmt.Sprintf("%s/%s", baseMDPath, request.Name) @@ -107,13 +107,13 @@ func (m *MDADM) DeleteLV(metadata *logicalvolume.Metadata) error { for _, device := range logicalVolume.PDrivesMetadata { // Remove the superblock of the device _, err = m.MDADM.Run([]string{ - "--zero-superblock", device.DevicePath, + "--zero-superblock", device.ID, }) if err != nil { return errors.Wrapf( err, "failed to run mdadm zero superblock command on physical drive: %s", - device.DevicePath, + device.ID, ) } } @@ -146,15 +146,15 @@ func (m *MDADM) AddPDsToLV( if physicalDrive.Status == physicaldrive.PDStatusFailed { return errors.Errorf( - "cannot add a failed physical drive to a logical volume : %s ", physicalDrive.DevicePath, + "cannot add a failed physical drive to a logical volume : %s ", physicalDrive.ID, ) } else if physicalDrive.Status == physicaldrive.PDStatusUsed { return errors.Errorf( - "cannot add a used physical drive to a logical volume : %s", physicalDrive.DevicePath, + "cannot add a used physical drive to a logical volume : %s", physicalDrive.ID, ) } - devicesPaths = append(devicesPaths, pdMetadata.DevicePath) + devicesPaths = append(devicesPaths, pdMetadata.ID) } if logicalVolume.RAIDLevel == logicalvolume.RAIDLevel10 || @@ -240,7 +240,7 @@ func (m *MDADM) DeletePDsFromLV( pdsDevicePaths := make([]string, 0, len(pdsMetadata)) for _, pdMetadata := range pdsMetadata { - pdsDevicePaths = append(pdsDevicePaths, pdMetadata.DevicePath) + pdsDevicePaths = append(pdsDevicePaths, pdMetadata.ID) } // Prepare the mdadm fail command diff --git a/pkg/implementation/logicalvolumemanager/mdadm_test.go b/pkg/implementation/logicalvolumemanager/mdadm_test.go index f0f77bf..d2854be 100644 --- a/pkg/implementation/logicalvolumemanager/mdadm_test.go +++ b/pkg/implementation/logicalvolumemanager/mdadm_test.go @@ -73,18 +73,18 @@ func TestMDADM_CreateLV_RAID1(t *testing.T) { Name: "testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, } // Mock physical drive checks - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme1n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme2n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) @@ -103,8 +103,8 @@ func TestMDADM_CreateLV_RAID1(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -135,18 +135,18 @@ func TestMDADM_CreateLV_RAID0(t *testing.T) { Name: "testlv0", RAIDLevel: logicalvolume.RAIDLevel0, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, } // Mock physical drive checks - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme1n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme2n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) @@ -164,8 +164,8 @@ func TestMDADM_CreateLV_RAID0(t *testing.T) { DevicePath: "/dev/md/testlv0", RAIDLevel: logicalvolume.RAIDLevel0, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -195,17 +195,17 @@ func TestMDADM_CreateLV_RAID10(t *testing.T) { Name: "testlv10", RAIDLevel: logicalvolume.RAIDLevel10, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, - {DevicePath: "/dev/nvme4n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, + {ID: "/dev/nvme4n1"}, }, } // Mock physical drive checks for all drives for _, path := range []string{"/dev/nvme1n1", "/dev/nvme2n1", "/dev/nvme3n1", "/dev/nvme4n1"} { - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: path}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: path}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: path}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: path}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) } @@ -224,10 +224,10 @@ func TestMDADM_CreateLV_RAID10(t *testing.T) { DevicePath: "/dev/md/testlv10", RAIDLevel: logicalvolume.RAIDLevel10, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, - {DevicePath: "/dev/nvme4n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, + {ID: "/dev/nvme4n1"}, }, }, nil) @@ -258,18 +258,18 @@ func TestMDADM_CreateLV_FailedDrive(t *testing.T) { Name: "testlv", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, } // Mock physical drive checks - one drive is failed - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme1n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme2n1"}, Status: physicaldrive.PDStatusFailed, }, nil) @@ -296,18 +296,18 @@ func TestMDADM_CreateLV_UsedDrive(t *testing.T) { Name: "testlv", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, } // Mock physical drive checks - one drive is already used - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme1n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme2n1"}, Status: physicaldrive.PDStatusUsed, }, nil) @@ -334,18 +334,18 @@ func TestMDADM_CreateLV_CommandError(t *testing.T) { Name: "testlv", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, } // Mock physical drive checks - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme1n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme1n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) - mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ - Metadata: &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"}, + mockPhysicalDrivesGetter.On("PhysicalDrive", &physicaldrive.Metadata{ID: "/dev/nvme2n1"}).Return(&physicaldrive.PhysicalDrive{ + Metadata: &physicaldrive.Metadata{ID: "/dev/nvme2n1"}, Status: physicaldrive.PDStatusUnassignedGood, }, nil) @@ -383,8 +383,8 @@ func TestMDADM_DeleteLV_Success(t *testing.T) { Metadata: &logicalvolume.Metadata{ID: "/dev/md/testlv"}, DevicePath: "/dev/md/testlv", PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -447,8 +447,8 @@ func TestMDADM_DeleteLV_StopError(t *testing.T) { Metadata: &logicalvolume.Metadata{ID: "/dev/md/testlv"}, DevicePath: "/dev/md/testlv", PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -481,8 +481,8 @@ func TestMDADM_DeleteLV_ZeroSuperblockError(t *testing.T) { Metadata: &logicalvolume.Metadata{ID: "/dev/md/testlv"}, DevicePath: "/dev/md/testlv", PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -526,8 +526,8 @@ func TestMDADM_DeleteLV_FailedLogicalVolume(t *testing.T) { DevicePath: "/dev/md/testlv", Status: logicalvolume.LVStatusFailed, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -564,7 +564,7 @@ func TestMDADM_AddPDsToLV_RAID0_Success(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv0"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -572,8 +572,8 @@ func TestMDADM_AddPDsToLV_RAID0_Success(t *testing.T) { DevicePath: "/dev/md/testlv0", RAIDLevel: logicalvolume.RAIDLevel0, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -612,7 +612,7 @@ func TestMDADM_AddPDsToLV_RAID1_Success(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -620,8 +620,8 @@ func TestMDADM_AddPDsToLV_RAID1_Success(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -664,8 +664,8 @@ func TestMDADM_AddPDsToLV_RAID10_Success(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv10"} - pdMetadata1 := &physicaldrive.Metadata{DevicePath: "/dev/nvme5n1"} - pdMetadata2 := &physicaldrive.Metadata{DevicePath: "/dev/nvme6n1"} + pdMetadata1 := &physicaldrive.Metadata{ID: "/dev/nvme5n1"} + pdMetadata2 := &physicaldrive.Metadata{ID: "/dev/nvme6n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -673,10 +673,10 @@ func TestMDADM_AddPDsToLV_RAID10_Success(t *testing.T) { DevicePath: "/dev/md/testlv10", RAIDLevel: logicalvolume.RAIDLevel10, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, - {DevicePath: "/dev/nvme4n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, + {ID: "/dev/nvme4n1"}, }, }, nil) @@ -723,7 +723,7 @@ func TestMDADM_AddPDsToLV_FailedLV(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} // Mock logical volume retrieval with failed status mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -732,8 +732,8 @@ func TestMDADM_AddPDsToLV_FailedLV(t *testing.T) { RAIDLevel: logicalvolume.RAIDLevel1, Status: logicalvolume.LVStatusFailed, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -756,7 +756,7 @@ func TestMDADM_AddPDsToLV_FailedDrive(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -764,8 +764,8 @@ func TestMDADM_AddPDsToLV_FailedDrive(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -795,7 +795,7 @@ func TestMDADM_AddPDsToLV_UsedDrive(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -803,8 +803,8 @@ func TestMDADM_AddPDsToLV_UsedDrive(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -834,7 +834,7 @@ func TestMDADM_DeletePDsFromLV_RAID1_Success(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -842,9 +842,9 @@ func TestMDADM_DeletePDsFromLV_RAID1_Success(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -899,8 +899,8 @@ func TestMDADM_DeletePDsFromLV_RAID10_Success(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv10"} - pdMetadata1 := &physicaldrive.Metadata{DevicePath: "/dev/nvme3n1"} - pdMetadata2 := &physicaldrive.Metadata{DevicePath: "/dev/nvme4n1"} + pdMetadata1 := &physicaldrive.Metadata{ID: "/dev/nvme3n1"} + pdMetadata2 := &physicaldrive.Metadata{ID: "/dev/nvme4n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -908,10 +908,10 @@ func TestMDADM_DeletePDsFromLV_RAID10_Success(t *testing.T) { DevicePath: "/dev/md/testlv10", RAIDLevel: logicalvolume.RAIDLevel10, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, - {DevicePath: "/dev/nvme4n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, + {ID: "/dev/nvme4n1"}, }, }, nil) @@ -954,7 +954,7 @@ func TestMDADM_DeletePDsFromLV_RAID0_Fail(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv0"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -962,8 +962,8 @@ func TestMDADM_DeletePDsFromLV_RAID0_Fail(t *testing.T) { DevicePath: "/dev/md/testlv0", RAIDLevel: logicalvolume.RAIDLevel0, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -986,7 +986,7 @@ func TestMDADM_DeletePDsFromLV_RAID1_MinimumDisksFail(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval with only 2 drives mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -994,8 +994,8 @@ func TestMDADM_DeletePDsFromLV_RAID1_MinimumDisksFail(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, }, }, nil) @@ -1018,7 +1018,7 @@ func TestMDADM_DeletePDsFromLV_FailedLV(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval with failed status mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1027,9 +1027,9 @@ func TestMDADM_DeletePDsFromLV_FailedLV(t *testing.T) { RAIDLevel: logicalvolume.RAIDLevel1, Status: logicalvolume.LVStatusFailed, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -1052,7 +1052,7 @@ func TestMDADM_DeletePDsFromLV_FailCommandError(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1060,9 +1060,9 @@ func TestMDADM_DeletePDsFromLV_FailCommandError(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -1093,7 +1093,7 @@ func TestMDADM_DeletePDsFromLV_RemoveCommandError(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1101,9 +1101,9 @@ func TestMDADM_DeletePDsFromLV_RemoveCommandError(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -1141,7 +1141,7 @@ func TestMDADM_DeletePDsFromLV_ZeroSuperblockError(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1149,9 +1149,9 @@ func TestMDADM_DeletePDsFromLV_ZeroSuperblockError(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -1195,7 +1195,7 @@ func TestMDADM_DeletePDsFromLV_GrowDevicesError(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1203,9 +1203,9 @@ func TestMDADM_DeletePDsFromLV_GrowDevicesError(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) @@ -1253,7 +1253,7 @@ func TestMDADM_DeletePDsFromLV_GrowArraySizeError(t *testing.T) { } lvMetadata := &logicalvolume.Metadata{ID: "/dev/md/testlv1"} - pdMetadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme2n1"} + pdMetadata := &physicaldrive.Metadata{ID: "/dev/nvme2n1"} // Mock logical volume retrieval mockLogicalVolumeGetter.On("LogicalVolume", lvMetadata).Return(&logicalvolume.LogicalVolume{ @@ -1261,9 +1261,9 @@ func TestMDADM_DeletePDsFromLV_GrowArraySizeError(t *testing.T) { DevicePath: "/dev/md/testlv1", RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ - {DevicePath: "/dev/nvme1n1"}, - {DevicePath: "/dev/nvme2n1"}, - {DevicePath: "/dev/nvme3n1"}, + {ID: "/dev/nvme1n1"}, + {ID: "/dev/nvme2n1"}, + {ID: "/dev/nvme3n1"}, }, }, nil) diff --git a/pkg/implementation/logicalvolumemanager/ssacli.go b/pkg/implementation/logicalvolumemanager/ssacli.go index 3690a37..c546314 100644 --- a/pkg/implementation/logicalvolumemanager/ssacli.go +++ b/pkg/implementation/logicalvolumemanager/ssacli.go @@ -57,7 +57,7 @@ func (s *SSACLI) CreateLV(request *logicalvolume.Request) (*logicalvolume.Logica pd, err := s.PhysicalDrive(pdMetadata) if err != nil { return nil, errors.Wrapf(err, "failed to get physical drive %s", - pdMetadata.Slot.Format()) + pdMetadata.ID) } physicalDrivesToUse = append(physicalDrivesToUse, pd) @@ -267,10 +267,10 @@ func formatDrives(pdsMetadata []*physicaldrive.Metadata) string { return "" } - formattedDrives = pdsMetadata[0].Slot.Format() + formattedDrives = pdsMetadata[0].ID for _, drive := range pdsMetadata[1:] { - formattedDrives += "," + drive.Slot.Format() + formattedDrives += "," + drive.ID } return formattedDrives @@ -297,7 +297,7 @@ func getLogicalDriveID( if len(parts) > 1 { logicalDriveID = parts[1] } - } else if strings.Contains(line, request.PDrivesMetadata[0].Slot.Format()) { + } else if strings.Contains(line, request.PDrivesMetadata[0].ID) { // Check if line contains the physical drive slot // If the logical drive ID is empty, return it // If the logical drive ID is not empty, return an error @@ -308,7 +308,7 @@ func getLogicalDriveID( return "", errors.Errorf( "physical drive %s found in multiple logical drives", - request.PDrivesMetadata[0].Slot.Format(), + request.PDrivesMetadata[0].ID, ) } } @@ -316,6 +316,6 @@ func getLogicalDriveID( return "", errors.Errorf( "physical drive %s not found in any logical drive", - request.PDrivesMetadata[0].Slot.Format(), + request.PDrivesMetadata[0].ID, ) } diff --git a/pkg/implementation/physicaldrivegetter/rhel8.go b/pkg/implementation/physicaldrivegetter/rhel8.go index 72e3227..177202c 100644 --- a/pkg/implementation/physicaldrivegetter/rhel8.go +++ b/pkg/implementation/physicaldrivegetter/rhel8.go @@ -59,7 +59,7 @@ func (r *RHEL8) PhysicalDrives( for _, device := range blockDevices { physicalDrive, err := r.PhysicalDrive(&physicaldrive.Metadata{ - DevicePath: device.DevicePath, + ID: device.DevicePath, }) if err != nil { return nil, errors.Wrapf(err, "failed to get physical drive: %s", device.DevicePath) @@ -75,9 +75,9 @@ func (r *RHEL8) PhysicalDrives( func (r *RHEL8) PhysicalDrive( metadata *physicaldrive.Metadata, ) (*physicaldrive.PhysicalDrive, error) { - device, err := r.getBlockDevice(metadata.DevicePath) + device, err := r.getBlockDevice(metadata.ID) if err != nil { - return nil, errors.Wrapf(err, "failed to get block device: %s", metadata.DevicePath) + return nil, errors.Wrapf(err, "failed to get block device: %s", metadata.ID) } physicalDrive := &physicaldrive.PhysicalDrive{} @@ -85,7 +85,7 @@ func (r *RHEL8) PhysicalDrive( output, err := r.UDevADM.Run([]string{ "info", "--query=all", - "--name=" + metadata.DevicePath, + "--name=" + device.DevicePath, }) if err != nil { return nil, errors.Wrap(err, "failed to run udevadm physical drive info command") @@ -152,7 +152,9 @@ func (r *RHEL8) physicalDriveStatus(device *BlockDevice) (physicaldrive.PDStatus // If err is not nil, it means smartctl failed to run // so we ignore this case for now. - if healthStatus != "PASSED" && err == nil { + // Sometimes health status can be empty, because some older drives + // doesn't support the associated SMART instruction + if healthStatus != "PASSED" && healthStatus != "" && err == nil { return physicaldrive.PDStatusFailed, "", nil } @@ -269,13 +271,7 @@ func ParseUDevADMOutput(output []byte) (*physicaldrive.PhysicalDrive, error) { physicalDrive.Model = strings.TrimPrefix(line, "E: ID_MODEL=") case strings.HasPrefix(line, "E: ID_SERIAL_SHORT="): physicalDrive.Serial = strings.TrimPrefix(line, "E: ID_SERIAL_SHORT=") - case strings.HasPrefix(line, "E: ID_WWN="): - physicalDrive.ID = strings.TrimPrefix(line, "E: ID_WWN=") case strings.HasPrefix(line, "E: DEVNAME="): - if physicalDrive.Metadata == nil { - physicalDrive.Metadata = &physicaldrive.Metadata{} - } - physicalDrive.DevicePath = strings.TrimPrefix(line, "E: DEVNAME=") case strings.HasPrefix(line, "E: DEVLINKS="): devlinks := strings.Split(strings.TrimPrefix(line, "E: DEVLINKS="), " ") diff --git a/pkg/implementation/physicaldrivegetter/rhel8_test.go b/pkg/implementation/physicaldrivegetter/rhel8_test.go index e709075..a3f5323 100644 --- a/pkg/implementation/physicaldrivegetter/rhel8_test.go +++ b/pkg/implementation/physicaldrivegetter/rhel8_test.go @@ -65,12 +65,9 @@ func TestParseUDevADMOutput(t *testing.T) { output := []byte(uDevADMTestOutput) expected := &physicaldrive.PhysicalDrive{ - Model: "Amazon Elastic Block Store", - Serial: "vol05ece746e40ff492f", - ID: "nvme.1d0f-766f6c3035656365373436653430666634393266-416d617a6f6e20456c617374696320426c6f636b2053746f7265-00000001", - Metadata: &physicaldrive.Metadata{ - DevicePath: "/dev/nvme1n1", - }, + Model: "Amazon Elastic Block Store", + Serial: "vol05ece746e40ff492f", + DevicePath: "/dev/nvme1n1", PermanentPath: "/dev/disk/by-id/nvme-nvme.1d0f-766f6c3035656365373436653430666634393266-416d617a6f6e20456c617374696320426c6f636b2053746f7265-00000001", } @@ -118,17 +115,18 @@ E: DEVLINKS=/dev/disk/by-id/nvme-123 /dev/disk/by-path/pci-0000:00:1b.0-nvme-1`) SMART overall-health self-assessment test result: PASSED `), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"} + metadata := &physicaldrive.Metadata{ID: "/dev/nvme1n1"} physicalDrive, err := r.PhysicalDrive(metadata) // Verify result assert.NoError(t, err) assert.Equal(t, "Amazon Elastic Block Store", physicalDrive.Model) assert.Equal(t, "vol05ece746e40ff492f", physicalDrive.Serial) - assert.Equal(t, "nvme.1d0f-123456", physicalDrive.ID) + assert.Equal(t, "/dev/nvme1n1", physicalDrive.ID) assert.Equal(t, uint64(8589934592), physicalDrive.Size) assert.Equal(t, physicaldrive.DiskTypeNVMe, physicalDrive.Type) assert.Equal(t, physicaldrive.PDStatusUnassignedGood, physicalDrive.Status) + assert.Equal(t, "/dev/nvme1n1", physicalDrive.DevicePath) assert.Equal(t, "/dev/disk/by-id/nvme-123", physicalDrive.PermanentPath) mockLSBLK.AssertExpectations(t) @@ -158,7 +156,7 @@ E: DEVLINKS=/dev/disk/by-id/ssd-123`), nil) mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte(`SMART overall-health self-assessment test result: PASSED`), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/sda"} + metadata := &physicaldrive.Metadata{ID: "/dev/sda"} physicalDrive, err := r.PhysicalDrive(metadata) assert.NoError(t, err) @@ -187,11 +185,12 @@ E: DEVNAME=/dev/sdb`), nil) mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte(`SMART overall-health self-assessment test result: PASSED`), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/sdb"} + metadata := &physicaldrive.Metadata{ID: "/dev/sdb"} physicalDrive, err := r.PhysicalDrive(metadata) assert.NoError(t, err) assert.Equal(t, "Seagate HDD", physicalDrive.Model) + assert.Equal(t, "/dev/sdb", physicalDrive.DevicePath) assert.Equal(t, physicaldrive.DiskTypeHDD, physicalDrive.Type) } @@ -209,7 +208,7 @@ func TestRHEL8_PhysicalDrive_BlockDeviceError(t *testing.T) { // Simulate error from lsblk mockLSBLK.On("Run", mock.AnythingOfType("[]string")).Return([]byte{}, errors.New("lsblk command failed")) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"} + metadata := &physicaldrive.Metadata{ID: "/dev/nvme1n1"} _, err := r.PhysicalDrive(metadata) assert.Error(t, err) @@ -233,7 +232,7 @@ func TestRHEL8_PhysicalDrive_UDevADMError(t *testing.T) { // Simulate error from udevadm mockUDevADM.On("Run", mock.AnythingOfType("[]string")).Return([]byte{}, errors.New("udevadm command failed")) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"} + metadata := &physicaldrive.Metadata{ID: "/dev/nvme1n1"} _, err := r.PhysicalDrive(metadata) assert.Error(t, err) @@ -262,13 +261,14 @@ E: DEVNAME=/dev/nvme1n1`), nil) // Simulate error from smartctl mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte{}, errors.New("smartctl command failed")) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"} + metadata := &physicaldrive.Metadata{ID: "/dev/nvme1n1"} physicalDrive, err := r.PhysicalDrive(metadata) // FIXME Ignore errors for now assert.NoError(t, err) assert.Equal(t, physicalDrive.Status, physicaldrive.PDStatusUnassignedGood) assert.Equal(t, physicalDrive.Reason, "smartctl command failed to get physical drive status") + assert.Equal(t, physicalDrive.DevicePath, "/dev/nvme1n1") } func TestRHEL8_PhysicalDrive_SmartCTLErrorDeviceUsed(t *testing.T) { @@ -293,7 +293,7 @@ E: DEVNAME=/dev/nvme1n1`), nil) // Simulate error from smartctl mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte{}, errors.New("smartctl command failed")) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/nvme1n1"} + metadata := &physicaldrive.Metadata{ID: "/dev/nvme1n1"} physicalDrive, err := r.PhysicalDrive(metadata) // FIXME Ignore errors for now @@ -322,12 +322,13 @@ E: DEVNAME=/dev/xda`), nil) mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte(`SMART overall-health self-assessment test result: PASSED`), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/xda"} + metadata := &physicaldrive.Metadata{ID: "/dev/xda"} physicalDrive, err := r.PhysicalDrive(metadata) assert.NoError(t, err) assert.Equal(t, "Unknown Disk", physicalDrive.Model) assert.Equal(t, physicaldrive.DiskTypeUnknown, physicalDrive.Type) + assert.Equal(t, physicalDrive.DevicePath, "/dev/xda") } func TestRHEL8_PhysicalDrive_UsedStatus(t *testing.T) { @@ -351,7 +352,7 @@ E: DEVNAME=/dev/sda`), nil) mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte(`SMART overall-health self-assessment test result: PASSED`), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/sda"} + metadata := &physicaldrive.Metadata{ID: "/dev/sda"} physicalDrive, err := r.PhysicalDrive(metadata) assert.NoError(t, err) @@ -380,7 +381,7 @@ E: DEVNAME=/dev/sda`), nil) mockSmartCTL.On("Run", mock.AnythingOfType("[]string")).Return([]byte(`SMART overall-health self-assessment test result: FAILED Reallocated Sector Count: 5`), nil) - metadata := &physicaldrive.Metadata{DevicePath: "/dev/sda"} + metadata := &physicaldrive.Metadata{ID: "/dev/sda"} physicalDrive, err := r.PhysicalDrive(metadata) assert.NoError(t, err) @@ -454,12 +455,14 @@ SMART overall-health self-assessment test result: PASSED // First drive assertions assert.Equal(t, "Amazon Elastic Block Store", physicalDrives[0].Model) assert.Equal(t, "vol05ece746e40ff492f", physicalDrives[0].Serial) + assert.Equal(t, "/dev/nvme1n1", physicalDrives[0].ID) assert.Equal(t, "/dev/nvme1n1", physicalDrives[0].DevicePath) assert.Equal(t, physicaldrive.DiskTypeNVMe, physicalDrives[0].Type) // Second drive assertions assert.Equal(t, "Amazon Elastic Block Store", physicalDrives[1].Model) assert.Equal(t, "vol05ece746e40ff493g", physicalDrives[1].Serial) + assert.Equal(t, "/dev/nvme2n1", physicalDrives[1].ID) assert.Equal(t, "/dev/nvme2n1", physicalDrives[1].DevicePath) assert.Equal(t, physicaldrive.DiskTypeNVMe, physicalDrives[1].Type) diff --git a/pkg/implementation/physicaldrivegetter/ssacli.go b/pkg/implementation/physicaldrivegetter/ssacli.go index a63ad16..5113807 100644 --- a/pkg/implementation/physicaldrivegetter/ssacli.go +++ b/pkg/implementation/physicaldrivegetter/ssacli.go @@ -74,20 +74,18 @@ func (s *SSACLI) PhysicalDrive(metadata *physicaldrive.Metadata) ( *physicaldrive.PhysicalDrive, error, ) { - slot := metadata.Slot.Format() - args := []string{ "controller", "slot=" + strconv.Itoa(metadata.CtrlMetadata.ID), "physicaldrive", - slot, + metadata.ID, "show", "detail", } output, err := s.SSACLI.Run(args) if err != nil { - return nil, errors.Wrapf(err, "failed to show details for physical drive %s", slot) + return nil, errors.Wrapf(err, "failed to show details for physical drive %s", metadata.ID) } controllerID, err := parseControllerID(output) @@ -97,7 +95,7 @@ func (s *SSACLI) PhysicalDrive(metadata *physicaldrive.Metadata) ( physicalDrive, err := s.parsePhysicalDrive(output) if err != nil { - return nil, errors.Wrapf(err, "failed to parse physical drive %s", slot) + return nil, errors.Wrapf(err, "failed to parse physical drive %s", metadata.ID) } physicalDrive.CtrlMetadata.ID = controllerID @@ -153,8 +151,8 @@ func (s *SSACLI) parsePhysicalDrive(block []byte) (*physicaldrive.PhysicalDrive, physicalDrive := &physicaldrive.PhysicalDrive{ Metadata: &physicaldrive.Metadata{ CtrlMetadata: &raidcontroller.Metadata{}, - Slot: &physicaldrive.Slot{}, }, + Slot: &physicaldrive.Slot{}, } // Split the block into lines and parse each line @@ -166,6 +164,8 @@ func (s *SSACLI) parsePhysicalDrive(block []byte) (*physicaldrive.PhysicalDrive, } } + physicalDrive.ID = physicalDrive.Slot.Format() + return physicalDrive, nil } @@ -236,9 +236,6 @@ func (s *SSACLI) parsePDLine( //nolint:funlen // This function is long and not c physicalDrive.Type = interfaceType - case "Drive Unique ID": - physicalDrive.ID = value - case "Disk Name": physicalDrive.DevicePath = value diff --git a/pkg/implementation/physicaldrivegetter/ssacli_test.go b/pkg/implementation/physicaldrivegetter/ssacli_test.go index 3cf1133..0a65674 100644 --- a/pkg/implementation/physicaldrivegetter/ssacli_test.go +++ b/pkg/implementation/physicaldrivegetter/ssacli_test.go @@ -117,27 +117,23 @@ func TestSSCALIPhysicalDrive(t *testing.T) { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Port: "4I", - Enclosure: "6", - Bay: "1", - }, + ID: "4I:6:1", }, expected: &physicaldrive.PhysicalDrive{ Metadata: &physicaldrive.Metadata{ CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Port: "4I", - Enclosure: "6", - Bay: "1", - }, + ID: "4I:6:1", + }, + Slot: &physicaldrive.Slot{ + Port: "4I", + Enclosure: "6", + Bay: "1", }, Vendor: "HPE", Model: "MO000800JXBEV", Serial: "W2X0751Y", - ID: "5000CCA0B8712794", Size: 858993459200, Status: physicaldrive.PDStatusUsed, }, @@ -151,7 +147,7 @@ func TestSSCALIPhysicalDrive(t *testing.T) { "controller", "slot=" + strconv.Itoa(tt.metadata.CtrlMetadata.ID), "physicaldrive", - tt.metadata.Slot.Format(), + tt.metadata.ID, "show", "detail", }).Return(tt.mocking, nil) @@ -164,11 +160,7 @@ func TestSSCALIPhysicalDrive(t *testing.T) { CtrlMetadata: &raidcontroller.Metadata{ ID: tt.metadata.CtrlMetadata.ID, }, - Slot: &physicaldrive.Slot{ - Port: "4I", - Enclosure: "6", - Bay: "1", - }, + ID: "4I:6:1", } physicalDrive, err := s.PhysicalDrive(metadata) diff --git a/pkg/implementation/raidcontroller/megaraid/logicalvolume.go b/pkg/implementation/raidcontroller/megaraid/logicalvolume.go index 1ff4ff3..3779510 100644 --- a/pkg/implementation/raidcontroller/megaraid/logicalvolume.go +++ b/pkg/implementation/raidcontroller/megaraid/logicalvolume.go @@ -208,14 +208,9 @@ func (a *Adapter) logicalVolume( pdsMetadata := make([]*physicaldrive.Metadata, len(pDrives)) for i := range pDrives { - enclosure, slot := pDrives[i].EnclosureSlot() - pdMetadata := &physicaldrive.Metadata{ CtrlMetadata: metadata.CtrlMetadata, - Slot: &physicaldrive.Slot{ - Enclosure: enclosure, - Bay: slot, - }, + ID: pDrives[i].EIDSlot, } pdsMetadata[i] = pdMetadata @@ -349,7 +344,7 @@ func (a *Adapter) fillPhysicalDrives(pdMetadatas []*physicaldrive.Metadata) ( pd, err := a.physicalDrive(pdMeta) if err != nil { return nil, errors.Wrapf(err, "failed to get physical drive %s", - pdMeta.Slot.String()) + pdMeta.ID) } pds[i] = pd @@ -363,7 +358,7 @@ func (a *Adapter) fillPhysicalDrives(pdMetadatas []*physicaldrive.Metadata) ( // The function is not too complex, and the complexity is due to the // multiple checks and conversions. // -//nolint:gocognit // The function is actually not too complex +//nolint:gocognit,funlen // The function is actually not too complex func enclosureSlots(pdsMetadatas []*physicaldrive.Metadata) ( enclosure int, slots []string, @@ -377,7 +372,11 @@ func enclosureSlots(pdsMetadatas []*physicaldrive.Metadata) ( slots = make([]string, len(pdsMetadatas)) for i, pd := range pdsMetadatas { - enclosure, bay := pd.Slot.Enclosure, pd.Slot.Bay + slot, err := physicaldrive.ParseSlot(pd.ID) + if err != nil { + return defaultEnclosure, nil, errors.Wrapf(err, "failed to parse slot %s", pd.ID) + } + enclosure, bay := slot.Enclosure, slot.Bay enclosureInt, err := strconv.Atoi(enclosure) if err != nil { @@ -516,9 +515,9 @@ func (a *Adapter) findNewLogicalVolume(pds []*physicaldrive.Metadata) ( } // Create a map of physical drive slots for efficient lookup - pdSlots := make(map[physicaldrive.Slot]struct{}) + pdSlots := make(map[string]struct{}) for _, pd := range pds { - pdSlots[*pd.Slot] = struct{}{} + pdSlots[pd.ID] = struct{}{} } // Find the new logical volume @@ -532,9 +531,9 @@ func (a *Adapter) findNewLogicalVolume(pds []*physicaldrive.Metadata) ( } // hasMatchingPDs checks if the logical volume has the same physical drives. -func hasMatchingPDs(lvPDs []*physicaldrive.Metadata, pdSlots map[physicaldrive.Slot]struct{}) bool { +func hasMatchingPDs(lvPDs []*physicaldrive.Metadata, pdSlots map[string]struct{}) bool { for _, lvPD := range lvPDs { - if _, found := pdSlots[*lvPD.Slot]; found { + if _, found := pdSlots[lvPD.ID]; found { return true } } diff --git a/pkg/implementation/raidcontroller/megaraid/megaraid.go b/pkg/implementation/raidcontroller/megaraid/megaraid.go index 9769d40..d5a3349 100644 --- a/pkg/implementation/raidcontroller/megaraid/megaraid.go +++ b/pkg/implementation/raidcontroller/megaraid/megaraid.go @@ -170,7 +170,7 @@ func (a *Adapter) PhysicalDrive(metadata *physicaldrive.Metadata) ( ) { pd, err := a.physicalDrive(metadata) if err != nil { - return nil, errors.Wrapf(err, "failed to get physical drive %s", metadata.Slot.String()) + return nil, errors.Wrapf(err, "failed to get physical drive %s", metadata.ID) } return pd, nil diff --git a/pkg/implementation/raidcontroller/megaraid/megaraid_test.go b/pkg/implementation/raidcontroller/megaraid/megaraid_test.go index 584814c..f6801b9 100644 --- a/pkg/implementation/raidcontroller/megaraid/megaraid_test.go +++ b/pkg/implementation/raidcontroller/megaraid/megaraid_test.go @@ -355,10 +355,7 @@ func (s *UnitTestSuite) TestPhysicalDrive() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "6", - }, + ID: "251:6", }, errExpected: false, err: "", @@ -368,10 +365,7 @@ func (s *UnitTestSuite) TestPhysicalDrive() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "99", - }, + ID: "251:99", }, errExpected: true, err: "Drive not found", @@ -388,7 +382,7 @@ func (s *UnitTestSuite) TestPhysicalDrive() { s.ErrorContains(err, tt.err) } else { s.NoError(err) - s.Equal("7", pDrive.ID) + s.Equal("251:6", pDrive.ID) s.Equal("ZVT2DBEW0000C24112G0", pDrive.Serial) s.Equal(uint64(17999005346693), pDrive.Size) s.Equal(physicaldrive.PDStatusUsed, pDrive.Status) @@ -525,10 +519,7 @@ func (s *UnitTestSuite) TestEnableJBOD() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "6", - }, + ID: "251:6", }, errExpected: true, err: "device state doesn't support requested command", @@ -556,10 +547,7 @@ func (s *UnitTestSuite) TestDisableJBOD() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "6", - }, + ID: "251:6", } err := s.a.DisableJBOD(metadata) @@ -647,10 +635,7 @@ func (s *UnitTestSuite) TestCreateLV() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "12", - }, + ID: "251:12", }, }, CacheOptions: &logicalvolume.CacheOptions{ @@ -673,10 +658,7 @@ func (s *UnitTestSuite) TestCreateLV() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "12", - }, + ID: "251:12", }, }, CacheOptions: &logicalvolume.CacheOptions{ @@ -705,8 +687,7 @@ func (s *UnitTestSuite) TestCreateLV() { s.Equal(logicalvolume.RAIDLevel0, newLv.RAIDLevel) s.Equal(logicalvolume.LVStatusOptimal, newLv.Status) s.Len(newLv.PDrivesMetadata, 1) - s.Equal("251", newLv.PDrivesMetadata[0].Slot.Enclosure) - s.Equal("12", newLv.PDrivesMetadata[0].Slot.Bay) + s.Equal("251:12", newLv.PDrivesMetadata[0].ID) s.Equal(logicalvolume.ReadPolicyReadAhead, newLv.CacheOptions.ReadPolicy) s.Equal(logicalvolume.WritePolicyWriteThrough, newLv.CacheOptions.WritePolicy) s.Equal(logicalvolume.IOPolicyDirect, newLv.CacheOptions.IOPolicy) @@ -770,10 +751,7 @@ func (s *UnitTestSuite) TestStartBlink() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "9", - }, + ID: "251:9", } err := s.a.StartBlink(metadata) @@ -789,10 +767,7 @@ func (s *UnitTestSuite) TestStopBlink() { CtrlMetadata: &raidcontroller.Metadata{ ID: 0, }, - Slot: &physicaldrive.Slot{ - Enclosure: "251", - Bay: "9", - }, + ID: "251:9", } err := s.a.StopBlink(metadata) diff --git a/pkg/implementation/raidcontroller/megaraid/physicaldrive.go b/pkg/implementation/raidcontroller/megaraid/physicaldrive.go index 927080a..eb81825 100644 --- a/pkg/implementation/raidcontroller/megaraid/physicaldrive.go +++ b/pkg/implementation/raidcontroller/megaraid/physicaldrive.go @@ -37,20 +37,15 @@ func (a *Adapter) physicaldrives(metadata *raidcontroller.Metadata) ( // Fill the slice of physical drives for _, pd := range pds { - enclosure, slot := pd.EnclosureSlot() - pdMetadata := &physicaldrive.Metadata{ CtrlMetadata: metadata, - Slot: &physicaldrive.Slot{ - Enclosure: enclosure, - Bay: slot, - }, + ID: pd.EIDSlot, } physicalDrive, err := a.physicalDrive(pdMetadata) if err != nil { return nil, errors.Wrapf(err, "failed to get physical drive %s", - pdMetadata.Slot.String()) + pdMetadata.ID) } physicalDrives = append(physicalDrives, physicalDrive) @@ -70,6 +65,8 @@ func (a *Adapter) physicaldrives(metadata *raidcontroller.Metadata) ( } // physicalDrive returns a physical drive for a given physical drive metadata. +// +//nolint:funlen // no good reason to split it for now func (a *Adapter) physicalDrive( metadata *physicaldrive.Metadata) ( *physicaldrive.PhysicalDrive, error, @@ -110,9 +107,14 @@ func (a *Adapter) physicalDrive( jbod := strings.Contains(strings.ToUpper(pd.Type), "JBOD") + slot, err := validateID(metadata.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to validate slot IDs") + } + physicalDrive := &physicaldrive.PhysicalDrive{ Metadata: metadata, - ID: strconv.Itoa(pd.DeviceID), + Slot: slot, Vendor: strings.TrimSpace(ddAttributes.ManufacturerID), Model: strings.TrimSpace(pd.Model), Serial: strings.TrimSpace(ddAttributes.SerialNumber), @@ -129,23 +131,6 @@ func (a *Adapter) physicalDrive( return physicalDrive, nil } -// EnclosureSlot returns the enclosure and slot of a physical drive. -func (pd *PD) EnclosureSlot() (enclosure, slot string) { - eidSlotSplit := strings.Split(pd.EIDSlot, ":") - splitParts := 2 - - // If the enclosureSlot is not in the format "enclosure:slot" - // then the slot is the value of EIDSlot - if len(eidSlotSplit) != splitParts { - return "", pd.EIDSlot - } - - enclosure = eidSlotSplit[0] - slot = eidSlotSplit[1] - - return enclosure, slot -} - // DiskType returns the disk type of a physical drive. func (pd *PD) DiskType() physicaldrive.DiskType { // diskTypeMap maps the disk type string to the physical drive disk type. @@ -182,41 +167,46 @@ func (pd *PD) PDStatus() physicaldrive.PDStatus { } // validateID validates the slot IDs of a physical drive. -func validateID(s *physicaldrive.Slot) error { - bayID, err := strconv.Atoi(s.Bay) +func validateID(s string) (*physicaldrive.Slot, error) { + slot, err := physicaldrive.ParseSlot(s) if err != nil { - return errors.Wrapf(err, "failed to convert bay ID to int: %s", s.Bay) + return nil, errors.Wrap(err, "failed to parse ID") + } + + bayID, err := strconv.Atoi(slot.Bay) + if err != nil { + return nil, errors.Wrapf(err, "failed to convert bay ID to int: %s", slot.Bay) } if bayID < 0 { - return errors.Wrapf(err, "invalid bay ID: %s", s.Bay) + return nil, errors.Wrapf(err, "invalid bay ID: %s", slot.Bay) } - if s.Enclosure != "" { - enclosureID, err := strconv.Atoi(s.Enclosure) + if slot.Enclosure != "" { + enclosureID, err := strconv.Atoi(slot.Enclosure) if err != nil { - return errors.Wrapf(err, "failed to convert enclosure ID to int: %s", s.Enclosure) + return nil, errors.Wrapf(err, "failed to convert enclosure ID to int: %s", slot.Enclosure) } if enclosureID < 0 { - return errors.Wrapf(err, "invalid enclosure ID: %s", s.Enclosure) + return nil, errors.Wrapf(err, "invalid enclosure ID: %s", slot.Enclosure) } } - return nil + return slot, nil } // selectorPD returns the selector for a physical drive metadata. func selectorPD(m *physicaldrive.Metadata) (string, error) { - err := validateID(m.Slot) + slot, err := validateID(m.ID) if err != nil { return "", errors.Wrap(err, "failed to validate slot IDs") } - selector := fmt.Sprintf(patternNoEnclosure, m.CtrlMetadata.ID, m.Slot.Bay) + selector := fmt.Sprintf(patternNoEnclosure, m.CtrlMetadata.ID, slot.Bay) - if m.Slot.Enclosure != "" { - selector = fmt.Sprintf(patternEnclosure, m.CtrlMetadata.ID, m.Slot.Enclosure, m.Slot.Bay) + if slot.Enclosure != "" { + selector = fmt.Sprintf(patternEnclosure, m.CtrlMetadata.ID, slot.Enclosure, slot.Bay) } return selector, nil diff --git a/tests/integration/software_raid_controller.go b/tests/integration/software_raid_controller.go index 0514441..c73953b 100644 --- a/tests/integration/software_raid_controller.go +++ b/tests/integration/software_raid_controller.go @@ -45,9 +45,6 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { } controllerMetadata := &raidcontroller.Metadata{ID: 0} - slot := &physicaldrive.Slot{ - Port: "pouet", - } creationRequest := &logicalvolume.Request{ CacheOptions: &logicalvolume.CacheOptions{}, @@ -55,24 +52,20 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { RAIDLevel: logicalvolume.RAIDLevel10, PDrivesMetadata: []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", + ID: "/dev/nvme1n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme2n1", + ID: "/dev/nvme2n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme3n1", + ID: "/dev/nvme3n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme4n1", + ID: "/dev/nvme4n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, }, Name: "test_raid10", @@ -101,9 +94,8 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { drives := []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", + ID: "/dev/nvme1n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -157,14 +149,12 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { drives = []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", + ID: "/dev/nvme1n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme4n1", + ID: "/dev/nvme4n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -218,14 +208,12 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { drives = []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme5n1", + ID: "/dev/nvme5n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme6n1", + ID: "/dev/nvme6n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -242,14 +230,12 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { drives = []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme6n1", + ID: "/dev/nvme6n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme7n1", + ID: "/dev/nvme7n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -317,9 +303,6 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { } controllerMetadata := &raidcontroller.Metadata{ID: 0} - slot := &physicaldrive.Slot{ - Port: "pouet", - } creationRequest := &logicalvolume.Request{ CacheOptions: &logicalvolume.CacheOptions{}, @@ -327,14 +310,12 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { RAIDLevel: logicalvolume.RAIDLevel1, PDrivesMetadata: []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", + ID: "/dev/nvme1n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, { - DevicePath: "/dev/nvme2n1", + ID: "/dev/nvme2n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, }, Name: "test_raid1", @@ -361,9 +342,8 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { drives := []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", + ID: "/dev/nvme1n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -378,9 +358,8 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { drives = []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme3n1", + ID: "/dev/nvme3n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, } @@ -414,9 +393,6 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { } controllerMetadata := &raidcontroller.Metadata{ID: 0} - slot := &physicaldrive.Slot{ - Port: "pouet", - } creationRequest := &logicalvolume.Request{ CacheOptions: &logicalvolume.CacheOptions{}, @@ -424,16 +400,14 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { RAIDLevel: logicalvolume.RAIDLevel0, PDrivesMetadata: []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme1n1", - // DevicePath: physicalDrives[0].DevicePath, + ID: "/dev/nvme1n1", + // ID: physicalDrives[0].DevicePath, CtrlMetadata: controllerMetadata, - Slot: slot, }, { - // DevicePath: physicalDrives[1].DevicePath, - DevicePath: "/dev/nvme2n1", + // ID: physicalDrives[1].DevicePath, + ID: "/dev/nvme2n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, }, Name: "test_raid0", @@ -453,9 +427,8 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { drives := []*physicaldrive.Metadata{ { - DevicePath: "/dev/nvme3n1", + ID: "/dev/nvme3n1", CtrlMetadata: controllerMetadata, - Slot: slot, }, }