Add support for hooks to the reconciler

Hooks are an extension of the sink concept that we already use for
watches, but support more interception points and we can have multiple
hooks.

Co-authored-by: atoato88 <akihito-inou@nec.com>

Author: justinsb

pkg/patterns/declarative/hooks.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package declarative
+
+import (
+	"context"
+
+	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative/pkg/applier"
+	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative/pkg/manifest"
+)
+
+// Hook is the base interface implemented by a hook
+type Hook interface {
+}
+
+// ApplyOperation contains the details of an Apply operation
+type ApplyOperation struct {
+	// Subject is the object we are reconciling
+	Subject DeclarativeObject
+
+	// Objects is the set of objects we are applying
+	Objects *manifest.Objects
+
+	// ApplierOptions is the set of options passed to the applier
+	ApplierOptions *applier.ApplierOptions
+}
+
+// AfterApply is implemented by hooks that want to be called after every apply operation
+type AfterApply interface {
+	AfterApply(ctx context.Context, op *ApplyOperation) error
+}
+
+// BeforeApply is implemented by hooks that want to be called before every apply operation
+type BeforeApply interface {
+	BeforeApply(ctx context.Context, op *ApplyOperation) error
+}

pkg/patterns/declarative/options.go

@@ -61,6 +61,9 @@ type reconcilerParams struct {
 	ownerFn    OwnerSelector
 	labelMaker LabelMaker
 	status     Status
+
+	// hooks allow for interception of events during the reconciliation lifecycle
+	hooks []Hook
 }
 
 type ManifestController interface {
@@ -241,3 +244,11 @@ func WithReconcileMetrics(metricsDuration int, ot *ObjectTracker) ReconcilerOpti
 		return p
 	}
 }
+
+// WithHook allows for us to intercept and inject behaviours at various points in the lifecycle
+func WithHook(hook Hook) ReconcilerOption {
+	return func(p reconcilerParams) reconcilerParams {
+		p.hooks = append(p.hooks, hook)
+		return p
+	}
+}

pkg/patterns/declarative/reconciler.go

@@ -304,7 +304,22 @@ func (r *Reconciler) reconcileExists(ctx context.Context, name types.NamespacedN
 		CascadingStrategy: r.options.cascadingStrategy,
 	}
 
+	applyOperation := &ApplyOperation{
+		Subject:        instance,
+		Objects:        objects,
+		ApplierOptions: &applierOpt,
+	}
+
 	applier := r.options.applier
+	for _, hook := range r.options.hooks {
+		if beforeApply, ok := hook.(BeforeApply); ok {
+			if err := beforeApply.BeforeApply(ctx, applyOperation); err != nil {
+				log.Error(err, "calling BeforeApply hook")
+				return objects, fmt.Errorf("error calling BeforeApply hook: %v", err)
+			}
+		}
+	}
+
 	if err := applier.Apply(ctx, applierOpt); err != nil {
 		log.Error(err, "applying manifest")
 		return objects, fmt.Errorf("error applying manifest: %v", err)
@@ -316,6 +331,16 @@ func (r *Reconciler) reconcileExists(ctx context.Context, name types.NamespacedN
 			return objects, err
 		}
 	}
+
+	for _, hook := range r.options.hooks {
+		if afterApply, ok := hook.(AfterApply); ok {
+			if err := afterApply.AfterApply(ctx, applyOperation); err != nil {
+				log.Error(err, "calling AfterApply hook")
+				return objects, fmt.Errorf("error calling AfterApply hook: %w", err)
+			}
+		}
+	}
+
 	return objects, nil
 }
 
@@ -613,10 +638,17 @@ func (r *Reconciler) IsKustomizeOptionUsed() bool {
 }
 
 // SetSink provides a Sink that will be notified for all deployments
+//
+// Deprecated: prefer WithHook
 func (r *Reconciler) SetSink(sink Sink) {
 	r.options.sink = sink
 }
 
+// AddHook provides a Hook that will be notified of significant events
+func (r *Reconciler) AddHook(hook Hook) {
+	r.options.hooks = append(r.options.hooks, hook)
+}
+
 func parseListKind(infos *manifest.Objects) (*manifest.Objects, error) {
 	var out []*manifest.Object
 

pkg/patterns/declarative/watch.go

@@ -33,12 +33,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/source"
-	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative/pkg/manifest"
 	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative/pkg/watch"
 )
 
-type eventsSource interface {
-	SetSink(sink Sink)
+// hookableReconciler is implemented by a reconciler that we can hook
+type hookableReconciler interface {
+	AddHook(hook Hook)
 }
 
 type DynamicWatch interface {
@@ -62,7 +62,7 @@ type WatchChildrenOptions struct {
 	Controller controller.Controller
 
 	// Reconciler lets us hook into the post-apply lifecycle event.
-	Reconciler eventsSource
+	Reconciler hookableReconciler
 
 	// ScopeWatchesToNamespace controls whether watches are per-namespace.
 	// This allows for more narrowly scoped RBAC permissions, at the cost of more watches.
@@ -71,7 +71,7 @@ type WatchChildrenOptions struct {
 
 // WatchAll creates a Watch on ctrl for all objects reconciled by recnl.
 // Deprecated: prefer WatchChildren (and consider setting ScopeWatchesToNamespace)
-func WatchAll(config *rest.Config, ctrl controller.Controller, reconciler eventsSource, labelMaker LabelMaker) (chan struct{}, error) {
+func WatchAll(config *rest.Config, ctrl controller.Controller, reconciler hookableReconciler, labelMaker LabelMaker) (chan struct{}, error) {
 	options := WatchChildrenOptions{
 		RESTConfig:              config,
 		Controller:              ctrl,
@@ -126,47 +126,54 @@ func WatchChildren(options WatchChildrenOptions) (chan struct{}, error) {
 		return nil, fmt.Errorf("setting up dynamic watch on the controller: %w", err)
 	}
 
-	options.Reconciler.SetSink(&watchAll{
-		dw:         dw,
-		options:    options,
-		registered: make(map[string]struct{})})
+	afterApplyHook := &clusterWatch{
+		dw:                      dw,
+		scopeWatchesToNamespace: options.ScopeWatchesToNamespace,
+		labelMaker:              options.LabelMaker,
+		registered:              make(map[string]struct{}),
+	}
+
+	options.Reconciler.AddHook(afterApplyHook)
 
 	return stopCh, nil
 }
 
-type watchAll struct {
+// clusterWatch watches the objects in one cluster
+type clusterWatch struct {
 	dw DynamicWatch
 
-	options WatchChildrenOptions
+	scopeWatchesToNamespace bool
+	labelMaker              LabelMaker
 
 	mutex sync.Mutex
-	// registered tracks what we are currently watching, avoid duplicate watches.
+
+	// registered tracks the objects we are currently watching, avoid duplicate watches.
 	registered map[string]struct{}
 }
 
-// Notify is called by the controller when the object changes.  We establish any new watches.
-func (w *watchAll) Notify(ctx context.Context, dest DeclarativeObject, objs *manifest.Objects) error {
+// AfterApply is called by the controller after an apply. We establish any new watches.
+func (w *clusterWatch) AfterApply(ctx context.Context, op *ApplyOperation) error {
 	log := log.FromContext(ctx)
 
-	labelSelector, err := labels.ValidatedSelectorFromSet(w.options.LabelMaker(ctx, dest))
+	labelSelector, err := labels.ValidatedSelectorFromSet(w.labelMaker(ctx, op.Subject))
 	if err != nil {
 		return fmt.Errorf("failed to build label selector: %w", err)
 	}
 
-	notify := metav1.ObjectMeta{Name: dest.GetName(), Namespace: dest.GetNamespace()}
+	notify := metav1.ObjectMeta{Name: op.Subject.GetName(), Namespace: op.Subject.GetNamespace()}
 	filter := metav1.ListOptions{LabelSelector: labelSelector.String()}
 
 	// Protect against concurrent invocation
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
 
-	for _, obj := range objs.Items {
+	for _, obj := range op.Objects.Items {
 		gvk := obj.GroupVersionKind()
 
 		key := fmt.Sprintf("gvk=%s:%s:%s;labels=%s", gvk.Group, gvk.Version, gvk.Kind, filter.LabelSelector)
 
 		filterNamespace := ""
-		if w.options.ScopeWatchesToNamespace && obj.GetNamespace() != "" {
+		if w.scopeWatchesToNamespace && obj.GetNamespace() != "" {
 			filterNamespace = obj.GetNamespace()
 			key += ";namespace=" + filterNamespace
 		}