feat: introduce getEffectiveNamespaces on ControllerConfiguration

Author: metacosm

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/Operator.java

@@ -11,7 +11,6 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -144,7 +143,7 @@ public <R extends CustomResource> void register(
           resClass,
           configuration.watchAllNamespaces()
               ? "[all namespaces]"
-              : Arrays.toString(eventSourceManager.getTargetNamespaces()));
+              : configuration.getEffectiveNamespaces());
     }
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerConfiguration.java

@@ -41,6 +41,15 @@ static boolean currentNamespaceWatched(Set<String> namespaces) {
         && namespaces.contains(Controller.WATCH_CURRENT_NAMESPACE);
   }
 
+  default Set<String> getEffectiveNamespaces() {
+    var targetNamespaces = getNamespaces();
+    if (watchCurrentNamespace()) {
+      targetNamespaces =
+          Collections.singleton(getConfigurationService().getClientConfiguration().getNamespace());
+    }
+    return targetNamespaces;
+  }
+
   default RetryConfiguration getRetryConfiguration() {
     return RetryConfiguration.DEFAULT;
   }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/DefaultEventSourceManager.java

@@ -27,7 +27,6 @@ public class DefaultEventSourceManager implements EventSourceManager {
   private final ReentrantLock lock = new ReentrantLock();
   private final Map<String, EventSource> eventSources = new ConcurrentHashMap<>();
   private final DefaultEventHandler defaultEventHandler;
-  private String[] targetNamespaces;
   private TimerEventSource retryTimerEventSource;
 
   DefaultEventSourceManager(DefaultEventHandler defaultEventHandler, boolean supportRetry) {
@@ -39,28 +38,16 @@ public class DefaultEventSourceManager implements EventSourceManager {
     }
   }
 
-  public String[] getTargetNamespaces() {
-    return targetNamespaces;
-  }
-
   public <R extends CustomResource> DefaultEventSourceManager(
       ResourceController<R> controller,
       ControllerConfiguration<R> configuration,
       MixedOperation<R, KubernetesResourceList<R>, Resource<R>> client) {
     this(new DefaultEventHandler(controller, configuration, client), true);
-    // check if we only want to watch the current namespace
-    targetNamespaces = configuration.getNamespaces().toArray(new String[] {});
-    if (configuration.watchCurrentNamespace()) {
-      targetNamespaces =
-          new String[] {
-            configuration.getConfigurationService().getClientConfiguration().getNamespace()
-          };
-    }
     registerEventSource(
         CUSTOM_RESOURCE_EVENT_SOURCE_NAME,
         new CustomResourceEventSource(
             client,
-            targetNamespaces,
+            configuration.getEffectiveNamespaces(),
             configuration.isGenerationAware(),
             configuration.getFinalizer(),
             configuration.getCustomResourceClass()));

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/internal/CustomResourceEventSource.java

@@ -27,7 +27,7 @@ public class CustomResourceEventSource extends AbstractEventSource
   private static final Logger log = LoggerFactory.getLogger(CustomResourceEventSource.class);
 
   private final MixedOperation client;
-  private final String[] targetNamespaces;
+  private final Set<String> targetNamespaces;
   private final boolean generationAware;
   private final String resourceFinalizer;
   private final Map<String, Long> lastGenerationProcessedSuccessfully = new ConcurrentHashMap<>();
@@ -36,7 +36,7 @@ public class CustomResourceEventSource extends AbstractEventSource
 
   public CustomResourceEventSource(
       MixedOperation client,
-      String[] targetNamespaces,
+      Set<String> targetNamespaces,
       boolean generationAware,
       String resourceFinalizer,
       Class<?> resClass) {
@@ -48,28 +48,25 @@ public CustomResourceEventSource(
     this.resClass = resClass.getName();
   }
 
-  public String[] getTargetNamespaces() {
-    return targetNamespaces;
-  }
-
   @Override
   public void start() {
     CustomResourceOperationsImpl crClient = (CustomResourceOperationsImpl) client;
-    if (ControllerConfiguration.allNamespacesWatched(Set.of(targetNamespaces))) {
+    if (ControllerConfiguration.allNamespacesWatched(targetNamespaces)) {
       var w = crClient.inAnyNamespace().watch(this);
       watches.add(w);
       log.debug("Registered controller {} -> {} for any namespace", resClass, w);
-    } else if (targetNamespaces.length == 0) {
+    } else if (targetNamespaces.isEmpty()) {
       var w = client.watch(this);
       watches.add(w);
       log.debug(
           "Registered controller {} -> {} for namespace {}", resClass, w, crClient.getNamespace());
     } else {
-      for (String targetNamespace : targetNamespaces) {
-        var w = crClient.inNamespace(targetNamespace).watch(this);
-        watches.add(w);
-        log.debug("Registered controller {} -> {} for namespace: {}", resClass, w, targetNamespace);
-      }
+      targetNamespaces.forEach(
+          ns -> {
+            var w = crClient.inNamespace(ns).watch(this);
+            watches.add(w);
+            log.debug("Registered controller {} -> {} for namespace: {}", resClass, w, ns);
+          });
     }
   }