fix: update parsecconteiner to wait for socat and container start

Author: samspycher

parsec-testcontainers/src/main/java/org/parallaxsecond/testcontainers/ParsecContainer.java

@@ -1,27 +1,32 @@
 package org.parallaxsecond.testcontainers;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.Assertions;
-import org.testcontainers.containers.BindMode;
-import org.testcontainers.containers.GenericContainer;
-import org.testcontainers.utility.DockerImageName;
 
 import java.net.ServerSocket;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.PosixFilePermissions;
+import java.time.Duration;
+import static java.util.Collections.singletonList;
 import java.util.Locale;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-import static java.util.Collections.singletonList;
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.containers.wait.strategy.ShellStrategy;
+import org.testcontainers.shaded.org.awaitility.Awaitility;
+import org.testcontainers.utility.DockerImageName;
+
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 public class ParsecContainer extends GenericContainer<ParsecContainer> {
   private static final String IMAGE_NAME = "parallaxsecond/parsec";
   private static final String PARSEC_SOCKET_FILE = "parsec.sock";
-  private static final String PARSEC_RUN_DIR = "/run/parsec/";
+  private static final String PARSEC_RUN_DIR = "/parsec/quickstart/";
   private static final String PARSEC_SOCKET = PARSEC_RUN_DIR + PARSEC_SOCKET_FILE;
   private static final int PARSEC_TCP_PORT = 4444;
   private final int localPort = findFreePort();
@@ -30,20 +35,47 @@ public class ParsecContainer extends GenericContainer<ParsecContainer> {
   private Process cmd;
   private ExecutorService executor;
 
+  public Path runDir;
+
   @SneakyThrows
   public ParsecContainer(final DockerImageName dockerImageName) {
     super(dockerImageName);
-    Path runDir = Files.createTempDirectory("ps");
+    this.setWaitStrategy(new ShellStrategy().withCommand("parsec-tool ping")
+        .withStartupTimeout(Duration.ofSeconds(10)));
+    runDir = Files.createTempDirectory("parsec_");
     Files.setPosixFilePermissions(runDir, PosixFilePermissions.fromString("rwxrwxrwx"));
     this.parsecSock = runDir.resolve(PARSEC_SOCKET_FILE);
     this.parsecSockSocat = runDir.resolve("ps_socat.sock");
-    this.withFileSystemBind(
-        runDir.toFile().getAbsoluteFile().getAbsolutePath(), PARSEC_RUN_DIR, BindMode.READ_WRITE);
+
     this.setPortBindings(singletonList(localPort + ":" + PARSEC_TCP_PORT));
+    this.withLogConsumer(new Slf4jLogConsumer(LoggerFactory.getLogger(ParsecContainer.class)));
+  }
+
+  public boolean isRunning() {
+    if (getContainerId() == null) {
+      return false;
+    }
+
+    try {
+      Boolean running = getCurrentContainerInfo().getState().getRunning();
+      return Boolean.TRUE.equals(running);
+    } catch (Throwable e) {
+      return false;
+    }
   }
 
+  @SneakyThrows
   public static ParsecContainer withVersion(String version) {
-    return new ParsecContainer(DockerImageName.parse(IMAGE_NAME + ":" + version));
+    ParsecContainer parsecContainer =
+        new ParsecContainer(DockerImageName.parse(IMAGE_NAME + ":" + version));
+
+    parsecContainer.start();
+
+    // Wait for container to be running
+    Awaitility.await().until(parsecContainer::isRunning);
+
+
+    return parsecContainer;
   }
 
   @SneakyThrows
@@ -63,20 +95,20 @@ public URI getSocketUri() {
 
   @Override
   public void start() {
-    super.start();
     if (isOsx()) {
       useSocat();
+    } else {
     }
+    super.start();
   }
+
   private static boolean isOsx() {
     String os = System.getProperty("os.name", "generic").toLowerCase(Locale.ENGLISH);
     return ((os.contains("mac")) || (os.contains("darwin")));
   }
 
-
   @Override
   public void close() {
-    super.close();
     if (this.cmd != null) {
       this.cmd.destroyForcibly();
       this.cmd = null;
@@ -90,29 +122,21 @@ public void close() {
   @SneakyThrows
   public void useSocat() {
     executor = Executors.newSingleThreadExecutor();
-    executor.submit(
-        () -> {
-          log.info("starting socat in docker container");
-          ParsecContainer.this.execInContainer(
-              "socat",
-              "TCP4-LISTEN:" + PARSEC_TCP_PORT + ",reuseaddr,fork",
-              "UNIX-CONNECT:" + PARSEC_SOCKET);
-          log.info("started socat in docker container");
-          return null;
-        });
-
-    log.info("starting socat on local machine");
-    cmd =
-        Runtime.getRuntime()
-            .exec(
-                new String[] {
-                  "socat",
-                  "UNIX-LISTEN:"
-                      + this.parsecSockSocat.toFile().getAbsolutePath()
-                      + ",fork,reuseaddr",
-                  "TCP4:localhost:" + this.localPort
-                });
-    log.info("started socat on local machine");
+    executor.submit(() -> {
+      ParsecContainer.this.execInContainer("socat", "-d", "-d", // Add debug output
+          "TCP4-LISTEN:" + PARSEC_TCP_PORT + ",reuseaddr,fork", "UNIX-CONNECT:" + PARSEC_SOCKET);
+      return null;
+    });
+
+    cmd = Runtime.getRuntime().exec(new String[] {"socat", "-d", "-d", // Add debug output
+        "UNIX-LISTEN:" + this.parsecSockSocat.toFile().getAbsolutePath() + ",fork,reuseaddr",
+        "TCP4:localhost:" + this.localPort});
+
+    // wait until this.parsecSockSocat is created
+    Awaitility.await().until(() -> {
+      return Files.exists(this.parsecSockSocat);
+    });
+
   }
 
   @SneakyThrows
@@ -121,6 +145,7 @@ public void parsecTool(String... args) {
     System.arraycopy(args, 0, args_, 1, args.length);
     args_[0] = "parsec-tool";
     ExecResult r = execInContainer(args_);
-    Assertions.assertEquals(0, r.getExitCode(), getLogs() + "\n" + r.getStdout() + "\n" + r.getStderr());
+    Assertions.assertEquals(0, r.getExitCode(),
+        getLogs() + "\n" + r.getStdout() + "\n" + r.getStderr());
   }
 }