Code clenup and commenting

Signed-off-by: Siddhesh Ghadi <[email protected]>

Author: svghadi

cmd/main.go

@@ -62,7 +62,7 @@ import (
 	v1alpha1 "github.com/argoproj-labs/argocd-operator/api/v1alpha1"
 	v1beta1 "github.com/argoproj-labs/argocd-operator/api/v1beta1"
 	"github.com/argoproj-labs/argocd-operator/pkg/cacheutils"
-	wc "github.com/argoproj-labs/argocd-operator/pkg/clientwrapper"
+	cw "github.com/argoproj-labs/argocd-operator/pkg/clientwrapper"
 	"github.com/argoproj-labs/argocd-operator/version"
 	//+kubebuilder:scaffold:imports
 )
@@ -184,19 +184,19 @@ func main() {
 		Controller: controllerconfig.Controller{
 			SkipNameValidation: &skipControllerNameValidation,
 		},
+		// Use transformers to strip data from Secrets and ConfigMaps 
+		// that are not tracked by the operator to reduce memory usage.
 		Cache: cache.Options{
 			Scheme: scheme,
 			ByObject: map[crclient.Object]cache.ByObject{
-				&corev1.Secret{}:    {Transform: cacheutils.StripSecretDataTranform()},
+				&corev1.Secret{}:    {Transform: cacheutils.StripSecretDataTransform()},
 				&corev1.ConfigMap{}: {Transform: cacheutils.StripConfigMapDataTransform()},
 			},
 		},
 	}
 
 	if watchedNsCache := getDefaultWatchedNamespacesCacheOptions(); watchedNsCache != nil {
-		options.Cache = cache.Options{
-			DefaultNamespaces: watchedNsCache,
-		}
+		options.Cache.DefaultNamespaces = watchedNsCache
 	}
 
 	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), options)
@@ -205,9 +205,17 @@ func main() {
 		os.Exit(1)
 	}
 
-	liveClient, _ := crclient.New(ctrl.GetConfigOrDie(), crclient.Options{Scheme: mgr.GetScheme()})
-	client := wc.NewClientWrapper(mgr.GetClient(), liveClient)
-	//print(client)
+	liveClient, err := crclient.New(ctrl.GetConfigOrDie(), crclient.Options{Scheme: mgr.GetScheme()})
+	if err != nil {
+		setupLog.Error(err, "unable to create live client")
+		os.Exit(1)
+	}
+
+	// Wraps the controller runtime's default client to provide:
+	//   1. Fallback to the live client when a Secret/ConfigMap is stripped in the cache.
+	//   2. Automatic labeling of fetched objects, so they are retained in full form
+	//      in subsequent cache updates and avoid repeated live lookups.
+	client := cw.NewClientWrapper(mgr.GetClient(), liveClient)
 
 	setupLog.Info("Registering Components.")
 

pkg/cacheutils/utlis.go

@@ -7,7 +7,10 @@ import (
 	"github.com/argoproj-labs/argocd-operator/common"
 )
 
-func StripSecretDataTranform() clientgotools.TransformFunc {
+// StripSecretDataTransform returns a TransformFunc that strips the data from Secrets
+// that are not tracked by the operator. This is useful for reducing memory usage
+// when caching Secrets that are not managed by the operator.
+func StripSecretDataTransform() clientgotools.TransformFunc {
 	return func(in interface{}) (interface{}, error) {
 		if s, ok := in.(*v1.Secret); ok {
 			if IsTrackedByOperator(s.Labels) {
@@ -28,6 +31,9 @@ func StripSecretDataTranform() clientgotools.TransformFunc {
 	}
 }
 
+// StripConfigMapDataTransform returns a TransformFunc that strips the data from ConfigMaps
+// that are not tracked by the operator. This is useful for reducing memory usage
+// when caching ConfigMaps that are not managed by the operator.
 func StripConfigMapDataTransform() clientgotools.TransformFunc {
 	return func(in interface{}) (interface{}, error) {
 		if cm, ok := in.(*v1.ConfigMap); ok {
@@ -47,6 +53,7 @@ func StripConfigMapDataTransform() clientgotools.TransformFunc {
 	}
 }
 
+// IsTrackedByOperator checks if the given labels indicate that the resource is tracked by the operator.
 func IsTrackedByOperator(labels map[string]string) bool {
 	trackedLabels := []string{
 		common.ArgoCDTrackedByOperatorLabel,

pkg/clientwrapper/client.go

@@ -9,63 +9,74 @@ import (
 
 	"github.com/argoproj-labs/argocd-operator/common"
 	"github.com/argoproj-labs/argocd-operator/pkg/cacheutils"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
 )
 
+var log = logf.Log.WithName("clientwrapper")
+
 // ClientWrapper wraps a cached client and only falls back to
 // live GET when the cached object appears stripped OR is missing required labels.
+// We currently override GET only, but could extend to other methods if needed.
 type ClientWrapper struct {
 	ctrlclient.Client                   // cached client
 	liveClient        ctrlclient.Client // direct API client
 }
 
+// NewClientWrapper creates a new ClientWrapper instance.
 func NewClientWrapper(cached, live ctrlclient.Client) *ClientWrapper {
 	return &ClientWrapper{
 		Client:     cached,
 		liveClient: live,
 	}
 }
 
+// Get first tries to get from the cached client, and only falls back to live GET
+// if the cached object appears stripped or is missing required labels.
+// After a live GET, it also ensures the object has the tracking label (best-effort).
 func (cw *ClientWrapper) Get(ctx context.Context, key types.NamespacedName, obj ctrlclient.Object, opts ...ctrlclient.GetOption) error {
-	// 1) Cache read (no live fallback here on error)
+
 	if err := cw.Client.Get(ctx, key, obj, opts...); err != nil {
 		return err
 	}
 
-	// 2) Post-read check: only specific kinds may need live refresh
 	switch o := obj.(type) {
 	case *corev1.Secret:
 		if secretNeedsLiveRefresh(o) {
-			// Re-fetch from live to get the full object
+
 			if err := cw.liveClient.Get(ctx, key, obj, opts...); err != nil {
 				return err
 			}
-			// Ensure it becomes tracked for future full-caching (best-effort)
+
 			cw.ensureTrackedLabel(ctx, obj)
 		}
+
 	case *corev1.ConfigMap:
 		if configmapNeedsLiveRefresh(o) {
-			// Re-fetch from live to get the full object
+
 			if err := cw.liveClient.Get(ctx, key, obj, opts...); err != nil {
 				return err
 			}
-			// Ensure it becomes tracked for future full-caching (best-effort)
+
 			cw.ensureTrackedLabel(ctx, obj)
 		}
 
-		// add more kinds here (e.g., *corev1.ConfigMap) if you apply similar striping
+		// add more kinds here (e.g., *corev1.Deployment) if applying similar striping
+
 	}
 
 	return nil
 }
 
 // secretNeedsLiveRefresh returns true if the cached secret looks stripped or untracked.
 func secretNeedsLiveRefresh(s *corev1.Secret) bool {
-	// Untracked → we likely cached a slimmed object; refresh live.
+
 	if !cacheutils.IsTrackedByOperator(s.GetLabels()) {
 		return true
 	}
-	// Heuristic: a "slimmed" secret from our transform has nil Data/StringData.
-	// (Note: a legitimately empty secret may also match; adjust if you add a marker label/annotation.)
+
+	// Heuristic: a "stripped" Secret from our transform has nil Data/StringData.
+	// A truly empty Secret may also match, but that only triggers an extra live GET,
+	// which is rare and acceptable.
 	if s.Data == nil && s.StringData == nil {
 		return true
 	}
@@ -77,13 +88,17 @@ func configmapNeedsLiveRefresh(cm *corev1.ConfigMap) bool {
 	if !cacheutils.IsTrackedByOperator(cm.GetLabels()) {
 		return true
 	}
+
+	// Heuristic: a "stripped" ConfigMap from our transform has nil Data/BinaryData.
+	// A truly empty ConfigMap may also match, but that only triggers an extra live GET,
+	// which is rare and acceptable.
 	if cm.Data == nil && cm.BinaryData == nil {
 		return true
 	}
 	return false
 }
 
-// ensureTrackedLabel adds the operator tracking label (best-effort, ignores patch error).
+// ensureTrackedLabel adds the operator tracking label.
 func (cw *ClientWrapper) ensureTrackedLabel(ctx context.Context, obj ctrlclient.Object) {
 	if cacheutils.IsTrackedByOperator(obj.GetLabels()) {
 		return
@@ -97,5 +112,10 @@ func (cw *ClientWrapper) ensureTrackedLabel(ctx context.Context, obj ctrlclient.
 	labels[common.ArgoCDTrackedByOperatorLabel] = common.ArgoCDAppName
 	obj.SetLabels(labels)
 
-	_ = cw.liveClient.Patch(ctx, obj, ctrlclient.MergeFrom(orig)) // best-effort
+	// Best-effort patch to add the operator tracking label.
+	// Non-fatal: a later reconcile will reattempt if this fails.
+	err := cw.liveClient.Patch(ctx, obj, ctrlclient.MergeFrom(orig))
+	if err != nil {
+		log.Error(err, "failed to add operator tracking label to object", "name", obj.GetName(), "namespace", obj.GetNamespace())
+	}
 }