[Fix #1267] Adapting to GraalVM static grabbing policy (#1268)

Signed-off-by: fjtirado <ftirados@redhat.com>

Author: fjtirado

impl/container/src/main/java/io/serverlessworkflow/impl/container/executors/ContainerRunner.java

@@ -41,21 +41,11 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 class ContainerRunner implements CallableTask {
 
-  private static final DefaultDockerClientConfig DEFAULT_CONFIG =
-      DefaultDockerClientConfig.createDefaultConfigBuilder().build();
-
-  private static class DockerClientHolder {
-    private static final DockerClient dockerClient =
-        DockerClientImpl.getInstance(
-            DEFAULT_CONFIG,
-            new ApacheDockerHttpClient.Builder()
-                .dockerHost(DEFAULT_CONFIG.getDockerHost())
-                .build());
-  }
-
   private final Collection<ContainerPropertySetter> propertySetters;
   private final Optional<WorkflowValueResolver<Duration>> timeout;
   private final ContainerCleanupPolicy policy;
@@ -82,7 +72,8 @@ public CompletableFuture<WorkflowModel> apply(
 
   private WorkflowModel startSync(
       WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel input) {
-    Integer exit = executeContainer(workflowContext, taskContext, input);
+    Integer exit =
+        executeContainer(workflowContext, taskContext, input, DockerClientHolder.client());
     if (exit == null || exit == 0) {
       return input;
     } else {
@@ -91,14 +82,20 @@ private WorkflowModel startSync(
   }
 
   private Integer executeContainer(
-      WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel input) {
+      WorkflowContext workflowContext,
+      TaskContext taskContext,
+      WorkflowModel input,
+      DockerClient dockerClient) {
     try {
-      pullImageIfNeeded(containerImage);
-      CreateContainerCmd containerCommand =
-          DockerClientHolder.dockerClient.createContainerCmd(containerImage);
+      pullImageIfNeeded(containerImage, dockerClient);
+      CreateContainerCmd containerCommand = dockerClient.createContainerCmd(containerImage);
       propertySetters.forEach(p -> p.accept(containerCommand, workflowContext, taskContext, input));
       return waitAccordingToLifetime(
-          createAndStartContainer(containerCommand), workflowContext, taskContext, input);
+          createAndStartContainer(containerCommand, dockerClient),
+          workflowContext,
+          taskContext,
+          input,
+          dockerClient);
     } catch (InterruptedException ie) {
       Thread.currentThread().interrupt();
       throw failed("Container execution failed with exit code " + ie.getMessage());
@@ -107,43 +104,46 @@ private Integer executeContainer(
     }
   }
 
-  private void pullImageIfNeeded(String imageRef) throws InterruptedException {
+  private void pullImageIfNeeded(String imageRef, DockerClient dockerClient)
+      throws InterruptedException {
     NameParser.ReposTag rt = NameParser.parseRepositoryTag(imageRef);
-    DockerClientHolder.dockerClient
+    dockerClient
         .pullImageCmd(NameParser.resolveRepositoryName(imageRef).reposName)
         .withTag(WorkflowUtils.isValid(rt.tag) ? rt.tag : "latest")
         .start()
         .awaitCompletion();
   }
 
-  private String createAndStartContainer(CreateContainerCmd containerCommand) {
+  private String createAndStartContainer(
+      CreateContainerCmd containerCommand, DockerClient dockerClient) {
     CreateContainerResponse resp = containerCommand.exec();
     String id = resp.getId();
     if (!isValid(id)) {
       throw new IllegalStateException("Container creation failed: empty ID");
     }
-    DockerClientHolder.dockerClient.startContainerCmd(id).exec();
+    dockerClient.startContainerCmd(id).exec();
     return id;
   }
 
   private Integer waitAccordingToLifetime(
-      String id, WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel input)
+      String id,
+      WorkflowContext workflowContext,
+      TaskContext taskContext,
+      WorkflowModel input,
+      DockerClient dockerClient)
       throws IOException {
-    try (var cb =
-        DockerClientHolder.dockerClient
-            .waitContainerCmd(id)
-            .exec(new WaitContainerResultCallback())) {
+    try (var cb = dockerClient.waitContainerCmd(id).exec(new WaitContainerResultCallback())) {
       if (policy == ContainerCleanupPolicy.EVENTUALLY) {
         Duration timeout =
             this.timeout
                 .map(t -> t.apply(workflowContext, taskContext, input))
                 .orElse(Duration.ZERO);
         try {
           Integer exit = cb.awaitStatusCode(timeout.toMillis(), TimeUnit.MILLISECONDS);
-          safeStop(id);
+          safeStop(id, dockerClient);
           return exit;
         } catch (DockerClientException timeoutOrOther) {
-          safeStop(id);
+          safeStop(id, dockerClient);
         }
       } else {
         return cb.awaitStatusCode();
@@ -154,47 +154,41 @@ private Integer waitAccordingToLifetime(
     return 0;
   }
 
-  private boolean isRunning(String id) {
+  private boolean isRunning(String id, DockerClient dockerClient) {
     try {
-      var st = DockerClientHolder.dockerClient.inspectContainerCmd(id).exec().getState();
+      var st = dockerClient.inspectContainerCmd(id).exec().getState();
       return st != null && Boolean.TRUE.equals(st.getRunning());
     } catch (Exception e) {
       return false; // must be already removed
     }
   }
 
-  private void safeStop(String id) {
-    if (isRunning(id)) {
-      safeStop(id, Duration.ofSeconds(10));
-      try (var cb2 =
-          DockerClientHolder.dockerClient
-              .waitContainerCmd(id)
-              .exec(new WaitContainerResultCallback())) {
+  private void safeStop(String id, DockerClient dockerClient) {
+    if (isRunning(id, dockerClient)) {
+      safeStop(id, Duration.ofSeconds(10), dockerClient);
+      try (var cb2 = dockerClient.waitContainerCmd(id).exec(new WaitContainerResultCallback())) {
         cb2.awaitStatusCode();
-        safeRemove(id);
+        safeRemove(id, dockerClient);
       } catch (Exception ignore) {
         // we can ignore this
       }
     } else {
-      safeRemove(id);
+      safeRemove(id, dockerClient);
     }
   }
 
-  private void safeStop(String id, Duration timeout) {
+  private void safeStop(String id, Duration timeout, DockerClient dockerClient) {
     try {
-      DockerClientHolder.dockerClient
-          .stopContainerCmd(id)
-          .withTimeout((int) Math.max(1, timeout.toSeconds()))
-          .exec();
+      dockerClient.stopContainerCmd(id).withTimeout((int) Math.max(1, timeout.toSeconds())).exec();
     } catch (Exception ignore) {
       // we can ignore this
     }
   }
 
   // must be removed because of withAutoRemove(true), but just in case
-  private void safeRemove(String id) {
+  private void safeRemove(String id, DockerClient dockerClient) {
     try {
-      DockerClientHolder.dockerClient.removeContainerCmd(id).withForce(true).exec();
+      dockerClient.removeContainerCmd(id).withForce(true).exec();
     } catch (Exception ignore) {
       // we can ignore this
     }
@@ -217,4 +211,30 @@ private static RuntimeException mapExitCode(int exit) {
   private static RuntimeException failed(String message) {
     return new RuntimeException(message);
   }
+
+  private static class DockerClientHolder {
+    private static volatile DockerClient client;
+    private static final Lock dockerLock = new ReentrantLock();
+
+    private static DockerClient client() {
+      if (client == null) {
+        dockerLock.lock();
+        try {
+          if (client == null) {
+            DefaultDockerClientConfig config =
+                DefaultDockerClientConfig.createDefaultConfigBuilder().build();
+            client =
+                DockerClientImpl.getInstance(
+                    config,
+                    new ApacheDockerHttpClient.Builder()
+                        .dockerHost(config.getDockerHost())
+                        .build());
+          }
+        } finally {
+          dockerLock.unlock();
+        }
+      }
+      return client;
+    }
+  }
 }

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

@@ -15,8 +15,6 @@
  */
 package io.serverlessworkflow.impl.auth;
 
-import java.util.Random;
-
 public class AuthUtils {
 
   private AuthUtils() {}
@@ -40,15 +38,7 @@ private AuthUtils() {}
 
   private static final String AUTH_HEADER_FORMAT = "%s %s";
 
-  private static class RandomHolder {
-    private static final Random random = new Random();
-  }
-
   public static String authHeaderValue(String scheme, String parameter) {
     return String.format(AUTH_HEADER_FORMAT, scheme, parameter);
   }
-
-  public static String getRandomHexString() {
-    return String.format("%08x", RandomHolder.random.nextInt());
-  }
 }

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

@@ -29,13 +29,15 @@
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowUtils;
 import io.serverlessworkflow.impl.WorkflowValueResolver;
+import io.serverlessworkflow.impl.utils.RandomFactory;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.HttpURLConnection;
 import java.net.URI;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Optional;
+import java.util.Random;
 import java.util.StringTokenizer;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
@@ -110,9 +112,11 @@ private static enum QOP {
     AUTH_INT,
   };
 
+  private static final String HEX = "%08x";
   private final WorkflowValueResolver<String> userFilter;
   private final WorkflowValueResolver<String> passwordFilter;
   private final String method;
+  private final Random random = RandomFactory.getRandom();
 
   public DigestAuthProvider(
       WorkflowApplication app,
@@ -155,8 +159,8 @@ public String content(WorkflowContext workflow, TaskContext task, WorkflowModel
         String nonceCount;
         String clientNonce;
         if (serverInfo.qop.isPresent() || serverInfo.algorithm == Algorithm.MD5SESSS) {
-          nonceCount = String.format("%08x", nc.getAndIncrement());
-          clientNonce = AuthUtils.getRandomHexString();
+          nonceCount = String.format(HEX, nc.getAndIncrement());
+          clientNonce = String.format(HEX, random.nextInt());
         } else {
           nonceCount = null;
           clientNonce = null;

impl/core/src/main/java/io/serverlessworkflow/impl/utils/RandomFactory.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.utils;
+
+import java.util.Random;
+
+public class RandomFactory {
+
+  public static Random getRandom() {
+    return new Random();
+  }
+
+  private RandomFactory() {}
+}

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

@@ -20,19 +20,37 @@
 import io.serverlessworkflow.impl.WorkflowContext;
 import jakarta.ws.rs.client.Client;
 import jakarta.ws.rs.client.ClientBuilder;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 public class HttpClientResolver {
 
   public static final String HTTP_CLIENT_PROVIDER = "httpClientProvider";
 
   private static class DefaultHolder {
-    private static final Client client = ClientBuilder.newClient();
+
+    private static final Lock clientLock = new ReentrantLock();
+    private static volatile Client client;
+
+    private static final Client client() {
+      if (client == null) {
+        clientLock.lock();
+        try {
+          if (client == null) {
+            client = ClientBuilder.newClient();
+          }
+        } finally {
+          clientLock.unlock();
+        }
+      }
+      return client;
+    }
   }
 
   public static Client client(WorkflowContext workflowContext, TaskContext taskContext) {
     WorkflowApplication appl = workflowContext.definition().application();
     return appl.<Client>additionalObject(HTTP_CLIENT_PROVIDER, workflowContext, taskContext)
-        .orElseGet(() -> DefaultHolder.client);
+        .orElseGet(() -> DefaultHolder.client());
   }
 
   private HttpClientResolver() {}