Support building and publishing Docker images.

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

@@ -69,14 +69,88 @@ trait DockerPlugin extends Plugin with UniversalPlugin {
     ))
   }
 
+  private[docker] def publishLocalLogger(log: Logger) = {
+    new ProcessLogger {
+      def error(err: => String) = {
+        err match {
+          case s if s.startsWith("Uploading context") => log.debug(s) // pre-1.0
+          case s if s.startsWith("Sending build context") => log.debug(s) // 1.0
+          case s if !s.trim.isEmpty => log.error(s)
+          case s =>
+        }
+      }
+
+      def info(inf: => String) = inf match {
+        case s if !s.trim.isEmpty => log.info(s)
+        case s                    =>
+      }
+
+      def buffer[T](f: => T) = f
+    }
+  }
+
+  def publishLocalDocker(context: File, tag: String, log: Logger): Unit = {
+    val cmd = Seq("docker", "build", "-t", tag, ".")
+    val cwd = context.getParentFile
+
+    log.debug("Executing " + cmd.mkString(" "))
+    log.debug("Working directory " + cwd.toString)
+
+    val ret = Process(cmd, cwd) ! publishLocalLogger(log)
+
+    if (ret != 0)
+      throw new RuntimeException("Nonzero exit value: " + ret)
+    else
+      log.info("Built image " + tag)
+  }
+
+  def publishDocker(tag: String, log: Logger): Unit = {
+    @volatile
+    var loginRequired = false
+
+    def publishLogger(log: Logger) = {
+      new ProcessLogger {
+
+        def error(err: => String) = err match {
+          case s if !s.trim.isEmpty => log.error(s)
+          case s                    =>
+        }
+
+        def info(inf: => String) = {
+          inf match {
+            case s if !loginRequired && s.startsWith("Please login") =>
+              loginRequired = true
+            case s if !loginRequired && !s.trim.isEmpty => log.info(s)
+            case s                                      =>
+          }
+        }
+
+        def buffer[T](f: => T) = f
+      }
+    }
+
+    val cmd = Seq("docker", "push", tag)
+
+    log.debug("Executing " + cmd.mkString(" "))
+
+    val ret = Process(cmd) ! publishLogger(log)
+
+    if (loginRequired)
+      throw new RuntimeException("""No credentials for repository, please run "docker login"""")
+    else if (ret != 0)
+      throw new RuntimeException("Nonzero exit value: " + ret)
+    else
+      log.info("Published image " + tag)
+  }
+
   def dockerSettings: Seq[Setting[_]] = Seq(
     dockerBaseImage := "dockerfile/java",
     name in Docker <<= name,
+    dockerRepository := None,
     sourceDirectory in Docker <<= sourceDirectory apply (_ / "docker"),
     target in Docker <<= target apply (_ / "docker")
   ) ++ mapGenericFilesToDocker ++ inConfig(Docker)(Seq(
       daemonUser := "daemon",
-      publishArtifact := false,
       defaultLinuxInstallLocation := "/opt/docker",
       dockerExposedPorts := Seq(),
       dockerExposedVolumes := Seq(),
@@ -92,6 +166,18 @@ trait DockerPlugin extends Plugin with UniversalPlugin {
           stageFiles("docker")(cacheDirectory, contextDir, mappings)
           contextDir
       },
+      dockerTarget <<= (dockerRepository, normalizedName, version) map {
+        (repo, name, version) =>
+          repo.map(_ + "/").getOrElse("") + name + ":" + version
+      },
+      publishLocal <<= (dockerGenerateConfig, dockerGenerateContext, dockerTarget, streams) map {
+        (config, _, target, s) =>
+          publishLocalDocker(config, target, s.log)
+      },
+      publish <<= (publishLocal, dockerTarget, streams) map {
+        (_, target, s) =>
+          publishDocker(target, s.log)
+      },
       dockerGenerateConfig <<=
         (dockerBaseImage, defaultLinuxInstallLocation, maintainer, daemonUser, normalizedName, dockerExposedPorts, dockerExposedVolumes, target) map {
           case (dockerBaseImage, baseDirectory, maintainer, daemonUser, normalizedName, exposedPorts, exposedVolumes, target) =>

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

@@ -8,19 +8,25 @@ trait DockerKeys {
   val dockerGenerateConfig = TaskKey[File]("docker-generate-config", "Generates configuration file 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 dockerTarget = TaskKey[String]("docker-target", "Defines target used when building and publishing Docker image")
 
   val dockerBaseImage = SettingKey[String]("dockerBaseImage", "Base image for Dockerfile.")
   val dockerExposedPorts = SettingKey[Seq[Int]]("dockerExposedPorts", "Ports exposed by Docker image")
   val dockerExposedVolumes = SettingKey[Seq[String]]("dockerExposedVolumes", "Volumes exposed by Docker image")
+  val dockerRepository = SettingKey[Option[String]]("dockerRepository", "Repository for published Docker image")
 }
 
 object Keys extends DockerKeys {
   def cacheDirectory = sbt.Keys.cacheDirectory
   def mappings = sbt.Keys.mappings
   def name = sbt.Keys.name
+  def publish = sbt.Keys.publish
   def publishArtifact = sbt.Keys.publishArtifact
+  def publishLocal = sbt.Keys.publishLocal
   def sourceDirectory = sbt.Keys.sourceDirectory
+  def streams = sbt.Keys.streams
   def target = sbt.Keys.target
+  def version = sbt.Keys.version
   def defaultLinuxInstallLocation = packager.Keys.defaultLinuxInstallLocation
   def normalizedName = universal.Keys.normalizedName
   def stage = universal.Keys.stage

src/sbt-test/docker/simple-docker/build.sbt

@@ -0,0 +1,10 @@
+import com.typesafe.sbt.SbtNativePackager._
+import NativePackagerKeys._
+
+packageArchetype.java_application
+
+name := "docker-test"
+
+version := "0.1.0"
+
+maintainer := "Gary Coady <[email protected]>"

src/sbt-test/docker/simple-docker/project/plugins.sbt

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

src/sbt-test/docker/simple-docker/src/main/scala/Main.scala

@@ -0,0 +1,3 @@
+object Main extends App {
+  println("Hello world")
+}

src/sbt-test/docker/simple-docker/test

@@ -0,0 +1,3 @@
+# Generate the Docker image locally
+> docker:publishLocal
+$ exec bash -c 'docker run docker-test:0.1.0 | grep -q "Hello world"'