Reliable list_running_servers(runtime_dir) design

notebook/notebookapp.py

@@ -429,20 +429,10 @@ def start(self):
         self.log.info("Wrote hashed password to %s" % self.config_file)
 
 
-def shutdown_server(server_info, timeout=5, log=None):
-    """Shutdown a notebook server in a separate process.
-
-    *server_info* should be a dictionary as produced by list_running_servers().
-
-    Will first try to request shutdown using /api/shutdown .
-    On Unix, if the server is still running after *timeout* seconds, it will
-    send SIGTERM. After another timeout, it escalates to SIGKILL.
-
-    Returns True if the server was stopped by any means, False if stopping it
-    failed (on Windows).
-    """
+def kernel_request(server_info, path='/login', method='GET', body=None, headers=None, timeout=5, log=None):
+    """query a notebook server in a separate process."""
     from tornado import gen
-    from tornado.httpclient import AsyncHTTPClient, HTTPClient, HTTPRequest
+    from tornado.httpclient import AsyncHTTPClient, HTTPClient, HTTPRequest, HTTPError
     from tornado.netutil import Resolver
     url = server_info['url']
     pid = server_info['pid']
@@ -468,12 +458,45 @@ def resolve(self, host, port, *args, **kwargs):
 
         resolver = UnixSocketResolver(resolver=Resolver())
 
-    req = HTTPRequest(url + 'api/shutdown', method='POST', body=b'', headers={
-        'Authorization': 'token ' + server_info['token']
-    })
-    if log: log.debug("POST request to %sapi/shutdown", url)
-    AsyncHTTPClient.configure(None, resolver=resolver)
-    HTTPClient(AsyncHTTPClient).fetch(req)
+    fullurl = urljoin(url, path)
+    headers = dict(headers) if headers is not None else {}
+    headers.setdefault('Authorization', 'token ' + server_info['token'])
+    req = HTTPRequest(fullurl,
+        method=method, body=body, headers=headers,
+        follow_redirects=True,
+        decompress_response=True,
+        allow_nonstandard_methods=False,
+        validate_cert=False
+    )
+    if log: log.debug("%s request to %s", method, fullurl)
+
+    savedAsyncHTTPClient = AsyncHTTPClient._save_configuration()
+    try:
+        AsyncHTTPClient.configure(None, resolver=resolver)
+        response = HTTPClient(AsyncHTTPClient).fetch(req)
+    except HTTPError as e:
+        if e.response is not None:
+            response = e.response
+        else:
+            raise
+    finally:
+        AsyncHTTPClient._restore_configuration(savedAsyncHTTPClient)
+
+    return response
+
+
+def shutdown_server(server_info, timeout=5, log=None):
+    """Shutdown a notebook server in a separate process.
+    *server_info* should be a dictionary as produced by list_running_servers().
+    Will first try to request shutdown using /api/shutdown .
+    On Unix, if the server is still running after *timeout* seconds, it will
+    send SIGTERM. After another timeout, it escalates to SIGKILL.
+    Returns True if the server was stopped by any means, False if stopping it
+    failed (on Windows).
+    """
+    url = server_info['url']
+    pid = server_info['pid']
+    kernel_request(server_info, path='api/shutdown', method='POST', body=b'', timeout=timeout, log=log)
 
     # Poll to see if it shut down.
     for _ in range(timeout*10):
@@ -2294,9 +2317,10 @@ def list_running_servers(runtime_dir=None):
             with io.open(os.path.join(runtime_dir, file_name), encoding='utf-8') as f:
                 info = json.load(f)
 
-            # Simple check whether that process is really still running
+            # active check whether that process is really available via real HTTP request
             # Also remove leftover files from IPython 2.x without a pid field
-            if ('pid' in info) and check_pid(info['pid']):
+            response = kernel_request(info, path='/login')
+            if response.body.find(b'<title>Jupyter Notebook</title>') > 0:
                 yield info
             else:
                 # If the process has died, try to delete its info file

notebook/tests/test_notebookapp.py

@@ -30,21 +30,40 @@ def test_help_output():
     check_help_all_output('notebook')
 
 def test_server_info_file():
+    import threading, tornado.ioloop as iom, tornado.platform.asyncio as torio
     td = TemporaryDirectory()
+
+    if iom.asyncio is not None:
+        iom.asyncio.set_event_loop_policy(torio.AnyThreadEventLoopPolicy())
+        iom.IOLoop.configure("tornado.platform.asyncio.AsyncIOLoop")
+
     nbapp = NotebookApp(runtime_dir=td.name, log=logging.getLogger())
-    def get_servers():
-        return list(notebookapp.list_running_servers(nbapp.runtime_dir))
     nbapp.initialize(argv=[])
+    nbapp.io_loop = iom.IOLoop.current()
+    nbapp.open_browser = False
+    super(NotebookApp, nbapp).start()
     nbapp.write_server_info_file()
-    servers = get_servers()
-    nt.assert_equal(len(servers), 1)
-    nt.assert_equal(servers[0]['port'], nbapp.port)
-    nt.assert_equal(servers[0]['url'], nbapp.connection_url)
-    nbapp.remove_server_info_file()
-    nt.assert_equal(get_servers(), [])
 
-    # The ENOENT error should be silenced.
-    nbapp.remove_server_info_file()
+    def check_thread():
+        try:
+            servers = list(notebookapp.list_running_servers(nbapp.runtime_dir))
+            nt.assert_equal(len(servers), 1)
+            nt.assert_equal(servers[0]['port'], nbapp.port)
+            nt.assert_equal(servers[0]['url'], nbapp.connection_url)
+        finally:
+            nbapp.stop()
+
+    nbapp.io_loop.add_callback(nbapp.io_loop.run_in_executor, executor=None, func=check_thread)
+
+    if sys.platform.startswith("win"):
+        pc = iom.PeriodicCallback(lambda: None, 5000)
+        pc.start()
+    try:
+        nbapp.io_loop.start()
+    except KeyboardInterrupt:
+        print("Interrupted...")
+    finally:
+        nbapp.remove_server_info_file()
 
 def test_nb_dir():
     with TemporaryDirectory() as td:
@@ -200,4 +219,4 @@ def test_run(self):
         def test_list_running_sock_servers(self):
             servers = list(notebookapp.list_running_servers())
             assert len(servers) >= 1
-            assert self.sock in {info['sock'] for info in servers}
+            assert self.sock in {info['sock'] for info in servers}