Adds obsv samples for powermax

Adds unit test for obs for powermax

controllers/csm_controller.go

@@ -811,6 +811,7 @@ func (r *ContainerStorageModuleReconciler) reconcileObservability(ctx context.Co
 	metricsComp2reconFunc := map[string]func(context.Context, bool, utils.OperatorConfig, csmv1.ContainerStorageModule, client.Client, kubernetes.Interface) error{
 		modules.ObservabilityMetricsPowerScaleName: modules.PowerScaleMetrics,
 		modules.ObservabilityMetricsPowerFlexName:  modules.PowerFlexMetrics,
+		modules.ObservabilityMetricsPowerMaxName:   modules.PowerMaxMetrics,
 	}
 
 	for _, comp := range components {
@@ -819,7 +820,7 @@ func (r *ContainerStorageModuleReconciler) reconcileObservability(ctx context.Co
 		switch comp {
 		case modules.ObservabilityTopologyName, modules.ObservabilityOtelCollectorName, modules.ObservabilityCertManagerComponent:
 			err = comp2reconFunc[comp](ctx, isDeleting, op, cr, ctrlClient)
-		case modules.ObservabilityMetricsPowerScaleName, modules.ObservabilityMetricsPowerFlexName:
+		case modules.ObservabilityMetricsPowerScaleName, modules.ObservabilityMetricsPowerFlexName, modules.ObservabilityMetricsPowerMaxName:
 			err = metricsComp2reconFunc[comp](ctx, isDeleting, op, cr, ctrlClient, k8sClient)
 		default:
 			err = fmt.Errorf("unsupported component type: %v", comp)
@@ -1198,7 +1199,7 @@ func checkUpgrade(ctx context.Context, cr *csmv1.ContainerStorageModule, operato
 
 	// If annotation exists, we are doing an upgrade or modify
 	if configVersionExists {
-		// if versions are equal, it is a modify
+		// if versions are equal, it is a modification
 		if oldVersion == cr.Spec.Driver.ConfigVersion {
 			log.Infow("proceeding with modification of driver install")
 			return true, nil

operatorconfig/moduleconfig/observability/v1.5.0/karavi-metrics-powermax.yaml

@@ -0,0 +1,159 @@
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: karavi-metrics-powermax-controller
+  namespace: karavi
+
+---
+
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: karavi-metrics-powermax-controller
+rules:
+  - apiGroups: ["storage.k8s.io"]
+    resources: ["csinodes", "storageclasses"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["persistentvolumes", "nodes"]
+    verbs: ["list"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["*"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["list", "watch", "get"]
+---
+
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: karavi-metrics-powermax-controller
+subjects:
+  - kind: ServiceAccount
+    name: karavi-metrics-powermax-controller
+    namespace: karavi
+roleRef:
+  kind: ClusterRole
+  name: karavi-metrics-powermax-controller
+  apiGroup: rbac.authorization.k8s.io
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app.kubernetes.io/name: karavi-metrics-powermax
+    app.kubernetes.io/instance: karavi
+  name: karavi-metrics-powermax
+  namespace: karavi
+spec:
+  type: ClusterIP
+  ports:
+    - name: karavi-metrics-powermax
+      port: 8081
+      targetPort: 8081
+  selector:
+    app.kubernetes.io/name: karavi-metrics-powermax
+    app.kubernetes.io/instance: karavi
+
+---
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: karavi-metrics-powermax-configmap
+  namespace: karavi
+data:
+  karavi-metrics-powermax.yaml : |
+    COLLECTOR_ADDR: <COLLECTOR_ADDRESS>
+    PROVISIONER_NAMES: csi-powermax.dellemc.com
+    POWERMAX_CAPACITY_METRICS_ENABLED: <POWERMAX_CAPACITY_METRICS_ENABLED>
+    POWERMAX_CAPACITY_POLL_FREQUENCY: <POWERMAX_CAPACITY_POLL_FREQUENCY>
+    POWERMAX_PERFORMANCE_METRICS_ENABLED: <POWERMAX_PERFORMANCE_METRICS_ENABLED>
+    POWERMAX_PERFORMANCE_POLL_FREQUENCY: <POWERMAX_PERFORMANCE_POLL_FREQUENCY>
+    POWERMAX_MAX_CONCURRENT_QUERIES: <POWERMAX_MAX_CONCURRENT_QUERIES>
+    LOG_LEVEL: <POWERMAX_LOG_LEVEL>
+    LOG_FORMAT: <POWERMAX_LOG_FORMAT>
+
+---
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: <DriverDefaultReleaseName>-config-params
+  namespace: karavi
+data:
+  driver-config-params.yaml: |
+    CSI_LOG_LEVEL: debug
+    CSI_LOG_FORMAT: TEXT
+
+---
+
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: karavi-metrics-powermax
+  namespace: karavi
+  labels:
+    app.kubernetes.io/name: karavi-metrics-powermax
+    app.kubernetes.io/instance: karavi
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: karavi-metrics-powermax
+      app.kubernetes.io/instance: karavi
+  replicas: 1
+  strategy: {}
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: karavi-metrics-powermax
+        app.kubernetes.io/instance: karavi
+    spec:
+      serviceAccountName: karavi-metrics-powermax-controller
+      containers:
+        - name: karavi-metrics-powermax
+          image: <POWERMAX_OBS_IMAGE>
+          resources: {}
+          env:
+            - name: POWERMAX_METRICS_ENDPOINT
+              value: "karavi-metrics-powermax"
+            - name: POWERMAX_METRICS_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+            - name: TLS_ENABLED
+              value: "true"
+            - name: SSL_CERT_DIR
+              value: /certs
+          volumeMounts:
+            - name: <X_CSI_CONFIG_MAP_NAME>
+              mountPath: /etc/reverseproxy
+            - name: tls-secret
+              mountPath: /etc/ssl/certs
+              readOnly: true
+            - name: karavi-metrics-powermax-configmap
+              mountPath: /etc/config
+            - name: certs
+              mountPath: /certs
+      volumes:
+        - name: certs
+          emptyDir: { }
+        - name: <X_CSI_CONFIG_MAP_NAME>
+          configMap:
+            name: <X_CSI_CONFIG_MAP_NAME>
+        - name: tls-secret
+          secret:
+            secretName: otel-collector-tls
+            items:
+              - key: tls.crt
+                path: cert.crt
+        - name: karavi-metrics-powermax-configmap
+          configMap:
+            name: karavi-metrics-powermax-configmap
+        - name: powermax-config-params
+          configMap:
+            name: <DriverDefaultReleaseName>-config-params
+      restartPolicy: Always
+status: {}

pkg/modules/observability.go

@@ -46,6 +46,9 @@ const (
 	// ObservabilityMetricsPowerFlexName - component metrics-powerflex
 	ObservabilityMetricsPowerFlexName string = "metrics-powerflex"
 
+	// ObservabilityMetricsPowerMaxName - component metrics-powermax
+	ObservabilityMetricsPowerMaxName string = "metrics-powermax"
+
 	// TopologyLogLevel -
 	TopologyLogLevel string = "<TOPOLOGY_LOG_LEVEL>"
 
@@ -139,8 +142,35 @@ const (
 	// DriverDefaultReleaseName constant
 	DriverDefaultReleaseName string = "<DriverDefaultReleaseName>"
 
-	// PflexObsYamlFile - Otel Collector yaml file
+	// PflexObsYamlFile - powerflex metrics yaml file
 	PflexObsYamlFile string = "karavi-metrics-powerflex.yaml"
+
+	// PmaxCapacityMetricsEnabled - enable/disable capacity metrics
+	PmaxCapacityMetricsEnabled string = "<POWERMAX_CAPACITY_METRICS_ENABLED>"
+
+	// PmaxCapacityPollFreq - polling frequency to get capacity metrics
+	PmaxCapacityPollFreq string = "<POWERMAX_CAPACITY_POLL_FREQUENCY>"
+
+	// PmaxPerformanceMetricsEnabled - enable/disable performance metrics
+	PmaxPerformanceMetricsEnabled string = "<POWERMAX_PERFORMANCE_METRICS_ENABLED>"
+
+	// PmaxPerformancePollFreq - polling frequency to get capacity metrics
+	PmaxPerformancePollFreq string = "<POWERMAX_PERFORMANCE_POLL_FREQUENCY>"
+
+	// PmaxConcurrentQueries - number of concurrent queries
+	PmaxConcurrentQueries string = "<POWERMAX_MAX_CONCURRENT_QUERIES>"
+
+	// PmaxLogLevel - the level for the Powermax metrics
+	PmaxLogLevel string = "<POWERMAX_LOG_LEVEL>"
+
+	// PmaxLogFormat - log format for Powermax metrics
+	PmaxLogFormat string = "<POWERMAX_LOG_FORMAT>"
+
+	// PmaxObsImage - Observability image for Powermax
+	PmaxObsImage string = "<POWERMAX_OBS_IMAGE>"
+
+	// PMaxObsYamlFile - powermax metrics yaml file
+	PMaxObsYamlFile string = "karavi-metrics-powermax.yaml"
 )
 
 // ObservabilitySupportedDrivers is a map containing the CSI Drivers supported by CSM Replication. The key is driver name and the value is the driver plugin identifier
@@ -161,6 +191,10 @@ var ObservabilitySupportedDrivers = map[string]SupportedDriverParam{
 		PluginIdentifier:              drivers.PowerFlexPluginIdentifier,
 		DriverConfigParamsVolumeMount: drivers.PowerFlexConfigParamsVolumeMount,
 	},
+	string(csmv1.PowerMax): {
+		PluginIdentifier:              drivers.PowerMaxPluginIdentifier,
+		DriverConfigParamsVolumeMount: drivers.PowerMaxConfigParamsVolumeMount,
+	},
 }
 
 var defaultVolumeConfigName = map[csmv1.DriverType]string{
@@ -754,3 +788,147 @@ func createObsSecretObj(driverSecret corev1.Secret, newNameSpace, newSecretName
 func getNewAuthSecretName(driverType csmv1.DriverType, secretName string) string {
 	return fmt.Sprintf("%s-%s", driverType, secretName)
 }
+
+// PowerMaxMetrics - delete or update powermax metrics objects
+func PowerMaxMetrics(ctx context.Context, isDeleting bool, op utils.OperatorConfig, cr csmv1.ContainerStorageModule, ctrlClient client.Client, k8sClient kubernetes.Interface) error {
+	log := logger.GetLogger(ctx)
+
+	YamlString, err := getPowerMaxMetricsObject(op, cr)
+	if err != nil {
+		return err
+	}
+
+	powerMaxMetricsObjects, err := utils.GetModuleComponentObj([]byte(YamlString))
+	if err != nil {
+		return err
+	}
+
+	// update secret volume and inject authorization to deployment
+	var dpApply *confv1.DeploymentApplyConfiguration
+	foundDp := false
+	for i, obj := range powerMaxMetricsObjects {
+		if deployment, ok := obj.(*appsv1.Deployment); ok {
+			dpApply, err = parseObservabilityMetricsDeployment(ctx, deployment, op, cr)
+			if err != nil {
+				return err
+			}
+			foundDp = true
+			powerMaxMetricsObjects[i] = powerMaxMetricsObjects[len(powerMaxMetricsObjects)-1]
+			powerMaxMetricsObjects = powerMaxMetricsObjects[:len(powerMaxMetricsObjects)-1]
+			break
+		}
+	}
+	if !foundDp {
+		return fmt.Errorf("could not find deployment obj")
+	}
+
+	powerMaxMetricsObjects, err = appendObservabilitySecrets(ctx, cr, powerMaxMetricsObjects, ctrlClient, k8sClient)
+	if err != nil {
+		return fmt.Errorf("copy secrets from %s: %v", cr.Namespace, err)
+	}
+
+	for _, ctrlObj := range powerMaxMetricsObjects {
+		if isDeleting {
+			if err := utils.DeleteObject(ctx, ctrlObj, ctrlClient); err != nil {
+				return err
+			}
+		} else {
+			if err := utils.ApplyCTRLObject(ctx, ctrlObj, ctrlClient); err != nil {
+				return err
+			}
+		}
+	}
+
+	// update Deployment
+	if isDeleting {
+		// Delete Deployment
+		deploymentKey := client.ObjectKey{
+			Namespace: *dpApply.Namespace,
+			Name:      *dpApply.Name,
+		}
+		deploymentObj := &appsv1.Deployment{}
+		if err = ctrlClient.Get(ctx, deploymentKey, deploymentObj); err == nil {
+			if err = ctrlClient.Delete(ctx, deploymentObj); err != nil && !k8serrors.IsNotFound(err) {
+				return fmt.Errorf("error delete deployment: %v", err)
+			}
+		} else {
+			log.Infow("error getting deployment", "deploymentKey", deploymentKey)
+		}
+	} else {
+		// Create/Update Deployment
+		if err = deployment.SyncDeployment(ctx, *dpApply, k8sClient, cr.Name); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// getPowerMaxMetricsObject - get powermax metrics yaml string
+func getPowerMaxMetricsObject(op utils.OperatorConfig, cr csmv1.ContainerStorageModule) (string, error) {
+	YamlString := ""
+
+	obs, err := getObservabilityModule(cr)
+	if err != nil {
+		return YamlString, err
+	}
+
+	buf, err := readConfigFile(obs, cr, op, PMaxObsYamlFile)
+	if err != nil {
+		return YamlString, err
+	}
+	YamlString = string(buf)
+
+	otelCollectorAddress := "otel-collector:55680"
+	pmaxImage := "dellemc/csm-metrics-powermax:v1.1.0"
+	maxConcurrentQueries := "10"
+	capacityEnabled := "true"
+	perfEnabled := "true"
+	capacityPollFrequency := "10"
+	perfPollFrequency := "10"
+	logFormat := "TEXT"
+	logLevel := "INFO"
+	revproxyConfigMap := "powermax-reverseproxy-config"
+
+	for _, component := range obs.Components {
+		if component.Name == ObservabilityMetricsPowerMaxName {
+			if component.Image != "" {
+				pmaxImage = string(component.Image)
+			}
+			for _, env := range component.Envs {
+				if strings.Contains(PmaxLogLevel, env.Name) {
+					logLevel = env.Value
+				} else if strings.Contains(PmaxConcurrentQueries, env.Name) {
+					maxConcurrentQueries = env.Value
+				} else if strings.Contains(PmaxCapacityMetricsEnabled, env.Name) {
+					capacityEnabled = env.Value
+				} else if strings.Contains(PmaxCapacityPollFreq, env.Name) {
+					capacityPollFrequency = env.Value
+				} else if strings.Contains(PmaxPerformanceMetricsEnabled, env.Name) {
+					perfEnabled = env.Value
+				} else if strings.Contains(PmaxPerformancePollFreq, env.Name) {
+					perfPollFrequency = env.Value
+				} else if strings.Contains(ReverseProxyConfigMap, env.Name) {
+					revproxyConfigMap = env.Value
+				} else if strings.Contains(PmaxLogFormat, env.Name) {
+					logFormat = env.Value
+				} else if strings.Contains(OtelCollectorAddress, env.Name) {
+					otelCollectorAddress = env.Value
+				}
+			}
+		}
+	}
+
+	YamlString = strings.ReplaceAll(YamlString, PmaxObsImage, pmaxImage)
+	YamlString = strings.ReplaceAll(YamlString, PmaxLogLevel, logLevel)
+	YamlString = strings.ReplaceAll(YamlString, PmaxLogFormat, logFormat)
+	YamlString = strings.ReplaceAll(YamlString, PmaxConcurrentQueries, maxConcurrentQueries)
+	YamlString = strings.ReplaceAll(YamlString, PmaxCapacityMetricsEnabled, capacityEnabled)
+	YamlString = strings.ReplaceAll(YamlString, PmaxCapacityPollFreq, capacityPollFrequency)
+	YamlString = strings.ReplaceAll(YamlString, PmaxPerformanceMetricsEnabled, perfEnabled)
+	YamlString = strings.ReplaceAll(YamlString, PmaxPerformancePollFreq, perfPollFrequency)
+	YamlString = strings.ReplaceAll(YamlString, OtelCollectorAddress, otelCollectorAddress)
+	YamlString = strings.ReplaceAll(YamlString, ReverseProxyConfigMap, revproxyConfigMap)
+	YamlString = strings.ReplaceAll(YamlString, DriverDefaultReleaseName, cr.Name)
+	return YamlString, nil
+}