Add option to specify base image for cli jar command

jib-cli/src/integration-test/java/com/google/cloud/tools/jib/cli/JarCommandTest.java

@@ -239,6 +239,24 @@ public void testSpringBootJar_packagedMode() throws IOException, InterruptedExce
     assertThat(getContent(new URL("http://localhost:8080"))).isEqualTo("Hello world");
   }
 
+  @Test
+  public void testJar_baseImageSpecified()
+      throws IOException, URISyntaxException, InterruptedException {
+    Path jarPath = Paths.get(Resources.getResource("jarTest/standard/noDependencyJar.jar").toURI());
+    Integer exitCode =
+        new CommandLine(new JibCli())
+            .execute(
+                "jar",
+                "--target",
+                "docker://cli-gcr-base",
+                "--from",
+                "gcr.io/google-appengine/openjdk:8",
+                jarPath.toString());
+    assertThat(exitCode).isEqualTo(0);
+    String output = new Command("docker", "run", "--rm", "cli-gcr-base").run();
+    assertThat(output).isEqualTo("Hello World");
+  }
+
   @Nullable
   private static String getContent(URL url) throws InterruptedException {
     for (int i = 0; i < 40; i++) {

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/ContainerBuilders.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2021 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.cli;
+
+import static com.google.cloud.tools.jib.api.Jib.DOCKER_DAEMON_IMAGE_PREFIX;
+import static com.google.cloud.tools.jib.api.Jib.REGISTRY_IMAGE_PREFIX;
+import static com.google.cloud.tools.jib.api.Jib.TAR_IMAGE_PREFIX;
+
+import com.google.cloud.tools.jib.api.DockerDaemonImage;
+import com.google.cloud.tools.jib.api.ImageReference;
+import com.google.cloud.tools.jib.api.InvalidImageReferenceException;
+import com.google.cloud.tools.jib.api.Jib;
+import com.google.cloud.tools.jib.api.JibContainerBuilder;
+import com.google.cloud.tools.jib.api.RegistryImage;
+import com.google.cloud.tools.jib.api.TarImage;
+import com.google.cloud.tools.jib.api.buildplan.Platform;
+import com.google.cloud.tools.jib.frontend.CredentialRetrieverFactory;
+import com.google.cloud.tools.jib.plugins.common.DefaultCredentialRetrievers;
+import com.google.cloud.tools.jib.plugins.common.logging.ConsoleLogger;
+import java.io.FileNotFoundException;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/** Helper class for creating JibContainerBuilders from JibCli specifications. */
+public class ContainerBuilders {
+
+  /**
+   * Creates a {@link JibContainerBuilder} depending on the base image specified.
+   *
+   * @param baseImageReference base image
+   * @param platforms platforms for multi-platform support in build command.
+   * @param commonCliOptions common cli options
+   * @param logger console logger
+   * @return a {@link JibContainerBuilder}
+   * @throws InvalidImageReferenceException if the baseImage reference cannot be parsed
+   * @throws FileNotFoundException if credential helper file cannot be found
+   */
+  public static JibContainerBuilder create(
+      String baseImageReference,
+      List<Platform> platforms,
+      CommonCliOptions commonCliOptions,
+      ConsoleLogger logger)
+      throws InvalidImageReferenceException, FileNotFoundException {
+    if (baseImageReference.startsWith(DOCKER_DAEMON_IMAGE_PREFIX)) {
+      return Jib.from(
+          DockerDaemonImage.named(baseImageReference.replaceFirst(DOCKER_DAEMON_IMAGE_PREFIX, "")));
+    }
+    if (baseImageReference.startsWith(TAR_IMAGE_PREFIX)) {
+      return Jib.from(
+          TarImage.at(Paths.get(baseImageReference.replaceFirst(TAR_IMAGE_PREFIX, ""))));
+    }
+    ImageReference imageReference =
+        ImageReference.parse(baseImageReference.replaceFirst(REGISTRY_IMAGE_PREFIX, ""));
+    RegistryImage registryImage = RegistryImage.named(imageReference);
+    DefaultCredentialRetrievers defaultCredentialRetrievers =
+        DefaultCredentialRetrievers.init(
+            CredentialRetrieverFactory.forImage(
+                imageReference,
+                logEvent -> logger.log(logEvent.getLevel(), logEvent.getMessage())));
+    Credentials.getFromCredentialRetrievers(commonCliOptions, defaultCredentialRetrievers)
+        .forEach(registryImage::addCredentialRetriever);
+    JibContainerBuilder containerBuilder = Jib.from(registryImage);
+    if (!platforms.isEmpty()) {
+      containerBuilder.setPlatforms(platforms.stream().collect(Collectors.toSet()));
+    }
+    return containerBuilder;
+  }
+}

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Jar.java

@@ -31,6 +31,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Duration;
+import java.util.Optional;
 import java.util.concurrent.Callable;
 import picocli.CommandLine;
 import picocli.CommandLine.Model.CommandSpec;
@@ -64,6 +65,13 @@ public class Jar implements Callable<Integer> {
   @SuppressWarnings("NullAway.Init") // initialized by picocli
   private ProcessingMode mode;
 
+  @CommandLine.Option(
+      names = "--from",
+      paramLabel = "<from>",
+      description = "The base image to use.")
+  @SuppressWarnings("NullAway.Init") // initialized by picocli
+  private String from;
+
   @Override
   public Integer call() {
     try {
@@ -98,7 +106,8 @@ public Integer call() {
       }
 
       JarProcessor processor = JarProcessors.from(jarFile, tempDirectoryProvider, mode);
-      JibContainerBuilder containerBuilder = JarFiles.toJibContainerBuilder(processor);
+      JibContainerBuilder containerBuilder =
+          JarFiles.toJibContainerBuilder(processor, this, commonCliOptions, logger);
       CacheDirectories cacheDirectories =
           CacheDirectories.from(commonCliOptions, jarFile.toAbsolutePath().getParent());
       Containerizer containerizer = Containerizers.from(commonCliOptions, logger, cacheDirectories);
@@ -114,4 +123,13 @@ public Integer call() {
     }
     return 0;
   }
+
+  /**
+   * Returns the user specified base image.
+   *
+   * @return an optional base image
+   */
+  public Optional<String> getFrom() {
+    return Optional.ofNullable(from);
+  }
 }

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/buildfile/BuildFiles.java

@@ -16,34 +16,25 @@
 
 package com.google.cloud.tools.jib.cli.buildfile;
 
-import static com.google.cloud.tools.jib.api.Jib.DOCKER_DAEMON_IMAGE_PREFIX;
-import static com.google.cloud.tools.jib.api.Jib.REGISTRY_IMAGE_PREFIX;
-import static com.google.cloud.tools.jib.api.Jib.TAR_IMAGE_PREFIX;
-
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
-import com.google.cloud.tools.jib.api.DockerDaemonImage;
-import com.google.cloud.tools.jib.api.ImageReference;
 import com.google.cloud.tools.jib.api.InvalidImageReferenceException;
 import com.google.cloud.tools.jib.api.Jib;
 import com.google.cloud.tools.jib.api.JibContainerBuilder;
-import com.google.cloud.tools.jib.api.RegistryImage;
-import com.google.cloud.tools.jib.api.TarImage;
 import com.google.cloud.tools.jib.api.buildplan.Platform;
 import com.google.cloud.tools.jib.cli.Build;
 import com.google.cloud.tools.jib.cli.CommonCliOptions;
-import com.google.cloud.tools.jib.cli.Credentials;
-import com.google.cloud.tools.jib.frontend.CredentialRetrieverFactory;
-import com.google.cloud.tools.jib.plugins.common.DefaultCredentialRetrievers;
+import com.google.cloud.tools.jib.cli.ContainerBuilders;
 import com.google.cloud.tools.jib.plugins.common.logging.ConsoleLogger;
 import com.google.common.base.Charsets;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.LinkedHashSet;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import org.apache.commons.text.StringSubstitutor;
 import org.apache.commons.text.io.StringSubstitutorReader;
@@ -87,10 +78,10 @@ public static JibContainerBuilder toJibContainerBuilder(
       throws InvalidImageReferenceException, IOException {
     BuildFileSpec buildFile =
         toBuildFileSpec(buildFilePath, buildCommandOptions.getTemplateParameters());
-
+    Optional<BaseImageSpec> baseImageSpec = buildFile.getFrom();
     JibContainerBuilder containerBuilder =
-        buildFile.getFrom().isPresent()
-            ? createJibContainerBuilder(buildFile.getFrom().get(), commonCliOptions, logger)
+        baseImageSpec.isPresent()
+            ? createJibContainerBuilder(baseImageSpec.get(), commonCliOptions, logger)
             : Jib.fromScratch();
 
     buildFile.getCreationTime().ifPresent(containerBuilder::setCreationTime);
@@ -111,40 +102,20 @@ public static JibContainerBuilder toJibContainerBuilder(
     return containerBuilder;
   }
 
-  // TODO: add testing, need to do via intergration tests as there's no good way to extract out that
-  //   the base image was populated as the user intended currently.
-  static JibContainerBuilder createJibContainerBuilder(
-      BaseImageSpec from, CommonCliOptions commonCliOptions, ConsoleLogger logger)
+  private static JibContainerBuilder createJibContainerBuilder(
+      BaseImageSpec baseImageSpec, CommonCliOptions commonCliOptions, ConsoleLogger logger)
       throws InvalidImageReferenceException, FileNotFoundException {
-    String baseImageReference = from.getImage();
-    if (baseImageReference.startsWith(DOCKER_DAEMON_IMAGE_PREFIX)) {
-      return Jib.from(
-          DockerDaemonImage.named(baseImageReference.replaceFirst(DOCKER_DAEMON_IMAGE_PREFIX, "")));
-    }
-    if (baseImageReference.startsWith(TAR_IMAGE_PREFIX)) {
-      return Jib.from(
-          TarImage.at(Paths.get(baseImageReference.replaceFirst(TAR_IMAGE_PREFIX, ""))));
-    }
-    ImageReference imageReference =
-        ImageReference.parse(baseImageReference.replaceFirst(REGISTRY_IMAGE_PREFIX, ""));
-    RegistryImage registryImage = RegistryImage.named(imageReference);
-    DefaultCredentialRetrievers defaultCredentialRetrievers =
-        DefaultCredentialRetrievers.init(
-            CredentialRetrieverFactory.forImage(
-                imageReference,
-                logEvent -> logger.log(logEvent.getLevel(), logEvent.getMessage())));
-    Credentials.getFromCredentialRetrievers(commonCliOptions, defaultCredentialRetrievers)
-        .forEach(registryImage::addCredentialRetriever);
-    JibContainerBuilder containerBuilder = Jib.from(registryImage);
-    if (!from.getPlatforms().isEmpty()) {
-      containerBuilder.setPlatforms(
-          from.getPlatforms()
+    List<Platform> platforms = new ArrayList<>();
+    if (!baseImageSpec.getPlatforms().isEmpty()) {
+      platforms =
+          baseImageSpec
+              .getPlatforms()
               .stream()
               .map(
                   platformSpec ->
                       new Platform(platformSpec.getArchitecture(), platformSpec.getOs()))
-              .collect(Collectors.toCollection(LinkedHashSet::new)));
+              .collect(Collectors.toList());
     }
-    return containerBuilder;
+    return ContainerBuilders.create(baseImageSpec.getImage(), platforms, commonCliOptions, logger);
   }
 }

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/JarFiles.java

@@ -20,7 +20,12 @@
 import com.google.cloud.tools.jib.api.Jib;
 import com.google.cloud.tools.jib.api.JibContainerBuilder;
 import com.google.cloud.tools.jib.api.buildplan.FileEntriesLayer;
+import com.google.cloud.tools.jib.cli.CommonCliOptions;
+import com.google.cloud.tools.jib.cli.ContainerBuilders;
+import com.google.cloud.tools.jib.cli.Jar;
+import com.google.cloud.tools.jib.plugins.common.logging.ConsoleLogger;
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 
 /** Class to build a container representation from the contents of a jar file. */
@@ -30,16 +35,27 @@ public class JarFiles {
    * Generates a {@link JibContainerBuilder} from contents of a jar file.
    *
    * @param processor jar processor
+   * @param jarOptions jar cli options
+   * @param commonCliOptions common cli options
+   * @param logger console logger
    * @return JibContainerBuilder
    * @throws IOException if I/O error occurs when opening the jar file or if temporary directory
    *     provided doesn't exist
    * @throws InvalidImageReferenceException if the base image reference is invalid
    */
-  public static JibContainerBuilder toJibContainerBuilder(JarProcessor processor)
+  public static JibContainerBuilder toJibContainerBuilder(
+      JarProcessor processor,
+      Jar jarOptions,
+      CommonCliOptions commonCliOptions,
+      ConsoleLogger logger)
       throws IOException, InvalidImageReferenceException {
 
-    // Use distroless as the base image.
-    JibContainerBuilder containerBuilder = Jib.from("gcr.io/distroless/java");
+    // Use distroless as the default base image.
+    JibContainerBuilder containerBuilder =
+        jarOptions.getFrom().isPresent()
+            ? ContainerBuilders.create(
+                jarOptions.getFrom().get(), Collections.emptyList(), commonCliOptions, logger)
+            : Jib.from("gcr.io/distroless/java");
 
     List<FileEntriesLayer> layers = processor.createLayers();
     List<String> entrypoint = processor.computeEntrypoint();

jib-cli/src/test/java/com/google/cloud/tools/jib/api/JibContainerBuilderTestHelper.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2021 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.google.cloud.tools.jib.configuration.BuildContext;
+
+/** Test helper to expose package-private members of {@link JibContainerBuilder}. */
+public class JibContainerBuilderTestHelper {
+
+  public static BuildContext toBuildContext(
+      JibContainerBuilder jibContainerBuilder, Containerizer containerizer)
+      throws CacheDirectoryCreationException {
+    return jibContainerBuilder.toBuildContext(containerizer);
+  }
+
+  private JibContainerBuilderTestHelper() {}
+}