Add support for Docker networks.

.travis.yml

@@ -24,7 +24,7 @@ cache:
 install:
   - echo "MAVEN_OPTS='-XX:+TieredCompilation -XX:TieredStopAtLevel=1'" > ~/.mavenrc
   - sudo apt-get update -qq
-  - sudo apt-get -y -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confnew install docker-engine
+  - sudo apt-get -y -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confnew install docker-ce
   - docker info
   # Update env vars required by testcontainers
   - export DOCKER_HOST=tcp://127.0.0.1:2375

CHANGELOG.md

@@ -7,6 +7,7 @@ All notable changes to this project will be documented in this file.
 - Added pre-flight checks (can be disabled with `checks.disable` configuration property) (#363)
 - Removed unused Jersey dependencies (#361)
 - Fixed non-POSIX fallback for file attribute reading (#371)
+- Added support for the Docker networks (#372)
 
 ## [1.3.0] - 2017-06-05
 ### Fixed

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

@@ -196,6 +196,24 @@ public String getStderr() {
      */
     SELF withNetworkMode(String networkMode);
 
+    /**
+     * Set the network for this container, similar to the <code>--network &lt;name&gt;</code>
+     * option on the docker CLI.
+     *
+     * @param network the instance of {@link Network}
+     * @return this
+     */
+    SELF withNetwork(Network network);
+
+    /**
+     * Set the network aliases for this container, similar to the <code>--network-alias &lt;my-service&gt;</code>
+     * option on the docker CLI.
+     *
+     * @param aliases the list of aliases
+     * @return this
+     */
+    SELF withNetworkAliases(String... aliases);
+
     /**
      * Map a resource (file or directory) on the classpath to a path inside the container.
      * This will only work if you are running your tests outside a Docker container.

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

@@ -75,6 +75,12 @@ public class GenericContainer<SELF extends GenericContainer<SELF>>
     @NonNull
     private String networkMode;
 
+    @NonNull
+    private Network network;
+
+    @NonNull
+    private List<String> networkAliases = new ArrayList<>();
+
     @NonNull
     private Future<String> image;
 
@@ -412,7 +418,14 @@ private void applyConfiguration(CreateContainerCmd createCommand) {
                 .toArray(String[]::new);
         createCommand.withExtraHosts(extraHostsArray);
 
-        if (networkMode != null) {
+        if (network != null) {
+            if (!network.isCreated()) {
+                throw new ContainerLaunchException("Aborting attempt to use non-existing network " + network.getName());
+            }
+
+            createCommand.withNetworkMode(network.getName());
+            createCommand.withAliases(this.networkAliases);
+        } else if (networkMode != null) {
             createCommand.withNetworkMode(networkMode);
         }
 
@@ -615,6 +628,18 @@ public SELF withNetworkMode(String networkMode) {
         return self();
     }
 
+    @Override
+    public SELF withNetwork(Network network) {
+        this.network = network;
+        return self();
+    }
+
+    @Override
+    public SELF withNetworkAliases(String... aliases) {
+        Collections.addAll(this.networkAliases, aliases);
+        return self();
+    }
+
     /**
      * {@inheritDoc}
      */

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

@@ -0,0 +1,142 @@
+package org.testcontainers.containers;
+
+import com.github.dockerjava.api.command.CreateNetworkCmd;
+import lombok.*;
+import lombok.experimental.Delegate;
+import org.junit.rules.ExternalResource;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.utility.ResourceReaper;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+
+public interface Network extends AutoCloseable {
+
+    String getName();
+
+    Boolean getEnableIpv6();
+
+    String getDriver();
+
+    boolean isCreated();
+
+    @Override
+    default void close() {
+        if (isCreated()) {
+            ResourceReaper.instance().removeNetworks(getName());
+        }
+    }
+
+    @SneakyThrows
+    @SuppressWarnings("unchecked")
+    default <T extends Network> T as(Class<T> type) {
+        return type.getDeclaredConstructor(Network.class).newInstance(this);
+    }
+
+    static Network newNetwork() {
+        return builder().build();
+    }
+
+    static NetworkImpl.NetworkImplBuilder builder() {
+        return NetworkImpl.builder();
+    }
+
+    @Builder
+    @Getter
+    class NetworkImpl implements Network {
+
+        private final String name = UUID.randomUUID().toString();
+
+        private Boolean enableIpv6;
+
+        private String driver;
+
+        @Singular
+        private Set<Consumer<CreateNetworkCmd>> createNetworkCmdModifiers = new LinkedHashSet<>();
+
+        @Override
+        public boolean isCreated() {
+            return false;
+        }
+    }
+
+    @RequiredArgsConstructor
+    class Runnable implements Network, java.lang.Runnable {
+
+        @Delegate(excludes = Excludes.class)
+        protected final Network network;
+
+        private final AtomicBoolean created = new AtomicBoolean(false);
+
+        @Override
+        public void run() {
+            if (!created.getAndSet(true)) {
+                ResourceReaper.instance().registerNetworkForCleanup(getName());
+
+                CreateNetworkCmd createNetworkCmd = DockerClientFactory.instance().client().createNetworkCmd();
+
+                createNetworkCmd.withName(getName());
+                createNetworkCmd.withCheckDuplicate(true);
+
+                if (getEnableIpv6() != null) {
+                    createNetworkCmd.withEnableIpv6(getEnableIpv6());
+                }
+
+                if (getDriver() != null) {
+                    createNetworkCmd.withDriver(getDriver());
+                }
+
+                if (network instanceof NetworkImpl) {
+                    for (Consumer<CreateNetworkCmd> consumer : ((NetworkImpl) network).getCreateNetworkCmdModifiers()) {
+                        consumer.accept(createNetworkCmd);
+                    }
+                }
+
+                createNetworkCmd.exec();
+            }
+        }
+
+        @Override
+        public boolean isCreated() {
+            return created.get();
+        }
+    }
+
+    class AutoCreated implements Network {
+
+        @Delegate(types = Network.class)
+        protected final Network.Runnable network;
+
+        public AutoCreated(Network network) {
+            this.network = network.as(Runnable.class);
+            this.network.run();
+        }
+    }
+
+    class JUnitRule extends ExternalResource implements Network {
+
+        @Delegate(types = Network.class)
+        protected final Network.Runnable network;
+
+        public JUnitRule(Network network) {
+            this.network = network.as(Runnable.class);
+        }
+
+        @Override
+        protected void before() throws Throwable {
+            network.run();
+        }
+
+        @Override
+        protected void after() {
+            network.close();
+        }
+    }
+
+    interface Excludes {
+        boolean isCreated();
+    }
+}

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

@@ -5,15 +5,12 @@
 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.Container;
 import com.github.dockerjava.api.model.Network;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testcontainers.DockerClientFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -25,7 +22,7 @@ public final class ResourceReaper {
     private static ResourceReaper instance;
     private final DockerClient dockerClient;
     private Map<String, String> registeredContainers = new ConcurrentHashMap<>();
-    private List<String> registeredNetworks = new ArrayList<>();
+    private Set<String> registeredNetworks = Collections.newSetFromMap(new ConcurrentHashMap<>());
 
     private ResourceReaper() {
         dockerClient = DockerClientFactory.instance().client();
@@ -145,22 +142,34 @@ public void removeNetworks(String identifier) {
     }
 
     private void removeNetwork(String networkName) {
-        List<Network> networks;
         try {
-            networks = dockerClient.listNetworksCmd().withNameFilter(networkName).exec();
-        } catch (DockerException e) {
-            LOGGER.trace("Error encountered when looking up network for removal (name: {}) - it may not have been removed", networkName);
-            return;
-        }
+            try {
+                // First try to remove by name
+                dockerClient.removeNetworkCmd(networkName).exec();
+            } catch (Exception e) {
+                LOGGER.trace("Error encountered removing network by name ({}) - it may not have been removed", networkName);
+            }
 
-        for (Network network : networks) {
+            List<Network> networks;
             try {
-                dockerClient.removeNetworkCmd(network.getId()).exec();
-                registeredNetworks.remove(network.getId());
-                LOGGER.debug("Removed network: {}", networkName);
-            } catch (DockerException e) {
-                LOGGER.trace("Error encountered removing network (name: {}) - it may not have been removed", network.getName());
+                // Then try to list all networks with the same name
+                networks = dockerClient.listNetworksCmd().withNameFilter(networkName).exec();
+            } catch (Exception e) {
+                LOGGER.trace("Error encountered when looking up network for removal (name: {}) - it may not have been removed", networkName);
+                return;
+            }
+
+            for (Network network : networks) {
+                try {
+                    dockerClient.removeNetworkCmd(network.getId()).exec();
+                    registeredNetworks.remove(network.getId());
+                    LOGGER.debug("Removed network: {}", networkName);
+                } catch (Exception e) {
+                    LOGGER.trace("Error encountered removing network (name: {}) - it may not have been removed", network.getName());
+                }
             }
+        } finally {
+            registeredNetworks.remove(networkName);
         }
     }
 }