test refactor, bottom resources

Author: csviri

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

@@ -1,8 +1,6 @@
 package io.javaoperatorsdk.operator.processing.dependent.workflow;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -18,42 +16,46 @@
  */
 public class Workflow<P extends HasMetadata> {
 
-  private final List<DependentResourceNode<?, P>> dependentResourceNodes;
-  private final List<DependentResourceNode<?, P>> topLevelResources = new ArrayList<>();
+  private final Set<DependentResourceNode<?, P>> dependentResourceNodes;
+  private final Set<DependentResourceNode<?, P>> topLevelResources = new HashSet<>();
+  private final Set<DependentResourceNode<?, P>> bottomLevelResource = new HashSet<>();
   private Map<DependentResourceNode<?, P>, List<DependentResourceNode<?, P>>> dependents;
 
   // it's "global" executor service shared between multiple reconciliations running parallel
   private ExecutorService executorService;
 
-  public Workflow(List<DependentResourceNode<?, P>> dependentResourceNodes) {
+  public Workflow(Set<DependentResourceNode<?, P>> dependentResourceNodes) {
     this.executorService = ConfigurationServiceProvider.instance().getExecutorService();
     this.dependentResourceNodes = dependentResourceNodes;
     preprocessForReconcile();
   }
 
-  public Workflow(List<DependentResourceNode<?, P>> dependentResourceNodes,
+  public Workflow(Set<DependentResourceNode<?, P>> dependentResourceNodes,
       ExecutorService executorService) {
     this.executorService = executorService;
     this.dependentResourceNodes = dependentResourceNodes;
     preprocessForReconcile();
   }
 
-  public Workflow(List<DependentResourceNode<?, P>> dependentResourceNodes, int globalParallelism) {
+  public Workflow(Set<DependentResourceNode<?, P>> dependentResourceNodes, int globalParallelism) {
     this(dependentResourceNodes, Executors.newFixedThreadPool(globalParallelism));
   }
 
   public WorkflowExecutionResult reconcile(P primary, Context<P> context) {
-    WorkflowReconcileExecutor workflowReconcileExecutor =
+    WorkflowReconcileExecutor<P> workflowReconcileExecutor =
         new WorkflowReconcileExecutor<>(this, primary, context);
     return workflowReconcileExecutor.reconcile();
   }
 
-  public void cleanup(P resource, Context<P> context) {
-
+  public WorkflowCleanupResult cleanup(P primary, Context<P> context) {
+    WorkflowCleanupExecutor<P> workflowCleanupExecutor =
+        new WorkflowCleanupExecutor<>(this, primary, context);
+    return workflowCleanupExecutor.cleanup();
   }
 
   // add cycle detection?
   private void preprocessForReconcile() {
+    bottomLevelResource.addAll(dependentResourceNodes);
     dependents = new ConcurrentHashMap<>(dependentResourceNodes.size());
     for (DependentResourceNode<?, P> node : dependentResourceNodes) {
       if (node.getDependsOn().isEmpty()) {
@@ -62,6 +64,7 @@ private void preprocessForReconcile() {
         for (DependentResourceNode<?, P> dependsOn : node.getDependsOn()) {
           dependents.computeIfAbsent(dependsOn, dr -> new ArrayList<>());
           dependents.get(dependsOn).add(node);
+          bottomLevelResource.remove(dependsOn);
         }
       }
     }
@@ -71,10 +74,14 @@ public void setExecutorService(ExecutorService executorService) {
     this.executorService = executorService;
   }
 
-  List<DependentResourceNode<?, P>> getTopLevelDependentResources() {
+  Set<DependentResourceNode<?, P>> getTopLevelDependentResources() {
     return topLevelResources;
   }
 
+  Set<DependentResourceNode<?, P>> getBottomLevelResource() {
+    return bottomLevelResource;
+  }
+
   Map<DependentResourceNode<?, P>, List<DependentResourceNode<?, P>>> getDependents() {
     return dependents;
   }

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

@@ -0,0 +1,29 @@
+package io.javaoperatorsdk.operator.processing.dependent.workflow;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+
+public class WorkflowCleanupExecutor<P extends HasMetadata> {
+
+  private static final Logger log = LoggerFactory.getLogger(WorkflowReconcileExecutor.class);
+
+  private final Workflow<P> workflow;
+  private final P primary;
+  private final Context<P> context;
+
+  public WorkflowCleanupExecutor(Workflow<P> workflow, P primary, Context<P> context) {
+    this.workflow = workflow;
+    this.primary = primary;
+    this.context = context;
+  }
+
+
+  public WorkflowCleanupResult cleanup() {
+
+    return null;
+  }
+
+}

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

@@ -0,0 +1,4 @@
+package io.javaoperatorsdk.operator.processing.dependent.workflow;
+
+public class WorkflowCleanupResult {
+}

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

@@ -106,6 +106,7 @@ private synchronized void handleNodeExecutionFinish(DependentResourceNode depend
 
   // needs to be synced
   private synchronized void updateStatusForNotReady(ReadyCondition<?, P> readyCondition) {
+    // todo think through this, since more can't be not ready
     readyCondition.addNotReadyStatusInfo(primary);
   }
 

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

@@ -1,7 +1,7 @@
 package io.javaoperatorsdk.operator.processing.dependent.workflow.builder;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.concurrent.ExecutorService;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
@@ -12,7 +12,7 @@
 
 public class WorkflowBuilder<P extends HasMetadata> {
 
-  private List<DependentResourceNode<?, P>> dependentResourceNodes = new ArrayList<>();
+  private Set<DependentResourceNode<?, P>> dependentResourceNodes = new HashSet<>();
 
   public DependentBuilder<P> addDependent(DependentResource<?, P> dependentResource) {
     DependentResourceNode<?, P> node = new DependentResourceNode<>(dependentResource);