dockerpty output

Author: reliveyy

images/utils/launcher/__init__.py

@@ -211,6 +211,8 @@ def start(self):
                     break
                 try:
                     self.handle_command(cmd)
+                except KeyboardInterrupt:
+                    pass
                 except ServiceNotFound as e:
                     print("Service not found: %s" % e)
                 except ContainerNotFound as e:

images/utils/launcher/node/base.py

@@ -3,17 +3,16 @@
 import itertools
 import logging
 import os
-import sys
 from typing import List, Dict, Any, Optional
 import docker
 from docker import DockerClient
 from docker.errors import NotFound
 from docker.models.containers import Container
 from typing import TYPE_CHECKING
-import dockerpty
 
 from launcher.config import PortPublish
 from .image import Image
+from .pty import exec_command
 
 if TYPE_CHECKING:
     from launcher.config import Config
@@ -45,28 +44,16 @@ def __init__(self, name: str, image: Image, hostname: str, environment: List[str
         self.volumes = volumes
         self.ports = ports
 
-    def __repr__(self):
-        return f"<ContainerSpec {self.name=} {self.image=} {self.hostname=} {self.environment=} {self.command=} {self.volumes=} {self.ports=}>"
 
+class OutputStream:
+    def __init__(self, fd):
+        self.fd = fd
 
-class CompareEntity:
-    def __init__(self, obj: Any, diff: Any = None):
-        self.obj = obj
-        self.diff = diff
-
-    def __repr__(self):
-        return f"<CompareEntity obj={self.obj} diff={self.diff}>"
-
-
-class CompareResult:
-    def __init__(self, same: bool, message: str, old: CompareEntity, new: CompareEntity):
-        self.same = same
-        self.message = message
-        self.old = old
-        self.new = new
+    def isatty(self) -> bool:
+        return True
 
-    def __repr__(self):
-        return f"<CompareDetails same={self.same} message={self.message} old={self.old} new={self.new}>"
+    def fileno(self) -> int:
+        return self.fd
 
 
 def diff_details(s1, s2):
@@ -267,65 +254,28 @@ def status(self) -> str:
     def exec(self, command: str) -> Any:
         return self.container.exec_run(command)
 
-    def exec2(self, command: str) -> None:
-        try:
-            dockerpty.exec_command(self.client.api, self.container_name, command)
-        except docker.errors.NotFound:
-            raise ContainerNotFound(self.name)
-
-    def cli(self, command: str) -> None:
-        cli_cmd = self._cli + " " + command
-        logger.info("[CLI] %s", cli_cmd)
-        self.exec2(cli_cmd)
-
-    def cli2(self, cmd, shell):
+    def cli(self, command: str, exception=False) -> None:
         if self.mode != "native":
             return
-        full_cmd = "%s %s" % (self._cli, cmd)
-        self._logger.debug("[Execute] %s", full_cmd)
-        _, socket = self._container.exec_run(full_cmd, stdin=True, tty=True, socket=True)
 
-        shell.redirect_stdin(socket._sock)
         try:
-            output = ""
-            pre_data = None
-            while True:
-                data = socket.read(1024)
-
-                if pre_data is not None:
-                    data = pre_data + data
-
-                if len(data) == 0:
-                    break
-
-                try:
-                    text = data.decode()
-                    pre_data = None
-                except:
-                    pre_data = data
-                    continue
-
-                text = self.cli_filter(cmd, text)
-                output += text
-
-                # Write text in chunks in case trigger BlockingIOError: could not complete without blocking
-                # because text is too large to fit the output buffer
-                # https://stackoverflow.com/questions/54185874/logging-chokes-on-blockingioerror-write-could-not-complete-without-blocking
-                i = 0
-                while i < len(text):
-                    os.write(sys.stdout.fileno(), text[i: i + 1024].encode())
-                    i = i + 1024
-                sys.stdout.flush()
-        finally:
-            shell.stop_redirect_stdin()
-
-        # TODO get exit code here
-        exception = self.extract_exception(cmd, output)
-        if exception:
-            raise exception
+            full_cmd = "%s %s" % (self._cli, command)
+            # FIXME use blocking docker client here
+            output = exec_command(self.client.api, self.container_name, full_cmd)
+            logger.debug("[Execute] %s (interactive)\n%s", full_cmd, output)
+            try:
+                self.extract_exception(command, output)
+            except KeyboardInterrupt:
+                raise
+            except:
+                if exception:
+                    raise
+        except docker.errors.NotFound:
+            # FIXME use self.container
+            raise ContainerNotFound(self.name)
 
     def extract_exception(self, cmd, text):
-        return None
+        pass
 
     def cli_filter(self, cmd, text):
         return text