[grid] Accepting TZ and screenResolution

A user can now get a container in the
time zone and screen resolution they
prefer.

Author: diemol

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

@@ -17,8 +17,8 @@
 
 package org.openqa.selenium.grid.docker;
 
-import com.google.common.collect.ImmutableMap;
 import org.openqa.selenium.Capabilities;
+import org.openqa.selenium.Dimension;
 import org.openqa.selenium.ImmutableCapabilities;
 import org.openqa.selenium.SessionNotCreatedException;
 import org.openqa.selenium.TimeoutException;
@@ -57,14 +57,17 @@
 import java.net.URL;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.TimeZone;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import static java.util.Optional.ofNullable;
 import static org.openqa.selenium.docker.ContainerConfig.image;
 import static org.openqa.selenium.remote.Dialect.W3C;
 import static org.openqa.selenium.remote.http.Contents.string;
@@ -130,7 +133,11 @@ public Optional<ActiveSession> apply(CreateSessionRequest sessionRequest) {
       attributeMap.put(AttributeKey.LOGGER_CLASS.getKey(),
                        EventAttribute.setValue(this.getClass().getName()));
       LOG.info("Creating container, mapping container port 4444 to " + port);
-      Container container = docker.create(image(browserImage).map(Port.tcp(4444), Port.tcp(port)));
+      Map<String, String> browserContainerEnvVars = getBrowserContainerEnvVars(sessionRequest.getCapabilities());
+        Container container = docker.create(
+          image(browserImage)
+            .env(browserContainerEnvVars)
+            .map(Port.tcp(4444), Port.tcp(port)));
       container.start();
       ContainerInfo containerInfo = container.inspect();
 
@@ -188,9 +195,10 @@ public Optional<ActiveSession> apply(CreateSessionRequest sessionRequest) {
       Capabilities capabilities = new ImmutableCapabilities((Map<?, ?>) response.getValue());
       Container videoContainer = null;
       if (isVideoRecordingAvailable && recordVideoForSession(sessionRequest.getCapabilities())) {
-        Map<String, String> envVars = ImmutableMap.of(
-          "DISPLAY_CONTAINER_NAME", containerInfo.getIp(),
-          "FILE_NAME", String.format("%s.mp4", id));
+        Map<String, String> envVars = getVideoContainerEnvVars(
+          sessionRequest.getCapabilities(),
+          containerInfo.getIp(),
+          id.toString());
         Map<String, String> volumeBinds = Collections.singletonMap(storagePath, "/videos");
         videoContainer = docker.create(image(videoImage).env(envVars).bind(volumeBinds));
         videoContainer.start();
@@ -223,13 +231,81 @@ public Optional<ActiveSession> apply(CreateSessionRequest sessionRequest) {
     }
   }
 
-  private boolean recordVideoForSession(Capabilities sessionRequestCapabilities) {
-      Object rawSeleniumOptions = sessionRequestCapabilities.getCapability("se:options");
-      if (rawSeleniumOptions instanceof Map) {
-          @SuppressWarnings("unchecked") Map<String, Object> seleniumOptions = (Map<String, Object>) rawSeleniumOptions;
-          return Boolean.parseBoolean(seleniumOptions.getOrDefault("recordVideo", false).toString());
+  private Map<String, String> getBrowserContainerEnvVars(Capabilities sessionRequestCapabilities) {
+    Optional<Dimension> screenResolution =
+      ofNullable(getScreenResolution(sessionRequestCapabilities));
+    Map<String, String> envVars = new HashMap<>();
+    if (screenResolution.isPresent()) {
+      envVars.put("SCREEN_WIDTH", String.valueOf(screenResolution.get().getWidth()));
+      envVars.put("SCREEN_HEIGHT", String.valueOf(screenResolution.get().getHeight()));
+    }
+    Optional<TimeZone> timeZone = ofNullable(getTimeZone(sessionRequestCapabilities));
+    timeZone.ifPresent(zone -> envVars.put("TZ", zone.getID()));
+    return envVars;
+  }
+
+  private Map<String, String> getVideoContainerEnvVars(Capabilities sessionRequestCapabilities,
+    String containerIp, String fileName) {
+    Map<String, String> envVars = new HashMap<>();
+    envVars.put("DISPLAY_CONTAINER_NAME", containerIp);
+    envVars.put("FILE_NAME", String.format("%s.mp4", fileName));
+    Optional<Dimension> screenResolution =
+      ofNullable(getScreenResolution(sessionRequestCapabilities));
+    screenResolution.ifPresent(dimension -> envVars
+      .put("VIDEO_SIZE", String.format("%sx%s", dimension.getWidth(), dimension.getHeight())));
+    return envVars;
+  }
+
+  private TimeZone getTimeZone(Capabilities sessionRequestCapabilities) {
+    Optional<Object> timeZone =
+      ofNullable(getCapability(sessionRequestCapabilities, "timeZone"));
+    if (timeZone.isPresent()) {
+      String tz =  timeZone.get().toString();
+      if (Arrays.asList(TimeZone.getAvailableIDs()).contains(tz)) {
+        return TimeZone.getTimeZone(tz);
       }
-      return false;
+    }
+    return null;
+  }
+
+  private Dimension getScreenResolution(Capabilities sessionRequestCapabilities) {
+    Optional<Object> screenResolution =
+      ofNullable(getCapability(sessionRequestCapabilities, "screenResolution"));
+    if (screenResolution.isEmpty()) {
+      return null;
+    }
+    try {
+      String[] resolution = screenResolution.get().toString().split("x");
+      int screenWidth = Integer.parseInt(resolution[0]);
+      int screenHeight = Integer.parseInt(resolution[1]);
+      if (screenWidth > 0 && screenHeight > 0) {
+        return new Dimension(screenWidth, screenHeight);
+      } else {
+        LOG.warning("One of the values provided for screenResolution is negative, " +
+          "defaults will be used. Received value: " + screenResolution);
+      }
+    } catch (Exception e) {
+      LOG.warning("Values provided for screenResolution are not valid integers or " +
+                  "either width or height are missing, defaults will be used." +
+                  "Received value: " + screenResolution);
+    }
+    return null;
+  }
+
+  private boolean recordVideoForSession(Capabilities sessionRequestCapabilities) {
+    Optional<Object> recordVideo =
+      ofNullable(getCapability(sessionRequestCapabilities, "recordVideo"));
+    return recordVideo.isPresent() && Boolean.parseBoolean(recordVideo.get().toString());
+  }
+
+  private Object getCapability(Capabilities sessionRequestCapabilities, String capabilityName) {
+    Object rawSeleniumOptions = sessionRequestCapabilities.getCapability("se:options");
+    if (rawSeleniumOptions instanceof Map) {
+      @SuppressWarnings("unchecked")
+      Map<String, Object> seleniumOptions = (Map<String, Object>) rawSeleniumOptions;
+      return seleniumOptions.get(capabilityName);
+    }
+    return null;
   }
 
   private void waitForServerToStart(HttpClient client, Duration duration) {