Added concurrency Flag for ASUP reporting

Author: clintonk

core/common.go

@@ -19,6 +19,8 @@ const (
 	NodeAccessReconcilePeriod      = time.Second * 30
 	NodeRegistrationCooldownPeriod = time.Second * 30
 	AttachISCSIVolumeTimeoutLong   = time.Second * 90
+
+	FlagConcurrent = "concurrent"
 )
 
 // recordTiming is used to record in Prometheus the total time taken for an operation as follows:

core/concurrent_core.go

@@ -718,6 +718,8 @@ func (o *ConcurrentTridentOrchestrator) validateAndCreateBackendFromConfig(
 		return nil, err
 	}
 
+	commonConfig.Flags[FlagConcurrent] = "true"
+
 	if !collection.StringInSlice(commonConfig.StorageDriverName, supportedBackends) {
 		return nil, fmt.Errorf("backend type %s is not yet supported by concurrent Trident",
 			commonConfig.StorageDriverName)

core/concurrent_core_test.go

@@ -286,6 +286,7 @@ func getFakeStorageDriverConfig(name string) drivers.FakeStorageDriverConfig {
 		CommonStorageDriverConfig: &drivers.CommonStorageDriverConfig{
 			Version:           drivers.ConfigVersion,
 			StorageDriverName: config.FakeStorageDriverName,
+			Flags:             make(map[string]string),
 		},
 		Protocol:     config.File,
 		Pools:        testutils.GenerateFakePools(2),
@@ -1475,6 +1476,27 @@ func TestBootstrapSubordinateVolumesConcurrentCore(t *testing.T) {
 
 // Backend tests
 
+func TestValidateAndCreateBackendFromConfig_SetsConcurrentFlag(t *testing.T) {
+	db.Initialize()
+	o := getConcurrentOrchestrator()
+
+	fakeConfig := getFakeStorageDriverConfig("test-backend")
+	configJSON, err := fakeConfig.Marshal()
+	require.NoError(t, err)
+
+	backend, err := o.validateAndCreateBackendFromConfig(testCtx, string(configJSON), "", "")
+
+	require.NoError(t, err)
+	require.NotNil(t, backend)
+
+	// Verify the concurrent flag was set in the backend's common config
+	commonConfig := backend.Driver().GetCommonConfig(testCtx)
+	require.NotNil(t, commonConfig.Flags)
+	assert.Equal(t, "true", commonConfig.Flags[FlagConcurrent])
+
+	persistenceCleanup(t, o)
+}
+
 func TestGetBackendConcurrentCore(t *testing.T) {
 	tests := []struct {
 		name         string

core/orchestrator_core.go

@@ -1146,6 +1146,8 @@ func (o *TridentOrchestrator) validateAndCreateBackendFromConfig(
 		return nil, err
 	}
 
+	commonConfig.Flags[FlagConcurrent] = "false"
+
 	// For backends created using CRD Controller ensure there are no forbidden fields
 	if isCRDContext(ctx) {
 		if err = factory.SpecOnlyValidation(ctx, commonConfig, configInJSON); err != nil {

core/orchestrator_core_test.go

@@ -2304,6 +2304,36 @@ func TestBackendCleanup(t *testing.T) {
 	}
 }
 
+func TestAddBackend_SetsConcurrentFlag(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	o := getOrchestrator(t, false)
+	defer cleanup(t, o)
+
+	// Create a simple fake backend config
+	configJSON := `{
+		"version": 1,
+		"storageDriverName": "fake",
+		"storagePrefix": "test_"
+	}`
+
+	backendExternal, err := o.AddBackend(context.Background(), configJSON, "")
+	assert.NoError(t, err)
+	assert.NotNil(t, backendExternal)
+
+	// Verify the backend was added
+	backend, found := o.backends[backendExternal.BackendUUID]
+	assert.True(t, found)
+	assert.NotNil(t, backend)
+
+	// Verify the Flags map contains the concurrent flag set to "false"
+	driver := backend.Driver()
+	commonConfig := driver.GetCommonConfig(context.Background())
+	assert.NotNil(t, commonConfig.Flags)
+	assert.Equal(t, "false", commonConfig.Flags["concurrent"])
+}
+
 func TestLoadBackend(t *testing.T) {
 	const (
 		backendName = "load-backend-test"

storage_drivers/common.go

@@ -93,6 +93,8 @@ func ValidateCommonSettings(ctx context.Context, configJSON string) (*CommonStor
 		}
 	}
 
+	config.Flags = make(map[string]string)
+
 	Logc(ctx).Debugf("Parsed commonConfig: %+v", *config)
 
 	return config, nil

storage_drivers/common_test.go

@@ -98,6 +98,7 @@ func TestValidateCommonSettings(t *testing.T) {
 					StorageDriverName: "ontap-nas",
 					StoragePrefixRaw:  nil,
 					StoragePrefix:     nil,
+					Flags:             make(map[string]string),
 				},
 				errorExpected: false,
 			},
@@ -152,6 +153,7 @@ func TestValidateCommonSettings(t *testing.T) {
 						"name": "secret1",
 						"type": "secret",
 					},
+					Flags: make(map[string]string),
 				},
 				errorExpected: false,
 			},

storage_drivers/fake/fake.go

@@ -207,6 +207,7 @@ func NewFakeStorageDriverConfigJSON(
 				StorageDriverName: config.FakeStorageDriverName,
 				StoragePrefixRaw:  json.RawMessage("\"\""),
 				StoragePrefix:     &prefix,
+				Flags:             make(map[string]string),
 			},
 			Protocol:     protocol,
 			Pools:        pools,

storage_drivers/ontap/ontap_factory.go

@@ -65,20 +65,18 @@ func GetStorageDriver(
 	}
 
 	// Set up driver flags
-	ontapConfig.Flags = map[string]string{
-		FlagPersonality:   PersonalityUnified,
-		FlagDisaggregated: strconv.FormatBool(API.IsDisaggregated()),
-		FlagSANOptimized:  strconv.FormatBool(API.IsSANOptimized()),
+	if ontapConfig.Flags == nil {
+		ontapConfig.Flags = make(map[string]string)
 	}
+	ontapConfig.Flags[FlagPersonality] = PersonalityUnified
+	ontapConfig.Flags[FlagDisaggregated] = strconv.FormatBool(API.IsDisaggregated())
+	ontapConfig.Flags[FlagSANOptimized] = strconv.FormatBool(API.IsSANOptimized())
 
 	switch ontapConfig.StorageDriverName {
 
 	case config.OntapNASStorageDriverName:
 		if !API.IsSANOptimized() && API.IsDisaggregated() {
 			// Setup personality to be used by ASUP
-			if ontapConfig.Flags == nil {
-				ontapConfig.Flags = make(map[string]string)
-			}
 			ontapConfig.Flags[FlagPersonality] = PersonalityAFX
 		}
 		storageDriver = &NASStorageDriver{API: API, AWSAPI: AWSAPI, Config: *ontapConfig}
@@ -119,9 +117,6 @@ func getSANStorageDriverBasedOnPersonality(
 	isASAr2 := false
 	if sanOptimized && disaggregated {
 		// Setup personality to be used by ASUP
-		if ontapConfig.Flags == nil {
-			ontapConfig.Flags = make(map[string]string)
-		}
 		ontapConfig.Flags[FlagPersonality] = PersonalityASAr2
 		isASAr2 = true
 	}

storage_drivers/ontap/ontap_factory_test.go

@@ -55,7 +55,9 @@ func TestGetDriverProtocol(t *testing.T) {
 
 func TestGetSANStorageDriverBasedOnPersonality(t *testing.T) {
 	ontapConfig := drivers.OntapStorageDriverConfig{
-		CommonStorageDriverConfig: &drivers.CommonStorageDriverConfig{},
+		CommonStorageDriverConfig: &drivers.CommonStorageDriverConfig{
+			Flags: make(map[string]string),
+		},
 	}
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()