use case: single project, multiple apps

[wookietreiber]

As I understand it, from a cursory reading of your documentation, sbt-native-packager considers only a single main class and will create only a single script invoking that main class, is that correct?

The use case I am currently pondering on is having a single project with multiple main classes, i.e. multiple distinct apps, each of which should get its own script, e.g.:

package foobar

object foo extends App with Library with Util
object bar extends App with Library with Util

trait Library
trait Util

Supposed to be deployed result:

bin/foo
bin/bar
lib/project.jar

Each of the scripts in bin uses the same lib/project.jar only with a different main class.

Is this possible to achieve right now? If not: Is sbt-native-packager able to be extended to support this use case?

[metasim]

The way I handle this is via a packaging submodule, which in turn has separate submodules for each package I want to create. Here's a rough idea of what I'm talking about.

[muuki88]

Submodules are one way to handle this. If you just want different startup scripts you could

• create a script for each main in src/universal/bin
• content of each script ( not tested, only to the get the idea )

#!/bin/bash
you-app-name -main path.to.Main

See #319

[muuki88]

@metasim can you put your snippet here? At some point we can move parts from there to the docs.

[metasim]

@muuki88 How's this?: https://github.com/sbt/sbt-native-packager/wiki/Helpful-Snippets

[muuki88]

@metasim sweet :)

[muuki88]

@wookietreiber did one of the solutions solve your problem?

[wookietreiber]

Sorry for not replying sooner, I had to postpone the project I had this feature in mind for a while.

Today I dove a bit into sbt tasks and the way I handled it for now is this:

val scripts = taskKey[Unit]("Creates the scripts.")

scripts := {
  val scriptDir = target.value / "scripts"
  if (!scriptDir.exists) scriptDir.mkdir()

  val prefix = sys.env.getOrElse("PREFIX", "/usr/local")

  def script(clazz: String) =
    s"""|#!/bin/sh
        |java -cp ${prefix}/share/grid-engine-tools/grid-engine-tools.jar $clazz
        |""".stripMargin

  (discoveredMainClasses in Compile).value foreach { clazz =>
    val app = clazz.drop(clazz.lastIndexOf(".") + 1)
    val s = scriptDir / app
    IO.write(s, script(clazz))
  }
}

scripts <<= scripts dependsOn assembly

In the end I realized this wasn't that complicated overall. The one part that is not handled by this snippet is the actual installation and prefix handling which I did with an external Makefile, because there are some other non-Scala bash scripts which also need installation.

I always intended the solution to center around the discoveredMainClasses sbt key and to iterate over its values. Other solutions work around the problem too much and make it more complicated by e.g. having to have a separate sbt project for each app.

Do you think using discoveredMainClasses could be implemented in sbt-native-packager?

If you would like to see the full project, here is a link, both Makefile and build.sbt are not very complex.

Note: I depend in my example on the sbt assembly task.

[muuki88]

Sorry for the VERY late reply. Building a small archetype plugin for this would generally be a nice idea. Best case would be to just call the initial start script, but with a different main class.

[atrosinenko]

Looks like this already works in version 1.2.2.

[muuki88]

Thanks for the hint. Indeed this was introduced in 1.2.0