add a basic extension config manager

Author: Zsailer

jupyter_server/extension/config.py

@@ -0,0 +1,65 @@
+
+from jupyter_server.services.config.manager import ConfigManager
+
+
+DEFAULT_SECTION_NAME = "jupyter_server_config"
+
+
+class ExtensionConfigManager(ConfigManager):
+    """A manager class to interface with Jupyter Server Extension config
+    found in a `config.d` folder. It is assumed that all configuration
+    files in this directory are JSON files.
+    """
+    def get_jpserver_extensions(
+        self,
+        section_name=DEFAULT_SECTION_NAME
+    ):
+        """Return the jpserver_extensions field from all
+        config files found."""
+        data = self.get(section_name)
+        return (
+            data
+            .get("ServerApp", {})
+            .get("jpserver_extensions", {})
+        )
+
+    def enabled(
+        self,
+        name,
+        section_name=DEFAULT_SECTION_NAME,
+        include_root=True
+    ):
+        """Is the extension enabled?"""
+        extensions = self.get_jpserver_extensions(section_name)
+        try:
+            return extensions[name]
+        except KeyError:
+            return False
+
+    def enable(
+        self,
+        name,
+        section_name=DEFAULT_SECTION_NAME,
+    ):
+        data = {
+            "ServerApp": {
+                "jpserver_extensions": {
+                    name: True
+                }
+            }
+        }
+        self.update(section_name, data)
+
+    def disable(
+        self,
+        name,
+        section_name=DEFAULT_SECTION_NAME
+    ):
+        data = {
+            "ServerApp": {
+                "jpserver_extensions": {
+                    name: False
+                }
+            }
+        }
+        self.update(section_name, data)

jupyter_server/extension/manager.py

@@ -84,12 +84,7 @@ def module(self):
         """
         return self._module
 
-    def link(self, serverapp):
-        """Link the extension to a Jupyter ServerApp object.
-
-        This looks for a `_link_jupyter_server_extension` function
-        in the extension's module or ExtensionApp class.
-        """
+    def _get_linker(self):
         if self.app:
             linker = self.app._link_jupyter_server_extension
         else:
@@ -100,24 +95,39 @@ def link(self, serverapp):
                 # Otherwise return a dummy function.
                 lambda serverapp: None
             )
+        return linker
+
+    def _get_loader(self):
+        loc = self.app
+        if not loc:
+            loc = self.module
+        loader = get_loader(loc)
+        return loader
 
-        # Capture output to return
-        out = linker(serverapp)
-        # Store that this extension has been linked
-        return out
+    def validate(self):
+        """Check that both a linker and loader exists."""
+        try:
+            self.get_linker()
+            self.get_loader()
+        except Exception:
+            return False
+
+    def link(self, serverapp):
+        """Link the extension to a Jupyter ServerApp object.
+
+        This looks for a `_link_jupyter_server_extension` function
+        in the extension's module or ExtensionApp class.
+        """
+        linker = self.get_linker()
+        return linker(serverapp)
 
     def load(self, serverapp):
         """Load the extension in a Jupyter ServerApp object.
 
         This looks for a `_load_jupyter_server_extension` function
         in the extension's module or ExtensionApp class.
         """
-        # Use the ExtensionApp object to find a loading function
-        # if it exists. Otherwise, use the extension module given.
-        loc = self.app
-        if not loc:
-            loc = self.module
-        loader = get_loader(loc)
+        loader = self.get_loader()
         return loader(serverapp)
 
 
@@ -143,7 +153,7 @@ def _validate_name(self, proposed):
         name = proposed['value']
         self._extension_points = {}
         try:
-            self._metadata = get_metadata(name)
+            self._module, self._metadata = get_metadata(name)
         except ImportError:
             raise ExtensionModuleNotFound(
                 "The module '{name}' could not be found. Are you "
@@ -155,6 +165,16 @@ def _validate_name(self, proposed):
             self._extension_points[point.name] = point
         return name
 
+    @property
+    def module(self):
+        """Extension metadata loaded from the extension package."""
+        return self._module
+
+    @property
+    def version(self):
+        """Get the version of this package, if it's given. Otherwise, return an empty string"""
+        return getattr(self._module, "__version__", "")
+
     @property
     def metadata(self):
         """Extension metadata loaded from the extension package."""
@@ -165,6 +185,13 @@ def extension_points(self):
         """A dictionary of extension points."""
         return self._extension_points
 
+    def validate(self):
+        """Validate all extension points in this package."""
+        for extension in self.extensions_points:
+            if not extension.validate():
+                return False
+        return True
+
     def link_point(self, point_name, serverapp):
         linked = self._linked_points.get(point_name, False)
         if not linked:
@@ -191,7 +218,8 @@ class ExtensionManager(LoggingConfigurable):
     Usage:
     m = ExtensionManager(jpserver_extensions=extensions)
     """
-    def __init__(self, *args, **kwargs):
+    def __init__(self, config_manager=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         # The `enabled_extensions` attribute provides a dictionary
         # with extension (package) names mapped to their ExtensionPackage interface
         # (see above). This manager simplifies the interaction between the
@@ -202,7 +230,9 @@ def __init__(self, *args, **kwargs):
         # extensions from being re-linked recursively unintentionally if another
         # extension attempts to link extensions again.
         self._linked_extensions = {}
-        super().__init__(*args, **kwargs)
+        self._config_manager = config_manager
+        if self._config_manager:
+            self.from_config_manager
 
     @property
     def enabled_extensions(self):
@@ -221,6 +251,12 @@ def extension_points(self):
             for name, point in value.extension_points.items()
         }
 
+    def from_config_manager(self, config_manager):
+        """Add extensions found by an ExtensionConfigManager"""
+        self._config_manager = config_manager
+        jpserver_extensions = self._config_manager.get_jpserver_extensions()
+        self.from_jpserver_extensions(jpserver_extensions)
+
     def from_jpserver_extensions(self, jpserver_extensions):
         """Add extensions from 'jpserver_extensions'-like dictionary."""
         for name, enabled in jpserver_extensions.items():

jupyter_server/extension/utils.py

@@ -17,13 +17,6 @@ class NotAnExtensionApp(Exception):
     pass
 
 
-def get_extension_app_pkg(app_cls):
-    """Get the Python package name
-    """
-    if not isinstance(app_cls, "ExtensionApp"):
-        raise NotAnExtensionApp("The ")
-
-
 def get_loader(obj, logger=None):
     """Looks for _load_jupyter_server_extension as an attribute
     of the object or module.
@@ -61,7 +54,7 @@ def get_metadata(package_name, logger=None):
     # _jupyter_server_extension_paths. We will remove in
     # a later release of Jupyter Server.
     try:
-        return module._jupyter_server_extension_paths()
+        return module, module._jupyter_server_extension_paths()
     except AttributeError:
         if logger:
             logger.debug(
@@ -82,7 +75,7 @@ def get_metadata(package_name, logger=None):
             "for extension points in the extension pacakge's "
             "root.".format(name=package_name)
         )
-    return [{
+    return module, [{
         "module": package_name,
         "name": package_name
     }]

jupyter_server/serverapp.py

@@ -102,6 +102,7 @@
 
 from jupyter_server.extension.serverextension import ServerExtensionApp
 from jupyter_server.extension.manager import ExtensionManager
+from jupyter_server.extension.config import ExtensionConfigManager
 
 #-----------------------------------------------------------------------------
 # Module globals
@@ -1481,13 +1482,12 @@ def find_server_extensions(self):
         # This enables merging on keys, which we want for extension enabling.
         # Regular config loading only merges at the class level,
         # so each level clobbers the previous.
-        config_path = jupyter_config_path()
-        if self.config_dir not in config_path:
+        config_paths = jupyter_config_path()
+        if self.config_dir not in config_paths:
             # add self.config_dir to the front, if set manually
-            config_path.insert(0, self.config_dir)
-        manager = ConfigManager(read_config_path=config_path)
-        section = manager.get(self.config_file_name)
-        extensions = section.get('ServerApp', {}).get('jpserver_extensions', {})
+            config_paths.insert(0, self.config_dir)
+        manager = ExtensionConfigManager(config_paths=config_paths)
+        extensions = manager.get_jpserver_extensions()
 
         for modulename, enabled in sorted(extensions.items()):
             if modulename not in self.jpserver_extensions:

tests/extension/test_config.py

@@ -0,0 +1,61 @@
+import pytest
+
+from jupyter_core.paths import jupyter_config_path
+from jupyter_server.extension.config import (
+    ExtensionConfigManager,
+)
+
+# Use ServerApps environment because it monkeypatches
+# jupyter_core.paths and provides a config directory
+# that's not cross contaminating the user config directory.
+pytestmark = pytest.mark.usefixtures("environ")
+
+
+@pytest.fixture
+def configd(env_config_path):
+    """A pathlib.Path object that acts like a jupyter_server_config.d folder."""
+    configd = env_config_path.joinpath('jupyter_server_config.d')
+    configd.mkdir()
+    return configd
+
+
+ext1_json_config = """\
+{
+    "ServerApp": {
+        "jpserver_extensions": {
+            "ext1_config": true
+        }
+    }
+}
+"""
+
+@pytest.fixture
+def ext1_config(configd):
+    config = configd.joinpath("ext1_config.json")
+    config.write_text(ext1_json_config)
+
+
+ext2_json_config = """\
+{
+    "ServerApp": {
+        "jpserver_extensions": {
+            "ext2_config": false
+        }
+    }
+}
+"""
+
+
+@pytest.fixture
+def ext2_config(configd):
+    config = configd.joinpath("ext2_config.json")
+    config.write_text(ext2_json_config)
+
+
+def test_list_extension_from_configd(ext1_config, ext2_config):
+    manager = ExtensionConfigManager(
+        read_config_path=jupyter_config_path()
+    )
+    extensions = manager.get_jpserver_extensions()
+    assert "ext2_config" in extensions
+    assert "ext1_config" in extensions

tests/extension/test_utils.py

@@ -8,7 +8,6 @@
 pytestmark = pytest.mark.usefixtures("environ")
 
 
-
 def test_validate_extension():
     # enabled at sys level
     assert validate_extension('tests.extension.mockextensions.mockext_sys')