Remove the legacy execStart() implementation

The modern execStart() allows interactive exec based on OkHttp 5.3.0

Author: gesellix

client/src/main/groovy/de/gesellix/docker/client/container/ManageContainerClient.groovy

@@ -3,9 +3,7 @@ package de.gesellix.docker.client.container
 import de.gesellix.docker.client.EngineResponseContent
 import de.gesellix.docker.client.repository.RepositoryAndTag
 import de.gesellix.docker.client.repository.RepositoryTagParser
-import de.gesellix.docker.engine.AttachConfig
 import de.gesellix.docker.engine.EngineClient
-import de.gesellix.docker.engine.EngineResponse
 import de.gesellix.docker.remote.api.ContainerConfig
 import de.gesellix.docker.remote.api.ContainerCreateRequest
 import de.gesellix.docker.remote.api.ContainerCreateResponse
@@ -195,37 +193,6 @@ class ManageContainerClient implements ManageContainer {
     return new EngineResponseContent<IdResponse>(containerExec)
   }
 
-  /**
-   * @deprecated removed
-   * @see #startExec(java.lang.String, de.gesellix.docker.remote.api.ExecStartConfig, de.gesellix.docker.remote.api.core.StreamCallback, java.time.Duration)
-   */
-  @Deprecated
-  @Override
-  void startExec(String execId, ExecStartConfig execStartConfig, AttachConfig attachConfig) {
-    log.info("docker start exec '${execId}'")
-
-    // When using the TTY setting is enabled in POST /containers/create,
-    // the stream is the raw data from the process PTY and client’s stdin.
-    // When the TTY is disabled, then the stream is multiplexed to separate stdout and stderr.
-    ExecInspectResponse execInspect = client.execApi.execInspect(execId)
-    boolean multiplexStreams = !execInspect.processConfig.tty
-    EngineResponse response = engineClient.post([
-        path              : "/exec/${execId}/start".toString(),
-        body              : [Detach: execStartConfig.detach, Tty: execStartConfig.tty],
-        requestContentType: "application/json",
-        attach            : attachConfig,
-        multiplexStreams  : multiplexStreams])
-
-    if (!attachConfig) {
-      if (response.status?.code == 404) {
-        log.error("no such exec '${execId}'")
-      }
-      responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker exec start failed"))
-      response.stream.multiplexStreams = multiplexStreams
-    }
-//    return response
-  }
-
   @Override
   void startExec(String execId, ExecStartConfig execStartConfig, StreamCallback<Frame> callback, Duration timeout) {
     log.info("docker start exec '${execId}'")

client/src/main/java/de/gesellix/docker/client/container/ManageContainer.java

@@ -1,7 +1,6 @@
 package de.gesellix.docker.client.container;
 
 import de.gesellix.docker.client.EngineResponseContent;
-import de.gesellix.docker.engine.AttachConfig;
 import de.gesellix.docker.remote.api.ContainerCreateRequest;
 import de.gesellix.docker.remote.api.ContainerCreateResponse;
 import de.gesellix.docker.remote.api.ContainerInspectResponse;
@@ -62,13 +61,6 @@ void attach(String containerId,
 
   EngineResponseContent<IdResponse> createExec(String container, ExecConfig execConfig);
 
-  /**
-   * @deprecated removed
-   * @see #startExec(java.lang.String, de.gesellix.docker.remote.api.ExecStartConfig, de.gesellix.docker.remote.api.core.StreamCallback, java.time.Duration)
-   */
-  @Deprecated
-  void startExec(String execId, ExecStartConfig execStartConfig, AttachConfig attachConfig);
-
   void startExec(String execId, ExecStartConfig execStartConfig, StreamCallback<Frame> callback, Duration timeout);
 
   EngineResponseContent<ExecInspectResponse> inspectExec(String execId);

integration-test/src/test/groovy/de/gesellix/docker/client/DockerContainerIntegrationSpec.groovy

@@ -1,7 +1,6 @@
 package de.gesellix.docker.client
 
 import de.gesellix.docker.client.container.ArchiveUtil
-import de.gesellix.docker.engine.AttachConfig
 import de.gesellix.docker.remote.api.ChangeType
 import de.gesellix.docker.remote.api.ContainerCreateRequest
 import de.gesellix.docker.remote.api.ContainerUpdateRequest
@@ -23,6 +22,7 @@ import groovy.json.JsonOutput
 import groovy.util.logging.Slf4j
 import okhttp3.Response
 import okhttp3.WebSocket
+import okio.BufferedSink
 import okio.ByteString
 import okio.Okio
 import okio.Sink
@@ -657,36 +657,80 @@ class DockerContainerIntegrationSpec extends Specification {
 
     String input = "exec ${UUID.randomUUID()}"
     String expectedOutput = "#$input#"
-    def outputStream = new ByteArrayOutputStream()
 
-    def onSinkClosed = new CountDownLatch(1)
-    def onSourceConsumed = new CountDownLatch(1)
+    when:
+    Cancellable job = null
+    List<Frame> frames = []
+    def execStartConfig = new ExecStartConfig(false, true, null)
+    def callback = new StreamCallback<Frame>() {
 
-    def attachConfig = new AttachConfig()
-    attachConfig.streams.stdin = new ByteArrayInputStream("$input\n".bytes)
-    attachConfig.streams.stdout = outputStream
-    attachConfig.onFailure = { Exception e ->
-      log.error("exec failed", e)
-    }
-    attachConfig.onResponse = { Response response ->
-      log.trace("onResponse (${response})")
+      @Override
+      void onStarting(Cancellable cancellable) {
+        job = cancellable
+      }
+
+      @Override
+      void attachInput(Sink sink) {
+        System.out.println("attachInput, sending data...")
+        new Thread(() -> {
+          BufferedSink buffer = Okio.buffer(sink)
+          try {
+            buffer.writeUtf8("$input\n")
+            buffer.flush()
+            System.out.println("... data sent")
+          } catch (IOException e) {
+            e.printStackTrace()
+            System.err.println("Failed to write to stdin: " + e.getMessage())
+          } finally {
+            try {
+              Thread.sleep(100)
+              sink.close()
+            } catch (Exception ignored) {
+              // ignore
+            }
+          }
+        }).start()
+      }
+
+      @Override
+      void onNext(Frame element) {
+        log.info(element?.toString())
+        frames.add(element)
+      }
+
+      @Override
+      void onFailed(Exception e) {
+        log.error("Exec Attach failed", e)
+      }
+
+      @Override
+      void onFinished() {
+        log.info("Exec Attach finished")
+      }
     }
-    attachConfig.onSinkClosed = { Response response ->
-      log.trace("onSinkClosed (${response})")
-      onSinkClosed.countDown()
+
+    new Thread(() -> {
+      dockerClient.startExec(execId, execStartConfig, callback, Duration.ofSeconds(10))
+    }, "exec-client").start()
+
+    CountDownLatch wait = new CountDownLatch(1)
+    new Timer().schedule(new TimerTask() {
+      @Override
+      void run() {
+        if (job != null) {
+          job.cancel()
+        }
+        wait.countDown()
+      }
+    }, 5000)
+
+    try {
+      wait.await()
     }
-    attachConfig.onSourceConsumed = {
-      log.trace("onSourceConsumed")
-      onSourceConsumed.countDown()
+    catch (InterruptedException e) {
+      e.printStackTrace()
     }
 
-    when:
-    def execStartConfig = new ExecStartConfig(false, true, null)
-    dockerClient.startExec(execId, execStartConfig, attachConfig)
-//    dockerClient.startExec(execId, execStartConfig, callback, Duration.of(1, ChronoUnit.MINUTES))
-    onSinkClosed.await(5, SECONDS)
-    onSourceConsumed.await(5, SECONDS)
-
     def containerIsolation = dockerClient.inspectContainer(containerId).content.hostConfig?.isolation
     def actualIsolation = containerIsolation ? SystemInfo.Isolation.values().find { it.value == containerIsolation.value } : LocalDocker.getDaemonIsolation()
     if (actualIsolation == SystemInfo.Isolation.Hyperv) {