Use AbsoluteUnixPath for container.appRoot propagation

jib-core/src/integration-test/java/com/google/cloud/tools/jib/builder/BuildStepsIntegrationTest.java

@@ -25,6 +25,7 @@
 import com.google.cloud.tools.jib.configuration.ContainerConfiguration;
 import com.google.cloud.tools.jib.configuration.ImageConfiguration;
 import com.google.cloud.tools.jib.configuration.LayerConfiguration;
+import com.google.cloud.tools.jib.filesystem.AbsoluteUnixPath;
 import com.google.cloud.tools.jib.frontend.ExposedPortsParser;
 import com.google.cloud.tools.jib.frontend.JavaEntrypointConstructor;
 import com.google.cloud.tools.jib.image.ImageReference;
@@ -286,7 +287,7 @@ private BuildConfiguration.Builder getBuildConfigurationBuilder(
         ContainerConfiguration.builder()
             .setEntrypoint(
                 JavaEntrypointConstructor.makeDefaultEntrypoint(
-                    "/app", Collections.emptyList(), "HelloWorld"))
+                    AbsoluteUnixPath.get("/app"), Collections.emptyList(), "HelloWorld"))
             .setProgramArguments(Collections.singletonList("An argument."))
             .setEnvironment(ImmutableMap.of("env1", "envvalue1", "env2", "envvalue2"))
             .setExposedPorts(

jib-core/src/main/java/com/google/cloud/tools/jib/frontend/JavaDockerContextGenerator.java

@@ -18,6 +18,7 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.cloud.tools.jib.filesystem.AbsoluteUnixPath;
 import com.google.cloud.tools.jib.image.LayerEntry;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
@@ -74,10 +75,12 @@ private static class CopyDirective {
     private final String directoryInContext;
 
     /** The extraction path in the image. */
-    private final String extractionPath;
+    private final AbsoluteUnixPath extractionPath;
 
     private CopyDirective(
-        ImmutableList<LayerEntry> layerEntries, String directoryInContext, String extractionPath) {
+        ImmutableList<LayerEntry> layerEntries,
+        String directoryInContext,
+        AbsoluteUnixPath extractionPath) {
       this.layerEntries = layerEntries;
       this.directoryInContext = directoryInContext;
       this.extractionPath = extractionPath;
@@ -96,7 +99,7 @@ private static void addIfNotEmpty(
       ImmutableList.Builder<CopyDirective> listBuilder,
       ImmutableList<LayerEntry> layerEntries,
       String directoryInContext,
-      String extractionPath) {
+      AbsoluteUnixPath extractionPath) {
     if (layerEntries.isEmpty()) {
       return;
     }
@@ -282,9 +285,9 @@ public void generate(Path targetDirectory) throws IOException {
         // 'baseExtractionPath' of '/app/classes', and an 'actualExtractionPath' of
         // '/app/classes/com/test/HelloWorld.class', the resolved destination would be
         // 'target/jib-docker-context/classes/com/test/HelloWorld.class'.
-        Path destination =
-            directoryInContext.resolve(
-                Paths.get(copyDirective.extractionPath).relativize(layerEntry.getExtractionPath()));
+        Path baseExtractionPath = Paths.get(copyDirective.extractionPath.toString());
+        Path relativeEntryPath = baseExtractionPath.relativize(layerEntry.getExtractionPath());
+        Path destination = directoryInContext.resolve(relativeEntryPath);
 
         if (Files.isDirectory(layerEntry.getSourceFile())) {
           Files.createDirectories(destination);
@@ -305,11 +308,11 @@ public void generate(Path targetDirectory) throws IOException {
    * <pre>{@code
    * FROM [base image]
    *
-   * COPY libs [path/to/dependencies]
-   * COPY snapshot-libs [path/to/dependencies]
-   * COPY resources [path/to/resources]
-   * COPY classes [path/to/classes]
-   * COPY root [path/to/classes]
+   * COPY libs [path/to/dependencies/]
+   * COPY snapshot-libs [path/to/dependencies/]
+   * COPY resources [path/to/resources/]
+   * COPY classes [path/to/classes/]
+   * COPY root [path/to/root/]
    *
    * EXPOSE [port]
    * [More EXPOSE instructions, if necessary]
@@ -330,11 +333,13 @@ String makeDockerfile() throws JsonProcessingException {
     StringBuilder dockerfile = new StringBuilder();
     dockerfile.append("FROM ").append(Preconditions.checkNotNull(baseImage)).append("\n");
     for (CopyDirective copyDirective : copyDirectives) {
+      boolean hasTrailingSlash = copyDirective.extractionPath.toString().endsWith("/");
       dockerfile
           .append("\nCOPY ")
           .append(copyDirective.directoryInContext)
           .append(" ")
-          .append(copyDirective.extractionPath);
+          .append(copyDirective.extractionPath)
+          .append(hasTrailingSlash ? "" : "/");
     }
 
     dockerfile.append("\n");

jib-core/src/main/java/com/google/cloud/tools/jib/frontend/JavaEntrypointConstructor.java

@@ -16,29 +16,32 @@
 
 package com.google.cloud.tools.jib.frontend;
 
-import com.google.common.base.Preconditions;
+import com.google.cloud.tools.jib.filesystem.AbsoluteUnixPath;
+import com.google.cloud.tools.jib.filesystem.RelativeUnixPath;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 /** Constructs an image entrypoint for the Java application. */
 public class JavaEntrypointConstructor {
 
-  public static final String DEFAULT_RELATIVE_RESOURCES_PATH_ON_IMAGE = "resources/";
-  public static final String DEFAULT_RELATIVE_CLASSES_PATH_ON_IMAGE = "classes/";
-  public static final String DEFAULT_RELATIVE_DEPENDENCIES_PATH_ON_IMAGE = "libs/";
+  public static final RelativeUnixPath DEFAULT_RELATIVE_RESOURCES_PATH_ON_IMAGE =
+      RelativeUnixPath.get("resources");
+  public static final RelativeUnixPath DEFAULT_RELATIVE_CLASSES_PATH_ON_IMAGE =
+      RelativeUnixPath.get("classes");
+  public static final RelativeUnixPath DEFAULT_RELATIVE_DEPENDENCIES_PATH_ON_IMAGE =
+      RelativeUnixPath.get("libs");
 
   public static List<String> makeDefaultEntrypoint(
-      String appRoot, List<String> jvmFlags, String mainClass) {
-    Preconditions.checkArgument(
-        appRoot.startsWith("/"), "appRoot should be an absolute path in Unix-style: " + appRoot);
-    appRoot = appRoot.endsWith("/") ? appRoot : appRoot + '/';
-
+      AbsoluteUnixPath appRoot, List<String> jvmFlags, String mainClass) {
     return makeEntrypoint(
         Arrays.asList(
-            appRoot + DEFAULT_RELATIVE_RESOURCES_PATH_ON_IMAGE,
-            appRoot + DEFAULT_RELATIVE_CLASSES_PATH_ON_IMAGE,
-            appRoot + DEFAULT_RELATIVE_DEPENDENCIES_PATH_ON_IMAGE + "*"),
+            appRoot.resolve(DEFAULT_RELATIVE_RESOURCES_PATH_ON_IMAGE).toString(),
+            appRoot.resolve(DEFAULT_RELATIVE_CLASSES_PATH_ON_IMAGE).toString(),
+            appRoot
+                .resolve(DEFAULT_RELATIVE_DEPENDENCIES_PATH_ON_IMAGE)
+                .resolve(RelativeUnixPath.get("*"))
+                .toString()),
         jvmFlags,
         mainClass);
   }

jib-core/src/main/java/com/google/cloud/tools/jib/frontend/JavaLayerConfigurations.java

@@ -17,6 +17,7 @@
 package com.google.cloud.tools.jib.frontend;
 
 import com.google.cloud.tools.jib.configuration.LayerConfiguration;
+import com.google.cloud.tools.jib.filesystem.AbsoluteUnixPath;
 import com.google.cloud.tools.jib.image.LayerEntry;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
@@ -66,49 +67,51 @@ String getName() {
   public static class Builder {
 
     private final Map<LayerType, List<Path>> layerFilesMap = new EnumMap<>(LayerType.class);
-    private final Map<LayerType, String> extractionPathMap = new EnumMap<>(LayerType.class);
+    private final Map<LayerType, AbsoluteUnixPath> extractionPathMap =
+        new EnumMap<>(LayerType.class);
 
     private Builder() {
       for (LayerType layerType : LayerType.values()) {
         layerFilesMap.put(layerType, new ArrayList<>());
-        extractionPathMap.put(layerType, "/");
+        extractionPathMap.put(layerType, AbsoluteUnixPath.get("/"));
       }
     }
 
-    public Builder setDependencyFiles(List<Path> dependencyFiles, String extractionPath) {
+    public Builder setDependencyFiles(List<Path> dependencyFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.DEPENDENCIES, dependencyFiles);
       extractionPathMap.put(LayerType.DEPENDENCIES, extractionPath);
       return this;
     }
 
     public Builder setSnapshotDependencyFiles(
-        List<Path> snapshotDependencyFiles, String extractionPath) {
+        List<Path> snapshotDependencyFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.SNAPSHOT_DEPENDENCIES, snapshotDependencyFiles);
       extractionPathMap.put(LayerType.SNAPSHOT_DEPENDENCIES, extractionPath);
       return this;
     }
 
-    public Builder setResourceFiles(List<Path> resourceFiles, String extractionPath) {
+    public Builder setResourceFiles(List<Path> resourceFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.RESOURCES, resourceFiles);
       extractionPathMap.put(LayerType.RESOURCES, extractionPath);
       return this;
     }
 
-    public Builder setClassFiles(List<Path> classFiles, String extractionPath) {
+    public Builder setClassFiles(List<Path> classFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.CLASSES, classFiles);
       extractionPathMap.put(LayerType.CLASSES, extractionPath);
       return this;
     }
 
-    public Builder setExtraFiles(List<Path> extraFiles, String extractionPath) {
+    public Builder setExtraFiles(List<Path> extraFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.EXTRA_FILES, extraFiles);
       extractionPathMap.put(LayerType.EXTRA_FILES, extractionPath);
       return this;
     }
 
     // TODO: remove this and put files in WAR into the relevant layers (i.e., dependencies, snapshot
     // dependencies, resources, and classes layers).
-    public Builder setExplodedWarFiles(List<Path> explodedWarFiles, String extractionPath) {
+    public Builder setExplodedWarFiles(
+        List<Path> explodedWarFiles, AbsoluteUnixPath extractionPath) {
       layerFilesMap.put(LayerType.EXPLODED_WAR, explodedWarFiles);
       extractionPathMap.put(LayerType.EXPLODED_WAR, extractionPath);
       return this;
@@ -118,19 +121,17 @@ public JavaLayerConfigurations build() throws IOException {
       ImmutableMap.Builder<LayerType, LayerConfiguration> layerConfigurationsMap =
           ImmutableMap.builderWithExpectedSize(LayerType.values().length);
       for (LayerType layerType : LayerType.values()) {
-        String extractionPath = Preconditions.checkNotNull(extractionPathMap.get(layerType));
-        // Windows filenames cannot have "/", so this also blocks Windows-style path.
-        Preconditions.checkState(
-            extractionPath.startsWith("/"),
-            "extractionPath should be an absolute path in Unix-style: " + extractionPath);
+        AbsoluteUnixPath extractionPath =
+            Preconditions.checkNotNull(extractionPathMap.get(layerType));
 
         LayerConfiguration.Builder layerConfigurationBuilder =
             LayerConfiguration.builder().setName(layerType.getName());
 
         // Adds all the layer files recursively.
         List<Path> layerFiles = Preconditions.checkNotNull(layerFilesMap.get(layerType));
         for (Path layerFile : layerFiles) {
-          Path pathInContainer = Paths.get(extractionPath).resolve(layerFile.getFileName());
+          Path pathInContainer =
+              Paths.get(extractionPath.toString()).resolve(layerFile.getFileName());
           layerConfigurationBuilder.addEntryRecursive(layerFile, pathInContainer);
         }
 
@@ -152,11 +153,11 @@ public static Builder builder() {
   public static final String DEFAULT_APP_ROOT = "/app";
 
   private final ImmutableMap<LayerType, LayerConfiguration> layerConfigurationMap;
-  private final ImmutableMap<LayerType, String> extractionPathMap;
+  private final ImmutableMap<LayerType, AbsoluteUnixPath> extractionPathMap;
 
   private JavaLayerConfigurations(
       ImmutableMap<LayerType, LayerConfiguration> layerConfigurationMap,
-      ImmutableMap<LayerType, String> extractionPathMap) {
+      ImmutableMap<LayerType, AbsoluteUnixPath> extractionPathMap) {
     this.layerConfigurationMap = layerConfigurationMap;
     this.extractionPathMap = extractionPathMap;
   }
@@ -191,35 +192,35 @@ public ImmutableList<LayerEntry> getExplodedWarEntries() {
     return getLayerEntries(LayerType.EXPLODED_WAR);
   }
 
-  public String getDependencyExtractionPath() {
+  public AbsoluteUnixPath getDependencyExtractionPath() {
     return getExtractionPath(LayerType.DEPENDENCIES);
   }
 
-  public String getSnapshotDependencyExtractionPath() {
+  public AbsoluteUnixPath getSnapshotDependencyExtractionPath() {
     return getExtractionPath(LayerType.SNAPSHOT_DEPENDENCIES);
   }
 
-  public String getResourceExtractionPath() {
+  public AbsoluteUnixPath getResourceExtractionPath() {
     return getExtractionPath(LayerType.RESOURCES);
   }
 
-  public String getClassExtractionPath() {
+  public AbsoluteUnixPath getClassExtractionPath() {
     return getExtractionPath(LayerType.CLASSES);
   }
 
-  public String getExtraFilesExtractionPath() {
+  public AbsoluteUnixPath getExtraFilesExtractionPath() {
     return getExtractionPath(LayerType.EXTRA_FILES);
   }
 
-  public String getExplodedWarExtractionPath() {
+  public AbsoluteUnixPath getExplodedWarExtractionPath() {
     return getExtractionPath(LayerType.EXPLODED_WAR);
   }
 
   private ImmutableList<LayerEntry> getLayerEntries(LayerType layerType) {
     return Preconditions.checkNotNull(layerConfigurationMap.get(layerType)).getLayerEntries();
   }
 
-  private String getExtractionPath(LayerType layerType) {
+  private AbsoluteUnixPath getExtractionPath(LayerType layerType) {
     return Preconditions.checkNotNull(extractionPathMap.get(layerType));
   }
 }

jib-core/src/test/java/com/google/cloud/tools/jib/frontend/JavaDockerContextGeneratorTest.java

@@ -16,6 +16,7 @@
 
 package com.google.cloud.tools.jib.frontend;
 
+import com.google.cloud.tools.jib.filesystem.AbsoluteUnixPath;
 import com.google.cloud.tools.jib.filesystem.DirectoryWalker;
 import com.google.cloud.tools.jib.image.LayerEntry;
 import com.google.common.collect.ImmutableList;
@@ -116,16 +117,17 @@ public void testGenerate() throws IOException, URISyntaxException {
         .thenReturn(filesToLayerEntries(testDependencies, Paths.get(EXPECTED_DEPENDENCIES_PATH)));
 
     Mockito.when(mockJavaLayerConfigurations.getDependencyExtractionPath())
-        .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_DEPENDENCIES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyExtractionPath())
-        .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_DEPENDENCIES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getResourceExtractionPath())
-        .thenReturn(EXPECTED_RESOURCES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_RESOURCES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getClassExtractionPath())
-        .thenReturn(EXPECTED_CLASSES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_CLASSES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getExplodedWarExtractionPath())
-        .thenReturn(EXPECTED_EXPLODED_WAR_PATH);
-    Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath()).thenReturn("/");
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_EXPLODED_WAR_PATH));
+    Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath())
+        .thenReturn(AbsoluteUnixPath.get("/"));
 
     new JavaDockerContextGenerator(mockJavaLayerConfigurations)
         .setBaseImage("somebaseimage")
@@ -175,23 +177,24 @@ public void testMakeDockerfile() throws IOException {
         .thenReturn(ImmutableList.of(new LayerEntry(ignored, Paths.get("/"))));
 
     Mockito.when(mockJavaLayerConfigurations.getDependencyExtractionPath())
-        .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_DEPENDENCIES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyExtractionPath())
-        .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_DEPENDENCIES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getResourceExtractionPath())
-        .thenReturn(EXPECTED_RESOURCES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_RESOURCES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getClassExtractionPath())
-        .thenReturn(EXPECTED_CLASSES_PATH);
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_CLASSES_PATH));
     Mockito.when(mockJavaLayerConfigurations.getExplodedWarExtractionPath())
-        .thenReturn(EXPECTED_EXPLODED_WAR_PATH);
-    Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath()).thenReturn("/");
+        .thenReturn(AbsoluteUnixPath.get(EXPECTED_EXPLODED_WAR_PATH));
+    Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath())
+        .thenReturn(AbsoluteUnixPath.get("/"));
 
     String dockerfile =
         new JavaDockerContextGenerator(mockJavaLayerConfigurations)
             .setBaseImage(expectedBaseImage)
             .setEntrypoint(
                 JavaEntrypointConstructor.makeDefaultEntrypoint(
-                    "/app", expectedJvmFlags, expectedMainClass))
+                    AbsoluteUnixPath.get("/app"), expectedJvmFlags, expectedMainClass))
             .setJavaArguments(expectedJavaArguments)
             .setEnvironment(expectedEnv)
             .setExposedPorts(exposedPorts)