Support for specifying a custom entrypoint

Author: Chris Birchall

config/src/main/scala/com/whisk/docker/config/DockerTypesafeConfig.scala

@@ -46,6 +46,7 @@ object DockerTypesafeConfig extends DockerKitDockerJava {
   case class DockerConfig(`image-name`: String,
                           `container-name`: Option[String],
                           command: Option[Seq[String]],
+                          entrypoint: Option[Seq[String]],
                           `environmental-variables`: Seq[String] = Seq.empty,
                           `port-maps`: Option[Map[String, DockerConfigPortMap]],
                           `ready-checker`: Option[DockerConfigReadyChecker],
@@ -63,6 +64,7 @@ object DockerTypesafeConfig extends DockerKitDockerJava {
         image = `image-name`,
         name = `container-name`,
         command = command,
+        entrypoint = entrypoint,
         bindPorts = bindPorts,
         env = `environmental-variables`,
         readyChecker = readyChecker,

config/src/test/resources/application.conf

@@ -83,6 +83,7 @@ docker {
 
   elasticsearch {
     image-name = "elasticsearch:1.7.1"
+    entrypoint = [ "my", "custom", "entrypoint" ]
     ready-checker {
       http-response-code {
         port = 9200

config/src/test/scala/com/whisk/docker/config/test/DockerConfigSpec.scala

@@ -38,6 +38,7 @@ class DockerConfigSpec extends FlatSpec with Matchers with DockerKitConfig {
     configureDockerContainer("docker.mongodb") shouldBe mongodbExpected
 
     val elasticExpected = DockerContainer("elasticsearch:1.7.1")
+      .withEntrypoint("my", "custom", "entrypoint")
       .withPorts(9200 -> None, 9300 -> None)
       .withReadyChecker(
         DockerReadyChecker

core/src/main/scala/com/whisk/docker/DockerContainer.scala

@@ -17,6 +17,7 @@ case class HostConfig(
 case class DockerContainer(image: String,
                            name: Option[String] = None,
                            command: Option[Seq[String]] = None,
+                           entrypoint: Option[Seq[String]] = None,
                            bindPorts: Map[Int, DockerPortMapping] = Map.empty,
                            tty: Boolean = false,
                            stdinOpen: Boolean = false,
@@ -33,6 +34,8 @@ case class DockerContainer(image: String,
 
   def withCommand(cmd: String*) = copy(command = Some(cmd))
 
+  def withEntrypoint(entrypoint: String*) = copy(entrypoint = Some(entrypoint))
+
   def withPorts(ps: (Int, Option[Int])*) =
     copy(bindPorts = ps.toMap.mapValues(hostPort => DockerPortMapping(hostPort)))
 

impl/docker-java/src/main/scala/com/whisk/docker/impl/dockerjava/DockerJavaExecutor.scala

@@ -23,48 +23,45 @@ class DockerJavaExecutor(override val host: String, client: DockerClient)
       (volume, new Bind(mapping.host, volume, AccessMode.fromBoolean(mapping.rw)))
     }
 
-    val baseCmd = {
-      val hostConfig = new com.github.dockerjava.api.model.HostConfig()
-      hostConfig
-        .withOption(spec.networkMode)({ case (config, value) => config.withNetworkMode(value) })
-        .withPortBindings(spec.bindPorts.foldLeft(new Ports()) {
-          case (ps, (guestPort, DockerPortMapping(Some(hostPort), address))) =>
-            ps.bind(ExposedPort.tcp(guestPort), Ports.Binding.bindPort(hostPort))
-            ps
-          case (ps, (guestPort, DockerPortMapping(None, address))) =>
-            ps.bind(ExposedPort.tcp(guestPort), Ports.Binding.empty())
-            ps
+    val hostConfig = new com.github.dockerjava.api.model.HostConfig()
+      .withOption(spec.networkMode)({ case (config, value) => config.withNetworkMode(value) })
+      .withPortBindings(spec.bindPorts.foldLeft(new Ports()) {
+        case (ps, (guestPort, DockerPortMapping(Some(hostPort), address))) =>
+          ps.bind(ExposedPort.tcp(guestPort), Ports.Binding.bindPort(hostPort))
+          ps
+        case (ps, (guestPort, DockerPortMapping(None, address))) =>
+          ps.bind(ExposedPort.tcp(guestPort), Ports.Binding.empty())
+          ps
+      })
+      .withLinks(
+        new Links(spec.links.map {
+          case ContainerLink(container, alias) =>
+            new Link(container.name.get, alias)
+        }: _*)
+      )
+      .withBinds(new Binds(volumeToBind.map(_._2): _*))
+
+    val cmd = client
+      .createContainerCmd(spec.image)
+      .withHostConfig(hostConfig)
+      .withPortSpecs(spec.bindPorts
+            .map({
+          case (guestPort, DockerPortMapping(Some(hostPort), address)) =>
+            s"$address:$hostPort:$guestPort"
+          case (guestPort, DockerPortMapping(None, address)) => s"$address::$guestPort"
         })
-        .withLinks(
-          new Links(spec.links.map {
-            case ContainerLink(container, alias) =>
-              new Link(container.name.get, alias)
-          }: _*)
-        )
-        .withBinds(new Binds(volumeToBind.map(_._2): _*))
-
-      val tmpCmd = client
-        .createContainerCmd(spec.image)
-        .withHostConfig(hostConfig)
-        .withPortSpecs(spec.bindPorts
-          .map({
-            case (guestPort, DockerPortMapping(Some(hostPort), address)) =>
-              s"$address:$hostPort:$guestPort"
-            case (guestPort, DockerPortMapping(None, address)) => s"$address::$guestPort"
-          })
-          .toSeq: _*)
-        .withExposedPorts(spec.bindPorts.keys.map(ExposedPort.tcp).toSeq: _*)
-        .withTty(spec.tty)
-        .withStdinOpen(spec.stdinOpen)
-        .withEnv(spec.env: _*)
-        .withVolumes(volumeToBind.map(_._1): _*)
-        .withOption(spec.user) { case (config, user) => config.withUser(user) }
-        .withOption(spec.hostname) { case (config, hostName) => config.withHostName(hostName) }
-
-      spec.name.map(tmpCmd.withName).getOrElse(tmpCmd)
-    }
+            .toSeq: _*)
+      .withExposedPorts(spec.bindPorts.keys.map(ExposedPort.tcp).toSeq: _*)
+      .withTty(spec.tty)
+      .withStdinOpen(spec.stdinOpen)
+      .withEnv(spec.env: _*)
+      .withVolumes(volumeToBind.map(_._1): _*)
+      .withOption(spec.user) { case (config, user) => config.withUser(user) }
+      .withOption(spec.hostname) { case (config, hostName) => config.withHostName(hostName) }
+      .withOption(spec.name) { case (config, name) => config.withName(name) }
+      .withOption(spec.command) { case (config, c) => config.withCmd(c: _*) }
+      .withOption(spec.entrypoint) { case (config, entrypoint) => config.withEntrypoint(entrypoint: _*) }
 
-    val cmd = spec.command.fold(baseCmd)(c => baseCmd.withCmd(c: _*))
     Future(cmd.exec()).map { resp =>
       if (resp.getId != null && resp.getId != "") {
         resp.getId

impl/spotify/src/main/scala/com/whisk/docker/impl/spotify/SpotifyDockerCommandExecutor.scala

@@ -58,7 +58,7 @@ class SpotifyDockerCommandExecutor(override val host: String, client: DockerClie
         .build()
     }
 
-    val builder = ContainerConfig
+    val containerConfig = ContainerConfig
       .builder()
       .image(spec.image)
       .hostConfig(hostConfig)
@@ -68,8 +68,9 @@ class SpotifyDockerCommandExecutor(override val host: String, client: DockerClie
       .env(spec.env: _*)
       .withOption(spec.user) { case (config, user) => config.user(user) }
       .withOption(spec.hostname) { case (config, hostname) => config.hostname(hostname) }
-
-    val containerConfig = spec.command.fold(builder)(c => builder.cmd(c: _*)).build()
+      .withOption(spec.command) { case (config, command) => config.cmd(command: _*) }
+      .withOption(spec.entrypoint) { case (config, entrypoint) => config.entrypoint(entrypoint: _*) }
+      .build()
 
     val creation = Future(
       spec.name.fold(client.createContainer(containerConfig))(