Reconcile resources

helm-app-operator/pkg/helm/controller/controller.go

@@ -9,7 +9,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	crthandler "sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
@@ -33,11 +32,10 @@ func Add(mgr manager.Manager, options WatchOptions) {
 		options.ResyncPeriod = time.Minute
 	}
 	r := &helmOperatorReconciler{
-		Client:               mgr.GetClient(),
-		GVK:                  options.GVK,
-		Installer:            options.Installer,
-		ResyncPeriod:         options.ResyncPeriod,
-		lastResourceVersions: map[types.NamespacedName]string{},
+		Client:       mgr.GetClient(),
+		GVK:          options.GVK,
+		Installer:    options.Installer,
+		ResyncPeriod: options.ResyncPeriod,
 	}
 
 	// Register the GVK with the schema

helm-app-operator/pkg/helm/controller/reconcile.go

@@ -2,16 +2,13 @@ package controller
 
 import (
 	"context"
-	"fmt"
-	"sync"
 	"time"
 
 	"github.com/sirupsen/logrus"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
@@ -23,40 +20,40 @@ type helmOperatorReconciler struct {
 	GVK          schema.GroupVersionKind
 	Installer    helm.Installer
 	ResyncPeriod time.Duration
-
-	lastResourceVersions map[types.NamespacedName]string
-	mutex                sync.RWMutex
 }
 
 const (
 	finalizer = "uninstall-helm-release"
 )
 
 func (r *helmOperatorReconciler) Reconcile(request reconcile.Request) (reconcile.Result, error) {
-	logrus.Infof("processing %s", request.NamespacedName)
-
 	o := &unstructured.Unstructured{}
 	o.SetGroupVersionKind(r.GVK)
+	o.SetNamespace(request.Namespace)
+	o.SetName(request.Name)
+	logrus.Debugf("Processing %s", helm.ResourceString(o))
+
 	err := r.Client.Get(context.TODO(), request.NamespacedName, o)
 	if apierrors.IsNotFound(err) {
 		return reconcile.Result{}, nil
 	}
 	if err != nil {
+		logrus.Errorf("Failed to lookup %s: %s", helm.ResourceString(o), err)
 		return reconcile.Result{}, err
 	}
 
 	deleted := o.GetDeletionTimestamp() != nil
 	pendingFinalizers := o.GetFinalizers()
 	if !deleted && !contains(pendingFinalizers, finalizer) {
-		logrus.Debugf("adding finalizer %s to resource", finalizer)
+		logrus.Debugf("Adding finalizer \"%s\" to %s", finalizer, helm.ResourceString(o))
 		finalizers := append(pendingFinalizers, finalizer)
 		o.SetFinalizers(finalizers)
 		err := r.Client.Update(context.TODO(), o)
 		return reconcile.Result{}, err
 	}
 	if deleted {
 		if !contains(pendingFinalizers, finalizer) {
-			logrus.Info("resouce is terminated, skipping reconciliation")
+			logrus.Infof("Resource %s is terminated, skipping reconciliation", helm.ResourceString(o))
 			return reconcile.Result{}, nil
 		}
 
@@ -76,24 +73,19 @@ func (r *helmOperatorReconciler) Reconcile(request reconcile.Request) (reconcile
 		return reconcile.Result{}, err
 	}
 
-	lastResourceVersion, ok := r.getLastResourceVersion(request.NamespacedName)
-	if ok && o.GetResourceVersion() == lastResourceVersion {
-		logrus.Infof("skipping %s because resource version has not changed", request.NamespacedName)
-		return reconcile.Result{RequeueAfter: r.ResyncPeriod}, nil
-	}
-
-	updatedResource, err := r.Installer.InstallRelease(o)
+	updatedResource, needsUpdate, err := r.Installer.ReconcileRelease(o)
 	if err != nil {
-		logrus.Errorf(err.Error())
+		logrus.Errorf("Failed to reconcile release for %s: %s", helm.ResourceString(o), err)
 		return reconcile.Result{}, err
 	}
 
-	err = r.Client.Update(context.TODO(), updatedResource)
-	if err != nil {
-		logrus.Errorf(err.Error())
-		return reconcile.Result{}, fmt.Errorf("failed to update custom resource status: %v", err)
+	if needsUpdate {
+		err = r.Client.Update(context.TODO(), updatedResource)
+		if err != nil {
+			logrus.Errorf("Failed to update resource status for %s: %s", helm.ResourceString(o), err)
+			return reconcile.Result{}, err
+		}
 	}
-	r.setLastResourceVersion(request.NamespacedName, o.GetResourceVersion())
 
 	return reconcile.Result{RequeueAfter: r.ResyncPeriod}, nil
 }
@@ -106,16 +98,3 @@ func contains(l []string, s string) bool {
 	}
 	return false
 }
-
-func (r *helmOperatorReconciler) getLastResourceVersion(n types.NamespacedName) (string, bool) {
-	r.mutex.RLock()
-	defer r.mutex.RUnlock()
-	v, ok := r.lastResourceVersions[n]
-	return v, ok
-}
-
-func (r *helmOperatorReconciler) setLastResourceVersion(n types.NamespacedName, v string) {
-	r.mutex.Lock()
-	defer r.mutex.Unlock()
-	r.lastResourceVersions[n] = v
-}

helm-app-operator/pkg/helm/engine.go

@@ -34,13 +34,13 @@ func (o *OwnerRefEngine) Render(chart *chart.Chart, values chartutil.Values) (ma
 		if !strings.HasSuffix(fileName, ".yaml") {
 			continue
 		}
-		logrus.Infof("adding ownerrefs to file: %s", fileName)
+		logrus.Debugf("adding ownerrefs to file: %s", fileName)
 		withOwner, err := o.addOwnerRefs(renderedFile)
 		if err != nil {
 			return nil, err
 		}
 		if withOwner == "" {
-			logrus.Infof("skipping empty template: %s", fileName)
+			logrus.Debugf("skipping empty template: %s", fileName)
 			continue
 		}
 		ownedRenderedFiles[fileName] = withOwner