refactor: don't require anything object-specific at handler construction

this avoids recomputing the entire handler state machine on each sync

Author: ecordell

component.go

@@ -1,6 +1,7 @@
 package libctrl
 
 import (
+	"context"
 	"fmt"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -20,24 +21,24 @@ type KubeObject interface {
 // i.e. a pod would be a component of a deployment (though direct ownership is
 // not required).
 type Component[K KubeObject] struct {
-	indexer   *typed.Indexer[K]
-	selector  labels.Selector
-	indexName string
+	indexer      *typed.Indexer[K]
+	selectorFunc func(ctx context.Context) labels.Selector
+	indexName    string
 }
 
 // NewIndexedComponent creates a component from an index
-func NewIndexedComponent[K KubeObject](indexer *typed.Indexer[K], indexName string, selector labels.Selector) *Component[K] {
+func NewIndexedComponent[K KubeObject](indexer *typed.Indexer[K], indexName string, selectorFunc func(ctx context.Context) labels.Selector) *Component[K] {
 	return &Component[K]{
-		indexer:   indexer,
-		indexName: indexName,
-		selector:  selector,
+		indexer:      indexer,
+		indexName:    indexName,
+		selectorFunc: selectorFunc,
 	}
 }
 
 // List all objects that match the component's specification.
 // Components are expected to be unique (per label), but List returns a slice
 // so that controllers can handle duplicates appropriately.
-func (c *Component[K]) List(indexValue fmt.Stringer) (out []K) {
+func (c *Component[K]) List(ctx context.Context, indexValue fmt.Stringer) (out []K) {
 	out = make([]K, 0)
 	ownedObjects, err := c.indexer.ByIndex(c.indexName, indexValue.String())
 	if err != nil {
@@ -49,7 +50,7 @@ func (c *Component[K]) List(indexValue fmt.Stringer) (out []K) {
 		if ls == nil {
 			continue
 		}
-		if c.selector.Matches(labels.Set(ls)) {
+		if c.selectorFunc(ctx).Matches(labels.Set(ls)) {
 			out = append(out, d)
 		}
 	}
@@ -59,12 +60,12 @@ func (c *Component[K]) List(indexValue fmt.Stringer) (out []K) {
 // HashableComponent is a Component with an annotation that stores a hash of the
 // previous configuration the controller wrote
 type HashableComponent[K KubeObject] struct {
-	Component[K]
+	*Component[K]
 	ObjectHasher
 	HashAnnotationKey string
 }
 
-func NewHashableComponent[K KubeObject](component Component[K], hasher ObjectHasher, key string) *HashableComponent[K] {
+func NewHashableComponent[K KubeObject](component *Component[K], hasher ObjectHasher, key string) *HashableComponent[K] {
 	return &HashableComponent[K]{
 		Component:         component,
 		ObjectHasher:      hasher,

component_handler.go

@@ -2,21 +2,22 @@ package libctrl
 
 import (
 	"context"
-	"fmt"
+
+	"k8s.io/apimachinery/pkg/types"
 
 	"github.com/authzed/controller-idioms/handler"
 )
 
 // ComponentContextHandler fills the value for a ContextKey with the result of
 // fetching a component.
 type ComponentContextHandler[K KubeObject] struct {
-	owner     fmt.Stringer
+	owner     MustValueContext[types.NamespacedName]
 	ctxKey    SettableContext[[]K]
 	component *Component[K]
 	next      handler.ContextHandler
 }
 
-func NewComponentContextHandler[K KubeObject](contextKey SettableContext[[]K], component *Component[K], owner fmt.Stringer, next handler.ContextHandler) *ComponentContextHandler[K] {
+func NewComponentContextHandler[K KubeObject](contextKey SettableContext[[]K], component *Component[K], owner MustValueContext[types.NamespacedName], next handler.ContextHandler) *ComponentContextHandler[K] {
 	return &ComponentContextHandler[K]{
 		owner:     owner,
 		ctxKey:    contextKey,
@@ -26,6 +27,6 @@ func NewComponentContextHandler[K KubeObject](contextKey SettableContext[[]K], c
 }
 
 func (h *ComponentContextHandler[K]) Handle(ctx context.Context) {
-	ctx = h.ctxKey.WithValue(ctx, h.component.List(h.owner))
+	ctx = h.ctxKey.WithValue(ctx, h.component.List(ctx, h.owner.MustValue(ctx)))
 	h.next.Handle(ctx)
 }

ensure_component.go

@@ -17,20 +17,20 @@ type Annotator[T any] interface {
 type EnsureComponentByHash[K KubeObject, A Annotator[A]] struct {
 	*HashableComponent[K]
 	ctrls        *ContextKey[ControlAll]
-	nn           types.NamespacedName
+	nn           MustValueContext[types.NamespacedName]
 	applyObject  func(ctx context.Context, apply A) (K, error)
-	deleteObject func(ctx context.Context, name string) error
+	deleteObject func(ctx context.Context, nn types.NamespacedName) error
 	newObj       func(ctx context.Context) A
 }
 
 var _ handler.ContextHandler = &EnsureComponentByHash[*corev1.Service, *applycorev1.ServiceApplyConfiguration]{}
 
 func NewEnsureComponentByHash[K KubeObject, A Annotator[A]](
 	component *HashableComponent[K],
-	owner types.NamespacedName,
+	owner MustValueContext[types.NamespacedName],
 	ctrls *ContextKey[ControlAll],
 	applyObj func(ctx context.Context, apply A) (K, error),
-	deleteObject func(ctx context.Context, name string) error,
+	deleteObject func(ctx context.Context, nn types.NamespacedName) error,
 	newObj func(ctx context.Context) A,
 ) *EnsureComponentByHash[K, A] {
 	return &EnsureComponentByHash[K, A]{
@@ -44,7 +44,7 @@ func NewEnsureComponentByHash[K KubeObject, A Annotator[A]](
 }
 
 func (e *EnsureComponentByHash[K, A]) Handle(ctx context.Context) {
-	ownedObjs := e.List(e.nn)
+	ownedObjs := e.List(ctx, e.nn.MustValue(ctx))
 
 	newObj := e.newObj(ctx)
 	hash, err := e.Hash(newObj)
@@ -80,7 +80,10 @@ func (e *EnsureComponentByHash[K, A]) Handle(ctx context.Context) {
 	if len(matchingObjs) == 1 {
 		// delete extra objects
 		for _, o := range extraObjs {
-			if err := e.deleteObject(ctx, o.GetName()); err != nil {
+			if err := e.deleteObject(ctx, types.NamespacedName{
+				Namespace: o.GetNamespace(),
+				Name:      o.GetName(),
+			}); err != nil {
 				e.ctrls.MustValue(ctx).RequeueErr(err)
 				return
 			}

file_informer.go

@@ -105,7 +105,7 @@ func NewFileInformer(watcher *fsnotify.Watcher, gvr schema.GroupVersionResource)
 	return &FileInformer{
 		fileName: gvr.Resource,
 		watcher:  watcher,
-		informer: NewFileSharedIndexInformer(gvr.Resource, watcher, 15*time.Minute),
+		informer: NewFileSharedIndexInformer(gvr.Resource, watcher, 1*time.Minute),
 	}, nil
 }
 

handler/handler.go

@@ -100,6 +100,12 @@ func (h Handlers) MustOne() Handler {
 	return h[0]
 }
 
+// NewTypeHandler assigns an id based on the underlying type to a ContextHandler
+// implementation and returns a Handler.
+func NewTypeHandler(h ContextHandler) Handler {
+	return Handler{ContextHandler: h, id: Key(fmt.Sprintf("%T", h))}
+}
+
 // NewHandler assigns an id to a ContextHandler implementation and returns a
 // Handler.
 func NewHandler(h ContextHandler, id Key) Handler {

manager/controller.go

@@ -131,10 +131,12 @@ func (c *OwnedResourceController) processNext(ctx context.Context) bool {
 	ctx, cancel := context.WithCancel(ctx)
 
 	done := func() {
+		klog.FromContext(ctx).V(5).Info("done", "key", key)
 		cancel()
 		c.Queue.Forget(key)
 	}
 	requeue := func(after time.Duration) {
+		klog.FromContext(ctx).V(5).Info("requeue", "key", key, "after", after)
 		cancel()
 		if after == 0 {
 			c.Queue.AddRateLimited(key)

pause.go

@@ -42,7 +42,7 @@ type PauseHandler[K HasStatusConditions] struct {
 	Next           handler.ContextHandler
 }
 
-func NewPauseHandler[K HasStatusConditions](ctrls *ContextKey[ControlAll],
+func NewPauseContextHandler[K HasStatusConditions](ctrls *ContextKey[ControlAll],
 	pausedLabelKey string,
 	object *ContextDefaultingKey[K],
 	patchStatus func(ctx context.Context, patch K) error,
@@ -94,14 +94,12 @@ type SelfPauseHandler[K HasStatusConditions] struct {
 func NewSelfPauseHandler[K HasStatusConditions](ctrls *ContextKey[ControlAll],
 	pausedLabelKey string,
 	contextKey *ContextDefaultingKey[K],
-	ownerUID types.UID,
 	patch, patchStatus func(ctx context.Context, patch K) error,
 ) *SelfPauseHandler[K] {
 	return &SelfPauseHandler[K]{
 		CtxKey:         contextKey,
 		ctrls:          ctrls,
 		PausedLabelKey: pausedLabelKey,
-		OwnerUID:       ownerUID,
 		Patch:          patch,
 		PatchStatus:    patchStatus,
 	}