Instantiate manager during extension loading

We add manager as a traitlet to ServerApp and add monitor as a callback
to ServerApp IO lopp

Simplify API handlers setup

Author: mahendrapaipuri

jupyter_server_proxy/__init__.py

@@ -1,14 +1,10 @@
-from jupyter_server.utils import url_path_join as ujoin
-
-from .api import (
-    IconHandler,
-    ListServersAPIHandler,
-    ServersAPIHandler,
-    ServersInfoHandler,
-)
+import traitlets
+
+from .manager import ServerProxyAppManager
 from .config import ServerProxy as ServerProxyConfig
 from .config import get_entrypoint_server_processes, make_handlers, make_server_process
 from .handlers import setup_handlers
+from .api import setup_api_handlers
 
 
 # Jupyter Extension points
@@ -43,14 +39,33 @@ def _jupyter_labextension_paths():
 def _load_jupyter_server_extension(nbapp):
     # Set up handlers picked up via config
     base_url = nbapp.web_app.settings["base_url"]
+
+    # Add server_proxy_manager trait to ServerApp and Instantiate a manager
+    nbapp.add_traits(
+        server_proxy_manager=traitlets.Instance(ServerProxyAppManager)
+    )
+    manager = nbapp.server_proxy_manager = ServerProxyAppManager()
     serverproxy_config = ServerProxyConfig(parent=nbapp)
 
+    # Add a long running background task that monitors the running proxies
+    try:
+        nbapp.io_loop.call_later(
+            serverproxy_config.monitor_interval,
+            manager.monitor,
+            serverproxy_config.monitor_interval
+        )
+    except AttributeError:
+        nbapp.log.debug(
+            "[jupyter-server-proxy] Server proxy manager is only supportted "
+            "for Notebook >= 7",
+        )
+
     server_processes = [
         make_server_process(name, server_process_config, serverproxy_config)
         for name, server_process_config in serverproxy_config.servers.items()
     ]
     server_processes += get_entrypoint_server_processes(serverproxy_config)
-    server_handlers = make_handlers(base_url, server_processes)
+    server_handlers = make_handlers(base_url, manager, server_processes)
     nbapp.web_app.add_handlers(".*", server_handlers)
 
     # Set up default non-server handler
@@ -59,29 +74,10 @@ def _load_jupyter_server_extension(nbapp):
         serverproxy_config,
     )
 
-    icon_handlers = []
-    for sp in server_processes:
-        if sp.launcher_entry.enabled and sp.launcher_entry.icon_path:
-            icon_handlers.append(
-                (
-                    ujoin(base_url, f"server-proxy/icon/{sp.name}"),
-                    IconHandler,
-                    {"path": sp.launcher_entry.icon_path},
-                )
-            )
-
-    nbapp.web_app.add_handlers(
-        ".*",
-        [
-            (
-                ujoin(base_url, "api/server-proxy/servers-info"),
-                ServersInfoHandler,
-                {"server_processes": server_processes},
-            ),
-            (ujoin(base_url, r"api/server-proxy"), ListServersAPIHandler),
-            (ujoin(base_url, r"api/server-proxy/(?P<name>.*)"), ServersAPIHandler),
-        ]
-        + icon_handlers,
+    setup_api_handlers(
+        nbapp.web_app,
+        manager,
+        server_processes,
     )
 
     nbapp.log.debug(

jupyter_server_proxy/handlers.py

@@ -20,7 +20,6 @@
 from traitlets import Bytes, Dict, Instance, Integer, Unicode, Union, default, observe
 from traitlets.traitlets import HasTraits
 
-from .manager import manager
 from .unixsock import UnixResolver
 from .utils import call_with_asked_args
 from .websocket import WebSocketHandlerMixin, pingable_ws_connect
@@ -712,8 +711,9 @@ def __init__(self, *args, **kwargs):
         self.command = list()
         super().__init__(*args, **kwargs)
 
-    def initialize(self, state):
+    def initialize(self, state, manager):
         self.state = state
+        self.manager = manager
         if "proc_lock" not in state:
             state["proc_lock"] = Lock()
 
@@ -803,7 +803,7 @@ async def ensure_process(self):
         async with self.state["proc_lock"]:
             # If the server process is terminated via Runningsessions or killed
             # outside of jsp, we should be able to restart the process. If
-            # process is not in running stated, remove proc object and restart
+            # process is not in running state, remove proc object and restart
             # the process
             if "proc" in self.state:
                 if not self.state["proc"].running:
@@ -846,9 +846,8 @@ async def ensure_process(self):
                         raise web.HTTPError(500, f"could not start {self.name} in time")
 
                     # If process started succesfully, add it to manager
-                    # Add the server proxy app to manager
-                    await manager.add_server_proxy_app(
-                        self.name, self.base_url, cmd, self.port, proc
+                    self.manager.add_server_proxy_app(
+                        self.name, self.base_url, cmd, self.port, proc, self.unix_socket
                     )
                 except:
                     # Make sure we remove proc from state in any error condition