File Editor Configurations changes

docs/source/examples/Notebook/Working With Markdown Cells.ipynb

@@ -175,18 +175,22 @@
     "Courtesy of MathJax, you can include mathematical expressions both inline: \n",
     "$e^{i\\pi} + 1 = 0$  and displayed:\n",
     "\n",
-    "$$e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i$$\n",
+    "\\begin{equation}\n",
+    "e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i\n",
+    "\\end{equation}\n",
     "\n",
     "Inline expressions can be added by surrounding the latex code with `$`:\n",
     "\n",
     "```\n",
     "$e^{i\\pi} + 1 = 0$\n",
     "```\n",
     "\n",
-    "Expressions on their own line are surrounded by `$$`:\n",
+    "Expressions on their own line are surrounded by `\\begin{equation}` and `\\end{equation}`:\n",
     "\n",
     "```latex\n",
-    "$$e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i$$\n",
+    "\\begin{equation}\n",
+    "e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i\n",
+    "\\end{equation}\n",
     "```"
    ]
   },

docs/source/frontend_config.rst

@@ -48,6 +48,18 @@ to reissue the patch on new notebooks.
 <https://codemirror.net/doc/manual.html#option_indentUnit>`_ which are available
 for configuration.
 
+You can similarly change the options of the file editor by entering the following
+snippet in the browser's Javascript console once (from a file editing page).::
+
+   var config = Jupyter.editor.config
+   var patch = {
+         Editor: {
+           codemirror_options: {
+             indentUnit: 2
+           }
+         }
+       }
+   config.update(patch)
 
 Example - Restoring the notebook's default indentation
 ------------------------------------------------------

notebook/base/handlers.py

@@ -404,6 +404,10 @@ def check_referer(self):
         Used on GET for api endpoints and /files/
         to block cross-site inclusion (XSSI).
         """
+
+        if self.allow_origin == "*" or self.skip_check_origin():
+            return True
+
         host = self.request.headers.get("Host")
         referer = self.request.headers.get("Referer")
 

notebook/notebookapp.py

@@ -2041,7 +2041,7 @@ def init_shutdown_no_activity(self):
     def _init_asyncio_patch(self):
         """set default asyncio policy to be compatible with tornado
 
-        Tornado 6 (at least) is not compatible with the default
+        Tornado <6.1 is not compatible with the default
         asyncio implementation on Windows
 
         Pick the older SelectorEventLoopPolicy on Windows
@@ -2054,7 +2054,7 @@ def _init_asyncio_patch(self):
         FIXME: if/when tornado supports the defaults in asyncio,
                remove and bump tornado requirement for py38
         """
-        if sys.platform.startswith("win") and sys.version_info >= (3, 8):
+        if sys.platform.startswith("win") and sys.version_info >= (3, 8) and tornado.version_info < (6, 1):
             import asyncio
             try:
                 from asyncio import (

notebook/services/contents/fileio.py

@@ -183,7 +183,7 @@ class FileManagerMixin(Configurable):
     Classes using this mixin must provide the following attributes:
 
     root_dir : unicode
-        A directory against against which API-style paths are to be resolved.
+        A directory against which API-style paths are to be resolved.
 
     log : logging.Logger
     """

notebook/services/kernels/handlers.py

@@ -123,11 +123,125 @@ def __repr__(self):
     def create_stream(self):
         km = self.kernel_manager
         identity = self.session.bsession
-        for channel in ('shell', 'control', 'iopub', 'stdin'):
-            meth = getattr(km, 'connect_' + channel)
+        for channel in ("iopub", "shell", "control", "stdin"):
+            meth = getattr(km, "connect_" + channel)
             self.channels[channel] = stream = meth(self.kernel_id, identity=identity)
             stream.channel = channel
 
+    def nudge(self):
+        """Nudge the zmq connections with kernel_info_requests
+
+        Returns a Future that will resolve when we have received
+        a shell reply and at least one iopub message,
+        ensuring that zmq subscriptions are established,
+        sockets are fully connected, and kernel is responsive.
+
+        Keeps retrying kernel_info_request until these are both received.
+        """
+        kernel = self.kernel_manager.get_kernel(self.kernel_id)
+
+        # Do not nudge busy kernels as kernel info requests sent to shell are
+        # queued behind execution requests.
+        # nudging in this case would cause a potentially very long wait
+        # before connections are opened,
+        # plus it is *very* unlikely that a busy kernel will not finish
+        # establishing its zmq subscriptions before processing the next request.
+        if getattr(kernel, "execution_state") == "busy":
+            self.log.debug("Nudge: not nudging busy kernel %s", self.kernel_id)
+            f = Future()
+            f.set_result(None)
+            return f
+
+        # Use a transient shell channel to prevent leaking
+        # shell responses to the front-end.
+        shell_channel = kernel.connect_shell()
+        # The IOPub used by the client, whose subscriptions we are verifying.
+        iopub_channel = self.channels["iopub"]
+
+        info_future = Future()
+        iopub_future = Future()
+        both_done = gen.multi([info_future, iopub_future])
+
+        def finish(f=None):
+            """Ensure all futures are resolved
+
+            which in turn triggers cleanup
+            """
+            for f in (info_future, iopub_future):
+                if not f.done():
+                    f.set_result(None)
+
+        def cleanup(f=None):
+            """Common cleanup"""
+            loop.remove_timeout(nudge_handle)
+            iopub_channel.stop_on_recv()
+            if not shell_channel.closed():
+                shell_channel.close()
+
+        # trigger cleanup when both message futures are resolved
+        both_done.add_done_callback(cleanup)
+
+        def on_shell_reply(msg):
+            self.log.debug("Nudge: shell info reply received: %s", self.kernel_id)
+            if not info_future.done():
+                self.log.debug("Nudge: resolving shell future: %s", self.kernel_id)
+                info_future.set_result(None)
+
+        def on_iopub(msg):
+            self.log.debug("Nudge: IOPub received: %s", self.kernel_id)
+            if not iopub_future.done():
+                iopub_channel.stop_on_recv()
+                self.log.debug("Nudge: resolving iopub future: %s", self.kernel_id)
+                iopub_future.set_result(None)
+
+        iopub_channel.on_recv(on_iopub)
+        shell_channel.on_recv(on_shell_reply)
+        loop = IOLoop.current()
+
+        # Nudge the kernel with kernel info requests until we get an IOPub message
+        def nudge(count):
+            count += 1
+
+            # NOTE: this close check appears to never be True during on_open,
+            # even when the peer has closed the connection
+            if self.ws_connection is None or self.ws_connection.is_closing():
+                self.log.debug(
+                    "Nudge: cancelling on closed websocket: %s", self.kernel_id
+                )
+                finish()
+                return
+
+            # check for stopped kernel
+            if self.kernel_id not in self.kernel_manager:
+                self.log.debug(
+                    "Nudge: cancelling on stopped kernel: %s", self.kernel_id
+                )
+                finish()
+                return
+
+            # check for closed zmq socket
+            if shell_channel.closed():
+                self.log.debug(
+                    "Nudge: cancelling on closed zmq socket: %s", self.kernel_id
+                )
+                finish()
+                return
+
+            if not both_done.done():
+                log = self.log.warning if count % 10 == 0 else self.log.debug
+                log("Nudge: attempt %s on kernel %s" % (count, self.kernel_id))
+                self.session.send(shell_channel, "kernel_info_request")
+                nonlocal nudge_handle
+                nudge_handle = loop.call_later(0.5, nudge, count)
+
+        nudge_handle = loop.call_later(0, nudge, count=0)
+
+        # resolve with a timeout if we get no response
+        future = gen.with_timeout(loop.time() + self.kernel_info_timeout, both_done)
+        # ensure we have no dangling resources or unresolved Futures in case of timeout
+        future.add_done_callback(finish)
+        return future
+
     def request_kernel_info(self):
         """send a request for kernel_info"""
         km = self.kernel_manager
@@ -150,7 +264,7 @@ def request_kernel_info(self):
                 self.log.debug("Waiting for pending kernel_info request")
             future.add_done_callback(lambda f: self._finish_kernel_info(f.result()))
         return self._kernel_info_future
-    
+
     def _handle_kernel_info_reply(self, msg):
         """process the kernel_info_reply
 
@@ -263,15 +377,21 @@ def open(self, kernel_id):
         if buffer_info and buffer_info['session_key'] == self.session_key:
             self.log.info("Restoring connection for %s", self.session_key)
             self.channels = buffer_info['channels']
-            replay_buffer = buffer_info['buffer']
-            if replay_buffer:
-                self.log.info("Replaying %s buffered messages", len(replay_buffer))
-                for channel, msg_list in replay_buffer:
-                    stream = self.channels[channel]
-                    self._on_zmq_reply(stream, msg_list)
+            connected = self.nudge()
+
+            def replay(value):
+                replay_buffer = buffer_info['buffer']
+                if replay_buffer:
+                    self.log.info("Replaying %s buffered messages", len(replay_buffer))
+                    for channel, msg_list in replay_buffer:
+                        stream = self.channels[channel]
+                        self._on_zmq_reply(stream, msg_list)
+
+            connected.add_done_callback(replay)
         else:
             try:
                 self.create_stream()
+                connected = self.nudge()
             except web.HTTPError as e:
                 self.log.error("Error opening stream: %s", e)
                 # WebSockets don't response to traditional error codes so we
@@ -285,8 +405,13 @@ def open(self, kernel_id):
         km.add_restart_callback(self.kernel_id, self.on_kernel_restarted)
         km.add_restart_callback(self.kernel_id, self.on_restart_failed, 'dead')
 
-        for channel, stream in self.channels.items():
-            stream.on_recv_stream(self._on_zmq_reply)
+        def subscribe(value):
+            for channel, stream in self.channels.items():
+                stream.on_recv_stream(self._on_zmq_reply)
+
+        connected.add_done_callback(subscribe)
+
+        return connected
 
     def on_message(self, msg):
         if not self.channels:

notebook/tests/services/kernel.js

@@ -242,8 +242,9 @@ casper.notebook_test(function () {
             'kernel_disconnected.Kernel',
             'kernel_reconnecting.Kernel',
             'kernel_connected.Kernel',
-            'kernel_busy.Kernel',
-            'kernel_idle.Kernel'
+            // note: there will be a 'busy' in here, too,
+            // but we can't guarantee which will come first
+            'kernel_idle.Kernel',
         ],
         function () {
             this.thenEvaluate(function () {
@@ -262,8 +263,7 @@ casper.notebook_test(function () {
             'kernel_connection_failed.Kernel',
             'kernel_reconnecting.Kernel',
             'kernel_connected.Kernel',
-            'kernel_busy.Kernel',
-            'kernel_idle.Kernel'
+            'kernel_idle.Kernel',
         ],
         function () {
             this.thenEvaluate(function () {