Add "VncRecordingContainer"

CHANGELOG.md

@@ -6,6 +6,7 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 - Added `getDatabaseName` method to JdbcDatabaseContainer, MySQLContainer, PostgreSQLContainer ([\#473](https://github.com/testcontainers/testcontainers-java/issues/473))
+- Added `VncRecordingContainer` - Network-based, attachable re-implementation of `VncRecordingSidekickContainer` ([\#526](https://github.com/testcontainers/testcontainers-java/pull/526))
 
 ## [1.5.0] - 2017-12-12
 ### Fixed

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

@@ -0,0 +1,157 @@
+package org.testcontainers.containers;
+
+import com.github.dockerjava.api.model.ContainerNetwork;
+import com.github.dockerjava.api.model.Frame;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import lombok.ToString;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
+import org.rnorth.ducttape.TimeoutException;
+import org.rnorth.ducttape.unreliables.Unreliables;
+import org.testcontainers.containers.output.FrameConsumerResultCallback;
+import org.testcontainers.utility.Base58;
+import org.testcontainers.utility.TestcontainersConfiguration;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+/**
+ * 'Sidekick container' with the sole purpose of recording the VNC screen output from another container.
+ *
+ */
+@Getter
+@ToString
+public class VncRecordingContainer extends GenericContainer<VncRecordingContainer> {
+
+    private static final String RECORDING_FILE_NAME = "/screen.flv";
+
+    public static final String DEFAULT_VNC_PASSWORD = "secret";
+
+    public static final int DEFAULT_VNC_PORT = 5900;
+
+    private final Supplier<String> targetContainerIdSupplier;
+
+    private String vncPassword = DEFAULT_VNC_PASSWORD;
+
+    private int vncPort = 5900;
+
+    private int frameRate = 30;
+
+    public VncRecordingContainer(@NonNull GenericContainer<?> targetContainer) {
+        this(targetContainer::getContainerId);
+    }
+
+    public VncRecordingContainer(@NonNull Supplier<String> targetContainerIdSupplier) {
+        super(TestcontainersConfiguration.getInstance().getVncRecordedContainerImage());
+        this.targetContainerIdSupplier = targetContainerIdSupplier;
+
+        waitingFor(new AbstractWaitStrategy() {
+
+            @Override
+            protected void waitUntilReady() {
+                try {
+                    Unreliables.retryUntilTrue((int) startupTimeout.toMillis(), TimeUnit.MILLISECONDS, () -> {
+                        CountDownLatch latch = new CountDownLatch(1);
+
+                        FrameConsumerResultCallback callback = new FrameConsumerResultCallback() {
+                            @Override
+                            public void onNext(Frame frame) {
+                                if (frame != null && new String(frame.getPayload()).contains("Connected")) {
+                                    latch.countDown();
+                                }
+                            }
+                        };
+
+                        try (
+                                Closeable __ = dockerClient.logContainerCmd(containerId)
+                                        .withFollowStream(true)
+                                        .withSince(0)
+                                        .withStdErr(true)
+                                        .exec(callback)
+                        ) {
+                            return latch.await(1, TimeUnit.SECONDS);
+                        }
+                    });
+                } catch (TimeoutException e) {
+                    throw new ContainerLaunchException("Timed out waiting for log output", e);
+                }
+            }
+        });
+    }
+
+    public VncRecordingContainer withVncPassword(@NonNull String vncPassword) {
+        this.vncPassword = vncPassword;
+        return this;
+    }
+
+    public VncRecordingContainer withVncPort(int vncPort) {
+        this.vncPort = vncPort;
+        return this;
+    }
+
+    public VncRecordingContainer withFrameRate(int frameRate) {
+        this.frameRate = frameRate;
+        return this;
+    }
+
+    @Override
+    protected void configure() {
+        withCreateContainerCmdModifier(it -> it.withEntrypoint("/bin/sh"));
+
+        if (getNetwork() == null) {
+            withNetwork(Network.newNetwork());
+        }
+
+        String alias = "vnchost-" + Base58.randomString(8);
+        dockerClient.connectToNetworkCmd()
+                .withContainerId(targetContainerIdSupplier.get())
+                .withNetworkId(getNetwork().getId())
+                .withContainerNetwork(new ContainerNetwork().withAliases(alias))
+                .exec();
+
+        setCommand(
+                "-c",
+                "echo '" + Base64.encodeBase64String(vncPassword.getBytes()) + "' | base64 -d > /vnc_password && " +
+                "flvrec.py -o " + RECORDING_FILE_NAME + " -d -r " + frameRate + " -P /vnc_password " + alias + " " + vncPort
+        );
+    }
+
+    @Override
+    public void stop() {
+        try {
+            dockerClient.disconnectFromNetworkCmd()
+                    .withContainerId(targetContainerIdSupplier.get())
+                    .withNetworkId(getNetwork().getId())
+                    .withForce(true)
+                    .exec();
+        } catch (Exception e) {
+            logger().warn("Failed to disconnect container with id '{}' from network '{}'", targetContainerIdSupplier.get(), getNetwork().getId(), e);
+        }
+
+        super.stop();
+    }
+
+    @SneakyThrows
+    public InputStream streamRecord() {
+        TarArchiveInputStream archiveInputStream = new TarArchiveInputStream(
+                dockerClient.copyArchiveFromContainerCmd(containerId, RECORDING_FILE_NAME).exec()
+        );
+        archiveInputStream.getNextEntry();
+        return archiveInputStream;
+    }
+
+    @SneakyThrows
+    public void saveRecordToFile(File file) {
+        try(InputStream inputStream = streamRecord()) {
+            Files.copy(inputStream, file.toPath(), StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+}

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

@@ -17,7 +17,10 @@
 
 /**
  * 'Sidekick container' with the sole purpose of recording the VNC screen output from another container.
+ *
+ * @deprecated please use {@link VncRecordingContainer}
  */
+@Deprecated
 public class VncRecordingSidekickContainer<SELF extends VncRecordingSidekickContainer<SELF, T>, T extends VncService & LinkableContainer> extends GenericContainer<SELF> {
     private final T vncServiceContainer;
     private final Path tempDir;

core/src/main/java/org/testcontainers/containers/traits/VncService.java

@@ -3,6 +3,7 @@
 /**
  * A container which exposes a VNC server.
  */
+@Deprecated
 public interface VncService {
     /**
      * @return a URL which can be used to connect to the VNC server from the machine running the tests. Exposed for convenience, e.g. to aid manual debugging

modules/selenium/src/main/java/org/testcontainers/containers/BrowserWebDriverContainer.java

@@ -23,8 +23,6 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
@@ -54,7 +52,7 @@ public class BrowserWebDriverContainer<SELF extends BrowserWebDriverContainer<SE
     private RecordingFileFactory recordingFileFactory;
     private File vncRecordingDirectory = new File("/tmp");
 
-    private final Collection<VncRecordingSidekickContainer> currentVncRecordings = new ArrayList<>();
+    private VncRecordingContainer vncRecordingContainer = null;
 
     private static final Logger LOGGER = LoggerFactory.getLogger(BrowserWebDriverContainer.class);
 
@@ -102,6 +100,12 @@ protected void configure() {
             throw new IllegalStateException();
         }
 
+        if (recordingMode != VncRecordingMode.SKIP) {
+            vncRecordingContainer = new VncRecordingContainer(this)
+                    .withVncPassword(DEFAULT_PASSWORD)
+                    .withVncPort(VNC_PORT);
+        }
+
         if (!customImageNameIsSet) {
             super.setDockerImageName(getImageForCapabilities(desiredCapabilities));
         }
@@ -164,19 +168,15 @@ public int getPort() {
 
     @Override
     protected void containerIsStarted(InspectContainerResponse containerInfo) {
-        if (recordingMode != VncRecordingMode.SKIP) {
-            LOGGER.debug("Starting VNC recording");
-
-            VncRecordingSidekickContainer recordingSidekickContainer = new VncRecordingSidekickContainer<>(this);
-
-            recordingSidekickContainer.start();
-            currentVncRecordings.add(recordingSidekickContainer);
-        }
-
         driver = Unreliables.retryUntilSuccess(30, TimeUnit.SECONDS,
-                Timeouts.getWithTimeout(10, TimeUnit.SECONDS,
+                Timeouts.getWithTimeout(1, TimeUnit.SECONDS,
                         () ->
                                 () -> new RemoteWebDriver(getSeleniumAddress(), desiredCapabilities)));
+
+        if (vncRecordingContainer != null) {
+            LOGGER.debug("Starting VNC recording");
+            vncRecordingContainer.start();
+        }
     }
 
     /**
@@ -193,39 +193,41 @@ public RemoteWebDriver getWebDriver() {
 
     @Override
     protected void failed(Throwable e, Description description) {
-        switch (recordingMode) {
-            case RECORD_FAILING:
-            case RECORD_ALL:
-                stopAndRetainRecordingForDescriptionAndSuccessState(description, false);
-                break;
-        }
-        currentVncRecordings.clear();
+        stopAndRetainRecordingForDescriptionAndSuccessState(description, false);
     }
 
     @Override
     protected void succeeded(Description description) {
-        switch (recordingMode) {
-            case RECORD_ALL:
-                stopAndRetainRecordingForDescriptionAndSuccessState(description, true);
-                break;
-        }
-        currentVncRecordings.clear();
+        stopAndRetainRecordingForDescriptionAndSuccessState(description, true);
     }
 
     @Override
-    protected void finished(Description description) {
+    public void stop() {
         if (driver != null) {
-            driver.quit();
+            try {
+                driver.quit();
+            } catch (Exception e) {
+                LOGGER.debug("Failed to quit the driver", e);
+            }
+        }
+
+        if (vncRecordingContainer != null) {
+            try {
+                vncRecordingContainer.stop();
+            } catch (Exception e) {
+                LOGGER.debug("Failed to stop vncRecordingContainer", e);
+            }
         }
-        this.stop();
+
+        super.stop();
     }
 
     private void stopAndRetainRecordingForDescriptionAndSuccessState(Description description, boolean succeeded) {
-        File recordingFile = recordingFileFactory.recordingFileForTest(vncRecordingDirectory, description, succeeded);
-        LOGGER.info("Screen recordings for test {} will be stored at: {}", description.getDisplayName(), recordingFile);
+        if (recordingMode == VncRecordingMode.RECORD_ALL || (!succeeded && recordingMode == VncRecordingMode.RECORD_FAILING)) {
+            File recordingFile = recordingFileFactory.recordingFileForTest(vncRecordingDirectory, description, succeeded);
+            LOGGER.info("Screen recordings for test {} will be stored at: {}", description.getDisplayName(), recordingFile);
 
-        for (VncRecordingSidekickContainer container : currentVncRecordings) {
-            container.stopAndRetainRecording(recordingFile);
+            vncRecordingContainer.saveRecordToFile(recordingFile);
         }
     }
 

modules/selenium/src/test/java/org/testcontainers/junit/BaseWebDriverContainerTest.java

@@ -8,6 +8,7 @@
 import java.util.concurrent.TimeUnit;
 
 import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
+import static org.rnorth.visibleassertions.VisibleAssertions.assertTrue;
 
 /**
  *
@@ -28,15 +29,18 @@ protected void doSimpleWebdriverTest(BrowserWebDriverContainer rule) {
     }
 
     @NotNull
-    private RemoteWebDriver setupDriverFromRule(BrowserWebDriverContainer rule) {
+    private static RemoteWebDriver setupDriverFromRule(BrowserWebDriverContainer rule) {
         RemoteWebDriver driver = rule.getWebDriver();
         driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
         return driver;
     }
 
-    protected void doSimpleExplore(BrowserWebDriverContainer rule) {
+    protected static void doSimpleExplore(BrowserWebDriverContainer rule) {
         RemoteWebDriver driver = setupDriverFromRule(rule);
         driver.get("http://en.wikipedia.org/wiki/Randomness");
+
+        // Oh! The irony!
+        assertTrue("Randomness' description has the word 'pattern'", driver.findElementByPartialLinkText("pattern").isDisplayed());
     }
 
 }

modules/selenium/src/test/java/org/testcontainers/junit/ChromeRecordingWebDriverContainerTest.java

@@ -2,6 +2,8 @@
 
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
 import org.openqa.selenium.remote.DesiredCapabilities;
 import org.testcontainers.containers.BrowserWebDriverContainer;
 import org.testcontainers.containers.DefaultRecordingFileFactory;
@@ -10,29 +12,32 @@
 
 import static org.testcontainers.containers.BrowserWebDriverContainer.VncRecordingMode.RECORD_ALL;
 
-/**
- *
- */
+@RunWith(Enclosed.class)
 public class ChromeRecordingWebDriverContainerTest extends BaseWebDriverContainerTest {
 
-    @Rule
-    public BrowserWebDriverContainer chromeThatRecordsAllTests = new BrowserWebDriverContainer()
-            .withDesiredCapabilities(DesiredCapabilities.chrome())
-            .withRecordingMode(RECORD_ALL, new File("./target/"))
-            .withRecordingFileFactory(new DefaultRecordingFileFactory());
+    public static class ChromeThatRecordsAllTests {
 
-    @Rule
-    public BrowserWebDriverContainer chromeThatRecordsFailingTests = new BrowserWebDriverContainer()
-            .withDesiredCapabilities(DesiredCapabilities.chrome());
+        @Rule
+        public BrowserWebDriverContainer chrome = new BrowserWebDriverContainer()
+                .withDesiredCapabilities(DesiredCapabilities.chrome())
+                .withRecordingMode(RECORD_ALL, new File("./target/"))
+                .withRecordingFileFactory(new DefaultRecordingFileFactory());
 
-
-    @Test
-    public void recordingTestThatShouldBeRecordedButDeleted() {
-        doSimpleExplore(chromeThatRecordsFailingTests);
+        @Test
+        public void recordingTestThatShouldBeRecordedAndRetained() {
+            doSimpleExplore(chrome);
+        }
     }
 
-    @Test
-    public void recordingTestThatShouldBeRecordedAndRetained() {
-        doSimpleExplore(chromeThatRecordsAllTests);
+    public static class ChromeThatRecordsFailingTests {
+
+        @Rule
+        public BrowserWebDriverContainer chrome = new BrowserWebDriverContainer()
+                .withDesiredCapabilities(DesiredCapabilities.chrome());
+
+        @Test
+        public void recordingTestThatShouldBeRecordedButDeleted() {
+            doSimpleExplore(chrome);
+        }
     }
 }