some smell fixes

Author: csviri

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

@@ -4,34 +4,35 @@
 import java.util.List;
 import java.util.Optional;
 
+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.ReconcileCondition;
 
-public class DependentResourceNode {
+public class DependentResourceNode<R, P extends HasMetadata> {
 
-  private final DependentResource<?, ?> dependentResource;
+  private final DependentResource<R, P> dependentResource;
   private ReconcileCondition reconcileCondition;
   private CleanupCondition cleanupCondition;
   private List<DependsOnRelation> dependsOnRelations = new ArrayList<>(1);
 
-  public DependentResourceNode(DependentResource<?, ?> dependentResource) {
+  public DependentResourceNode(DependentResource<R, P> dependentResource) {
     this(dependentResource, null, null);
   }
 
-  public DependentResourceNode(DependentResource<?, ?> dependentResource,
+  public DependentResourceNode(DependentResource<R, P> dependentResource,
       ReconcileCondition reconcileCondition) {
     this(dependentResource, reconcileCondition, null);
   }
 
-  public DependentResourceNode(DependentResource<?, ?> dependentResource,
+  public DependentResourceNode(DependentResource<R, P> dependentResource,
       ReconcileCondition reconcileCondition, CleanupCondition cleanupCondition) {
     this.dependentResource = dependentResource;
     this.reconcileCondition = reconcileCondition;
     this.cleanupCondition = cleanupCondition;
   }
 
-  public DependentResource getDependentResource() {
+  public DependentResource<R, P> getDependentResource() {
     return dependentResource;
   }
 

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

@@ -4,8 +4,8 @@
 
 public class DependsOnRelation {
 
-  private DependentResourceNode owner;
-  private DependentResourceNode dependsOn;
+  private DependentResourceNode<?, ?> owner;
+  private DependentResourceNode<?, ?> dependsOn;
   private WaitCondition waitCondition;
 
   public DependsOnRelation() {}
@@ -34,7 +34,7 @@ public void setWaitCondition(WaitCondition waitCondition) {
     this.waitCondition = waitCondition;
   }
 
-  public DependentResourceNode getOwner() {
+  public DependentResourceNode<?, ?> getOwner() {
     return owner;
   }
 

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

@@ -16,31 +16,29 @@
  *
  * @param <P> primary resource
  */
-// todo build time graph creation for quarkus
 public class Workflow<P extends HasMetadata> {
 
-  private final List<DependentResourceNode> dependentResourceNodes;
-
-  private List<DependentResourceNode> topLevelResources = new ArrayList<>();
-  private Map<DependentResourceNode, List<DependentResourceNode>> dependents;
+  private final List<DependentResourceNode<?, ?>> dependentResourceNodes;
+  private final List<DependentResourceNode<?, ?>> topLevelResources = new ArrayList<>();
+  private Map<DependentResourceNode<?, ?>, List<DependentResourceNode<?, ?>>> dependents;
 
   // it's "global" executor service shared between multiple reconciliations running parallel
   private ExecutorService executorService;
 
-  public Workflow(List<DependentResourceNode> dependentResourceNodes) {
+  public Workflow(List<DependentResourceNode<?, ?>> dependentResourceNodes) {
     this.executorService = ConfigurationServiceProvider.instance().getExecutorService();
     this.dependentResourceNodes = dependentResourceNodes;
     preprocessForReconcile();
   }
 
-  public Workflow(List<DependentResourceNode> dependentResourceNodes,
+  public Workflow(List<DependentResourceNode<?, ?>> dependentResourceNodes,
       ExecutorService executorService) {
     this.executorService = executorService;
     this.dependentResourceNodes = dependentResourceNodes;
     preprocessForReconcile();
   }
 
-  public Workflow(List<DependentResourceNode> dependentResourceNodes, int globalParallelism) {
+  public Workflow(List<DependentResourceNode<?, ?>> dependentResourceNodes, int globalParallelism) {
     this(dependentResourceNodes, Executors.newFixedThreadPool(globalParallelism));
   }
 
@@ -57,7 +55,7 @@ public void cleanup(P resource, Context<P> context) {
   // add cycle detection?
   private void preprocessForReconcile() {
     dependents = new ConcurrentHashMap<>(dependentResourceNodes.size());
-    for (DependentResourceNode node : dependentResourceNodes) {
+    for (DependentResourceNode<?, ?> node : dependentResourceNodes) {
       if (node.getDependsOnRelations().isEmpty()) {
         topLevelResources.add(node);
       } else {
@@ -73,11 +71,11 @@ public void setExecutorService(ExecutorService executorService) {
     this.executorService = executorService;
   }
 
-  List<DependentResourceNode> getTopLevelDependentResources() {
+  List<DependentResourceNode<?, ?>> getTopLevelDependentResources() {
     return topLevelResources;
   }
 
-  Map<DependentResourceNode, List<DependentResourceNode>> getDependents() {
+  Map<DependentResourceNode<?, ?>, List<DependentResourceNode<?, ?>>> getDependents() {
     return dependents;
   }
 

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

@@ -15,14 +15,16 @@ public class WorkflowReconcileExecutor<P extends HasMetadata> {
   // todo add log messages
   private static final Logger log = LoggerFactory.getLogger(WorkflowReconcileExecutor.class);
 
-  private Workflow<P> workflow;
+  private final Workflow<P> workflow;
 
-  private Set<DependentResourceNode> alreadyReconciled = ConcurrentHashMap.newKeySet();
-  private Set<Future<?>> actualExecutions = ConcurrentHashMap.newKeySet();
-  private Map<DependentResourceNode, Future<?>> nodeToFuture = new ConcurrentHashMap<>();
-  private List<Exception> exceptionsDuringExecution =
+  private final Set<DependentResourceNode<?, ?>> alreadyReconciled = ConcurrentHashMap.newKeySet();
+  private final Set<Future<?>> actualExecutions = ConcurrentHashMap.newKeySet();
+  private final Map<DependentResourceNode<?, ?>, Future<?>> nodeToFuture =
+      new ConcurrentHashMap<>();
+  private final List<Exception> exceptionsDuringExecution =
       Collections.synchronizedList(new ArrayList<>());
-  private Set<DependentResourceNode> markedToReconcileAgain = ConcurrentHashMap.newKeySet();
+  private final Set<DependentResourceNode<?, ?>> markedToReconcileAgain =
+      ConcurrentHashMap.newKeySet();
 
   private final P primary;
   private final Context<P> context;
@@ -34,13 +36,15 @@ public WorkflowReconcileExecutor(Workflow<P> workflow, P primary, Context<P> con
   }
 
   public synchronized void reconcile() {
-    for (DependentResourceNode dependentResourceNode : workflow.getTopLevelDependentResources()) {
+    for (DependentResourceNode<?, ?> dependentResourceNode : workflow
+        .getTopLevelDependentResources()) {
       submitForReconcile(dependentResourceNode);
     }
     while (true) {
       try {
         this.wait();
         if (exceptionsPresent()) {
+          log.debug("Exception during re");
           throw createFinalException();
         }
         if (noMoreExecutionsScheduled()) {
@@ -59,11 +63,13 @@ private AggregatedOperatorException createFinalException() {
     return new AggregatedOperatorException("Exception during workflow.", exceptionsDuringExecution);
   }
 
-  private synchronized boolean alreadyReconciled(DependentResourceNode dependentResourceNode) {
+  private synchronized boolean alreadyReconciled(
+      DependentResourceNode<?, ?> dependentResourceNode) {
     return alreadyReconciled.contains(dependentResourceNode);
   }
 
-  private synchronized boolean allDependOnsReconciled(DependentResourceNode dependentResourceNode) {
+  private synchronized boolean allDependOnsReconciled(
+      DependentResourceNode<?, ?> dependentResourceNode) {
     return dependentResourceNode.getDependsOnRelations().isEmpty()
         || dependentResourceNode.getDependsOnRelations().stream()
             .allMatch(relation -> alreadyReconciled(relation.getDependsOn()));
@@ -96,7 +102,7 @@ && alreadyReconciled(dependentResourceNode)) {
     }
   }
 
-  private synchronized void submitForReconcile(DependentResourceNode dependentResourceNode) {
+  private synchronized void submitForReconcile(DependentResourceNode<?, ?> dependentResourceNode) {
     log.debug("Submitting for reconcile: {}", dependentResourceNode);
 
     if (alreadyReconciled(dependentResourceNode)
@@ -113,15 +119,14 @@ private synchronized void submitForReconcile(DependentResourceNode dependentReso
       return;
     }
 
-
     Future<?> nodeFuture =
         workflow.getExecutorService().submit(new NodeExecutor(dependentResourceNode));
     actualExecutions.add(nodeFuture);
     nodeToFuture.put(dependentResourceNode, nodeFuture);
     log.debug("Submitted to reconcile: {}", dependentResourceNode);
   }
 
-  private synchronized void submitDependents(DependentResourceNode dependentResourceNode) {
+  private synchronized void submitDependents(DependentResourceNode<?, ?> dependentResourceNode) {
     if (!exceptionsPresent()) {
       var dependents = workflow.getDependents().get(dependentResourceNode);
       if (dependents != null) {
@@ -151,7 +156,7 @@ private class NodeExecutor implements Runnable {
 
     private final DependentResourceNode dependentResourceNode;
 
-    private NodeExecutor(DependentResourceNode dependentResourceNode) {
+    private NodeExecutor(DependentResourceNode<?, ?> dependentResourceNode) {
       this.dependentResourceNode = dependentResourceNode;
     }
 

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

@@ -12,7 +12,7 @@
 
 public class WorkflowBuilder<P extends HasMetadata> {
 
-  private List<DependentResourceNode> dependentResourceNodes = new ArrayList<>();
+  private List<DependentResourceNode<?, ?>> dependentResourceNodes = new ArrayList<>();
 
   public DependentBuilder<P> addDependent(DependentResource dependentResource) {
     DependentResourceNode node = new DependentResourceNode(dependentResource);