set DisableNonReplicatableQueries before sandboxing subcluster during online upgrade

Makefile

@@ -467,7 +467,7 @@ endif
 docker-push-extra-vertica: # Push a hard-coded image used in multi-online-upgrade test
 ifeq ($(LEG9), yes)
 ifeq ($(shell $(KIND_CHECK)), 1)
-	scripts/push-to-kind.sh -i opentext/vertica-k8s-private:20240626-minimal
+	scripts/push-to-kind.sh -i opentext/vertica-k8s-private:20240725-minimal
 endif
 endif
 

pkg/catalog/config_parameter_vcluster.go

@@ -0,0 +1,51 @@
+/*
+ (c) Copyright [2021-2024] Open Text.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ You may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package catalog
+
+import (
+	"context"
+
+	"github.com/vertica/vertica-kubernetes/pkg/vadmin"
+	"github.com/vertica/vertica-kubernetes/pkg/vadmin/opts/getconfigparameter"
+	"github.com/vertica/vertica-kubernetes/pkg/vadmin/opts/setconfigparameter"
+)
+
+// GetConfigurationParameter returns the value of a config parameter from the given sandbox
+func (v *VCluster) GetConfigurationParameter(param, level, sandbox string, ctx context.Context) (value string, err error) {
+	vclusterOps := vadmin.MakeVClusterOps(v.Log, v.VDB, v.Client, v.Password, v.EVRec, vadmin.SetupVClusterOps)
+	opts := []getconfigparameter.Option{
+		getconfigparameter.WithUserName(v.VDB.GetVerticaUser()),
+		getconfigparameter.WithInitiatorIP(v.PodIP),
+		getconfigparameter.WithSandbox(sandbox),
+		getconfigparameter.WithConfigParameter(param),
+		getconfigparameter.WithLevel(level),
+	}
+	return vclusterOps.GetConfigurationParameter(ctx, opts...)
+}
+
+// SetConfigurationParameter sets the value of a configuration parameter in the given san
+func (v *VCluster) SetConfigurationParameter(param, value, level, sandbox string, ctx context.Context) error {
+	vclusterOps := vadmin.MakeVClusterOps(v.Log, v.VDB, v.Client, v.Password, v.EVRec, vadmin.SetupVClusterOps)
+	opts := []setconfigparameter.Option{
+		setconfigparameter.WithUserName(v.VDB.GetVerticaUser()),
+		setconfigparameter.WithInitiatorIP(v.PodIP),
+		setconfigparameter.WithSandbox(sandbox),
+		setconfigparameter.WithConfigParameter(param),
+		setconfigparameter.WithValue(value),
+		setconfigparameter.WithLevel(level),
+	}
+	return vclusterOps.SetConfigurationParameter(ctx, opts...)
+}

pkg/controllers/vdb/onlineupgrade_reconciler.go

@@ -26,6 +26,7 @@ import (
 	"github.com/pkg/errors"
 	vapi "github.com/vertica/vertica-kubernetes/api/v1"
 	"github.com/vertica/vertica-kubernetes/api/v1beta1"
+	"github.com/vertica/vertica-kubernetes/pkg/catalog"
 	"github.com/vertica/vertica-kubernetes/pkg/controllers"
 	verrors "github.com/vertica/vertica-kubernetes/pkg/errors"
 	"github.com/vertica/vertica-kubernetes/pkg/events"
@@ -43,14 +44,24 @@ import (
 // When we generate a sandbox for the upgrade, this is preferred name of that sandbox.
 const preferredSandboxName = "replica-group-b"
 
+const (
+	ConfigParamLevelDatabase                 = ""
+	ConfigParamBoolTrue                      = "1"
+	ConfigParamBoolFalse                     = "0"
+	ConfigParamDisableNonReplicatableQueries = "DisableNonReplicatableQueries"
+)
+
 const archiveBaseName = "upgrade_backup"
 
 // List of status messages for online upgrade. When adding a new entry here,
 // be sure to add a *StatusMsgInx const below.
 var onlineUpgradeStatusMsgs = []string{
 	"Starting online upgrade",
 	"Create new subclusters to mimic subclusters in the main cluster",
+	fmt.Sprintf("Querying the original value of config parameter %q", ConfigParamDisableNonReplicatableQueries),
+	fmt.Sprintf("Disable non-replicatable queries by setting config parameter %q", ConfigParamDisableNonReplicatableQueries),
 	"Sandbox subclusters",
+	fmt.Sprintf("clear config parameter %q on sandbox", ConfigParamDisableNonReplicatableQueries),
 	"Promote secondaries whose base subcluster is primary",
 	"Upgrade sandbox to new version",
 	"Pause connections to main cluster",
@@ -68,7 +79,10 @@ var onlineUpgradeStatusMsgs = []string{
 const (
 	startOnlineUpgradeStatusMsgInx = iota
 	createNewSubclustersStatusMsgInx
+	queryOriginalConfigParamDisableNonReplicatableQueriesMsgInx
+	disableNonReplicatableQueriesMsgInx
 	sandboxSubclustersMsgInx
+	clearDisableNonReplicatableQueriesMsgInx
 	promoteSubclustersInSandboxMsgInx
 	upgradeSandboxMsgInx
 	pauseConnectionsMsgInx
@@ -87,6 +101,7 @@ const (
 	runObjRecForMainInx = iota
 	addSubclustersInx
 	addNodeInx
+	setConfigParamIdx
 	upgradeSandboxInx
 	backupBeforeReplicationInx
 	replicationInx
@@ -100,13 +115,14 @@ const (
 // write. This is done by splitting the cluster into two separate replicas and
 // using failover strategies to keep the database online.
 type OnlineUpgradeReconciler struct {
-	VRec        *VerticaDBReconciler
-	Log         logr.Logger
-	VDB         *vapi.VerticaDB
-	PFacts      map[string]*PodFacts // We have podfacts for main cluster and replica sandbox
-	Manager     UpgradeManager
-	Dispatcher  vadmin.Dispatcher
-	sandboxName string // name of the sandbox created for replica group B
+	VRec                                                  *VerticaDBReconciler
+	Log                                                   logr.Logger
+	VDB                                                   *vapi.VerticaDB
+	PFacts                                                map[string]*PodFacts // We have podfacts for main cluster and replica sandbox
+	Manager                                               UpgradeManager
+	Dispatcher                                            vadmin.Dispatcher
+	sandboxName                                           string // name of the sandbox created for replica group B
+	originalConfigParamDisableNonReplicatableQueriesValue string
 }
 
 // MakeOnlineUpgradeReconciler will build a OnlineUpgradeReconciler object
@@ -123,6 +139,8 @@ func MakeOnlineUpgradeReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
 }
 
 // Reconcile will automate the process of a online upgrade.
+//
+//nolint:funlen
 func (r *OnlineUpgradeReconciler) Reconcile(ctx context.Context, _ *ctrl.Request) (ctrl.Result, error) {
 	if ok, err := r.Manager.IsUpgradeNeeded(ctx, vapi.MainCluster); !ok || err != nil {
 		return ctrl.Result{}, err
@@ -154,10 +172,21 @@ func (r *OnlineUpgradeReconciler) Reconcile(ctx context.Context, _ *ctrl.Request
 		r.runAddSubclusterReconcilerForMainCluster,
 		r.runAddNodesReconcilerForMainCluster,
 		r.runRebalanceSandboxSubcluster,
+		r.validateSubscriptionsActive,
+		// Get the original value of config parameter DisableNonReplicatableQueries at database level
+		r.postQueryOriginalConfigParamDisableNonReplicatableQueriesMsg,
+		r.queryOriginalConfigParamDisableNonReplicatableQueries,
+		// Disable all non-replicatable queries by setting config parameter DisableNonReplicatableQueries
+		// at database level
+		r.postDisableNonReplicatableQueriesMsg,
+		r.setConfigParamDisableNonReplicatableQueries,
 		// Sandbox all of the secondary subclusters that are destined for
 		// replica group B.
 		r.postSandboxSubclustersMsg,
 		r.sandboxReplicaGroupB,
+		// workaround: clear the value to force vertica.conf to be rewritten
+		r.postClearConfigParamDisableNonReplicatableQueriesMsg,
+		r.clearConfigParamDisableNonReplicatableQueries,
 		// Change replica b subcluster types to match the main cluster's
 		r.postPromoteSubclustersInSandboxMsg,
 		r.promoteReplicaBSubclusters,
@@ -337,6 +366,14 @@ func (r *OnlineUpgradeReconciler) runRebalanceSandboxSubcluster(ctx context.Cont
 	return res, err
 }
 
+func (r *OnlineUpgradeReconciler) validateSubscriptionsActive(ctx context.Context) (ctrl.Result, error) {
+	// If we have already promoted sandbox to main, we don't need to touch old main cluster
+	if vmeta.GetOnlineUpgradeStepInx(r.VDB.Annotations) > promoteSandboxInx {
+		return ctrl.Result{}, nil
+	}
+	return r.Manager.checkAllSubscriptionsActive(ctx, r.PFacts[vapi.MainCluster])
+}
+
 // postCreateNewSubclustersMsg will update the status message to indicate that
 // we are about to create new subclusters to mimic the main cluster's subclusters.
 func (r *OnlineUpgradeReconciler) postCreateNewSubclustersMsg(ctx context.Context) (ctrl.Result, error) {
@@ -368,6 +405,84 @@ func (r *OnlineUpgradeReconciler) assignSubclustersToReplicaGroupB(ctx context.C
 	return ctrl.Result{}, nil
 }
 
+// postQueryOriginalConfigParamDisableNonReplicatableQueriesMsg updates the status message to indicate that
+// we are going to query the original value of config parameter DisableNonReplicatableQueries.
+func (r *OnlineUpgradeReconciler) postQueryOriginalConfigParamDisableNonReplicatableQueriesMsg(
+	ctx context.Context) (ctrl.Result, error) {
+	return r.postNextStatusMsg(ctx, queryOriginalConfigParamDisableNonReplicatableQueriesMsgInx)
+}
+
+// queryOriginalConfigParamDisableNonReplicatableQueries gets value of the config parameter
+// DisableNonReplicatableQueries at database level within main cluster
+func (r *OnlineUpgradeReconciler) queryOriginalConfigParamDisableNonReplicatableQueries(ctx context.Context) (res ctrl.Result, err error) {
+	if r.originalConfigParamDisableNonReplicatableQueriesValue != "" ||
+		vmeta.GetOnlineUpgradeStepInx(r.VDB.Annotations) > setConfigParamIdx {
+		return ctrl.Result{}, err
+	}
+	pf := r.PFacts[vapi.MainCluster]
+	initiator, ok := pf.findFirstUpPod(false /*not allow read-only*/, "" /*arbitrary subcluster*/)
+	if !ok {
+		r.Log.Info("No Up nodes found. Requeue reconciliation.")
+		return ctrl.Result{Requeue: true}, nil
+	}
+	vc := catalog.MakeVCluster(r.VDB, pf.VerticaSUPassword, initiator.podIP, r.Log, r.VRec.Client, r.VRec.EVRec)
+	r.originalConfigParamDisableNonReplicatableQueriesValue, err = vc.GetConfigurationParameter(ConfigParamDisableNonReplicatableQueries,
+		ConfigParamLevelDatabase, vapi.MainCluster, ctx)
+	return ctrl.Result{}, err
+}
+
+// postDisableNonReplicatableQueriesMsg updates the status message to indicate that
+// we are going to disable non-replicatable queries by setting config parameter DisableNonReplicatableQueries.
+func (r *OnlineUpgradeReconciler) postDisableNonReplicatableQueriesMsg(ctx context.Context) (ctrl.Result, error) {
+	return r.postNextStatusMsg(ctx, disableNonReplicatableQueriesMsgInx)
+}
+
+// setConfigParamDisableNonReplicatableQueries sets the config parameter
+// DisableNonReplicatableQueries to true ("1") at database level within a given cluster
+func (r *OnlineUpgradeReconciler) setConfigParamDisableNonReplicatableQueries(ctx context.Context) (ctrl.Result, error) {
+	if vmeta.GetOnlineUpgradeStepInx(r.VDB.Annotations) > setConfigParamIdx {
+		return ctrl.Result{}, nil
+	}
+	if r.originalConfigParamDisableNonReplicatableQueriesValue != "1" {
+		return r.setConfigParamDisableNonReplicatableQueriesImpl(ctx, ConfigParamBoolTrue, vapi.MainCluster)
+	}
+	return ctrl.Result{}, r.updateOnlineUpgradeStepAnnotation(ctx, r.getNextStep())
+}
+
+// postClearConfigParamDisableNonReplicatableQueriesMsg updates the status message to indicate that
+// we are going to clear the config parameter DisableNonReplicatableQueries.
+func (r *OnlineUpgradeReconciler) postClearConfigParamDisableNonReplicatableQueriesMsg(ctx context.Context) (ctrl.Result, error) {
+	return r.postNextStatusMsg(ctx, clearDisableNonReplicatableQueriesMsgInx)
+}
+
+// clearConfigParamDisableNonReplicatableQueries clears the config parameter
+// DisableNonReplicatableQueries from the sandbox
+func (r *OnlineUpgradeReconciler) clearConfigParamDisableNonReplicatableQueries(ctx context.Context) (ctrl.Result, error) {
+	if vmeta.GetOnlineUpgradeStepInx(r.VDB.Annotations) >= upgradeSandboxInx {
+		return ctrl.Result{}, nil
+	}
+	// update podfacts for sandbox
+	if _, err := r.getSandboxPodFacts(ctx, true); err != nil {
+		return ctrl.Result{}, err
+	}
+	return r.setConfigParamDisableNonReplicatableQueriesImpl(ctx, ConfigParamBoolFalse, r.sandboxName)
+}
+
+// setConfigParamDisableNonReplicatableQueriesImpl sets the config parameter
+// DisableNonReplicatableQueries to a certain value at database level within a given cluster
+func (r *OnlineUpgradeReconciler) setConfigParamDisableNonReplicatableQueriesImpl(ctx context.Context,
+	value, clusterName string) (ctrl.Result, error) {
+	pf := r.PFacts[clusterName]
+	initiator, ok := pf.findFirstUpPod(false /*not allow read-only*/, "" /*arbitrary subcluster*/)
+	if !ok {
+		r.Log.Info("No Up nodes found. Requeue reconciliation.")
+		return ctrl.Result{Requeue: true}, nil
+	}
+	vc := catalog.MakeVCluster(r.VDB, pf.VerticaSUPassword, initiator.podIP, r.Log, r.VRec.Client, r.VRec.EVRec)
+	err := vc.SetConfigurationParameter(ConfigParamDisableNonReplicatableQueries, value, ConfigParamLevelDatabase, clusterName, ctx)
+	return ctrl.Result{}, err
+}
+
 // postSandboxSubclustersMsg will update the status message to indicate that
 // we are going to sandbox subclusters for replica group b.
 func (r *OnlineUpgradeReconciler) postSandboxSubclustersMsg(ctx context.Context) (ctrl.Result, error) {
@@ -416,7 +531,7 @@ func (r *OnlineUpgradeReconciler) sandboxReplicaGroupB(ctx context.Context) (ctr
 	}
 
 	// Drive the actual sandbox command. When this returns we know the sandbox is complete.
-	actor := MakeSandboxSubclusterReconciler(r.VRec, r.Log, r.VDB, r.PFacts[vapi.MainCluster], r.Dispatcher, r.VRec.Client)
+	actor := MakeSandboxSubclusterReconciler(r.VRec, r.Log, r.VDB, r.PFacts[vapi.MainCluster], r.Dispatcher, r.VRec.Client, true)
 	r.Manager.traceActorReconcile(actor)
 	res, err = actor.Reconcile(ctx, &ctrl.Request{})
 	if verrors.IsReconcileAborted(res, err) {

pkg/controllers/vdb/sandboxsubcluster_reconciler.go

@@ -46,19 +46,21 @@ type SandboxSubclusterReconciler struct {
 	PFacts       *PodFacts
 	InitiatorIPs map[string]string // IPs from main cluster and sandboxes that should be passed down to vcluster
 	Dispatcher   vadmin.Dispatcher
+	ForUpgrade   bool
 	client.Client
 }
 
 // MakeSandboxSubclusterReconciler will build a SandboxSubclusterReconciler object
 func MakeSandboxSubclusterReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger, vdb *vapi.VerticaDB,
-	pfacts *PodFacts, dispatcher vadmin.Dispatcher, cli client.Client) controllers.ReconcileActor {
+	pfacts *PodFacts, dispatcher vadmin.Dispatcher, cli client.Client, forUpgrade bool) controllers.ReconcileActor {
 	return &SandboxSubclusterReconciler{
 		VRec:         vdbrecon,
 		Log:          log.WithName("SandboxSubclusterReconciler"),
 		Vdb:          vdb,
 		InitiatorIPs: make(map[string]string),
 		PFacts:       pfacts,
 		Dispatcher:   dispatcher,
+		ForUpgrade:   forUpgrade,
 		Client:       cli,
 	}
 }
@@ -382,6 +384,7 @@ func (s *SandboxSubclusterReconciler) sandboxSubcluster(ctx context.Context, sub
 		sandboxsc.WithUpHostInSandbox(s.InitiatorIPs[sandbox]),
 		// vclusterOps needs correct node names and addresses to do re-ip
 		sandboxsc.WithNodeNameAddressMap(nodeNameAddressMap),
+		sandboxsc.WithForUpgrade(s.ForUpgrade),
 	)
 	if err != nil {
 		s.VRec.Eventf(s.Vdb, corev1.EventTypeWarning, events.SandboxSubclusterFailed,

pkg/controllers/vdb/sandboxsubcluster_reconciler_test.go

@@ -69,7 +69,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		fpr := &cmds.FakePodRunner{}
 		pfacts := MakePodFacts(vdbRec, fpr, logger, TestPassword)
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		Expect(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{}))
 	})
 
@@ -92,7 +92,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		fpr := &cmds.FakePodRunner{}
 		pfacts := MakePodFacts(vdbRec, fpr, logger, TestPassword)
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		Expect(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{}))
 	})
 
@@ -114,7 +114,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		fpr := &cmds.FakePodRunner{}
 		pfacts := MakePodFacts(vdbRec, fpr, logger, TestPassword)
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		Expect(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{}))
 	})
 
@@ -141,7 +141,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		pfacts.Detail[pfmain].subclusterName = ""
 		pfacts.Detail[pfmain].isPrimary = true
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		Expect(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{}))
 	})
 
@@ -167,7 +167,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		// should requeue the iteration without any error
 		pfacts.Detail[pfsc1].upNode = false
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		Expect(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{Requeue: true}))
 
 		// let subcluster1 up and main cluster down
@@ -201,7 +201,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		pfacts.Detail[pfsc3].upNode = true
 		pfacts.Detail[pfsc3].subclusterName = "sc3"
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		r := rec.(*SandboxSubclusterReconciler)
 		scSbMap, allNodesUp := r.fetchSubclustersWithSandboxes()
 		targetScSbMap := map[string]string{subcluster1: sandbox1, subcluster2: sandbox2}
@@ -228,7 +228,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		fpr := &cmds.FakePodRunner{}
 		pfacts := MakePodFacts(vdbRec, fpr, logger, TestPassword)
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		r := rec.(*SandboxSubclusterReconciler)
 		sbScMap := map[string][]string{sandbox1: {subcluster1}, sandbox2: {subcluster2}}
 		err := r.updateSandboxStatus(ctx, sbScMap)
@@ -261,7 +261,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 		fpr := &cmds.FakePodRunner{}
 		pfacts := MakePodFacts(vdbRec, fpr, logger, TestPassword)
 		dispatcher := vdbRec.makeDispatcher(logger, vdb, fpr, TestPassword)
-		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient)
+		rec := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, &pfacts, dispatcher, k8sClient, false)
 		r := rec.(*SandboxSubclusterReconciler)
 		// should create config map for sandbox1
 		err := r.checkSandboxConfigMap(ctx, sandbox1)
@@ -330,7 +330,7 @@ var _ = Describe("sandboxsubcluster_reconcile", func() {
 			return &sandboxSubclusterVOps{initiatorIPs: &initiatorIPs}, logr.Logger{}
 		}
 		dispatcher := mockvops.MakeMockVClusterOpsDispatcher(vdb, logger, k8sClient, setupAPIFunc)
-		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, pfacts, dispatcher, k8sClient)
+		r := MakeSandboxSubclusterReconciler(vdbRec, logger, vdb, pfacts, dispatcher, k8sClient, false)
 
 		Ω(r.Reconcile(ctx, &ctrl.Request{})).Should(Equal(ctrl.Result{}))
 		cmNm := names.GenSandboxConfigMapName(vdb, sandbox1)