Merge pull request #1599 from abays/OSPRH-19828

openshift-merge-bot[bot] · web-flow · commit 9ad9305d0fb2 · 2025-09-16T15:41:38.000Z
[OSPRH-19828] Improve consistency of condition severity usage
diff --git a/controllers/client/openstackclient_controller.go b/controllers/client/openstackclient_controller.go
@@ -219,6 +219,8 @@ func (r *OpenStackClientReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 	_, configMapHash, err := configmap.GetConfigMapAndHashWithName(ctx, helper, *instance.Spec.OpenStackConfigMap, instance.Namespace)
 	if err != nil {
 		if k8s_errors.IsNotFound(err) {
+			// Since the OpenStackConfigMap config map is usually automatically created by the Keystone operator,
+			// we treat this as an info (because the user is usually not responsible for manually creating it).
 			instance.Status.Conditions.Set(condition.FalseCondition(
 				clientv1.OpenStackClientReadyCondition,
 				condition.RequestedReason,
@@ -239,6 +241,8 @@ func (r *OpenStackClientReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 	_, secretHash, err := secret.GetSecret(ctx, helper, *instance.Spec.OpenStackConfigSecret, instance.Namespace)
 	if err != nil {
 		if k8s_errors.IsNotFound(err) {
+			// Since the OpenStackConfigSecret secret is usually automatically created by the Keystone operator,
+			// we treat this as an info (because the user is usually not responsible for manually creating it).
 			instance.Status.Conditions.Set(condition.FalseCondition(
 				clientv1.OpenStackClientReadyCondition,
 				condition.RequestedReason,
@@ -267,10 +271,12 @@ func (r *OpenStackClientReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 		)
 		if err != nil {
 			if k8s_errors.IsNotFound(err) {
+				// Since the CA cert secret should have been manually created by the user when provided in the spec,
+				// we treat this as a warning because it means that reconciliation will not be able to continue.
 				instance.Status.Conditions.Set(condition.FalseCondition(
 					condition.TLSInputReadyCondition,
-					condition.RequestedReason,
-					condition.SeverityInfo,
+					condition.ErrorReason,
+					condition.SeverityWarning,
 					fmt.Sprintf(condition.TLSInputReadyWaitingMessage, instance.Spec.CaBundleSecretName)))
 				return ctrl.Result{}, nil
 			}
diff --git a/controllers/core/openstackversion_controller.go b/controllers/core/openstackversion_controller.go
@@ -354,18 +354,22 @@ func (r *OpenStackVersionReconciler) Reconcile(ctx context.Context, req ctrl.Req
 			Log.Info("Minor update for Controlplane in progress")
 			return ctrl.Result{}, nil
 		}
+
 		// ctlplane is ready, lets make sure all images match newly deployed versions
 		ctlplaneImagesMatch, badMatches := openstack.ControlplaneContainerImageMatch(ctx, controlPlane, instance)
 		if !ctlplaneImagesMatch {
+			// Since we need the images to match and we cannot proceed without it,
+			// we treat this as a warning because it means that reconciliation will not be able to continue.
 			errMsgBadMatches := "Controlplane images do not match the target version for the following services: " + strings.Join(badMatches, ", ")
 			instance.Status.Conditions.Set(condition.FalseCondition(
 				corev1beta1.OpenStackVersionMinorUpdateControlplane,
-				condition.RequestedReason,
-				condition.SeverityInfo,
+				condition.ErrorReason,
+				condition.SeverityWarning,
 				corev1beta1.OpenStackVersionMinorUpdateReadyErrorMessage,
 				errMsgBadMatches))
-
+			return ctrl.Result{}, nil
 		}
+
 		instance.Status.Conditions.MarkTrue(
 			corev1beta1.OpenStackVersionMinorUpdateControlplane,
 			corev1beta1.OpenStackVersionMinorUpdateReadyMessage)
diff --git a/controllers/dataplane/openstackdataplanenodeset_controller.go b/controllers/dataplane/openstackdataplanenodeset_controller.go
@@ -280,15 +280,17 @@ func (r *OpenStackDataPlaneNodeSetReconciler) Reconcile(ctx context.Context, req
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			condition.InputReadyCondition,
-			condition.RequestedReason,
+			condition.ErrorReason,
 			condition.SeverityError,
 			err.Error())
 		return result, err
 	} else if (result != ctrl.Result{}) {
+		// Since the the private key secret should have been manually created by the user when provided in the spec,
+		// we treat this as a warning because it means that reconciliation will not be able to continue.
 		instance.Status.Conditions.MarkFalse(
 			condition.InputReadyCondition,
-			condition.RequestedReason,
-			condition.SeverityInfo,
+			condition.ErrorReason,
+			condition.SeverityWarning,
 			dataplanev1.InputReadyWaitingMessage,
 			"secret/"+ansibleSSHPrivateKeySecret)
 		return result, nil
@@ -424,8 +426,10 @@ func (r *OpenStackDataPlaneNodeSetReconciler) Reconcile(ctx context.Context, req
 	// Handles the case where the NodeSet is created, but not yet deployed.
 	if instance.Status.Conditions.IsUnknown(condition.DeploymentReadyCondition) {
 		Log.Info("Set NodeSet DeploymentReadyCondition false")
-		instance.Status.Conditions.MarkFalse(condition.DeploymentReadyCondition,
-			condition.RequestedReason, condition.SeverityInfo,
+		instance.Status.Conditions.MarkFalse(
+			condition.DeploymentReadyCondition,
+			condition.RequestedReason,
+			condition.SeverityInfo,
 			dataplanev1.NodeSetDeploymentReadyWaitingMessage)
 	}
 
@@ -437,8 +441,10 @@ func (r *OpenStackDataPlaneNodeSetReconciler) Reconcile(ctx context.Context, req
 	} else if isDeploymentRunning {
 		Log.Info("Deployment still running...", "instance", instance)
 		Log.Info("Set NodeSet DeploymentReadyCondition false")
-		instance.Status.Conditions.MarkFalse(condition.DeploymentReadyCondition,
-			condition.RequestedReason, condition.SeverityInfo,
+		instance.Status.Conditions.MarkFalse(
+			condition.DeploymentReadyCondition,
+			condition.RequestedReason,
+			condition.SeverityInfo,
 			condition.DeploymentReadyRunningMessage)
 	} else if isDeploymentFailed {
 		podsInterface := r.Kclient.CoreV1().Pods(instance.Namespace)
@@ -459,8 +465,10 @@ func (r *OpenStackDataPlaneNodeSetReconciler) Reconcile(ctx context.Context, req
 		if err != nil {
 			deployErrorMsg = err.Error()
 		}
-		instance.Status.Conditions.MarkFalse(condition.DeploymentReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+		instance.Status.Conditions.MarkFalse(
+			condition.DeploymentReadyCondition,
+			condition.ErrorReason,
+			condition.SeverityError,
 			deployErrorMsg)
 	}
 
diff --git a/pkg/dataplane/baremetal.go b/pkg/dataplane/baremetal.go
@@ -113,7 +113,8 @@ func DeployBaremetalSet(
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetBareMetalProvisionReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			dataplanev1.NodeSetBaremetalProvisionErrorMessage,
 			err.Error())
 		return ProvisionResult{}, err
@@ -124,7 +125,8 @@ func DeployBaremetalSet(
 		utils.LogForObject(helper, "BaremetalSet not ready, waiting...", instance)
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetBareMetalProvisionReadyCondition,
-			condition.RequestedReason, condition.SeverityInfo,
+			condition.RequestedReason,
+			condition.SeverityInfo,
 			dataplanev1.NodeSetBaremetalProvisionReadyWaitingMessage)
 		return ProvisionResult{}, nil
 	}
diff --git a/pkg/dataplane/ipam.go b/pkg/dataplane/ipam.go
@@ -195,14 +195,16 @@ func EnsureDNSData(ctx context.Context, helper *helper.Helper,
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetDNSDataReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			err.Error())
 		return dnsDetails, err
 	}
 	if dnsDetails.ClusterAddresses == nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetDNSDataReadyCondition,
-			condition.RequestedReason, condition.SeverityInfo,
+			condition.RequestedReason,
+			condition.SeverityInfo,
 			dataplanev1.NodeSetDNSDataReadyWaitingMessage)
 		return dnsDetails, nil
 	}
@@ -213,7 +215,8 @@ func EnsureDNSData(ctx context.Context, helper *helper.Helper,
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetDNSDataReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			dataplanev1.NodeSetDNSDataReadyErrorMessage,
 			err.Error())
 		return dnsDetails, err
@@ -230,7 +233,8 @@ func EnsureDNSData(ctx context.Context, helper *helper.Helper,
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetDNSDataReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			dataplanev1.NodeSetDNSDataReadyErrorMessage,
 			err.Error())
 		return dnsDetails, err
@@ -239,7 +243,8 @@ func EnsureDNSData(ctx context.Context, helper *helper.Helper,
 		util.LogForObject(helper, "DNSData not ready yet waiting", instance)
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetDNSDataReadyCondition,
-			condition.RequestedReason, condition.SeverityInfo,
+			condition.RequestedReason,
+			condition.SeverityInfo,
 			dataplanev1.NodeSetDNSDataReadyWaitingMessage)
 		return dnsDetails, nil
 	}
@@ -261,7 +266,8 @@ func EnsureIPSets(ctx context.Context, helper *helper.Helper,
 		util.LogErrorForObject(helper, err, "Could not cleanup stale IP Reservations", instance)
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetIPReservationReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			dataplanev1.NodeSetIPReservationReadyErrorMessage,
 			err.Error())
 		return nil, nil, false, err
@@ -270,7 +276,8 @@ func EnsureIPSets(ctx context.Context, helper *helper.Helper,
 	if err != nil {
 		instance.Status.Conditions.MarkFalse(
 			dataplanev1.NodeSetIPReservationReadyCondition,
-			condition.ErrorReason, condition.SeverityError,
+			condition.ErrorReason,
+			condition.SeverityError,
 			dataplanev1.NodeSetIPReservationReadyErrorMessage,
 			err.Error())
 		return nil, netServiceNetMap, false, err
@@ -280,7 +287,8 @@ func EnsureIPSets(ctx context.Context, helper *helper.Helper,
 		if s.Status.Conditions.IsFalse(condition.ReadyCondition) {
 			instance.Status.Conditions.MarkFalse(
 				dataplanev1.NodeSetIPReservationReadyCondition,
-				condition.RequestedReason, condition.SeverityInfo,
+				condition.RequestedReason,
+				condition.SeverityInfo,
 				dataplanev1.NodeSetIPReservationReadyWaitingMessage)
 			return nil, netServiceNetMap, false, nil
 		}
diff --git a/pkg/openstack/ca.go b/pkg/openstack/ca.go
@@ -406,8 +406,6 @@ func ReconcileCAs(ctx context.Context, instance *corev1.OpenStackControlPlane, h
 		}
 	}
 
-	instance.Status.Conditions.MarkTrue(corev1.OpenStackControlPlaneCAReadyCondition, corev1.OpenStackControlPlaneCAReadyMessage)
-
 	// create/update combined CA secret
 	if instance.Spec.TLS.CaBundleSecretName != "" {
 		caSecret, _, err := secret.GetSecret(ctx, helper, instance.Spec.TLS.CaBundleSecretName, instance.Namespace)
@@ -421,6 +419,14 @@ func ReconcileCAs(ctx context.Context, instance *corev1.OpenStackControlPlane, h
 				instance.Spec.TLS.CaBundleSecretName,
 				err.Error()))
 			if k8s_errors.IsNotFound(err) {
+				// Since the CA cert secret should have been manually created by the user when provided in the spec,
+				// we treat this as a warning because it means that reconciliation will not be able to continue.
+				instance.Status.Conditions.Set(condition.FalseCondition(
+					corev1.OpenStackControlPlaneCAReadyCondition,
+					condition.ErrorReason,
+					condition.SeverityWarning,
+					fmt.Sprintf(condition.TLSInputReadyWaitingMessage, instance.Spec.TLS.CaBundleSecretName)))
+
 				timeout := time.Second * 10
 				Log.Info(fmt.Sprintf("Certificate %s not found, reconcile in %s", instance.Spec.TLS.CaBundleSecretName, timeout.String()))
 
@@ -438,6 +444,8 @@ func ReconcileCAs(ctx context.Context, instance *corev1.OpenStackControlPlane, h
 		}
 	}
 
+	instance.Status.Conditions.MarkTrue(corev1.OpenStackControlPlaneCAReadyCondition, corev1.OpenStackControlPlaneCAReadyMessage)
+
 	// get CA bundle from operator image. Downstream and upstream build use a different
 	// base image, so the ca bundle cert file can be in different locations
 	caBundle, err := getOperatorCABundle(tls.DownstreamTLSCABundlePath)
diff --git a/pkg/openstack/common.go b/pkg/openstack/common.go
@@ -261,10 +261,12 @@ func EnsureEndpointConfig(
 					_, err := validateSecret.ValidateCertSecret(ctx, helper, instance.GetNamespace())
 					if err != nil {
 						if k8s_errors.IsNotFound(err) {
+							// Since the CA cert secret should have been manually created by the user when provided in the spec,
+							// we treat this as a warning because it means that reconciliation will not be able to continue.
 							instance.Status.Conditions.Set(condition.FalseCondition(
 								corev1.OpenStackControlPlaneCustomTLSReadyCondition,
-								condition.RequestedReason,
-								condition.SeverityInfo,
+								condition.ErrorReason,
+								condition.SeverityWarning,
 								corev1.OpenStackControlPlaneCustomTLSReadyWaitingMessage,
 								ingressOverride.TLS.SecretName))
 							return endpoints, ctrl.Result{RequeueAfter: time.Duration(10) * time.Second}, nil
diff --git a/pkg/openstack/version.go b/pkg/openstack/version.go
@@ -284,80 +284,79 @@ func stringPointersEqual(a, b *string) bool {
 // only enabled services are checked
 func ControlplaneContainerImageMatch(ctx context.Context, controlPlane *corev1beta1.OpenStackControlPlane, version *corev1beta1.OpenStackVersion) (bool, []string) {
 	failedMatches := []string{}
-	if BarbicanImageMatch(ctx, controlPlane, version) {
+	if !BarbicanImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Barbican")
 	}
-	if CinderImageMatch(ctx, controlPlane, version) {
+	if !CinderImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Cinder")
 	}
-	if DesignateImageMatch(ctx, controlPlane, version) {
+	if !DesignateImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Designate")
 	}
-	if DnsmasqImageMatch(ctx, controlPlane, version) {
+	if !DnsmasqImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Dnsmasq")
 	}
-	if GaleraImageMatch(ctx, controlPlane, version) {
+	if !GaleraImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Galera")
 	}
-	if GlanceImageMatch(ctx, controlPlane, version) {
+	if !GlanceImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Glance")
 	}
-	if HeatImageMatch(ctx, controlPlane, version) {
+	if !HeatImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Heat")
 	}
-	if HorizonImageMatch(ctx, controlPlane, version) {
+	if !HorizonImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Horizon")
 	}
-	if IronicImageMatch(ctx, controlPlane, version) {
+	if !IronicImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Ironic")
 	}
-	if KeystoneImageMatch(ctx, controlPlane, version) {
+	if !KeystoneImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Keystone")
 	}
-	if ManilaImageMatch(ctx, controlPlane, version) {
+	if !ManilaImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Manila")
 	}
-	if MemcachedImageMatch(ctx, controlPlane, version) {
+	if !MemcachedImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Memcached")
 	}
-	if RedisImageMatch(ctx, controlPlane, version) {
+	if !RedisImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Redis")
 	}
-	if NeutronImageMatch(ctx, controlPlane, version) {
+	if !NeutronImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Neutron")
 	}
-	if NovaImageMatch(ctx, controlPlane, version) {
+	if !NovaImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Nova")
 	}
-	if OctaviaImageMatch(ctx, controlPlane, version) {
+	if !OctaviaImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Octavia")
 	}
-	if ClientImageMatch(ctx, controlPlane, version) {
+	if !ClientImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "OpenstackClient")
 	}
-	if OVNControllerImageMatch(ctx, controlPlane, version) {
+	if !OVNControllerImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "OVNController")
 	}
-	if OVNNorthImageMatch(ctx, controlPlane, version) {
+	if !OVNNorthImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "OVNNorth")
 	}
-	if OVNDbClusterImageMatch(ctx, controlPlane, version) {
+	if !OVNDbClusterImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "OVNDbCluster")
 	}
-	if PlacementImageMatch(ctx, controlPlane, version) {
+	if !PlacementImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Placement")
 	}
-	if RabbitmqImageMatch(ctx, controlPlane, version) {
+	if !RabbitmqImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Rabbitmq")
 	}
-	if SwiftImageMatch(ctx, controlPlane, version) {
+	if !SwiftImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Swift")
 	}
-	if TelemetryImageMatch(ctx, controlPlane, version) {
+	if !TelemetryImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Telemetry")
 	}
-
-	if WatcherImageMatch(ctx, controlPlane, version) {
+	if !WatcherImageMatch(ctx, controlPlane, version) {
 		failedMatches = append(failedMatches, "Watcher")
 	}
 
diff --git a/tests/functional/ctlplane/openstackoperator_controller_test.go b/tests/functional/ctlplane/openstackoperator_controller_test.go
@@ -1438,7 +1438,7 @@ var _ = Describe("OpenStackOperator controller", func() {
 					ConditionGetterFunc(OpenStackControlPlaneConditionGetter),
 					corev1.OpenStackControlPlaneCustomTLSReadyCondition,
 					k8s_corev1.ConditionFalse,
-					condition.RequestedReason,
+					condition.ErrorReason,
 					fmt.Sprintf(corev1.OpenStackControlPlaneCustomTLSReadyWaitingMessage, names.CustomServiceCertSecretName.Name),
 				)
 			})
diff --git a/tests/functional/ctlplane/openstackversion_controller_test.go b/tests/functional/ctlplane/openstackversion_controller_test.go
@@ -626,7 +626,7 @@ var _ = Describe("OpenStackOperator controller", func() {
 			// this would occur automatically via the watch on the DataPlaneNodeSet's by openstackcontrolplane
 			// so once the administrator executes the DataplaneDeployment and that finishes the controlplane will update the images immediately
 			SimulateControlplaneReady()
-			// now we check that the rest of the container images got updated
+			// now we check that the container images for the aforementioned services got updated
 			Eventually(func(g Gomega) {
 				th.ExpectCondition(
 					names.OpenStackVersionName,

Original file line number	Diff line number	Diff line change
`@@ -284,80 +284,79 @@ func stringPointersEqual(a, b *string) bool {`
`284`	`284`	`// only enabled services are checked`
`285`	`285`	`func ControlplaneContainerImageMatch(ctx context.Context, controlPlane corev1beta1.OpenStackControlPlane, version corev1beta1.OpenStackVersion) (bool, []string) {`
`286`	`286`	`failedMatches := []string{}`
`287`		`- if BarbicanImageMatch(ctx, controlPlane, version) {`
	`287`	`+ if !BarbicanImageMatch(ctx, controlPlane, version) {`
`288`	`288`	`failedMatches = append(failedMatches, "Barbican")`
`289`	`289`	`}`
`290`		`- if CinderImageMatch(ctx, controlPlane, version) {`
	`290`	`+ if !CinderImageMatch(ctx, controlPlane, version) {`
`291`	`291`	`failedMatches = append(failedMatches, "Cinder")`
`292`	`292`	`}`
`293`		`- if DesignateImageMatch(ctx, controlPlane, version) {`
	`293`	`+ if !DesignateImageMatch(ctx, controlPlane, version) {`
`294`	`294`	`failedMatches = append(failedMatches, "Designate")`
`295`	`295`	`}`
`296`		`- if DnsmasqImageMatch(ctx, controlPlane, version) {`
	`296`	`+ if !DnsmasqImageMatch(ctx, controlPlane, version) {`
`297`	`297`	`failedMatches = append(failedMatches, "Dnsmasq")`
`298`	`298`	`}`
`299`		`- if GaleraImageMatch(ctx, controlPlane, version) {`
	`299`	`+ if !GaleraImageMatch(ctx, controlPlane, version) {`
`300`	`300`	`failedMatches = append(failedMatches, "Galera")`
`301`	`301`	`}`
`302`		`- if GlanceImageMatch(ctx, controlPlane, version) {`
	`302`	`+ if !GlanceImageMatch(ctx, controlPlane, version) {`
`303`	`303`	`failedMatches = append(failedMatches, "Glance")`
`304`	`304`	`}`
`305`		`- if HeatImageMatch(ctx, controlPlane, version) {`
	`305`	`+ if !HeatImageMatch(ctx, controlPlane, version) {`
`306`	`306`	`failedMatches = append(failedMatches, "Heat")`
`307`	`307`	`}`
`308`		`- if HorizonImageMatch(ctx, controlPlane, version) {`
	`308`	`+ if !HorizonImageMatch(ctx, controlPlane, version) {`
`309`	`309`	`failedMatches = append(failedMatches, "Horizon")`
`310`	`310`	`}`
`311`		`- if IronicImageMatch(ctx, controlPlane, version) {`
	`311`	`+ if !IronicImageMatch(ctx, controlPlane, version) {`
`312`	`312`	`failedMatches = append(failedMatches, "Ironic")`
`313`	`313`	`}`
`314`		`- if KeystoneImageMatch(ctx, controlPlane, version) {`
	`314`	`+ if !KeystoneImageMatch(ctx, controlPlane, version) {`
`315`	`315`	`failedMatches = append(failedMatches, "Keystone")`
`316`	`316`	`}`
`317`		`- if ManilaImageMatch(ctx, controlPlane, version) {`
	`317`	`+ if !ManilaImageMatch(ctx, controlPlane, version) {`
`318`	`318`	`failedMatches = append(failedMatches, "Manila")`
`319`	`319`	`}`
`320`		`- if MemcachedImageMatch(ctx, controlPlane, version) {`
	`320`	`+ if !MemcachedImageMatch(ctx, controlPlane, version) {`
`321`	`321`	`failedMatches = append(failedMatches, "Memcached")`
`322`	`322`	`}`
`323`		`- if RedisImageMatch(ctx, controlPlane, version) {`
	`323`	`+ if !RedisImageMatch(ctx, controlPlane, version) {`
`324`	`324`	`failedMatches = append(failedMatches, "Redis")`
`325`	`325`	`}`
`326`		`- if NeutronImageMatch(ctx, controlPlane, version) {`
	`326`	`+ if !NeutronImageMatch(ctx, controlPlane, version) {`
`327`	`327`	`failedMatches = append(failedMatches, "Neutron")`
`328`	`328`	`}`
`329`		`- if NovaImageMatch(ctx, controlPlane, version) {`
	`329`	`+ if !NovaImageMatch(ctx, controlPlane, version) {`
`330`	`330`	`failedMatches = append(failedMatches, "Nova")`
`331`	`331`	`}`
`332`		`- if OctaviaImageMatch(ctx, controlPlane, version) {`
	`332`	`+ if !OctaviaImageMatch(ctx, controlPlane, version) {`
`333`	`333`	`failedMatches = append(failedMatches, "Octavia")`
`334`	`334`	`}`
`335`		`- if ClientImageMatch(ctx, controlPlane, version) {`
	`335`	`+ if !ClientImageMatch(ctx, controlPlane, version) {`
`336`	`336`	`failedMatches = append(failedMatches, "OpenstackClient")`
`337`	`337`	`}`
`338`		`- if OVNControllerImageMatch(ctx, controlPlane, version) {`
	`338`	`+ if !OVNControllerImageMatch(ctx, controlPlane, version) {`
`339`	`339`	`failedMatches = append(failedMatches, "OVNController")`
`340`	`340`	`}`
`341`		`- if OVNNorthImageMatch(ctx, controlPlane, version) {`
	`341`	`+ if !OVNNorthImageMatch(ctx, controlPlane, version) {`
`342`	`342`	`failedMatches = append(failedMatches, "OVNNorth")`
`343`	`343`	`}`
`344`		`- if OVNDbClusterImageMatch(ctx, controlPlane, version) {`
	`344`	`+ if !OVNDbClusterImageMatch(ctx, controlPlane, version) {`
`345`	`345`	`failedMatches = append(failedMatches, "OVNDbCluster")`
`346`	`346`	`}`
`347`		`- if PlacementImageMatch(ctx, controlPlane, version) {`
	`347`	`+ if !PlacementImageMatch(ctx, controlPlane, version) {`
`348`	`348`	`failedMatches = append(failedMatches, "Placement")`
`349`	`349`	`}`
`350`		`- if RabbitmqImageMatch(ctx, controlPlane, version) {`
	`350`	`+ if !RabbitmqImageMatch(ctx, controlPlane, version) {`
`351`	`351`	`failedMatches = append(failedMatches, "Rabbitmq")`
`352`	`352`	`}`
`353`		`- if SwiftImageMatch(ctx, controlPlane, version) {`
	`353`	`+ if !SwiftImageMatch(ctx, controlPlane, version) {`
`354`	`354`	`failedMatches = append(failedMatches, "Swift")`
`355`	`355`	`}`
`356`		`- if TelemetryImageMatch(ctx, controlPlane, version) {`
	`356`	`+ if !TelemetryImageMatch(ctx, controlPlane, version) {`
`357`	`357`	`failedMatches = append(failedMatches, "Telemetry")`
`358`	`358`	`}`
`359`		`-`
`360`		`- if WatcherImageMatch(ctx, controlPlane, version) {`
	`359`	`+ if !WatcherImageMatch(ctx, controlPlane, version) {`
`361`	`360`	`failedMatches = append(failedMatches, "Watcher")`
`362`	`361`	`}`
`363`	`362`
Original file line number	Diff line number	Diff line change
`@@ -1438,7 +1438,7 @@ var _ = Describe("OpenStackOperator controller", func() {`
`1438`	`1438`	`ConditionGetterFunc(OpenStackControlPlaneConditionGetter),`
`1439`	`1439`	`corev1.OpenStackControlPlaneCustomTLSReadyCondition,`
`1440`	`1440`	`k8s_corev1.ConditionFalse,`
`1441`		`- condition.RequestedReason,`
	`1441`	`+ condition.ErrorReason,`
`1442`	`1442`	`fmt.Sprintf(corev1.OpenStackControlPlaneCustomTLSReadyWaitingMessage, names.CustomServiceCertSecretName.Name),`
`1443`	`1443`	`)`
`1444`	`1444`	`})`