Extending "universal" configuration in sbt-native-packager

Question

I'm working with sbt 0.13.8 and sbt-native-packager 1.0.3.

I'd like to to set up a development and production packaging configuration with different java options. The idea is creating a package tarball through UniversalPluguin from sbt-native-packager : "universal:packageZipTarball". I'm also using the "JavaServerAppPackaging" archetype.

I tried this Build.scala:

import sbt._
import Keys._
import com.typesafe.sbt.packager.universal.UniversalPlugin.autoImport._
import com.typesafe.sbt.packager.archetypes.JavaServerAppPackaging

object Build extends Build {

  lazy val commonSettings: Seq[Setting[_]] = Seq(
    scalaVersion := "2.11.7",
    crossScalaVersions := Seq("2.11.7"),
    scalacOptions in Compile ++= Seq( "-unchecked", "-feature", "-language:postfixOps", "-deprecation" )
  )

  lazy val devConfig = config("dev") extend Universal
  lazy val prodConfig = config("prod") extend Universal

  lazy val root = (project in file("."))
    .settings(commonSettings : _*)
    .enablePlugins(JavaServerAppPackaging)
    .configs(devConfig, prodConfig)
    .settings(
      javaOptions in devConfig ++= Seq(
        // -J params will be added as jvm parameters
        "-J-Xmx384m",
        "-J-Xss512k"),
      javaOptions in prodConfig ++= Seq(
        // -J params will be added as jvm parameters
        "-J-Xmx384m",
        "-J-Xss740k")
    )
}

With that setup, SBT keeps failing with:

Error:Error while importing SBT project:
...
at sbt.Classpaths$$anonfun$updateTask$1.apply(Defaults.scala:1310)
at scala.Function1$$anonfun$compose$1.apply(Function1.scala:47)
at sbt.$tilde$greater$$anonfun$$u2219$1.apply(TypeFunctions.scala:40)
at sbt.std.Transform$$anon$4.work(System.scala:63)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:226)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:226)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:17)
at sbt.Execute.work(Execute.scala:235)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:226)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:226)
at sbtConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:159)
at sbt.CompletionService$$anon$2.call(CompletionService.scala:28)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
[error] java.text.ParseException: unknown configuration 'universal'. It is extended by dev in null
[error] Use 'last' for the full log.

See complete log in /Users/ivan/Library/Logs/IdeaIC14/sbt.last.log

I'm behind the idea of creating two packaged tarball for development with sbt command "dev:packageZipTarball", and for production with "prod:packageZipTarball" with different jvm options.

Any ideas why I can't extend "universal" configuration with custom configurations in order to achieve that or alternatives to that approach?

Answer 1

I highly recommend against extending configurations. The behaviour is not the expected one. The best way to achieve different build configurations is to create submodules for each configuration.

See this answer that explains in more detail how to create subprojects with different configurations.