Check newer docker-java

.envrc

@@ -1 +1,2 @@
 use python 3.6.0
+use java 1.8

core/build.gradle

@@ -95,7 +95,7 @@ dependencies {
         exclude(group: "net.java.dev.jna")
     }
 
-    shaded ('com.github.docker-java:docker-java:3.1.0-rc-4') {
+    shaded ('com.github.docker-java:docker-java:3.1.1') {
         exclude(group: 'org.glassfish.jersey.core')
         exclude(group: 'org.glassfish.jersey.connectors')
         exclude(group: 'log4j')

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

@@ -48,8 +48,8 @@ public class DockerClientFactory {
     public static final String SESSION_ID = UUID.randomUUID().toString();
 
     public static final Map<String, String> DEFAULT_LABELS = ImmutableMap.of(
-            TESTCONTAINERS_LABEL, "true",
-            TESTCONTAINERS_SESSION_ID_LABEL, SESSION_ID
+        TESTCONTAINERS_LABEL, "true",
+        TESTCONTAINERS_SESSION_ID_LABEL, SESSION_ID
     );
 
     private static final String TINY_IMAGE = TestcontainersConfiguration.getInstance().getTinyImage();
@@ -89,7 +89,6 @@ public synchronized static DockerClientFactory instance() {
     }
 
     /**
-     *
      * @return a new initialized Docker client
      */
     @Synchronized
@@ -100,7 +99,7 @@ public DockerClient client() {
         }
 
         List<DockerClientProviderStrategy> configurationStrategies = new ArrayList<DockerClientProviderStrategy>();
-        ServiceLoader.load(DockerClientProviderStrategy.class).forEach( cs -> configurationStrategies.add( cs ) );
+        ServiceLoader.load(DockerClientProviderStrategy.class).forEach(cs -> configurationStrategies.add(cs));
 
         strategy = DockerClientProviderStrategy.getFirstValidStrategy(configurationStrategies);
 
@@ -114,10 +113,10 @@ public DockerClient client() {
             activeApiVersion = version.getApiVersion();
             activeExecutionDriver = dockerInfo.getExecutionDriver();
             log.info("Connected to docker: \n" +
-                    "  Server Version: " + dockerInfo.getServerVersion() + "\n" +
-                    "  API Version: " + activeApiVersion + "\n" +
-                    "  Operating System: " + dockerInfo.getOperatingSystem() + "\n" +
-                    "  Total Memory: " + dockerInfo.getMemTotal() / (1024 * 1024) + " MB");
+                "  Server Version: " + dockerInfo.getServerVersion() + "\n" +
+                "  API Version: " + activeApiVersion + "\n" +
+                "  Operating System: " + dockerInfo.getOperatingSystem() + "\n" +
+                "  Total Memory: " + dockerInfo.getMemTotal() / (1024 * 1024) + " MB");
 
             boolean checksEnabled = !TestcontainersConfiguration.getInstance().isDisableChecks();
 
@@ -157,18 +156,18 @@ private void checkDiskSpace(DockerClient dockerClient, String id) {
 
         try {
             dockerClient
-                    .execStartCmd(dockerClient.execCreateCmd(id).withAttachStdout(true).withCmd("df", "-P").exec().getId())
-                    .exec(new ExecStartResultCallback(outputStream, null))
-                    .awaitCompletion();
+                .execStartCmd(dockerClient.execCreateCmd(id).withAttachStdout(true).withCmd("df", "-P").exec().getId())
+                .exec(new ExecStartResultCallback(outputStream, null))
+                .awaitCompletion();
         } catch (Exception e) {
             log.debug("Can't exec disk checking command", e);
         }
 
         DiskSpaceUsage df = parseAvailableDiskSpace(outputStream.toString());
 
         VisibleAssertions.assertTrue(
-                "Docker environment should have more than 2GB free disk space",
-                df.availableMB.map(it -> it >= 2048).orElse(true)
+            "Docker environment should have more than 2GB free disk space",
+            df.availableMB.map(it -> it >= 2048).orElse(true)
         );
     }
 
@@ -180,7 +179,9 @@ private boolean checkMountableFile() {
         Volume volume = new Volume("/dummy");
         try {
             return runInsideDocker(
-                createContainerCmd -> createContainerCmd.withBinds(new Bind(mountableFile.getResolvedPath(), volume, AccessMode.ro)),
+                createContainerCmd -> createContainerCmd.withHostConfig(
+                    new HostConfig()
+                        .withBinds(new Bind(mountableFile.getResolvedPath(), volume, AccessMode.ro))),
                 (__, containerId) -> {
                     try (InputStream stream = dockerClient.copyArchiveFromContainerCmd(containerId, volume.getPath()).exec()) {
                         stream.read();
@@ -197,8 +198,8 @@ private boolean checkMountableFile() {
     }
 
     /**
-   * Check whether the image is available locally and pull it otherwise
-   */
+     * Check whether the image is available locally and pull it otherwise
+     */
     public void checkAndPullImage(DockerClient client, String image) {
         List<Image> images = client.listImagesCmd().withImageNameFilter(image).exec();
         if (images.isEmpty()) {
@@ -224,7 +225,7 @@ public <T> T runInsideDocker(Consumer<CreateContainerCmd> createContainerCmdCons
     private <T> T runInsideDocker(DockerClient client, Consumer<CreateContainerCmd> createContainerCmdConsumer, BiFunction<DockerClient, String, T> block) {
         checkAndPullImage(client, TINY_IMAGE);
         CreateContainerCmd createContainerCmd = client.createContainerCmd(TINY_IMAGE)
-                .withLabels(DEFAULT_LABELS);
+            .withLabels(DEFAULT_LABELS);
         createContainerCmdConsumer.accept(createContainerCmd);
         String id = createContainerCmd.exec().getId();
 

core/src/main/java/org/testcontainers/containers/GenericContainer.java

@@ -233,7 +233,7 @@ private void tryStart() {
 
             containerId = createCommand.exec().getId();
 
-            connectToPortForwardingNetwork(createCommand.getNetworkMode());
+            connectToPortForwardingNetwork(createCommand.getHostConfig().getNetworkMode());
 
             copyToFileContainerPathMap.forEach(this::copyFileToContainer);
 
@@ -290,6 +290,7 @@ private void tryStart() {
     /**
      * Set any custom settings for the create command such as shared memory size.
      */
+    @NotNull
     private HostConfig buildHostConfig() {
         HostConfig config = new HostConfig();
         if (shmSize != null) {
@@ -432,7 +433,7 @@ private void applyConfiguration(CreateContainerCmd createCommand) {
                 .map(PortBinding::parse)
                 .toArray(PortBinding[]::new);
 
-        createCommand.withPortBindings(portBindingArray);
+        hostConfig.withPortBindings(portBindingArray);
 
         if (commandParts != null) {
             createCommand.withCmd(commandParts);
@@ -454,13 +455,11 @@ private void applyConfiguration(CreateContainerCmd createCommand) {
             }
         }
 
-        Bind[] bindsArray = binds.stream()
-                .toArray(Bind[]::new);
-        createCommand.withBinds(bindsArray);
+        Bind[] bindsArray = binds.toArray(new Bind[0]);
+        hostConfig.withBinds(bindsArray);
 
-        VolumesFrom[] volumesFromsArray = volumesFroms.stream()
-                .toArray(VolumesFrom[]::new);
-        createCommand.withVolumesFrom(volumesFromsArray);
+        VolumesFrom[] volumesFromsArray = volumesFroms.toArray(new VolumesFrom[0]);
+        hostConfig.withVolumesFrom(volumesFromsArray);
 
         Set<Link> allLinks = new HashSet<>();
         Set<String> allLinkedContainerNetworks = new HashSet<>();
@@ -482,7 +481,7 @@ private void applyConfiguration(CreateContainerCmd createCommand) {
             allLinkedContainerNetworks.addAll(linkedContainerNetworks);
         }
 
-        createCommand.withLinks(allLinks.toArray(new Link[allLinks.size()]));
+        hostConfig.withLinks(allLinks.toArray(new Link[0]));
 
         allLinkedContainerNetworks.remove("bridge");
         if (allLinkedContainerNetworks.size() > 1) {
@@ -494,38 +493,36 @@ private void applyConfiguration(CreateContainerCmd createCommand) {
         Optional<String> networkForLinks = allLinkedContainerNetworks.stream().findFirst();
         if (networkForLinks.isPresent()) {
             logger().debug("Associating container with network: {}", networkForLinks.get());
-            createCommand.withNetworkMode(networkForLinks.get());
+            hostConfig.withNetworkMode(networkForLinks.get());
         }
 
-        createCommand.withPublishAllPorts(true);
+        hostConfig.withPublishAllPorts(true);
 
         PortForwardingContainer.INSTANCE.getNetwork().ifPresent(it -> {
             withExtraHost(INTERNAL_HOST_HOSTNAME, it.getIpAddress());
         });
 
-        String[] extraHostsArray = extraHosts.stream()
-                .toArray(String[]::new);
-        createCommand.withExtraHosts(extraHostsArray);
+        String[] extraHostsArray = extraHosts.toArray(new String[0]);
+        hostConfig.withExtraHosts(extraHostsArray);
 
         if (network != null) {
-            createCommand.withNetworkMode(network.getId());
+            hostConfig.withNetworkMode(network.getId());
             createCommand.withAliases(this.networkAliases);
         } else if (networkMode != null) {
-            createCommand.withNetworkMode(networkMode);
+            hostConfig.withNetworkMode(networkMode);
         }
 
         if (workingDirectory != null) {
             createCommand.withWorkingDir(workingDirectory);
         }
 
         if (privilegedMode) {
-            createCommand.withPrivileged(privilegedMode);
+            hostConfig.withPrivileged(privilegedMode);
         }
 
         createContainerCmdModifiers.forEach(hook -> hook.accept(createCommand));
 
-        Map<String, String> combinedLabels = new HashMap<>();
-        combinedLabels.putAll(labels);
+        Map<String, String> combinedLabels = new HashMap<>(labels);
         if (createCommand.getLabels() != null) {
             combinedLabels.putAll(createCommand.getLabels());
         }
@@ -550,7 +547,6 @@ private Set<String> findAllNetworksForLinkedContainers(LinkableContainer linkabl
                 .filter(container -> container.getNetworkSettings() != null &&
                         container.getNetworkSettings().getNetworks() != null)
                 .flatMap(container -> container.getNetworkSettings().getNetworks().keySet().stream())
-                .distinct()
                 .collect(Collectors.toSet());
     }
 

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

@@ -5,12 +5,7 @@
 import com.github.dockerjava.api.exception.DockerException;
 import com.github.dockerjava.api.exception.InternalServerErrorException;
 import com.github.dockerjava.api.exception.NotFoundException;
-import com.github.dockerjava.api.model.Bind;
-import com.github.dockerjava.api.model.ExposedPort;
-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.github.dockerjava.api.model.*;
 import com.google.common.annotations.VisibleForTesting;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
@@ -20,18 +15,10 @@
 import org.slf4j.LoggerFactory;
 import org.testcontainers.DockerClientFactory;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
+import java.io.*;
 import java.net.Socket;
 import java.util.AbstractMap.SimpleEntry;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -69,17 +56,17 @@ public static String start(String hostIpAddress, DockerClient client) {
         String ryukImage = TestcontainersConfiguration.getInstance().getRyukImage();
         DockerClientFactory.instance().checkAndPullImage(client, ryukImage);
 
-        List<Bind> binds = new ArrayList<>();
-        binds.add(new Bind("//var/run/docker.sock", new Volume("/var/run/docker.sock")));
+        Binds binds = new Binds(new Bind("//var/run/docker.sock", new Volume("/var/run/docker.sock")));
 
         String ryukContainerId = client.createContainerCmd(ryukImage)
-                .withHostConfig(new HostConfig().withAutoRemove(true))
+                .withHostConfig(new HostConfig()
+                    .withAutoRemove(true)
+                    .withPublishAllPorts(true)
+                    .withBinds(binds)
+                    .withPrivileged(TestcontainersConfiguration.getInstance().isRyukPrivileged()))
                 .withExposedPorts(new ExposedPort(8080))
-                .withPublishAllPorts(true)
                 .withName("testcontainers-ryuk-" + DockerClientFactory.SESSION_ID)
                 .withLabels(Collections.singletonMap(DockerClientFactory.TESTCONTAINERS_LABEL, "true"))
-                .withBinds(binds)
-                .withPrivileged(TestcontainersConfiguration.getInstance().isRyukPrivileged())
                 .exec()
                 .getId();
 

docs/examples/src/test/java/generic/CmdModifierTest.java

@@ -1,5 +1,6 @@
 package generic;
 
+import com.github.dockerjava.api.model.HostConfig;
 import org.junit.Rule;
 import org.junit.Test;
 import org.testcontainers.containers.Container;
@@ -20,8 +21,9 @@ public class CmdModifierTest {
     // memory {
     @Rule
     public GenericContainer memoryLimitedRedis = new GenericContainer<>("redis:3.0.2")
-            .withCreateContainerCmdModifier(cmd -> cmd.withMemory((long) 4 * 1024 * 1024))
-            .withCreateContainerCmdModifier(cmd -> cmd.withMemorySwap((long) 4 * 1024 * 1024));
+            .withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(HostConfig.newHostConfig()
+                .withMemory((long) 4 * 1024 * 1024)
+                .withMemorySwap((long) 4 * 1024 * 1024)));
     // }
 
 

modules/vault/src/main/java/org/testcontainers/vault/VaultContainer.java

@@ -1,6 +1,7 @@
 package org.testcontainers.vault;
 
 import com.github.dockerjava.api.command.InspectContainerResponse;
+import com.github.dockerjava.api.model.HostConfig;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.traits.LinkableContainer;
 
@@ -41,7 +42,7 @@ public VaultContainer(String dockerImageName) {
     @Override
     protected void configure() {
         setStartupAttempts(3);
-        withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(IPC_LOCK));
+        withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(new HostConfig().withCapAdd(IPC_LOCK)));
         if(!isVaultPortRequested()){
             withEnv("VAULT_ADDR", "http://0.0.0.0:" + VAULT_PORT);
         }
@@ -130,4 +131,4 @@ private void setVaultPortRequested(boolean vaultPortRequested) {
     private boolean isVaultPortRequested() {
         return vaultPortRequested;
     }
-}
+}