leverage the extension manager for enabling/disabling

Author: Zsailer

jupyter_server/config_manager.py

@@ -118,7 +118,6 @@ def set(self, section_name, data):
         # Generate the JSON up front, since it could raise an exception,
         # in order to avoid writing half-finished corrupted data to disk.
         json_content = json.dumps(data, indent=2)
-
         if PY3:
             f = io.open(filename, 'w', encoding='utf-8')
         else:

jupyter_server/extension/config.py

@@ -36,30 +36,22 @@ def enabled(
         except KeyError:
             return False
 
-    def enable(
-        self,
-        name,
-        section_name=DEFAULT_SECTION_NAME,
-    ):
+    def enable(self, name):
         data = {
             "ServerApp": {
                 "jpserver_extensions": {
                     name: True
                 }
             }
         }
-        self.update(section_name, data)
+        self.update(name, data)
 
-    def disable(
-        self,
-        name,
-        section_name=DEFAULT_SECTION_NAME
-    ):
+    def disable(self, name):
         data = {
             "ServerApp": {
                 "jpserver_extensions": {
                     name: False
                 }
             }
         }
-        self.update(section_name, data)
+        self.update(name, data)

jupyter_server/extension/manager.py

@@ -5,6 +5,7 @@
     HasTraits,
     Dict,
     Unicode,
+    Bool,
     validate
 )
 
@@ -107,8 +108,8 @@ def _get_loader(self):
     def validate(self):
         """Check that both a linker and loader exists."""
         try:
-            self.get_linker()
-            self.get_loader()
+            self._get_linker()
+            self._get_loader()
         except Exception:
             return False
 
@@ -118,7 +119,7 @@ def link(self, serverapp):
         This looks for a `_link_jupyter_server_extension` function
         in the extension's module or ExtensionApp class.
         """
-        linker = self.get_linker()
+        linker = self._get_linker()
         return linker(serverapp)
 
     def load(self, serverapp):
@@ -127,7 +128,7 @@ def load(self, serverapp):
         This looks for a `_load_jupyter_server_extension` function
         in the extension's module or ExtensionApp class.
         """
-        loader = self.get_loader()
+        loader = self._get_loader()
         return loader(serverapp)
 
 
@@ -140,6 +141,7 @@ class ExtensionPackage(HasTraits):
     extpkg = ExtensionPackage(name=ext_name)
     """
     name = Unicode(help="Name of the an importable Python package.")
+    enabled = Bool(False).tag(config=True)
 
     def __init__(self, *args, **kwargs):
         # Store extension points that have been linked.
@@ -187,7 +189,7 @@ def extension_points(self):
 
     def validate(self):
         """Validate all extension points in this package."""
-        for extension in self.extensions_points:
+        for extension in self.extension_points.values():
             if not extension.validate():
                 return False
         return True
@@ -224,27 +226,27 @@ def __init__(self, config_manager=None, *args, **kwargs):
         # with extension (package) names mapped to their ExtensionPackage interface
         # (see above). This manager simplifies the interaction between the
         # ServerApp and the extensions being appended.
-        self._enabled_extensions = {}
+        self._extensions = {}
         # The `_linked_extensions` attribute tracks when each extension
         # has been successfully linked to a ServerApp. This helps prevent
         # extensions from being re-linked recursively unintentionally if another
         # extension attempts to link extensions again.
         self._linked_extensions = {}
         self._config_manager = config_manager
         if self._config_manager:
-            self.from_config_manager
+            self.from_config_manager(self._config_manager)
 
     @property
-    def enabled_extensions(self):
+    def extensions(self):
         """Dictionary with extension package names as keys
         and an ExtensionPackage objects as values.
         """
         # Sort enabled extensions before
-        return self._enabled_extensions
+        return self._extensions
 
     @property
     def extension_points(self):
-        extensions = self.enabled_extensions
+        extensions = self.extensions
         return {
             name: point
             for value in extensions.values()
@@ -260,42 +262,42 @@ def from_config_manager(self, config_manager):
     def from_jpserver_extensions(self, jpserver_extensions):
         """Add extensions from 'jpserver_extensions'-like dictionary."""
         for name, enabled in jpserver_extensions.items():
-            if enabled:
-                self.add_extension(name)
+            self.add_extension(name, enabled=enabled)
 
-    def add_extension(self, extension_name):
+    def add_extension(self, extension_name, enabled=False):
         try:
-            extpkg = ExtensionPackage(name=extension_name)
-            self._enabled_extensions[extension_name] = extpkg
-            # Raise a warning if the extension cannot be loaded.
+            extpkg = ExtensionPackage(name=extension_name, enabled=enabled)
+            self._extensions[extension_name] = extpkg
+        # Raise a warning if the extension cannot be loaded.
         except Exception as e:
             self.log.warning(e)
 
     def link_extension(self, name, serverapp):
         linked = self._linked_extensions.get(name, False)
-        extension = self.enabled_extensions[name]
-        if not linked:
+        extension = self.extensions[name]
+        if not linked and extension.enabled:
             try:
                 extension.link_all_points(serverapp)
                 self.log.info("{name} | extension was successfully linked.".format(name=name))
             except Exception as e:
                 self.log.warning(e)
 
     def load_extension(self, name, serverapp):
-        extension = self.enabled_extensions.get(name)
-        try:
-            extension.load_all_points(serverapp)
-            self.log.info("{name} | extension was successfully loaded.".format(name=name))
-        except Exception as e:
-            self.log.warning(e)
+        extension = self.extensions.get(name)
+        if extension.enabled:
+            try:
+                extension.load_all_points(serverapp)
+                self.log.info("{name} | extension was successfully loaded.".format(name=name))
+            except Exception as e:
+                self.log.warning(e)
 
     def link_all_extensions(self, serverapp):
         """Link all enabled extensions
         to an instance of ServerApp
         """
         # Sort the extension names to enforce deterministic linking
         # order.
-        for name in sorted(self.enabled_extensions.keys()):
+        for name in sorted(self.extensions.keys()):
             self.link_extension(name, serverapp)
 
     def load_all_extensions(self, serverapp):
@@ -304,6 +306,6 @@ def load_all_extensions(self, serverapp):
         """
         # Sort the extension names to enforce deterministic loading
         # order.
-        for name in sorted(self.enabled_extensions.keys()):
+        for name in sorted(self.extensions.keys()):
             self.load_extension(name, serverapp)