feat(controllers): CachedImage events

closes #28

Author: plaffitt

cmd/cache/main.go

@@ -77,8 +77,9 @@ func main() {
 	}
 
 	if err = (&controllers.CachedImageReconciler{
-		Client: mgr.GetClient(),
-		Scheme: mgr.GetScheme(),
+		Client:   mgr.GetClient(),
+		Scheme:   mgr.GetScheme(),
+		Recorder: mgr.GetEventRecorderFor("cachedimage-controller"),
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "CachedImage")
 		os.Exit(1)

config/rbac/role.yaml

@@ -6,6 +6,13 @@ metadata:
   creationTimestamp: null
   name: manager-role
 rules:
+- apiGroups:
+  - ""
+  resources:
+  - events
+  verbs:
+  - create
+  - patch
 - apiGroups:
   - ""
   resources:

controllers/cachedimage_controller.go

@@ -25,6 +25,7 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/tools/record"
 	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -39,13 +40,15 @@ import (
 // CachedImageReconciler reconciles a CachedImage object
 type CachedImageReconciler struct {
 	client.Client
-	Scheme *runtime.Scheme
+	Scheme   *runtime.Scheme
+	Recorder record.EventRecorder
 }
 
 //+kubebuilder:rbac:groups=dcr.enix.io,resources=cachedimages,verbs=get;list;watch;create;update;patch;delete
 //+kubebuilder:rbac:groups=dcr.enix.io,resources=cachedimages/status,verbs=get;update;patch
 //+kubebuilder:rbac:groups=dcr.enix.io,resources=cachedimages/finalizers,verbs=update
 //+kubebuilder:rbac:groups=core,resources=secrets,verbs=get;list
+//+kubebuilder:rbac:groups="",resources=events,verbs=create;patch
 
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
@@ -72,10 +75,13 @@ func (r *CachedImageReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	// Remove image from registry when CachedImage is beeing deleted, finalizer is removed after it
 	if !cachedImage.ObjectMeta.DeletionTimestamp.IsZero() {
 		if containsString(cachedImage.GetFinalizers(), finalizerName) {
-			log.Info("deleting image cache")
+			log.Info("deleting image from cache")
+			r.Recorder.Eventf(&cachedImage, "Normal", "CleaningUp", "Removing image %s from cache", cachedImage.Spec.SourceImage)
 			if err := registry.DeleteImage(cachedImage.Spec.SourceImage); err != nil {
+				r.Recorder.Eventf(&cachedImage, "Warning", "CleanupFailed", "Image %s could not be removed from cache: %s", cachedImage.Spec.SourceImage, err)
 				return ctrl.Result{}, err
 			}
+			r.Recorder.Eventf(&cachedImage, "Normal", "CleanedUp", "Image %s successfully removed from cache", cachedImage.Spec.SourceImage)
 
 			log.Info("removing finalizer")
 			controllerutil.RemoveFinalizer(&cachedImage, finalizerName)
@@ -127,10 +133,13 @@ func (r *CachedImageReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	if !expiresAt.IsZero() {
 		if time.Now().After(expiresAt.Time) {
 			log.Info("cachedimage expired, deleting it", "now", time.Now(), "expiresAt", expiresAt)
+			r.Recorder.Eventf(&cachedImage, "Normal", "Expiring", "Image %s has expired, deleting it", cachedImage.Spec.SourceImage)
 			err := r.Delete(ctx, &cachedImage)
 			if err != nil {
+				r.Recorder.Eventf(&cachedImage, "Warning", "ExpiringFailed", "Image %s could not expire: %s", cachedImage.Spec.SourceImage, err)
 				return ctrl.Result{}, err
 			}
+			r.Recorder.Eventf(&cachedImage, "Normal", "Expired", "Image %s successfully expired", cachedImage.Spec.SourceImage)
 			return ctrl.Result{}, nil
 		} else {
 			return ctrl.Result{RequeueAfter: expiresAt.Sub(time.Now())}, nil
@@ -139,17 +148,28 @@ func (r *CachedImageReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 
 	// Adding image to registry
 	log.Info("caching image")
-	keychain := registry.NewKubernetesKeychain(r.Client, cachedImage.Spec.PullSecretsNamespace, cachedImage.Spec.PullSecretNames)
-	if cacheUpdated, err := registry.CacheImage(cachedImage.Spec.SourceImage, keychain); err != nil {
-		log.Error(err, "failed to cache image")
+	isCached, err := registry.ImageIsCached(cachedImage.Spec.SourceImage)
+	if err != nil {
+		log.Error(err, "could not determine if the image present in cache")
 		return ctrl.Result{}, err
-	} else if cacheUpdated {
-		log.Info("image cached")
-		if err := r.Get(ctx, req.NamespacedName, &cachedImage); err != nil {
-			return ctrl.Result{}, client.IgnoreNotFound(err)
+	}
+
+	if !isCached {
+		r.Recorder.Eventf(&cachedImage, "Normal", "Caching", "Start caching image %s", cachedImage.Spec.SourceImage)
+		keychain := registry.NewKubernetesKeychain(r.Client, cachedImage.Spec.PullSecretsNamespace, cachedImage.Spec.PullSecretNames)
+		if err := registry.CacheImage(cachedImage.Spec.SourceImage, keychain); err != nil {
+			log.Error(err, "failed to cache image")
+			r.Recorder.Eventf(&cachedImage, "Warning", "CacheFailed", "Failed to cache image %s, reason: %s", cachedImage.Spec.SourceImage, err)
+			return ctrl.Result{}, err
+		} else {
+			log.Info("image cached")
+			r.Recorder.Eventf(&cachedImage, "Normal", "Cached", "Successfully cached image %s", cachedImage.Spec.SourceImage)
+			if err := r.Get(ctx, req.NamespacedName, &cachedImage); err != nil {
+				return ctrl.Result{}, client.IgnoreNotFound(err)
+			}
 		}
 	} else {
-		log.Info("image already cached, cache not updated")
+		log.Info("image already present in cache, ignoring")
 	}
 
 	// Update CachedImage IsCached status

controllers/suite_test.go

@@ -147,8 +147,9 @@ var _ = BeforeSuite(func(done Done) {
 	Expect(err).ToNot(HaveOccurred())
 
 	err = (&CachedImageReconciler{
-		Client: k8sManager.GetClient(),
-		Scheme: k8sManager.GetScheme(),
+		Client:   k8sManager.GetClient(),
+		Scheme:   k8sManager.GetScheme(),
+		Recorder: k8sManager.GetEventRecorderFor("cachedimage-controller"),
 	}).SetupWithManager(k8sManager)
 	Expect(err).ToNot(HaveOccurred())
 

helm/cache-registry/templates/clusterrole.yaml

@@ -4,6 +4,13 @@ apiVersion: rbac.authorization.k8s.io/v1
 metadata:
   name: {{ default (include "cache-registry.fullname" .) .Values.serviceAccount.name }}
 rules:
+  - apiGroups:
+    - ""
+    resources:
+    - events
+    verbs:
+    - create
+    - patch
   - apiGroups:
     - ""
     resources:

internal/registry/registry.go

@@ -38,12 +38,25 @@ func getDestinationName(sourceName string) (string, error) {
 	return Endpoint + "/" + fullname, nil
 }
 
-func DeleteImage(imageName string) error {
+func parseLocalReference(imageName string) (name.Reference, error) {
 	destName, err := getDestinationName(imageName)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	ref, err := name.ParseReference(destName, name.Insecure)
+	return name.ParseReference(destName, name.Insecure)
+}
+
+func ImageIsCached(imageName string) (bool, error) {
+	reference, err := parseLocalReference(imageName)
+	if err != nil {
+		return false, err
+	}
+
+	return imageExists(reference)
+}
+
+func DeleteImage(imageName string) error {
+	ref, err := parseLocalReference(imageName)
 	if err != nil {
 		return err
 	}
@@ -57,7 +70,7 @@ func DeleteImage(imageName string) error {
 		return err
 	}
 
-	digest, err := name.NewDigest(destName+"@"+descriptor.Digest.String(), name.Insecure)
+	digest, err := name.NewDigest(ref.Name()+"@"+descriptor.Digest.String(), name.Insecure)
 
 	if err != nil {
 		return err
@@ -66,51 +79,39 @@ func DeleteImage(imageName string) error {
 	return remote.Delete(digest)
 }
 
-func CacheImage(imageName string, keychain authn.Keychain) (bool, error) {
-	destName, err := getDestinationName(imageName)
-	if err != nil {
-		return false, err
-	}
-	destRef, err := name.ParseReference(destName, name.Insecure)
+func CacheImage(imageName string, keychain authn.Keychain) error {
+	destRef, err := parseLocalReference(imageName)
 	if err != nil {
-		return false, err
+		return err
 	}
 	sourceRef, err := name.ParseReference(imageName, name.Insecure)
 	if err != nil {
-		return false, err
-	}
-
-	exists, err := imageExists(destRef)
-	if err != nil {
-		return false, err
-	}
-	if exists {
-		return false, nil
+		return err
 	}
 
 	auth := remote.WithAuthFromKeychain(keychain)
-	exists, err = imageExists(sourceRef, auth)
+	exists, err := imageExists(sourceRef, auth)
 	if err != nil {
-		return false, err
+		return err
 	}
 	if !exists {
-		return false, errors.New("could not find source image")
+		return errors.New("could not find source image")
 	}
 
 	image, err := remote.Image(sourceRef, auth)
 	if err != nil {
-		return false, err
+		return err
 	}
 
 	if err := remote.Write(destRef, image); err != nil {
-		return false, err
+		return err
 	}
 
 	if err := remote.Put(destRef, image); err != nil {
-		return false, err
+		return err
 	}
 
-	return true, nil
+	return nil
 }
 
 func SanitizeName(image string) string {