[grid] Allowing a path on the host & container to be configurable [skip ci]

When we run inside a container, we need to know where to save the
assets inside it, which is not the same path we have on the host.
The user will mount the host path to the container path, so for
the user the assets will end up on the same path on their host
machine.

Author: diemol

java/server/src/org/openqa/selenium/grid/docker/DockerFlags.java

@@ -68,11 +68,24 @@ public class DockerFlags implements HasRoles {
 
   @Parameter(
     names = {"--docker-assets-path"},
-    description = "Absolute path where videos will be stored"
+    description = "Absolute path where assets will be stored"
   )
   @ConfigValue(section = "docker", name = "assets-path", example = "\"/absolute/path/to/assets/path\"")
   private String assetsPath;
 
+  @Parameter(
+    names = {"--docker-container-assets-path"},
+    description = "Absolute path where assets inside the container will be stored. Use it when " +
+                  "running inside a Docker container.",
+    hidden = true
+  )
+  @ConfigValue(
+    section = "docker",
+    name = "container-assets-path",
+    example = "\"/absolute/path/to/container/assets/path\""
+  )
+  private String containerAssetsPath;
+
   @Override
   public Set<Role> getRoles() {
     return Collections.singleton(NODE_ROLE);

java/server/src/org/openqa/selenium/grid/docker/DockerOptions.java

@@ -180,8 +180,18 @@ private Image getVideoImage(Docker docker) {
     return videoImage.map(docker::getImage).orElse(null);
   }
 
-  private String getAssetsPath() {
-    return config.get(DOCKER_SECTION, "assets-path").orElse("");
+  private DockerSessionAssetsPath getAssetsPath() {
+    Optional<String> hostAssetsPath = config.get(DOCKER_SECTION, "assets-path");
+    Optional<String> containerAssetsPath = config.get(DOCKER_SECTION, "container-assets-path");
+    if (hostAssetsPath.isPresent() && containerAssetsPath.isPresent()) {
+      return new DockerSessionAssetsPath(hostAssetsPath.get(), containerAssetsPath.get());
+    } else if (hostAssetsPath.isPresent()) {
+      // If only the host assets path is present, we assume this is not running inside a container.
+      return new DockerSessionAssetsPath(hostAssetsPath.get(), hostAssetsPath.get());
+    }
+    // We should not reach this point because the invocation to this method is
+    // guarded by `isVideoRecordingAvailable()`
+    return null;
   }
 
   private void loadImages(Docker docker, String... imageNames) {

java/server/src/org/openqa/selenium/grid/docker/DockerSessionAssetsPath.java

@@ -0,0 +1,63 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.openqa.selenium.grid.docker;
+
+import org.openqa.selenium.remote.SessionId;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class DockerSessionAssetsPath {
+
+  private static final Logger LOG = Logger.getLogger(DockerSessionAssetsPath.class.getName());
+
+  private final String hostAssetsPath;
+  private final String containerAssetsPath;
+
+  public DockerSessionAssetsPath(String hostAssetsPath, String containerAssetsPath) {
+    this.hostAssetsPath = hostAssetsPath;
+    this.containerAssetsPath = containerAssetsPath;
+  }
+
+  public Optional<Path> createHostSessionAssetsPath(SessionId id) {
+    return createSessionAssetsPath(this.hostAssetsPath, id);
+  }
+
+  public Optional<Path> createContainerSessionAssetsPath(SessionId id) {
+    return createSessionAssetsPath(this.containerAssetsPath, id);
+  }
+
+  private Optional<Path> createSessionAssetsPath(String assetsPath, SessionId id) {
+    if (assetsPath == null || assetsPath.isEmpty()) {
+      return Optional.empty();
+    }
+    try {
+      return Optional.of(Files.createDirectories(Paths.get(assetsPath, id.toString())));
+    } catch (IOException e) {
+      LOG.log(Level.WARNING,
+              "Failed to create path to store session assets, no assets will be stored: " +
+              assetsPath, e);
+    }
+    return Optional.empty();
+  }
+}

java/server/src/org/openqa/selenium/grid/docker/DockerSessionFactory.java

@@ -91,7 +91,7 @@ public class DockerSessionFactory implements SessionFactory {
   private final Capabilities stereotype;
   private boolean isVideoRecordingAvailable;
   private Image videoImage;
-  private String assetsPath;
+  private DockerSessionAssetsPath assetsPath;
 
   public DockerSessionFactory(
       Tracer tracer,
@@ -110,8 +110,15 @@ public DockerSessionFactory(
     this.isVideoRecordingAvailable = false;
   }
 
-  public DockerSessionFactory(Tracer tracer, HttpClient.Factory clientFactory, Docker docker, URI dockerUri,
-    Image browserImage, Capabilities stereotype, Image videoImage, String assetsPath) {
+  public DockerSessionFactory(
+    Tracer tracer,
+    HttpClient.Factory clientFactory,
+    Docker docker,
+    URI dockerUri,
+    Image browserImage,
+    Capabilities stereotype,
+    Image videoImage,
+    DockerSessionAssetsPath assetsPath) {
     this(tracer, clientFactory, docker, dockerUri, browserImage, stereotype);
     this.isVideoRecordingAvailable = true;
     this.videoImage = videoImage;
@@ -201,16 +208,17 @@ public Optional<ActiveSession> apply(CreateSessionRequest sessionRequest) {
 
       SessionId id = new SessionId(response.getSessionId());
       Capabilities capabilities = new ImmutableCapabilities((Map<?, ?>) response.getValue());
-      Optional<Path> sessionAssetsPath = createSessionAssetsPath(assetsPath, id);
-      sessionAssetsPath.ifPresent(path -> saveSessionCapabilities(capabilities, path));
+      Optional<Path> containerAssetsPath = assetsPath.createContainerSessionAssetsPath(id);
+      containerAssetsPath.ifPresent(path -> saveSessionCapabilities(capabilities, path));
       Container videoContainer = null;
       if (isVideoRecordingAvailable && recordVideoForSession(capabilities)) {
         Map<String, String> envVars = getVideoContainerEnvVars(
           capabilities,
           containerInfo.getIp());
-        if (sessionAssetsPath.isPresent()) {
+        Optional<Path> hostAssetsPath = assetsPath.createHostSessionAssetsPath(id);
+        if (hostAssetsPath.isPresent()) {
           Map<String, String> volumeBinds =
-            Collections.singletonMap(sessionAssetsPath.get().toString(), "/videos");
+            Collections.singletonMap(hostAssetsPath.get().toString(), "/videos");
           videoContainer = docker.create(image(videoImage).env(envVars).bind(volumeBinds));
           videoContainer.start();
           LOG.info(String.format("Video container started (id: %s)", videoContainer.getId()));
@@ -320,16 +328,6 @@ private Object getCapability(Capabilities sessionRequestCapabilities, String cap
     return null;
   }
 
-  private Optional<Path> createSessionAssetsPath(String assetsPath, SessionId id) {
-    try {
-      return Optional.of(Files.createDirectories(Paths.get(assetsPath, id.toString())));
-    } catch (IOException e) {
-      LOG.log(Level.WARNING,
-              "Failed to create path to store session assets, no assets will be stored", e);
-    }
-    return Optional.empty();
-  }
-
   private void saveSessionCapabilities(Capabilities sessionRequestCapabilities, Path assetsPath) {
     String capsToJson = new Json().toJson(sessionRequestCapabilities);
     try {