[Fix #1611] Allow reloading by checking when application is created

Signed-off-by: Francisco Javier Tirado Sarti <ftirados@ibm.com>

Author: fjtirado

impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowApplication.java

@@ -114,6 +114,7 @@ public class WorkflowApplication implements AutoCloseable {
   private final WorkflowLifeCycleCloudEventFactory lifeCycleCloudEventFactory;
   private final ScheduledExecutorService schedulerExecutorService;
   private final Set<String> allowedCommands;
+  private final Map<Class<?>, List<?>> serviceLoadedClasses = new ConcurrentHashMap<>();
 
   private WorkflowApplication(Builder builder) {
     this.taskFactory = builder.taskFactory;
@@ -708,4 +709,16 @@ public WorkflowLifeCycleCloudEventFactory lifeCycleCloudEventFactory() {
   public Set<String> allowedCommands() {
     return allowedCommands;
   }
+
+  @SuppressWarnings("unchecked")
+  public <T> List<T> getServiceLoadedClasses(Class<T> clazz) {
+    return (List<T>)
+        serviceLoadedClasses.computeIfAbsent(
+            clazz,
+            c ->
+                ServiceLoader.load(clazz).stream()
+                    .map(ServiceLoader.Provider::get)
+                    .sorted()
+                    .toList());
+  }
 }

impl/core/src/main/java/io/serverlessworkflow/impl/auth/CommonOAuthProvider.java

@@ -16,13 +16,13 @@
 package io.serverlessworkflow.impl.auth;
 
 import static io.serverlessworkflow.impl.WorkflowUtils.checkSecret;
-import static io.serverlessworkflow.impl.WorkflowUtils.loadFirst;
 import static io.serverlessworkflow.impl.WorkflowUtils.secret;
 
 import io.serverlessworkflow.api.types.OAuth2AuthenticationData;
 import io.serverlessworkflow.api.types.SecretBasedAuthenticationPolicy;
 import io.serverlessworkflow.api.types.Workflow;
 import io.serverlessworkflow.impl.TaskContext;
+import io.serverlessworkflow.impl.WorkflowApplication;
 import io.serverlessworkflow.impl.WorkflowContext;
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowValueResolver;
@@ -35,14 +35,6 @@ public abstract class CommonOAuthProvider implements AuthProvider {
 
   private final WorkflowValueResolver<AccessTokenProvider> tokenProvider;
 
-  private static JWTConverter jwtConverter =
-      loadFirst(JWTConverter.class)
-          .orElseThrow(() -> new IllegalStateException("No JWTConverter implementation found"));
-
-  private static AccessTokenProviderFactory accessTokenProviderFactory =
-      loadFirst(AccessTokenProviderFactory.class)
-          .orElseThrow(() -> new IllegalStateException("No JWTConverter implementation found"));
-
   protected CommonOAuthProvider(WorkflowValueResolver<AccessTokenProvider> tokenProvider) {
     this.tokenProvider = tokenProvider;
   }
@@ -67,35 +59,44 @@ protected static OAuth2AuthenticationData fillFromMap(
   }
 
   protected static WorkflowValueResolver<AccessTokenProvider> accessToken(
+      WorkflowApplication app,
       Workflow workflow,
       OAuth2AuthenticationData authenticationData,
       SecretBasedAuthenticationPolicy secret,
       AuthRequestBuilder<?> builder) {
     if (authenticationData != null) {
-      return build(authenticationData, builder);
+      return build(authenticationData, builder, app);
     } else if (secret != null) {
-      return build(checkSecret(workflow, secret), builder);
+      return build(checkSecret(workflow, secret), builder, app);
     }
     throw new IllegalStateException("Both policy and secret are null");
   }
 
   private static WorkflowValueResolver<AccessTokenProvider> build(
-      OAuth2AuthenticationData authenticationData, AuthRequestBuilder authBuilder) {
+      OAuth2AuthenticationData authenticationData,
+      AuthRequestBuilder authBuilder,
+      WorkflowApplication app) {
     AccessTokenProvider tokenProvider =
-        accessTokenProviderFactory.build(
-            authBuilder.apply(authenticationData), authenticationData.getIssuers(), jwtConverter);
+        app.getServiceLoadedClasses(AccessTokenProviderFactory.class)
+            .get(0)
+            .build(
+                authBuilder.apply(authenticationData),
+                authenticationData.getIssuers(),
+                app.getServiceLoadedClasses(JWTConverter.class).get(0));
     return (w, t, m) -> tokenProvider;
   }
 
   private static WorkflowValueResolver<AccessTokenProvider> build(
-      String secretName, AuthRequestBuilder authBuilder) {
+      String secretName, AuthRequestBuilder authBuilder, WorkflowApplication app) {
     return (w, t, m) -> {
       Map<String, Object> secret = secret(w, secretName);
       String issuers = (String) secret.get("issuers");
-      return accessTokenProviderFactory.build(
-          authBuilder.apply(secret),
-          issuers != null ? Arrays.asList(issuers.split(",")) : null,
-          jwtConverter);
+      return app.getServiceLoadedClasses(AccessTokenProviderFactory.class)
+          .get(0)
+          .build(
+              authBuilder.apply(secret),
+              issuers != null ? Arrays.asList(issuers.split(",")) : null,
+              app.getServiceLoadedClasses(JWTConverter.class).get(0));
     };
   }
 }

impl/core/src/main/java/io/serverlessworkflow/impl/auth/OAuth2AuthProvider.java

@@ -24,6 +24,7 @@ public OAuth2AuthProvider(
       WorkflowApplication application, Workflow workflow, OAuthPolicyData policyData) {
     super(
         accessToken(
+            application,
             workflow,
             policyData.data(),
             policyData.secret(),

impl/core/src/main/java/io/serverlessworkflow/impl/auth/OpenIdAuthProvider.java

@@ -24,6 +24,7 @@ public OpenIdAuthProvider(
       WorkflowApplication application, Workflow workflow, OAuthPolicyData policyData) {
     super(
         accessToken(
+            application,
             workflow,
             policyData.data(),
             policyData.secret(),

impl/core/src/main/java/io/serverlessworkflow/impl/executors/EmitExecutor.java

@@ -41,16 +41,10 @@
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
-import java.util.ServiceLoader;
 import java.util.concurrent.CompletableFuture;
 
 public class EmitExecutor extends RegularTaskExecutor<EmitTask> {
 
-  private static final Collection<EmittedEventDecorator> emittedDecorators =
-      ServiceLoader.load(EmittedEventDecorator.class).stream()
-          .map(ServiceLoader.Provider::get)
-          .sorted()
-          .toList();
   private final EventPropertiesBuilder props;
 
   public static class EmitExecutorBuilder
@@ -139,7 +133,11 @@ private CloudEvent buildCloudEvent(WorkflowContext workflow, TaskContext taskCon
         .additionalFilter()
         .map(filter -> filter.apply(workflow, taskContext, taskContext.input()))
         .ifPresent(value -> value.forEach((k, v) -> addExtension(ceBuilder, k, v)));
-    emittedDecorators.forEach(d -> d.decorate(ceBuilder, workflow, taskContext));
+    workflow
+        .definition()
+        .application()
+        .getServiceLoadedClasses(EmittedEventDecorator.class)
+        .forEach(d -> d.decorate(ceBuilder, workflow, taskContext));
     return ceBuilder.build();
   }
 

impl/core/src/main/java/io/serverlessworkflow/impl/executors/RunScriptExecutorBuilder.java

@@ -25,19 +25,11 @@
 import io.serverlessworkflow.impl.resources.ResourceLoaderUtils;
 import io.serverlessworkflow.impl.scripts.ScriptLanguageId;
 import io.serverlessworkflow.impl.scripts.ScriptRunner;
-import java.util.Collection;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.ServiceLoader;
 
 public class RunScriptExecutorBuilder implements RunnableTaskBuilder<RunScript> {
 
-  private static Collection<ScriptRunner> scriptRunners =
-      ServiceLoader.load(ScriptRunner.class).stream()
-          .map(ServiceLoader.Provider::get)
-          .sorted()
-          .toList();
-
   @Override
   public CallableTask build(RunScript taskConfiguration, WorkflowDefinition definition) {
     ScriptUnion scriptUnion = taskConfiguration.getScript();
@@ -72,7 +64,7 @@ public CallableTask build(RunScript taskConfiguration, WorkflowDefinition defini
                         m),
         taskConfiguration.isAwait(),
         taskConfiguration.getReturn(),
-        scriptRunners.stream()
+        application.getServiceLoadedClasses(ScriptRunner.class).stream()
             .filter(s -> s.identifier().equals(language))
             .findFirst()
             .orElseThrow(

impl/core/src/main/java/io/serverlessworkflow/impl/executors/RunTaskExecutor.java

@@ -22,19 +22,12 @@
 import io.serverlessworkflow.impl.WorkflowDefinition;
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowMutablePosition;
-import java.util.Collection;
-import java.util.ServiceLoader;
-import java.util.ServiceLoader.Provider;
 import java.util.concurrent.CompletableFuture;
 
 public class RunTaskExecutor extends RegularTaskExecutor<RunTask> {
 
   private final CallableTask runnable;
 
-  private static final Collection<RunnableTaskBuilder> runnables =
-      ServiceLoader.load(RunnableTaskBuilder.class).stream().map(Provider::get).sorted().toList();
-  ;
-
   public static class RunTaskExecutorBuilder
       extends RegularTaskExecutorBuilder<RunTask, RunTaskExecutor> {
     private CallableTask runnable;
@@ -44,7 +37,7 @@ protected RunTaskExecutorBuilder(
       super(position, task, definition);
       RunTaskConfiguration config = task.getRun().get();
       this.runnable =
-          runnables.stream()
+          definition.application().getServiceLoadedClasses(RunnableTaskBuilder.class).stream()
               .filter(r -> r.accept(config.getClass()))
               .findFirst()
               .map(r -> r.build(config, definition))

impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/HttpExecutorBuilder.java

@@ -30,15 +30,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.ServiceLoader;
-import java.util.concurrent.ConcurrentHashMap;
 
 public class HttpExecutorBuilder {
 
   public static final String HTTP_REQUEST_DECORATOR_KEY = "HttpRequestDecorators";
   private final WorkflowDefinition definition;
-  private static final Map<String, List<HttpRequestDecorator>> appRequestDecorators =
-      new ConcurrentHashMap<>();
   private List<HttpRequestDecorator> requestDecorators;
   private WorkflowValueResolver<URI> pathSupplier;
   private Object body;
@@ -51,20 +47,14 @@ public class HttpExecutorBuilder {
   private HttpExecutorBuilder(WorkflowDefinition definition) {
     this.definition = definition;
     this.requestDecorators =
-        appRequestDecorators.computeIfAbsent(
-            definition.application().id(),
-            __ -> {
-              List<HttpRequestDecorator> result = new ArrayList<>();
-              result.addAll(
-                  definition
-                      .application()
-                      .<Collection<HttpRequestDecorator>>additionalObject(
-                          HTTP_REQUEST_DECORATOR_KEY)
-                      .orElse(List.of()));
-              ServiceLoader.load(HttpRequestDecorator.class).forEach(result::add);
-              Collections.sort(result);
-              return result;
-            });
+        new ArrayList<>(
+            definition.application().getServiceLoadedClasses(HttpRequestDecorator.class));
+    requestDecorators.addAll(
+        definition
+            .application()
+            .<Collection<HttpRequestDecorator>>additionalObject(HTTP_REQUEST_DECORATOR_KEY)
+            .orElse(List.of()));
+    Collections.sort(requestDecorators);
   }
 
   public HttpExecutorBuilder withAuth(ReferenceableAuthenticationPolicy policy) {