Native cli launcher

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/DockerBuildTask.java

@@ -22,6 +22,7 @@
 import org.gradle.api.provider.MapProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.provider.SetProperty;
+import org.gradle.api.services.ServiceReference;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputDirectory;
 import org.gradle.api.tasks.Optional;
@@ -39,6 +40,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -68,10 +70,20 @@ public DockerBuildTask(WorkerExecutor workerExecutor, ObjectFactory objectFactor
         this.dockerContext = objectFactory.directoryProperty();
         this.buildArgs = objectFactory.mapProperty(String.class, String.class);
         this.markerFile.set(projectLayout.getBuildDirectory().file("markers/" + this.getName() + ".marker"));
+        onlyIf("Docker supports all requested platforms", task -> {
+            var platforms = getPlatforms().getOrElse(Collections.emptySet());
+            if (platforms.isEmpty()) {
+                return false;
+            }
+            DockerSupportService support = getDockerSupport().get();
+            return platforms.stream()
+                .allMatch(platform -> Architecture.fromDockerPlatform(platform).map(support::isArchitectureSupported).orElse(false));
+        });
     }
 
     @TaskAction
     public void build() {
+        String dockerExecutable = getDockerSupport().get().getResolvedDockerExecutable();
         workerExecutor.noIsolation().submit(DockerBuildAction.class, params -> {
             params.getDockerContext().set(dockerContext);
             params.getMarkerFile().set(markerFile);
@@ -82,6 +94,7 @@ public void build() {
             params.getBaseImages().set(Arrays.asList(baseImages));
             params.getBuildArgs().set(buildArgs);
             params.getPlatforms().set(getPlatforms());
+            params.getDockerExecutable().set(dockerExecutable);
         });
     }
 
@@ -148,6 +161,9 @@ public RegularFileProperty getMarkerFile() {
         return markerFile;
     }
 
+    @ServiceReference(DockerSupportPlugin.DOCKER_SUPPORT_SERVICE_NAME)
+    public abstract Property<DockerSupportService> getDockerSupport();
+
     public abstract static class DockerBuildAction implements WorkAction<Parameters> {
         private final ExecOperations execOperations;
 
@@ -163,12 +179,13 @@ public DockerBuildAction(ExecOperations execOperations) {
          */
         private void pullBaseImage(String baseImage) {
             final int maxAttempts = 10;
+            String docker = getParameters().getDockerExecutable().get();
 
             for (int attempt = 1; attempt <= maxAttempts; attempt++) {
                 try {
                     LoggedExec.exec(execOperations, spec -> {
                         maybeConfigureDockerConfig(spec);
-                        spec.executable("docker");
+                        spec.executable(docker);
                         spec.args("pull");
                         spec.environment("DOCKER_BUILDKIT", "1");
                         spec.args(baseImage);
@@ -205,7 +222,7 @@ public void execute() {
             LoggedExec.exec(execOperations, spec -> {
                 maybeConfigureDockerConfig(spec);
 
-                spec.executable("docker");
+                spec.executable(parameters.getDockerExecutable().get());
                 spec.environment("DOCKER_BUILDKIT", "1");
                 if (isCrossPlatform) {
                     spec.args("buildx");
@@ -260,9 +277,10 @@ private boolean isCrossPlatform() {
 
         private String getImageChecksum(String imageTag) {
             final ByteArrayOutputStream stdout = new ByteArrayOutputStream();
+            String docker = getParameters().getDockerExecutable().get();
 
             execOperations.exec(spec -> {
-                spec.setCommandLine("docker", "inspect", "--format", "{{ .Id }}", imageTag);
+                spec.setCommandLine(docker, "inspect", "--format", "{{ .Id }}", imageTag);
                 spec.setStandardOutput(stdout);
                 spec.setIgnoreExitValue(false);
             });
@@ -289,5 +307,7 @@ interface Parameters extends WorkParameters {
         SetProperty<String> getPlatforms();
 
         Property<Boolean> getPush();
+
+        Property<String> getDockerExecutable();
     }
 }

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/DockerSupportPlugin.java

@@ -43,7 +43,7 @@ public void apply(Project project) {
                 params.getIsCI().set(buildParams.getCi());
             }));
 
-        // Ensure that if we are trying to run any DockerBuildTask tasks, we assert an available Docker installation exists
+        // Ensure that if we are trying to run Docker build tasks, we assert an available Docker installation exists
         project.getGradle().getTaskGraph().whenReady(graph -> {
             List<String> dockerTasks = graph.getAllTasks()
                 .stream()

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/DockerSupportService.java

@@ -49,8 +49,8 @@
 public abstract class DockerSupportService implements BuildService<DockerSupportService.Parameters> {
 
     private static final Logger LOGGER = Logging.getLogger(DockerSupportService.class);
-    // Defines the possible locations of the Docker CLI. These will be searched in order.
-    private static final String[] DOCKER_BINARIES = { "/usr/bin/docker", "/usr/local/bin/docker" };
+    // Defines the possible locations of the Docker CLI. Searched in order for resolution and availability.
+    private static final String[] DOCKER_BINARIES = { "/usr/local/bin/docker", "/usr/bin/docker", "/opt/homebrew/bin/docker" };
     private static final String[] DOCKER_COMPOSE_BINARIES = {
         "/usr/local/bin/docker-compose",
         "/usr/bin/docker-compose",
@@ -72,7 +72,7 @@ public DockerSupportService(ProviderFactory providerFactory) {
      *
      * @return the results of the search.
      */
-    public DockerAvailability getDockerAvailability() {
+    public synchronized DockerAvailability getDockerAvailability() {
         if (this.dockerAvailability == null) {
             String dockerPath;
             String dockerComposePath = null;
@@ -305,15 +305,43 @@ static Map<String, String> parseOsRelease(final List<String> osReleaseLines) {
     }
 
     /**
-     * Searches the entries in {@link #DOCKER_BINARIES} for the Docker CLI. This method does
-     * not check whether the Docker installation appears usable, see {@link #getDockerAvailability()}
-     * instead.
+     * Resolves the Docker executable so it can be found even when PATH is minimal (e.g. Gradle
+     * workers or IDE). Searches PATH first for an executable named "docker", then falls back to
+     * {@link #DOCKER_BINARIES}. Use this when invoking docker from tasks so the binary is found
+     * regardless of worker environment.
+     *
+     * @return the absolute path to the Docker CLI if found and executable, otherwise "docker".
+     */
+    public String getResolvedDockerExecutable() {
+        String pathEnv = System.getenv("PATH");
+        if (pathEnv != null && pathEnv.isEmpty() == false) {
+            String separator = System.getProperty("path.separator", ":");
+            for (String dir : pathEnv.split(separator)) {
+                File candidate = new File(dir.trim(), "docker");
+                if (candidate.isFile() && candidate.canExecute()) {
+                    return candidate.getAbsolutePath();
+                }
+            }
+        }
+        for (String path : DOCKER_BINARIES) {
+            File f = new File(path);
+            if (f.isFile() && f.canExecute()) {
+                return f.getAbsolutePath();
+            }
+        }
+        return "docker";
+    }
+
+    /**
+     * Searches for the Docker CLI using the same logic as {@link #getResolvedDockerExecutable()}.
+     * This method does not check whether the Docker installation appears usable, see
+     * {@link #getDockerAvailability()} instead.
      *
      * @return the path to a CLI, if available.
      */
     private Optional<String> getDockerPath() {
-        // Check if the Docker binary exists
-        return Stream.of(DOCKER_BINARIES).filter(path -> new File(path).exists()).findFirst();
+        String resolved = getResolvedDockerExecutable();
+        return "docker".equals(resolved) ? Optional.empty() : Optional.of(resolved);
     }
 
     /**

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/NativeImageBuildTask.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+package org.elasticsearch.gradle.internal.docker;
+
+import org.elasticsearch.gradle.Architecture;
+import org.elasticsearch.gradle.LoggedExec;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.services.ServiceReference;
+import org.gradle.api.tasks.CacheableTask;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.process.ExecOperations;
+import org.gradle.process.ExecSpec;
+import org.gradle.workers.WorkAction;
+import org.gradle.workers.WorkParameters;
+import org.gradle.workers.WorkerExecutor;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.inject.Inject;
+
+/**
+ * Builds a GraalVM native-image binary by running native-image inside a Docker
+ * container. Uses the Gradle worker API so multiple architecture builds can
+ * run in parallel, and is cacheable for remote build cache.
+ *
+ * We assume native images to be optional, and a fallback to be available, so
+ * this task will be skipped if Docker is not available or the target platform
+ * is not supported rather than failing.
+ */
+@CacheableTask
+public abstract class NativeImageBuildTask extends DefaultTask {
+
+    private FileCollection classpath;
+
+    @Inject
+    public NativeImageBuildTask() {
+        onlyIf(
+            "Docker supports target platform",
+            task -> Architecture.fromDockerPlatform(getPlatform().getOrNull())
+                .map(arch -> getDockerSupport().get().isArchitectureSupported(arch))
+                .orElse(false)
+                && getDockerSupport().get().getDockerAvailability().isAvailable()
+        );
+    }
+
+    @Classpath
+    public FileCollection getClasspath() {
+        return classpath;
+    }
+
+    public void setClasspath(FileCollection classpath) {
+        this.classpath = classpath;
+    }
+
+    @Input
+    public abstract Property<String> getImageTag();
+
+    @Input
+    public abstract Property<String> getPlatform();
+
+    @Input
+    public abstract Property<String> getMainClass();
+
+    /**
+     * When true, pass {@code --static} to native-image to produce a fully static binary.
+     * Defaults to false.
+     */
+    @Input
+    @Optional
+    public abstract Property<Boolean> getStatic();
+
+    @OutputFile
+    public abstract RegularFileProperty getOutputFile();
+
+    @ServiceReference(DockerSupportPlugin.DOCKER_SUPPORT_SERVICE_NAME)
+    public abstract Property<DockerSupportService> getDockerSupport();
+
+    @Inject
+    public abstract WorkerExecutor getWorkerExecutor();
+
+    @TaskAction
+    public void execute() {
+        String dockerExecutable = getDockerSupport().get().getResolvedDockerExecutable();
+        getWorkerExecutor().noIsolation().submit(NativeImageBuildAction.class, params -> {
+            params.getClasspath().setFrom(getClasspath());
+            params.getImageTag().set(getImageTag());
+            params.getPlatform().set(getPlatform());
+            params.getMainClass().set(getMainClass());
+            params.getStatic().set(getStatic().getOrElse(false));
+            params.getOutputFile().set(getOutputFile());
+            params.getDockerExecutable().set(dockerExecutable);
+        });
+    }
+
+    interface Parameters extends WorkParameters {
+        ConfigurableFileCollection getClasspath();
+
+        Property<String> getImageTag();
+
+        Property<String> getPlatform();
+
+        Property<String> getMainClass();
+
+        Property<Boolean> getStatic();
+
+        RegularFileProperty getOutputFile();
+
+        Property<String> getDockerExecutable();
+    }
+
+    public abstract static class NativeImageBuildAction implements WorkAction<Parameters> {
+
+        private final ExecOperations execOperations;
+
+        @Inject
+        public NativeImageBuildAction(ExecOperations execOperations) {
+            this.execOperations = execOperations;
+        }
+
+        @Override
+        public void execute() {
+            Parameters params = getParameters();
+            String imageTag = params.getImageTag().get();
+            String platform = params.getPlatform().get();
+            String mainClass = params.getMainClass().get();
+            File outputFile = params.getOutputFile().get().getAsFile();
+            File outputDir = outputFile.getParentFile();
+
+            if (outputDir.exists() == false && outputDir.mkdirs() == false) {
+                throw new GradleException("Failed to create output directory: " + outputDir);
+            }
+
+            List<File> classpathFiles = params.getClasspath().getFiles().stream().filter(File::exists).collect(Collectors.toList());
+            if (classpathFiles.isEmpty()) {
+                throw new GradleException("Native-image classpath is empty");
+            }
+
+            // Build classpath string for inside the container: /cp/0:/cp/1:...
+            List<String> cpPaths = new ArrayList<>();
+            for (int i = 0; i < classpathFiles.size(); i++) {
+                cpPaths.add("/cp/" + i);
+            }
+            // Container is always Linux
+            String cpString = String.join(":", cpPaths);
+
+            List<String> args = new ArrayList<>();
+            args.add("run");
+            args.add("--rm");
+            for (int i = 0; i < classpathFiles.size(); i++) {
+                File f = classpathFiles.get(i);
+                String path = f.getAbsolutePath();
+                if (File.separatorChar == '\\') {
+                    path = path.replace("\\", "/");
+                }
+                args.add("-v");
+                args.add(path + ":/cp/" + i + ":ro");
+            }
+            args.add("-v");
+            String outPath = outputDir.getAbsolutePath();
+            if (File.separatorChar == '\\') {
+                outPath = outPath.replace("\\", "/");
+            }
+            args.add(outPath + ":/output");
+            args.add("--platform");
+            args.add(platform);
+            args.add(imageTag);
+            args.add("--no-fallback");
+            if (params.getStatic().get()) {
+                args.add("--static");
+            }
+            args.add("-cp");
+            args.add(cpString);
+            args.add("-o");
+            args.add("/output/" + outputFile.getName());
+            args.add(mainClass);
+
+            LoggedExec.exec(execOperations, spec -> {
+                maybeConfigureDockerConfig(spec);
+                spec.executable(params.getDockerExecutable().get());
+                spec.args(args);
+            });
+        }
+
+        private void maybeConfigureDockerConfig(ExecSpec spec) {
+            String dockerConfig = System.getenv("DOCKER_CONFIG");
+            if (dockerConfig != null) {
+                spec.environment("DOCKER_CONFIG", dockerConfig);
+            }
+        }
+    }
+}