avoid code duplication by using ContainerState in ResourceReaper

Author: bsideup

core/src/main/java/org/testcontainers/DockerClientFactory.java

@@ -175,8 +175,7 @@ public DockerClient client() {
 
         final DockerClientProviderStrategy strategy = getOrInitializeStrategy();
 
-        String hostIpAddress = strategy.getDockerHostIpAddress();
-        log.info("Docker host IP address is {}", hostIpAddress);
+        log.info("Docker host IP address is {}", strategy.getDockerHostIpAddress());
         final DockerClient client = new DelegatingDockerClient(strategy.getDockerClient()) {
             @Override
             public void close() {
@@ -200,7 +199,8 @@ public void close() {
         if (useRyuk) {
             log.debug("Ryuk is enabled");
             try {
-                ryukContainerId = ResourceReaper.start(hostIpAddress, client);
+                //noinspection deprecation
+                ryukContainerId = ResourceReaper.start(client);
             } catch (RuntimeException e) {
                 cachedClientFailure = e;
                 throw e;

core/src/main/java/org/testcontainers/utility/ResourceReaper.java

@@ -9,7 +9,6 @@
 import com.github.dockerjava.api.model.Frame;
 import com.github.dockerjava.api.model.HostConfig;
 import com.github.dockerjava.api.model.Network;
-import com.github.dockerjava.api.model.Ports;
 import com.github.dockerjava.api.model.Volume;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
@@ -21,6 +20,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.ContainerState;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -70,8 +70,23 @@ private ResourceReaper() {
         dockerClient = DockerClientFactory.instance().client();
     }
 
-    @SneakyThrows(InterruptedException.class)
+
+    /**
+     *
+     * @deprecated internal API
+     */
+    @Deprecated
     public static String start(String hostIpAddress, DockerClient client) {
+        return start(client);
+    }
+
+    /**
+     *
+     * @deprecated internal API
+     */
+    @Deprecated
+    @SneakyThrows(InterruptedException.class)
+    public static String start(DockerClient client) {
         String ryukImage = ImageNameSubstitutor.instance()
             .apply(DockerImageName.parse("testcontainers/ryuk:0.3.0"))
             .asCanonicalNameString();
@@ -107,14 +122,22 @@ public void onNext(Frame frame) {
                 }
             });
 
-        InspectContainerResponse inspectedContainer = client.inspectContainerCmd(ryukContainerId).exec();
+        ContainerState containerState = new ContainerState() {
 
-        Integer ryukPort = inspectedContainer.getNetworkSettings().getPorts().getBindings().values().stream()
-                .flatMap(Stream::of)
-                .findFirst()
-                .map(Ports.Binding::getHostPortSpec)
-                .map(Integer::parseInt)
-                .get();
+            final InspectContainerResponse inspectedContainer = client.inspectContainerCmd(ryukContainerId).exec();
+
+            @Override
+            public List<Integer> getExposedPorts() {
+                return Stream.of(getContainerInfo().getConfig().getExposedPorts())
+                    .map(ExposedPort::getPort)
+                    .collect(Collectors.toList());
+            }
+
+            @Override
+            public InspectContainerResponse getContainerInfo() {
+                return inspectedContainer;
+            }
+        };
 
         CountDownLatch ryukScheduledLatch = new CountDownLatch(1);
 
@@ -126,13 +149,15 @@ public void onNext(Frame frame) {
             );
         }
 
+        String host = containerState.getHost();
+        Integer ryukPort = containerState.getFirstMappedPort();
         Thread kiraThread = new Thread(
                 DockerClientFactory.TESTCONTAINERS_THREAD_GROUP,
                 () -> {
                     while (true) {
                         RYUK_ACK_RATE_LIMITER.doWhenReady(() -> {
                             int index = 0;
-                            try(Socket clientSocket = new Socket(hostIpAddress, ryukPort)) {
+                            try(Socket clientSocket = new Socket(host, ryukPort)) {
                                 FilterRegistry registry = new FilterRegistry(clientSocket.getInputStream(), clientSocket.getOutputStream());
 
                                 synchronized (DEATH_NOTE) {
@@ -157,7 +182,7 @@ public void onNext(Frame frame) {
                                     }
                                 }
                             } catch (IOException e) {
-                                log.warn("Can not connect to Ryuk at {}:{}", hostIpAddress, ryukPort, e);
+                                log.warn("Can not connect to Ryuk at {}:{}", host, ryukPort, e);
                             }
                         });
                     }
@@ -170,7 +195,7 @@ public void onNext(Frame frame) {
             // We need to wait before we can start any containers to make sure that we delete them
             if (!ryukScheduledLatch.await(TestcontainersConfiguration.getInstance().getRyukTimeout(), TimeUnit.SECONDS)) {
                 log.error("Timed out waiting for Ryuk container to start. Ryuk's logs:\n{}", ryukLog);
-                throw new IllegalStateException(String.format("Could not connect to Ryuk at %s:%s", hostIpAddress, ryukPort));
+                throw new IllegalStateException(String.format("Could not connect to Ryuk at %s:%s", host, ryukPort));
             }
         } finally {
             try {