Replace Docker CLI with Java Docker API Client

Authored-by: Leonhardt Koepsell <[email protected]>

Author: lnhrdt

.idea/codeStyles/Project.xml

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Remove the unreliable dependency on Docker CLI
+
 ### Chore
 
 - Upgrade project dependencies

.idea/codeStyles/codeStyleConfig.xml

@@ -2,14 +2,12 @@ import com.vanniktech.maven.publish.SonatypeHost
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.gradle.kotlin.dsl.support.serviceOf
-import org.gradle.kotlin.dsl.kotlin
-import org.gradle.kotlin.dsl.withType
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.plugin.extraProperties
 import java.io.ByteArrayOutputStream
 import java.io.StringReader
 import java.nio.charset.StandardCharsets
-import java.util.Properties
+import java.util.*
 
 group = "dev.codebandits"
 
@@ -121,6 +119,9 @@ sourceSets {
 }
 
 dependencies {
+  implementation(libs.docker.java.core)
+  implementation(libs.docker.java.transport.httpclient5)
+
   add(sourceSets["testShared"].apiConfigurationName, libs.junit.jupiter.api)
   testImplementation(sourceSets["testShared"].output)
 }

CHANGELOG.md

@@ -7,13 +7,16 @@ logback = "1.5.18" # https://github.com/qos-ch/logback/tags
 slf4j = "2.0.17" # https://github.com/qos-ch/slf4j/tags
 gradleMavenPublish = "0.31.0" # https://github.com/vanniktech/gradle-maven-publish-plugin/releases
 testRetryGradlePlugin = "1.6.2" # https://github.com/gradle/test-retry-gradle-plugin/releases
+dockerJava = "3.5.0" # https://github.com/docker-java/docker-java/releases
 
 [libraries]
 strikt-core = { module = "io.strikt:strikt-core", version.ref = "strikt" }
 testcontainers-testcontainers = { module = "org.testcontainers:testcontainers", version.ref = "testcontainers" }
 logback = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit-jupiter" }
+docker-java-core = { module = "com.github.docker-java:docker-java-core", version.ref = "dockerJava" }
+docker-java-transport-httpclient5 = { module = "com.github.docker-java:docker-java-transport-httpclient5", version.ref = "dockerJava" }
 
 [bundles]
 logging-implementation = ["slf4j-api"]

build.gradle.kts

@@ -0,0 +1,25 @@
+package dev.codebandits.container.gradle.docker
+
+import com.github.dockerjava.api.DockerClient
+import com.github.dockerjava.core.DefaultDockerClientConfig
+import com.github.dockerjava.core.DockerClientImpl
+import com.github.dockerjava.httpclient5.ApacheDockerHttpClient
+import com.github.dockerjava.transport.DockerHttpClient
+
+private fun createDockerClientConfig(dockerHost: String? = null): DefaultDockerClientConfig {
+  var builder = DefaultDockerClientConfig.createDefaultConfigBuilder()
+  if (dockerHost != null) {
+    builder = builder.withDockerHost(dockerHost)
+  }
+  return builder.build()
+}
+
+internal fun createDockerHttpClient(config: DefaultDockerClientConfig = createDockerClientConfig()): DockerHttpClient {
+  return ApacheDockerHttpClient.Builder().dockerHost(config.dockerHost).build()
+}
+
+internal fun createDockerClient(dockerHost: String? = null): DockerClient {
+  val config = createDockerClientConfig(dockerHost)
+  val httpClient = createDockerHttpClient(config)
+  return DockerClientImpl.getInstance(config, httpClient)
+}

gradle/libs.versions.toml

@@ -6,12 +6,10 @@ import org.gradle.api.tasks.TaskAction
 
 public abstract class ContainerExecTask : DefaultTask() {
   @Internal
-  protected val actionSteps: MutableList<ExecutionStep> = mutableListOf<ExecutionStep>()
+  protected val steps: MutableList<ExecutionStep> = mutableListOf()
 
   @TaskAction
   public fun run() {
-    actionSteps.forEach { action ->
-      project.runExecutionStep(action)
-    }
+    steps.forEach(::run)
   }
 }

src/main/kotlin/dev/codebandits/container/gradle/docker/client.kt

@@ -1,5 +1,13 @@
 package dev.codebandits.container.gradle.tasks
 
+import com.github.dockerjava.api.async.ResultCallback
+import com.github.dockerjava.api.command.WaitContainerResultCallback
+import com.github.dockerjava.api.model.Bind
+import com.github.dockerjava.api.model.Frame
+import com.github.dockerjava.api.model.HostConfig
+import com.github.dockerjava.api.model.StreamType
+import dev.codebandits.container.gradle.docker.createDockerClient
+import org.gradle.api.GradleException
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
 
@@ -18,39 +26,55 @@ public abstract class ContainerRunTask : ContainerExecTask() {
   }
 
   public fun dockerRun(configure: DockerRunSpec.() -> Unit) {
-    actionSteps.add(
+    steps.add(
       ExecutionStep(
-        execAction = {
+        action = {
           val spec = DockerRunSpec(project.objects).apply(configure)
-          val image = spec.image.get()
-          val options = mutableListOf<String>()
-          val user = spec.user.orNull
-          if (user != null) {
-            options.addAll(listOf("--user", user))
-          }
-          if (spec.privileged.get()) {
-            options.add("--privileged")
-          }
-          if (spec.autoRemove.get()) {
-            options.add("--rm")
-          }
-          spec.volumes.get().forEach { volume ->
-            options.addAll(listOf("--volume", volume))
-          }
-          val entrypoint = spec.entrypoint.orNull
-          if (entrypoint != null) {
-            options.addAll(listOf("--entrypoint", entrypoint))
-          }
-          val workdir = spec.workdir.orNull
-          if (workdir != null) {
-            options.addAll(listOf("--workdir", workdir))
-          }
-          val dockerArgs = arrayOf("run", *options.toTypedArray(), image, *spec.args.get())
-          executable = "docker"
-          args(*dockerArgs)
           val dockerHost = spec.dockerHost.orNull
-          if (dockerHost != null) {
-            environment("DOCKER_HOST", dockerHost)
+          val dockerClient = createDockerClient(dockerHost)
+
+          val hostConfig = HostConfig.newHostConfig()
+            .withAutoRemove(spec.autoRemove.get())
+            .withPrivileged(spec.privileged.get())
+            .withBinds(spec.volumes.get().map(Bind::parse))
+
+          val createContainerCmd = dockerClient.createContainerCmd(spec.image.get())
+            .withHostConfig(hostConfig)
+            .withCmd(*spec.args.get())
+            .let { cmd -> spec.user.orNull?.let { user -> cmd.withUser(user) } ?: cmd }
+            .let { cmd -> spec.entrypoint.orNull?.let { user -> cmd.withEntrypoint(user) } ?: cmd }
+            .let { cmd -> spec.workdir.orNull?.let { user -> cmd.withWorkingDir(user) } ?: cmd }
+
+          val container = createContainerCmd.exec()
+
+          dockerClient.startContainerCmd(container.id).exec()
+
+          val containerLogCallback = dockerClient
+            .logContainerCmd(container.id)
+            .withStdOut(true)
+            .withStdErr(true)
+            .withSince(0)
+            .withFollowStream(true)
+            .exec(object : ResultCallback.Adapter<Frame>() {
+              override fun onNext(frame: Frame) {
+                when (frame.streamType) {
+                  StreamType.STDOUT -> System.out.write(frame.payload)
+                  StreamType.STDERR -> System.err.write(frame.payload)
+                  else -> {}
+                }
+              }
+            })
+
+          val containerStatusCodeCallback = dockerClient
+            .waitContainerCmd(container.id)
+            .exec(WaitContainerResultCallback())
+
+          containerLogCallback.awaitCompletion()
+
+          val statusCode = containerStatusCodeCallback.awaitStatusCode()
+
+          if (statusCode != 0) {
+            throw GradleException("Container exited with status code $statusCode")
           }
         },
       )

src/main/kotlin/dev/codebandits/container/gradle/tasks/ContainerExecTask.kt

@@ -1,9 +1,12 @@
 package dev.codebandits.container.gradle.tasks
 
+import com.github.dockerjava.transport.DockerHttpClient
+import dev.codebandits.container.gradle.docker.createDockerClient
+import dev.codebandits.container.gradle.docker.createDockerHttpClient
+import org.gradle.api.GradleException
 import org.gradle.api.Task
 import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.Provider
-import java.io.OutputStream
 import java.net.URLEncoder
 import java.nio.charset.StandardCharsets
 
@@ -21,14 +24,26 @@ public abstract class TaskImages(private val task: Task) {
     val fileName = getImageReferenceFileName(imageReference)
     val imageIdentifierFileProvider = task.project.layout.buildDirectory.file("images/docker/local/$fileName")
     val updateStep = ExecutionStep(
-      execAction = {
+      action = {
         val file = imageIdentifierFileProvider.get().asFile
-        file.parentFile.mkdirs()
-        executable = "docker"
-        args("inspect", "--format", "{{.Id}}", imageReference)
-        standardOutput = imageIdentifierFileProvider.get().asFile.outputStream()
-        errorOutput = OutputStream.nullOutputStream()
-        isIgnoreExitValue = true
+        val dockerClient = createDockerClient()
+        try {
+          dockerClient.pingCmd().exec()
+          val inspectImageResponse = dockerClient.inspectImageCmd(imageReference).exec()
+          val imageId = inspectImageResponse.id
+          file.parentFile.mkdirs()
+          if (imageId != null) {
+            file.writeText(imageId)
+          } else {
+            file.delete()
+          }
+        } catch (exception: Exception) {
+          if (exception.javaClass.name == "com.github.dockerjava.api.exception.NotFoundException") {
+            file.delete()
+          } else {
+            throw exception
+          }
+        }
       },
       resultHandler = { result ->
         if (result.exitValue != 0) {
@@ -40,7 +55,7 @@ public abstract class TaskImages(private val task: Task) {
 
     return ImageIdentifierFileConfig(
       fileProvider = imageIdentifierFileProvider.map { regularFile ->
-        task.project.runExecutionStep(step = updateStep)
+        task.run(updateStep)
         regularFile
       },
       updateStep = updateStep,
@@ -54,13 +69,42 @@ public abstract class TaskImages(private val task: Task) {
     val fileName = getImageReferenceFileName(imageReference)
     val imageIdentifierFileProvider = task.project.layout.buildDirectory.file("images/docker/registry/$fileName")
     val updateStep = ExecutionStep(
-      execAction = {
+      action = {
         val file = imageIdentifierFileProvider.get().asFile
-        file.parentFile.mkdirs()
-        executable = "docker"
-        args("manifest", "inspect", imageReference)
-        standardOutput = file.outputStream()
-        isIgnoreExitValue = true
+        val dockerHttpClient = createDockerHttpClient()
+
+        val (repo, tag) = imageReference
+          .split(":", limit = 2)
+          .let { it[0] to it.getOrElse(1) { "latest" } }
+        val path = "/v2/$repo/manifests/$tag"
+
+        val request = DockerHttpClient.Request.builder()
+          .method(DockerHttpClient.Request.Method.GET)
+          .path(path)
+          .putHeader("Accept", "application/vnd.docker.distribution.manifest.v2+json")
+          .build()
+
+        dockerHttpClient.execute(request).use { response ->
+          when (response.statusCode) {
+            200 -> {
+              val digest = response.headers["Docker-Content-Digest"]?.firstOrNull()
+              if (digest != null) {
+                file.parentFile.mkdirs()
+                file.writeText(digest)
+              } else {
+                file.delete()
+              }
+            }
+
+            404 -> {
+              file.delete()
+            }
+
+            else -> throw GradleException(
+              "Failed to fetch manifest for $imageReference: HTTP ${response.statusCode}"
+            )
+          }
+        }
       },
       resultHandler = { result ->
         if (result.exitValue != 0) {
@@ -73,7 +117,7 @@ public abstract class TaskImages(private val task: Task) {
 
     return ImageIdentifierFileConfig(
       fileProvider = imageIdentifierFileProvider.map { regularFile ->
-        task.project.runExecutionStep(step = updateStep)
+        task.run(updateStep)
         regularFile
       },
       updateStep = updateStep,
@@ -103,7 +147,7 @@ public abstract class TaskImages(private val task: Task) {
         imageReference = imageReference,
       )
       task.outputs.file(config.fileProvider)
-      task.doLast { task -> task.project.runExecutionStep(config.updateStep) }
+      task.doLast { task -> task.run(config.updateStep) }
     }
 
     public fun dockerRegistry(imageReference: String, autoRefresh: Boolean = false) {
@@ -112,7 +156,7 @@ public abstract class TaskImages(private val task: Task) {
         autoRefresh = autoRefresh,
       )
       task.outputs.file(config.fileProvider)
-      task.doLast { task -> task.project.runExecutionStep(config.updateStep) }
+      task.doLast { task -> task.run(config.updateStep) }
     }
   }
 }

src/main/kotlin/dev/codebandits/container/gradle/tasks/ContainerRunTask.kt

@@ -1,20 +1,17 @@
 package dev.codebandits.container.gradle.tasks
 
-import org.gradle.api.Project
-import org.gradle.internal.extensions.core.serviceOf
-import org.gradle.process.ExecOperations
+import org.gradle.api.Action
+import org.gradle.api.Task
 import org.gradle.process.ExecResult
-import org.gradle.process.ExecSpec
 
 public class ExecutionStep(
-  public val execAction: ExecSpec.() -> Unit,
+  public val action: Action<Task>,
   public val resultHandler: ((ExecResult) -> Unit)? = null,
   public val shouldRun: () -> Boolean = { true },
 )
 
-internal fun Project.runExecutionStep(step: ExecutionStep) {
+internal fun Task.run(step: ExecutionStep) {
   if (step.shouldRun()) {
-    val result = serviceOf<ExecOperations>().exec(step.execAction)
-    step.resultHandler?.invoke(result)
+    apply(step.action::execute)
   }
 }