Merge branch 'master' of github.com:whisklabs/docker-it-scala

viktortnk · viktortnk · commit 6b24f98b8c02 · 2017-09-10T08:48:30.000+01:00
diff --git a/config/src/main/scala/com/whisk/docker/config/DockerTypesafeConfig.scala b/config/src/main/scala/com/whisk/docker/config/DockerTypesafeConfig.scala
@@ -1,7 +1,7 @@
 package com.whisk.docker.config
 
 import com.whisk.docker.impl.dockerjava.DockerKitDockerJava
-import com.whisk.docker.{DockerContainer, DockerPortMapping, DockerReadyChecker, VolumeMapping}
+import com.whisk.docker.{DockerContainer, DockerPortMapping, DockerReadyChecker, HostConfig, VolumeMapping}
 
 import scala.concurrent.duration._
 
@@ -46,10 +46,13 @@ 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],
-                          `volume-maps`: Seq[VolumeMapping] = Seq.empty) {
+                          `volume-maps`: Seq[VolumeMapping] = Seq.empty,
+                          memory: Option[Long],
+                          `memory-reservation`: Option[Long]) {
 
     def toDockerContainer(): DockerContainer = {
       val bindPorts = `port-maps`.fold(EmptyPortBindings) { _.values.map(_.asTuple).toMap } mapValues {
@@ -59,14 +62,21 @@ object DockerTypesafeConfig extends DockerKitDockerJava {
 
       val readyChecker = `ready-checker`.fold[DockerReadyChecker](AlwaysReady) { _.toReadyChecker }
 
+      val hostConfig = HostConfig(
+        memory = memory,
+        memoryReservation = `memory-reservation`
+      )
+
       DockerContainer(
         image = `image-name`,
         name = `container-name`,
         command = command,
+        entrypoint = entrypoint,
         bindPorts = bindPorts,
         env = `environmental-variables`,
         readyChecker = readyChecker,
-        volumeMappings = `volume-maps`
+        volumeMappings = `volume-maps`,
+        hostConfig = Some(hostConfig)
       )
     }
   }
diff --git a/config/src/test/resources/application.conf b/config/src/test/resources/application.conf
@@ -83,6 +83,9 @@ docker {
 
   elasticsearch {
     image-name = "elasticsearch:1.7.1"
+    entrypoint = [ "my", "custom", "entrypoint" ]
+    memory = 536870912 # 512MB
+    memory-reservation = 268435456 # 256MB
     ready-checker {
       http-response-code {
         port = 9200
diff --git a/config/src/test/scala/com/whisk/docker/config/test/DockerConfigSpec.scala b/config/src/test/scala/com/whisk/docker/config/test/DockerConfigSpec.scala
@@ -1,6 +1,6 @@
 package com.whisk.docker.config.test
 
-import com.whisk.docker.{DockerContainer, DockerReadyChecker, VolumeMapping}
+import com.whisk.docker.{DockerContainer, DockerReadyChecker, HostConfig, VolumeMapping}
 import com.whisk.docker.config.DockerKitConfig
 import org.scalatest._
 
@@ -38,7 +38,9 @@ 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)
+      .withHostConfig(HostConfig(memory = Some(536870912), memoryReservation = Some(268435456)))
       .withReadyChecker(
         DockerReadyChecker
           .HttpResponseCode(9200, "/")
diff --git a/core/src/main/scala/com/whisk/docker/DockerContainer.scala b/core/src/main/scala/com/whisk/docker/DockerContainer.scala
@@ -11,12 +11,25 @@ case class LogLineReceiver(withErr: Boolean, f: String => Unit)
 case class DockerPortMapping(hostPort: Option[Int] = None, address: String = "0.0.0.0")
 
 case class HostConfig(
-    tmpfs: Option[Map[String, String]] = None
+
+    tmpfs: Option[Map[String, String]] = None,
+
+    /**
+      * the hard limit on memory usage (in bytes)
+      */
+    memory: Option[Long] = None,
+
+    /**
+      * the soft limit on memory usage (in bytes)
+      */
+    memoryReservation: Option[Long] = None
+
 )
 
 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 +46,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)))
 
@@ -61,4 +76,5 @@ case class DockerContainer(image: String,
   def withHostname(hostname: String) = copy(hostname = Some(hostname))
 
   def withHostConfig(hostConfig: HostConfig) = copy(hostConfig = Some(hostConfig))
+
 }
diff --git a/impl/docker-java/src/main/scala/com/whisk/docker/impl/dockerjava/DockerJavaExecutor.scala b/impl/docker-java/src/main/scala/com/whisk/docker/impl/dockerjava/DockerJavaExecutor.scala
@@ -23,48 +23,51 @@ 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): _*))
+      .withOption(spec.hostConfig.flatMap(_.memory)) {
+        case (config, memory) => config.withMemory(memory)
+      }
+      .withOption(spec.hostConfig.flatMap(_.memoryReservation)) {
+        case (config, memoryReservation) => config.withMemoryReservation(memoryReservation)
+      }
+
+    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
diff --git a/impl/spotify/src/main/scala/com/whisk/docker/impl/spotify/SpotifyDockerCommandExecutor.scala b/impl/spotify/src/main/scala/com/whisk/docker/impl/spotify/SpotifyDockerCommandExecutor.scala
@@ -12,8 +12,7 @@ import com.spotify.docker.client.exceptions.ContainerNotFoundException
 import com.spotify.docker.client.messages.{
   ContainerConfig,
   HostConfig,
-  PortBinding,
-  AttachedNetwork
+  PortBinding
 }
 import com.spotify.docker.client.{DockerClient, LogMessage}
 import com.whisk.docker._
@@ -55,10 +54,16 @@ class SpotifyDockerCommandExecutor(override val host: String, client: DockerClie
         .withOption(spec.hostConfig.flatMap(_.tmpfs)) {
           case (config, value) => config.tmpfs(value.asJava)
         }
+        .withOption(spec.hostConfig.flatMap(_.memory)) {
+          case (config, memory) => config.memory(memory)
+        }
+        .withOption(spec.hostConfig.flatMap(_.memoryReservation)) {
+          case (config, reservation) => config.memoryReservation(reservation)
+        }
         .build()
     }
 
-    val builder = ContainerConfig
+    val containerConfig = ContainerConfig
       .builder()
       .image(spec.image)
       .hostConfig(hostConfig)
@@ -68,8 +73,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))(
