Rename websockify to RawSocketProxy

Author: dylex

docs/source/server-process.md

@@ -169,15 +169,15 @@ Defaults to _True_.
 
 (server-process:callable-arguments)=
 
-### `websockify`
+### `raw_socket_proxy`
 
 _True_ to proxy only websocket connections into raw stream connections.
 _False_ (default) if the proxied server speaks full HTTP.
 
 If _True_, the proxied server is treated a raw TCP (or unix socket) server that
 does not use HTTP.
 In this mode, only websockets are handled, and messages are sent to the backend
-server as stream data. This is equivalent to running a
+server as raw stream data. This is similar to running a
 [websockify](https://github.com/novnc/websockify) wrapper.
 All other HTTP requests return 405.
 

jupyter_server_proxy/config.py

@@ -16,7 +16,7 @@
 from traitlets.config import Configurable
 
 from .handlers import AddSlashHandler, NamedLocalProxyHandler, SuperviseAndProxyHandler
-from .websockify import WebsockifyHandler, SuperviseAndWebsockifyHandler
+from .rawsocket import RawSocketHandler, SuperviseAndRawSocketHandler
 
 try:
     # Traitlets >= 4.3.3
@@ -44,7 +44,7 @@
         "request_headers_override",
         "rewrite_response",
         "update_last_activity",
-        "websockify",
+        "raw_socket_proxy",
     ],
 )
 
@@ -54,7 +54,7 @@ def _make_proxy_handler(sp: ServerProcess):
     Create an appropriate handler with given parameters
     """
     if sp.command:
-        cls = SuperviseAndWebsockifyHandler if sp.websockify else SuperviseAndProxyHandler
+        cls = SuperviseAndRawSocketHandler if sp.raw_socket_proxy else SuperviseAndProxyHandler
         args = dict(state={})
     elif not (sp.port or isinstance(sp.unix_socket, str)):
         warn(
@@ -64,7 +64,7 @@ def _make_proxy_handler(sp: ServerProcess):
         )
         return
     else:
-        cls = WebsockifyHandler if sp.websockify else NamedLocalProxyHandler
+        cls = RawSocketHandler if sp.raw_socket_proxy else NamedLocalProxyHandler
         args = {}
 
     # FIXME: Set 'name' properly
@@ -162,7 +162,7 @@ def make_server_process(name, server_process_config, serverproxy_config):
         update_last_activity=server_process_config.get(
             "update_last_activity", True
         ),
-        websockify=server_process_config.get("websockify", False),
+        raw_socket_proxy=server_process_config.get("raw_socket_proxy", False),
     )
 
 
@@ -287,10 +287,10 @@ def cats_only(response, path):
           update_last_activity
             Will cause the proxy to report activity back to jupyter server.
 
-          websockify
-            Proxy websocket requests as a TCP (or unix socket) stream.
+          raw_socket_proxy
+            Proxy websocket requests as a raw TCP (or unix socket) stream.
             In this mode, only websockets are handled, and messages are sent to the backend,
-            equivalent to running a websockify layer (https://github.com/novnc/websockify).
+            similar to running a websockify layer (https://github.com/novnc/websockify).
             All other HTTP requests return 405 (and thus this will also bypass rewrite_response).
         """,
         config=True,

jupyter_server_proxy/websockify.py renamed to jupyter_server_proxy/rawsocket.py

@@ -2,7 +2,7 @@
 A simple translation layer between tornado websockets and asyncio stream
 connections.
 
-This subsumes the functionality of websockify
+This provides similar functionality to websockify
 (https://github.com/novnc/websockify) without needing an extra proxy hop
 or process through with all messages pass for translation.
 """
@@ -11,7 +11,7 @@
 
 from .handlers import NamedLocalProxyHandler, SuperviseAndProxyHandler
 
-class WebsockifyProtocol(asyncio.Protocol):
+class RawSocketProtocol(asyncio.Protocol):
     """
     A protocol handler for the proxied stream connection.
     Sends any received blocks directly as websocket messages.
@@ -22,15 +22,16 @@ def __init__(self, handler):
     def data_received(self, data):
         "Send the buffer as a websocket message."
         self.handler._record_activity()
-        # async "semi-synchronous", waiting is only needed for control flow and errors:
+        # ignore async "semi-synchronous" result, waiting is only needed for control flow and errors
+        # (see https://github.com/tornadoweb/tornado/blob/bdfc017c66817359158185561cee7878680cd841/tornado/websocket.py#L1073)
         self.handler.write_message(data, binary=True)
 
     def connection_lost(self, exc):
         "Close the websocket connection."
-        self.handler.log.info(f"Websockify {self.handler.name} connection lost: {exc}")
+        self.handler.log.info(f"Raw websocket {self.handler.name} connection lost: {exc}")
         self.handler.close()
 
-class WebsockifyHandler(NamedLocalProxyHandler):
+class RawSocketHandler(NamedLocalProxyHandler):
     """
     HTTP handler that proxies websocket connections into a backend stream.
     All other HTTP requests return 405.
@@ -39,51 +40,50 @@ def _create_ws_connection(self, proto: asyncio.BaseProtocol):
         "Create the appropriate backend asyncio connection"
         loop = asyncio.get_running_loop()
         if self.unix_socket is not None:
-            self.log.info(f"Websockify {self.name} connecting to {self.unix_socket}")
+            self.log.info(f"RawSocket {self.name} connecting to {self.unix_socket}")
             return loop.create_unix_connection(proto, self.unix_socket)
         else:
-            self.log.info(f"Websockify {self.name} connecting to port {self.port}")
+            self.log.info(f"RawSocket {self.name} connecting to port {self.port}")
             return loop.create_connection(proto, 'localhost', self.port)
 
     async def proxy(self, port, path):
-        raise web.HTTPError(405, "websockets only")
+        raise web.HTTPError(405, "this raw_socket_proxy backend only supports websocket connections")
 
     async def proxy_open(self, host, port, proxied_path=""):
         """
         Open the backend connection. host and port are ignored (as they are in
         the parent for unix sockets) since they are always passed known values.
         """
-        transp, proto = await self._create_ws_connection(lambda: WebsockifyProtocol(self))
+        transp, proto = await self._create_ws_connection(lambda: RawSocketProtocol(self))
         self.ws_transp = transp
         self.ws_proto = proto
         self._record_activity()
-        self.log.info(f"Websockify {self.name} connected")
+        self.log.info(f"RawSocket {self.name} connected")
 
     def on_message(self, message):
         "Send websocket messages as stream writes, encoding if necessary."
         self._record_activity()
-        if hasattr(self, "ws_transp"):
-            if isinstance(message, str):
-                message = message.encode('utf-8')
-            self.ws_transp.write(message) # buffered non-blocking. should block?
+        if isinstance(message, str):
+            message = message.encode('utf-8')
+        self.ws_transp.write(message) # buffered non-blocking. should block (needs new enough tornado)
 
     def on_ping(self, message):
         "No-op"
         self._record_activity()
 
     def on_close(self):
         "Close the backend connection."
-        self.log.info(f"Websockify {self.name} connection closed")
+        self.log.info(f"RawSocket {self.name} connection closed")
         if hasattr(self, "ws_transp"):
             self.ws_transp.close()
 
-class SuperviseAndWebsockifyHandler(SuperviseAndProxyHandler, WebsockifyHandler):
+class SuperviseAndRawSocketHandler(SuperviseAndProxyHandler, RawSocketHandler):
     async def _http_ready_func(self, p):
         # not really HTTP here, just try an empty connection
         try:
             transp, _ = await self._create_ws_connection(asyncio.Protocol)
         except OSError as exc:
-            self.log.debug(f"Websockify {self.name} connection check failed: {exc}")
+            self.log.debug(f"RawSocket {self.name} connection check failed: {exc}")
             return False
         transp.close()
         return True