Rename GatewayKernelManager to GatewayKernelManagers

Author: kevin-bates

docs/source/other/full-config.rst

@@ -1178,19 +1178,19 @@ NotebookNotary.store_factory : Callable
     A callable returning the storage backend for notebook signatures.
     The default uses an SQLite database.
 
-GatewayKernelManager.allow_tracebacks : Bool
+GatewayKernelManagers.allow_tracebacks : Bool
     Default: ``True``
 
     Whether to send tracebacks to clients on exceptions.
 
-GatewayKernelManager.allowed_message_types : List
+GatewayKernelManagers.allowed_message_types : List
     Default: ``[]``
 
     White list of allowed kernel message types.
     When the list is empty, all message types are allowed.
 
 
-GatewayKernelManager.buffer_offline_messages : Bool
+GatewayKernelManagers.buffer_offline_messages : Bool
     Default: ``True``
 
     Whether messages from kernels whose frontends have disconnected should be buffered in-memory.
@@ -1202,36 +1202,36 @@ GatewayKernelManager.buffer_offline_messages : Bool
     no frontends are connected.
 
 
-GatewayKernelManager.cull_busy : Bool
+GatewayKernelManagers.cull_busy : Bool
     Default: ``False``
 
     Whether to consider culling kernels which are busy.
     Only effective if cull_idle_timeout > 0.
 
-GatewayKernelManager.cull_connected : Bool
+GatewayKernelManagers.cull_connected : Bool
     Default: ``False``
 
     Whether to consider culling kernels which have one or more connections.
     Only effective if cull_idle_timeout > 0.
 
-GatewayKernelManager.cull_idle_timeout : Int
+GatewayKernelManagers.cull_idle_timeout : Int
     Default: ``0``
 
     Timeout (in seconds) after which a kernel is considered idle and ready to be culled.
     Values of 0 or lower disable culling. Very short timeouts may result in kernels being culled
     for users with poor network connections.
 
-GatewayKernelManager.cull_interval : Int
+GatewayKernelManagers.cull_interval : Int
     Default: ``300``
 
     The interval (in seconds) on which to check for idle kernels exceeding the cull timeout value.
 
-GatewayKernelManager.default_kernel_name : Unicode
+GatewayKernelManagers.default_kernel_name : Unicode
     Default: ``'python3'``
 
     The name of the default kernel to start
 
-GatewayKernelManager.kernel_info_timeout : Float
+GatewayKernelManagers.kernel_info_timeout : Float
     Default: ``60``
 
     Timeout for giving up on a kernel (in seconds).
@@ -1244,24 +1244,24 @@ GatewayKernelManager.kernel_info_timeout : Float
     and the ZMQChannelsHandler (which handles the startup).
 
 
-GatewayKernelManager.kernel_manager_class : DottedObjectName
+GatewayKernelManagers.kernel_manager_class : DottedObjectName
     Default: ``'jupyter_client.ioloop.IOLoopKernelManager'``
 
     The kernel manager class.  This is configurable to allow
     subclassing of the KernelManager for customized behavior.
 
 
-GatewayKernelManager.root_dir : Unicode
+GatewayKernelManagers.root_dir : Unicode
     Default: ``''``
 
     No description
 
-GatewayKernelManager.shared_context : Bool
+GatewayKernelManagers.shared_context : Bool
     Default: ``True``
 
     Share a single zmq.Context to talk to all my kernels
 
-GatewayKernelManager.traceback_replacement_message : Unicode
+GatewayKernelManagers.traceback_replacement_message : Unicode
     Default: ``'An exception occurred at runtime, which is not shown due to ...``
 
     Message to print when allow_tracebacks is False, and an exception occurs

jupyter_server/gateway/managers.py

@@ -329,14 +329,14 @@ async def gateway_request(endpoint, **kwargs):
     return response
 
 
-class GatewayKernelManager(AsyncMappingKernelManager):
+class GatewayKernelManagers(AsyncMappingKernelManager):
     """Kernel manager that supports remote kernels hosted by Jupyter Kernel or Enterprise Gateway."""
 
     # We'll maintain our own set of kernel ids
     _kernels = {}
 
     def __init__(self, **kwargs):
-        super(GatewayKernelManager, self).__init__(**kwargs)
+        super(GatewayKernelManagers, self).__init__(**kwargs)
         self.base_endpoint = url_path_join(GatewayClient.instance().url, GatewayClient.instance().kernels_endpoint)
 
     def __contains__(self, kernel_id):
@@ -634,7 +634,7 @@ async def get_kernel_spec_resource(self, kernel_name, path):
 
 
 class GatewaySessionManager(SessionManager):
-    kernel_manager = Instance('jupyter_server.gateway.managers.GatewayKernelManager')
+    kernel_manager = Instance('jupyter_server.gateway.managers.GatewayKernelManagers')
 
     async def kernel_culled(self, kernel_id):
         """Checks if the kernel is still considered alive and returns true if its not found. """

jupyter_server/serverapp.py

@@ -75,7 +75,7 @@
 from jupyter_server.services.contents.filemanager import AsyncFileContentsManager, FileContentsManager
 from jupyter_server.services.contents.largefilemanager import LargeFileManager
 from jupyter_server.services.sessions.sessionmanager import SessionManager
-from jupyter_server.gateway.managers import GatewayKernelManager, GatewayKernelSpecManager, GatewaySessionManager, GatewayClient
+from jupyter_server.gateway.managers import GatewayKernelManagers, GatewayKernelSpecManager, GatewaySessionManager, GatewayClient
 
 from jupyter_server.auth.login import LoginHandler
 from jupyter_server.auth.logout import LogoutHandler
@@ -593,7 +593,7 @@ class ServerApp(JupyterApp):
     classes = [
             KernelManager, Session, MappingKernelManager, KernelSpecManager, AsyncMappingKernelManager,
             ContentsManager, FileContentsManager, AsyncContentsManager, AsyncFileContentsManager, NotebookNotary,
-            GatewayKernelManager, GatewayKernelSpecManager, GatewaySessionManager, GatewayClient
+            GatewayKernelManagers, GatewayKernelSpecManager, GatewaySessionManager, GatewayClient
         ]
     if terminado_available:  # Only necessary when terminado is available
         classes.append(TerminalManager)
@@ -1408,7 +1408,7 @@ def init_configurables(self):
         self.gateway_config = GatewayClient.instance(parent=self)
 
         if self.gateway_config.gateway_enabled:
-            self.kernel_manager_class = 'jupyter_server.gateway.managers.GatewayKernelManager'
+            self.kernel_manager_class = 'jupyter_server.gateway.managers.GatewayKernelManagers'
             self.session_manager_class = 'jupyter_server.gateway.managers.GatewaySessionManager'
             self.kernel_spec_manager_class = 'jupyter_server.gateway.managers.GatewayKernelSpecManager'
 

jupyter_server/tests/test_gateway.py

@@ -179,7 +179,7 @@ async def test_gateway_cli_options(jp_configurable_serverapp):
 
 async def test_gateway_class_mappings(init_gateway, jp_serverapp):
     # Ensure appropriate class mappings are in place.
-    assert jp_serverapp.kernel_manager_class.__name__ == 'GatewayKernelManager'
+    assert jp_serverapp.kernel_manager_class.__name__ == 'GatewayKernelManagers'
     assert jp_serverapp.session_manager_class.__name__ == 'GatewaySessionManager'
     assert jp_serverapp.kernel_spec_manager_class.__name__ == 'GatewayKernelSpecManager'