Add RepackageModule to build assemblies based on Spring Boot tools (#4489)

This adds a `mill.javalib.repackage.RepackageModule` which enhances a
`Module` with a `repackagedJar` task to produce self-executable JAR
files. If the module is a `JavaModule` everything should work out of the
box. Otherwise, the use may need to override various tasks, which is
analogue to using `RunModule` or `AssemblyModule`.

The Spring-Boot tools are encapsulated into a separate
`mill.javalib.spring.boot.SpringBootToolsModule` to avoid instantiating
multiple instance. A pre-configured version using the tools version
present at built-time is available as `ExternalModule` and used by
default.

Fix #4479

Pull request: #4489

Author: lefou

build.mill

@@ -192,6 +192,7 @@ object Deps {
   val semanticDBscala = mvn"org.scalameta:::semanticdb-scalac:4.13.4"
   val semanticDbJava = mvn"com.sourcegraph:semanticdb-java:0.10.3"
   val sourcecode = mvn"com.lihaoyi::sourcecode:0.4.3-M5"
+  val springBootTools = mvn"org.springframework.boot:spring-boot-loader-tools:3.4.5"
   val upickle = mvn"com.lihaoyi::upickle:4.1.0"
   // Using "native-terminal-no-ffm" rather than just "native-terminal", as the GraalVM releases currently
   // lacks support for FFM on Mac ARM. That should be fixed soon, see oracle/graal#8113.

core/util/src/mill/mill.scala

@@ -8,7 +8,9 @@ package object mill extends mill.define.JsonFormatters with mill.util.TokenReade
   type Module = define.Module
   type Cross[T <: Cross.Module[?]] = define.Cross[T]
   val Cross = define.Cross
+  @deprecated("Use Seq[T] instead", "Mill 0.13.0-M1")
   type Agg[T] = Seq[T]
+  @deprecated("Use Seq instead", "Mill 0.13.0-M1")
   val Agg = Seq
 
   type Args = define.Args

example/javalib/publishing/9-repackage-config/bar/src/bar/Bar.java

@@ -0,0 +1,12 @@
+package bar;
+
+import org.thymeleaf.TemplateEngine;
+import org.thymeleaf.context.Context;
+
+public class Bar {
+  public static String value() {
+    Context context = new Context();
+    context.setVariable("text", "world");
+    return new TemplateEngine().process("<p th:text=\"${text}\"></p>", context);
+  }
+}

example/javalib/publishing/9-repackage-config/bar/test/src/bar/BarTests.java

@@ -0,0 +1,13 @@
+package bar;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BarTests {
+
+  @Test
+  public void test() {
+    assertEquals(Bar.value(), "<p>world</p>");
+  }
+}

example/javalib/publishing/9-repackage-config/build.mill

@@ -0,0 +1,76 @@
+// An alternative way to produce self-executable assemblies is the `RepackageModule` which used the https://docs.spring.io/spring-boot/build-tool-plugin/index.html[Spring Boot Tools suite].
+// Instead of copying and merging dependencies classes and resources into a flat jar file, it embeds all dependencies as-is in the final jar.
+// One of the pros of this approach is, that all dependency archives are kept unextracted, which makes later introspection for checksums, authorship and copyright questions easier.
+
+package build
+
+import mill._, javalib._, publish._
+import mill.javalib.repackage.RepackageModule
+
+trait MyModule extends JavaModule with PublishModule {
+  def publishVersion = "0.0.1"
+
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("lihaoyi", "example"),
+    developers = Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
+  )
+
+  def mvnDeps = Seq(mvn"org.thymeleaf:thymeleaf:3.1.1.RELEASE")
+
+  object test extends JavaTests with TestModule.Junit4
+}
+
+object foo extends MyModule with RepackageModule { // <1>
+  def moduleDeps = Seq(bar, qux)
+}
+
+object bar extends MyModule {
+  def moduleDeps = Seq(qux)
+}
+
+object qux extends MyModule
+
+// <1> Add the `mill.javalib.repackage.RepackageModule` to the executable module.
+
+/** Usage
+
+> mill foo.run
+Foo.value: <h1>hello</h1>
+Bar.value: <p>world</p>
+Qux.value: 31337
+
+> mill show foo.repackagedJar
+".../out/foo/repackagedJar.dest/out.jar"
+
+> ./out/foo/repackagedJar.dest/out.jar
+Foo.value: <h1>hello</h1>
+Bar.value: <p>world</p>
+Qux.value: 31337
+
+> unzip -l ./out/foo/repackagedJar.dest/out.jar "BOOT-INF/lib*"
+...BOOT-INF/lib/thymeleaf-3.1.1.RELEASE.jar
+...BOOT-INF/lib/ognl-3.3.4.jar
+...BOOT-INF/lib/attoparser-2.0.6.RELEASE.jar
+...BOOT-INF/lib/unbescape-1.1.6.RELEASE.jar
+...BOOT-INF/lib/slf4j-api-2.0.5.jar
+...BOOT-INF/lib/javassist-3.29.0-GA.jar
+...BOOT-INF/lib/qux-0.0.1.jar
+...BOOT-INF/lib/bar-0.0.1.jar
+
+*/
+
+// *Futher notes:*
+//
+// * a small wrapper application needs to be added, which is run as entry point and transparently manages loading the embedded jars and running your `main` method.
+// This works for all Java (also Scala or Kotlin) applications.
+// * It's not necessary to use the Spring Framework in the application.
+// * The resulting jar is a self-executable application, but it might not suitable to be used on the classpath of other applications.
+
+// * Since the final jar produced with the `RepackageModule.repackagedJar` task often contains significantly less ZIP entries
+// then the jar file produced with `.assembly`, it's possible to workaround
+// an https://github.com/com-lihaoyi/mill/issues/2650[issue where `JavaModule.assembly` cannot produce executable assemblies]
+// due to some JVM limitations in ZIP file handling of large files.

example/javalib/publishing/9-repackage-config/foo/src/foo/Foo.java

@@ -0,0 +1,11 @@
+package foo;
+
+public class Foo {
+  public static String value = "<h1>hello</h1>";
+
+  public static void main(String[] args) {
+    System.out.println("Foo.value: " + Foo.value);
+    System.out.println("Bar.value: " + bar.Bar.value());
+    System.out.println("Qux.value: " + qux.Qux.value);
+  }
+}

example/javalib/publishing/9-repackage-config/foo/test/src/foo/FooTests.java

@@ -0,0 +1,13 @@
+package foo;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class FooTests {
+
+  @Test
+  public void test() {
+    assertEquals(Foo.value, "<h1>hello</h1>");
+  }
+}

example/javalib/publishing/9-repackage-config/qux/src/qux/Qux.java

@@ -0,0 +1,9 @@
+package qux;
+
+public class Qux {
+  public static final int value = 31337;
+
+  public static void main(String[] args) {
+    System.out.println("Qux.value: " + Qux.value);
+  }
+}

libs/scalalib/api/src/mill/javalib/spring/boot/worker/SpringBootTools.scala

@@ -0,0 +1,20 @@
+package mill.javalib.spring.boot.worker
+
+import mill.define.TaskCtx
+
+@mill.api.experimental
+trait SpringBootTools {
+  def repackageJar(
+      dest: os.Path,
+      base: os.Path,
+      mainClass: String,
+      libs: Seq[os.Path],
+      assemblyScript: Option[String]
+  )(implicit ctx: TaskCtx): Unit
+
+  /**
+   * Find a SpringBootApplication entry point.
+   * @param classesPath
+   */
+  def findSpringBootApplicationClass(classesPath: Seq[os.Path]): Either[String, String]
+}

libs/scalalib/package.mill

@@ -1,6 +1,7 @@
 package build.libs.scalalib
 import scala.util.Properties
 import scala.util.chaining._
+
 import coursier.maven.MavenRepository
 import mill._
 import mill.define.NamedTask
@@ -91,13 +92,21 @@ object `package` extends build.MillStableScalaModule {
         "revApiVersion",
         build.Deps.RuntimeDeps.revApi.version,
         "Version of revApi"
+      ),
+      BuildInfo.Value("springBuildToolsVersion", build.Deps.springBootTools.version),
+      BuildInfo.Value(
+        "millSpringBootWorkerDep", {
+          val dep = `spring-boot-worker`.publishSelfDependency()
+          s"${dep.group}:${dep.id}:${dep.version}"
+        },
+        "The dependency containing the worker implementation to be loaded at runtime."
       )
     )
   }
 
   object worker extends build.MillPublishScalaModule with BuildInfo {
     def moduleDeps = Seq(api, build.core.util)
-    def mvnDeps = Agg(build.Deps.zinc, build.Deps.log4j2Core)
+    def mvnDeps = Seq(build.Deps.zinc, build.Deps.log4j2Core)
     def buildInfoPackageName = "mill.scalalib.worker"
     def buildInfoObjectName = "Versions"
     def buildInfoMembers = Seq(
@@ -107,12 +116,20 @@ object `package` extends build.MillStableScalaModule {
 
   object `classgraph-worker` extends build.MillPublishScalaModule {
     def moduleDeps = Seq(api, build.core.util)
-    def mvnDeps = Agg(build.Deps.classgraph)
+    def mvnDeps = Seq(build.Deps.classgraph)
   }
 
   object `jarjarabrams-worker` extends build.MillPublishScalaModule {
     def moduleDeps = Seq(api, build.core.util, build.libs.scalalib)
     def mvnDeps = Agg(build.Deps.jarjarabrams)
   }
 
+  object `spring-boot-worker` extends build.MillPublishScalaModule {
+    def moduleDeps = Seq(api)
+    def compileMvnDeps = Seq(
+      // we just bind against the API, will be loaded at Mill runtime by the module
+      build.Deps.springBootTools
+    )
+  }
+
 }