hostconfig with tmpfs

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

@@ -10,6 +10,10 @@ 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
+)
+
 case class DockerContainer(image: String,
                            name: Option[String] = None,
                            command: Option[Seq[String]] = None,
@@ -24,7 +28,8 @@ case class DockerContainer(image: String,
                            volumeMappings: Seq[VolumeMapping] = Seq.empty,
                            logLineReceiver: Option[LogLineReceiver] = None,
                            user: Option[String] = None,
-                           hostname: Option[String] = None) {
+                           hostname: Option[String] = None,
+                           hostConfig: Option[HostConfig] = None) {
 
   def withCommand(cmd: String*) = copy(command = Some(cmd))
 
@@ -54,4 +59,6 @@ case class DockerContainer(image: String,
   def withUser(user: String) = copy(user = Some(user))
 
   def withHostname(hostname: String) = copy(hostname = Some(hostname))
+
+  def withHostConfig(hostConfig: HostConfig) = copy(hostConfig = Some(hostConfig))
 }

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

@@ -41,16 +41,17 @@ class DockerContainerManager(containers: Seq[DockerContainer], executor: DockerC
 
     @tailrec
     def initGraph(graph: ContainerDependencyGraph,
-                  previousInits: Future[Seq[DockerContainerState]] = Future.successful(Seq.empty)
-                 ): Future[Seq[DockerContainerState]] = {
+                  previousInits: Future[Seq[DockerContainerState]] = Future.successful(Seq.empty))
+      : Future[Seq[DockerContainerState]] = {
       val initializedContainers = previousInits.flatMap { prev =>
         Future.traverse(graph.containers.map(dockerStatesMap))(_.init()).map(prev ++ _)
       }
 
       graph.dependants match {
         case None => initializedContainers
         case Some(dependants) =>
-          val readyInits: Future[Seq[Future[Boolean]]] = initializedContainers.map(_.map(state => state.isReady()))
+          val readyInits: Future[Seq[Future[Boolean]]] =
+            initializedContainers.map(_.map(state => state.isReady()))
           val simplifiedReadyInits: Future[Seq[Boolean]] = readyInits.flatMap(Future.sequence(_))
           Await.result(simplifiedReadyInits, containerStartTimeout)
           initGraph(dependants, initializedContainers)

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

@@ -24,8 +24,28 @@ class DockerJavaExecutor(override val host: String, client: DockerClient)
     }
 
     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
+        })
+        .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)) =>
@@ -37,27 +57,7 @@ class DockerJavaExecutor(override val host: String, client: DockerClient)
         .withTty(spec.tty)
         .withStdinOpen(spec.stdinOpen)
         .withEnv(spec.env: _*)
-        .withOption(spec.networkMode) {
-          case (config, networkMode) => config.withNetworkMode(networkMode)
-        }
-        .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(
-            spec.links.map {
-              case ContainerLink(container, alias) =>
-                new Link(container.name.get, alias)
-            }.asJava
-        )
         .withVolumes(volumeToBind.map(_._1): _*)
-        .withBinds(volumeToBind.map(_._2): _*)
         .withOption(spec.user) { case (config, user) => config.withUser(user) }
         .withOption(spec.hostname) { case (config, hostName) => config.withHostName(hostName) }
 

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

@@ -28,14 +28,14 @@ class SpotifyDockerCommandExecutor(override val host: String, client: DockerClie
       case (guestPort, DockerPortMapping(None, address)) =>
         guestPort.toString -> Collections.singletonList(PortBinding.randomPort(address))
     }
-    val binds: Seq[String] = spec.volumeMappings.map{
-      volumeMapping =>
-        val rw = if(volumeMapping.rw) ":rw" else ""
-        volumeMapping.host + ":" + volumeMapping.container + rw
+    val binds: Seq[String] = spec.volumeMappings.map { volumeMapping =>
+      val rw = if (volumeMapping.rw) ":rw" else ""
+      volumeMapping.host + ":" + volumeMapping.container + rw
     }
 
     val hostConfig = {
-      val hostConfigBase = HostConfig.builder().portBindings(portBindings.asJava).binds(binds.asJava)
+      val hostConfigBase =
+        HostConfig.builder().portBindings(portBindings.asJava).binds(binds.asJava)
 
       val links = spec.links.map {
         case ContainerLink(container, alias) => s"${container.name.get}:$alias"
@@ -47,6 +47,9 @@ class SpotifyDockerCommandExecutor(override val host: String, client: DockerClie
         .withOption(spec.networkMode) {
           case (config, networkMode) => config.networkMode(networkMode)
         }
+        .withOption(spec.hostConfig.flatMap(_.tmpfs)) {
+          case (config, value) => config.tmpfs(value.asJava)
+        }
         .build()
     }
 

samples/src/main/scala/com/whisk/docker/DockerElasticsearchService.scala

@@ -10,10 +10,10 @@ trait DockerElasticsearchService extends DockerKit {
   val elasticsearchContainer = DockerContainer("elasticsearch:1.7.1")
     .withPorts(DefaultElasticsearchHttpPort -> None, DefaultElasticsearchClientPort -> None)
     .withReadyChecker(
-      DockerReadyChecker
-        .HttpResponseCode(DefaultElasticsearchHttpPort, "/")
-        .within(100.millis)
-        .looped(20, 1250.millis)
+        DockerReadyChecker
+          .HttpResponseCode(DefaultElasticsearchHttpPort, "/")
+          .within(100.millis)
+          .looped(20, 1250.millis)
     )
 
   abstract override def dockerContainers: List[DockerContainer] =

samples/src/main/scala/com/whisk/docker/DockerNeo4jService.scala

@@ -10,10 +10,10 @@ trait DockerNeo4jService extends DockerKit {
     .withPorts(DefaultNeo4jHttpPort -> None)
     .withEnv("NEO4J_AUTH=none")
     .withReadyChecker(
-      DockerReadyChecker
-        .HttpResponseCode(DefaultNeo4jHttpPort, "/db/data/")
-        .within(100.millis)
-        .looped(20, 1250.millis)
+        DockerReadyChecker
+          .HttpResponseCode(DefaultNeo4jHttpPort, "/db/data/")
+          .within(100.millis)
+          .looped(20, 1250.millis)
     )
 
   abstract override def dockerContainers: List[DockerContainer] =

samples/src/main/scala/com/whisk/docker/DockerPostgresService.scala

@@ -16,23 +16,25 @@ trait DockerPostgresService extends DockerKit {
     .withPorts((PostgresAdvertisedPort, Some(PostgresExposedPort)))
     .withEnv(s"POSTGRES_USER=$PostgresUser", s"POSTGRES_PASSWORD=$PostgresPassword")
     .withReadyChecker(
-      new PostgresReadyChecker(PostgresUser, PostgresPassword, Some(PostgresExposedPort)).looped(15, 1.second)
+        new PostgresReadyChecker(PostgresUser, PostgresPassword, Some(PostgresExposedPort))
+          .looped(15, 1.second)
     )
 
   abstract override def dockerContainers: List[DockerContainer] =
     postgresContainer :: super.dockerContainers
 }
 
-class PostgresReadyChecker(user: String, password: String, port: Option[Int] = None) extends DockerReadyChecker {
+class PostgresReadyChecker(user: String, password: String, port: Option[Int] = None)
+    extends DockerReadyChecker {
 
-  override def apply(container: DockerContainerState)(implicit docker: DockerCommandExecutor, ec: ExecutionContext) =
-    container.getPorts().map(ports =>
-      Try {
-        Class.forName("org.postgresql.Driver")
-        val url = s"jdbc:postgresql://${docker.host}:${port.getOrElse(ports.values.head)}/"
-        Option(DriverManager.getConnection(url, user, password))
-          .map(_.close)
-          .isDefined
-      }.getOrElse(false)
-    )
-}
+  override def apply(container: DockerContainerState)(implicit docker: DockerCommandExecutor,
+                                                      ec: ExecutionContext) =
+    container
+      .getPorts()
+      .map(ports =>
+            Try {
+          Class.forName("org.postgresql.Driver")
+          val url = s"jdbc:postgresql://${docker.host}:${port.getOrElse(ports.values.head)}/"
+          Option(DriverManager.getConnection(url, user, password)).map(_.close).isDefined
+        }.getOrElse(false))
+}