feat: add getDependentConditionResult method and document it

Signed-off-by: Chris Laprun <[email protected]>

Author: metacosm

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

@@ -120,7 +120,7 @@ protected boolean isNotReady(DependentResourceNode<?, P> dependentResourceNode)
   }
 
   protected boolean isInError(DependentResourceNode<?, P> dependentResourceNode) {
-   return getResultFlagFor(dependentResourceNode, WorkflowResult.DetailBuilder::hasError);
+    return getResultFlagFor(dependentResourceNode, WorkflowResult.DetailBuilder::hasError);
   }
 
   protected synchronized void handleNodeExecutionFinish(

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

@@ -7,6 +7,8 @@
 
 @SuppressWarnings("rawtypes")
 public class WorkflowCleanupResult extends WorkflowResult {
+  private Boolean allPostConditionsMet;
+
   WorkflowCleanupResult(Map<DependentResource, Detail<?>> results) {
     super(results);
   }
@@ -20,6 +22,9 @@ public List<DependentResource> getPostConditionNotMetDependents() {
   }
 
   public boolean allPostConditionsMet() {
-    return getPostConditionNotMetDependents().isEmpty();
+    if (allPostConditionsMet == null) {
+      allPostConditionsMet = getPostConditionNotMetDependents().isEmpty();
+    }
+    return allPostConditionsMet;
   }
 }

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

@@ -8,6 +8,7 @@
 
 @SuppressWarnings("rawtypes")
 public class WorkflowReconcileResult extends WorkflowResult {
+  private Boolean allDependentsReady;
 
   WorkflowReconcileResult(Map<DependentResource, Detail<?>> results) {
     super(results);
@@ -21,23 +22,15 @@ public List<DependentResource> getNotReadyDependents() {
     return listFilteredBy(detail -> !detail.isConditionWithTypeMet(Condition.Type.READY));
   }
 
-  public <T> T getNotReadyDependentResult(DependentResource dependentResource,
+  public <T> Optional<T> getNotReadyDependentResult(DependentResource dependentResource,
       Class<T> expectedResultType) {
-    final var result = new Object[1];
-    try {
-      return Optional.ofNullable(results().get(dependentResource))
-          .flatMap(detail -> detail.getResultForConditionWithType(Condition.Type.READY))
-          .map(r -> result[0] = r.getResult())
-          .map(expectedResultType::cast)
-          .orElse(null);
-    } catch (Exception e) {
-      throw new IllegalArgumentException("Condition result " + result[0] +
-          " for Dependent " + dependentResource.name() + " doesn't match expected type "
-          + expectedResultType.getSimpleName(), e);
-    }
+    return getDependentConditionResult(dependentResource, Condition.Type.READY, expectedResultType);
   }
 
   public boolean allDependentResourcesReady() {
-    return getNotReadyDependents().isEmpty();
+    if (allDependentsReady == null) {
+      allDependentsReady = getNotReadyDependents().isEmpty();
+    }
+    return allDependentsReady;
   }
 }

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

@@ -34,6 +34,34 @@ protected Map<DependentResource, Detail<?>> results() {
     return results;
   }
 
+  /**
+   * Retrieves the optional result of the condition with the specified type for the specified
+   * dependent resource.
+   *
+   * @param <T> the expected result type of the condition
+   * @param dependentResource the dependent resource for which we want to retrieve a condition
+   *        result
+   * @param conditionType the condition type which result we're interested in
+   * @param expectedResultType the expected result type of the condition
+   * @return the dependent condition result if it exists or {@link Optional#empty()} otherwise
+   * @throws IllegalArgumentException if a result exists but is not of the expected type
+   */
+  public <T> Optional<T> getDependentConditionResult(DependentResource dependentResource,
+      Condition.Type conditionType, Class<T> expectedResultType) {
+    final var result = new Object[1];
+    try {
+      return Optional.ofNullable(results().get(dependentResource))
+          .flatMap(detail -> detail.getResultForConditionWithType(conditionType))
+          .map(r -> result[0] = r.getResult())
+          .map(expectedResultType::cast);
+    } catch (Exception e) {
+      throw new IllegalArgumentException("Condition " +
+          "result " + result[0] +
+          " for Dependent " + dependentResource.name() + " doesn't match expected type "
+          + expectedResultType.getSimpleName(), e);
+    }
+  }
+
   protected List<DependentResource> listFilteredBy(
       Function<Detail, Boolean> filter) {
     return results.entrySet().stream()
@@ -71,16 +99,20 @@ static class DetailBuilder<R> {
 
     Detail<R> build() {
       return new Detail<>(error, reconcileResult, activationConditionResult,
-          deletePostconditionResult, readyPostconditionResult, reconcilePostconditionResult, deleted, visited, markedForDelete);
+          deletePostconditionResult, readyPostconditionResult, reconcilePostconditionResult,
+          deleted, visited, markedForDelete);
     }
 
-    DetailBuilder<R> withResultForCondition(DependentResourceNode.ConditionWithType conditionWithType, ResultCondition.Result conditionResult) {
+    DetailBuilder<R> withResultForCondition(
+        DependentResourceNode.ConditionWithType conditionWithType,
+        ResultCondition.Result conditionResult) {
       switch (conditionWithType.type()) {
         case ACTIVATION -> activationConditionResult = conditionResult;
         case DELETE -> deletePostconditionResult = conditionResult;
         case READY -> readyPostconditionResult = conditionResult;
         case RECONCILE -> reconcilePostconditionResult = conditionResult;
-        default -> throw new IllegalStateException("Unexpected condition type: " + conditionWithType);
+        default ->
+          throw new IllegalStateException("Unexpected condition type: " + conditionWithType);
       }
       return this;
     }
@@ -137,13 +169,15 @@ record Detail<R>(Exception error, ReconcileResult<R> reconcileResult,
       ResultCondition.Result deletePostconditionResult,
       ResultCondition.Result readyPostconditionResult,
       ResultCondition.Result reconcilePostconditionResult,
-                   boolean deleted, boolean visited, boolean markedForDelete) {
+      boolean deleted, boolean visited, boolean markedForDelete) {
 
     boolean isConditionWithTypeMet(Condition.Type conditionType) {
-      return getResultForConditionWithType(conditionType).map(ResultCondition.Result::isSuccess).orElse(true);
+      return getResultForConditionWithType(conditionType).map(ResultCondition.Result::isSuccess)
+          .orElse(true);
     }
 
-    Optional<ResultCondition.Result<?>> getResultForConditionWithType(Condition.Type conditionType) {
+    Optional<ResultCondition.Result<?>> getResultForConditionWithType(
+        Condition.Type conditionType) {
       return switch (conditionType) {
         case ACTIVATION -> Optional.ofNullable(activationConditionResult);
         case DELETE -> Optional.ofNullable(deletePostconditionResult);

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

@@ -604,7 +604,8 @@ public boolean isSuccess() {
         .build();
 
     final var reconcileResult = workflow.reconcile(new TestCustomResource(), mockContext);
-    assertEquals(result, reconcileResult.getNotReadyDependentResult(dr1, Integer.class));
+    assertEquals(result,
+        reconcileResult.getNotReadyDependentResult(dr1, Integer.class).orElseThrow());
   }
 
   @Test
@@ -643,13 +644,13 @@ public boolean isSuccess() {
   }
 
   @Test
-  void shouldReturnNullIfNoConditionResultExists() {
+  void shouldReturnEmptyIfNoConditionResultExists() {
     var workflow = new WorkflowBuilder<TestCustomResource>()
         .addDependentResource(dr1)
         .withReadyPostcondition(notMetCondition)
         .build();
 
     final var reconcileResult = workflow.reconcile(new TestCustomResource(), mockContext);
-    assertNull(reconcileResult.getNotReadyDependentResult(dr1, Integer.class));
+    assertTrue(reconcileResult.getNotReadyDependentResult(dr1, Integer.class).isEmpty());
   }
 }