refactor: remove unneeded DependentResourceNode interface

Author: metacosm

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

@@ -82,6 +82,6 @@ public Workflow<P> resolve(KubernetesClient client,
   private DependentResourceNode createDRN(
       KubernetesClient client, ControllerConfiguration<P> configuration,
       SpecDependentResourceNode spec) {
-    return new DefaultDependentResourceNode(spec.resolve(client, configuration));
+    return new DependentResourceNode(spec.resolve(client, configuration));
   }
 }

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

@@ -1,25 +1,117 @@
 package io.javaoperatorsdk.operator.processing.dependent.workflow;
 
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
 
 @SuppressWarnings("rawtypes")
-public interface DependentResourceNode<R, P extends HasMetadata> {
+public class DependentResourceNode<R, P extends HasMetadata> {
 
-  Optional<Condition<R, P>> getReconcilePrecondition();
+  private final List<DependentResourceNode> dependsOn = new LinkedList<>();
+  private final List<DependentResourceNode> parents = new LinkedList<>();
+  private final String name;
+  private Condition<R, P> reconcilePrecondition;
+  private Condition<R, P> deletePostcondition;
+  private Condition<R, P> readyPostcondition;
+  private DependentResource<R, P> dependentResource;
 
-  Optional<Condition<R, P>> getDeletePostcondition();
+  public List<? extends DependentResourceNode> getDependsOn() {
+    return dependsOn;
+  }
 
-  List<? extends DependentResourceNode> getDependsOn();
+  void addParent(DependentResourceNode parent) {
+    parents.add(parent);
+  }
 
-  Optional<Condition<R, P>> getReadyPostcondition();
 
-  List<? extends DependentResourceNode> getParents();
+  void addDependsOnRelation(DependentResourceNode node) {
+    node.addParent(this);
+    dependsOn.add(node);
+  }
 
-  String getName();
+  public List<DependentResourceNode> getParents() {
+    return parents;
+  }
 
-  DependentResource<R, P> getDependentResource();
+  public String getName() {
+    return name;
+  }
+
+
+  public Optional<Condition<R, P>> getReconcilePrecondition() {
+    return Optional.ofNullable(reconcilePrecondition);
+  }
+
+
+  public Optional<Condition<R, P>> getDeletePostcondition() {
+    return Optional.ofNullable(deletePostcondition);
+  }
+
+  void setReconcilePrecondition(Condition<R, P> reconcilePrecondition) {
+    this.reconcilePrecondition = reconcilePrecondition;
+  }
+
+  void setDeletePostcondition(Condition<R, P> cleanupCondition) {
+    this.deletePostcondition = cleanupCondition;
+  }
+
+  public Optional<Condition<R, P>> getReadyPostcondition() {
+    return Optional.ofNullable(readyPostcondition);
+  }
+
+  void setReadyPostcondition(Condition<R, P> readyPostcondition) {
+    this.readyPostcondition = readyPostcondition;
+  }
+
+  public DependentResource<R, P> getDependentResource() {
+    return dependentResource;
+  }
+
+  public void setDependentResource(DependentResource<R, P> dependentResource) {
+    this.dependentResource = dependentResource;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    DependentResourceNode<?, ?> that = (DependentResourceNode<?, ?>) o;
+    return name.equals(that.name);
+  }
+
+  @Override
+  public int hashCode() {
+    return name.hashCode();
+  }
+
+
+  public DependentResourceNode(DependentResource<R, P> dependentResource) {
+    this(dependentResource, null, null);
+  }
+
+  public DependentResourceNode(DependentResource<R, P> dependentResource,
+      Condition<R, P> reconcilePrecondition, Condition<R, P> deletePostcondition) {
+    this.name = getNameFor(dependentResource);
+    setDependentResource(dependentResource);
+    setReconcilePrecondition(reconcilePrecondition);
+    setDeletePostcondition(deletePostcondition);
+  }
+
+  @SuppressWarnings("rawtypes")
+  static String getNameFor(DependentResource dependentResource) {
+    return DependentResource.defaultNameFor(dependentResource.getClass()) + "#"
+        + dependentResource.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return "DependentResourceNode{" + getDependentResource() + '}';
+  }
 }

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

@@ -17,14 +17,14 @@
 @SuppressWarnings({"rawtypes", "unchecked"})
 public class WorkflowBuilder<P extends HasMetadata> {
 
-  private final Map<String, DefaultDependentResourceNode<?, P>> dependentResourceNodes =
+  private final Map<String, DependentResourceNode<?, P>> dependentResourceNodes =
       new HashMap<>();
   private boolean throwExceptionAutomatically = THROW_EXCEPTION_AUTOMATICALLY_DEFAULT;
-  private DefaultDependentResourceNode currentNode;
+  private DependentResourceNode currentNode;
   private boolean isCleaner = false;
 
   public WorkflowBuilder<P> addDependentResource(DependentResource dependentResource) {
-    currentNode = new DefaultDependentResourceNode<>(dependentResource);
+    currentNode = new DependentResourceNode<>(dependentResource);
     isCleaner = dependentResource.isDeletable();
     final var name = currentNode.getName();
     dependentResourceNodes.put(name, currentNode);
@@ -61,11 +61,11 @@ public WorkflowBuilder<P> withDeletePostcondition(Condition deletePostcondition)
     return this;
   }
 
-  DefaultDependentResourceNode getNodeByDependentResource(
+  DependentResourceNode getNodeByDependentResource(
       DependentResource<?, ?> dependentResource) {
     // first check by name
     final var node =
-        dependentResourceNodes.get(DefaultDependentResourceNode.getNameFor(dependentResource));
+        dependentResourceNodes.get(DependentResourceNode.getNameFor(dependentResource));
     if (node != null) {
       return node;
     } else {