Add support for --chown flag for ADD/COPY Docker commands

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

@@ -13,6 +13,9 @@ import com.typesafe.sbt.SbtNativePackager.Universal
 import com.typesafe.sbt.packager.Compat._
 import com.typesafe.sbt.packager.{MappingsHelper, Stager}
 
+import scala.sys.process.Process
+import scala.util.Try
+
 /**
   * == Docker Plugin ==
   *
@@ -80,6 +83,9 @@ object DockerPlugin extends AutoPlugin {
     dockerEntrypoint := Seq("bin/%s" format executableScriptName.value),
     dockerCmd := Seq(),
     dockerExecCommand := Seq("docker"),
+    dockerVersion := Try(Process(dockerExecCommand.value ++ Seq("version --format '{{.Server.Version}}'")).!!)
+      .toOption.map(_.trim)
+      .flatMap(DockerVersion.parse),
     dockerBuildOptions := Seq("--force-rm") ++ Seq("-t", dockerAlias.value.versioned) ++ (
       if (dockerUpdateLatest.value)
         Seq("-t", dockerAlias.value.latest)
@@ -96,7 +102,7 @@ object DockerPlugin extends AutoPlugin {
       val generalCommands = makeFrom(dockerBaseImage.value) +: makeMaintainer((maintainer in Docker).value).toSeq
 
       generalCommands ++
-        Seq(makeWorkdir(dockerBaseDirectory), makeAdd(dockerBaseDirectory), makeChown(user, group, "." :: Nil)) ++
+        Seq(makeWorkdir(dockerBaseDirectory)) ++ makeAdd(dockerVersion.value, dockerBaseDirectory, user, group) ++
         dockerLabels.value.map(makeLabel) ++
         makeExposePorts(dockerExposedPorts.value, dockerExposedUdpPorts.value) ++
         makeVolumes(dockerExposedVolumes.value, user, group) ++
@@ -179,18 +185,34 @@ object DockerPlugin extends AutoPlugin {
     Cmd("WORKDIR", dockerBaseDirectory)
 
   /**
-    * @param dockerBaseDirectory, the installation directory
+    * @param dockerVersion
+    * @param dockerBaseDirectory the installation directory
+    * @param daemonUser
+    * @param daemonGroup
     * @return ADD command adding all files inside the installation directory
     */
-  private final def makeAdd(dockerBaseDirectory: String): CmdLike = {
+  private final def makeAdd(dockerVersion: Option[DockerVersion], dockerBaseDirectory: String,
+                            daemonUser: String, daemonGroup: String): Seq[CmdLike] = {
 
     /**
       * This is the file path of the file in the Docker image, and does not depend on the OS where the image
       * is being built. This means that it needs to be the Unix file separator even when the image is built
       * on e.g. Windows systems.
       */
     val files = dockerBaseDirectory.split(UnixSeparatorChar)(1)
-    Cmd("ADD", s"$files /$files")
+
+    dockerVersion match {
+      case Some(DockerVersion(major, minor, _, _)) if major >= 17 && minor >= 9 =>
+        Seq(
+          Cmd("ADD", s"--chown=$daemonUser:$daemonGroup $files /$files")
+        )
+
+      case _ =>
+        Seq(
+          Cmd("ADD", s"$files /$files"),
+          makeChown(daemonUser, daemonGroup, "." :: Nil)
+        )
+    }
   }
 
   /**
@@ -278,7 +300,7 @@ object DockerPlugin extends AutoPlugin {
   }
 
   /**
-    * uses the `mappings in Unversial` to generate the
+    * uses the `mappings in Universal` to generate the
     * `mappings in Docker`.
     */
   def mapGenericFilesToDocker: Seq[Setting[_]] = {

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

@@ -0,0 +1,17 @@
+package com.typesafe.sbt.packager.docker
+
+import scala.util.matching.Regex
+
+
+case class DockerVersion(major: Int, minor: Int, patch: Int, release: Option[String])
+
+object DockerVersion {
+  private val DockerVersionPattern: Regex = "^'([0-9]+).([0-9]+).([0-9]+)-?([-a-z]+)?'$".r
+
+  def parse(version: String): Option[DockerVersion] = {
+    Option(version).collect {
+      case DockerVersionPattern(major, minor, patch, release) =>
+        new DockerVersion(major.toInt, minor.toInt, patch.toInt, Option(release))
+    }
+  }
+}

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

@@ -29,6 +29,7 @@ trait DockerKeys {
     "Docker CMD. Used together with dockerEntrypoint. Arguments passed in exec form"
   )
   val dockerExecCommand = SettingKey[Seq[String]]("dockerExecCommand", "The shell command used to exec Docker")
+  val dockerVersion = SettingKey[Option[DockerVersion]]("dockerVersion", "The docker server version")
   val dockerBuildOptions = SettingKey[Seq[String]]("dockerBuildOptions", "Options used for the Docker build")
   val dockerBuildCommand = SettingKey[Seq[String]]("dockerBuildCommand", "Command for building the Docker image")
   val dockerLabels = SettingKey[Map[String, String]]("dockerLabels", "Labels applied to the Docker image")