Move app-level _send, _recv into base class in unpythonic.net.common

Technologicat · Technologicat · commit 706306da22cc · 2020-01-05T00:01:21.000+02:00
diff --git a/unpythonic/net/client.py b/unpythonic/net/client.py
@@ -3,13 +3,13 @@
 
 import readline  # noqa: F401, input() uses the readline module if it has been loaded.
 import socket
-import json
 import select
 import sys
 import signal
 import threading
 
-from .msg import encodemsg, socketsource, MessageDecoder
+from .msg import socketsource, MessageDecoder
+from .common import ApplevelProtocol
 
 __all__ = ["connect"]
 
@@ -50,7 +50,7 @@ def _handle_alarm(signum, frame):
 # 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:
+class ControlClient(ApplevelProtocol):
     # 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):
@@ -61,34 +61,10 @@ def __init__(self, sock):
         """
         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
+        # read data from a specific type of message source; buffering occurs in
         # ReceiveBuffer inside MessageDecoder.
         self.decoder = MessageDecoder(socketsource(sock))
 
-    # TODO: Refactor low-level _send, _recv functions into a base class common for server and client.
-    def _send(self, data):
-        """Send a message on the control channel.
-
-        data: dict-like.
-        """
-        json_data = json.dumps(data)
-        bytes_out = json_data.encode("utf-8")
-        self.sock.sendall(encodemsg(bytes_out))
-    def _recv(self):
-        """Receive a message on the control channel.
-
-        Returns a dict-like.
-
-        Blocks if no data is currently available on the channel,
-        but EOF has not been signaled.
-        """
-        bytes_in = self.decoder.decode()
-        if not bytes_in:
-            print("Socket closed by other end.")
-            return None
-        json_data = bytes_in.decode("utf-8")
-        return json.loads(json_data)
-
     def complete(self, text, state):
         """Tab-complete in a remote REPL session.
 
@@ -99,7 +75,10 @@ def complete(self, text, state):
             self._send(request)
             reply = self._recv()
             # print("text '{}' state '{}' reply '{}'".format(text, state, reply))
-            if reply and reply["status"] == "ok":
+            if not reply:
+                print("Socket closed by other end.")
+                return None
+            if reply["status"] == "ok":
                 return reply["result"]
         except BaseException as err:
             print(type(err), err)
@@ -117,7 +96,10 @@ def send_kbinterrupt(self):
             request = {"command": "KeyboardInterrupt"}
             self._send(request)
             reply = self._recv()
-            return reply and reply["status"] == "ok"
+            if not reply:
+                print("Socket closed by other end.")
+                return None
+            return reply["status"] == "ok"
         except BaseException as err:
             print(type(err), err)
         return False
diff --git a/unpythonic/net/common.py b/unpythonic/net/common.py
@@ -0,0 +1,64 @@
+# -*- coding: utf-8; -*-
+
+import json
+
+from .msg import encodemsg
+
+__all__ = ["ApplevelProtocol"]
+
+class ApplevelProtocol:
+    """Application-level communication protocol.
+
+    We encode the payload as JSON encoded dictionaries, then encoded as utf-8
+    text. The bytes are stuffed into a message using the `unpythonic.net.msg`
+    low-level message protocol.
+
+    This format was chosen instead of pickle to ensure the client and server
+    can talk to each other regardless of the Python versions on each end of the
+    connection.
+
+    Transmission is synchronous; when one end is sending, the other one must be
+    receiving. Both sending and receiving will block until success, or until
+    the socket is closed.
+
+    This can be used as a common base class for server/client object pairs.
+
+    **NOTE**: The derived class must define two attributes:
+
+      - `sock`: an open TCP socket connected to the peer to communicate with.
+
+      - `decoder`: `unpythonic.net.msg.MessageDecoder` instance for receiving
+        messages. Typically this is connected to `sock` using an
+        `unpythonic.net.msg.socketsource`, like
+        `MessageDecoder(socketsource(sock))`.
+
+    These are left to the user code to define, because typically the client and
+    server sides must handle this differently. The client can create `sock` and
+    `decoder` in its constructor, whereas a TCP server typically inherits from
+    `socketserver.BaseRequestHandler`, and receives an incoming connection in
+    its `handle` method (which is then the official place to create any
+    session-specific attributes).
+    """
+    def _send(self, data):
+        """Send a message using the application-level protocol.
+
+        data: dict-like.
+        """
+        json_data = json.dumps(data)
+        bytes_out = json_data.encode("utf-8")
+        self.sock.sendall(encodemsg(bytes_out))
+
+    def _recv(self):
+        """Receive a message using the application-level protocol.
+
+        Returns a dict-like, or `None` if the decoder's message source
+        signaled EOF.
+
+        Blocks if no data is currently available at the message source,
+        but EOF has not been signaled.
+        """
+        bytes_in = self.decoder.decode()
+        if not bytes_in:
+            return None
+        json_data = bytes_in.decode("utf-8")
+        return json.loads(json_data)
diff --git a/unpythonic/net/server.py b/unpythonic/net/server.py
@@ -5,7 +5,7 @@
 
 In a REPL session, you can inspect and mutate the global state of your running
 program. You can e.g. replace top-level function definitions with new versions
-in your running process.
+in your running process, or reload modules from disk (with `importlib.reload`).
 
 To enable it in your app::
 
@@ -14,7 +14,7 @@
 
 To connect to a running REPL server::
 
-    python3 -m unpythonic.replclient localhost 1337
+    python3 -m unpythonic.net.client localhost 1337
 
 If you're already running in a local Python REPL, this should also work::
 
@@ -33,12 +33,24 @@
 process will terminate the server, also forcibly terminating all open REPL
 sessions in that process.
 
+**CAUTION**: `help(foo)` currently does not work in this REPL server. Its
+stdin/stdout are not redirected to the socket; instead, it will run locally on
+the server, causing the client to hang. The top-level `help()`, which uses a
+command-based interface, appears to work, until you ask for a help page, at
+which point it runs into the same problem.
+
 **CAUTION**: as Python was not designed for arbitrary hot-patching, if you
-change a **class** definition, only new instances will use the new definition,
-unless you specifically monkey-patch existing instances to change their type.
+change a **class** definition (whether by re-assigning the reference or by
+reloading the module containing the definition), only new instances will use
+the new definition, unless you specifically monkey-patch existing instances to
+change their type.
+
 The language docs hint it is somehow possible to retroactively change an
 object's type, if you're careful with it:
     https://docs.python.org/3/reference/requestmodel.html#id8
+In fact, ActiveState recipe 160164 explicitly tells how to do it,
+and even automate that with a custom metaclass:
+    https://github.com/ActiveState/code/tree/master/recipes/Python/160164_automatically_upgrade_class_instances
 
 Based on socketserverREPL by Ivor Wanders, 2017. Used under the MIT license.
     https://github.com/iwanders/socketserverREPL
@@ -56,6 +68,7 @@
 The `socketserverREPL` package uses the same default, and actually its
 `repl_tool.py` can talk to this server (but doesn't currently feature
 remote tab completion).
+
 """
 
 # TODO: use logging module instead of server-side print
@@ -81,14 +94,14 @@
 import os
 import time
 import socketserver
-import json
 import atexit
 
 from ..collections import ThreadLocalBox, Shim
 #from ..misc import async_raise
 
 from .util import ReuseAddrThreadingTCPServer
-from .msg import encodemsg, MessageDecoder, socketsource
+from .msg import MessageDecoder, socketsource
+from .common import ApplevelProtocol
 from .ptyproxy import PTYSocketProxy
 
 _server_instance = None
@@ -104,6 +117,8 @@
 _banner = None
 
 # TODO: inject this to globals of the target module
+#   - Maybe better to inject just a single "repl" container which has this and
+#     the other stuff, and print out at connection time where to find this stuff.
 def halt(doit=True):
     """Tell the REPL server to shut down after the last client has disconnected.
 
@@ -130,44 +145,15 @@ def server_print(*values, **kwargs):
     print(*values, **kwargs, file=_original_stdout)
 
 
-class ControlSession(socketserver.BaseRequestHandler):
+class ControlSession(socketserver.BaseRequestHandler, ApplevelProtocol):
     """Entry point for connections to the control server.
 
     We use a separate connection for control to avoid head-of-line blocking.
 
     In a session, the client sends us requests for remote tab completion. We
     invoke `rlcompleter` on the server side, and return its response to the
     client.
-
-    We encode the payload as JSON encoded dictionaries. This format was chosen
-    instead of pickle to ensure the client and server can talk to each other
-    regardless of the Python versions on each end of the connection.
     """
-
-    # TODO: Refactor low-level _send, _recv functions into a base class common for server and client.
-    def _send(self, data):
-        """Send a message on the control channel.
-
-        data: dict-like.
-        """
-        json_data = json.dumps(data)
-        bytes_out = json_data.encode("utf-8")
-        self.sock.sendall(encodemsg(bytes_out))
-    def _recv(self):
-        """Receive a message on the control channel.
-
-        Returns a dict-like.
-
-        Blocks if no data is currently available on the channel,
-        but EOF has not been signaled.
-        """
-        bytes_in = self.decoder.decode()
-        if not bytes_in:
-            print("Socket closed by other end.")
-            return None
-        json_data = bytes_in.decode("utf-8")
-        return json.loads(json_data)
-
     def handle(self):
         # TODO: ipv6 support
         caddr, cport = self.client_address
@@ -211,6 +197,7 @@ class ClientExit(Exception):
                 # about the failure may be included in arbitrary other fields.
                 request = self._recv()
                 if not request:
+                    print("Socket closed by other end.")
                     raise ClientExit
 
                 if request["command"] == "TabComplete":
@@ -242,7 +229,10 @@ class ClientExit(Exception):
 
 
 class ConsoleSession(socketserver.BaseRequestHandler):
-    """Entry point for connections from the TCP server."""
+    """Entry point for connections from the TCP server.
+
+    Primary channel. This serves the actual REPL session.
+    """
     def handle(self):
         # TODO: ipv6 support
         caddr, cport = self.client_address
