feat: reconcile condition

Author: csviri

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

@@ -3,15 +3,15 @@
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.fabric8.kubernetes.client.CustomResource;
 
-public class UpdateControl<T extends HasMetadata> extends BaseControl<UpdateControl<T>> {
+public class UpdateControl<P extends HasMetadata> extends BaseControl<UpdateControl<P>> {
 
-  private final T resource;
+  private final P resource;
   private final boolean updateStatus;
   private final boolean updateResource;
   private final boolean patch;
 
   private UpdateControl(
-      T resource, boolean updateStatus, boolean updateResource, boolean patch) {
+      P resource, boolean updateStatus, boolean updateResource, boolean patch) {
     if ((updateResource || updateStatus) && resource == null) {
       throw new IllegalArgumentException("CustomResource cannot be null in case of update");
     }
@@ -92,7 +92,7 @@ public static <T extends HasMetadata> UpdateControl<T> noUpdate() {
     return new UpdateControl<>(null, false, false, false);
   }
 
-  public T getResource() {
+  public P getResource() {
     return resource;
   }
 

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/workflow/DependentResourceNode.java

@@ -7,14 +7,16 @@
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
 import io.javaoperatorsdk.operator.processing.dependent.workflow.condition.CleanupCondition;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.condition.ReadyCondition;
 import io.javaoperatorsdk.operator.processing.dependent.workflow.condition.ReconcileCondition;
 
 public class DependentResourceNode<R, P extends HasMetadata> {
 
   private final DependentResource<R, P> dependentResource;
-  private ReconcileCondition reconcileCondition;
+  private ReconcileCondition<P> reconcileCondition;
   private CleanupCondition cleanupCondition;
-  private List<DependsOnRelation> dependsOnRelations = new ArrayList<>(1);
+  private ReadyCondition<R, P> readyCondition;
+  private List<DependentResourceNode> dependsOn = new ArrayList<>(1);
 
   public DependentResourceNode(DependentResource<R, P> dependentResource) {
     this(dependentResource, null, null);
@@ -26,7 +28,7 @@ public DependentResourceNode(DependentResource<R, P> dependentResource,
   }
 
   public DependentResourceNode(DependentResource<R, P> dependentResource,
-      ReconcileCondition reconcileCondition, CleanupCondition cleanupCondition) {
+      ReconcileCondition<P> reconcileCondition, CleanupCondition cleanupCondition) {
     this.dependentResource = dependentResource;
     this.reconcileCondition = reconcileCondition;
     this.cleanupCondition = cleanupCondition;
@@ -36,24 +38,24 @@ public DependentResource<R, P> getDependentResource() {
     return dependentResource;
   }
 
-  public Optional<ReconcileCondition> getReconcileCondition() {
+  public Optional<ReconcileCondition<P>> getReconcileCondition() {
     return Optional.ofNullable(reconcileCondition);
   }
 
   public Optional<CleanupCondition> getCleanupCondition() {
     return Optional.ofNullable(cleanupCondition);
   }
 
-  public void setDependsOnRelations(List<DependsOnRelation> dependsOnRelations) {
-    this.dependsOnRelations = dependsOnRelations;
+  public void setDependsOn(List<DependentResourceNode> dependsOn) {
+    this.dependsOn = dependsOn;
   }
 
-  public List<DependsOnRelation> getDependsOnRelations() {
-    return dependsOnRelations;
+  public List<DependentResourceNode> getDependsOn() {
+    return dependsOn;
   }
 
-  public void addDependsOnRelation(DependsOnRelation dependsOnRelation) {
-    dependsOnRelations.add(dependsOnRelation);
+  public void addDependsOnRelation(DependentResourceNode node) {
+    dependsOn.add(node);
   }
 
   @Override
@@ -62,4 +64,24 @@ public String toString() {
         "dependentResource=" + dependentResource +
         '}';
   }
+
+  public DependentResourceNode<R, P> setReconcileCondition(
+      ReconcileCondition<P> reconcileCondition) {
+    this.reconcileCondition = reconcileCondition;
+    return this;
+  }
+
+  public DependentResourceNode<R, P> setCleanupCondition(CleanupCondition cleanupCondition) {
+    this.cleanupCondition = cleanupCondition;
+    return this;
+  }
+
+  public ReadyCondition<R, P> getReadyCondition() {
+    return readyCondition;
+  }
+
+  public DependentResourceNode<R, P> setReadyCondition(ReadyCondition<R, P> readyCondition) {
+    this.readyCondition = readyCondition;
+    return this;
+  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/workflow/DependsOnRelation.java

@@ -1,12 +1,12 @@
 package io.javaoperatorsdk.operator.processing.dependent.workflow;
 
-import io.javaoperatorsdk.operator.processing.dependent.workflow.condition.WaitCondition;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.condition.ReadyCondition;
 
 public class DependsOnRelation {
 
   private DependentResourceNode<?, ?> owner;
   private DependentResourceNode<?, ?> dependsOn;
-  private WaitCondition waitCondition;
+  private ReadyCondition readyCondition;
 
   public DependsOnRelation() {}
 
@@ -16,10 +16,10 @@ public DependsOnRelation(DependentResourceNode<?, ?> owner,
   }
 
   public DependsOnRelation(DependentResourceNode<?, ?> owner, DependentResourceNode<?, ?> dependsOn,
-      WaitCondition waitCondition) {
+      ReadyCondition readyCondition) {
     this.owner = owner;
     this.dependsOn = dependsOn;
-    this.waitCondition = waitCondition;
+    this.readyCondition = readyCondition;
   }
 
   public DependentResourceNode<?, ?> getOwner() {
@@ -30,7 +30,7 @@ public DependsOnRelation(DependentResourceNode<?, ?> owner, DependentResourceNod
     return dependsOn;
   }
 
-  public WaitCondition getWaitCondition() {
-    return waitCondition;
+  public ReadyCondition getWaitCondition() {
+    return readyCondition;
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/workflow/Workflow.java

@@ -56,12 +56,12 @@ public void cleanup(P resource, Context<P> context) {
   private void preprocessForReconcile() {
     dependents = new ConcurrentHashMap<>(dependentResourceNodes.size());
     for (DependentResourceNode<?, ?> node : dependentResourceNodes) {
-      if (node.getDependsOnRelations().isEmpty()) {
+      if (node.getDependsOn().isEmpty()) {
         topLevelResources.add(node);
       } else {
-        for (DependsOnRelation relation : node.getDependsOnRelations()) {
-          dependents.computeIfAbsent(relation.getDependsOn(), dr -> new ArrayList<>());
-          dependents.get(relation.getDependsOn()).add(relation.getOwner());
+        for (DependentResourceNode<?, ?> dependsOn : node.getDependsOn()) {
+          dependents.computeIfAbsent(dependsOn, dr -> new ArrayList<>());
+          dependents.get(dependsOn).add(node);
         }
       }
     }