feat: compute managed workflow graphs w/o requiring dependent resources

This allows for workflows to be computed at build time, only to be
resolved (i.e. associating workflow nodes to actual dependent
resources) when needed.
In the process, the configuration mechanism of managed dependent
resource has been improved to make it possible to resolve the
configuration solely from the dependent resource class instead of
previously requiring the dependent to be instantiated. This is now done
viw the DependentResourceConfigurationResolver class.

Author: metacosm

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

@@ -20,7 +20,6 @@
 import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Dependent;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
-import io.javaoperatorsdk.operator.api.reconciler.dependent.managed.AnnotationDependentResourceConfigurator;
 import io.javaoperatorsdk.operator.processing.dependent.workflow.Condition;
 import io.javaoperatorsdk.operator.processing.event.rate.RateLimiter;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilter;
@@ -121,19 +120,17 @@ public ResourceEventFilter<P> getEventFilter() {
     Class<ResourceEventFilter<P>>[] filterTypes =
         (Class<ResourceEventFilter<P>>[]) valueOrDefault(annotation,
             ControllerConfiguration::eventFilters, new Object[] {});
-    if (filterTypes.length > 0) {
-      for (var filterType : filterTypes) {
-        try {
-          ResourceEventFilter<P> filter = filterType.getConstructor().newInstance();
-
-          if (answer == null) {
-            answer = filter;
-          } else {
-            answer = answer.and(filter);
-          }
-        } catch (Exception e) {
-          throw new IllegalArgumentException(e);
+    for (var filterType : filterTypes) {
+      try {
+        ResourceEventFilter<P> filter = filterType.getConstructor().newInstance();
+
+        if (answer == null) {
+          answer = filter;
+        } else {
+          answer = answer.and(filter);
         }
+      } catch (Exception e) {
+        throw new IllegalArgumentException(e);
       }
     }
     return answer != null ? answer : ResourceEventFilters.passthrough();
@@ -177,22 +174,6 @@ private void configureFromAnnotatedReconciler(Object instance) {
     }
   }
 
-  @SuppressWarnings("unchecked")
-  private void configureFromCustomAnnotation(Object instance) {
-    if (instance instanceof AnnotationDependentResourceConfigurator) {
-      AnnotationDependentResourceConfigurator configurator =
-          (AnnotationDependentResourceConfigurator) instance;
-      final Class<? extends Annotation> configurationClass =
-          (Class<? extends Annotation>) Utils.getFirstTypeArgumentFromInterface(
-              instance.getClass(), AnnotationDependentResourceConfigurator.class);
-      final var configAnnotation = instance.getClass().getAnnotation(configurationClass);
-      // always called even if the annotation is null so that implementations can provide default
-      // values
-      final var config = configurator.configFrom(configAnnotation, this);
-      configurator.configureWith(config);
-    }
-  }
-
   @Override
   @SuppressWarnings("unchecked")
   public Optional<OnAddFilter<P>> onAddFilter() {
@@ -239,15 +220,10 @@ public List<DependentResourceSpec> getDependentResources() {
               "A DependentResource named '" + name + "' already exists: " + spec);
         }
 
-        final var dependentResource = Utils.instantiateAndConfigureIfNeeded(dependentType,
-            DependentResource.class,
-            Utils.contextFor(this, dependentType, Dependent.class),
-            this::configureFromCustomAnnotation);
-
         var eventSourceName = dependent.useEventSourceWithName();
         eventSourceName = Constants.NO_VALUE_SET.equals(eventSourceName) ? null : eventSourceName;
         final var context = Utils.contextFor(this, dependentType, null);
-        spec = new DependentResourceSpec(dependentResource, name,
+        spec = new DependentResourceSpec(dependentType, name,
             Set.of(dependent.dependsOn()),
             Utils.instantiate(dependent.readyPostcondition(), Condition.class, context),
             Utils.instantiate(dependent.reconcilePrecondition(), Condition.class, context),

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

@@ -145,9 +145,9 @@ default ObjectMapper getObjectMapper() {
     return Serialization.jsonMapper();
   }
 
-  @Deprecated(forRemoval = true)
+  @SuppressWarnings("rawtypes")
   default DependentResourceFactory dependentResourceFactory() {
-    return null;
+    return DependentResourceFactory.DEFAULT;
   }
 
   default Optional<LeaderElectionConfiguration> getLeaderElectionConfiguration() {

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

@@ -1,17 +1,15 @@
 package io.javaoperatorsdk.operator.api.config;
 
 import java.time.Duration;
+import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Optional;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.UnaryOperator;
-import java.util.stream.Collectors;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.config.dependent.DependentResourceSpec;
-import io.javaoperatorsdk.operator.api.reconciler.dependent.managed.DependentResourceConfigurator;
 import io.javaoperatorsdk.operator.processing.event.rate.RateLimiter;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilter;
 import io.javaoperatorsdk.operator.processing.event.source.filter.GenericFilter;
@@ -34,12 +32,12 @@ public class ControllerConfigurationOverrider<R extends HasMetadata> {
   private ResourceEventFilter<R> customResourcePredicate;
   private final ControllerConfiguration<R> original;
   private Duration reconciliationMaxInterval;
-  private final LinkedHashMap<String, DependentResourceSpec> namedDependentResourceSpecs;
   private OnAddFilter<R> onAddFilter;
   private OnUpdateFilter<R> onUpdateFilter;
   private GenericFilter<R> genericFilter;
   private RateLimiter rateLimiter;
   private UnaryOperator<R> cachePruneFunction;
+  private Map<DependentResourceSpec, Object> configurations;
 
   private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     finalizer = original.getFinalizerName();
@@ -49,13 +47,9 @@ private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     labelSelector = original.getLabelSelector();
     customResourcePredicate = original.getEventFilter();
     reconciliationMaxInterval = original.maxReconciliationInterval().orElse(null);
-    // make the original specs modifiable
-    final var dependentResources = original.getDependentResources();
-    namedDependentResourceSpecs = new LinkedHashMap<>(dependentResources.size());
     this.onAddFilter = original.onAddFilter().orElse(null);
     this.onUpdateFilter = original.onUpdateFilter().orElse(null);
     this.genericFilter = original.genericFilter().orElse(null);
-    dependentResources.forEach(drs -> namedDependentResourceSpecs.put(drs.getName(), drs));
     this.original = original;
     this.rateLimiter = original.getRateLimiter();
     this.cachePruneFunction = original.cachePruneFunction().orElse(null);
@@ -167,40 +161,24 @@ public ControllerConfigurationOverrider<R> withCachePruneFunction(
     return this;
   }
 
-  @SuppressWarnings("unchecked")
   public ControllerConfigurationOverrider<R> replacingNamedDependentResourceConfig(String name,
       Object dependentResourceConfig) {
 
-    var current = namedDependentResourceSpecs.get(name);
-    if (current == null) {
-      throw new IllegalArgumentException("Cannot find a DependentResource named: " + name);
-    }
+    final var specs = original.getDependentResources();
+    final var spec = specs.stream()
+        .filter(drs -> drs.getName().equals(name)).findFirst()
+        .orElseThrow(
+            () -> new IllegalArgumentException("Cannot find a DependentResource named: " + name));
 
-    var dependentResource = current.getDependentResource();
-    if (dependentResource instanceof DependentResourceConfigurator) {
-      var configurator = (DependentResourceConfigurator) dependentResource;
-      configurator.configureWith(dependentResourceConfig);
+    if (configurations == null) {
+      configurations = new HashMap<>(specs.size());
     }
+    configurations.put(spec, dependentResourceConfig);
 
     return this;
   }
 
   public ControllerConfiguration<R> build() {
-    final var hasModifiedNamespaces = !original.getNamespaces().equals(namespaces);
-    final var newDependentSpecs = namedDependentResourceSpecs.values().stream()
-        .peek(spec -> {
-          // if the dependent resource has a NamespaceChangeable config
-          // update the namespaces if needed, otherwise, do nothing
-          if (hasModifiedNamespaces) {
-            final Optional<?> maybeConfig = spec.getDependentResourceConfiguration();
-            maybeConfig
-                .filter(NamespaceChangeable.class::isInstance)
-                .map(NamespaceChangeable.class::cast)
-                .filter(NamespaceChangeable::allowsNamespaceChanges)
-                .ifPresent(nc -> nc.changeNamespaces(namespaces));
-          }
-        }).collect(Collectors.toList());
-
     return new DefaultControllerConfiguration<>(
         original.getAssociatedReconcilerClassName(),
         original.getName(),
@@ -217,7 +195,9 @@ public ControllerConfiguration<R> build() {
         onUpdateFilter,
         genericFilter,
         rateLimiter,
-        newDependentSpecs, cachePruneFunction);
+        original.getDependentResources(),
+        cachePruneFunction,
+        configurations);
   }
 
   public static <R extends HasMetadata> ControllerConfigurationOverrider<R> override(

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

@@ -3,11 +3,13 @@
 import java.time.Duration;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.UnaryOperator;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.config.dependent.DependentResourceConfigurationProvider;
 import io.javaoperatorsdk.operator.api.config.dependent.DependentResourceSpec;
 import io.javaoperatorsdk.operator.processing.event.rate.LinearRateLimiter;
 import io.javaoperatorsdk.operator.processing.event.rate.RateLimiter;
@@ -20,7 +22,7 @@
 @SuppressWarnings("rawtypes")
 public class DefaultControllerConfiguration<R extends HasMetadata>
     extends DefaultResourceConfiguration<R>
-    implements ControllerConfiguration<R> {
+    implements ControllerConfiguration<R>, DependentResourceConfigurationProvider {
 
   private final String associatedControllerClassName;
   private final String name;
@@ -32,6 +34,7 @@ public class DefaultControllerConfiguration<R extends HasMetadata>
   private final List<DependentResourceSpec> dependents;
   private final Duration reconciliationMaxInterval;
   private final RateLimiter rateLimiter;
+  private final Map<DependentResourceSpec, Object> configurations;
 
   // NOSONAR constructor is meant to provide all information
   public DefaultControllerConfiguration(
@@ -52,6 +55,31 @@ public DefaultControllerConfiguration(
       RateLimiter rateLimiter,
       List<DependentResourceSpec> dependents,
       UnaryOperator<R> cachePruneFunction) {
+    this(associatedControllerClassName, name, crdName, finalizer, generationAware, namespaces,
+        retry, labelSelector, resourceEventFilter, resourceClass, reconciliationMaxInterval,
+        onAddFilter, onUpdateFilter, genericFilter, rateLimiter, dependents, cachePruneFunction,
+        null);
+  }
+
+  DefaultControllerConfiguration(
+      String associatedControllerClassName,
+      String name,
+      String crdName,
+      String finalizer,
+      boolean generationAware,
+      Set<String> namespaces,
+      Retry retry,
+      String labelSelector,
+      ResourceEventFilter<R> resourceEventFilter,
+      Class<R> resourceClass,
+      Duration reconciliationMaxInterval,
+      OnAddFilter<R> onAddFilter,
+      OnUpdateFilter<R> onUpdateFilter,
+      GenericFilter<R> genericFilter,
+      RateLimiter rateLimiter,
+      List<DependentResourceSpec> dependents,
+      UnaryOperator<R> cachePruneFunction,
+      Map<DependentResourceSpec, Object> configurations) {
     super(labelSelector, resourceClass, onAddFilter, onUpdateFilter, genericFilter, namespaces,
         cachePruneFunction);
     this.associatedControllerClassName = associatedControllerClassName;
@@ -68,6 +96,7 @@ public DefaultControllerConfiguration(
     this.rateLimiter =
         rateLimiter != null ? rateLimiter : LinearRateLimiter.deactivatedRateLimiter();
     this.dependents = dependents != null ? dependents : Collections.emptyList();
+    this.configurations = configurations != null ? configurations : Collections.emptyMap();
   }
 
   @Override
@@ -120,4 +149,8 @@ public RateLimiter getRateLimiter() {
     return rateLimiter;
   }
 
+  @Override
+  public Object getConfigurationFor(DependentResourceSpec spec) {
+    return configurations.get(spec);
+  }
 }

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

@@ -237,7 +237,6 @@ public static String contextFor(ControllerConfiguration<?> controllerConfigurati
     }
     context += "reconciler: " + controllerConfiguration.getName();
 
-
     return context;
   }
 }

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

@@ -0,0 +1,12 @@
+package io.javaoperatorsdk.operator.api.config.dependent;
+
+import java.lang.annotation.Annotation;
+
+import io.javaoperatorsdk.operator.api.config.ControllerConfiguration;
+import io.javaoperatorsdk.operator.api.reconciler.dependent.managed.DependentResourceConfigurator;
+
+public interface ConfigurationConverter<A extends Annotation, C, D extends DependentResourceConfigurator<? extends C>> {
+
+  C configFrom(A configAnnotation, ControllerConfiguration<?> parentConfiguration,
+      Class<D> originatingClass);
+}

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

@@ -0,0 +1,16 @@
+package io.javaoperatorsdk.operator.api.config.dependent;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Configured {
+
+  Class<? extends Annotation> by();
+
+  Class<?> with();
+
+  @SuppressWarnings("rawtypes")
+  Class<? extends ConfigurationConverter> converter();
+}

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

@@ -0,0 +1,6 @@
+package io.javaoperatorsdk.operator.api.config.dependent;
+
+public interface DependentResourceConfigurationProvider {
+  @SuppressWarnings("rawtypes")
+  Object getConfigurationFor(DependentResourceSpec spec);
+}