remove devices even if some are missing

Author: plaffitt

iscsi/iscsi.go

@@ -279,7 +279,7 @@ func (c *Connector) Connect() (string, error) {
 	// GetISCSIDevices returns all devices if no paths are given
 	if len(devicePaths) < 1 {
 		c.Devices = []Device{}
-	} else if c.Devices, err = GetISCSIDevices(devicePaths); err != nil {
+	} else if c.Devices, err = GetISCSIDevices(devicePaths, true); err != nil {
 		return "", err
 	}
 
@@ -457,10 +457,10 @@ func (c *Connector) IsMultipathEnabled() bool {
 
 // GetSCSIDevices get SCSI devices from device paths
 // It will returns all SCSI devices if no paths are given
-func GetSCSIDevices(devicePaths []string) ([]Device, error) {
+func GetSCSIDevices(devicePaths []string, strict bool) ([]Device, error) {
 	debug.Printf("Getting info about SCSI devices %s.\n", devicePaths)
 
-	deviceInfo, err := lsblk(devicePaths)
+	deviceInfo, err := lsblk(devicePaths, strict)
 	if err != nil {
 		debug.Printf("An error occured while looking info about SCSI devices: %v", err)
 		return nil, err
@@ -471,8 +471,8 @@ func GetSCSIDevices(devicePaths []string) ([]Device, error) {
 
 // GetISCSIDevices get iSCSI devices from device paths
 // It will returns all iSCSI devices if no paths are given
-func GetISCSIDevices(devicePaths []string) (devices []Device, err error) {
-	scsiDevices, err := GetSCSIDevices(devicePaths)
+func GetISCSIDevices(devicePaths []string, strict bool) (devices []Device, err error) {
+	scsiDevices, err := GetSCSIDevices(devicePaths, strict)
 	if err != nil {
 		return
 	}
@@ -488,21 +488,26 @@ func GetISCSIDevices(devicePaths []string) (devices []Device, err error) {
 }
 
 // lsblk execute the lsblk commands
-func lsblk(devicePaths []string) (*deviceInfo, error) {
+func lsblk(devicePaths []string, strict bool) (*deviceInfo, error) {
 	flags := []string{"-J", "-o", "NAME,HCTL,TYPE,TRAN,SIZE"}
 	command := execCommand("lsblk", append(flags, devicePaths...)...)
 	debug.Println(command.String())
 	out, err := command.Output()
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
-			return nil, fmt.Errorf("%s, (%v)", strings.Trim(string(ee.Stderr), "\n"), ee)
+			err = fmt.Errorf("%s, (%w)", strings.Trim(string(ee.Stderr), "\n"), ee)
+			if strict || ee.ExitCode() != 64 { // ignore the error if some devices have been found when not strict
+				return nil, err
+			}
+			debug.Printf("lsblk could find only some devices: %v", err)
+		} else {
+			return nil, err
 		}
-		return nil, err
 	}
 
 	var deviceInfo deviceInfo
-	if err = json.Unmarshal(out, &deviceInfo); err != nil {
-		return nil, err
+	if jsonErr := json.Unmarshal(out, &deviceInfo); jsonErr != nil {
+		return nil, jsonErr
 	}
 
 	return &deviceInfo, nil
@@ -603,13 +608,13 @@ func GetConnectorFromFile(filePath string) (*Connector, error) {
 		devicePaths = append(devicePaths, device.GetPath())
 	}
 
-	if devices, err := GetSCSIDevices([]string{c.MountTargetDevice.GetPath()}); err != nil {
+	if devices, err := GetSCSIDevices([]string{c.MountTargetDevice.GetPath()}, false); err != nil {
 		return nil, err
 	} else {
 		c.MountTargetDevice = &devices[0]
 	}
 
-	if c.Devices, err = GetSCSIDevices(devicePaths); err != nil {
+	if c.Devices, err = GetSCSIDevices(devicePaths, false); err != nil {
 		return nil, err
 	}
 

iscsi/iscsi_test.go

@@ -581,8 +581,12 @@ func Test_getMultipathDevice(t *testing.T) {
 func Test_lsblk(t *testing.T) {
 	sda := Device{Name: "sda", Children: []Device{{}}}
 
+	sdaOutput, err := json.Marshal(deviceInfo{BlockDevices: []Device{sda}})
+	assert.New(t).Nil(err, "could not setup test")
+
 	tests := map[string]struct {
 		devicePaths      []string
+		strict           bool
 		mockedStdout     string
 		mockedDevices    []Device
 		mockedExitStatus int
@@ -591,34 +595,43 @@ func Test_lsblk(t *testing.T) {
 		"Basic": {
 			devicePaths:   []string{"/dev/sda"},
 			mockedDevices: []Device{sda},
+			mockedStdout:  string(sdaOutput),
 		},
 		"NotABlockDevice": {
 			devicePaths:      []string{"/dev/sdzz"},
 			mockedStdout:     "lsblk: sdzz: not a block device",
 			mockedExitStatus: 32,
+			wantErr:          true,
 		},
 		"InvalidJson": {
 			mockedStdout:     "{",
 			mockedExitStatus: 0,
 			wantErr:          true,
 		},
+		"StrictWithMissingDevices": {
+			devicePaths:      []string{"/dev/sda", "/dev/sdb"},
+			strict:           true,
+			mockedDevices:    []Device{sda},
+			mockedStdout:     string(sdaOutput),
+			mockedExitStatus: 64,
+			wantErr:          true,
+		},
+		"NotStrictWithMissingDevices": {
+			devicePaths:      []string{"/dev/sda", "/dev/sdb"},
+			mockedDevices:    []Device{sda},
+			mockedStdout:     string(sdaOutput),
+			mockedExitStatus: 64,
+		},
 	}
 
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			mockedStdout := tt.mockedStdout
-			if mockedStdout == "" {
-				out, err := json.Marshal(deviceInfo{BlockDevices: tt.mockedDevices})
-				assert.Nil(err, "could not setup test")
-				mockedStdout = string(out)
-			}
-
-			defer gostub.Stub(&execCommand, makeFakeExecCommand(tt.mockedExitStatus, mockedStdout)).Reset()
-			deviceInfo, err := lsblk(tt.devicePaths)
+			defer gostub.Stub(&execCommand, makeFakeExecCommand(tt.mockedExitStatus, tt.mockedStdout)).Reset()
+			deviceInfo, err := lsblk(tt.devicePaths, tt.strict)
 
-			if tt.mockedExitStatus != 0 || tt.wantErr {
+			if tt.wantErr {
 				assert.Nil(deviceInfo)
 				assert.NotNil(err)
 			} else {