Merge pull request #27 from raydouglass/docker-19

[REVIEW] Detect and use gpu flag

Author: raydouglass

src/main/java/com/gpuopenanalytics/jenkins/remotedocker/DockerLauncher.java

@@ -60,6 +60,7 @@ public class DockerLauncher extends Launcher {
     private TaskListener listener;
     private RemoteDockerBuildWrapper buildWrapper;
     private AbstractBuild build;
+    private DockerVersion version;
 
     private transient Optional<DockerNetwork> network = Optional.empty();
     private transient List<String> containerIds = new ArrayList<>();
@@ -84,6 +85,12 @@ public DockerLauncher(boolean debug,
         this.delegate = delegate;
         this.listener = listener;
         this.buildWrapper = buildWrapper;
+        try {
+            this.version = parseVersion();
+            getListener().getLogger().println(this.version);
+        } catch (IOException | InterruptedException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     @Override
@@ -339,4 +346,32 @@ public AbstractBuild getBuild() {
     public boolean isDebug() {
         return debug;
     }
+
+    public DockerVersion getVersion() {
+        return version;
+    }
+
+    private DockerVersion parseVersion() throws IOException, InterruptedException {
+        ArgumentListBuilder args = new ArgumentListBuilder("docker",
+                                                           "--version");
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        int status = executeCommand(args)
+                .stdout(baos)
+                .stderr(getListener().getLogger())
+                .join();
+
+        if (status != 0) {
+            throw new IOException("Could not get docker version");
+        }
+        String versionString = baos.toString(StandardCharsets.UTF_8.name())
+                .trim();
+        try {
+            return DockerVersion.fromVersionString(versionString);
+        } catch (DockerVersion.VersionParseException e) {
+            getListener().getLogger().println(
+                    "WARN - Could not parse docker version");
+            e.printStackTrace(getListener().getLogger());
+            return DockerVersion.DEFAULT;
+        }
+    }
 }

src/main/java/com/gpuopenanalytics/jenkins/remotedocker/DockerVersion.java

@@ -0,0 +1,109 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2020, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.gpuopenanalytics.jenkins.remotedocker;
+
+import java.io.Serializable;
+
+public class DockerVersion implements Serializable {
+
+    public static final DockerVersion DEFAULT = new DockerVersion(0, 0, 0, null,
+                                                                  "0");
+
+    private int major;
+    private int minor;
+    private int patch;
+    private String extra;
+    private String build;
+
+    private DockerVersion(int major,
+                          int minor,
+                          int patch,
+                          String extra,
+                          String build) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.extra = extra;
+        this.build = build;
+    }
+
+    /**
+     * Parse from output of <code>docker --version</code> such as <code>Docker
+     * version 19.03.5, build 633a0ea</code>
+     *
+     * @return
+     */
+    public static DockerVersion fromVersionString(String versionString) throws VersionParseException {
+        try {
+            String[] split = versionString.split("\\s");
+            String build = split[split.length - 1];
+            String[] version = split[2].substring(0, split[2].length() - 1)
+                    .split(
+                            "\\.");
+            int major = Integer.parseInt(version[0]);
+            int minor = Integer.parseInt(version[1]);
+            int patch = 0;
+            String extra = null;
+            if (version[2].contains("-")) {
+                patch = Integer.parseInt(
+                        version[2].substring(0, version[2].indexOf('-')));
+                extra = version[2].substring(version[2].indexOf('-') + 1);
+            } else {
+                patch = Integer.parseInt(version[2]);
+            }
+            return new DockerVersion(major, minor, patch, extra, build);
+        } catch (Exception e) {
+            throw new VersionParseException(versionString, e);
+        }
+    }
+
+    public String getVersionString() {
+        return String.format("%02d.%02d.%d", major, minor, patch);
+    }
+
+    public boolean hasGpuFlag() {
+        return "19.03.0".compareTo(getVersionString()) < 0;
+    }
+
+    public String toString() {
+        if (extra != null) {
+            return String.format("Docker version %s-%s, build %s",
+                                 getVersionString(),
+                                 extra,
+                                 build);
+        } else {
+            return String.format("Docker version %s, build %s",
+                                 getVersionString(),
+                                 build);
+        }
+    }
+
+    public static class VersionParseException extends Exception {
+
+        public VersionParseException(String version, Throwable cause) {
+            super(String.format("Could not parse '%s'", version), cause);
+        }
+    }
+}

src/main/java/com/gpuopenanalytics/jenkins/remotedocker/config/DockerRuntimeConfigItem.java

@@ -61,7 +61,15 @@ public void validate() throws Descriptor.FormException {
     public void addCreateArgs(DockerLauncher launcher,
                               ArgumentListBuilder args,
                               AbstractBuild build) {
-        args.addKeyValuePair("", "--runtime", getResolvedValue(launcher), false);
+        String runtime = getResolvedValue(launcher);
+        if (!launcher.getVersion().hasGpuFlag() || !"nvidia".equals(runtime)) {
+            //If the runtime is nvidia, but the version supports --gpus, ignore the runtime
+            args.addKeyValuePair("", "--runtime", runtime,
+                                 false);
+        } else {
+            launcher.getListener().getLogger().println(
+                    "WARN Runtime is 'nvidia', but docker version supports --gpus. Ignoring 'nvidia' runtime.");
+        }
     }
 
     @Extension

src/main/java/com/gpuopenanalytics/jenkins/remotedocker/config/NvidiaGpuDevicesConfigItem.java

@@ -70,19 +70,23 @@ public void validate() throws Descriptor.FormException {
     public void addCreateArgs(DockerLauncher launcher,
                               ArgumentListBuilder args,
                               AbstractBuild build) {
-        args.add("-e");
+        String value;
         if ("executor".equals(getValue())) {
             try {
-                String index = build.getEnvironment(launcher.getListener())
+                value = build.getEnvironment(launcher.getListener())
                         .get("EXECUTOR_NUMBER", null);
-                args.addKeyValuePair("", ENV_VAR_NAME, index,
-                                     false);
             } catch (IOException | InterruptedException e) {
                 throw new RuntimeException(e);
             }
         } else {
-            args.addKeyValuePair("", ENV_VAR_NAME, getResolvedValue(launcher),
-                                 false);
+            value = getResolvedValue(launcher);
+        }
+
+        if (launcher.getVersion().hasGpuFlag()) {
+            args.add("--gpus", value);
+        } else {
+            args.add("-e");
+            args.addKeyValuePair("", ENV_VAR_NAME, value, false);
         }
     }