Add container.appRoot config parameter

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

@@ -284,7 +284,7 @@ private BuildConfiguration.Builder getBuildConfigurationBuilder(
  ContainerConfiguration.builder()
  .setEntrypoint(
  JavaEntrypointConstructor.makeDefaultEntrypoint(
- Collections.emptyList(), "HelloWorld"))
+ "/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

@@ -151,35 +151,35 @@ public JavaDockerContextGenerator(JavaLayerConfigurations javaLayerConfiguration
  copyDirectivesBuilder,
  javaLayerConfigurations.getDependencyLayerEntries(),
  DEPENDENCIES_LAYER_DIRECTORY,
- JavaEntrypointConstructor.DEFAULT_DEPENDENCIES_PATH_ON_IMAGE);
+ javaLayerConfigurations.getDependencyExtractionPath());
  addIfNotEmpty(
  copyDirectivesBuilder,
  javaLayerConfigurations.getSnapshotDependencyLayerEntries(),
  SNAPSHOT_DEPENDENCIES_LAYER_DIRECTORY,
- JavaEntrypointConstructor.DEFAULT_DEPENDENCIES_PATH_ON_IMAGE);
+ javaLayerConfigurations.getSnapshotDependencyExtractionPath());
  addIfNotEmpty(
  copyDirectivesBuilder,
  javaLayerConfigurations.getResourceLayerEntries(),
  RESOURCES_LAYER_DIRECTORY,
- JavaEntrypointConstructor.DEFAULT_RESOURCES_PATH_ON_IMAGE);
+ javaLayerConfigurations.getResourceExtractionPath());
  addIfNotEmpty(
  copyDirectivesBuilder,
  javaLayerConfigurations.getClassLayerEntries(),
  CLASSES_LAYER_DIRECTORY,
- JavaEntrypointConstructor.DEFAULT_CLASSES_PATH_ON_IMAGE);
+ javaLayerConfigurations.getClassExtractionPath());
  // TODO: remove this once we put files in WAR into the relevant layers (i.e., dependencies,
  // snapshot dependencies, resources, and classes layers). Should copy files in the right
  // directories. (For example, "resources" will go into the webapp root.)
  addIfNotEmpty(
  copyDirectivesBuilder,
  javaLayerConfigurations.getExplodedWarEntries(),
  EXPLODED_WAR_LAYER_DIRECTORY,
- JavaEntrypointConstructor.DEFAULT_JETTY_BASE_ON_IMAGE);
+ javaLayerConfigurations.getExplodedWarExtractionPath());
  addIfNotEmpty(
  copyDirectivesBuilder,
  javaLayerConfigurations.getExtraFilesLayerEntries(),
  EXTRA_FILES_LAYER_DIRECTORY,
- "/");
+ javaLayerConfigurations.getExtraFilesExtractionPath());
  copyDirectives = copyDirectivesBuilder.build();
  }
 

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

@@ -16,24 +16,29 @@
 
 package com.google.cloud.tools.jib.frontend;
 
+import com.google.common.base.Preconditions;
 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_RESOURCES_PATH_ON_IMAGE = "/app/resources/";
- public static final String DEFAULT_CLASSES_PATH_ON_IMAGE = "/app/classes/";
- public static final String DEFAULT_DEPENDENCIES_PATH_ON_IMAGE = "/app/libs/";
- public static final String DEFAULT_JETTY_BASE_ON_IMAGE = "/jetty/webapps/ROOT/";
+ 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 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 + '/';
 
- public static List<String> makeDefaultEntrypoint(List<String> jvmFlags, String mainClass) {
  return makeEntrypoint(
  Arrays.asList(
- DEFAULT_RESOURCES_PATH_ON_IMAGE,
- DEFAULT_CLASSES_PATH_ON_IMAGE,
- DEFAULT_DEPENDENCIES_PATH_ON_IMAGE + "*"),
+ appRoot + DEFAULT_RELATIVE_RESOURCES_PATH_ON_IMAGE,
+ appRoot + DEFAULT_RELATIVE_CLASSES_PATH_ON_IMAGE,
+ appRoot + DEFAULT_RELATIVE_DEPENDENCIES_PATH_ON_IMAGE + "*"),
  jvmFlags,
  mainClass);
  }

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

@@ -36,108 +36,129 @@ public class JavaLayerConfigurations {
  /** Represents the different types of layers for a Java application. */
  @VisibleForTesting
  enum LayerType {
- DEPENDENCIES("dependencies", JavaEntrypointConstructor.DEFAULT_DEPENDENCIES_PATH_ON_IMAGE),
- SNAPSHOT_DEPENDENCIES(
- "snapshot dependencies", JavaEntrypointConstructor.DEFAULT_DEPENDENCIES_PATH_ON_IMAGE),
- RESOURCES("resources", JavaEntrypointConstructor.DEFAULT_RESOURCES_PATH_ON_IMAGE),
- CLASSES("classes", JavaEntrypointConstructor.DEFAULT_CLASSES_PATH_ON_IMAGE),
+ DEPENDENCIES("dependencies"),
+ SNAPSHOT_DEPENDENCIES("snapshot dependencies"),
+ RESOURCES("resources"),
+ CLASSES("classes"),
  // TODO: remove this once we put files in WAR into the relevant layers (i.e., dependencies,
  // snapshot dependencies, resources, and classes layers). Should copy files in the right
- EXPLODED_WAR("exploded war", JavaEntrypointConstructor.DEFAULT_JETTY_BASE_ON_IMAGE),
- EXTRA_FILES("extra files", "/");
+ EXPLODED_WAR("exploded war"),
+ EXTRA_FILES("extra files");
 
  private final String name;
- private final Path extractionPath;
 
- /** Initializes with a name for the layer and the layer files' default extraction path root. */
- LayerType(String name, String extractionPath) {
+ /**
+ * Initializes with a name for the layer.
+ *
+ * @param name name to set for the layer; does not affect the contents of the layer
+ */
+ LayerType(String name) {
  this.name = name;
- this.extractionPath = Paths.get(extractionPath);
  }
 
  @VisibleForTesting
  String getName() {
  return name;
  }
-
- @VisibleForTesting
- Path getExtractionPath() {
- return extractionPath;
- }
  }
 
  /** Builds with each layer's files. */
  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 Builder() {
  for (LayerType layerType : LayerType.values()) {
  layerFilesMap.put(layerType, new ArrayList<>());
+ extractionPathMap.put(layerType, "/");
  }
  }
 
- public Builder setDependencyFiles(List<Path> dependencyFiles) {
+ public Builder setDependencyFiles(List<Path> dependencyFiles, String extractionPath) {
  layerFilesMap.put(LayerType.DEPENDENCIES, dependencyFiles);
+ extractionPathMap.put(LayerType.DEPENDENCIES, extractionPath);
  return this;
  }
 
- public Builder setSnapshotDependencyFiles(List<Path> snapshotDependencyFiles) {
+ public Builder setSnapshotDependencyFiles(
+ List<Path> snapshotDependencyFiles, String extractionPath) {
  layerFilesMap.put(LayerType.SNAPSHOT_DEPENDENCIES, snapshotDependencyFiles);
+ extractionPathMap.put(LayerType.SNAPSHOT_DEPENDENCIES, extractionPath);
  return this;
  }
 
- public Builder setResourceFiles(List<Path> resourceFiles) {
+ public Builder setResourceFiles(List<Path> resourceFiles, String extractionPath) {
  layerFilesMap.put(LayerType.RESOURCES, resourceFiles);
+ extractionPathMap.put(LayerType.RESOURCES, extractionPath);
  return this;
  }
 
- public Builder setClassFiles(List<Path> classFiles) {
+ public Builder setClassFiles(List<Path> classFiles, String extractionPath) {
  layerFilesMap.put(LayerType.CLASSES, classFiles);
+ extractionPathMap.put(LayerType.CLASSES, extractionPath);
  return this;
  }
 
- public Builder setExtraFiles(List<Path> extraFiles) {
+ public Builder setExtraFiles(List<Path> extraFiles, String 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) {
+ public Builder setExplodedWarFiles(List<Path> explodedWarFiles, String extractionPath) {
  layerFilesMap.put(LayerType.EXPLODED_WAR, explodedWarFiles);
+ extractionPathMap.put(LayerType.EXPLODED_WAR, extractionPath);
  return this;
  }
 
  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);
+
  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) {
- layerConfigurationBuilder.addEntryRecursive(
-  layerFile, layerType.getExtractionPath().resolve(layerFile.getFileName()));
+ Path pathInContainer = Paths.get(extractionPath).resolve(layerFile.getFileName());
+ layerConfigurationBuilder.addEntryRecursive(layerFile, pathInContainer);
  }
 
  layerConfigurationsMap.put(layerType, layerConfigurationBuilder.build());
  }
- return new JavaLayerConfigurations(layerConfigurationsMap.build());
+ return new JavaLayerConfigurations(
+ layerConfigurationsMap.build(), ImmutableMap.copyOf(extractionPathMap));
  }
  }
 
  public static Builder builder() {
  return new Builder();
  }
 
+ /**
+ * The default app root in the image. For example, if this is set to {@code "/app"}, dependency
+ * JARs will be in {@code "/app/libs"}.
+ */
+ public static final String DEFAULT_APP_ROOT = "/app";
+
  private final ImmutableMap<LayerType, LayerConfiguration> layerConfigurationMap;
+ private final ImmutableMap<LayerType, String> extractionPathMap;
 
  private JavaLayerConfigurations(
- ImmutableMap<LayerType, LayerConfiguration> layerConfigurationsMap) {
- this.layerConfigurationMap = layerConfigurationsMap;
+ ImmutableMap<LayerType, LayerConfiguration> layerConfigurationMap,
+ ImmutableMap<LayerType, String> extractionPathMap) {
+ this.layerConfigurationMap = layerConfigurationMap;
+ this.extractionPathMap = extractionPathMap;
  }
 
  public ImmutableList<LayerConfiguration> getLayerConfigurations() {
@@ -170,7 +191,35 @@ public ImmutableList<LayerEntry> getExplodedWarEntries() {
  return getLayerEntries(LayerType.EXPLODED_WAR);
  }
 
+ public String getDependencyExtractionPath() {
+ return getExtractionPath(LayerType.DEPENDENCIES);
+ }
+
+ public String getSnapshotDependencyExtractionPath() {
+ return getExtractionPath(LayerType.SNAPSHOT_DEPENDENCIES);
+ }
+
+ public String getResourceExtractionPath() {
+ return getExtractionPath(LayerType.RESOURCES);
+ }
+
+ public String getClassExtractionPath() {
+ return getExtractionPath(LayerType.CLASSES);
+ }
+
+ public String getExtraFilesExtractionPath() {
+ return getExtractionPath(LayerType.EXTRA_FILES);
+ }
+
+ public String getExplodedWarExtractionPath() {
+ return getExtractionPath(LayerType.EXPLODED_WAR);
+ }
+
  private ImmutableList<LayerEntry> getLayerEntries(LayerType layerType) {
  return Preconditions.checkNotNull(layerConfigurationMap.get(layerType)).getLayerEntries();
  }
+
+ private String getExtractionPath(LayerType layerType) {
+ return Preconditions.checkNotNull(extractionPathMap.get(layerType));
+ }
 }

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

@@ -43,10 +43,10 @@
 @RunWith(MockitoJUnitRunner.class)
 public class JavaDockerContextGeneratorTest {
 
- private static final Path EXPECTED_DEPENDENCIES_PATH = Paths.get("/app/libs/");
- private static final Path EXPECTED_RESOURCES_PATH = Paths.get("/app/resources/");
- private static final Path EXPECTED_CLASSES_PATH = Paths.get("/app/classes/");
- private static final Path EXPECTED_EXPLODED_WAR_PATH = Paths.get("/jetty/webapps/ROOT/");
+ private static final String EXPECTED_DEPENDENCIES_PATH = "/app/libs/";
+ private static final String EXPECTED_RESOURCES_PATH = "/app/resources/";
+ private static final String EXPECTED_CLASSES_PATH = "/app/classes/";
+ private static final String EXPECTED_EXPLODED_WAR_PATH = "/exploded/war/";
 
  private static void assertSameFiles(Path directory1, Path directory2) throws IOException {
  ImmutableList<Path> directory1Files =
@@ -99,17 +99,33 @@ public void testGenerate() throws IOException, URISyntaxException {
  Files.delete(targetDirectory);
 
  Mockito.when(mockJavaLayerConfigurations.getDependencyLayerEntries())
- .thenReturn(filesToLayerEntries(testDependencies, EXPECTED_DEPENDENCIES_PATH));
+ .thenReturn(filesToLayerEntries(testDependencies, Paths.get(EXPECTED_DEPENDENCIES_PATH)));
  Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyLayerEntries())
- .thenReturn(filesToLayerEntries(testSnapshotDependencies, EXPECTED_DEPENDENCIES_PATH));
+ .thenReturn(
+ filesToLayerEntries(testSnapshotDependencies, Paths.get(EXPECTED_DEPENDENCIES_PATH)));
  Mockito.when(mockJavaLayerConfigurations.getResourceLayerEntries())
- .thenReturn(filesToLayerEntries(testResources, EXPECTED_RESOURCES_PATH));
+ .thenReturn(filesToLayerEntries(testResources, Paths.get(EXPECTED_RESOURCES_PATH)));
  Mockito.when(mockJavaLayerConfigurations.getClassLayerEntries())
- .thenReturn(filesToLayerEntries(testClasses, EXPECTED_CLASSES_PATH));
+ .thenReturn(filesToLayerEntries(testClasses, Paths.get(EXPECTED_CLASSES_PATH)));
  Mockito.when(mockJavaLayerConfigurations.getExplodedWarEntries())
- .thenReturn(filesToLayerEntries(testExplodedWarFiles, EXPECTED_EXPLODED_WAR_PATH));
+ .thenReturn(
+ filesToLayerEntries(testExplodedWarFiles, Paths.get(EXPECTED_EXPLODED_WAR_PATH)));
  Mockito.when(mockJavaLayerConfigurations.getExtraFilesLayerEntries())
  .thenReturn(filesToLayerEntries(testExtraFiles, Paths.get("/")));
+ Mockito.when(mockJavaLayerConfigurations.getDependencyLayerEntries())
+ .thenReturn(filesToLayerEntries(testDependencies, Paths.get(EXPECTED_DEPENDENCIES_PATH)));
+
+ Mockito.when(mockJavaLayerConfigurations.getDependencyExtractionPath())
+ .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyExtractionPath())
+ .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getResourceExtractionPath())
+ .thenReturn(EXPECTED_RESOURCES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getClassExtractionPath())
+ .thenReturn(EXPECTED_CLASSES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getExplodedWarExtractionPath())
+ .thenReturn(EXPECTED_EXPLODED_WAR_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath()).thenReturn("/");
 
  new JavaDockerContextGenerator(mockJavaLayerConfigurations)
  .setBaseImage("somebaseimage")
@@ -141,28 +157,41 @@ public void testMakeDockerfile() throws IOException {
  "key3",
  "value3");
 
+ Path ignored = Paths.get("ignored");
  Mockito.when(mockJavaLayerConfigurations.getDependencyLayerEntries())
  .thenReturn(
- ImmutableList.of(new LayerEntry(Paths.get("ignored"), EXPECTED_DEPENDENCIES_PATH)));
+ ImmutableList.of(new LayerEntry(ignored, Paths.get(EXPECTED_DEPENDENCIES_PATH))));
  Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyLayerEntries())
  .thenReturn(
- ImmutableList.of(new LayerEntry(Paths.get("ignored"), EXPECTED_DEPENDENCIES_PATH)));
+ ImmutableList.of(new LayerEntry(ignored, Paths.get(EXPECTED_DEPENDENCIES_PATH))));
  Mockito.when(mockJavaLayerConfigurations.getResourceLayerEntries())
- .thenReturn(
- ImmutableList.of(new LayerEntry(Paths.get("ignored"), EXPECTED_RESOURCES_PATH)));
+ .thenReturn(ImmutableList.of(new LayerEntry(ignored, Paths.get(EXPECTED_RESOURCES_PATH))));
  Mockito.when(mockJavaLayerConfigurations.getClassLayerEntries())
- .thenReturn(ImmutableList.of(new LayerEntry(Paths.get("ignored"), EXPECTED_CLASSES_PATH)));
+ .thenReturn(ImmutableList.of(new LayerEntry(ignored, Paths.get(EXPECTED_CLASSES_PATH))));
  Mockito.when(mockJavaLayerConfigurations.getExplodedWarEntries())
  .thenReturn(
- ImmutableList.of(new LayerEntry(Paths.get("ignored"), EXPECTED_EXPLODED_WAR_PATH)));
+ ImmutableList.of(new LayerEntry(ignored, Paths.get(EXPECTED_EXPLODED_WAR_PATH))));
  Mockito.when(mockJavaLayerConfigurations.getExtraFilesLayerEntries())
- .thenReturn(ImmutableList.of(new LayerEntry(Paths.get("ignored"), Paths.get("/"))));
+ .thenReturn(ImmutableList.of(new LayerEntry(ignored, Paths.get("/"))));
+
+ Mockito.when(mockJavaLayerConfigurations.getDependencyExtractionPath())
+ .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getSnapshotDependencyExtractionPath())
+ .thenReturn(EXPECTED_DEPENDENCIES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getResourceExtractionPath())
+ .thenReturn(EXPECTED_RESOURCES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getClassExtractionPath())
+ .thenReturn(EXPECTED_CLASSES_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getExplodedWarExtractionPath())
+ .thenReturn(EXPECTED_EXPLODED_WAR_PATH);
+ Mockito.when(mockJavaLayerConfigurations.getExtraFilesExtractionPath()).thenReturn("/");
+
  String dockerfile =
  new JavaDockerContextGenerator(mockJavaLayerConfigurations)
  .setBaseImage(expectedBaseImage)
  .setEntrypoint(
  JavaEntrypointConstructor.makeDefaultEntrypoint(
- expectedJvmFlags, expectedMainClass))
+ "/app", expectedJvmFlags, expectedMainClass))
  .setJavaArguments(expectedJavaArguments)
  .setEnvironment(expectedEnv)
  .setExposedPorts(exposedPorts)