Only define Docker pkg tests if Docker is available

Vagrantfile

@@ -216,6 +216,10 @@ def ubuntu_docker(config)
 
     # Add vagrant to the Docker group, so that it can run commands
     usermod -aG docker vagrant
+
+    # Enable IPv4 forwarding
+    sed -i '/net.ipv4.ip_forward/s/^#//' /etc/sysctl.conf
+    systemctl restart networking
   SHELL
 end
 

buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy

@@ -78,16 +78,17 @@ import org.gradle.external.javadoc.CoreJavadocOptions
 import org.gradle.internal.jvm.Jvm
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 import org.gradle.process.CommandLineArgumentProvider
-import org.gradle.process.ExecResult
-import org.gradle.process.ExecSpec
 import org.gradle.util.GradleVersion
 
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
-import java.util.regex.Matcher
 
+import static DockerUtils.DOCKER_BINARIES
+import static DockerUtils.getDockerAvailability
+import static DockerUtils.getDockerPath
 import static org.elasticsearch.gradle.tool.Boilerplate.findByName
 import static org.elasticsearch.gradle.tool.Boilerplate.maybeConfigure
+
 /**
  * Encapsulates build configuration for elasticsearch projects.
  */
@@ -189,8 +190,7 @@ class BuildPlugin implements Plugin<Project> {
              */
 
             // check if the Docker binary exists and record its path
-            final List<String> maybeDockerBinaries = ['/usr/bin/docker', '/usr/local/bin/docker']
-            final String dockerBinary = maybeDockerBinaries.find { it -> new File(it).exists() }
+            final String dockerBinary = getDockerPath().orElse(null)
 
             final boolean buildDocker
             final String buildDockerProperty = System.getProperty("build.docker")
@@ -209,77 +209,56 @@ class BuildPlugin implements Plugin<Project> {
             ext.set('requiresDocker', [])
             rootProject.gradle.taskGraph.whenReady { TaskExecutionGraph taskGraph ->
                 final List<String> tasks = taskGraph.allTasks.intersect(ext.get('requiresDocker') as List<Task>).collect { "  ${it.path}".toString()}
+
                 if (tasks.isEmpty() == false) {
+                    final DockerUtils.DockerAvailability dockerAvailability = getDockerAvailability()
+
+                    if (dockerAvailability.isAvailable() == true) {
+                        return
+                    }
+
                     /*
-                     * There are tasks in the task graph that require Docker. Now we are failing because either the Docker binary does not
-                     * exist or because execution of a privileged Docker command failed.
+                     * There are tasks in the task graph that require Docker.
+                     * Now we are failing because either the Docker binary does
+                     * not exist or because execution of a privileged Docker
+                     * command failed.
                      */
-                    if (dockerBinary == null) {
+                    if (dockerAvailability.getPath() == null) {
                         final String message = String.format(
                                 Locale.ROOT,
                                 "Docker (checked [%s]) is required to run the following task%s: \n%s",
-                                maybeDockerBinaries.join(","),
+                                DOCKER_BINARIES.join(","),
                                 tasks.size() > 1 ? "s" : "",
                                 tasks.join('\n'))
                         throwDockerRequiredException(message)
                     }
 
-                    // we use a multi-stage Docker build, check the Docker version since 17.05
-                    final ByteArrayOutputStream dockerVersionOutput = new ByteArrayOutputStream()
-                    LoggedExec.exec(
-                            rootProject,
-                            { ExecSpec it ->
-                                it.commandLine = [dockerBinary, '--version']
-                                it.standardOutput = dockerVersionOutput
-                            })
-                    final String dockerVersion = dockerVersionOutput.toString().trim()
-                    checkDockerVersionRecent(dockerVersion)
-
-                    final ByteArrayOutputStream dockerImagesErrorOutput = new ByteArrayOutputStream()
-                    // the Docker binary executes, check that we can execute a privileged command
-                    final ExecResult dockerImagesResult = LoggedExec.exec(
-                            rootProject,
-                            { ExecSpec it ->
-                                it.commandLine = [dockerBinary, "images"]
-                                it.errorOutput = dockerImagesErrorOutput
-                                it.ignoreExitValue = true
-                            })
-
-                    if (dockerImagesResult.exitValue != 0) {
+                    if (dockerAvailability.isVersionHighEnough() == false) {
                         final String message = String.format(
                                 Locale.ROOT,
-                                "a problem occurred running Docker from [%s] yet it is required to run the following task%s: \n%s\n" +
-                                        "the problem is that Docker exited with exit code [%d] with standard error output [%s]",
-                                dockerBinary,
-                                tasks.size() > 1 ? "s" : "",
-                                tasks.join('\n'),
-                                dockerImagesResult.exitValue,
-                                dockerImagesErrorOutput.toString().trim())
+                                "building Docker images requires Docker version 17.05+ due to use of multi-stage builds yet was [%s]",
+                                dockerAvailability.getVersion())
                         throwDockerRequiredException(message)
                     }
 
+                    // Some other problem, print the error
+                    final String message = String.format(
+                            Locale.ROOT,
+                            "a problem occurred running Docker from [%s] yet it is required to run the following task%s: \n%s\n" +
+                                    "the problem is that Docker exited with exit code [%d] with standard error output [%s]",
+                            dockerBinary,
+                            tasks.size() > 1 ? "s" : "",
+                            tasks.join('\n'),
+                            dockerAvailability.getLastCommand().exitCode,
+                            dockerAvailability.getLastCommand().stderr.trim())
+                    throwDockerRequiredException(message)
                 }
             }
         }
 
         (ext.get('requiresDocker') as List<Task>).add(task)
     }
 
-    protected static void checkDockerVersionRecent(String dockerVersion) {
-        final Matcher matcher = dockerVersion =~ /Docker version (\d+\.\d+)\.\d+(?:-[a-zA-Z0-9]+)?, build [0-9a-f]{7,40}/
-        assert matcher.matches(): dockerVersion
-        final dockerMajorMinorVersion = matcher.group(1)
-        final String[] majorMinor = dockerMajorMinorVersion.split("\\.")
-        if (Integer.parseInt(majorMinor[0]) < 17
-                || (Integer.parseInt(majorMinor[0]) == 17 && Integer.parseInt(majorMinor[1]) < 5)) {
-            final String message = String.format(
-                    Locale.ROOT,
-                    "building Docker images requires Docker version 17.05+ due to use of multi-stage builds yet was [%s]",
-                    dockerVersion)
-            throwDockerRequiredException(message)
-        }
-    }
-
     private static void throwDockerRequiredException(final String message) {
         throw new GradleException(
                 message + "\nyou can address this by attending to the reported issue, "

buildSrc/src/main/groovy/org/elasticsearch/gradle/test/DistroTestPlugin.java

@@ -60,6 +60,7 @@
 import java.util.Random;
 import java.util.stream.Collectors;
 
+import static org.elasticsearch.gradle.DockerUtils.getDockerAvailability;
 import static org.elasticsearch.gradle.vagrant.VagrantMachine.convertLinuxPath;
 import static org.elasticsearch.gradle.vagrant.VagrantMachine.convertWindowsPath;
 
@@ -319,8 +320,15 @@ private List<ElasticsearchDistribution> configureDistributions(Project project,
         List<ElasticsearchDistribution> currentDistros = new ArrayList<>();
         List<ElasticsearchDistribution> upgradeDistros = new ArrayList<>();
 
-        // Docker disabled for https://github.com/elastic/elasticsearch/issues/47639
-        for (Type type : Arrays.asList(Type.DEB, Type.RPM /*,Type.DOCKER*/)) {
+        final String buildDockerProperty = System.getProperty("build.docker");
+        final boolean shouldAddDocker = (buildDockerProperty == null || "true".equals(buildDockerProperty))
+            && getDockerAvailability().isAvailable();
+
+        final List<Type> applicablePackageTypes = shouldAddDocker
+            ? List.of(Type.DEB, Type.RPM, Type.DOCKER)
+            : List.of(Type.DEB, Type.RPM);
+
+        for (Type type : applicablePackageTypes) {
             for (Flavor flavor : Flavor.values()) {
                 for (boolean bundledJdk : Arrays.asList(true, false)) {
                     // We should never add a Docker distro with bundledJdk == false
@@ -338,6 +346,7 @@ private List<ElasticsearchDistribution> configureDistributions(Project project,
                 addDistro(distributions, type, null, Flavor.OSS, true, upgradeVersion.toString(), upgradeDistros);
             }
         }
+
         for (Platform platform : Arrays.asList(Platform.LINUX, Platform.WINDOWS)) {
             for (Flavor flavor : Flavor.values()) {
                 for (boolean bundledJdk : Arrays.asList(true, false)) {