WebSocket url is now passed to browser when a kernel is started.

IPython/frontend/html/notebook/handlers.py

@@ -1,297 +1,326 b''
 """Tornado handlers for the notebook."""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 
 from tornado import web
 from tornado import websocket
 
 from zmq.eventloop import ioloop
 from zmq.utils import jsonapi
 
 from IPython.zmq.session import Session
 
 try:
     from docutils.core import publish_string
 except ImportError:
     publish_string = None
 
 
 
 #-----------------------------------------------------------------------------
 # 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)
 
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(web.RequestHandler):
 
     def get(self):
         km = self.application.kernel_manager
         self.finish(jsonapi.dumps(km.kernel_ids))
 
     def post(self):
         km = self.application.kernel_manager
         notebook_id = self.get_argument('notebook', default=None)
         kernel_id = km.start_kernel(notebook_id)
+        ws_url = self.application.ipython_app.get_ws_url()
+        data = {'ws_url':ws_url,'kernel_id':kernel_id}
         self.set_header('Location', '/'+kernel_id)
-        self.finish(jsonapi.dumps(kernel_id))
+        self.finish(jsonapi.dumps(data))
 
 
 class KernelHandler(web.RequestHandler):
 
     SUPPORTED_METHODS = ('DELETE')
 
     def delete(self, kernel_id):
         km = self.application.kernel_manager
         km.kill_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(web.RequestHandler):
 
     def post(self, kernel_id, action):
         km = self.application.kernel_manager
         if action == 'interrupt':
             km.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             new_kernel_id = km.restart_kernel(kernel_id)
-            self.write(jsonapi.dumps(new_kernel_id))
+            ws_url = self.application.ipython_app.get_ws_url()
+            data = {'ws_url':ws_url,'kernel_id':new_kernel_id}
+            self.set_header('Location', '/'+new_kernel_id)
+            self.write(jsonapi.dumps(data))
         self.finish()
 
 
 class ZMQStreamHandler(websocket.WebSocketHandler):
 
     def _reserialize_reply(self, msg_list):
         """Reserialize a reply message using JSON.
 
         This takes the msg list from the ZMQ socket, unserializes it using
         self.session and then serializes the result using JSON. This method
         should be used by self._on_zmq_reply to build messages that can
         be sent back to the browser.
         """
         idents, msg_list = self.session.feed_identities(msg_list)
         msg = self.session.unserialize(msg_list)
         try:
             msg['header'].pop('date')
         except KeyError:
             pass
         try:
             msg['parent_header'].pop('date')
         except KeyError:
             pass
         msg.pop('buffers')
         return jsonapi.dumps(msg)
 
     def _on_zmq_reply(self, msg_list):
         try:
             msg = self._reserialize_reply(msg_list)
         except:
             self.application.kernel_manager.log.critical("Malformed message: %r" % msg_list)
         else:
             self.write_message(msg)
 
 
 class IOPubHandler(ZMQStreamHandler):
 
     def initialize(self, *args, **kwargs):
         self._kernel_alive = True
         self._beating = False
+        self.iopub_stream = None
+        self.hb_stream = None
 
     def open(self, kernel_id):
         km = self.application.kernel_manager
         self.kernel_id = kernel_id
         self.session = Session()
         self.time_to_dead = km.time_to_dead
+        try:
         self.iopub_stream = km.create_iopub_stream(kernel_id)
         self.hb_stream = km.create_hb_stream(kernel_id)
+        except web.HTTPError:
+            # WebSockets don't response to traditional error codes so we
+            # close the connection.
+            if not self.stream.closed():
+                self.stream.close()
+        else:
         self.iopub_stream.on_recv(self._on_zmq_reply)
         self.start_hb(self.kernel_died)
 
     def on_close(self):
+        # This method can be called twice, once by self.kernel_died and once 
+        # from the WebSocket close event. If the WebSocket connection is
+        # closed before the ZMQ streams are setup, they could be None.
         self.stop_hb()
+        if self.iopub_stream is not None and not self.iopub_stream.closed():
+            self.iopub_stream.on_recv(None)
         self.iopub_stream.close()
+        if self.hb_stream is not None and not self.hb_stream.closed():
         self.hb_stream.close()
  
     def start_hb(self, callback):
         """Start the heartbeating and call the callback if the kernel dies."""
         if not self._beating:
             self._kernel_alive = True
 
             def ping_or_dead():
                 if self._kernel_alive:
                     self._kernel_alive = False
                     self.hb_stream.send(b'ping')
                 else:
                     try:
                         callback()
                     except:
                         pass
                     finally:
                         self._hb_periodic_callback.stop()
 
             def beat_received(msg):
                 self._kernel_alive = True
 
             self.hb_stream.on_recv(beat_received)
             self._hb_periodic_callback = ioloop.PeriodicCallback(ping_or_dead, self.time_to_dead*1000)
             self._hb_periodic_callback.start()
             self._beating= True
 
     def stop_hb(self):
         """Stop the heartbeating and cancel all related callbacks."""
         if self._beating:
             self._hb_periodic_callback.stop()
             if not self.hb_stream.closed():
                 self.hb_stream.on_recv(None)
 
     def kernel_died(self):
         self.application.kernel_manager.delete_mapping_for_kernel(self.kernel_id)
         self.write_message(
             {'header': {'msg_type': 'status'},
              'parent_header': {},
              'content': {'execution_state':'dead'}
             }
         )
         self.on_close()
 
 
 class ShellHandler(ZMQStreamHandler):
 
     def initialize(self, *args, **kwargs):
-        pass
+        self.shell_stream = None
 
     def open(self, kernel_id):
         km = self.application.kernel_manager
         self.max_msg_size = km.max_msg_size
         self.kernel_id = kernel_id
+        try:
+            self.shell_stream = km.create_shell_stream(kernel_id)
+        except web.HTTPError:
+            # WebSockets don't response to traditional error codes so we
+            # close the connection.
+            if not self.stream.closed():
+                self.stream.close()
+        else:
         self.session = Session()
-        self.shell_stream = self.application.kernel_manager.create_shell_stream(kernel_id)
         self.shell_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
         if len(msg) < self.max_msg_size:
             msg = jsonapi.loads(msg)
             self.session.send(self.shell_stream, msg)
 
     def on_close(self):
+        # Make sure the stream exists and is not already closed.
+        if self.shell_stream is not None and not self.shell_stream.closed():
         self.shell_stream.close()
 
 
 #-----------------------------------------------------------------------------
 # Notebook web service handlers
 #-----------------------------------------------------------------------------
 
 class NotebookRootHandler(web.RequestHandler):
 
     def get(self):
         nbm = self.application.notebook_manager
         files = nbm.list_notebooks()
         self.finish(jsonapi.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(jsonapi.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()
 
 #-----------------------------------------------------------------------------
 # RST web service handlers
 #-----------------------------------------------------------------------------
 
 
 class RSTHandler(web.RequestHandler):
 
     def post(self):
         if publish_string is None:
             raise web.HTTPError(503)
         body = self.request.body.strip()
         source = body
         # template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html')
         defaults = {'file_insertion_enabled': 0,
                     'raw_enabled': 0,
                     '_disable_config': 1,
                     'stylesheet_path': 0
                     # 'template': template_path
         }
         try:
             html = publish_string(source, writer_name='html',
                                   settings_overrides=defaults
             )
         except:
             raise web.HTTPError(400)
         print html
         self.set_header('Content-Type', 'text/html')
         self.finish(html)
 
 

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,306 +1,320 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 zmq.eventloop.zmqstream import ZMQStream
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.zmq.ipkernel import launch_kernel
 from IPython.utils.traitlets import Instance, Dict, List, Unicode, Float, Int
 
 #-----------------------------------------------------------------------------
 # 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 = 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_connected_stream(self, ip, port, socket_type):
         sock = self.context.socket(socket_type)
         addr = "tcp://%s:%i" % (ip, port)
         self.log.info("Connecting to: %s" % addr)
         sock.connect(addr)
         return ZMQStream(sock)
 
     def create_iopub_stream(self, kernel_id):
         ip = self.get_kernel_ip(kernel_id)
         ports = self.get_kernel_ports(kernel_id)
         iopub_stream = self.create_connected_stream(ip, ports['iopub_port'], zmq.SUB)
         iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
         return iopub_stream
 
     def create_shell_stream(self, kernel_id):
         ip = self.get_kernel_ip(kernel_id)
         ports = self.get_kernel_ports(kernel_id)
         shell_stream = self.create_connected_stream(ip, ports['shell_port'], zmq.XREQ)
         return shell_stream
 
     def create_hb_stream(self, kernel_id):
         ip = self.get_kernel_ip(kernel_id)
         ports = self.get_kernel_ports(kernel_id)
         hb_stream = self.create_connected_stream(ip, ports['hb_port'], zmq.REQ)
         return hb_stream
 
 
 class MappingKernelManager(KernelManager):
     """A KernelManager that handles notebok mapping and HTTP error handling"""
 
     kernel_argv = List(Unicode)
     kernel_manager = Instance(KernelManager)
     time_to_dead = Float(3.0, config=True, help="""Kernel heartbeat interval in seconds.""")
     max_msg_size = Int(65536, config=True, help="""
         The max raw message size accepted from the browser
         over a WebSocket connection.
     """)
 
     _notebook_mapping = Dict()
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
     def kernel_for_notebook(self, notebook_id):
         """Return the kernel_id for a notebook_id or None."""
         return self._notebook_mapping.get(notebook_id)
 
     def set_kernel_for_notebook(self, notebook_id, kernel_id):
         """Associate a notebook with a kernel."""
         if notebook_id is not None:
             self._notebook_mapping[notebook_id] = kernel_id
 
     def notebook_for_kernel(self, kernel_id):
         """Return the notebook_id for a kernel_id or None."""
         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):
         """Remove the kernel/notebook mapping for 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):
         """Start a kernel for a notebok an return its kernel_id.
 
         Parameters
         ----------
         notebook_id : uuid
             The uuid of the notebook to associate the new kernel with. If this
             is not None, this kernel will be persistent whenever the notebook
             requests a kernel.
         """
         kernel_id = self.kernel_for_notebook(notebook_id)
         if kernel_id is None:
             kwargs = dict()
             kwargs['extra_arguments'] = self.kernel_argv
             kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)
             self.set_kernel_for_notebook(notebook_id, kernel_id)
             self.log.info("Kernel started: %s" % kernel_id)
             self.log.debug("Kernel args: %r" % kwargs)
         else:
             self.log.info("Using existing kernel: %s" % kernel_id)
         return kernel_id
 
     def kill_kernel(self, kernel_id):
         """Kill a kernel and remove its notebook association."""
         if kernel_id not in self:
             raise web.HTTPError(404)
         super(MappingKernelManager, self).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):
         """Interrupt a kernel."""
         if kernel_id not in self:
             raise web.HTTPError(404)
         super(MappingKernelManager, self).interrupt_kernel(kernel_id)
         self.log.info("Kernel interrupted: %s" % kernel_id)
 
     def restart_kernel(self, kernel_id):
         """Restart a kernel while keeping clients connected."""
         if kernel_id not in self:
             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()
         # Now kill the old kernel.
         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.set_kernel_for_notebook(notebook_id, new_kernel_id)
-        self.log.debug("Kernel restarted: %s" % new_kernel_id)
+        self.log.info("Kernel restarted: %s" % new_kernel_id)
         return new_kernel_id
 
+    def create_iopub_stream(self, kernel_id):
+        if kernel_id not in self:
+            raise web.HTTPError(404)
+        return super(MappingKernelManager, self).create_iopub_stream(kernel_id)
+
+    def create_shell_stream(self, kernel_id):
+        if kernel_id not in self:
+            raise web.HTTPError(404)
+        return super(MappingKernelManager, self).create_shell_stream(kernel_id)
+
+    def create_hb_stream(self, kernel_id):
+        if kernel_id not in self:
+            raise web.HTTPError(404)
+        return super(MappingKernelManager, self).create_hb_stream(kernel_id)
 

IPython/frontend/html/notebook/notebookapp.py

@@ -1,244 +1,261 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 errno
 import logging
 import os
 import signal
 import socket
 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 MappingKernelManager
 from .handlers import (
     NBBrowserHandler, NewHandler, NamedNotebookHandler,
     MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler,
     ShellHandler, NotebookRootHandler, NotebookHandler, RSTHandler
 )
 from .notebookmanager import NotebookManager
 
 from IPython.core.application import BaseIPythonApplication
 from IPython.core.profiledir import ProfileDir
 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, 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'
 
 _examples = """
 ipython notebook                       # start the notebook
 ipython notebook --profile=sympy       # use the sympy profile
 ipython notebook --pylab=inline        # pylab in inline plotting mode
 ipython notebook --certfile=mycert.pem # use SSL/TLS certificate
 ipython notebook --port=5555 --ip=*    # Listen on port 5555, all interfaces
 """
 
 #-----------------------------------------------------------------------------
 # The Tornado web application
 #-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
-    def __init__(self, kernel_manager, notebook_manager, log):
+    def __init__(self, ipython_app, kernel_manager, notebook_manager, log):
         handlers = [
             (r"/", NBBrowserHandler),
             (r"/new", NewHandler),
             (r"/%s" % _notebook_id_regex, NamedNotebookHandler),
             (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, IOPubHandler),
             (r"/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
             (r"/notebooks", NotebookRootHandler),
             (r"/notebooks/%s" % _notebook_id_regex, NotebookHandler),
             (r"/rstservice/render", RSTHandler)
         ]
         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.log = log
         self.notebook_manager = notebook_manager
+        self.ipython_app = ipython_app
 
 
 #-----------------------------------------------------------------------------
 # 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({
     'ip': 'IPythonNotebookApp.ip',
     'port': 'IPythonNotebookApp.port',
     'keyfile': 'IPythonNotebookApp.keyfile',
     'certfile': 'IPythonNotebookApp.certfile',
+    'ws-hostname': 'IPythonNotebookApp.ws_hostname',
     'notebook-dir': 'NotebookManager.notebook_dir'
 })
 
 #-----------------------------------------------------------------------------
 # 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.
     """
     examples = _examples
     
     classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session,
                MappingKernelManager, NotebookManager]
     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.")
 
     # Network related information.
 
     ip = Unicode(LOCALHOST, config=True,
         help="The IP address the notebook server will listen on."
     )
 
     def _ip_changed(self, name, old, new):
         if new == u'*': self.ip = u''
 
     port = Int(8888, config=True,
         help="The port the notebook server will listen on."
     )
 
+    ws_hostname = Unicode(LOCALHOST, config=True,
+        help="""The FQDN or IP for WebSocket connections. The default will work
+                fine when the server is listening on localhost, but this needs to
+                be set if the ip option is used. It will be used as the hostname part
+                of the WebSocket url: ws://hostname/path."""
+    )
+
     certfile = Unicode(u'', config=True, 
         help="""The full path to an SSL/TLS certificate file."""
     )
     
     keyfile = Unicode(u'', config=True, 
         help="""The full path to a private key file for usage with SSL/TLS."""
     )
 
+    def get_ws_url(self):
+        """Return the WebSocket URL for this server."""
+        if self.certfile:
+            prefix = u'wss://'
+        else:
+            prefix = u'ws://'
+        return prefix + self.ws_hostname + u':' + unicode(self.port)
+
     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_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 = MappingKernelManager(
             config=self.config, log=self.log, 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_configurables()
         self.web_app = NotebookWebApplication(
-            self.kernel_manager, self.notebook_manager, self.log
+            self, self.kernel_manager, self.notebook_manager, self.log
         )
         if self.certfile:
             ssl_options = dict(certfile=self.certfile)
             if self.keyfile:
                 ssl_options['keyfile'] = self.keyfile
         else:
             ssl_options = None
         self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options)
         if ssl_options is None and not self.ip:
             self.log.critical('WARNING: the notebook server is listening on all IP addresses '
                               'but not using any encryption or authentication. This is highly '
                               'insecure and not recommended.')
         for i in range(10):
             try:
                 port = self.port + i
                 self.http_server.listen(port, self.ip)
             except socket.error, e:
                 if e.errno != errno.EADDRINUSE:
                     raise
                 self.log.info('The port %i is already in use, trying: %i' % (port, port+1))
             else:
                 self.port = port
                 break
     
 
     def start(self):
         ip = self.ip if self.ip else '[all ip addresses on your system]'
         self.log.info("The IPython Notebook is running at: http://%s:%i" % (ip, self.port))
         ioloop.IOLoop.instance().start()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def launch_new_instance():
     app = IPythonNotebookApp()
     app.initialize()
     app.start()
 

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

@@ -1,141 +1,143 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;
         this.shell_channel = null;
         this.iopub_channel = null;
         this.running = false;
     };
 
 
     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 = function (notebook_id, callback) {
         var that = this;
         if (!this.running) {
             var qs = $.param({notebook:notebook_id});
             $.post(this.base_url + '?' + qs,
                 function (kernel_id) {
                     that._handle_start_kernel(kernel_id, callback);
                 }, 
                 'json'
             );
         };
     };
 
 
     Kernel.prototype.restart = function (callback) {
         IPython.kernel_status_widget.status_restarting();
         var url = this.kernel_url + "/restart";
         var that = this;
         if (this.running) {
             this.stop_channels();
             $.post(url,
                 function (kernel_id) {
                     that._handle_start_kernel(kernel_id, callback);
                 },
                 'json'
             );
         };
     };
 
 
-    Kernel.prototype._handle_start_kernel = function (kernel_id, callback) {
+    Kernel.prototype._handle_start_kernel = function (json, callback) {
         this.running = true;
-        this.kernel_id = kernel_id;
+        this.kernel_id = json.kernel_id;
+        this.ws_url = json.ws_url;
         this.kernel_url = this.base_url + "/" + this.kernel_id;
         this.start_channels();
         callback();
         IPython.kernel_status_widget.status_idle();
     };
 
 
     Kernel.prototype.start_channels = function () {
         this.stop_channels();
-        var ws_url = "ws://127.0.0.1:8888" + this.kernel_url;
+        var ws_url = this.ws_url + this.kernel_url;
+        console.log("Starting WS:", ws_url);
         this.shell_channel = new WebSocket(ws_url + "/shell");
         this.iopub_channel = new WebSocket(ws_url + "/iopub");
     };
 
 
     Kernel.prototype.stop_channels = function () {
         if (this.shell_channel !== null) {
             this.shell_channel.close();
             this.shell_channel = null;
         };
         if (this.iopub_channel !== null) {
             this.iopub_channel.close();
             this.iopub_channel = null;
         };
     };
 
     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 () {
         if (this.running) {
             $.post(this.kernel_url + "/interrupt");
         };
     };
 
 
     Kernel.prototype.kill = function () {
         if (this.running) {
             this.running = false;
             var settings = {
                 cache : false,
                 type : "DELETE",
             };
             $.ajax(this.kernel_url, settings);
         };
     };
 
     IPython.Kernel = Kernel;
 
     return IPython;
 
 }(IPython));