more event filters

micrometer-support/pom.xml

@@ -5,7 +5,7 @@
   <parent>
     <artifactId>java-operator-sdk</artifactId>
     <groupId>io.javaoperatorsdk</groupId>
-    <version>3.0.4-SNAPSHOT</version>
+    <version>3.1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 

operator-framework-core/pom.xml

@@ -6,7 +6,7 @@
   <parent>
     <groupId>io.javaoperatorsdk</groupId>
     <artifactId>java-operator-sdk</artifactId>
-    <version>3.0.4-SNAPSHOT</version>
+    <version>3.1.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 

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

@@ -1,13 +1,16 @@
 package io.javaoperatorsdk.operator.api.config;
 
+import java.lang.reflect.InvocationTargetException;
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.BiPredicate;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
@@ -19,24 +22,30 @@
 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.VoidCondition;
 import io.javaoperatorsdk.operator.processing.dependent.kubernetes.KubernetesDependent;
 import io.javaoperatorsdk.operator.processing.dependent.kubernetes.KubernetesDependentResource;
 import io.javaoperatorsdk.operator.processing.dependent.kubernetes.KubernetesDependentResourceConfig;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.Condition;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilter;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilters;
+import io.javaoperatorsdk.operator.processing.event.source.filter.VoidGenericFilter;
+import io.javaoperatorsdk.operator.processing.event.source.filter.VoidOnAddFilter;
+import io.javaoperatorsdk.operator.processing.event.source.filter.VoidOnDeleteFilter;
+import io.javaoperatorsdk.operator.processing.event.source.filter.VoidOnUpdateFilter;
 
 import static io.javaoperatorsdk.operator.api.reconciler.Constants.DEFAULT_NAMESPACES_SET;
 
 @SuppressWarnings("rawtypes")
-public class AnnotationControllerConfiguration<R extends HasMetadata>
-    implements io.javaoperatorsdk.operator.api.config.ControllerConfiguration<R> {
+public class AnnotationControllerConfiguration<P extends HasMetadata>
+    implements io.javaoperatorsdk.operator.api.config.ControllerConfiguration<P> {
 
-  protected final Reconciler<R> reconciler;
+  protected final Reconciler<P> reconciler;
   private final ControllerConfiguration annotation;
   private List<DependentResourceSpec> specs;
-  private Class<R> resourceClass;
+  private Class<P> resourceClass;
 
-  public AnnotationControllerConfiguration(Reconciler<R> reconciler) {
+  public AnnotationControllerConfiguration(Reconciler<P> reconciler) {
     this.reconciler = reconciler;
     this.annotation = reconciler.getClass().getAnnotation(ControllerConfiguration.class);
     if (annotation == null) {
@@ -81,10 +90,10 @@ public Set<String> getNamespaces() {
 
   @Override
   @SuppressWarnings("unchecked")
-  public Class<R> getResourceClass() {
+  public Class<P> getResourceClass() {
     if (resourceClass == null) {
       resourceClass =
-          (Class<R>) Utils.getFirstTypeArgumentFromSuperClassOrInterface(reconciler.getClass(),
+          (Class<P>) Utils.getFirstTypeArgumentFromSuperClassOrInterface(reconciler.getClass(),
               Reconciler.class);
     }
     return resourceClass;
@@ -102,16 +111,16 @@ public String getAssociatedReconcilerClassName() {
 
   @SuppressWarnings("unchecked")
   @Override
-  public ResourceEventFilter<R> getEventFilter() {
-    ResourceEventFilter<R> answer = null;
+  public ResourceEventFilter<P> getEventFilter() {
+    ResourceEventFilter<P> answer = null;
 
-    Class<ResourceEventFilter<R>>[] filterTypes =
-        (Class<ResourceEventFilter<R>>[]) valueOrDefault(annotation,
+    Class<ResourceEventFilter<P>>[] filterTypes =
+        (Class<ResourceEventFilter<P>>[]) valueOrDefault(annotation,
             ControllerConfiguration::eventFilters, new Object[] {});
     if (filterTypes.length > 0) {
       for (var filterType : filterTypes) {
         try {
-          ResourceEventFilter<R> filter = filterType.getConstructor().newInstance();
+          ResourceEventFilter<P> filter = filterType.getConstructor().newInstance();
 
           if (answer == null) {
             answer = filter;
@@ -141,17 +150,55 @@ public Optional<Duration> reconciliationMaxInterval() {
     }
   }
 
-  public static <T> T valueOrDefault(
-      ControllerConfiguration controllerConfiguration,
-      Function<ControllerConfiguration, T> mapper,
-      T defaultValue) {
-    if (controllerConfiguration == null) {
-      return defaultValue;
+  @Override
+  @SuppressWarnings("unchecked")
+  public Optional<Predicate<P>> onAddFilter() {
+    return (Optional<Predicate<P>>) createFilter(annotation.onAddFilter(), FilterType.onAdd,
+        annotation.getClass().getSimpleName());
+  }
+
+  private enum FilterType {
+    onAdd(VoidOnAddFilter.class), onUpdate(VoidOnUpdateFilter.class), onDelete(
+        VoidOnDeleteFilter.class), generic(VoidGenericFilter.class);
+
+    final Class<?> defaultValue;
+
+    FilterType(Class<?> defaultValue) {
+      this.defaultValue = defaultValue;
+    }
+  }
+
+  private <T> Optional<T> createFilter(Class<T> filter, FilterType filterType, String origin) {
+    if (filterType.defaultValue.equals(filter)) {
+      return Optional.empty();
     } else {
-      return mapper.apply(controllerConfiguration);
+      try {
+        var instance = (T) filter.getDeclaredConstructor().newInstance();
+        return Optional.of(instance);
+      } catch (InstantiationException | IllegalAccessException | InvocationTargetException
+          | NoSuchMethodException e) {
+        throw new OperatorException(
+            "Couldn't create " + filterType + " filter from " + filter.getName() + " class in "
+                + origin + " for reconciler " + getName(),
+            e);
+      }
     }
   }
 
+  @SuppressWarnings("unchecked")
+  @Override
+  public Optional<BiPredicate<P, P>> onUpdateFilter() {
+    return (Optional<BiPredicate<P, P>>) createFilter(annotation.onUpdateFilter(),
+        FilterType.onUpdate, annotation.getClass().getSimpleName());
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public Optional<Predicate<P>> genericFilter() {
+    return (Optional<Predicate<P>>) createFilter(annotation.genericFilter(),
+        FilterType.generic, annotation.getClass().getSimpleName());
+  }
+
   @SuppressWarnings({"rawtypes", "unchecked"})
   @Override
   public List<DependentResourceSpec> getDependentResources() {
@@ -172,19 +219,46 @@ public List<DependentResourceSpec> getDependentResources() {
         }
 
         final var name = getName(dependent, dependentType);
-        final var spec = specsMap.get(name);
+        var spec = specsMap.get(name);
         if (spec != null) {
           throw new IllegalArgumentException(
               "A DependentResource named: " + name + " already exists: " + spec);
         }
-        specsMap.put(name, new DependentResourceSpec(dependentType, config, name));
+        spec = new DependentResourceSpec(dependentType, config, name);
+        spec.setDependsOn(Set.of(dependent.dependsOn()));
+        addConditions(spec, dependent);
+        specsMap.put(name, spec);
       }
 
       specs = specsMap.values().stream().collect(Collectors.toUnmodifiableList());
     }
     return specs;
   }
 
+  @SuppressWarnings("unchecked")
+  private void addConditions(DependentResourceSpec spec, Dependent dependent) {
+    if (dependent.deletePostcondition() != VoidCondition.class) {
+      spec.setDeletePostCondition(instantiateCondition(dependent.deletePostcondition()));
+    }
+    if (dependent.readyPostcondition() != VoidCondition.class) {
+      spec.setReadyPostcondition(instantiateCondition(dependent.readyPostcondition()));
+    }
+    if (dependent.reconcilePrecondition() != VoidCondition.class) {
+      spec.setReconcilePrecondition(instantiateCondition(dependent.reconcilePrecondition()));
+    }
+  }
+
+  private Condition<?, ?> instantiateCondition(Class<? extends Condition> condition) {
+    try {
+      return condition.getDeclaredConstructor().newInstance();
+    } catch (InstantiationException
+        | IllegalAccessException
+        | InvocationTargetException
+        | NoSuchMethodException e) {
+      throw new OperatorException(e);
+    }
+  }
+
   private String getName(Dependent dependent, Class<? extends DependentResource> dependentType) {
     var name = dependent.name();
     if (name.isBlank()) {
@@ -193,26 +267,55 @@ private String getName(Dependent dependent, Class<? extends DependentResource> d
     return name;
   }
 
+  @SuppressWarnings("rawtypes")
   private Object createKubernetesResourceConfig(Class<? extends DependentResource> dependentType) {
+
     Object config;
     final var kubeDependent = dependentType.getAnnotation(KubernetesDependent.class);
 
     var namespaces = getNamespaces();
     var configuredNS = false;
-    if (kubeDependent != null && !Arrays.equals(KubernetesDependent.DEFAULT_NAMESPACES,
-        kubeDependent.namespaces())) {
-      namespaces = Set.of(kubeDependent.namespaces());
-      configuredNS = true;
-    }
-
     String labelSelector = null;
+    Predicate<? extends HasMetadata> onAddFilter = null;
+    BiPredicate<? extends HasMetadata, ? extends HasMetadata> onUpdateFilter = null;
+    BiPredicate<? extends HasMetadata, Boolean> onDeleteFilter = null;
     if (kubeDependent != null) {
+      if (!Arrays.equals(KubernetesDependent.DEFAULT_NAMESPACES,
+          kubeDependent.namespaces())) {
+        namespaces = Set.of(kubeDependent.namespaces());
+        configuredNS = true;
+      }
+
       final var fromAnnotation = kubeDependent.labelSelector();
       labelSelector = Constants.NO_VALUE_SET.equals(fromAnnotation) ? null : fromAnnotation;
+
+      final var kubeDependentName = KubernetesDependent.class.getSimpleName();
+      onAddFilter = createFilter(kubeDependent.onAddFilter(), FilterType.onAdd, kubeDependentName)
+          .orElse(null);
+      onUpdateFilter =
+          createFilter(kubeDependent.onUpdateFilter(), FilterType.onUpdate, kubeDependentName)
+              .orElse(null);
+      onDeleteFilter =
+          createFilter(kubeDependent.onDeleteFilter(), FilterType.onDelete, kubeDependentName)
+              .orElse(null);
     }
 
     config =
-        new KubernetesDependentResourceConfig(namespaces, labelSelector, configuredNS);
+        new KubernetesDependentResourceConfig(namespaces, labelSelector, configuredNS, onAddFilter,
+            onUpdateFilter, onDeleteFilter);
+
     return config;
   }
+
+  public static <T> T valueOrDefault(
+      ControllerConfiguration controllerConfiguration,
+      Function<ControllerConfiguration, T> mapper,
+      T defaultValue) {
+    if (controllerConfiguration == null) {
+      return defaultValue;
+    } else {
+      return mapper.apply(controllerConfiguration);
+    }
+  }
+
 }

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

@@ -80,7 +80,7 @@ default boolean checkCRDAndValidateLocalModel() {
     return false;
   }
 
-  int DEFAULT_RECONCILIATION_THREADS_NUMBER = 5;
+  int DEFAULT_RECONCILIATION_THREADS_NUMBER = 10;
 
   /**
    * Retrieves the maximum number of threads the operator can spin out to dispatch reconciliation

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

@@ -7,10 +7,8 @@
  * to the ConfigurationService is via the reconciliation context.
  */
 public class ConfigurationServiceProvider {
-  static final ConfigurationService DEFAULT =
-      new BaseConfigurationService(Utils.loadFromProperties());
   private static ConfigurationService instance;
-  private static ConfigurationService defaultConfigurationService = DEFAULT;
+  private static ConfigurationService defaultConfigurationService = createDefault();
   private static boolean alreadyConfigured = false;
 
   private ConfigurationServiceProvider() {}
@@ -64,8 +62,12 @@ synchronized static ConfigurationService getDefault() {
   }
 
   public synchronized static void reset() {
-    defaultConfigurationService = DEFAULT;
+    defaultConfigurationService = createDefault();
     instance = null;
     alreadyConfigured = false;
   }
+
+  static ConfigurationService createDefault() {
+    return new BaseConfigurationService(Utils.loadFromProperties());
+  }
 }

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

@@ -10,6 +10,8 @@
 import io.javaoperatorsdk.operator.api.config.dependent.DependentResourceSpec;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilter;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEventFilters;
+import io.javaoperatorsdk.operator.processing.retry.GenericRetry;
+import io.javaoperatorsdk.operator.processing.retry.Retry;
 
 public interface ControllerConfiguration<R extends HasMetadata> extends ResourceConfiguration<R> {
 
@@ -27,6 +29,16 @@ default boolean isGenerationAware() {
 
   String getAssociatedReconcilerClassName();
 
+  default Retry getRetry() {
+    return GenericRetry.fromConfiguration(getRetryConfiguration()); // NOSONAR
+  }
+
+  /**
+   * Use getRetry instead.
+   *
+   * @return configuration for retry.
+   */
+  @Deprecated
   default RetryConfiguration getRetryConfiguration() {
     return RetryConfiguration.DEFAULT;
   }