feat: explicit workflow invocation

Signed-off-by: Attila Mészáros <[email protected]>

Author: csviri

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/BaseConfigurationService.java

@@ -169,7 +169,7 @@ protected <P extends HasMetadata> ControllerConfiguration<P> configFor(Reconcile
         io.javaoperatorsdk.operator.api.reconciler.Workflow.class);
     if (workflowAnnotation != null) {
       List<DependentResourceSpec> specs = dependentResources(workflowAnnotation, config);
-      WorkflowSpec workflowSpec = new WorkflowSpec(specs);
+      WorkflowSpec workflowSpec = new WorkflowSpec(specs, workflowAnnotation.explicitInvocation());
       config.setWorkflowSpec(workflowSpec);
     }
 

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/workflow/WorkflowSpec.java

@@ -8,12 +8,19 @@ public class WorkflowSpec {
 
   @SuppressWarnings("rawtypes")
   private final List<DependentResourceSpec> dependentResourceSpecs;
+  private final boolean explicitInvocation;
 
-  public WorkflowSpec(List<DependentResourceSpec> dependentResourceSpecs) {
+  public WorkflowSpec(List<DependentResourceSpec> dependentResourceSpecs,
+      boolean explicitInvocation) {
     this.dependentResourceSpecs = dependentResourceSpecs;
+    this.explicitInvocation = explicitInvocation;
   }
 
   public List<DependentResourceSpec> getDependentResourceSpecs() {
     return dependentResourceSpecs;
   }
+
+  public boolean isExplicitInvocation() {
+    return explicitInvocation;
+  }
 }

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/DefaultContext.java

@@ -21,14 +21,15 @@ public class DefaultContext<P extends HasMetadata> implements Context<P> {
   private final Controller<P> controller;
   private final P primaryResource;
   private final ControllerConfiguration<P> controllerConfiguration;
-  private final DefaultManagedDependentResourceContext defaultManagedDependentResourceContext;
+  private final DefaultManagedDependentResourceContext<P> defaultManagedDependentResourceContext;
 
   public DefaultContext(RetryInfo retryInfo, Controller<P> controller, P primaryResource) {
     this.retryInfo = retryInfo;
     this.controller = controller;
     this.primaryResource = primaryResource;
     this.controllerConfiguration = controller.getConfiguration();
-    this.defaultManagedDependentResourceContext = new DefaultManagedDependentResourceContext();
+    this.defaultManagedDependentResourceContext =
+        new DefaultManagedDependentResourceContext<>(controller, primaryResource, this);
   }
 
   @Override

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Workflow.java

@@ -2,6 +2,7 @@
 
 import java.lang.annotation.*;
 
+import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Dependent;
 
 @Inherited
@@ -11,4 +12,12 @@
 
   Dependent[] dependents();
 
+  // todo maybe better naming? "explicitReconciliation" ?
+  /**
+   * If true, managed workflow should be explicitly invoked within the reconciler implementation. If
+   * false workflow is invoked just before the {@link Reconciler#reconcile(HasMetadata, Context)}
+   * method.
+   */
+  boolean explicitInvocation() default false;
+
 }

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/dependent/managed/DefaultManagedDependentResourceContext.java

@@ -3,15 +3,30 @@
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.processing.Controller;
 import io.javaoperatorsdk.operator.processing.dependent.workflow.WorkflowCleanupResult;
 import io.javaoperatorsdk.operator.processing.dependent.workflow.WorkflowReconcileResult;
 
 @SuppressWarnings("rawtypes")
-public class DefaultManagedDependentResourceContext implements ManagedDependentResourceContext {
+public class DefaultManagedDependentResourceContext<P extends HasMetadata>
+    implements ManagedDependentResourceContext {
 
+  private final ConcurrentHashMap attributes = new ConcurrentHashMap();
+  private final Controller<P> controller;
+  private final P primaryResource;
+  private final Context<P> context;
   private WorkflowReconcileResult workflowReconcileResult;
   private WorkflowCleanupResult workflowCleanupResult;
-  private final ConcurrentHashMap attributes = new ConcurrentHashMap();
+
+  public DefaultManagedDependentResourceContext(Controller<P> controller,
+      P primaryResource,
+      Context<P> context) {
+    this.controller = controller;
+    this.primaryResource = primaryResource;
+    this.context = context;
+  }
 
   @Override
   public <T> Optional<T> get(Object key, Class<T> expectedType) {
@@ -58,4 +73,10 @@ public WorkflowReconcileResult getWorkflowReconcileResult() {
   public WorkflowCleanupResult getWorkflowCleanupResult() {
     return workflowCleanupResult;
   }
+
+  @Override
+  public void invokeWorkflow() {
+    controller.invokeManagedWorkflow(primaryResource, context);
+  }
+
 }

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/dependent/managed/ManagedDependentResourceContext.java

@@ -55,4 +55,7 @@ public interface ManagedDependentResourceContext {
   WorkflowReconcileResult getWorkflowReconcileResult();
 
   WorkflowCleanupResult getWorkflowCleanupResult();
+
+  void invokeWorkflow();
+
 }

Diff for: operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/Controller.java

@@ -130,12 +130,11 @@ public Map<String, Object> metadata() {
           @Override
           public UpdateControl<P> execute() throws Exception {
             initContextIfNeeded(resource, context);
-            if (!managedWorkflow.isEmpty()) {
-              var res = managedWorkflow.reconcile(resource, context);
-              ((DefaultManagedDependentResourceContext) context.managedDependentResourceContext())
-                  .setWorkflowExecutionResult(res);
-              res.throwAggregateExceptionIfErrorsPresent();
-            }
+            configuration.getWorkflowSpec().ifPresent(ws -> {
+              if (!ws.isExplicitInvocation()) {
+                invokeManagedWorkflow(resource, context);
+              }
+            });
             return reconciler.reconcile(resource, context);
           }
         });
@@ -429,4 +428,13 @@ public ExecutorServiceManager getExecutorServiceManager() {
   public EventSourceContext<P> eventSourceContext() {
     return eventSourceContext;
   }
+
+  public void invokeManagedWorkflow(P primary, Context<P> context) {
+    if (!managedWorkflow.isEmpty()) {
+      var res = managedWorkflow.reconcile(primary, context);
+      ((DefaultManagedDependentResourceContext) context.managedDependentResourceContext())
+          .setWorkflowExecutionResult(res);
+      res.throwAggregateExceptionIfErrorsPresent();
+    }
+  }
 }

Diff for: operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/dependent/workflow/ManagedWorkflowTest.java

@@ -64,7 +64,7 @@ ManagedWorkflow managedWorkflow(DependentResourceSpec... specs) {
     final var configuration = mock(ControllerConfiguration.class);
     final var specList = List.of(specs);
 
-    var ws = new WorkflowSpec(specList);
+    var ws = new WorkflowSpec(specList, false);
     when(configuration.getWorkflowSpec()).thenReturn(Optional.of(ws));
 
     return new BaseConfigurationService().getWorkflowFactory()