remote/client: Move terminal handling into a separate file

There is quite a lot of code here, so move the terminal function into
its own file. This will make it easier to extend it later.

Signed-off-by: Simon Glass <sjg@chromium.org>

Author: sjg20

labgrid/remote/client.py

@@ -14,7 +14,6 @@
 import signal
 import sys
 import shlex
-import shutil
 import json
 import itertools
 import ipaddress
@@ -46,7 +45,7 @@
 from ..exceptions import NoDriverFoundError, NoResourceFoundError, InvalidConfigError
 from .generated import labgrid_coordinator_pb2, labgrid_coordinator_pb2_grpc
 from ..resource.remote import RemotePlaceManager, RemotePlace
-from ..util import diff_dict, flat_dict, dump, atomic_replace, labgrid_version, Timeout
+from ..util import diff_dict, flat_dict, dump, atomic_replace, labgrid_version, Timeout, term
 from ..util.proxy import proxymanager
 from ..util.helper import processwrapper
 from ..driver import Mode, ExecutionError
@@ -1072,56 +1071,16 @@ async def _console(self, place, target, timeout, *, logfile=None, loop=False, li
 
         # check for valid resources
         assert port is not None, "Port is not set"
-
-        microcom_bin = shutil.which("microcom")
-
-        if microcom_bin is not None:
-            call = [microcom_bin, "-s", str(resource.speed), "-t", f"{host}:{port}"]
-
-            if listen_only:
-                call.append("--listenonly")
-
-            if logfile:
-                call.append(f"--logfile={logfile}")
-        else:
-            call = ["telnet", host, str(port)]
-
-            logging.info("microcom not available, using telnet instead")
-
-            if listen_only:
-                logging.warning("--listenonly option not supported by telnet, ignoring")
-
-            if logfile:
-                logging.warning("--logfile option not supported by telnet, ignoring")
-
-        if logfile:
-            call.append(f"--logfile={logfile}")
-        logging.info("connecting to %s calling %s", resource, " ".join(call))
         try:
-            p = await asyncio.create_subprocess_exec(*call)
+            returncode = await term.external(
+                lambda: self.is_allowed(place), host, port, resource, logfile, listen_only
+            )
         except FileNotFoundError as e:
             raise ServerError(f"failed to execute remote console command: {e}")
-        while p.returncode is None:
-            try:
-                await asyncio.wait_for(p.wait(), 1.0)
-            except asyncio.TimeoutError:
-                # subprocess is still running
-                pass
 
-            try:
-                self._check_allowed(place)
-            except UserError:
-                p.terminate()
-                try:
-                    await asyncio.wait_for(p.wait(), 1.0)
-                except asyncio.TimeoutError:
-                    # try harder
-                    p.kill()
-                    await asyncio.wait_for(p.wait(), 1.0)
-                raise
-        if p.returncode:
-            print("connection lost", file=sys.stderr)
-        return p.returncode
+        # Raise an exception if the place was released
+        self._check_allowed(place)
+        return returncode
 
     async def console(self, place, target):
         while True:
@@ -1133,7 +1092,7 @@ async def console(self, place, target):
                 break
             if not self.args.loop:
                 if res:
-                    raise InteractiveCommandError("microcom error", res)
+                    raise InteractiveCommandError("console error", res)
                 break
             await asyncio.sleep(1.0)
 

labgrid/util/term.py

@@ -0,0 +1,71 @@
+"""Terminal handling, using microcom or telnet"""
+
+import asyncio
+import logging
+import sys
+import shutil
+
+EXIT_CHAR = 0x1d    # FS (Ctrl + ])
+
+async def external(check_allowed, host, port, resource, logfile, listen_only):
+    """Start an external terminal sessions
+
+    This uses microcom if available, otherwise falls back to telnet.
+
+    Args:
+        check_allowed (lambda): Function to call to make sure the terminal is
+            still accessible. No args. Returns True if allowed, False if not.
+        host (str): Host name to connect to
+        port (int): Port number to connect to
+        resource (str): Serial resource to connect to (used to get speed / name)
+        logfile (str): Logfile to write output too, or None. This is ignored if
+            telnet is used
+        listen_only (bool): True to ignore keyboard input (ignored with telnet)
+
+    Returns:
+        int: Return code from tool
+    """
+    microcom_bin = shutil.which("microcom")
+
+    if microcom_bin is not None:
+        call = [microcom_bin, "-s", str(resource.speed), "-t", f"{host}:{port}"]
+
+        if listen_only:
+            call.append("--listenonly")
+
+        if logfile:
+            call.append(f"--logfile={logfile}")
+    else:
+        call = ["telnet", host, str(port)]
+
+        logging.info("microcom not available, using telnet instead")
+
+        if listen_only:
+            logging.warning("--listenonly option not supported by telnet, ignoring")
+
+        if logfile:
+            logging.warning("--logfile option not supported by telnet, ignoring")
+
+    if logfile:
+        call.append(f"--logfile={logfile}")
+    logging.info("connecting to %s calling %s", resource, " ".join(call))
+    p = await asyncio.create_subprocess_exec(*call)
+    while p.returncode is None:
+        try:
+            await asyncio.wait_for(p.wait(), 1.0)
+        except asyncio.TimeoutError:
+            # subprocess is still running
+            pass
+
+        if check_allowed():
+            p.terminate()
+            try:
+                await asyncio.wait_for(p.wait(), 1.0)
+            except asyncio.TimeoutError:
+                # try harder
+                p.kill()
+                await asyncio.wait_for(p.wait(), 1.0)
+            break
+    if p.returncode:
+        print("connection lost", file=sys.stderr)
+    return p.returncode