Sysvinit script for debian package

project/build.properties

@@ -1 +1 @@
-sbt.version=0.12.4
+sbt.version=0.13.0

src/main/resources/com/typesafe/sbt/packager/archetypes/sysvinit-template

@@ -0,0 +1,49 @@
+#! /bin/sh
+
+### BEGIN INIT INFO
+# Provides:	${{app_name}}
+# Required-Start: $syslog
+# Required-Stop: $syslog
+# Default-Start:	2 3 4 5
+# Default-Stop:
+# Short-Description: ${{descr}}
+### END INIT INFO
+
+PIDFILE=/var/run/${{app_name}}.pid
+DAEMON_USER=${{daemon_user}}
+
+. /lib/init/vars.sh
+. /lib/lsb/init-functions
+
+get_java_cmd() {
+  if [[ -n "$JAVA_HOME" ]] && [[ -x "$JAVA_HOME/bin/java" ]];  then
+    echo "$JAVA_HOME/bin/java"
+  else
+    echo "java"
+  fi
+}
+
+JAVA_CMD=$(get_java_cmd)
+
+RUN_CMD=$JAVA_CMD -cp ${{app_classpath}} ${{app_main_class}}
+
+case "$1" in
+
+start)  log_daemon_msg "Starting ${{app_name}}"
+
+        start-stop-daemon --background --start --chuid $DAEMON_USER --make-pidfile --pidfile $PIDFILE --exec $RUN_CMD
+
+	;;
+stop)   log_daemon_msg "Stopping ${{app_name}}"
+
+	start-stop-daemon --stop --pidfile $PIDFILE --chuid $DAEMON_USER
+
+        RETVAL=$?
+        [ $RETVAL -eq 0 ] && [ -e "$PIDFILE" ] && rm -f $PIDFILE
+        exit 2
+	;;
+*)      log_daemon_msg "Usage: /etc/init.d/${{app_name}} {start|stop}"
+        exit 2
+        ;;
+esac
+exit 0

src/main/scala/com/typesafe/sbt/PackagerPlugin.scala

@@ -46,6 +46,8 @@ object SbtNativePackager extends Plugin
       genericMappingSettings ++ archetypes.JavaAppPackaging.settings
     def java_server: Seq[Setting[_]] =
       genericMappingSettings ++ archetypes.JavaServerAppPackaging.settings
+    def java_server_sysvinit: Seq[Setting[_]] =
+      genericMappingSettings ++ archetypes.JavaServerAppSysVinitPackaging.settings
   }
 
   // TODO - Add a few targets that detect the current OS and build a package for that OS.

src/main/scala/com/typesafe/sbt/packager/archetypes/JavaAppUpstartScript.scala

@@ -6,16 +6,14 @@ package com.typesafe.sbt.packager.archetypes
  * Makes use of the associated upstart-template, with a few hooks
  *
  */
-object JavaAppUpstartScript {
+object JavaAppUpstartScript extends JavaAppScript {
 
-  private[this] def upstartTemplateSource: java.net.URL = getClass.getResource("upstart-template")
+  protected def templateSource: java.net.URL = getClass.getResource("upstart-template")
 
-  private[this] def postinstTemplateSource: java.net.URL = getClass.getResource("postinst-template")
-  private[this] def preremTemplateSource: java.net.URL = getClass.getResource("prerem-template")
   /**
    *
    * @param author -
-   * @param description - short description
+   * @param descr - short description
    * @param execScript - name of the script in /usr/bin
    * @param chdir - execution path of the script
    * @param retries - on fail, how often should a restart be tried
@@ -36,11 +34,53 @@ object JavaAppUpstartScript {
     "retries" -> retries.toString,
     "retryTimeout" -> retryTimeout.toString)
 
+}
+
+object JavaAppSysVinitScript extends JavaAppScript {
+  protected def templateSource: java.net.URL = getClass.getResource("sysvinit-template")
+
+
+  /**
+   *
+   * @param author -
+   * @param description - short description
+   * @return Seq of key,replacement pairs
+   */
+  def makeReplacements(
+    author: String,
+    description: String,
+    appDir: String,
+    appName: String,
+    appMainClass: String,
+    appClasspath: String,
+    daemonUser: String
+
+    ): Seq[(String, String)] =
+    Seq(
+      "author" -> author,
+      "descr" -> description,
+      "app_name" -> appName,
+      "app_dir" -> appDir,
+      "app_main_class" -> appMainClass,
+      "app_classpath" -> appClasspath,
+      "daemon_user" -> daemonUser
+    )
+}
+
+
+trait JavaAppScript {
+
+  protected def templateSource: java.net.URL
+
+  protected def postinstTemplateSource: java.net.URL = getClass.getResource("postinst-template")
+  protected def preremTemplateSource: java.net.URL = getClass.getResource("prerem-template")
+
+
   def generateScript(replacements: Seq[(String, String)]): String =
-    TemplateWriter.generateScript(upstartTemplateSource, replacements)
+    TemplateWriter.generateScript(templateSource, replacements)
 
   def generatePrerm(appName: String): String =
     TemplateWriter.generateScript(preremTemplateSource, Seq("app_name" -> appName))
   def generatePostinst(appName: String): String =
     TemplateWriter.generateScript(postinstTemplateSource, Seq("app_name" -> appName))
-}
+}

src/main/scala/com/typesafe/sbt/packager/archetypes/JavaServerApplication.scala

@@ -19,7 +19,7 @@ import com.typesafe.sbt.packager.linux.LinuxPackageMapping
  *
  *  **NOTE:  EXPERIMENTAL**   This currently only supports debian upstart scripts.
  */
-object JavaServerAppPackaging {
+object JavaServerAppPackaging extends JavaServerAppPackaging {
 
   def settings: Seq[Setting[_]] =
     JavaAppPackaging.settings ++
@@ -42,26 +42,79 @@ object JavaServerAppPackaging {
       debianMakePrermScript <<= (normalizedName, target in Universal) map makeDebianPrermScript,
       debianMakePostinstScript <<= (normalizedName, target in Universal) map makeDebianPostinstScript)
 
-  private[this] final def makeDebianPrermScript(name: String, tmpDir: File): Option[File] = {
+
+  private def makeDebianUpstartScript(replacements: Seq[(String, String)], name: String, tmpDir: File): Option[File] =
+    if (replacements.isEmpty) None
+    else {
+      val scriptBits = JavaAppUpstartScript.generateScript(replacements)
+      val script = tmpDir / "tmp" / "bin" / (name + ".conf")
+      IO.write(script, scriptBits)
+      Some(script)
+    }
+}
+
+
+object JavaServerAppSysVinitPackaging extends JavaServerAppPackaging {
+
+  def settings: Seq[Setting[_]] =
+    JavaAppPackaging.settings ++ debianSysVinitSettings
+
+  def debianSysVinitSettings: Seq[Setting[_]] = {
+    Seq(
+      debianSysVinitScriptReplacements <<= (maintainer in Debian, packageSummary in Debian, daemonUser in Debian,
+        normalizedName, name, sbt.Keys.version, defaultLinuxInstallLocation, sbt.Keys.mainClass in Compile, scriptClasspath)
+          map { (author, descr, daemonUser, normalizedName, name, version, installLocation, mainClass, cp) =>
+      // TODO name-version is copied from UniversalPlugin. This should be consolidated into a setting (install location...)
+        val appDir = installLocation + "/" + normalizedName
+        val appClasspath = cp.map(appDir + "/lib/" + _).mkString(":")
+
+        JavaAppSysVinitScript.makeReplacements(
+          author = author, description = descr,
+          appDir = appDir,
+          appName = name,
+          appClasspath = appClasspath,
+          appMainClass = mainClass.get,
+          daemonUser = daemonUser
+        )
+      },
+      debianMakeSysVinitScript <<= (debianSysVinitScriptReplacements, normalizedName, target in Universal) map makeDebianSysVinitScript,
+      linuxPackageMappings in Debian <++= (debianMakeSysVinitScript, normalizedName) map { (script, name) =>
+        for {
+          s <- script.toSeq
+        } yield LinuxPackageMapping(Seq(s -> ("/etc/init.d/" + name))).withPerms("0755")
+      },
+      // TODO - only make these if the upstart config exists...
+      debianMakePrermScript <<= (normalizedName, target in Universal) map makeDebianPrermScript,
+      debianMakePostinstScript <<= (normalizedName, target in Universal) map makeDebianPostinstScript)
+  }
+
+
+  private def makeDebianSysVinitScript(replacements: Seq[(String, String)], name: String, tmpDir: File): Option[File] =
+    if (replacements.isEmpty) None
+    else {
+      val scriptBits = JavaAppSysVinitScript.generateScript(replacements)
+      val script = tmpDir / "tmp" / "bin" / (name + ".conf")
+      IO.write(script, scriptBits)
+      Some(script)
+    }
+}
+
+
+trait JavaServerAppPackaging {
+
+  def settings: Seq[Setting[_]]
+
+  protected def makeDebianPrermScript(name: String, tmpDir: File): Option[File] = {
     val scriptBits = JavaAppUpstartScript.generatePrerm(name)
     val script = tmpDir / "tmp" / "bin" / "debian-prerm"
     IO.write(script, scriptBits)
     Some(script)
   }
 
-  private[this] final def makeDebianPostinstScript(name: String, tmpDir: File): Option[File] = {
+  protected def makeDebianPostinstScript(name: String, tmpDir: File): Option[File] = {
     val scriptBits = JavaAppUpstartScript.generatePostinst(name)
     val script = tmpDir / "tmp" / "bin" / "debian-postinst"
     IO.write(script, scriptBits)
     Some(script)
   }
-
-  private[this] final def makeDebianUpstartScript(replacements: Seq[(String, String)], name: String, tmpDir: File): Option[File] =
-    if (replacements.isEmpty) None
-    else {
-      val scriptBits = JavaAppUpstartScript.generateScript(replacements)
-      val script = tmpDir / "tmp" / "bin" / (name + ".conf")
-      IO.write(script, scriptBits)
-      Some(script)
-    }
-}
+}

src/main/scala/com/typesafe/sbt/packager/debian/Keys.scala

@@ -57,6 +57,20 @@ trait DebianKeys {
          |  retries - on fail, how often should a restart be tried
          |  retryTimeout - pause between retries
       """.stripMargin)
+
+  // Debian sysVinit scripts
+  val debianMakeSysVinitScript = TaskKey[Option[File]]("makeSysVinitScript", "Creates or discovers the sysVinit script used by this project")
+  val debianSysVinitScriptReplacements = TaskKey[Seq[(String, String)]]("sysVinitScriptReplacements",
+    """|Replacements of template parameters used in the sysVinit script.
+      |  Default supported templates:
+      |  execScript - name of the script in /usr/bin
+      |  daemonUser - daemon user
+      |  author - author of this project
+      |  descr - short description
+      |  retries - on fail, how often should a restart be tried
+      |  retryTimeout - pause between retries
+    """.stripMargin)
+
 }
 
 /** Keys used for Debian specific settings. */
@@ -77,5 +91,8 @@ object Keys extends DebianKeys {
   def target = sbt.Keys.target
   def streams = sbt.Keys.streams
 
+  //init script parameters
+  def daemonUser = linux.Keys.daemonUser
+
   val debianPackageInstallSize = TaskKey[Long]("debian-installed-size")
 }

src/main/scala/com/typesafe/sbt/packager/linux/Keys.scala

@@ -10,6 +10,7 @@ trait Keys {
   val packageSummary = SettingKey[String]("package-summary", "Summary of the contents of a linux package.")
   val packageDescription = SettingKey[String]("package-description", "The description of the package.  Used when searching.")
   val maintainer = SettingKey[String]("maintainer", "The name/email address of a maintainer for the native package.")
+  val daemonUser = SettingKey[String]("daemon-user", "User to start application daemon")
   val linuxPackageMappings = TaskKey[Seq[LinuxPackageMapping]]("linux-package-mappings", "File to install location mappings including owner and privileges.")
   val linuxPackageSymlinks = TaskKey[Seq[LinuxSymlink]]("linux-package-symlinks", "Symlinks we should produce in the underlying package.")
   val generateManPages = TaskKey[Unit]("generate-man-pages", "Shows all the man files in the current project")  

src/sbt-test/debian/sysvinit-deb/build.sbt

@@ -0,0 +1,15 @@
+import NativePackagerKeys._
+
+packageArchetype.java_server_sysvinit
+
+name := "debian-test"
+
+version := "0.1.0"
+
+maintainer := "Josh Suereth <[email protected]>"
+
+packageSummary := "Test debian package"
+
+packageDescription := """A fun package description of our software,
+  with multiple lines."""
+

src/sbt-test/debian/sysvinit-deb/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % sys.props("project.version"))

src/sbt-test/debian/sysvinit-deb/test

@@ -0,0 +1,6 @@
+# Run the debian packaging.
+> debian:package-bin
+$ exists target/debian-test-0.1.0.deb
+
+$ exists target/debian-test-0.1.0/etc
+$ exists target/debian-test-0.1.0/etc/init.d/debian-test