Refactored htmlnotebook session and kernel manager.

* The KernelManager now manages multiple kernels with a uniform
  API.
* The SessionManager now manages the full set of channels+streams
  and the IPython.zmq.session.Session object for a single kernel.

IPython/frontend/html/notebook/sessionmanager.py

@@ -0,0 +1,75 b''
+"""A manager for session and channels for a single kernel."""
+
+import zmq
+from zmq.eventloop.zmqstream import ZMQStream
+
+from IPython.utils.traitlets import Instance, Dict, CBytes, Bool
+from IPython.zmq.session import SessionFactory
+
+
+class SessionManagerRunningError(Exception):
+    pass
+
+
+class SessionManager(SessionFactory):
+    """Manages a session for a kernel.
+
+    The object manages a variety of things for a connection session to
+    a running kernel:
+
+    * The set of channels or connected ZMQ streams to the kernel.
+    * An IPython.zmq.session.Session object that manages send/recv logic
+      for those channels.
+    """
+
+    kernel_manager = Instance('IPython.frontend.html.notebook.kernelmanager.KernelManager')
+    kernel_id = CBytes(b'')
+    _session_streams = Dict()
+    _running = Bool(False)
+
+    def __init__(self, **kwargs):
+        kernel_id = kwargs.pop('kernel_id')
+        super(SessionManager, self).__init__(**kwargs)
+        self.kernel_id = kernel_id
+        self.start()
+
+    def __del__(self):
+        self.stop()
+
+    def start(self):
+        if not self._running:
+            ports = self.kernel_manager.get_kernel_ports(self.kernel_id)
+            iopub_stream = self.create_connected_stream(ports['iopub_port'], zmq.SUB)
+            iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
+            shell_stream = self.create_connected_stream(ports['shell_port'], zmq.XREQ)
+            self._session_streams = dict(
+                iopub_stream = iopub_stream,
+                shell_stream = shell_stream
+            )
+            self._running = True
+        else:
+            raise SessionManagerRunningError(
+                'Session manager is already running, call stop() before start()'
+            )
+
+    def stop(self):
+        if self._running:
+            for name, stream in self._session_streams.items():
+                stream.close()
+            self._session_streams = {}
+            self._running = False
+
+    def create_connected_stream(self, port, socket_type):
+        sock = self.context.socket(socket_type)
+        addr = "tcp://%s:%i" % (self.kernel_manager.get_kernel_ip(self.kernel_id), port)
+        self.log.info("Connecting to: %s, %r" % (addr, socket_type))
+        sock.connect(addr)
+        return ZMQStream(sock)
+
+    def get_iopub_stream(self):
+        return self._session_streams['iopub_stream']
+
+    def get_shell_stream(self):
+        return self._session_streams['shell_stream']
+
+

IPython/frontend/html/notebook/tests/test_kernelsession.py

@@ -0,0 +1,38 b''
+
+from unittest import TestCase
+
+from IPython.frontend.html.notebook.kernelmanager import KernelManager
+from IPython.frontend.html.notebook.sessionmanager import SessionManagerRunningError
+
+class TestKernelManager(TestCase):
+
+    def test_km_lifecycle(self):
+        km = KernelManager()
+        kid = km.start_kernel()
+        self.assert_(kid in km)
+        self.assertEquals(len(km),1)
+        km.kill_kernel(kid)
+        self.assert_(not kid in km)
+
+        kid = km.start_kernel()
+        self.assertEquals('127.0.0.1',km.get_kernel_ip(kid))
+        port_dict = km.get_kernel_ports(kid)
+        self.assert_('stdin_port' in port_dict)
+        self.assert_('iopub_port' in port_dict)
+        self.assert_('shell_port' in port_dict)
+        self.assert_('hb_port' in port_dict)
+        km.get_kernel_process(kid)
+
+    def test_session_manager(self):
+        km = KernelManager()
+        kid = km.start_kernel()
+        sm = km.create_session_manager(kid)
+        self.assert_(sm._running)
+        sm.stop()
+        self.assert_(not sm._running)
+        sm.start()
+        self.assertRaises(SessionManagerRunningError, sm.start)
+        sm.get_iopub_stream()
+        sm.get_shell_stream()
+        sm.session
+

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,28 +1,41 b''
+"""A kernel manager for multiple kernels."""
+
+import logging
 import signal
 import sys
 import uuid
 
+import zmq
+
+from IPython.config.configurable import Configurable
 from IPython.zmq.ipkernel import launch_kernel
-from session import SessionManager
+from IPython.utils.traitlets import Instance, Dict, Unicode
 
 
 class DuplicateKernelError(Exception):
     pass
 
 
-class KernelManager(object):
+class KernelManager(Configurable):
+    """A class for managing multiple kernels."""
+
+    context = Instance('zmq.Context')
+    def _context_default(self):
+        return zmq.Context.instance()
 
-    ip = '127.0.0.1'
+    logname = Unicode('')
+    def _logname_changed(self, name, old, new):
+        self.log = logging.getLogger(new)
 
-    def __init__(self, context):
-        self.context = context
-        self._kernels = {}
+    _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):
@@ -31,21 +44,31 b' class KernelManager(object):'
         else:
             return False
 
-    def start_kernel(self):
+    def start_kernel(self, **kwargs):
+        """Start a new kernel."""
         kernel_id = str(uuid.uuid4())
-        (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel(pylab='inline')
+        (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,
-            session_manager = SessionManager(self, kernel_id, self.context)
+            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.
@@ -59,6 +82,13 b' class KernelManager(object):'
             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':
@@ -68,14 +98,28 b' class KernelManager(object):'
                 kernel_process.send_signal(signal.SIGINT)
 
     def signal_kernel(self, kernel_id, signum):
-        """ Sends a signal to the kernel. Note that since only SIGTERM is
-        supported on Windows, this function is only useful on Unix systems.
+        """ 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']
@@ -83,20 +127,53 b' class KernelManager(object):'
             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_session_manager(self, 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['session_manager']
+            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, logname=self.logname
+        )