found - ¿Cuáles son las principales diferencias entre sbt-pack y sbt-assembly?

deduplicate: different file contents found in the following

Question

Acabo de tropezar con el plugin sbt-pack . La secuencia de desarrollo parece steady . Es sorprendente para mí, ya que creía que el único complemento para (citando el título de sbt-pack) "crear paquetes Scala distribuibles". es sbt-assembly (entre otras características).

¿Cuáles son las diferencias clave entre los complementos? ¿Cuándo debería usar uno sobre el otro?

Answer 1

(Descargo de responsabilidad: mantengo sbt-assembly)

sbt-assembly

sbt-assembly crea un JAR sbt-assembly : un único archivo JAR que contiene todos los archivos de clase de su código y bibliotecas. Por evolución, también contiene formas de resolver conflictos cuando varios JAR proporcionan la misma ruta de archivo (como configuración o archivo README). Implica descomprimir todos los JAR de la biblioteca, por lo que es un poco lento, pero están muy almacenados en caché.

paquete sbt

sbt-pack mantiene todos los archivos sbt-pack la biblioteca intactos, los mueve al directorio de target/pack (a diferencia del caché de hiedra donde normalmente vivirían) y crea un script de shell para que pueda ejecutarlos.

sbt-native-packager

sbt-native-packager es similar a sbt-pack pero fue iniciado por un committer de sbt Josh Suereth , y ahora es mantenido por Nepomuk Seiler (también conocido como muuki88). El complemento es compatible con varios formatos, como el archivo msi de Windows y el archivo debian Debian. La reciente adición es un soporte para imágenes Docker .

Todos son medios viables para crear imágenes de implementación. En ciertos casos, como la implementación de su aplicación en un marco web, etc., podría facilitar las cosas si se trata de un archivo en lugar de una docena.

Mención de honor: sbt-progard y sbt-onejar .

Answer 2

Aunque la explicación de Eugene Yokota es completa, me gustaría explicar los complementos mencionados con el comando del paquete en el aspecto de los usos y cómo se generan los diferentes resultados.

Configuración del directorio y build.sbt

lazy val commonSettings = Seq(
organization := "",
scalaVersion := "2.11.12",
version := "1.0",
)
lazy val app = (project in file ("app")).
enablePlugins(PackPlugin).
settings(commonSettings)

El archivo above build.sbt declara la aplicación llamada proyecto e incluye todos los archivos fuente en el directorio de la aplicación. Para habilitar los complementos de paquete, enablePlugins (PackPlugin) debe incluirse en el archivo sbt.

Además, he puesto la siguiente línea en el archivo project / plugins.sbt para usar los complementos del paquete en nuestro proyecto

addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.9.3")
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.5")

El paquete ya está integrado en el sbt de forma predeterminada, por lo que no tiene que especificar explícitamente los complementos mediante addSbtPlugins. Sin embargo, los complementos sbt-pack y sbt-assembly no están incluidos en el sbt de forma predeterminada, por lo que debe especificar que desea usarlos. addSbtPlugin es una forma de decir "Quiero usar xxx, yyy complementos en mi proyecto" para tu sbt.

Además, implementé dos archivos scala artificiales en ./app/src/main/scala:

AppBar.scala

class AppBar {
def printDescription() = println(AppBar.getDescription)
}
object AppBar {
private val getDescription: String = "Hello World, I am AppBar"
def main (args: Array[String]): Unit = {
val appBar = new AppBar
appBar.printDescription()
}
}

AppFoo.scala

class AppFoo {
def printDescription() = println(AppFoo.getDescription)
}
object AppFoo {
private val getDescription: String = "Hello World, I am AppFoo"
def main (args: Array[String]): Unit = {
val appFoo = new AppFoo
appFoo.printDescription()
}
}

paquete sbt

Este es un comando sbt muy básico incluido en el sbt para ayudarlo a distribuir su proyecto a través del archivo jar. El archivo jar generado por el comando package se encuentra en projectDirectoy / target / scala-2.11 / app_2.11-1.0.jar (Aquí, las claves ScalaVersion y de configuración de versión incluidas en el archivo build.sbt se utilizan para generar el jar nombre del archivo).

Cuando mira dentro del contenedor, puede ver los archivos de clase generados por la herramienta sbt, que es el resultado de compilar las fuentes en la aplicación / src / main / scala. Además, incluye un archivo MANIFEST.

$vi projectDirectoy/target/scala-2.11/app_2.11-1.0.jar
META-INF/MANIFEST.MF
AppBar$.class
AppBar.class
AppFoo.class
AppFoo$.class

Tenga en cuenta que solo incluye los archivos de clase generados a partir de los archivos scala ubicados en el directorio app / src / main / scala. El archivo jar generado por el comando paquete no incluye ninguna biblioteca relacionada con scala, como la colección en la biblioteca scala (por ejemplo, collection.mutable.Map.class). Por lo tanto, para ejecutar el programa puede necesitar una biblioteca de scala porque el archivo jar de generación solo contiene las clases mínimas generadas a partir de las fuentes de scala que implementé. Esa es la razón por la cual el archivo jar contiene AppBar.class, AppBar $ .class para el objeto complementario, etc.

sbt-assembly

Como menciona Eugene Yokota, sbt-assembly también lo ayuda a distribuir su proyecto mediante la generación del archivo jar; sin embargo, el archivo jar generado incluye no solo los archivos de clase generados por su código fuente, sino también todas las bibliotecas que necesita para ejecutar el programa. Por ejemplo, para ejecutar la función principal definida en el objeto AppFoo, es posible que necesite bibliotecas scala. Además, cuando agrega bibliotecas externas en su proyecto, que se pueden incluir agregando las dependencias a la clave libraryDependencies.

libraryDependencies ++= Seq("org.json4s" %% "json4s-jackson" % "3.5.3")

Por ejemplo, puede incluir bibliotecas json4s en su proyecto, y los archivos jar relacionados con el soporte de json4s en su proyecto también se agregarán al archivo jar final generado por el sbt-assembly. En otras palabras, cuando invocas el ensamblado en tu sbt, genera un archivo jar que contiene todos los requisitos para ejecutar tu programa, de modo que no necesites otra dependencia para ejecutar tu programa.

Cuando solicite el comando de ensamblaje en su shell sbt, generará un archivo jar en su directorio de destino. En este caso, puede encontrar el app-assembly-1.0.jar en el directorio app / target / scala-2.11. Cuando miras dentro del archivo jar, puedes encontrar que contiene muchas clases.

$vi projectDirectoy/target/scala-2.11/app_2.11-1.0.jar
ETA-INF/MANIFEST.MF
scala/
scala/annotation/
scala/annotation/meta/
scala/annotation/unchecked/
scala/beans/
scala/collection/
scala/collection/concurrent/
scala/collection/convert/
scala/collection/generic/
scala/collection/immutable/
scala/collection/mutable/
scala/collection/parallel/
scala/collection/parallel/immutable/
scala/collection/parallel/mutable/
scala/collection/script/
scala/compat/
scala/concurrent/
scala/concurrent/duration/
scala/concurrent/forkjoin/
scala/concurrent/impl/
scala/concurrent/util/
scala/io/
scala/math/
scala/ref/
scala/reflect/
scala/reflect/macros/
scala/reflect/macros/internal/
scala/runtime/
scala/sys/
scala/sys/process/
scala/text/
scala/util/
scala/util/control/
scala/util/hashing/
scala/util/matching/
AppBar$.class
AppBar.class
AppFoo$.class
AppFoo.class
......

Como se mencionó anteriormente, dado que el archivo jar generado por el ensamblado contiene todas las dependencias tales como scala y bibliotecas externas para ejecutar su programa en el jar, puede pensar que puede invocar las funciones principales definidas en el objeto AppFoo y en el objeto AppBar.

jaehyuk@ubuntu:~/work/sbt/app/target/scala-2.11$ java -cp ''./*'' AppFoo
Hello World, I am AppFoo
jaehyuk@ubuntu:~/work/sbt/app/target/scala-2.11$ java -cp ''./*'' AppBar
Hello World, I am AppBar

Sí ~ puedes ejecutar la función principal usando el archivo jar generado.

paquete sbt

sbt-pack es casi lo mismo que el sbt-assembly; guarda toda la biblioteca de la que depende su proyecto como archivos jar necesarios para ejecutar su programa. Sin embargo, sbt-pack no integra todas las dependencias en un archivo jar, sino que genera varios archivos jar que corresponden a las dependencias de una biblioteca y sus clases (por ejemplo, AppFoo.class).

Además, curiosamente genera scripts automáticamente para invocar todas las funciones principales definidas en los archivos fuente scala y Makefiles para instalar el programa. Echemos un vistazo al directorio del paquete creado después de que usted solicite el comando pack en su shell sbt.

jaehyuk@ubuntu:~/work/sbt/app/target/pack$ ls
bin lib Makefile VERSION
jaehyuk@ubuntu:~/work/sbt/app/target/pack$ ls bin/
app-bar app-bar.bat app-foo app-foo.bat
jaehyuk@ubuntu:~/work/sbt/app/target/pack$ ls lib/
app_2.11-1.0.jar sbt_2.12-0.1.0-SNAPSHOT.jar scala-library-2.11.12.jar
jaehyuk@ubuntu:~/work/sbt/app/target/pack$

Como se muestra en lo anterior, se crean dos directorios y dos archivos; bin contiene todos los archivos de script para ejecutar las funciones definidas en sus fuentes (cada archivo es un script que le ayuda a ejecutar el método principal definido en sus archivos scala); lib contiene todos los archivos jar necesarios para ejecutar su programa; y, por último, Makefile puede usarse para instalar su programa y bibliotecas dependientes en su sistema.

Para más detalles, consulte las páginas de github para cada complemento.