Ensure extension manager always has a handle to serverapp

So that it can always check the reraise errors flag

jupyter_server/extension/manager.py

@@ -246,6 +246,8 @@ class ExtensionManager(LoggingConfigurable):
 
     config_manager = Instance(ExtensionConfigManager, allow_none=True)
 
+    serverapp = Any()  # Use Any to avoid circular import of Instance(ServerApp)
+
     @default("config_manager")
     def _load_default_config_manager(self):
         config_manager = ExtensionConfigManager()
@@ -327,31 +329,33 @@ def add_extension(self, extension_name, enabled=False):
             return True
         # Raise a warning if the extension cannot be loaded.
         except Exception as e:
+            if self.serverapp.reraise_server_extension_failures:
+                raise
             self.log.warning(e)
         return False
 
-    def link_extension(self, name, serverapp):
+    def link_extension(self, name):
         linked = self.linked_extensions.get(name, False)
         extension = self.extensions[name]
         if not linked and extension.enabled:
             try:
                 # Link extension and store links
-                extension.link_all_points(serverapp)
+                extension.link_all_points(self.serverapp)
                 self.linked_extensions[name] = True
                 self.log.info("{name} | extension was successfully linked.".format(name=name))
             except Exception as e:
-                if serverapp.reraise_server_extension_failures:
+                if self.serverapp.reraise_server_extension_failures:
                     raise
                 self.log.warning(e)
 
-    def load_extension(self, name, serverapp):
+    def load_extension(self, name):
         extension = self.extensions.get(name)
 
         if extension.enabled:
             try:
-                extension.load_all_points(serverapp)
+                extension.load_all_points(self.serverapp)
             except Exception as e:
-                if serverapp.reraise_server_extension_failures:
+                if self.serverapp.reraise_server_extension_failures:
                     raise
                 self.log.debug("".join(traceback.format_exception(*sys.exc_info())))
                 self.log.warning(
@@ -369,25 +373,25 @@ async def stop_extension(self, name, apps):
             await app.stop_extension()
             self.log.debug('{} | extension app "{}" stopped'.format(name, app.name))
 
-    def link_all_extensions(self, serverapp):
+    def link_all_extensions(self):
         """Link all enabled extensions
         to an instance of ServerApp
         """
         # Sort the extension names to enforce deterministic linking
         # order.
         for name in self.sorted_extensions.keys():
-            self.link_extension(name, serverapp)
+            self.link_extension(name)
 
-    def load_all_extensions(self, serverapp):
+    def load_all_extensions(self):
         """Load all enabled extensions and append them to
         the parent ServerApp.
         """
         # Sort the extension names to enforce deterministic loading
         # order.
         for name in self.sorted_extensions.keys():
-            self.load_extension(name, serverapp)
+            self.load_extension(name)
 
-    async def stop_all_extensions(self, serverapp):
+    async def stop_all_extensions(self):
         """Call the shutdown hooks in all extensions."""
         await multi(
             [

jupyter_server/serverapp.py

@@ -2076,9 +2076,9 @@ def init_server_extensions(self):
         and load its own config.
         """
         # Create an instance of the ExtensionManager.
-        self.extension_manager = ExtensionManager(log=self.log)
+        self.extension_manager = ExtensionManager(log=self.log, serverapp=self)
         self.extension_manager.from_jpserver_extensions(self.jpserver_extensions)
-        self.extension_manager.link_all_extensions(self)
+        self.extension_manager.link_all_extensions()
 
     def load_server_extensions(self):
         """Load any extensions specified by config.
@@ -2088,7 +2088,7 @@ def load_server_extensions(self):
 
         The extension API is experimental, and may change in future releases.
         """
-        self.extension_manager.load_all_extensions(self)
+        self.extension_manager.load_all_extensions()
 
     def init_mime_overrides(self):
         # On some Windows machines, an application has registered incorrect
@@ -2365,7 +2365,7 @@ async def cleanup_extensions(self):
             "Shutting down %d extension", "Shutting down %d extensions", n_extensions
         )
         self.log.info(extension_msg % n_extensions)
-        await run_sync_in_loop(self.extension_manager.stop_all_extensions(self))
+        await run_sync_in_loop(self.extension_manager.stop_all_extensions())
 
     def running_server_info(self, kernel_count=True):
         "Return the current working directory and the server url information"

jupyter_server/tests/extension/test_app.py

@@ -98,8 +98,8 @@ def test_stop_extension(jp_serverapp, caplog):
     calls = 0
 
     # load extensions (make sure we only have the one extension loaded
-    jp_serverapp.extension_manager.load_all_extensions(jp_serverapp)
-    extension_name = "jupyter_server.tests.extension.mockextensions"
+    jp_serverapp.extension_manager.load_all_extensions()
+    extension_name = 'jupyter_server.tests.extension.mockextensions'
     assert list(jp_serverapp.extension_manager.extension_apps) == [extension_name]
 
     # add a stop_extension method for the extension app

jupyter_server/tests/extension/test_manager.py

@@ -74,11 +74,11 @@ def _normalize_path(path_list):
     return [p.rstrip(os.path.sep) for p in path_list]
 
 
-def test_extension_manager_api():
+def test_extension_manager_api(jp_serverapp):
     jpserver_extensions = {"jupyter_server.tests.extension.mockextensions": True}
-    manager = ExtensionManager()
+    manager = ExtensionManager(serverapp=jp_serverapp)
     assert manager.config_manager
-    expected = _normalize_path(os.path.join(jupyter_config_path()[0], "serverconfig"))
+    expected = _normalize_path(os.path.join(jupyter_config_path()[0], 'serverconfig'))
     assert _normalize_path(manager.config_manager.read_config_path[0]) == expected
     manager.from_jpserver_extensions(jpserver_extensions)
     assert len(manager.extensions) == 1
@@ -87,7 +87,7 @@ def test_extension_manager_api():
 
 def test_extension_manager_linked_extensions(jp_serverapp):
     name = "jupyter_server.tests.extension.mockextensions"
-    manager = ExtensionManager()
+    manager = ExtensionManager(serverapp=jp_serverapp)
     manager.add_extension(name, enabled=True)
-    manager.link_extension(name, jp_serverapp)
+    manager.link_extension(name)
     assert name in manager.linked_extensions