Adding kernel/notebook associations.

IPython/frontend/html/notebook/handlers.py

@@ -1,135 +1,160 b''
 """Tornado handlers for the notebook."""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import json
 import logging
 import urllib
 
 from tornado import web
 from tornado import websocket
 
 
 #-----------------------------------------------------------------------------
-# Handlers
+# Top-level handlers
 #-----------------------------------------------------------------------------
 
 
 class NBBrowserHandler(web.RequestHandler):
     def get(self):
         nbm = self.application.notebook_manager
         project = nbm.notebook_dir
         self.render('nbbrowser.html', project=project)
 
 
 class NewHandler(web.RequestHandler):
     def get(self):
         notebook_id = self.application.notebook_manager.new_notebook()
         self.render('notebook.html', notebook_id=notebook_id)
 
 
 class NamedNotebookHandler(web.RequestHandler):
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         if not nbm.notebook_exists(notebook_id):
             raise web.HTTPError(404)
         self.render('notebook.html', notebook_id=notebook_id)
 
 
-class KernelHandler(web.RequestHandler):
+#-----------------------------------------------------------------------------
+# Kernel handlers
+#-----------------------------------------------------------------------------
+
+
+class MainKernelHandler(web.RequestHandler):
 
     def get(self):
-        self.finish(json.dumps(self.application.kernel_ids))
+        rkm = self.application.routing_kernel_manager
+        self.finish(json.dumps(rkm.kernel_ids))
 
     def post(self):
-        kernel_id = self.application.start_kernel()
+        rkm = self.application.routing_kernel_manager
+        notebook_id = self.get_argument('notebook', default=None)
+        kernel_id = rkm.start_kernel(notebook_id)
         self.set_header('Location', '/'+kernel_id)
         self.finish(json.dumps(kernel_id))
 
 
+class KernelHandler(web.RequestHandler):
+
+    SUPPORTED_METHODS = ('DELETE')
+
+    def delete(self, kernel_id):
+        rkm = self.application.routing_kernel_manager
+        self.kill_kernel(kernel_id)
+        self.set_status(204)
+        self.finish()
+
+
 class KernelActionHandler(web.RequestHandler):
 
     def post(self, kernel_id, action):
-        # TODO: figure out a better way of handling RPC style calls.
+        rkm = self.application.routing_kernel_manager
         if action == 'interrupt':
-            self.application.interrupt_kernel(kernel_id)
+            rkm.interrupt_kernel(kernel_id)
+            self.set_status(204)
         if action == 'restart':
-            new_kernel_id = self.application.restart_kernel(kernel_id)
+            new_kernel_id = rkm.restart_kernel(kernel_id)
             self.write(json.dumps(new_kernel_id))
         self.finish()
 
 
 class ZMQStreamHandler(websocket.WebSocketHandler):
 
     def initialize(self, stream_name):
         self.stream_name = stream_name
 
     def open(self, kernel_id):
-        self.router = self.application.get_router(kernel_id, self.stream_name)
+        rkm = self.application.routing_kernel_manager
+        self.router = rkm.get_router(kernel_id, self.stream_name)
         self.client_id = self.router.register_client(self)
         logging.info("Connection open: %s, %s" % (kernel_id, self.client_id))
 
     def on_message(self, msg):
         self.router.forward_msg(self.client_id, msg)
 
     def on_close(self):
         self.router.unregister_client(self.client_id)
         logging.info("Connection closed: %s" % self.client_id)
 
 
+#-----------------------------------------------------------------------------
+# Notebook web service handlers
+#-----------------------------------------------------------------------------
+
 class NotebookRootHandler(web.RequestHandler):
 
     def get(self):
         nbm = self.application.notebook_manager
         files = nbm.list_notebooks()
         self.finish(json.dumps(files))
 
     def post(self):
         nbm = self.application.notebook_manager
         body = self.request.body.strip()
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         if body:
             notebook_id = nbm.save_new_notebook(body, name=name, format=format)
         else:
             notebook_id = nbm.new_notebook()
         self.set_header('Location', '/'+notebook_id)
         self.finish(json.dumps(notebook_id))
 
 
 class NotebookHandler(web.RequestHandler):
 
     SUPPORTED_METHODS = ('GET', 'PUT', 'DELETE')
 
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         last_mod, name, data = nbm.get_notebook(notebook_id, format)
         if format == u'json':
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename=%s.json' % name)
         elif format == u'xml':
             self.set_header('Content-Type', 'application/xml')
             self.set_header('Content-Disposition','attachment; filename=%s.ipynb' % name)
         elif format == u'py':
             self.set_header('Content-Type', 'application/x-python')
             self.set_header('Content-Disposition','attachment; filename=%s.py' % name)
         self.set_header('Last-Modified', last_mod)
         self.finish(data)
 
     def put(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         nbm.save_notebook(notebook_id, self.request.body, name=name, format=format)
         self.set_status(204)
         self.finish()
 
     def delete(self, notebook_id):
         nbm = self.application.notebook_manager
         nbm.delete_notebook(notebook_id)
         self.set_status(204)
         self.finish()
 

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,188 +1,306 b''
 """A kernel manager for multiple kernels."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import signal
 import sys
 import uuid
 
 import zmq
 
+from tornado import web
+
+from .routers import IOPubStreamRouter, ShellStreamRouter
+
 from IPython.config.configurable import LoggingConfigurable
 from IPython.zmq.ipkernel import launch_kernel
-from IPython.utils.traitlets import Instance, Dict
+from IPython.utils.traitlets import Instance, Dict, List, Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class DuplicateKernelError(Exception):
     pass
 
 
 class KernelManager(LoggingConfigurable):
     """A class for managing multiple kernels."""
 
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
 
     _kernels = Dict()
 
     @property
     def kernel_ids(self):
         """Return a list of the kernel ids of the active kernels."""
         return self._kernels.keys()
 
     def __len__(self):
         """Return the number of running kernels."""
         return len(self.kernel_ids)
 
     def __contains__(self, kernel_id):
         if kernel_id in self.kernel_ids:
             return True
         else:
             return False
 
     def start_kernel(self, **kwargs):
         """Start a new kernel."""
-        kernel_id = str(uuid.uuid4())
+        kernel_id = unicode(uuid.uuid4())
         (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel(**kwargs)
         # Store the information for contacting the kernel. This assumes the kernel is
         # running on localhost.
         d = dict(
             process = process,
             stdin_port = stdin_port,
             iopub_port = iopub_port,
             shell_port = shell_port,
             hb_port = hb_port,
             ip = '127.0.0.1'
         )
         self._kernels[kernel_id] = d
         return kernel_id
 
     def kill_kernel(self, kernel_id):
         """Kill a kernel by its kernel uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to kill.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             # Attempt to kill the kernel.
             try:
                 kernel_process.kill()
             except OSError, e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if not (sys.platform == 'win32' and e.winerror == 5):
                     raise
             del self._kernels[kernel_id]
 
     def interrupt_kernel(self, kernel_id):
         """Interrupt (SIGINT) the kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(kernel_process.win32_interrupt_event)
             else:
                 kernel_process.send_signal(signal.SIGINT)
 
     def signal_kernel(self, kernel_id, signum):
         """ Sends a signal to the kernel by its uuid.
 
         Note that since only SIGTERM is supported on Windows, this function
         is only useful on Unix systems.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to signal.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             kernel_process.send_signal(signum)
 
     def get_kernel_process(self, kernel_id):
         """Get the process object for a kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['process']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ports(self, kernel_id):
         """Return a dictionary of ports for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         port_dict : dict
             A dict of key, value pairs where the keys are the names
             (stdin_port,iopub_port,shell_port) and the values are the
             integer port numbers for those channels.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             dcopy = d.copy()
             dcopy.pop('process')
             dcopy.pop('ip')
             return dcopy
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ip(self, kernel_id):
         """Return ip address for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         ip : str
             The ip address of the kernel.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['ip']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def create_session_manager(self, kernel_id):
         """Create a new session manager for a kernel by its uuid."""
         from sessionmanager import SessionManager
         return SessionManager(
             kernel_id=kernel_id, kernel_manager=self, 
             config=self.config, context=self.context, log=self.log
         )
 
+
+class RoutingKernelManager(LoggingConfigurable):
+    """A KernelManager that handles WebSocket routing and HTTP error handling"""
+
+    kernel_argv = List(Unicode)
+    kernel_manager = Instance(KernelManager)
+
+    _routers = Dict()
+    _session_dict = Dict()
+    _notebook_mapping = Dict()
+
+    #-------------------------------------------------------------------------
+    # Methods for managing kernels and sessions
+    #-------------------------------------------------------------------------
+
+    @property
+    def kernel_ids(self):
+        return self.kernel_manager.kernel_ids
+
+    def notebook_for_kernel(self, kernel_id):
+        notebook_ids = [k for k, v in self._notebook_mapping.iteritems() if v == kernel_id]
+        if len(notebook_ids) == 1:
+            return notebook_ids[0]
+        else:
+            return None
+
+    def delete_mapping_for_kernel(self, kernel_id):
+        notebook_id = self.notebook_for_kernel(kernel_id)
+        if notebook_id is not None:
+            del self._notebook_mapping[notebook_id]
+
+    def start_kernel(self, notebook_id=None):
+        self.log.info
+        kernel_id = self._notebook_mapping.get(notebook_id)
+        if kernel_id is None:
+            kwargs = dict()
+            kwargs['extra_arguments'] = self.kernel_argv
+            kernel_id = self.kernel_manager.start_kernel(**kwargs)
+            if notebook_id is not None:
+                self._notebook_mapping[notebook_id] = kernel_id
+            self.log.info("Kernel started for notebook %s: %s" % (notebook_id,kernel_id))
+            self.log.debug("Kernel args: %r" % kwargs)
+            self.start_session_manager(kernel_id)
+        else:
+            self.log.info("Using existing kernel: %s" % kernel_id)
+        return kernel_id
+
+    def start_session_manager(self, kernel_id):
+        sm = self.kernel_manager.create_session_manager(kernel_id)
+        self._session_dict[kernel_id] = sm
+        iopub_stream = sm.get_iopub_stream()
+        shell_stream = sm.get_shell_stream()
+        iopub_router = IOPubStreamRouter(
+            zmq_stream=iopub_stream, session=sm.session, config=self.config
+        )
+        shell_router = ShellStreamRouter(
+            zmq_stream=shell_stream, session=sm.session, config=self.config
+        )
+        self._routers[(kernel_id, 'iopub')] = iopub_router
+        self._routers[(kernel_id, 'shell')] = shell_router
+
+    def kill_kernel(self, kernel_id):
+        if kernel_id not in self.kernel_manager:
+            raise web.HTTPError(404)
+        try:
+            sm = self._session_dict.pop(kernel_id)
+        except KeyError:
+            raise web.HTTPError(404)
+        sm.stop()
+        self.kernel_manager.kill_kernel(kernel_id)
+        self.delete_mapping_for_kernel(kernel_id)
+        self.log.info("Kernel killed: %s" % kernel_id)
+
+    def interrupt_kernel(self, kernel_id):
+        if kernel_id not in self.kernel_manager:
+            raise web.HTTPError(404)
+        self.kernel_manager.interrupt_kernel(kernel_id)
+        self.log.debug("Kernel interrupted: %s" % kernel_id)
+
+    def restart_kernel(self, kernel_id):
+        if kernel_id not in self.kernel_manager:
+            raise web.HTTPError(404)
+
+        # Get the notebook_id to preserve the kernel/notebook association
+        notebook_id = self.notebook_for_kernel(kernel_id)
+        # Create the new kernel first so we can move the clients over.
+        new_kernel_id = self.start_kernel()
+
+        # Copy the clients over to the new routers.
+        old_iopub_router = self.get_router(kernel_id, 'iopub')
+        old_shell_router = self.get_router(kernel_id, 'shell')
+        new_iopub_router = self.get_router(new_kernel_id, 'iopub')
+        new_shell_router = self.get_router(new_kernel_id, 'shell')
+        new_iopub_router.copy_clients(old_iopub_router)
+        new_shell_router.copy_clients(old_shell_router)
+
+        # Now shutdown the old session and the kernel.
+        # TODO: This causes a hard crash in ZMQStream.close, which sets
+        # self.socket to None to hastily. We will need to fix this in PyZMQ
+        # itself. For now, we just leave the old kernel running :(
+        # Maybe this is fixed now, but nothing was changed really.
+        self.kill_kernel(kernel_id)
+
+        # Now save the new kernel/notebook association. We have to save it
+        # after the old kernel is killed as that will delete the mapping.
+        self._notebook_mapping[notebook_id] = kernel_id
+
+        self.log.debug("Kernel restarted: %s -> %s" % (kernel_id, new_kernel_id))
+        return new_kernel_id
+
+    def get_router(self, kernel_id, stream_name):
+        router = self._routers[(kernel_id, stream_name)]
+        return router
+

IPython/frontend/html/notebook/notebookapp.py

@@ -1,270 +1,203 b''
 """A tornado based IPython notebook server."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import logging
 import os
 import signal
 import sys
 
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 import tornado.ioloop
 tornado.ioloop = ioloop
 
 from tornado import httpserver
 from tornado import web
 
-from .kernelmanager import KernelManager
+from .kernelmanager import KernelManager, RoutingKernelManager
 from .sessionmanager import SessionManager
 from .handlers import (
     NBBrowserHandler, NewHandler, NamedNotebookHandler,
-    KernelHandler, KernelActionHandler, ZMQStreamHandler,
+    MainKernelHandler, KernelHandler, KernelActionHandler, ZMQStreamHandler,
     NotebookRootHandler, NotebookHandler
 )
-from .routers import IOPubStreamRouter, ShellStreamRouter
 from .notebookmanager import NotebookManager
 
 from IPython.core.application import BaseIPythonApplication
 from IPython.core.profiledir import ProfileDir
 from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.zmq.session import Session
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 from IPython.zmq.ipkernel import (
     flags as ipkernel_flags,
     aliases as ipkernel_aliases,
     IPKernelApp
 )
 from IPython.utils.traitlets import Dict, Unicode, Int, Any, List, Enum
 
 #-----------------------------------------------------------------------------
 # Module globals
 #-----------------------------------------------------------------------------
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 _notebook_id_regex = r"(?P<notebook_id>\w+-\w+-\w+-\w+-\w+)"
 
 LOCALHOST = '127.0.0.1'
 
 #-----------------------------------------------------------------------------
 # The Tornado web application
 #-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
-    def __init__(self, kernel_manager, log, kernel_argv, config):
+    def __init__(self, routing_kernel_manager, notebook_manager, log):
         handlers = [
             (r"/", NBBrowserHandler),
             (r"/new", NewHandler),
             (r"/%s" % _notebook_id_regex, NamedNotebookHandler),
-            (r"/kernels", KernelHandler),
+            (r"/kernels", MainKernelHandler),
+            (r"/kernels/%s" % _kernel_id_regex, KernelHandler),
             (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
             (r"/kernels/%s/iopub" % _kernel_id_regex, ZMQStreamHandler, dict(stream_name='iopub')),
             (r"/kernels/%s/shell" % _kernel_id_regex, ZMQStreamHandler, dict(stream_name='shell')),
             (r"/notebooks", NotebookRootHandler),
             (r"/notebooks/%s" % _notebook_id_regex, NotebookHandler)
         ]
         settings = dict(
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
         )
         web.Application.__init__(self, handlers, **settings)
 
-        self.kernel_manager = kernel_manager
+        self.routing_kernel_manager = routing_kernel_manager
         self.log = log
-        self.kernel_argv = kernel_argv
-        self.config = config
-        self._routers = {}
-        self._session_dict = {}
-        self.notebook_manager = NotebookManager(config=self.config)
-
-    #-------------------------------------------------------------------------
-    # Methods for managing kernels and sessions
-    #-------------------------------------------------------------------------
-
-    @property
-    def kernel_ids(self):
-        return self.kernel_manager.kernel_ids
-
-    def start_kernel(self):
-        kwargs = dict()
-        kwargs['extra_arguments'] = self.kernel_argv
-        kernel_id = self.kernel_manager.start_kernel(**kwargs)
-        self.log.info("Kernel started: %s" % kernel_id)
-        self.log.debug("Kernel args: %r" % kwargs)
-        self.start_session_manager(kernel_id)
-        return kernel_id
-
-    def start_session_manager(self, kernel_id):
-        sm = self.kernel_manager.create_session_manager(kernel_id)
-        self._session_dict[kernel_id] = sm
-        iopub_stream = sm.get_iopub_stream()
-        shell_stream = sm.get_shell_stream()
-        iopub_router = IOPubStreamRouter(
-            zmq_stream=iopub_stream, session=sm.session, config=self.config
-        )
-        shell_router = ShellStreamRouter(
-            zmq_stream=shell_stream, session=sm.session, config=self.config
-        )
-        self._routers[(kernel_id, 'iopub')] = iopub_router
-        self._routers[(kernel_id, 'shell')] = shell_router
-
-    def kill_kernel(self, kernel_id):
-        sm = self._session_dict.pop(kernel_id)
-        sm.stop()
-        self.kernel_manager.kill_kernel(kernel_id)
-        self.log.info("Kernel killed: %s" % kernel_id)
-
-    def interrupt_kernel(self, kernel_id):
-        self.kernel_manager.interrupt_kernel(kernel_id)
-        self.log.debug("Kernel interrupted: %s" % kernel_id)
-
-    def restart_kernel(self, kernel_id):
-        # Create the new kernel first so we can move the clients over.
-        new_kernel_id = self.start_kernel()
-
-        # Copy the clients over to the new routers.
-        old_iopub_router = self.get_router(kernel_id, 'iopub')
-        old_shell_router = self.get_router(kernel_id, 'shell')
-        new_iopub_router = self.get_router(new_kernel_id, 'iopub')
-        new_shell_router = self.get_router(new_kernel_id, 'shell')
-        new_iopub_router.copy_clients(old_iopub_router)
-        new_shell_router.copy_clients(old_shell_router)
-
-        # Now shutdown the old session and the kernel.
-        # TODO: This causes a hard crash in ZMQStream.close, which sets
-        # self.socket to None to hastily. We will need to fix this in PyZMQ
-        # itself. For now, we just leave the old kernel running :(
-        # Maybe this is fixed now, but nothing was changed really.
-        self.kill_kernel(kernel_id)
-
-        self.log.debug("Kernel restarted: %s -> %s" % (kernel_id, new_kernel_id))
-        return new_kernel_id
-
-    def get_router(self, kernel_id, stream_name):
-        router = self._routers[(kernel_id, stream_name)]
-        return router
+        self.notebook_manager = notebook_manager
 
-    
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(ipkernel_flags)
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
 notebook_flags = []
 
 aliases = dict(ipkernel_aliases)
 
 aliases.update(dict(
     ip = 'IPythonNotebookApp.ip',
     port = 'IPythonNotebookApp.port',
     colors = 'ZMQInteractiveShell.colors',
     editor = 'RichIPythonWidget.editor',
 ))
 
 #-----------------------------------------------------------------------------
 # IPythonNotebookApp
 #-----------------------------------------------------------------------------
 
 class IPythonNotebookApp(BaseIPythonApplication):
     name = 'ipython-notebook'
     default_config_file_name='ipython_notebook_config.py'
     
     description = """
         The IPython HTML Notebook.
         
         This launches a Tornado based HTML Notebook Server that serves up an
         HTML5/Javascript Notebook client.
     """
     
     classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session,
+               RoutingKernelManager, NotebookManager,
                KernelManager, SessionManager, RichIPythonWidget]
     flags = Dict(flags)
     aliases = Dict(aliases)
 
     kernel_argv = List(Unicode)
 
     log_level = Enum((0,10,20,30,40,50,'DEBUG','INFO','WARN','ERROR','CRITICAL'),
                     default_value=logging.INFO,
                     config=True,
                     help="Set the log level by value or name.")
 
     # connection info:
     ip = Unicode(LOCALHOST, config=True,
         help="The IP address the notebook server will listen on."
     )
 
     port = Int(8888, config=True,
         help="The port the notebook server will listen on."
     )
 
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
     def parse_command_line(self, argv=None):
         super(IPythonNotebookApp, self).parse_command_line(argv)
         if argv is None:
             argv = sys.argv[1:]
 
         self.kernel_argv = list(argv) # copy
         # kernel should inherit default config file from frontend
         self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name)
         # scrub frontend-specific flags
         for a in argv:
             if a.startswith('-') and a.lstrip('-') in notebook_flags:
                 self.kernel_argv.remove(a)
 
-    def init_kernel_manager(self):
+    def init_configurables(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = KernelManager(config=self.config, log=self.log)
+        self.routing_kernel_manager = RoutingKernelManager(config=self.config, log=self.log,
+            kernel_manager=self.kernel_manager, kernel_argv=self.kernel_argv
+        )
+        self.notebook_manager = NotebookManager(config=self.config, log=self.log)
 
     def init_logging(self):
         super(IPythonNotebookApp, self).init_logging()
         # This prevents double log messages because tornado use a root logger that
         # self.log is a child of. The logging module dipatches log messages to a log
         # and all of its ancenstors until propagate is set to False.
         self.log.propagate = False
 
     def initialize(self, argv=None):
         super(IPythonNotebookApp, self).initialize(argv)
-        self.init_kernel_manager()
+        self.init_configurables()
         self.web_app = NotebookWebApplication(
-            self.kernel_manager, self.log, self.kernel_argv, self.config
+            self.routing_kernel_manager, self.notebook_manager, self.log
         )
         self.http_server = httpserver.HTTPServer(self.web_app)
         self.http_server.listen(self.port)
 
     def start(self):
         self.log.info("The IPython Notebook is running at: http://%s:%i" % (self.ip, self.port))
         ioloop.IOLoop.instance().start()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def launch_new_instance():
     app = IPythonNotebookApp()
     app.initialize()
     app.start()
 

IPython/frontend/html/notebook/notebookmanager.py

@@ -1,225 +1,225 b''
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import datetime
 import os
 import uuid
 
 from tornado import web
 
-from IPython.config.configurable import Configurable
+from IPython.config.configurable import LoggingConfigurable
 from IPython.nbformat import current
 from IPython.utils.traitlets import Unicode, List, Dict
 
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
-class NotebookManager(Configurable):
+class NotebookManager(LoggingConfigurable):
 
     notebook_dir = Unicode(os.getcwd())
     filename_ext = Unicode(u'.ipynb')
     allowed_formats = List([u'json',u'xml',u'py'])
 
     # Map notebook_ids to notebook names
     mapping = Dict()
     # Map notebook names to notebook_ids
     rev_mapping = Dict()
 
     def list_notebooks(self):
         """List all notebooks in the notebook dir.
 
         This returns a list of dicts of the form::
 
             dict(notebook_id=notebook,name=name)
         """
         names = os.listdir(self.notebook_dir)
         names = [name.split(u'.')[0] \
             for name in names if name.endswith(self.filename_ext)]
         data = []
         for name in names:
             if name not in self.rev_mapping:
                 notebook_id = self.new_notebook_id(name)
             else:
                 notebook_id = self.rev_mapping[name]
             data.append(dict(notebook_id=notebook_id,name=name))
         data = sorted(data, key=lambda item: item['name'])
         return data
 
     def new_notebook_id(self, name):
         """Generate a new notebook_id for a name and store its mappings."""
         notebook_id = unicode(uuid.uuid4())
         self.mapping[notebook_id] = name
         self.rev_mapping[name] = notebook_id
         return notebook_id
 
     def delete_notebook_id(self, notebook_id):
         """Delete a notebook's id only. This doesn't delete the actual notebook."""
         name = self.mapping[notebook_id]
         del self.mapping[notebook_id]
         del self.rev_mapping[name]
 
     def notebook_exists(self, notebook_id):
         """Does a notebook exist?"""
         if notebook_id not in self.mapping:
             return False
         path = self.get_path_by_name(self.mapping[notebook_id])
         if not os.path.isfile(path):
             return False
         return True        
 
     def find_path(self, notebook_id):
         """Return a full path to a notebook given its notebook_id."""
         try:
             name = self.mapping[notebook_id]
         except KeyError:
             raise web.HTTPError(404)
         return self.get_path_by_name(name)
 
     def get_path_by_name(self, name):
         """Return a full path to a notebook given its name."""
         filename = name + self.filename_ext
         path = os.path.join(self.notebook_dir, filename)
         return path       
 
     def get_notebook(self, notebook_id, format=u'json'):
         """Get the representation of a notebook in format by notebook_id."""
         format = unicode(format)
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
         last_modified, nb = self.get_notebook_object(notebook_id)
         data = current.writes(nb, format)
         name = nb.get('name','notebook')
         return last_modified, name, data
 
     def get_notebook_object(self, notebook_id):
         """Get the NotebookNode representation of a notebook by notebook_id."""
         path = self.find_path(notebook_id)
         if not os.path.isfile(path):
             raise web.HTTPError(404)
         info = os.stat(path)
         last_modified = datetime.datetime.utcfromtimestamp(info.st_mtime)
         try:
             with open(path,'r') as f:
                 s = f.read()
                 try:
                     # v2 and later have xml in the .ipynb files.
                     nb = current.reads(s, 'xml')
                 except:
                     # v1 had json in the .ipynb files.
                     nb = current.reads(s, 'json')
                     # v1 notebooks don't have a name field, so use the filename.
                     nb.name = os.path.split(path)[-1].split(u'.')[0]
         except:
             raise web.HTTPError(404)
         return last_modified, nb
 
     def save_new_notebook(self, data, name=None, format=u'json'):
         """Save a new notebook and return its notebook_id.
 
         If a name is passed in, it overrides any values in the notebook data
         and the value in the data is updated to use that value.
         """
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
 
         try:
             nb = current.reads(data, format)
         except:
             if format == u'xml':
                 # v1 notebooks might come in with a format='xml' but be json.
                 try:
                     nb = current.reads(data, u'json')
                 except:
                     raise web.HTTPError(400)
             else:
                 raise web.HTTPError(400)
 
         if name is None:
             try:
                 name = nb.name
             except AttributeError:
                 raise web.HTTPError(400)
         nb.name = name
 
         notebook_id = self.new_notebook_id(name)
         self.save_notebook_object(notebook_id, nb)
         return notebook_id
 
     def save_notebook(self, notebook_id, data, name=None, format=u'json'):
         """Save an existing notebook by notebook_id."""
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
 
         try:
             nb = current.reads(data, format)
         except:
             if format == u'xml':
                 # v1 notebooks might come in with a format='xml' but be json.
                 try:
                     nb = current.reads(data, u'json')
                 except:
                     raise web.HTTPError(400)
             else:
                 raise web.HTTPError(400)
 
         if name is not None:
             nb.name = name
         self.save_notebook_object(notebook_id, nb)
 
     def save_notebook_object(self, notebook_id, nb):
         """Save an existing notebook object by notebook_id."""
         if notebook_id not in self.mapping:
             raise web.HTTPError(404)
         old_name = self.mapping[notebook_id]
         try:
             new_name = nb.name
         except AttributeError:
             raise web.HTTPError(400)
         path = self.get_path_by_name(new_name)
         try:
             with open(path,'w') as f:
                 current.write(nb, f, u'xml')
         except:
             raise web.HTTPError(400)
         if old_name != new_name:
             old_path = self.get_path_by_name(old_name)
             if os.path.isfile(old_path):
                 os.unlink(old_path)
             self.mapping[notebook_id] = new_name
             self.rev_mapping[new_name] = notebook_id
 
     def delete_notebook(self, notebook_id):
         """Delete notebook by notebook_id."""
         path = self.find_path(notebook_id)
         if not os.path.isfile(path):
             raise web.HTTPError(404)
         os.unlink(path)
         self.delete_notebook_id(notebook_id)
 
     def new_notebook(self):
         """Create a new notebook and returns its notebook_id."""
         i = 0
         while True:
             name = u'Untitled%i' % i
             path = self.get_path_by_name(name)
             if not os.path.isfile(path):
                 break
             else:
                 i = i+1
         notebook_id = self.new_notebook_id(name)
         nb = current.new_notebook(name=name, id=notebook_id)
         with open(path,'w') as f:
             current.write(nb, f, u'xml')
         return notebook_id
 

IPython/frontend/html/notebook/static/js/kernel.js

@@ -1,105 +1,106 b''
 
 //============================================================================
 // Kernel
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Kernel = function () {
         this.kernel_id = null;
         this.base_url = "/kernels";
         this.kernel_url = null;
     };
 
 
     Kernel.prototype.get_msg = function (msg_type, content) {
         var msg = {
             header : {
                 msg_id : utils.uuid(),
                 username : "username",
                 session: this.session_id,
                 msg_type : msg_type
             },
             content : content,
             parent_header : {}
         };
         return msg;
     }
 
-    Kernel.prototype.start_kernel = function (callback) {
+    Kernel.prototype.start_kernel = function (notebook_id, callback) {
         var that = this;
-        $.post(this.base_url,
+        var qs = $.param({notebook:notebook_id});
+        $.post(this.base_url + '?' + qs,
             function (kernel_id) {
                 that._handle_start_kernel(kernel_id, callback);
             }, 
             'json'
         );
     };
 
 
     Kernel.prototype._handle_start_kernel = function (kernel_id, callback) {
         this.kernel_id = kernel_id;
         this.kernel_url = this.base_url + "/" + this.kernel_id;
         this._start_channels();
         callback();
     };
 
 
     Kernel.prototype._start_channels = function () {
         var ws_url = "ws://127.0.0.1:8888" + this.kernel_url;
         this.shell_channel = new WebSocket(ws_url + "/shell");
         this.iopub_channel = new WebSocket(ws_url + "/iopub");
     }
 
 
     Kernel.prototype.execute = function (code) {
         var content = {
             code : code,
             silent : false,
             user_variables : [],
             user_expressions : {}
         };
         var msg = this.get_msg("execute_request", content);
         this.shell_channel.send(JSON.stringify(msg));
         return msg.header.msg_id;
     }
 
 
     Kernel.prototype.complete = function (line, cursor_pos) {
         var content = {
             text : '',
             line : line,
             cursor_pos : cursor_pos
         };
         var msg = this.get_msg("complete_request", content);
         this.shell_channel.send(JSON.stringify(msg));
         return msg.header.msg_id;
     }
 
 
     Kernel.prototype.interrupt = function () {
         $.post(this.kernel_url + "/interrupt");
     };
 
 
     Kernel.prototype.restart = function () {
         IPython.kernel_status_widget.status_restarting();
         url = this.kernel_url + "/restart"
         var that = this;
         $.post(url, function (kernel_id) {
             console.log("Kernel restarted: " + kernel_id);
             that.kernel_id = kernel_id;
             that.kernel_url = that.base_url + "/" + that.kernel_id;
             IPython.kernel_status_widget.status_idle();
         }, 'json');
     };
 
 
     IPython.Kernel = Kernel;
 
     return IPython;
 
 }(IPython));
 

IPython/frontend/html/notebook/static/js/notebook.js

@@ -1,622 +1,623 b''
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Notebook = function (selector) {
         this.element = $(selector);
         this.element.scroll();
         this.element.data("notebook", this);
         this.next_prompt_number = 1;
         this.kernel = null;
         this.msg_cell_map = {};
         this.style();
         this.create_elements();
         this.bind_events();
     };
 
 
     Notebook.prototype.style = function () {
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.create_elements = function () {
         // We add this end_space div to the end of the notebook div to:
         // i) provide a margin between the last cell and the end of the notebook
         // ii) to prevent the div from scrolling up when the last cell is being
         // edited, but is too low on the page, which browsers will do automatically.
         this.element.append($('<div class="end_space"></div>').height(50));
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
             // console.log(event);
             if (event.which === 38) {
                 var cell = that.selected_cell();
                 if (cell.at_top()) {
                     event.preventDefault();
                     that.select_prev();
                 };
             } else if (event.which === 40) {
                 var cell = that.selected_cell();
                 if (cell.at_bottom()) {
                     event.preventDefault();
                     that.select_next();
                 };
             } else if (event.which === 13 && event.shiftKey) {
                 that.execute_selected_cell();
                 return false;
             } else if (event.which === 13 && event.ctrlKey) {
                 that.execute_selected_cell({terminal:true});
                 return false;
             };
         });
 
         this.element.bind('collapse_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var new_height = app_height - splitter_height;
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('expand_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var pager_height = $('div#pager').outerHeight(true);
             var new_height = app_height - pager_height - splitter_height; 
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('collapse_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var new_margin = splitter_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
 
         this.element.bind('expand_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var left_panel_width = IPython.left_panel.width;
             var new_margin = splitter_width + left_panel_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
     };
 
 
     Notebook.prototype.scroll_to_bottom = function () {
         this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0);
     };
 
 
     Notebook.prototype.scroll_to_top = function () {
         this.element.animate({scrollTop:0}, 0);
     };
 
 
     // Cell indexing, retrieval, etc.
 
 
     Notebook.prototype.cell_elements = function () {
         return this.element.children("div.cell");
     }
 
 
     Notebook.prototype.ncells = function (cell) {
         return this.cell_elements().length;
     }
 
 
     // TODO: we are often calling cells as cells()[i], which we should optimize
     // to cells(i) or a new method.
     Notebook.prototype.cells = function () {
         return this.cell_elements().toArray().map(function (e) {
             return $(e).data("cell");
         });
     }
 
 
     Notebook.prototype.find_cell_index = function (cell) {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell") === cell) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.index_or_selected = function (index) {
         return index || this.selected_index() || 0;
     }
 
 
     Notebook.prototype.select = function (index) {
         if (index !== undefined && index >= 0 && index < this.ncells()) {
             if (this.selected_index() !== null) {
                 this.selected_cell().unselect();
             };
             this.cells()[index].select();
             if (index === (this.ncells()-1)) {
                 this.scroll_to_bottom();
             };
         };
         return this;
     };
 
 
     Notebook.prototype.select_next = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index+1) < this.ncells()) {
             this.select(index+1);
         };
         return this;
     };
 
 
     Notebook.prototype.select_prev = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index-1) < this.ncells()) {
             this.select(index-1);
         };
         return this;
     };
 
 
     Notebook.prototype.selected_index = function () {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell").selected === true) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.cell_for_msg = function (msg_id) {
         var cell_id = this.msg_cell_map[msg_id];
         var result = null;
         this.cell_elements().filter(function (index) {
             cell = $(this).data("cell");
             if (cell.cell_id === cell_id) {
                 result = cell;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.selected_cell = function () {
         return this.cell_elements().eq(this.selected_index()).data("cell");
     }
 
 
     // Cell insertion, deletion and moving.
 
 
     Notebook.prototype.delete_cell = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i >= 0 && i < this.ncells()) {
             this.cell_elements().eq(i).remove();
             if (i === (this.ncells())) {
                 this.select(i-1);
             } else {
                 this.select(i);
             };
         };
         return this;
     };
 
 
     Notebook.prototype.append_cell = function (cell) {
         this.element.find('div.end_space').before(cell.element);
         return this;
     };
 
 
     Notebook.prototype.insert_cell_after = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).after(cell.element);
         };
         return this
     };
 
 
     Notebook.prototype.insert_cell_before = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).before(cell.element);
         };
         return this;
     };
 
 
     Notebook.prototype.move_cell_up = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < this.ncells() && i > 0) {
             var pivot = this.cell_elements().eq(i-1);
             var tomove = this.cell_elements().eq(i);
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.before(tomove);
                 this.select(i-1);
             };
         };
         return this;
     }
 
 
     Notebook.prototype.move_cell_down = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < (this.ncells()-1) && i >= 0) {
             var pivot = this.cell_elements().eq(i+1)
             var tomove = this.cell_elements().eq(i)
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.after(tomove);
                 this.select(i+1);
             };
         };
         return this;
     }
 
 
     Notebook.prototype.sort_cells = function () {
         var ncells = this.ncells();
         var sindex = this.selected_index();
         var swapped;
         do {
             swapped = false
             for (var i=1; i<ncells; i++) {
                 current = this.cell_elements().eq(i).data("cell");
                 previous = this.cell_elements().eq(i-1).data("cell");
                 if (previous.input_prompt_number > current.input_prompt_number) {
                     this.move_cell_up(i);
                     swapped = true;
                 };
             };
         } while (swapped);
         this.select(sindex);
         return this;
     };
 
 
     Notebook.prototype.insert_code_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_code_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_text_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.TextCell(this);
         cell.config_mathjax();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_text_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.TextCell(this);
         cell.config_mathjax();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.text_to_code = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         if (source_cell instanceof IPython.TextCell) {
             this.insert_code_cell_after(i);
             var target_cell = this.cells()[i+1];
             target_cell.set_code(source_cell.get_text());
             source_element.remove();
         };
     };
 
 
     Notebook.prototype.code_to_text = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         if (source_cell instanceof IPython.CodeCell) {
             this.insert_text_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_text(text);
             source_element.remove();
             target_cell.edit();
         };
     };
 
 
     // Cell collapsing
 
     Notebook.prototype.collapse = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].collapse();
     };
 
 
     Notebook.prototype.expand = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].expand();
     };
 
 
     // Kernel related things
 
     Notebook.prototype.start_kernel = function () {
         this.kernel = new IPython.Kernel();
-        this.kernel.start_kernel($.proxy(this.kernel_started, this));
+        var notebook_id = IPython.save_widget.get_notebook_id();
+        this.kernel.start_kernel(notebook_id, $.proxy(this.kernel_started, this));
     };
 
 
     Notebook.prototype.handle_shell_reply = function (e) {
         reply = $.parseJSON(e.data);
         var header = reply.header;
         var content = reply.content;
         var msg_type = header.msg_type;
         // console.log(reply);
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         if (msg_type === "execute_reply") {
             cell.set_input_prompt(content.execution_count);
         } else if (msg_type === "complete_reply") {
             cell.finish_completing(content.matched_text, content.matches);
         };
         var payload = content.payload || [];
         this.handle_payload(payload);
     };
 
 
     Notebook.prototype.handle_payload = function (payload) {
         var l = payload.length;
         if (l > 0) {
             IPython.pager.clear();
             IPython.pager.expand();
         };
         for (var i=0; i<l; i++) {
             IPython.pager.append_text(payload[i].text);
         };
     };
 
 
     Notebook.prototype.handle_iopub_reply = function (e) {
         reply = $.parseJSON(e.data);
         var content = reply.content;
         // console.log(reply);
         var msg_type = reply.header.msg_type;
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         if (msg_type === "stream") {
             cell.expand();
             cell.append_stream(content.data + "\n");
         } else if (msg_type === "display_data") {
             cell.expand();
             cell.append_display_data(content.data);
         } else if (msg_type === "pyout") {
             cell.expand();
             cell.append_pyout(content.data, content.execution_count)
         } else if (msg_type === "pyerr") {
             cell.expand();
             cell.append_pyerr(content.ename, content.evalue, content.traceback);
         } else if (msg_type === "status") {
             if (content.execution_state === "busy") {
                 IPython.kernel_status_widget.status_busy();
             } else if (content.execution_state === "idle") {
                 IPython.kernel_status_widget.status_idle();
             };
         }
     };
 
 
     Notebook.prototype.kernel_started = function () {
         console.log("Kernel started: ", this.kernel.kernel_id);
         this.kernel.shell_channel.onmessage = $.proxy(this.handle_shell_reply,this);
         this.kernel.iopub_channel.onmessage = $.proxy(this.handle_iopub_reply,this);
     };
 
 
     Notebook.prototype.execute_selected_cell = function (options) {
         // add_new: should a new cell be added if we are at the end of the nb
         // terminal: execute in terminal mode, which stays in the current cell
         default_options = {terminal: false, add_new: true}
         $.extend(default_options, options)
         var that = this;
         var cell = that.selected_cell();
         var cell_index = that.find_cell_index(cell);
         if (cell instanceof IPython.CodeCell) {
             cell.clear_output();
             var code = cell.get_code();
             var msg_id = that.kernel.execute(cell.get_code());
             that.msg_cell_map[msg_id] = cell.cell_id;
         } else if (cell instanceof IPython.TextCell) {
             cell.render();
         }
         if (default_options.terminal) {
             cell.clear_input();
         } else {
             if ((cell_index === (that.ncells()-1)) && default_options.add_new) {
                 that.insert_code_cell_after();
                 // If we are adding a new cell at the end, scroll down to show it.
                 that.scroll_to_bottom();
             } else {
                 that.select(cell_index+1);
             };
         };
     };
 
 
     Notebook.prototype.execute_all_cells = function () {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             this.select(i);
             this.execute_selected_cell({add_new:false});
         };
         this.scroll_to_bottom();
     };
 
 
     Notebook.prototype.complete_cell = function (cell, line, cursor_pos) {
         var msg_id = this.kernel.complete(line, cursor_pos);
         this.msg_cell_map[msg_id] = cell.cell_id;
     };
 
     // Persistance and loading
 
 
     Notebook.prototype.fromJSON = function (data) {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             // Always delete cell 0 as they get renumbered as they are deleted.
             this.delete_cell(0);
         };
         // Only handle 1 worksheet for now.
         var worksheet = data.worksheets[0];
         if (worksheet !== undefined) {
             var new_cells = worksheet.cells;
             ncells = new_cells.length;
             var cell_data = null;
             var new_cell = null;
             for (var i=0; i<ncells; i++) {
                 cell_data = new_cells[i];
                 if (cell_data.cell_type == 'code') {
                     new_cell = this.insert_code_cell_after();
                     new_cell.fromJSON(cell_data);
                 } else if (cell_data.cell_type === 'text') {
                     new_cell = this.insert_text_cell_after();
                     new_cell.fromJSON(cell_data);
                 };
             };          
         };
     };
 
 
     Notebook.prototype.toJSON = function () {
         var cells = this.cells();
         var ncells = cells.length;
         cell_array = new Array(ncells);
         for (var i=0; i<ncells; i++) {
             cell_array[i] = cells[i].toJSON();
         };
         data = {
             // Only handle 1 worksheet for now.
             worksheets : [{cells:cell_array}]
         }
         return data
     };
 
     Notebook.prototype.save_notebook = function () {
         if (IPython.save_widget.test_notebook_name()) {
             var notebook_id = IPython.save_widget.get_notebook_id();
             var nbname = IPython.save_widget.get_notebook_name();
             // We may want to move the name/id/nbformat logic inside toJSON?
             var data = this.toJSON();
             data.name = nbname;
             data.nbformat = 2;
             data.id = notebook_id
             // We do the call with settings so we can set cache to false.
             var settings = {
                 processData : false,
                 cache : false,
                 type : "PUT",
                 data : JSON.stringify(data),
                 headers : {'Content-Type': 'application/json'},
                 success : $.proxy(this.notebook_saved,this)
             };
             IPython.save_widget.status_saving();
             $.ajax("/notebooks/" + notebook_id, settings);
         };
     };
 
 
     Notebook.prototype.notebook_saved = function (data, status, xhr) {
         IPython.save_widget.status_save();
     }
 
 
     Notebook.prototype.load_notebook = function (callback) {
         var that = this;
         var notebook_id = IPython.save_widget.get_notebook_id();
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : function (data, status, xhr) {
                 that.notebook_loaded(data, status, xhr);
                 if (callback !== undefined) {
                     callback();
                 };
             }
         };
         IPython.save_widget.status_loading();
         $.ajax("/notebooks/" + notebook_id, settings);
     }
 
 
     Notebook.prototype.notebook_loaded = function (data, status, xhr) {
         this.fromJSON(data);
         if (this.ncells() === 0) {
             this.insert_code_cell_after();
         };
         IPython.save_widget.status_save();
         IPython.save_widget.set_notebook_name(data.name);
         this.start_kernel();
         // fromJSON always selects the last cell inserted. We need to wait
         // until that is done before scrolling to the top.
         setTimeout(function () {
             IPython.notebook.select(0);
             IPython.notebook.scroll_to_top();
         }, 50);
     };
 
     IPython.Notebook = Notebook;
 
     return IPython;
 
 }(IPython));