Terminate all terminals on server shutdown

Author: kevin-bates

jupyter_server/serverapp.py

@@ -1847,6 +1847,22 @@ def cleanup_kernels(self):
         self.log.info(kernel_msg % n_kernels)
         run_sync(self.kernel_manager.shutdown_all())
 
+    def cleanup_terminals(self):
+        """Shutdown all terminals.
+
+        The terminals will shutdown themselves when this process no longer exists,
+        but explicit shutdown allows the TerminalManager to cleanup.
+        """
+        try:
+            terminal_manager = self.web_app.settings['terminal_manager']
+        except KeyError:
+            return  # Terminals not enabled
+
+        n_terminals = len(terminal_manager.list())
+        terminal_msg = trans.ngettext('Shutting down %d terminal', 'Shutting down %d terminals', n_terminals)
+        self.log.info(terminal_msg % n_terminals)
+        run_sync(terminal_manager.terminate_all())
+
     def running_server_info(self, kernel_count=True):
         "Return the current working directory and the server url information"
         info = self.contents_manager.info_string() + "\n"
@@ -2077,6 +2093,7 @@ def _cleanup(self):
         self.remove_server_info_file()
         self.remove_browser_open_files()
         self.cleanup_kernels()
+        self.cleanup_terminals()
 
     def start_ioloop(self):
         """Start the IO Loop."""

jupyter_server/terminal/terminalmanager.py

@@ -8,7 +8,7 @@
 
 
 from datetime import timedelta
-from notebook._tz import utcnow, isoformat
+from jupyter_server._tz import utcnow, isoformat
 from terminado import NamedTermManager
 from tornado import web
 from tornado.ioloop import IOLoop, PeriodicCallback
@@ -40,8 +40,9 @@ class TerminalManager(Configurable, NamedTermManager):
     def __init__(self, *args, **kwargs):
         super(TerminalManager, self).__init__(*args, **kwargs)
 
-    def create(self):
-        name, term = self.new_named_terminal()
+    def create(self, **kwargs):
+        """Create a new terminal."""
+        name, term = self.new_named_terminal(**kwargs)
         # Monkey-patch last-activity, similar to kernels.  Should we need
         # more functionality per terminal, we can look into possible sub-
         # classing or containment then.
@@ -50,14 +51,16 @@ def create(self):
         # Increase the metric by one because a new terminal was created
         TERMINAL_CURRENTLY_RUNNING_TOTAL.inc()
         # Ensure culler is initialized
-        self.initialize_culler()
+        self._initialize_culler()
         return model
 
     def get(self, name):
+        """Get terminal 'name'."""
         model = self.terminal_model(name)
         return model
 
     def list(self):
+        """Get a list of all running terminals."""
         models = [self.terminal_model(name) for name in self.terminals]
 
         # Update the metric below to the length of the list 'terms'
@@ -67,13 +70,20 @@ def list(self):
         return models
 
     async def terminate(self, name, force=False):
+        """Terminate terminal 'name'."""
         self._check_terminal(name)
         await super(TerminalManager, self).terminate(name, force=force)
 
         # Decrease the metric below by one
         # because a terminal has been shutdown
         TERMINAL_CURRENTLY_RUNNING_TOTAL.dec()
 
+    async def terminate_all(self):
+        """Terminate all terminals."""
+        terms = [name for name in self.terminals]
+        for term in terms:
+            await self.terminate(term, force=True)
+
     def terminal_model(self, name):
         """Return a JSON-safe dict representing a terminal.
         For use in representing terminals in the JSON APIs.
@@ -91,7 +101,7 @@ def _check_terminal(self, name):
         if name not in self.terminals:
             raise web.HTTPError(404, u'Terminal not found: %s' % name)
 
-    def initialize_culler(self):
+    def _initialize_culler(self):
         """Start culler if 'cull_inactive_timeout' is greater than zero.
         Regardless of that value, set flag that we've been here.
         """
@@ -103,25 +113,25 @@ def initialize_culler(self):
                         self.cull_interval, self.cull_interval_default)
                     self.cull_interval = self.cull_interval_default
                 self._culler_callback = PeriodicCallback(
-                    self.cull_terminals, 1000*self.cull_interval)
+                    self._cull_terminals, 1000 * self.cull_interval)
                 self.log.info("Culling terminals with inactivity > %s seconds at %s second intervals ...",
                               self.cull_inactive_timeout, self.cull_interval)
                 self._culler_callback.start()
 
         self._initialized_culler = True
 
-    async def cull_terminals(self):
+    async def _cull_terminals(self):
         self.log.debug("Polling every %s seconds for terminals inactive for > %s seconds...",
                        self.cull_interval, self.cull_inactive_timeout)
         # Create a separate list of terminals to avoid conflicting updates while iterating
         for name in list(self.terminals):
             try:
-                await self.cull_inactive_terminal(name)
+                await self._cull_inactive_terminal(name)
             except Exception as e:
                 self.log.exception("The following exception was encountered while checking the "
                                    "activity of terminal {}: {}".format(name, e))
 
-    async def cull_inactive_terminal(self, name):
+    async def _cull_inactive_terminal(self, name):
         try:
             term = self.terminals[name]
         except KeyError: