Updated changes for Docker extension to sbt-native-packager

- Trait DockerPlugin should not extend DockerKeys
- publishArtifact in Docker is false - do not generate POM/etc.
- Tasks for stage do not depend on each other.
- Change the CWD in the Docker container to install location.
- Adding Docker-specific mappings happens outside mapGenericFilesToDocker
- Use defaultLinuxInstallLocation instead of defaultDockerInstallLocation
- dockerBaseImage is set outside Docker config, easier to override

Author: Gary Coady

src/main/scala/com/typesafe/sbt/packager/docker/DockerPlugin.scala

@@ -5,21 +5,18 @@ import Keys._
 import universal._
 import sbt._
 
-import sbt.Keys.cacheDirectory
-import universal.Keys.stage
-
-trait DockerPlugin extends Plugin with UniversalPlugin with DockerKeys {
+trait DockerPlugin extends Plugin with UniversalPlugin {
   val Docker = config("docker") extend Universal
 
   private[this] final def makeDockerContent(dockerBaseImage: String, dockerBaseDirectory: String, maintainer: String, daemonUser: String, name: String) = {
     Dockerfile(
       Cmd("FROM", dockerBaseImage),
       Cmd("MAINTAINER", maintainer),
       Cmd("ADD", "files /"),
-      Cmd("WORKDIR", "%s/bin" format dockerBaseDirectory),
-      ExecCmd("RUN", "chown", "-R", daemonUser, ".."),
+      Cmd("WORKDIR", "%s" format dockerBaseDirectory),
+      ExecCmd("RUN", "chown", "-R", daemonUser, "."),
       Cmd("USER", daemonUser),
-      ExecCmd("ENTRYPOINT", name),
+      ExecCmd("ENTRYPOINT", "bin/%s" format name),
       ExecCmd("CMD")
     ).makeContent
   }
@@ -42,32 +39,33 @@ trait DockerPlugin extends Plugin with UniversalPlugin with DockerKeys {
     }
 
     inConfig(Docker)(Seq(
-      mappings <<= (mappings in Universal, defaultDockerInstallLocation) map { (mappings, dest) =>
+      mappings <<= (mappings in Universal, defaultLinuxInstallLocation) map { (mappings, dest) =>
         renameDests(mappings, dest)
-      },
-      mappings <++= dockerPackageMappings
+      }
     ))
   }
 
   def dockerSettings: Seq[Setting[_]] = Seq(
+    dockerBaseImage := "dockerfile/java",
     sourceDirectory in Docker <<= sourceDirectory apply (_ / "docker"),
     target in Docker <<= target apply (_ / "docker")
   ) ++ mapGenericFilesToDocker ++ inConfig(Docker)(Seq(
       daemonUser := "daemon",
-      dockerBaseImage := "dockerfile/java",
-      defaultDockerInstallLocation := "/opt/docker",
-      dockerPackageMappings <<= (sourceDirectory in Docker) map { dir =>
+      publishArtifact := false,
+      defaultLinuxInstallLocation := "/opt/docker",
+      dockerPackageMappings <<= (sourceDirectory) map { dir =>
         MappingsHelper contentOf dir
       },
-      stage <<= dockerGenerateContext.dependsOn(dockerGenerateConfig),
+      mappings <++= dockerPackageMappings,
+      stage <<= (dockerGenerateConfig, dockerGenerateContext) map { (configFile, contextDir) => () },
       dockerGenerateContext <<= (cacheDirectory, mappings, target) map {
         (cacheDirectory, mappings, t) =>
           val contextDir = t / "files"
           stageFiles("docker")(cacheDirectory, contextDir, mappings)
           contextDir
       },
       dockerGenerateConfig <<=
-        (dockerBaseImage, defaultDockerInstallLocation, maintainer in Docker, daemonUser in Docker, normalizedName in Docker, target in Docker) map {
+        (dockerBaseImage, defaultLinuxInstallLocation, maintainer, daemonUser, normalizedName, target) map {
           case (dockerBaseImage, baseDirectory, maintainer, daemonUser, normalizedName, target) =>
             generateDockerConfig(dockerBaseImage, baseDirectory, maintainer, daemonUser, normalizedName, target)
         }

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

@@ -6,17 +6,21 @@ import sbt._
 
 trait DockerKeys {
   val dockerGenerateConfig = TaskKey[File]("docker-generate-config", "Generates configuration file for Docker.")
-  val dockerGenerateContext = TaskKey[Unit]("docker-generate-context", "Generates context directory for Docker.")
+  val dockerGenerateContext = TaskKey[File]("docker-generate-context", "Generates context directory for Docker.")
   val dockerPackageMappings = TaskKey[Seq[(File, String)]]("docker-package-mappings", "Generates location mappings for Docker build.")
+
   val dockerBaseImage = SettingKey[String]("dockerBaseImage", "Base image for Dockerfile.")
-  val defaultDockerInstallLocation = SettingKey[String]("defaultDockerInstallLocation", "The location where we will install Docker packages.")
 }
 
 object Keys extends DockerKeys {
+  def cacheDirectory = sbt.Keys.cacheDirectory
   def mappings = sbt.Keys.mappings
+  def publishArtifact = sbt.Keys.publishArtifact
   def sourceDirectory = sbt.Keys.sourceDirectory
   def target = sbt.Keys.target
+  def defaultLinuxInstallLocation = packager.Keys.defaultLinuxInstallLocation
   def normalizedName = universal.Keys.normalizedName
+  def stage = universal.Keys.stage
   def daemonUser = linux.Keys.daemonUser
   def maintainer = linux.Keys.maintainer
 }