feat: workflow Integration with API (dependent annotations, context)

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

@@ -1,5 +1,6 @@
 package io.javaoperatorsdk.operator.api.config;
 
+import java.lang.reflect.InvocationTargetException;
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.Collections;
@@ -19,9 +20,11 @@
 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;
 
@@ -166,19 +169,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()) {

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/ControllerConfigurationOverrider.java

@@ -140,11 +140,10 @@ public ControllerConfiguration<R> build() {
           // if the spec has a config and it's a KubernetesDependentResourceConfig, update the
           // namespaces if needed, otherwise, just return the existing spec
           final Optional<?> maybeConfig = spec.getDependentResourceConfiguration();
-          final Class<?> drClass = drsEntry.getValue().getDependentResourceClass();
           return maybeConfig.filter(KubernetesDependentResourceConfig.class::isInstance)
               .map(KubernetesDependentResourceConfig.class::cast)
               .filter(Predicate.not(KubernetesDependentResourceConfig::wereNamespacesConfigured))
-              .map(c -> updateSpec(drsEntry.getKey(), drClass, c))
+              .map(c -> updateSpec(drsEntry.getKey(), spec, c))
               .orElse(drsEntry.getValue());
         }).collect(Collectors.toUnmodifiableList());
 
@@ -164,9 +163,15 @@ public ControllerConfiguration<R> build() {
   }
 
   @SuppressWarnings({"rawtypes", "unchecked"})
-  private DependentResourceSpec<?, ?> updateSpec(String name, Class<?> drClass,
+  private DependentResourceSpec<?, ?> updateSpec(String name, DependentResourceSpec spec,
       KubernetesDependentResourceConfig c) {
-    return new DependentResourceSpec(drClass, c.setNamespaces(namespaces), name);
+    var res = new DependentResourceSpec(spec.getDependentResourceClass(),
+        c.setNamespaces(namespaces), name);
+    res.setReadyPostcondition(spec.getReadyCondition());
+    res.setReconcilePrecondition(spec.getReconcileCondition());
+    res.setDeletePostCondition(spec.getDeletePostCondition());
+    res.setDependsOn(spec.getDependsOn());
+    return res;
   }
 
   public static <R extends HasMetadata> ControllerConfigurationOverrider<R> override(

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

@@ -1,9 +1,12 @@
 package io.javaoperatorsdk.operator.api.config.dependent;
 
+import java.util.HashSet;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.Condition;
 
 public class DependentResourceSpec<T extends DependentResource<?, ?>, C> {
 
@@ -13,6 +16,14 @@ public class DependentResourceSpec<T extends DependentResource<?, ?>, C> {
 
   private final String name;
 
+  private Set<String> dependsOn;
+
+  private Condition<?, ?> readyCondition;
+
+  private Condition<?, ?> reconcileCondition;
+
+  private Condition<?, ?> deletePostCondition;
+
   public DependentResourceSpec(Class<T> dependentResourceClass, C dependentResourceConfig,
       String name) {
     this.dependentResourceClass = dependentResourceClass;
@@ -55,4 +66,46 @@ public boolean equals(Object o) {
   public int hashCode() {
     return Objects.hash(name);
   }
+
+  public Set<String> getDependsOn() {
+    if (dependsOn == null) {
+      dependsOn = new HashSet<>(0);
+    }
+    return dependsOn;
+  }
+
+  public DependentResourceSpec<T, C> setDependsOn(Set<String> dependsOn) {
+    this.dependsOn = dependsOn;
+    return this;
+  }
+
+  @SuppressWarnings("rawtypes")
+  public Condition getReadyCondition() {
+    return readyCondition;
+  }
+
+  public DependentResourceSpec<T, C> setReadyPostcondition(Condition<?, ?> readyCondition) {
+    this.readyCondition = readyCondition;
+    return this;
+  }
+
+  @SuppressWarnings("rawtypes")
+  public Condition getReconcileCondition() {
+    return reconcileCondition;
+  }
+
+  public DependentResourceSpec<T, C> setReconcilePrecondition(Condition<?, ?> reconcileCondition) {
+    this.reconcileCondition = reconcileCondition;
+    return this;
+  }
+
+  @SuppressWarnings("rawtypes")
+  public Condition getDeletePostCondition() {
+    return deletePostCondition;
+  }
+
+  public DependentResourceSpec<T, C> setDeletePostCondition(Condition<?, ?> deletePostCondition) {
+    this.deletePostCondition = deletePostCondition;
+    return this;
+  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Cleaner.java

@@ -5,7 +5,7 @@
 public interface Cleaner<P extends HasMetadata> {
 
   /**
-   * Note that this method turns on automatic finalizer usage.
+   * This method turns on automatic finalizer usage.
    *
    * The implementation should delete the associated component(s). This method is called when an
    * object is marked for deletion. After it's executed the custom resource finalizer is

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/DefaultContext.java

@@ -6,6 +6,7 @@
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.config.ControllerConfiguration;
+import io.javaoperatorsdk.operator.api.reconciler.dependent.managed.DefaultManagedDependentResourceContext;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.managed.ManagedDependentResourceContext;
 import io.javaoperatorsdk.operator.processing.Controller;
 
@@ -15,14 +16,14 @@ public class DefaultContext<P extends HasMetadata> implements Context<P> {
   private final Controller<P> controller;
   private final P primaryResource;
   private final ControllerConfiguration<P> controllerConfiguration;
-  private final ManagedDependentResourceContext managedDependentResourceContext;
+  private final DefaultManagedDependentResourceContext defaultManagedDependentResourceContext;
 
   public DefaultContext(RetryInfo retryInfo, Controller<P> controller, P primaryResource) {
     this.retryInfo = retryInfo;
     this.controller = controller;
     this.primaryResource = primaryResource;
     this.controllerConfiguration = controller.getConfiguration();
-    this.managedDependentResourceContext = new ManagedDependentResourceContext();
+    this.defaultManagedDependentResourceContext = new DefaultManagedDependentResourceContext();
   }
 
   @Override
@@ -52,8 +53,9 @@ public ControllerConfiguration<P> getControllerConfiguration() {
     return controllerConfiguration;
   }
 
+  @Override
   public ManagedDependentResourceContext managedDependentResourceContext() {
-    return managedDependentResourceContext;
+    return defaultManagedDependentResourceContext;
   }
 
   public DefaultContext<P> setRetryInfo(RetryInfo retryInfo) {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/dependent/Dependent.java

@@ -1,5 +1,7 @@
 package io.javaoperatorsdk.operator.api.reconciler.dependent;
 
+import io.javaoperatorsdk.operator.processing.dependent.workflow.Condition;
+
 import static io.javaoperatorsdk.operator.api.reconciler.Constants.NO_VALUE_SET;
 
 public @interface Dependent {
@@ -8,4 +10,15 @@
   Class<? extends DependentResource> type();
 
   String name() default NO_VALUE_SET;
+
+  @SuppressWarnings("rawtypes")
+  Class<? extends Condition> readyPostcondition() default VoidCondition.class;
+
+  @SuppressWarnings("rawtypes")
+  Class<? extends Condition> reconcilePrecondition() default VoidCondition.class;
+
+  @SuppressWarnings("rawtypes")
+  Class<? extends Condition> deletePostcondition() default VoidCondition.class;
+
+  String[] dependsOn() default {};
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/dependent/VoidCondition.java

@@ -0,0 +1,14 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.Condition;
+
+/** Used as default value for Condition in annotations */
+@SuppressWarnings("rawtypes")
+public class VoidCondition implements Condition {
+  @Override
+  public boolean isMet(DependentResource dependentResource, HasMetadata primary, Context context) {
+    throw new IllegalStateException("This is a placeholder class, should not be called");
+  }
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/dependent/managed/DefaultManagedDependentResourceContext.java

@@ -0,0 +1,61 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent.managed;
+
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import io.javaoperatorsdk.operator.processing.dependent.workflow.WorkflowCleanupResult;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.WorkflowReconcileResult;
+
+@SuppressWarnings("rawtypes")
+public class DefaultManagedDependentResourceContext implements ManagedDependentResourceContext {
+
+  private WorkflowReconcileResult workflowReconcileResult;
+  private WorkflowCleanupResult workflowCleanupResult;
+  private final ConcurrentHashMap attributes = new ConcurrentHashMap();
+
+  @Override
+  public <T> Optional<T> get(Object key, Class<T> expectedType) {
+    return Optional.ofNullable(attributes.get(key))
+        .filter(expectedType::isInstance)
+        .map(expectedType::cast);
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public <T> T put(Object key, T value) {
+    if (value == null) {
+      return (T) Optional.ofNullable(attributes.remove(key));
+    }
+    return (T) Optional.ofNullable(attributes.put(key, value));
+  }
+
+  @Override
+  @SuppressWarnings("unused")
+  public <T> T getMandatory(Object key, Class<T> expectedType) {
+    return get(key, expectedType).orElseThrow(() -> new IllegalStateException(
+        "Mandatory attribute (key: " + key + ", type: " + expectedType.getName()
+            + ") is missing or not of the expected type"));
+  }
+
+  public DefaultManagedDependentResourceContext setWorkflowExecutionResult(
+      WorkflowReconcileResult workflowReconcileResult) {
+    this.workflowReconcileResult = workflowReconcileResult;
+    return this;
+  }
+
+  public DefaultManagedDependentResourceContext setWorkflowCleanupResult(
+      WorkflowCleanupResult workflowCleanupResult) {
+    this.workflowCleanupResult = workflowCleanupResult;
+    return this;
+  }
+
+  @Override
+  public Optional<WorkflowReconcileResult> getWorkflowReconcileResult() {
+    return Optional.ofNullable(workflowReconcileResult);
+  }
+
+  @Override
+  public Optional<WorkflowCleanupResult> getWorkflowCleanupResult() {
+    return Optional.ofNullable(workflowCleanupResult);
+  }
+}