fix: support for Spring Boot 3.2.0 (and newer) layered jar format

manusa · manusa · commit a0befb16b09d · 2023-11-30T09:29:23.000+01:00
Signed-off-by: Marc Nuri &lt;marc@marcnuri.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -29,6 +29,7 @@ Usage:
 * Fix #2456: Add utility class to decompress archive files
 * Fix #2472: Support for Helm Chart.yaml appVersion field defaulting to project version
 * Fix #2474: Remove Docker-related classes providing  unused functionality
+* Fix #2477: Support for Spring Boot 3.2.0 (and newer) layered jar format
 
 ### 1.15.0 (2023-11-10)
 * Fix #2138: Support for Spring Boot Native Image
diff --git a/jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/ExternalCommand.java b/jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/ExternalCommand.java
@@ -45,9 +45,9 @@ protected ExternalCommand(KitLogger log) {
         this(log, null);
     }
 
-    protected ExternalCommand(KitLogger log, File dir) {
+    protected ExternalCommand(KitLogger log, File workDir) {
         this.log = log;
-        this.workDir = dir;
+        this.workDir = workDir;
     }
 
     public void execute() throws IOException {
@@ -72,10 +72,8 @@ public void execute(String processInput) throws IOException {
             end();
         }
         if (statusCode != 0) {
-            throw new IOException(String.format("Process '%s' exited with status %d",
-                                                getCommandAsString(), statusCode));
+            throw new IOException(String.format("Process '%s' exited with status %d", getCommandAsString(), statusCode));
         }
-
     }
 
     // Hooks for logging ...
diff --git a/jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/util/SpringBootUtil.java b/jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/util/SpringBootUtil.java
@@ -14,14 +14,12 @@
 package org.eclipse.jkube.kit.common.util;
 
 import java.io.File;
-import java.io.IOException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
-import java.util.jar.JarFile;
 
 import org.eclipse.jkube.kit.common.JavaProject;
 import org.eclipse.jkube.kit.common.Plugin;
@@ -124,14 +122,6 @@ public static boolean isSpringBootRepackage(JavaProject project) {
             .orElse(false);
     }
 
-    public static boolean isLayeredJar(File fatJar) {
-        try (JarFile jarFile = new JarFile(fatJar)) {
-            return jarFile.getEntry("BOOT-INF/layers.idx") != null;
-        } catch (IOException ioException) {
-            throw new IllegalStateException("Failure in inspecting fat jar for layers.idx file", ioException);
-        }
-    }
-
     public static Plugin getNativePlugin(JavaProject project) {
         Plugin plugin = JKubeProjectUtil.getPlugin(project, "org.graalvm.buildtools", "native-maven-plugin");
         if (plugin != null) {
diff --git a/jkube-kit/common/src/test/java/org/eclipse/jkube/kit/common/util/SpringBootUtilTest.java b/jkube-kit/common/src/test/java/org/eclipse/jkube/kit/common/util/SpringBootUtilTest.java
@@ -32,10 +32,6 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
-import java.util.jar.Attributes;
-import java.util.jar.JarEntry;
-import java.util.jar.JarOutputStream;
-import java.util.jar.Manifest;
 
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -249,32 +245,6 @@ void isSpringBootRepackage_whenNoExecution_thenReturnFalse() {
         assertThat(result).isFalse();
     }
 
-    @Test
-    void isLayeredJar_whenInvalidFile_thenThrowException() {
-        // When + Then
-        assertThatIllegalStateException()
-            .isThrownBy(() -> SpringBootUtil.isLayeredJar(new File("i-dont-exist.jar")))
-            .withMessage("Failure in inspecting fat jar for layers.idx file");
-    }
-
-    @Test
-    void isLayeredJar_whenJarContainsLayers_thenReturnTrue(@TempDir File temporaryFolder) throws IOException {
-        // Given
-        File jarFile = new File(temporaryFolder, "fat.jar");
-        Manifest manifest = new Manifest();
-        manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
-        manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, "org.example.Foo");
-        try (JarOutputStream jarOutputStream = new JarOutputStream(Files.newOutputStream(jarFile.toPath()), manifest)) {
-            jarOutputStream.putNextEntry(new JarEntry("BOOT-INF/layers.idx"));
-        }
-
-        // When
-        boolean result = SpringBootUtil.isLayeredJar(jarFile);
-
-        // Then
-        assertThat(result).isTrue();
-    }
-
     @Test
     void getNativePlugin_whenNoNativePluginPresent_thenReturnNull() {
         assertThat(SpringBootUtil.getNativePlugin(JavaProject.builder().build())).isNull();
diff --git a/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/SpringBootLayeredJar.java b/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/SpringBootLayeredJar.java
@@ -14,13 +14,19 @@
 package org.eclipse.jkube.springboot;
 
 import lombok.Getter;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.jkube.kit.common.ExternalCommand;
 import org.eclipse.jkube.kit.common.KitLogger;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Properties;
+import java.util.jar.JarFile;
+import java.util.zip.ZipEntry;
 
 public class SpringBootLayeredJar {
 
@@ -32,6 +38,32 @@ public SpringBootLayeredJar(File layeredJar, KitLogger kitLogger) {
     this.kitLogger = kitLogger;
   }
 
+  public boolean isLayeredJar() {
+    try (JarFile jarFile = new JarFile(layeredJar)) {
+      return jarFile.getEntry("BOOT-INF/layers.idx") != null && StringUtils.isNotBlank(getMainClass());
+    } catch(Exception e) {
+      kitLogger.debug("Couldn't determine if Spring Boot jar %s is layered", layeredJar.getName(), e);
+    }
+    return false;
+  }
+
+  public String getMainClass() {
+    try (JarFile jarFile = new JarFile(layeredJar)) {
+      final ZipEntry manifest = jarFile.getEntry("META-INF/MANIFEST.MF");
+      if (manifest == null) {
+        return null;
+      }
+      final Properties properties = new Properties();
+      try (InputStream manifestInputStream = jarFile.getInputStream(manifest)) {
+        properties.load(manifestInputStream);
+        return properties.getProperty("Main-Class");
+      }
+    } catch(Exception e) {
+      kitLogger.debug("Couldn't determine Spring Boot jar's (%s) main class ", layeredJar.getName(), e);
+    }
+    return null;
+  }
+
   public List<String> listLayers() {
     final LayerListCommand layerListCommand = new LayerListCommand(kitLogger, layeredJar);
     try {
@@ -44,45 +76,40 @@ public List<String> listLayers() {
 
   public void extractLayers(File extractionDir) {
     try {
-      new LayerExtractorCommand(kitLogger, extractionDir, layeredJar).execute();
+      new LayerToolsCommand(kitLogger, extractionDir, layeredJar,  "extract").execute();
     } catch (IOException ioException) {
       throw new IllegalStateException("Failure in extracting spring boot jar layers", ioException);
     }
   }
 
-  private static class LayerExtractorCommand extends ExternalCommand {
+  private static class LayerToolsCommand extends ExternalCommand {
     private final File layeredJar;
-    protected LayerExtractorCommand(KitLogger log, File workDir, File layeredJar) {
+    private final String[] args;
+
+    protected LayerToolsCommand(KitLogger log, File workDir, File layeredJar, String... args) {
       super(log, workDir);
       this.layeredJar = layeredJar;
+      this.args = args;
     }
 
     @Override
     protected String[] getArgs() {
-      return new String[] { "java", "-Djarmode=layertools", "-jar", layeredJar.getAbsolutePath(), "extract"};
+      return ArrayUtils.addAll(new String[] { "java", "-Djarmode=layertools", "-jar", layeredJar.getAbsolutePath()}, args);
     }
   }
 
-  private static class LayerListCommand extends ExternalCommand {
-    private final File layeredJar;
-    @Getter
-    private final List<String> layers;
+  @Getter
+  private static class LayerListCommand extends LayerToolsCommand {
 
+    private final List<String> layers;
     protected LayerListCommand(KitLogger log, File layeredJar) {
-      super(log);
-      this.layeredJar = layeredJar;
+      super(log, null, layeredJar, "list");
       layers = new ArrayList<>();
     }
 
-    @Override
-    protected String[] getArgs() {
-      return new String[] { "java", "-Djarmode=layertools", "-jar", layeredJar.getAbsolutePath(), "list"};
-    }
-
     @Override
     protected void processLine(String line) {
       layers.add(line);
     }
-
   }
 }
diff --git a/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/generator/LayeredJarGenerator.java b/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/generator/LayeredJarGenerator.java
@@ -30,7 +30,6 @@
 
 public class LayeredJarGenerator extends AbstractSpringBootNestedGenerator {
 
-  private static final String MAIN_CLASS = "org.springframework.boot.loader.JarLauncher";
   private final SpringBootLayeredJar springBootLayeredJar;
 
   public LayeredJarGenerator(GeneratorContext generatorContext, GeneratorConfig generatorConfig, File layeredJar) {
@@ -41,7 +40,7 @@ public LayeredJarGenerator(GeneratorContext generatorContext, GeneratorConfig ge
   @Override
   public Map<String, String> getEnv(Function<Boolean, Map<String, String>> javaExecEnvSupplier, boolean prePackagePhase) {
     final Map<String, String> res = super.getEnv(javaExecEnvSupplier, prePackagePhase);
-    res.put("JAVA_MAIN_CLASS", MAIN_CLASS);
+    res.put("JAVA_MAIN_CLASS", springBootLayeredJar.getMainClass());
     return res;
   }
 
diff --git a/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/generator/SpringBootNestedGenerator.java b/jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/generator/SpringBootNestedGenerator.java
@@ -20,13 +20,13 @@
 import org.eclipse.jkube.kit.common.AssemblyConfiguration;
 import org.eclipse.jkube.kit.common.AssemblyFileSet;
 import org.eclipse.jkube.kit.common.JavaProject;
+import org.eclipse.jkube.springboot.SpringBootLayeredJar;
 
 import java.util.List;
 import java.util.Map;
 
 import static org.eclipse.jkube.generator.javaexec.JavaExecGenerator.JOLOKIA_PORT_DEFAULT;
 import static org.eclipse.jkube.generator.javaexec.JavaExecGenerator.PROMETHEUS_PORT_DEFAULT;
-import static org.eclipse.jkube.kit.common.util.SpringBootUtil.isLayeredJar;
 import java.io.File;
 import java.util.function.Function;
 
@@ -70,7 +70,7 @@ static SpringBootNestedGenerator from(GeneratorContext generatorContext, Generat
       }
     }
     if (fatJarDetectorResult != null && fatJarDetectorResult.getArchiveFile() != null &&
-        isLayeredJar(fatJarDetectorResult.getArchiveFile())) {
+        new SpringBootLayeredJar(fatJarDetectorResult.getArchiveFile(), generatorContext.getLogger()).isLayeredJar()) {
       return new LayeredJarGenerator(generatorContext, generatorConfig, fatJarDetectorResult.getArchiveFile());
     }
     return new FatJarGenerator(generatorContext, generatorConfig);
diff --git a/jkube-kit/jkube-kit-spring-boot/src/test/java/org/eclipse/jkube/springboot/SpringBootLayeredJarTest.java b/jkube-kit/jkube-kit-spring-boot/src/test/java/org/eclipse/jkube/springboot/SpringBootLayeredJarTest.java
@@ -26,6 +26,10 @@
 import java.nio.file.Files;
 import java.util.List;
 import java.util.Objects;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
@@ -37,6 +41,7 @@ class SpringBootLayeredJarTest {
 
   private SpringBootLayeredJar springBootLayeredJar;
 
+
   @Nested
   @DisplayName("with invalid jar")
   class InvalidJar {
@@ -45,6 +50,22 @@ void setup() {
       springBootLayeredJar = new SpringBootLayeredJar(new File(projectDir, "invalid.jar"), new KitLogger.SilentLogger());
     }
 
+    @Test
+    void isLayeredJar_returnsFalse() {
+      // When
+      final boolean result = springBootLayeredJar.isLayeredJar();
+      // Then
+      assertThat(result).isFalse();
+    }
+
+    @Test
+    void getMainClass_returnsNull() {
+      // When
+      final String result = springBootLayeredJar.getMainClass();
+      // Then
+      assertThat(result).isNull();
+    }
+
     @Test
     void listLayers_whenJarInvalid_thenThrowException() {
       assertThatIllegalStateException()
@@ -59,9 +80,10 @@ void extractLayers_whenJarInvalid_thenThrowException() {
         .withMessage("Failure in extracting spring boot jar layers");
     }
   }
+
   @Nested
-  @DisplayName("with valid jar")
-  class ValidJar {
+  @DisplayName("with valid (real) jar")
+  class RealJar {
     @BeforeEach
     void setup() throws IOException {
       final File layeredJar = new File(projectDir, "layered.jar");
@@ -73,7 +95,23 @@ void setup() throws IOException {
     }
 
     @Test
-    void listLayers_whenJarInvalid_thenThrowException() {
+    void isLayeredJar_returnsTrue() {
+      // When
+      final boolean result = springBootLayeredJar.isLayeredJar();
+      // Then
+      assertThat(result).isTrue();
+    }
+
+    @Test
+    void getMainClass_returnsJarLauncher() {
+      // When
+      final String result = springBootLayeredJar.getMainClass();
+      // Then
+      assertThat(result).isEqualTo("org.springframework.boot.loader.JarLauncher");
+    }
+
+    @Test
+    void listLayers() {
       // When
       final List<String> result = springBootLayeredJar.listLayers();
       // Then
@@ -82,7 +120,7 @@ void listLayers_whenJarInvalid_thenThrowException() {
     }
 
     @Test
-    void extractLayers_whenJarInvalid_thenThrowException() throws IOException {
+    void extractLayers() throws IOException {
       // Given
       final File extractionDir = Files.createDirectory(new File(projectDir, "extracted").toPath()).toFile();
       // When
@@ -93,4 +131,51 @@ void extractLayers_whenJarInvalid_thenThrowException() throws IOException {
         .contains("dependencies", "spring-boot-loader", "snapshot-dependencies", "application");
     }
   }
+
+  @Nested
+  @DisplayName("with fake jar with MANIFEST.MF and layers.idx")
+  class FakeJar {
+    @BeforeEach
+    void setup() throws IOException {
+      final File fakeJar = new File(projectDir, "fake.jar");
+      final Manifest manifest = new Manifest();
+      manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
+      manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, "org.example.Foo");
+      try (JarOutputStream jarOutputStream = new JarOutputStream(Files.newOutputStream(fakeJar.toPath()), manifest)) {
+        jarOutputStream.putNextEntry(new JarEntry("BOOT-INF/layers.idx"));
+      }
+      springBootLayeredJar = new SpringBootLayeredJar(fakeJar, new KitLogger.SilentLogger());
+    }
+
+    @Test
+    void getMainClass_returnsManifestMainClass() {
+      // When
+      final String result = springBootLayeredJar.getMainClass();
+      // Then
+      assertThat(result).isEqualTo("org.example.Foo");
+    }
+
+    @Test
+    void isLayeredJar_returnsTrue() {
+      // When
+      final boolean result = springBootLayeredJar.isLayeredJar();
+      // Then
+      assertThat(result).isTrue();
+    }
+
+
+    @Test
+    void listLayers_whenJarInvalid_thenThrowException() {
+      assertThatIllegalStateException()
+        .isThrownBy(() -> springBootLayeredJar.listLayers())
+        .withMessage("Failure in getting spring boot jar layers information");
+    }
+
+    @Test
+    void extractLayers_whenJarInvalid_thenThrowException() {
+      assertThatIllegalStateException()
+        .isThrownBy(() -> springBootLayeredJar.extractLayers(projectDir))
+        .withMessage("Failure in extracting spring boot jar layers");
+    }
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -45,9 +45,9 @@ protected ExternalCommand(KitLogger log) {`
`45`	`45`	`this(log, null);`
`46`	`46`	`}`
`47`	`47`
`48`		`- protected ExternalCommand(KitLogger log, File dir) {`
	`48`	`+ protected ExternalCommand(KitLogger log, File workDir) {`
`49`	`49`	`this.log = log;`
`50`		`- this.workDir = dir;`
	`50`	`+ this.workDir = workDir;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`public void execute() throws IOException {`
`@@ -72,10 +72,8 @@ public void execute(String processInput) throws IOException {`
`72`	`72`	`end();`
`73`	`73`	`}`
`74`	`74`	`if (statusCode != 0) {`
`75`		`- throw new IOException(String.format("Process '%s' exited with status %d",`
`76`		`- getCommandAsString(), statusCode));`
	`75`	`+ throw new IOException(String.format("Process '%s' exited with status %d", getCommandAsString(), statusCode));`
`77`	`76`	`}`
`78`		`-`
`79`	`77`	`}`
`80`	`78`
`81`	`79`	`// Hooks for logging ...`