REPL: generalize control channel

Technologicat · Technologicat · commit 2f9f0f4bd230 · 2020-01-02T17:18:14.000+02:00
Now all we need for remote Ctrl+C is actually implementing the logic on the
server side. We must first associate the REPL and control sessions, so that
we'll know which REPL session thread t the async_raise(t, KeyboardInterrupt)
should target.
diff --git a/unpythonic/net/client.py b/unpythonic/net/client.py
@@ -23,46 +23,73 @@ def _handle_alarm(signum, frame):
 signal.signal(signal.SIGALRM, _handle_alarm)
 
 
-def _make_remote_completion_client(sock):
-    """Make a tab completion function for a remote REPL session.
-
-    `buf` is a receive buffer for the message protocol (see
-    `unpythonic.net.msg.ReceiveBuffer`).
-
-    `sock` must be a socket already connected to a `ControlSession`.
-    The caller is responsible for managing the socket.
-
-    The return value can be used as a completer in `readline.set_completer`.
-    """
-    # Messages must be processed by just one central decoder, to prevent data
-    # races, but also to handle buffering of incoming data correctly, because
-    # the underlying transport (TCP) has no notion of message boundaries. Thus
-    # typically, at the seam between two messages, some of the data belonging
-    # to the beginning of the second message has already arrived and been read
-    # from the socket, when trying to read the last batch of data belonging to
-    # the end of the first message.
-    #
-    # The source is just an abstraction over the details of how to actually
-    # read data from a specific type of data source; buffering occurs in
-    # ReceiveBuffer inside MessageDecoder.
-    decoder = MessageDecoder(socketsource(sock))
-    def complete(text, state):
+# Messages must be processed by just one central decoder, to prevent data
+# races, but also to handle buffering of incoming data correctly, because
+# the underlying transport (TCP) has no notion of message boundaries. Thus
+# typically, at the seam between two messages, some of the data belonging
+# to the beginning of the second message has already arrived and been read
+# from the socket, when trying to read the last batch of data belonging to
+# the end of the first message.
+class ControlClient:
+    # TODO: manage the socket internally. We need to make this into a context manager,
+    # so that __enter__ can set up the socket and __exit__ can tear it down.
+    def __init__(self, sock):
+        """Initialize session for control channel (client side).
+
+        `sock` must be a socket already connected to a `ControlSession` (on the
+        server side). The caller is responsible for managing the socket.
+        """
+        self.sock = sock
+        # The source is just an abstraction over the details of how to actually
+        # read data from a specific type of data source; buffering occurs in
+        # ReceiveBuffer inside MessageDecoder.
+        self.decoder = MessageDecoder(socketsource(sock))
+
+    # TODO: Refactor low-level _send, _recv functions.
+    # TODO: Always JSON encode. Don't send just strings.
+
+    def complete(self, text, state):
+        """Tab-complete in a remote REPL session.
+
+        This is a completer for `readline.set_completer`.
+        """
         try:
-            request = {"text": text, "state": state}
+            request = {"command": "TabComplete", "text": text, "state": state}
             data_out = json.dumps(request).encode("utf-8")
-            sock.sendall(encodemsg(data_out))
-            data_in = decoder.decode()
+            self.sock.sendall(encodemsg(data_out))
+            data_in = self.decoder.decode()
             response = data_in.decode("utf-8")
             # print("text '{}' state '{}' reply '{}'".format(text, state, response))
             if not response:
-                print("Control server exited, socket closed!")
+                print("Socket closed by other end.")
                 return None
             reply = json.loads(response)
             return reply
         except BaseException as err:
             print(type(err), err)
         return None
-    return complete
+
+    def send_kbinterrupt(self):
+        """Request the server to perform a `KeyboardInterrupt` (Ctrl+C).
+
+        The `KeyboardInterrupt` occurs in the REPL session associated with
+        this control channel.
+
+        Returns `True` on success, `False` on failure.
+        """
+        try:
+            request = {"command": "KeyboardInterrupt"}
+            data_out = json.dumps(request).encode("utf-8")
+            self.sock.sendall(encodemsg(data_out))
+            data_in = self.decoder.decode()
+            response = data_in.decode("utf-8")
+            if not response:
+                print("Socket closed by other end.")
+                return False
+            return response == "ok"
+        except BaseException as err:
+            print(type(err), err)
+        return False
 
 
 def connect(addrspec):
@@ -91,8 +118,8 @@ class SessionExit(Exception):
 
                 # Set a custom tab completer for readline.
                 # https://stackoverflow.com/questions/35115208/is-there-any-way-to-combine-readline-rlcompleter-and-interactiveconsole-in-pytho
-                completer = _make_remote_completion_client(csock)
-                readline.set_completer(completer)
+                controller = ControlClient(csock)
+                readline.set_completer(controller.complete)
                 readline.parse_and_bind("tab: complete")
 
                 def sock_to_stdout():
@@ -134,8 +161,7 @@ def sock_to_stdout():
                             inp = input()
                             sock.sendall((inp + "\n").encode("utf-8"))
                         except KeyboardInterrupt:
-                            # TODO: refactor control channel logic; send command on control channel
-                            sock.sendall("\x03\n".encode("utf-8"))
+                            controller.send_kbinterrupt()
                 except EOFError:
                     print("replclient: Ctrl+D pressed, asking server to disconnect.")
                     print("replclient: if the server does not respond, press Ctrl+C to force.")
diff --git a/unpythonic/net/server.py b/unpythonic/net/server.py
@@ -153,20 +153,45 @@ class ClientExit(Exception):
         try:
             server_print("Control channel for {} opened.".format(client_address_str))
             # TODO: fancier backend? See examples in https://pymotw.com/3/readline/
-            backend = rlcompleter.Completer(_console_locals_namespace)
+            completer_backend = rlcompleter.Completer(_console_locals_namespace)
             sock = self.request
             decoder = MessageDecoder(socketsource(sock))
             while True:
-                # TODO: Add support for requests to inject Ctrl+C. Needs a command protocol layer.
-                # TODO: Can use JSON dictionaries; we're guaranteed to get whole messages only.
+                # A message sent by the client contains exactly one request.
+                # A request is a UTF-8 encoded JSON dictionary with one
+                # compulsory field: "command". It must contain one of the
+                # recognized command names as `str`.
+                #
+                # Existence and type of any other fields depends on each
+                # individual command. This server source code is the official
+                # documentation of this small app-level protocol.
                 data_in = decoder.decode()
                 if not data_in:
                     raise ClientExit
                 request = json.loads(data_in.decode("utf-8"))
-                reply = backend.complete(request["text"], request["state"])
-                # server_print(request, reply)
-                data_out = json.dumps(reply).encode("utf-8")
-                sock.sendall(encodemsg(data_out))
+
+                if request["command"] == "TabComplete":
+                    reply = completer_backend.complete(request["text"], request["state"])
+                    # server_print(request, reply)
+                    data_out = json.dumps(reply).encode("utf-8")
+                    sock.sendall(encodemsg(data_out))
+
+                elif request["command"] == "KeyboardInterrupt":
+                    errmsg = "TODO: remote Ctrl+C request received; implement the server side!"
+                    server_print(errmsg)
+
+                    # TODO: Once we pair the REPL and control sessions, this will be as easy as:
+                    # async_raise(t, KeyboardInterrupt)
+                    # Here t is the threading.Thread instance in which *our* REPL session is running.
+
+                    # Acknowledge the request, the client wants to know whether it worked.
+                    # When this is implemented, upon success, we should send "ok".
+                    data_out = "not_implemented".encode("utf-8")
+                    sock.sendall(encodemsg(data_out))
+
+                # TODO: always send a JSON encoded reply, so that even if the
+                # command was not understood, we can inform the client about that.
+
         except ClientExit:
             server_print("Control channel for {} closed.".format(client_address_str))
         except BaseException as err:
