feat: determine platform details from local docker installation for jibDockerBuild

config/checkstyle/copyright-java.header

@@ -1,5 +1,5 @@
 ^/\*$
-^ \* Copyright 20(17|18|19|20|21|22|23) Google LLC\.$
+^ \* Copyright 20(17|18|19|20|21|22|23|24) Google LLC\.$
 ^ \*$
 ^ \* Licensed 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$

jib-core/src/integration-test/java/com/google/cloud/tools/jib/api/JibIntegrationTest.java

@@ -16,6 +16,9 @@
 
 package com.google.cloud.tools.jib.api;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
 import com.google.cloud.tools.jib.Command;
 import com.google.cloud.tools.jib.api.buildplan.Platform;
 import com.google.cloud.tools.jib.blob.Blobs;
@@ -304,6 +307,65 @@ public void testScratch_multiPlatform()
     Assert.assertEquals("windows", platform2.getOs());
   }
 
+  @Test
+  public void testBasic_jibImageToDockerDaemon()
+      throws IOException, InterruptedException, InvalidImageReferenceException, ExecutionException,
+          RegistryException, CacheDirectoryCreationException {
+    Jib.from(DockerDaemonImage.named(dockerHost + ":5000/busybox"))
+        .setEntrypoint("echo", "Hello World")
+        .containerize(
+            Containerizer.to(DockerDaemonImage.named(dockerHost + ":5000/docker-to-docker")));
+
+    String output =
+        new Command("docker", "run", "--rm", dockerHost + ":5000/docker-to-docker").run();
+    Assert.assertEquals("Hello World\n", output);
+  }
+
+  @Test
+  public void testBasicMultiPlatform_toDockerDaemon()
+      throws IOException, InterruptedException, ExecutionException, RegistryException,
+          CacheDirectoryCreationException, InvalidImageReferenceException {
+    Jib.from(
+            RegistryImage.named(
+                "busybox@sha256:4f47c01fa91355af2865ac10fef5bf6ec9c7f42ad2321377c21e844427972977"))
+        .setPlatforms(
+            ImmutableSet.of(new Platform("arm64", "linux"), new Platform("amd64", "linux")))
+        .setEntrypoint("echo", "Hello World")
+        .containerize(
+            Containerizer.to(
+                    DockerDaemonImage.named(dockerHost + ":5000/docker-daemon-multi-platform"))
+                .setAllowInsecureRegistries(true));
+
+    String output =
+        new Command("docker", "run", "--rm", dockerHost + ":5000/docker-daemon-multi-platform")
+            .run();
+    Assert.assertEquals("Hello World\n", output);
+  }
+
+  @Test
+  public void testBasicMultiPlatform_toDockerDaemon_noMatchingImage() {
+    ExecutionException exception =
+        assertThrows(
+            ExecutionException.class,
+            () ->
+                Jib.from(
+                        RegistryImage.named(
+                            "busybox@sha256:4f47c01fa91355af2865ac10fef5bf6ec9c7f42ad2321377c21e844427972977"))
+                    .setPlatforms(
+                        ImmutableSet.of(
+                            new Platform("s390x", "linux"), new Platform("arm", "linux")))
+                    .setEntrypoint("echo", "Hello World")
+                    .containerize(
+                        Containerizer.to(
+                                DockerDaemonImage.named(
+                                    dockerHost + ":5000/docker-daemon-multi-platform"))
+                            .setAllowInsecureRegistries(true)));
+    assertThat(exception)
+        .hasCauseThat()
+        .hasMessageThat()
+        .startsWith("The configured platforms don't match the Docker Engine's OS and architecture");
+  }
+
   @Test
   public void testDistroless_ociManifest()
       throws IOException, InterruptedException, ExecutionException, RegistryException,

jib-core/src/main/java/com/google/cloud/tools/jib/api/DockerClient.java

@@ -69,4 +69,15 @@ void save(ImageReference imageReference, Path outputPath, Consumer<Long> written
    * @throws InterruptedException if the {@code docker inspect} process was interrupted
    */
   ImageDetails inspect(ImageReference imageReference) throws IOException, InterruptedException;
+
+  /**
+   * Gets the os and architecture of the local docker installation.
+   *
+   * @return the os type and architecture of the image
+   * @throws IOException if an I/O exception occurs or {@code docker info} failed
+   * @throws InterruptedException if the {@code docker info} process was interrupted
+   */
+  default DockerInfoDetails info() throws IOException, InterruptedException {
+    return new DockerInfoDetails();
+  }
 }

jib-core/src/main/java/com/google/cloud/tools/jib/api/DockerInfoDetails.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2024 Google LLC.
+ *
+ * Licensed 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 com.google.cloud.tools.jib.api;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.cloud.tools.jib.json.JsonTemplate;
+
+/** Contains the os and architecture from {@code docker info}. */
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class DockerInfoDetails implements JsonTemplate {
+
+  @JsonProperty("OSType")
+  private String osType = "";
+
+  @JsonProperty("Architecture")
+  private String architecture = "";
+
+  public String getOsType() {
+    return osType;
+  }
+
+  public String getArchitecture() {
+    return architecture;
+  }
+}

jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps/StepsRunner.java

@@ -18,6 +18,7 @@
 
 import com.google.cloud.tools.jib.api.DescriptorDigest;
 import com.google.cloud.tools.jib.api.DockerClient;
+import com.google.cloud.tools.jib.api.DockerInfoDetails;
 import com.google.cloud.tools.jib.blob.BlobDescriptor;
 import com.google.cloud.tools.jib.builder.ProgressEventDispatcher;
 import com.google.cloud.tools.jib.builder.steps.LocalBaseImageSteps.LocalImage;
@@ -52,6 +53,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.function.Consumer;
+import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 
@@ -64,6 +66,8 @@
  */
 public class StepsRunner {
 
+  private static final Logger LOGGER = Logger.getLogger(StepsRunner.class.getName());
+
   /** Holds the individual step results. */
   private static class StepResults {
 
@@ -427,6 +431,7 @@ private void buildImages(ProgressEventDispatcher.Factory progressDispatcherFacto
                   Image baseImage = entry.getKey();
                   List<Future<PreparedLayer>> baseLayers = entry.getValue();
 
+                  // Image is immutable once built.
                   Future<Image> builtImage =
                       buildImage(baseImage, baseLayers, progressDispatcher.newChildProducer());
                   baseImagesAndBuiltImages.put(baseImage, builtImage);
@@ -616,13 +621,17 @@ private void loadDocker(
     results.buildResult =
         executorService.submit(
             () -> {
-              Verify.verify(
-                  results.baseImagesAndBuiltImages.get().size() == 1,
-                  "multi-platform image building not supported when pushing to Docker engine");
-              Image builtImage =
-                  results.baseImagesAndBuiltImages.get().values().iterator().next().get();
+              DockerInfoDetails dockerInfoDetails = dockerClient.info();
+              String osType = dockerInfoDetails.getOsType();
+              String architecture = computeArchitecture(dockerInfoDetails.getArchitecture());
+              Optional<Image> builtImage = fetchBuiltImageForLocalBuild(osType, architecture);
+              Preconditions.checkState(
+                  builtImage.isPresent(),
+                  String.format(
+                      "The configured platforms don't match the Docker Engine's OS and architecture (%s/%s)",
+                      osType, architecture));
               return new LoadDockerStep(
-                      buildContext, progressDispatcherFactory, dockerClient, builtImage)
+                      buildContext, progressDispatcherFactory, dockerClient, builtImage.get())
                   .call();
             });
   }
@@ -647,4 +656,29 @@ private void writeTarFile(
   private <E> List<Future<E>> scheduleCallables(ImmutableList<? extends Callable<E>> callables) {
     return callables.stream().map(executorService::submit).collect(Collectors.toList());
   }
+
+  private String computeArchitecture(String architecture) {
+    if (architecture.equals("x86_64")) {
+      return "amd64";
+    } else if (architecture.equals("aarch64")) {
+      return "arm64";
+    }
+    return architecture;
+  }
+
+  private Optional<Image> fetchBuiltImageForLocalBuild(String osType, String architecture)
+      throws InterruptedException, ExecutionException {
+    if (results.baseImagesAndBuiltImages.get().size() > 1) {
+      LOGGER.warning(
+          "Detected multi-platform configuration, only building the one that matches the local Docker Engine's os and architecture");
+    }
+    for (Map.Entry<Image, Future<Image>> imageEntry :
+        results.baseImagesAndBuiltImages.get().entrySet()) {
+      Image image = imageEntry.getValue().get();
+      if (image.getArchitecture().equals(architecture) && image.getOs().equals(osType)) {
+        return Optional.of(image);
+      }
+    }
+    return Optional.empty();
+  }
 }

jib-core/src/main/java/com/google/cloud/tools/jib/docker/CliDockerClient.java

@@ -20,6 +20,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.cloud.tools.jib.api.DescriptorDigest;
 import com.google.cloud.tools.jib.api.DockerClient;
+import com.google.cloud.tools.jib.api.DockerInfoDetails;
 import com.google.cloud.tools.jib.api.ImageDetails;
 import com.google.cloud.tools.jib.api.ImageReference;
 import com.google.cloud.tools.jib.http.NotifyingOutputStream;
@@ -184,6 +185,17 @@ public boolean supported(Map<String, String> parameters) {
     return true;
   }
 
+  @Override
+  public DockerInfoDetails info() throws IOException, InterruptedException {
+    // Runs 'docker info'.
+    Process infoProcess = docker("info", "-f", "{{json .}}");
+    if (infoProcess.waitFor() != 0) {
+      throw new IOException(
+          "'docker info' command failed with error: " + getStderrOutput(infoProcess));
+    }
+    return JsonTemplateMapper.readJson(infoProcess.getInputStream(), DockerInfoDetails.class);
+  }
+
   @Override
   public String load(ImageTarball imageTarball, Consumer<Long> writtenByteCountListener)
       throws InterruptedException, IOException {

jib-core/src/test/java/com/google/cloud/tools/jib/docker/CliDockerClientTest.java

@@ -16,8 +16,12 @@
 
 package com.google.cloud.tools.jib.docker;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
 import com.google.cloud.tools.jib.api.DescriptorDigest;
 import com.google.cloud.tools.jib.api.DockerClient;
+import com.google.cloud.tools.jib.api.DockerInfoDetails;
 import com.google.cloud.tools.jib.api.ImageReference;
 import com.google.cloud.tools.jib.docker.CliDockerClient.DockerImageDetails;
 import com.google.cloud.tools.jib.image.ImageTarball;
@@ -83,6 +87,42 @@ public void testIsDockerInstalled_pass() throws URISyntaxException {
             Paths.get(Resources.getResource("core/docker/emptyFile").toURI())));
   }
 
+  @Test
+  public void testInfo() throws InterruptedException, IOException {
+    String dockerInfoJson = "{ \"OSType\": \"windows\"," + "\"Architecture\": \"arm64\"}";
+    DockerClient testDockerClient =
+        new CliDockerClient(
+            subcommand -> {
+              assertThat(subcommand).containsExactly("info", "-f", "{{json .}}");
+              return mockProcessBuilder;
+            });
+    // Simulates stdout.
+    Mockito.when(mockProcess.getInputStream())
+        .thenReturn(new ByteArrayInputStream(dockerInfoJson.getBytes()));
+
+    DockerInfoDetails infoDetails = testDockerClient.info();
+    assertThat(infoDetails.getArchitecture()).isEqualTo("arm64");
+    assertThat(infoDetails.getOsType()).isEqualTo("windows");
+  }
+
+  @Test
+  public void testInfo_fail() throws InterruptedException {
+    DockerClient testDockerClient =
+        new CliDockerClient(
+            subcommand -> {
+              assertThat(subcommand).containsExactly("info", "-f", "{{json .}}");
+              return mockProcessBuilder;
+            });
+    Mockito.when(mockProcess.waitFor()).thenReturn(1);
+    Mockito.when(mockProcess.getErrorStream())
+        .thenReturn(new ByteArrayInputStream("error".getBytes(StandardCharsets.UTF_8)));
+
+    IOException exception = assertThrows(IOException.class, testDockerClient::info);
+    assertThat(exception)
+        .hasMessageThat()
+        .contains("'docker info' command failed with error: error");
+  }
+
   @Test
   public void testLoad() throws IOException, InterruptedException {
     DockerClient testDockerClient =

jib-gradle-plugin/src/integration-test/java/com/google/cloud/tools/jib/gradle/SingleProjectIntegrationTest.java

@@ -592,4 +592,28 @@ public void testCredHelperConfiguration()
                 simpleTestProject, targetImage, "build-cred-helper.gradle"))
         .isEqualTo("Hello, world. \n1970-01-01T00:00:01Z\n");
   }
+
+  @Test
+  public void testToDockerDaemon_multiPlatform()
+      throws DigestException, IOException, InterruptedException {
+    String targetImage = "multiplatform:gradle" + System.nanoTime();
+    assertThat(
+            JibRunHelper.buildToDockerDaemonAndRun(
+                simpleTestProject, targetImage, "build-multi-platform.gradle"))
+        .isEqualTo("Hello, world. \n1970-01-01T00:00:01Z\n");
+  }
+
+  @Test
+  public void testToDockerDaemon_multiPlatform_invalid() {
+    String targetImage = "multiplatform:gradle" + System.nanoTime();
+    UnexpectedBuildFailure exception =
+        assertThrows(
+            UnexpectedBuildFailure.class,
+            () ->
+                JibRunHelper.buildToDockerDaemonAndRun(
+                    simpleTestProject, targetImage, "build-multi-platform-invalid.gradle"));
+    assertThat(exception)
+        .hasMessageThat()
+        .contains("The configured platforms don't match the Docker Engine's OS and architecture");
+  }
 }

jib-gradle-plugin/src/integration-test/resources/gradle/projects/simple/build-multi-platform-invalid.gradle

@@ -0,0 +1,34 @@
+plugins {
+    id 'java'
+    id 'com.google.cloud.tools.jib'
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation files('libs/dependency-1.0.0.jar')
+}
+
+jib {
+    from {
+        image = 'busybox@sha256:4f47c01fa91355af2865ac10fef5bf6ec9c7f42ad2321377c21e844427972977'
+        platforms {
+            platform {
+                architecture = 'arm'
+                os = 'linux'
+            }
+            platform {
+                architecture = 's390x'
+                os = 'linux'
+            }
+        }
+    }
+    to {
+        image = System.getProperty('_TARGET_IMAGE')
+    }
+}