SQUASH: revert InDefaultCluster()

Signed-off-by: Dr. Stefan Schimanski <[email protected]>

Author: sttts

pkg/builder/controller.go

@@ -74,11 +74,10 @@ func ControllerManagedBy(m manager.Manager) *Builder {
 
 // ForInput represents the information set by the For method.
 type ForInput struct {
-	object              client.Object
-	forceDefaultCluster bool // in cluster-aware mode, force the object to be watched in the default cluster
-	predicates          []predicate.Predicate
-	objectProjection    objectProjection
-	err                 error
+	object           client.Object
+	predicates       []predicate.Predicate
+	objectProjection objectProjection
+	err              error
 }
 
 // For defines the type of Object being *reconciled*, and configures the ControllerManagedBy to respond to create / delete /
@@ -101,11 +100,10 @@ func (blder *Builder) For(object client.Object, opts ...ForOption) *Builder {
 
 // OwnsInput represents the information set by Owns method.
 type OwnsInput struct {
-	matchEveryOwner     bool
-	object              client.Object
-	forceDefaultCluster bool // in cluster-aware mode, force the object to be watched in the default cluster
-	predicates          []predicate.Predicate
-	objectProjection    objectProjection
+	matchEveryOwner  bool
+	object           client.Object
+	predicates       []predicate.Predicate
+	objectProjection objectProjection
 }
 
 // Owns defines types of Objects being *generated* by the ControllerManagedBy, and configures the ControllerManagedBy to respond to
@@ -128,11 +126,10 @@ func (blder *Builder) Owns(object client.Object, opts ...OwnsOption) *Builder {
 
 // WatchesInput represents the information set by Watches method.
 type WatchesInput struct {
-	src                 source.Source
-	forceDefaultCluster bool // in cluster-aware mode, force the object to be watched in the default cluster
-	eventHandler        handler.EventHandler
-	predicates          []predicate.Predicate
-	objectProjection    objectProjection
+	src              source.Source
+	eventHandler     handler.EventHandler
+	predicates       []predicate.Predicate
+	objectProjection objectProjection
 }
 
 // Watches defines the type of Object to watch, and configures the ControllerManagedBy to respond to create / delete /
@@ -287,10 +284,7 @@ func (blder *Builder) doWatch() error {
 		if err != nil {
 			return err
 		}
-		src := clusterAwareSource{
-			DeepCopyableSyncingSource: source.Kind(blder.cluster.GetCache(), obj),
-			forceDefaultCluster:       blder.forInput.forceDefaultCluster,
-		}
+		src := source.Kind(blder.cluster.GetCache(), obj)
 		hdler := &handler.EnqueueRequestForObject{}
 		allPredicates := append([]predicate.Predicate(nil), blder.globalPredicates...)
 		allPredicates = append(allPredicates, blder.forInput.predicates...)
@@ -308,10 +302,7 @@ func (blder *Builder) doWatch() error {
 		if err != nil {
 			return err
 		}
-		src := clusterAwareSource{
-			DeepCopyableSyncingSource: source.Kind(blder.cluster.GetCache(), obj),
-			forceDefaultCluster:       own.forceDefaultCluster,
-		}
+		src := source.Kind(blder.cluster.GetCache(), obj)
 		opts := []handler.OwnerOption{}
 		if !own.matchEveryOwner {
 			opts = append(opts, handler.OnlyControllerOwner())
@@ -334,17 +325,12 @@ func (blder *Builder) doWatch() error {
 	}
 	for _, w := range blder.watchesInput {
 		// If the source of this watch is of type Kind, project it.
-		src := w.src
 		if srcKind, ok := w.src.(*internalsource.Kind); ok {
 			typeForSrc, err := blder.project(srcKind.Type, w.objectProjection)
 			if err != nil {
 				return err
 			}
 			srcKind.Type = typeForSrc
-			src = clusterAwareSource{
-				DeepCopyableSyncingSource: srcKind,
-				forceDefaultCluster:       w.forceDefaultCluster,
-			}
 		} else if !ok {
 			// If we're building a cluster-aware controller, raw watches are not allowed
 			// given that the cache cannot be validated to be coming from the same cluster.
@@ -356,7 +342,7 @@ func (blder *Builder) doWatch() error {
 		}
 		allPredicates := append([]predicate.Predicate(nil), blder.globalPredicates...)
 		allPredicates = append(allPredicates, w.predicates...)
-		if err := blder.ctrl.Watch(src, w.eventHandler, allPredicates...); err != nil {
+		if err := blder.ctrl.Watch(w.src, w.eventHandler, allPredicates...); err != nil {
 			return err
 		}
 	}
@@ -445,12 +431,3 @@ func (blder *Builder) doController(r reconcile.Reconciler) error {
 	blder.ctrl, err = newController(controllerName, blder.mgr, ctrlOptions)
 	return err
 }
-
-type clusterAwareSource struct {
-	source.DeepCopyableSyncingSource
-	forceDefaultCluster bool
-}
-
-func (s clusterAwareSource) ForceDefaultCluster() bool {
-	return s.forceDefaultCluster
-}

pkg/builder/options.go

@@ -154,21 +154,3 @@ type matchEveryOwner struct{}
 func (o matchEveryOwner) ApplyToOwns(opts *OwnsInput) {
 	opts.matchEveryOwner = true
 }
-
-// InDefaultCluster configures the input to only watch objects on the default
-// cluster, even if a cluster provider is set.
-var InDefaultCluster = inDefaultCluster{}
-
-type inDefaultCluster struct{}
-
-func (f inDefaultCluster) ApplyToFor(opts *ForInput) {
-	opts.forceDefaultCluster = true
-}
-
-func (f inDefaultCluster) ApplyToOwns(opts *OwnsInput) {
-	opts.forceDefaultCluster = true
-}
-
-func (f inDefaultCluster) ApplyToWatches(opts *WatchesInput) {
-	opts.forceDefaultCluster = true
-}

pkg/internal/controller/controller.go

@@ -103,13 +103,6 @@ type Controller struct {
 	LeaderElected *bool
 }
 
-// ClusterAwareSource is a source that knows whether to watch in the default cluster
-// in the clusters engaged by the cluster provider.
-type ClusterAwareSource interface {
-	source.Source
-	ForceDefaultCluster() bool
-}
-
 type clusterDescription struct {
 	cluster.Cluster
 	ctx     context.Context
@@ -157,12 +150,8 @@ func (c *Controller) Watch(src source.Source, evthdler handler.EventHandler, prc
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
-	// If the source is cluster aware, store it in a separate list.
-	var forceDefaultCluster bool
-	if src, ok := src.(ClusterAwareSource); ok {
-		forceDefaultCluster = src.ForceDefaultCluster()
-	}
-	if c.WatchProviderClusters && !forceDefaultCluster {
+	// If a cluster provider is in-place, run src for every provided cluster
+	if c.WatchProviderClusters {
 		src, ok := src.(source.DeepCopyableSyncingSource)
 		if !ok {
 			return fmt.Errorf("source %T is not cluster aware, but WatchProviderClusters is true", src)