Surface NotSupported error message during AttachVolume call (#3595)

Signed-off-by: Deepak Kinni <[email protected]>

Author: deepakkinni

pkg/common/cns-lib/volume/manager.go

@@ -1119,7 +1119,7 @@ func (m *defaultManager) AttachVolume(ctx context.Context,
 		}
 
 		volumeOperationRes := taskResult.GetCnsVolumeOperationResult()
-		if volumeOperationRes.Fault != nil {
+		if volumeOperationRes.Fault != nil && volumeOperationRes.Fault.Fault != nil {
 			faultType = ExtractFaultTypeFromVolumeResponseResult(ctx, volumeOperationRes)
 			_, isResourceInUseFault := volumeOperationRes.Fault.Fault.(*vim25types.ResourceInUse)
 			if isResourceInUseFault {
@@ -1133,6 +1133,37 @@ func (m *defaultManager) AttachVolume(ctx context.Context,
 					return diskUUID, "", nil
 				}
 			}
+
+			// Check if this is a CnsFault with NotSupported fault cause
+			if cnsFault, isCnsFault := volumeOperationRes.Fault.Fault.(*cnstypes.CnsFault); isCnsFault {
+				if cnsFault.FaultCause != nil {
+					notSupportedFault, isNotSupportedFault := cnsFault.FaultCause.Fault.(*vim25types.NotSupported)
+					if isNotSupportedFault {
+						log.Infof("observed CnsFault with NotSupported fault cause while attaching volume: %q with vm: %q",
+							volumeID, vm.String())
+
+						// Extract the specific error message from NotSupported fault's FaultMessage array
+						var errorMessages []string
+						for _, faultMsg := range notSupportedFault.FaultMessage {
+							if faultMsg.Message != "" {
+								errorMessages = append(errorMessages, faultMsg.Message)
+							}
+						}
+
+						if len(errorMessages) > 0 {
+							extractedMessage := strings.Join(errorMessages, " - ")
+							log.Infof("NotSupported fault extracted message: %s", extractedMessage)
+							return "", faultType, logger.LogNewErrorf(log,
+								"%q Failed to attach cns volume: %q to node vm: %q. fault: %q. opId: %q",
+								extractedMessage, volumeID, vm.String(), spew.Sdump(volumeOperationRes.Fault), taskInfo.ActivationId)
+						}
+
+						// Fallback to detailed dump for debugging
+						log.Debugf("NotSupported fault details: %+v", spew.Sdump(cnsFault.FaultCause))
+					}
+				}
+			}
+
 			return "", faultType, logger.LogNewErrorf(log, "failed to attach cns volume: %q to node vm: %q. fault: %q. opId: %q",
 				volumeID, vm.String(), spew.Sdump(volumeOperationRes.Fault), taskInfo.ActivationId)
 		}

pkg/common/cns-lib/volume/manager_test.go

@@ -2,10 +2,12 @@ package volume
 
 import (
 	"context"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	cnstypes "github.com/vmware/govmomi/cns/types"
 	vim25types "github.com/vmware/govmomi/vim25/types"
 )
 
@@ -50,3 +52,119 @@ func performSlowTask(ch chan TaskResult, delay time.Duration) {
 		Err:      nil,
 	}
 }
+
+// Test CnsFault with NotSupported fault cause detection
+func TestCnsFaultNotSupportedDetection(t *testing.T) {
+	tests := []struct {
+		name               string
+		fault              vim25types.BaseMethodFault
+		expectCnsFault     bool
+		expectNotSupported bool
+		expectedMessage    string
+	}{
+		{
+			name: "CnsFault with NotSupported cause",
+			fault: &cnstypes.CnsFault{
+				MethodFault: vim25types.MethodFault{
+					FaultCause: &vim25types.LocalizedMethodFault{
+						LocalizedMessage: "The operation is not supported on the object.",
+						Fault: &vim25types.NotSupported{
+							RuntimeFault: vim25types.RuntimeFault{
+								MethodFault: vim25types.MethodFault{
+									FaultMessage: []vim25types.LocalizableMessage{
+										{
+											Message: "Attaching mutually shared fcd disks to same VM is not supported.",
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				Reason: "VSLM task failed",
+			},
+			expectCnsFault:     true,
+			expectNotSupported: true,
+			expectedMessage:    "Attaching mutually shared fcd disks to same VM is not supported.",
+		},
+		{
+			name: "CnsFault with NotSupported cause - multiple messages",
+			fault: &cnstypes.CnsFault{
+				MethodFault: vim25types.MethodFault{
+					FaultCause: &vim25types.LocalizedMethodFault{
+						LocalizedMessage: "The operation is not supported on the object.",
+						Fault: &vim25types.NotSupported{
+							RuntimeFault: vim25types.RuntimeFault{
+								MethodFault: vim25types.MethodFault{
+									FaultMessage: []vim25types.LocalizableMessage{
+										{
+											Message: "First error message.",
+										},
+										{
+											Message: "Second error message.",
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				Reason: "VSLM task failed",
+			},
+			expectCnsFault:     true,
+			expectNotSupported: true,
+			expectedMessage:    "First error message. - Second error message.",
+		},
+		{
+			name: "CnsFault without NotSupported cause",
+			fault: &cnstypes.CnsFault{
+				MethodFault: vim25types.MethodFault{
+					FaultMessage: []vim25types.LocalizableMessage{
+						{Message: "Some other error"},
+					},
+				},
+				Reason: "VSLM task failed",
+			},
+			expectCnsFault:     true,
+			expectNotSupported: false,
+		},
+		{
+			name: "Non-CnsFault",
+			fault: &vim25types.MethodFault{
+				FaultMessage: []vim25types.LocalizableMessage{
+					{Message: "Generic fault"},
+				},
+			},
+			expectCnsFault:     false,
+			expectNotSupported: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Test type assertions that would be used in the AttachVolume function
+			cnsFault, isCnsFault := tt.fault.(*cnstypes.CnsFault)
+			assert.Equal(t, tt.expectCnsFault, isCnsFault)
+
+			if isCnsFault && cnsFault.FaultCause != nil {
+				notSupportedFault, isNotSupportedFault := cnsFault.FaultCause.Fault.(*vim25types.NotSupported)
+				assert.Equal(t, tt.expectNotSupported, isNotSupportedFault)
+
+				if isNotSupportedFault && tt.expectedMessage != "" {
+					// Test message extraction logic - only extract from FaultMessage array
+					var errorMessages []string
+					for _, faultMsg := range notSupportedFault.FaultMessage {
+						if faultMsg.Message != "" {
+							errorMessages = append(errorMessages, faultMsg.Message)
+						}
+					}
+
+					if len(errorMessages) > 0 {
+						extractedMessage := strings.Join(errorMessages, " - ")
+						assert.Equal(t, tt.expectedMessage, extractedMessage)
+					}
+				}
+			}
+		})
+	}
+}