Watch KeystoneAPI status updates to reconcile

Adds watches of the Nova controller on the KeystoneAPI status to
reconcile if e.g. the endpoint list changes. This triggers setting
the new KeystoneAuthURL on the sub components to update their
configuration.

Depends-On: openstack-k8s-operators/keystone-operator#591

Jira: OSPRH-16994

Signed-off-by: Martin Schuppert <mschuppert@redhat.com>

Author: stuggi

controllers/nova_controller.go

@@ -2077,6 +2077,37 @@ func (r *NovaReconciler) findObjectsForSrc(ctx context.Context, src client.Objec
 	return requests
 }
 
+func (r *NovaReconciler) findObjectForSrc(ctx context.Context, src client.Object) []reconcile.Request {
+	requests := []reconcile.Request{}
+
+	l := log.FromContext(ctx).WithName("Controllers").WithName("Nova")
+
+	crList := &novav1.NovaList{}
+	listOps := &client.ListOptions{
+		Namespace: src.GetNamespace(),
+	}
+	err := r.Client.List(ctx, crList, listOps)
+	if err != nil {
+		l.Error(err, fmt.Sprintf("listing %s for namespace: %s", crList.GroupVersionKind().Kind, src.GetNamespace()))
+		return requests
+	}
+
+	for _, item := range crList.Items {
+		l.Info(fmt.Sprintf("input source %s changed, reconcile: %s - %s", src.GetName(), item.GetName(), item.GetNamespace()))
+
+		requests = append(requests,
+			reconcile.Request{
+				NamespacedName: types.NamespacedName{
+					Name:      item.GetName(),
+					Namespace: item.GetNamespace(),
+				},
+			},
+		)
+	}
+
+	return requests
+}
+
 func (r *NovaReconciler) memcachedNamespaceMapFunc(ctx context.Context, src client.Object) []reconcile.Request {
 
 	result := []reconcile.Request{}
@@ -2151,5 +2182,8 @@ func (r *NovaReconciler) SetupWithManager(mgr ctrl.Manager) error {
 			&memcachedv1.Memcached{},
 			handler.EnqueueRequestsFromMapFunc(r.memcachedNamespaceMapFunc),
 		).
+		Watches(&keystonev1.KeystoneAPI{},
+			handler.EnqueueRequestsFromMapFunc(r.findObjectForSrc),
+			builder.WithPredicates(keystonev1.KeystoneAPIStatusChangedPredicate)).
 		Complete(r)
 }

test/functional/base_test.go

@@ -537,6 +537,7 @@ type NovaNames struct {
 	MemcachedNamespace              types.NamespacedName
 	Cells                           map[string]CellNames
 	NovaTopologies                  []types.NamespacedName
+	KeystoneAPIName                 types.NamespacedName
 }
 
 func GetNovaNames(novaName types.NamespacedName, cellNames []string) NovaNames {

test/functional/nova_reconfiguration_test.go

@@ -39,7 +39,7 @@ import (
 	"k8s.io/utils/ptr"
 )
 
-func CreateNovaWith3CellsAndEnsureReady(novaNames NovaNames) {
+func CreateNovaWith3CellsAndEnsureReady(novaNames *NovaNames) {
 	cell0 := novaNames.Cells["cell0"]
 	cell1 := novaNames.Cells["cell1"]
 	cell2 := novaNames.Cells["cell2"]
@@ -107,7 +107,8 @@ func CreateNovaWith3CellsAndEnsureReady(novaNames NovaNames) {
 	spec["apiMessageBusInstance"] = cell0.TransportURLName.Name
 
 	DeferCleanup(th.DeleteInstance, CreateNova(novaNames.NovaName, spec))
-	DeferCleanup(keystone.DeleteKeystoneAPI, keystone.CreateKeystoneAPI(novaNames.NovaName.Namespace))
+	novaNames.KeystoneAPIName = keystone.CreateKeystoneAPI(novaNames.NovaName.Namespace)
+	DeferCleanup(keystone.DeleteKeystoneAPI, novaNames.KeystoneAPIName)
 	memcachedSpec := infra.GetDefaultMemcachedSpec()
 
 	DeferCleanup(infra.DeleteMemcached, infra.CreateMemcached(novaNames.NovaName.Namespace, MemcachedInstance, memcachedSpec))
@@ -166,7 +167,7 @@ var _ = Describe("Nova reconfiguration", func() {
 		// matchers
 		// format.MaxLength = 0
 
-		CreateNovaWith3CellsAndEnsureReady(novaNames)
+		CreateNovaWith3CellsAndEnsureReady(&novaNames)
 	})
 	When("cell1 is deleted", func() {
 		It("cell cr is deleted", func() {
@@ -1178,4 +1179,52 @@ var _ = Describe("Nova reconfiguration", func() {
 			g.Expect(diff).To(BeEmpty())
 		}, timeout, interval).Should(Succeed())
 	})
+
+	It("updates the KeystoneAuthURL of the sub components if keystone internal endpoint changes", func() {
+		newInternalEndpoint := "https://keystone-internal"
+
+		keystone.UpdateKeystoneAPIEndpoint(novaNames.KeystoneAPIName, "internal", newInternalEndpoint)
+		logger.Info("Reconfigured")
+
+		SimulateReadyOfNovaTopServices()
+		th.SimulateJobSuccess(cell0.DBSyncJobName)
+		th.SimulateJobSuccess(cell1.DBSyncJobName)
+		th.SimulateJobSuccess(cell2.DBSyncJobName)
+		th.SimulateStatefulSetReplicaReady(cell0.ConductorStatefulSetName)
+
+		for _, cell := range []types.NamespacedName{cell0.ConductorName, cell1.ConductorName, cell2.ConductorName} {
+			Eventually(func(g Gomega) {
+				cond := GetNovaConductor(cell)
+				g.Expect(cond).ToNot(BeNil())
+				g.Expect(cond.Spec.KeystoneAuthURL).To(Equal(newInternalEndpoint))
+			}, timeout, interval).Should(Succeed())
+		}
+
+		for _, cell := range []types.NamespacedName{cell1.NoVNCProxyName, cell2.NoVNCProxyName} {
+			Eventually(func(g Gomega) {
+				vnc := GetNovaNoVNCProxy(cell)
+				g.Expect(vnc).ToNot(BeNil())
+				g.Expect(vnc.Spec.KeystoneAuthURL).To(Equal(newInternalEndpoint))
+			}, timeout, interval).Should(Succeed())
+		}
+
+		Eventually(func(g Gomega) {
+			api := GetNovaAPI(novaNames.APIName)
+			g.Expect(api).ToNot(BeNil())
+			g.Expect(api.Spec.KeystoneAuthURL).To(Equal(newInternalEndpoint))
+		}, timeout, interval).Should(Succeed())
+
+		Eventually(func(g Gomega) {
+			sch := GetNovaScheduler(novaNames.SchedulerName)
+			g.Expect(sch).ToNot(BeNil())
+			g.Expect(sch.Spec.KeystoneAuthURL).To(Equal(newInternalEndpoint))
+		}, timeout, interval).Should(Succeed())
+
+		Eventually(func(g Gomega) {
+			metadata := GetNovaMetadata(novaNames.MetadataName)
+			g.Expect(metadata).ToNot(BeNil())
+			g.Expect(metadata.Spec.KeystoneAuthURL).To(Equal(newInternalEndpoint))
+		}, timeout, interval).Should(Succeed())
+	})
+
 })