wip

Author: csviri

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

@@ -11,8 +11,8 @@
 public class DependentResourceNode {
 
   private final DependentResource<?, ?> dependentResource;
-  private final ReconcileCondition reconcileCondition;
-  private final CleanupCondition cleanupCondition;
+  private ReconcileCondition reconcileCondition;
+  private CleanupCondition cleanupCondition;
   private List<DependsOnRelation> dependsOnRelations = new ArrayList<>(1);
 
   public DependentResourceNode(DependentResource<?, ?> dependentResource) {
@@ -51,6 +51,10 @@ public List<DependsOnRelation> getDependsOnRelations() {
     return dependsOnRelations;
   }
 
+  public void addDependsOnRelation(DependsOnRelation dependsOnRelation) {
+    dependsOnRelations.add(dependsOnRelation);
+  }
+
   @Override
   public String toString() {
     return "DependentResourceNode{" +

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

@@ -10,6 +10,10 @@ public class DependsOnRelation {
 
   public DependsOnRelation() {}
 
+  public DependsOnRelation(DependentResourceNode owner, DependentResourceNode dependsOn) {
+    this(owner, dependsOn, null);
+  }
+
   public DependsOnRelation(DependentResourceNode owner, DependentResourceNode dependsOn,
       WaitCondition waitCondition) {
     this.owner = owner;

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

@@ -32,16 +32,18 @@ public Workflow(List<DependentResourceNode> dependentResourceNodes, int globalPa
   }
 
   public void reconcile(P primary, Context<P> context) {
-
+    WorkflowReconcileExecutor<P> workflowReconcileExecutor =
+        new WorkflowReconcileExecutor<>(this, primary, context);
+    workflowReconcileExecutor.reconcile();
   }
 
   public void cleanup(P resource, Context<P> context) {
 
   }
 
+  // add cycle detection?
   private void preprocessForReconcile() {
     reverseDependsOn = new ConcurrentHashMap<>(dependentResourceNodes.size());
-
     for (DependentResourceNode node : dependentResourceNodes) {
       if (node.getDependsOnRelations().isEmpty()) {
         topLevelResources.add(node);

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

@@ -69,7 +69,7 @@ private synchronized void handleNodeExecutionFinish(DependentResourceNode depend
 
     var future = nodeToFuture.remove(dependentResourceNode);
     actualExecutions.remove(future);
-    
+
     if (exceptionsPresent()) {
       if (actualExecutions.isEmpty()) {
         notifyMainReconcile();

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

@@ -0,0 +1,23 @@
+package io.javaoperatorsdk.operator.processing.dependent.workflow.builder;
+
+import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.DependentResourceNode;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.DependsOnRelation;
+
+public class DependentBuilder {
+
+  private final WorkflowBuilder workflowBuilder;
+  private final DependentResourceNode node;
+
+  public DependentBuilder(WorkflowBuilder workflowBuilder, DependentResourceNode node) {
+    this.workflowBuilder = workflowBuilder;
+    this.node = node;
+  }
+
+  public DependentBuilder dependsOn(DependentResource<?, ?> dependentResource) {
+    var dependsOn = workflowBuilder.getNodeByDependentResource(dependentResource);
+    node.addDependsOnRelation(new DependsOnRelation(node, dependsOn, null));
+    return this;
+  }
+
+}

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

@@ -0,0 +1,45 @@
+package io.javaoperatorsdk.operator.processing.dependent.workflow.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.DependentResourceNode;
+import io.javaoperatorsdk.operator.processing.dependent.workflow.Workflow;
+
+public class WorkflowBuilder<P extends HasMetadata> {
+
+  private List<DependentResourceNode> dependentResourceNodes = new ArrayList<>();
+
+  public DependentBuilder addDependent(DependentResource<?, ?> dependentResource) {
+    DependentResourceNode node = new DependentResourceNode(dependentResource);
+    dependentResourceNodes.add(node);
+    return new DependentBuilder(this, node);
+  }
+
+  void addDependentResourceNode(DependentResourceNode node) {
+    dependentResourceNodes.add(node);
+  }
+
+  DependentResourceNode getNodeByDependentResource(DependentResource<?, ?> dependentResource) {
+    return dependentResourceNodes.stream()
+        .filter(dr -> dr.getDependentResource() == dependentResource)
+        .findFirst()
+        .orElseThrow();
+  }
+
+  public Workflow<P> build() {
+    return new Workflow<>(dependentResourceNodes, Executors.newCachedThreadPool());
+  }
+
+  public Workflow<P> build(int parallelism) {
+    return new Workflow<>(dependentResourceNodes, parallelism);
+  }
+
+  public Workflow<P> build(ExecutorService executorService) {
+    return new Workflow<>(dependentResourceNodes, executorService);
+  }
+}

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/dependent/workflow/WorkflowTest.java

@@ -0,0 +1,29 @@
+package io.javaoperatorsdk.operator.processing.dependent.workflow;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class WorkflowTest {
+
+  @Test
+  void reconcileTopLevelResources() {
+
+  }
+
+  @Test
+  void reconciliationWithSimpleDependsOn() {
+
+  }
+
+  @Test
+  void reconciliationWithTheDependsOns() {
+
+  }
+
+  @Test
+  void diamondShareWorkflowReconcile() {
+
+  }
+
+}