Add support for Windows containers (WCOW)

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

@@ -95,6 +95,8 @@ static Map<String, String> markerLabels() {
 
     private String activeApiVersion;
 
+    private boolean runningWindowsContainers;
+
     @Getter(lazy = true)
     private final boolean fileMountingSupported = checkMountableFile();
 
@@ -212,6 +214,8 @@ public void close() {
         Version version = client.versionCmd().exec();
         log.debug("Docker version: {}", version.getRawValues());
         activeApiVersion = version.getApiVersion();
+        String osType = dockerInfo.getOsType();
+        runningWindowsContainers = StringUtils.isNotBlank(osType) && osType.equals("windows");
 
         String serverInfo =
             "Connected to docker: \n" +
@@ -223,6 +227,7 @@ public void close() {
             "\n" +
             "  Operating System: " +
             dockerInfo.getOperatingSystem() +
+            (runningWindowsContainers ? " (WCOW)" : "") +
             "\n" +
             "  Total Memory: " +
             dockerInfo.getMemTotal() /
@@ -383,6 +388,14 @@ public String getActiveApiVersion() {
         return activeApiVersion;
     }
 
+    /**
+     * @return whether the daemon is running Windows containers
+     */
+    public boolean isRunningWindowsContainers() {
+        client();
+        return runningWindowsContainers;
+    }
+
     /**
      * @return the docker execution driver of the daemon that we have connected to
      */

core/src/main/java/org/testcontainers/dockerclient/DockerClientProviderStrategy.java

@@ -104,8 +104,8 @@ public boolean allowUserOverrides() {
     }
 
     /**
-   /* @return the path under which the Docker unix socket is reachable relative to the Docker daemon
-    */
+     * @return the path under which the Docker unix socket is reachable relative to the Docker daemon
+     */
     public String getRemoteDockerUnixSocketPath() {
         return null;
     }
@@ -301,7 +301,7 @@ private static boolean tryOutStrategy(List<String> configurationFailures, Docker
             String osType = strategy.getInfo().getOsType();
             if (StringUtils.isBlank(osType)) {
                 log.warn("Could not determine Docker OS type");
-            } else if (!osType.equals("linux")) {
+            } else if (!osType.equals("linux") && !osType.equals("windows")) {
                 log.warn("{} is currently not supported", osType);
                 throw new InvalidConfigurationException(osType + " containers are currently not supported");
             }

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

@@ -10,19 +10,25 @@ class RyukContainer extends GenericContainer<RyukContainer> {
 
     RyukContainer() {
         super("testcontainers/ryuk:0.9.0");
+        DockerClientFactory clientFactory = DockerClientFactory.instance();
         withExposedPorts(8080);
         withCreateContainerCmdModifier(cmd -> {
             cmd.withName("testcontainers-ryuk-" + DockerClientFactory.SESSION_ID);
             cmd.withHostConfig(
                 cmd
                     .getHostConfig()
                     .withAutoRemove(true)
-                    .withPrivileged(TestcontainersConfiguration.getInstance().isRyukPrivileged())
+                    .withPrivileged(
+                        TestcontainersConfiguration.getInstance().isRyukPrivileged() &&
+                        !clientFactory.isRunningWindowsContainers()
+                    )
                     .withBinds(
-                        new Bind(
-                            DockerClientFactory.instance().getRemoteDockerUnixSocketPath(),
-                            new Volume("/var/run/docker.sock")
-                        )
+                        clientFactory.isRunningWindowsContainers()
+                            ? new Bind("//./pipe/docker_engine", new Volume("//./pipe/docker_engine"))
+                            : new Bind(
+                                clientFactory.getRemoteDockerUnixSocketPath(),
+                                new Volume("/var/run/docker.sock")
+                            )
                     )
             );
         });

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

@@ -31,7 +31,7 @@ class RyukResourceReaper extends ResourceReaper {
         .withConstantThroughput()
         .build();
 
-    private final AtomicBoolean started = new AtomicBoolean(false);
+    private static final AtomicBoolean started = new AtomicBoolean(false);
 
     private final RyukContainer ryukContainer = new RyukContainer();
 

core/src/test/java/org/testcontainers/utility/ResourceReaperTest.java

@@ -8,6 +8,7 @@
 import org.junit.Test;
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
 import org.zeroturnaround.exec.ProcessExecutor;
 import org.zeroturnaround.exec.ProcessResult;
 
@@ -103,10 +104,31 @@ public static void main(String[] args) {
                 LABELS_MARKER + new ObjectMapper().writeValueAsString(ResourceReaper.instance().getLabels())
             );
 
-            GenericContainer<?> container = new GenericContainer<>("testcontainers/helloworld:1.1.0")
+            GenericContainer<?> container = new GenericContainer<>(
+                "testcontainers/helloworld:sha-141af7909907e04b124e691d3cd6fc7c32da2207"
+            )
                 .withNetwork(org.testcontainers.containers.Network.newNetwork())
                 .withExposedPorts(8080);
 
+            DockerClientFactory clientFactory = DockerClientFactory.instance();
+            if (clientFactory.isRunningWindowsContainers()) {
+                // Override the default WaitStrategy (HostPortWaitStrategy),
+                // which doesn't work on Windows, yet.
+                // See the InternalCommandPortListeningCheck.
+                container.setWaitStrategy(
+                    new AbstractWaitStrategy() {
+                        @Override
+                        protected void waitUntilReady() {
+                            try {
+                                Thread.sleep(1000);
+                            } catch (InterruptedException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    }
+                );
+            }
+
             container.start();
         }
     }