Fixing status update

Author: OlivierCazade

internal/controller/flowcollector_controller.go

@@ -12,12 +12,16 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	flowslatest "github.com/netobserv/network-observability-operator/api/flowcollector/v1beta2"
 	"github.com/netobserv/network-observability-operator/internal/controller/consoleplugin"
+	"github.com/netobserv/network-observability-operator/internal/controller/constants"
 	"github.com/netobserv/network-observability-operator/internal/controller/ebpf"
 	"github.com/netobserv/network-observability-operator/internal/controller/loki"
 	"github.com/netobserv/network-observability-operator/internal/controller/reconcilers"
@@ -35,9 +39,11 @@ const (
 // FlowCollectorReconciler reconciles a FlowCollector object
 type FlowCollectorReconciler struct {
 	client.Client
-	mgr     *manager.Manager
-	status  status.Instance
-	watcher *watchers.Watcher
+	mgr                *manager.Manager
+	status             status.Instance
+	watcher            *watchers.Watcher
+	ctrl               controller.Controller
+	lokiWatcherStarted bool
 }
 
 func Start(ctx context.Context, mgr *manager.Manager) (manager.PostCreateHook, error) {
@@ -66,15 +72,23 @@ func Start(ctx context.Context, mgr *manager.Manager) (manager.PostCreateHook, e
 		builder.Owns(&osv1.ConsolePlugin{}, reconcilers.UpdateOrDeleteOnlyPred)
 	}
 
-	if mgr.ClusterInfo.HasLokiStack() {
-		builder.Watches(&lokiv1.LokiStack{}, &handler.EnqueueRequestForObject{})
+	if mgr.ClusterInfo.HasLokiStack(ctx) {
+		builder.Watches(
+			&lokiv1.LokiStack{},
+			handler.EnqueueRequestsFromMapFunc(func(_ context.Context, _ client.Object) []ctrl.Request {
+				// When a LokiStack changes, trigger reconcile of the FlowCollector
+				return []ctrl.Request{{NamespacedName: constants.FlowCollectorName}}
+			}),
+		)
+		r.lokiWatcherStarted = true
 		log.Info("LokiStack CRD detected")
 	}
 
 	ctrl, err := builder.Build(&r)
 	if err != nil {
 		return nil, err
 	}
+	r.ctrl = ctrl
 	r.watcher = watchers.NewWatcher(ctrl)
 
 	return nil, nil
@@ -102,6 +116,14 @@ func (r *FlowCollectorReconciler) Reconcile(ctx context.Context, _ ctrl.Request)
 		return ctrl.Result{}, nil
 	}
 
+	// Dynamically start LokiStack watcher if the API became available
+	if desired.Spec.Loki.Mode == flowslatest.LokiModeLokiStack {
+		if err := r.ensureLokiStackWatcher(ctx); err != nil {
+			l.Error(err, "Failed to start LokiStack watcher")
+			// Don't fail reconciliation, just log the error
+		}
+	}
+
 	// At the moment, status workflow is to start as ready then degrade if necessary
 	// Later (when legacy controller is broken down into individual controllers), status should start as unknown and only on success finishes as ready
 	r.status.SetReady()
@@ -120,6 +142,36 @@ func (r *FlowCollectorReconciler) Reconcile(ctx context.Context, _ ctrl.Request)
 	return ctrl.Result{}, nil
 }
 
+func (r *FlowCollectorReconciler) ensureLokiStackWatcher(ctx context.Context) error {
+	// Check if LokiStack API is available but watcher not started
+	if !r.mgr.ClusterInfo.HasLokiStack(ctx) {
+		return nil
+	}
+
+	if r.lokiWatcherStarted {
+		return nil
+	}
+
+	// LokiStack API is now available, start the watcher
+	log := log.FromContext(ctx)
+	log.Info("LokiStack CRD detected after startup, starting watcher")
+
+	h := handler.TypedEnqueueRequestsFromMapFunc(func(_ context.Context, _ *lokiv1.LokiStack) []reconcile.Request {
+		// When a LokiStack changes, trigger reconcile of the FlowCollector
+		return []reconcile.Request{{NamespacedName: constants.FlowCollectorName}}
+	})
+
+	src := source.Kind(r.mgr.GetCache(), &lokiv1.LokiStack{}, h)
+	err := r.ctrl.Watch(src)
+	if err != nil {
+		return fmt.Errorf("failed to start LokiStack watcher: %w", err)
+	}
+
+	r.lokiWatcherStarted = true
+	log.Info("LokiStack watcher started successfully")
+	return nil
+}
+
 func (r *FlowCollectorReconciler) reconcile(ctx context.Context, clh *helper.Client, desired *flowslatest.FlowCollector) error {
 	ns := desired.Spec.GetNamespace()
 	previousNamespace := r.status.GetDeployedNamespace(desired)

internal/pkg/cluster/cluster.go

@@ -407,6 +407,14 @@ func getCRDPropertyInVersion(v *apix.CustomResourceDefinitionVersion, parts []st
 }
 
 // HasLokiStack returns true if "lokistack" API was found
-func (c *Info) HasLokiStack() bool {
+func (c *Info) HasLokiStack(ctx context.Context) bool {
+	if !c.apisMap[lokistacks] {
+		err := c.fetchAvailableAPIsInternal(ctx, true)
+		if err != nil {
+			return false
+		}
+	}
+	c.apisMapLock.RLock()
+	defer c.apisMapLock.RUnlock()
 	return c.apisMap[lokistacks]
 }

internal/pkg/cluster/cluster_test.go

@@ -495,28 +495,36 @@ func TestRefreshSuccess(t *testing.T) {
 }
 
 func TestHasLokiStack(t *testing.T) {
+	ctx := context.Background()
+
 	// Test 1: LokiStack CRD is available
-	infoWithLokiStack := Info{
-		apisMap: map[string]bool{
-			"lokistacks.loki.grafana.com/v1": true,
+	infoWithLokiStack := &Info{}
+	mockDclWithLoki := &mockDiscoveryClient{
+		resources: []*metav1.APIResourceList{
+			makeAPIResourceList("loki.grafana.com/v1", "lokistacks"),
 		},
-		ready: true,
+		err: nil,
 	}
-	assert.True(t, infoWithLokiStack.HasLokiStack())
+	infoWithLokiStack.dcl = mockDclWithLoki
+	assert.True(t, infoWithLokiStack.HasLokiStack(ctx))
 
 	// Test 2: LokiStack CRD is not available
-	infoWithoutLokiStack := Info{
-		apisMap: map[string]bool{
-			"lokistacks.loki.grafana.com/v1": false,
+	infoWithoutLokiStack := &Info{}
+	mockDclWithoutLoki := &mockDiscoveryClient{
+		resources: []*metav1.APIResourceList{
+			makeAPIResourceList("monitoring.coreos.com/v1", "servicemonitors"),
 		},
-		ready: true,
+		err: nil,
 	}
-	assert.False(t, infoWithoutLokiStack.HasLokiStack())
+	infoWithoutLokiStack.dcl = mockDclWithoutLoki
+	assert.False(t, infoWithoutLokiStack.HasLokiStack(ctx))
 
 	// Test 3: Empty apisMap
-	infoEmpty := Info{
-		apisMap: map[string]bool{},
-		ready:   true,
+	infoEmpty := &Info{}
+	mockDclEmpty := &mockDiscoveryClient{
+		resources: []*metav1.APIResourceList{},
+		err:       nil,
 	}
-	assert.False(t, infoEmpty.HasLokiStack())
+	infoEmpty.dcl = mockDclEmpty
+	assert.False(t, infoEmpty.HasLokiStack(ctx))
 }