Add global override for vmcluster

Author: vrutkovs

api/operator/v1alpha1/vmdistributedcluster_types.go

@@ -63,6 +63,13 @@ type VMDistributedClusterSpec struct {
 // +k8s:openapi-gen=true
 // ZoneSpec is a list of VMCluster instances to update.
 type ZoneSpec struct {
+	// GlobalOverrideSpec specifies an override to all VMClusters.
+	// These overrides are applied to the referenced object if `Ref` is specified.
+	// +kubebuilder:validation:Type=object
+	// +kubebuilder:validation:XPreserveUnknownFields
+	// +optional
+	GlobalOverrideSpec *apiextensionsv1.JSON `json:"globalOverrideSpec,omitempty"`
+
 	// Each VMClusterRefOrSpec is either defining a new inline VMCluster or referencing an existing one.
 	VMClusters []VMClusterRefOrSpec `json:"vmclusters,omitempty"`
 }
@@ -75,6 +82,7 @@ type VMClusterRefOrSpec struct {
 	// If Ref is specified, Name and Spec are ignored.
 	// +optional
 	Ref *corev1.LocalObjectReference `json:"ref,omitempty"`
+
 	// OverrideSpec specifies an override to the VMClusterSpec of the referenced object.
 	// This override is applied to the referenced object if `Ref` is specified.
 	// This field is ignored if `Spec` is specified.

api/operator/v1alpha1/zz_generated.deepcopy.go

@@ -23460,6 +23460,9 @@ spec:
                   type: string
                 zones:
                   properties:
+                    globalOverrideSpec:
+                      type: object
+                      x-kubernetes-preserve-unknown-fields: true
                     vmclusters:
                       items:
                         properties:

config/crd/overlay/crd.yaml

@@ -350,6 +350,70 @@ func TestValidateVMClusterRefOrSpec_Matrix(t *testing.T) {
 	assert.Error(t, validateVMClusterRefOrSpec(6, bad))
 }
 
+func TestApplyGlobalOverrideSpec(t *testing.T) {
+	base := vmv1beta1.VMClusterSpec{
+		ClusterVersion:     "v1.0.0",
+		ServiceAccountName: "base",
+		RetentionPeriod:    "30d",
+	}
+
+	// Test with nil GlobalOverrideSpec
+	globalOverride := (*apiextensionsv1.JSON)(nil)
+	merged, modified, err := ApplyOverrideSpec(base, globalOverride)
+	assert.NoError(t, err)
+	assert.False(t, modified)
+	assert.Equal(t, base, merged)
+
+	// Test with empty GlobalOverrideSpec
+	emptyGlobal := &apiextensionsv1.JSON{Raw: []byte("{}")}
+	merged2, modified2, err := ApplyOverrideSpec(base, emptyGlobal)
+	assert.NoError(t, err)
+	assert.False(t, modified2)
+	assert.Equal(t, base, merged2)
+
+	// Test with GlobalOverrideSpec that modifies top-level fields
+	globalTopLevel := &apiextensionsv1.JSON{Raw: []byte(`{"clusterVersion": "v2.0.0", "serviceAccountName": "global-sa"}`)}
+	merged3, modified3, err := ApplyOverrideSpec(base, globalTopLevel)
+	assert.NoError(t, err)
+	assert.True(t, modified3)
+	assert.Equal(t, "v2.0.0", merged3.ClusterVersion)
+	assert.Equal(t, "global-sa", merged3.ServiceAccountName)
+	assert.Equal(t, "30d", merged3.RetentionPeriod) // Unchanged field
+
+	// Test with GlobalOverrideSpec that sets a field to null
+	globalNullify := &apiextensionsv1.JSON{Raw: []byte(`{"serviceAccountName": null}`)}
+	merged5, modified5, err := ApplyOverrideSpec(base, globalNullify)
+	assert.NoError(t, err)
+	assert.True(t, modified5)
+	assert.Equal(t, "", merged5.ServiceAccountName) // Should be empty string (null in JSON becomes empty string after unmarshal)
+}
+
+func TestApplyGlobalAndClusterSpecificOverrideSpecs(t *testing.T) {
+	base := vmv1beta1.VMClusterSpec{
+		ClusterVersion:     "v1.0.0",
+		ServiceAccountName: "base",
+		RetentionPeriod:    "30d",
+	}
+
+	// Apply GlobalOverrideSpec first
+	globalOverride := &apiextensionsv1.JSON{Raw: []byte(`{"clusterVersion": "v2.0.0", "serviceAccountName": "global-sa"}`)}
+	merged1, modified1, err := ApplyOverrideSpec(base, globalOverride)
+	assert.NoError(t, err)
+	assert.True(t, modified1)
+	assert.Equal(t, "v2.0.0", merged1.ClusterVersion)
+	assert.Equal(t, "global-sa", merged1.ServiceAccountName)
+	assert.Equal(t, "30d", merged1.RetentionPeriod)
+
+	// Then apply cluster-specific override
+	clusterOverride := &apiextensionsv1.JSON{Raw: []byte(`{"retentionPeriod": "10d", "clusterVersion": "v3.0.0"}`)}
+	merged2, modified2, err := ApplyOverrideSpec(merged1, clusterOverride)
+	assert.NoError(t, err)
+	assert.True(t, modified2)
+	assert.Equal(t, "v3.0.0", merged2.ClusterVersion)        // Cluster-specific override should take precedence
+	assert.Equal(t, "global-sa", merged2.ServiceAccountName) // From global override, unchanged by cluster override
+	assert.Equal(t, "10d", merged2.RetentionPeriod)          // From cluster override
+}
+
 // helpers
 func ptrTo[T any](v T) *T { return &v }
 

internal/controller/operator/factory/vmdistributedcluster/vmcluster_test.go

@@ -116,17 +116,25 @@ func CreateOrUpdate(ctx context.Context, cr *vmv1alpha1.VMDistributedCluster, rc
 		}
 
 		// Update the VMCluster when overrideSpec needs to be applied or ownerref set
-		var mergedSpec vmv1beta1.VMClusterSpec
-		var modifiedSpec bool
+		mergedSpec := vmClusterObj.Spec
+		modifiedSpec := false
 
-		if zoneRefOrSpec.Ref != nil {
-			mergedSpec, modifiedSpec, err = ApplyOverrideSpec(vmClusterObj.Spec, zoneRefOrSpec.OverrideSpec)
+		// Apply GlobalOverrideSpec if it is set
+		if cr.Spec.Zones.GlobalOverrideSpec != nil {
+			mergedSpec, modifiedSpec, err = ApplyOverrideSpec(vmClusterObj.Spec, cr.Spec.Zones.GlobalOverrideSpec)
+			if err != nil {
+				return fmt.Errorf("failed to apply global override spec for vmcluster %s at index %d: %w", vmClusterObj.Name, i, err)
+			}
+		}
+		// Apply cluster-specific override if it exist
+		if zoneRefOrSpec.Ref != nil && zoneRefOrSpec.OverrideSpec != nil {
+			mergedSpec, modifiedSpec, err = ApplyOverrideSpec(mergedSpec, zoneRefOrSpec.OverrideSpec)
 			if err != nil {
 				return fmt.Errorf("failed to apply override spec for vmcluster %s at index %d: %w", vmClusterObj.Name, i, err)
 			}
 		}
 		if zoneRefOrSpec.Spec != nil {
-			mergedSpec, modifiedSpec, err = mergeVMClusterSpecs(vmClusterObj.Spec, *zoneRefOrSpec.Spec)
+			mergedSpec, modifiedSpec, err = mergeVMClusterSpecs(mergedSpec, *zoneRefOrSpec.Spec)
 			if err != nil {
 				return fmt.Errorf("failed to merge spec for vmcluster %s at index %d: %w", vmClusterObj.Name, i, err)
 			}

internal/controller/operator/factory/vmdistributedcluster/vmdistributedcluster.go

@@ -1003,4 +1003,102 @@ var _ = Describe("e2e vmdistributedcluster", Label("vm", "vmdistributedcluster")
 			}
 		})
 	})
+
+	Describe("GlobalOverrideSpec", func() {
+		It("should apply global overrides before cluster-specific overrides", func() {
+			By("creating initial VMClusters")
+			vmCluster1 := &vmv1beta1.VMCluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: namespace,
+					Name:      "vmcluster-global-1",
+				},
+				Spec: vmv1beta1.VMClusterSpec{
+					ClusterVersion:  "v1.126.0-cluster",
+					RetentionPeriod: "30d",
+					VMStorage: &vmv1beta1.VMStorage{
+						CommonApplicationDeploymentParams: vmv1beta1.CommonApplicationDeploymentParams{
+							ReplicaCount: ptr.To[int32](1),
+						},
+					},
+				},
+			}
+			createVMClusterAndEnsureOperational(ctx, k8sClient, vmCluster1, namespace)
+
+			vmCluster2 := &vmv1beta1.VMCluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: namespace,
+					Name:      "vmcluster-global-2",
+				},
+				Spec: vmv1beta1.VMClusterSpec{
+					ClusterVersion:  "v1.126.0-cluster",
+					RetentionPeriod: "30d",
+					VMStorage: &vmv1beta1.VMStorage{
+						CommonApplicationDeploymentParams: vmv1beta1.CommonApplicationDeploymentParams{
+							ReplicaCount: ptr.To[int32](1),
+						},
+					},
+				},
+			}
+			createVMClusterAndEnsureOperational(ctx, k8sClient, vmCluster2, namespace)
+
+			By("creating a VMDistributedCluster with GlobalOverrideSpec and cluster-specific overrides")
+			namespacedName.Name = "global-override-cluster"
+			cr := &vmv1alpha1.VMDistributedCluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: namespace,
+					Name:      namespacedName.Name,
+				},
+				Spec: vmv1alpha1.VMDistributedClusterSpec{
+					VMAgentFlushDeadline: &metav1.Duration{Duration: 1 * time.Second},
+					ZoneUpdatePause:      &metav1.Duration{Duration: 1 * time.Second},
+					VMAgent:              vmv1alpha1.VMAgentNameAndSpec{Name: existingVMAgentName},
+					VMAuth:               vmv1alpha1.VMAuthNameAndSpec{Name: existingVMAuthName},
+					Zones: vmv1alpha1.ZoneSpec{
+						GlobalOverrideSpec: &apiextensionsv1.JSON{
+							Raw: []byte(`{"clusterVersion": "v1.127.0-cluster", "retentionPeriod": "60d"}`),
+						},
+						VMClusters: []vmv1alpha1.VMClusterRefOrSpec{
+							{
+								Ref: &corev1.LocalObjectReference{Name: vmCluster1.Name},
+								OverrideSpec: &apiextensionsv1.JSON{
+									Raw: []byte(`{"vmStorage": {"replicaCount": 2}}`),
+								},
+							},
+							{
+								Ref: &corev1.LocalObjectReference{Name: vmCluster2.Name},
+								OverrideSpec: &apiextensionsv1.JSON{
+									Raw: []byte(`{"vmStorage": {"replicaCount": 3}}`),
+								},
+							},
+						},
+					},
+				},
+			}
+			DeferCleanup(func() {
+				Expect(finalize.SafeDelete(ctx, k8sClient, cr)).To(Succeed())
+			})
+			Expect(k8sClient.Create(ctx, cr)).To(Succeed())
+
+			By("waiting for VMDistributedCluster to become operational")
+			Eventually(func() error {
+				return expectObjectStatusOperational(ctx, k8sClient, &vmv1alpha1.VMDistributedCluster{}, namespacedName)
+			}, eventualVMDistributedClusterExpandingTimeout).WithContext(ctx).Should(Succeed())
+			verifyOwnerReferences(ctx, cr, []vmv1beta1.VMCluster{*vmCluster1, *vmCluster2}, namespace)
+
+			By("verifying that both VMClusters have the global override applied")
+			var updatedCluster1, updatedCluster2 vmv1beta1.VMCluster
+			Expect(k8sClient.Get(ctx, types.NamespacedName{Name: vmCluster1.Name, Namespace: namespace}, &updatedCluster1)).To(Succeed())
+			Expect(k8sClient.Get(ctx, types.NamespacedName{Name: vmCluster2.Name, Namespace: namespace}, &updatedCluster2)).To(Succeed())
+
+			// Global overrides should be applied
+			Expect(updatedCluster1.Spec.ClusterVersion).To(Equal("v1.127.0-cluster"))
+			Expect(updatedCluster1.Spec.RetentionPeriod).To(Equal("60d"))
+			Expect(updatedCluster2.Spec.ClusterVersion).To(Equal("v1.127.0-cluster"))
+			Expect(updatedCluster2.Spec.RetentionPeriod).To(Equal("60d"))
+
+			// Cluster-specific overrides should be applied after global overrides
+			Expect(*updatedCluster1.Spec.VMStorage.ReplicaCount).To(Equal(int32(2)))
+			Expect(*updatedCluster2.Spec.VMStorage.ReplicaCount).To(Equal(int32(3)))
+		})
+	})
 })