* Implemented a proper main() function for kernel.py that reads command line input.

* Added options to launch_kernel() for specifying particular ports.
* Wrote preliminary implementation for the KernelManager's start_kernel() and kill_kernel() methods
* Updated IPythonWidget test script to reflect new functionality.

IPython/frontend/qt/console/ipython_widget.py

@@ -1,96 +1,96 b''
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from frontend_widget import FrontendWidget
 
 
 class IPythonWidget(FrontendWidget):
     """ A FrontendWidget for an IPython kernel.
     """
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, parent=None):
         super(IPythonWidget, self).__init__(parent)
 
         self._magic_overrides = {}
 
     def execute_source(self, source, hidden=False, interactive=False):
         """ Reimplemented to override magic commands.
         """
         magic_source = source.strip()
         if magic_source.startswith('%'):
             magic_source = magic_source[1:]
         magic, sep, arguments = magic_source.partition(' ')
         if not magic:
             magic = magic_source
 
         callback = self._magic_overrides.get(magic)
         if callback:
             output = callback(arguments)
             if output:
                 self.appendPlainText(output)
             self._show_prompt('>>> ')
             return True
         else:
             return super(IPythonWidget, self).execute_source(source, hidden,
                                                              interactive)
 
     #---------------------------------------------------------------------------
     # 'IPythonWidget' interface
     #---------------------------------------------------------------------------
 
     def set_magic_override(self, magic, callback):
         """ Overrides an IPython magic command. This magic will be intercepted
             by the frontend rather than passed on to the kernel and 'callback'
             will be called with a single argument: a string of argument(s) for
             the magic. The callback can (optionally) return text to print to the
             console.
         """
         self._magic_overrides[magic] = callback
 
     def remove_magic_override(self, magic):
         """ Removes the override for the specified magic, if there is one.
         """
         try:
             del self._magic_overrides[magic]
         except KeyError:
             pass
 
 
 if __name__ == '__main__':
-    from IPython.external.argparse import ArgumentParser
-    from IPython.frontend.qt.kernelmanager import QtKernelManager
-
-    # Don't let Qt swallow KeyboardInterupts.
     import signal
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    from IPython.frontend.qt.kernelmanager import QtKernelManager
 
-    # Parse command line arguments.
-    parser = ArgumentParser()
-    parser.add_argument('--ip', type=str, default='127.0.0.1',
-                        help='set the kernel\'s IP address [default localhost]')
-    parser.add_argument('--xreq', type=int, metavar='PORT', default=5575,
-                        help='set the XREQ Channel port [default %(default)i]')
-    parser.add_argument('--sub', type=int, metavar='PORT', default=5576,
-                        help='set the SUB Channel port [default %(default)i]')
-    namespace = parser.parse_args()
-
-    # Create KernelManager
-    ip = namespace.ip
-    kernel_manager = QtKernelManager(xreq_address = (ip, namespace.xreq),
-                                     sub_address = (ip, namespace.sub))
+    # Create a KernelManager.
+    kernel_manager = QtKernelManager()
+    kernel_manager.start_kernel()
     kernel_manager.start_listening()
 
-    # Launch application
+    # Don't let Qt or ZMQ swallow KeyboardInterupts.
+    # FIXME: Gah, ZMQ swallows even custom signal handlers. So for now we leave 
+    #        behind a kernel process when Ctrl-C is pressed.
+    #def sigint_hook(signum, frame):
+    #    QtGui.qApp.quit()
+    #signal.signal(signal.SIGINT, sigint_hook)
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+    # Create the application, making sure to clean up nicely when we exit.
     app = QtGui.QApplication([])
+    def quit_hook():
+        kernel_manager.stop_listening()
+        kernel_manager.kill_kernel()
+    app.aboutToQuit.connect(quit_hook)
+
+    # Launch the application.
     widget = IPythonWidget()
     widget.kernel_manager = kernel_manager
     widget.setWindowTitle('Python')
     widget.resize(640, 480)
     widget.show()
     app.exec_()
     
+    

IPython/zmq/kernel.py

@@ -1,349 +1,361 b''
 #!/usr/bin/env python
 """A simple interactive kernel that talks to a frontend over 0MQ.
 
 Things to do:
 
 * Finish implementing `raw_input`.
 * Implement `set_parent` logic. Right before doing exec, the Kernel should
   call set_parent on all the PUB objects with the message about to be executed.
 * Implement random port and security key logic.
 * Implement control messages.
 * Implement event loop and poll version.
 """
 
 # Standard library imports.
 import __builtin__
 import sys
 import time
 import traceback
 from code import CommandCompiler
 
 # System library imports.
 import zmq
 
 # Local imports.
+from IPython.external.argparse import ArgumentParser
 from session import Session, Message, extract_header
 from completer import KernelCompleter
 
 
 class OutStream(object):
     """A file like object that publishes the stream to a 0MQ PUB socket."""
 
     def __init__(self, session, pub_socket, name, max_buffer=200):
         self.session = session
         self.pub_socket = pub_socket
         self.name = name
         self._buffer = []
         self._buffer_len = 0
         self.max_buffer = max_buffer
         self.parent_header = {}
 
     def set_parent(self, parent):
         self.parent_header = extract_header(parent)
 
     def close(self):
         self.pub_socket = None
 
     def flush(self):
         if self.pub_socket is None:
             raise ValueError(u'I/O operation on closed file')
         else:
             if self._buffer:
                 data = ''.join(self._buffer)
                 content = {u'name':self.name, u'data':data}
                 msg = self.session.msg(u'stream', content=content,
                                        parent=self.parent_header)
                 print>>sys.__stdout__, Message(msg)
                 self.pub_socket.send_json(msg)
                 self._buffer_len = 0
                 self._buffer = []
 
     def isattr(self):
         return False
 
     def next(self):
         raise IOError('Read not supported on a write only stream.')
 
     def read(self, size=None):
         raise IOError('Read not supported on a write only stream.')
 
     readline=read
 
     def write(self, s):
         if self.pub_socket is None:
             raise ValueError('I/O operation on closed file')
         else:
             self._buffer.append(s)
             self._buffer_len += len(s)
             self._maybe_send()
 
     def _maybe_send(self):
         if '\n' in self._buffer[-1]:
             self.flush()
         if self._buffer_len > self.max_buffer:
             self.flush()
 
     def writelines(self, sequence):
         if self.pub_socket is None:
             raise ValueError('I/O operation on closed file')
         else:
             for s in sequence:
                 self.write(s)
 
 
 class DisplayHook(object):
 
     def __init__(self, session, pub_socket):
         self.session = session
         self.pub_socket = pub_socket
         self.parent_header = {}
 
     def __call__(self, obj):
         if obj is None:
             return
 
         __builtin__._ = obj
         msg = self.session.msg(u'pyout', {u'data':repr(obj)},
                                parent=self.parent_header)
         self.pub_socket.send_json(msg)
 
     def set_parent(self, parent):
         self.parent_header = extract_header(parent)
 
 
 class RawInput(object):
 
     def __init__(self, session, socket):
         self.session = session
         self.socket = socket
 
     def __call__(self, prompt=None):
         msg = self.session.msg(u'raw_input')
         self.socket.send_json(msg)
         while True:
             try:
                 reply = self.socket.recv_json(zmq.NOBLOCK)
             except zmq.ZMQError, e:
                 if e.errno == zmq.EAGAIN:
                     pass
                 else:
                     raise
             else:
                 break
         return reply[u'content'][u'data']
 
 
 class Kernel(object):
 
     def __init__(self, session, reply_socket, pub_socket):
         self.session = session
         self.reply_socket = reply_socket
         self.pub_socket = pub_socket
         self.user_ns = {}
         self.history = []
         self.compiler = CommandCompiler()
         self.completer = KernelCompleter(self.user_ns)
         
         # Build dict of handlers for message types
         msg_types = [ 'execute_request', 'complete_request', 
                       'object_info_request' ]
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def abort_queue(self):
         while True:
             try:
                 ident = self.reply_socket.recv(zmq.NOBLOCK)
             except zmq.ZMQError, e:
                 if e.errno == zmq.EAGAIN:
                     break
             else:
                 assert self.reply_socket.rcvmore(), "Unexpected missing message part."
                 msg = self.reply_socket.recv_json()
             print>>sys.__stdout__, "Aborting:"
             print>>sys.__stdout__, Message(msg)
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
             print>>sys.__stdout__, Message(reply_msg)
             self.reply_socket.send(ident,zmq.SNDMORE)
             self.reply_socket.send_json(reply_msg)
             # We need to wait a bit for requests to come in. This can probably
             # be set shorter for true asynchronous clients.
             time.sleep(0.1)
 
     def execute_request(self, ident, parent):
         try:
             code = parent[u'content'][u'code']
         except:
             print>>sys.__stderr__, "Got bad msg: "
             print>>sys.__stderr__, Message(parent)
             return
         pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
         self.pub_socket.send_json(pyin_msg)
         try:
             comp_code = self.compiler(code, '<zmq-kernel>')
             sys.displayhook.set_parent(parent)
             exec comp_code in self.user_ns, self.user_ns
         except:
             result = u'error'
             etype, evalue, tb = sys.exc_info()
             tb = traceback.format_exception(etype, evalue, tb)
             exc_content = {
                 u'status' : u'error',
                 u'traceback' : tb,
                 u'etype' : unicode(etype),
                 u'evalue' : unicode(evalue)
             }
             exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.pub_socket.send_json(exc_msg)
             reply_content = exc_content
         else:
             reply_content = {'status' : 'ok'}
         reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         print>>sys.__stdout__, Message(reply_msg)
         self.reply_socket.send(ident, zmq.SNDMORE)
         self.reply_socket.send_json(reply_msg)
         if reply_msg['content']['status'] == u'error':
             self.abort_queue()
 
     def complete_request(self, ident, parent):
         matches = {'matches' : self.complete(parent),
                    'status' : 'ok'}
         completion_msg = self.session.send(self.reply_socket, 'complete_reply',
                                            matches, parent, ident)
         print >> sys.__stdout__, completion_msg
 
     def complete(self, msg):
         return self.completer.complete(msg.content.line, msg.content.text)
 
     def object_info_request(self, ident, parent):
         context = parent['content']['oname'].split('.')
         object_info = self.object_info(context)
         msg = self.session.send(self.reply_socket, 'object_info_reply',
                                 object_info, parent, ident)
         print >> sys.__stdout__, msg
 
     def object_info(self, context):
         symbol, leftover = self.symbol_from_context(context)
         if symbol is not None and not leftover:
             doc = getattr(symbol, '__doc__', '')
         else:
             doc = ''
         object_info = dict(docstring = doc)
         return object_info
 
     def symbol_from_context(self, context):
         if not context:
             return None, context
 
         base_symbol_string = context[0]
         symbol = self.user_ns.get(base_symbol_string, None)
         if symbol is None:
             symbol = __builtin__.__dict__.get(base_symbol_string, None)
         if symbol is None:
             return None, context
 
         context = context[1:]
         for i, name in enumerate(context):
             new_symbol = getattr(symbol, name, None)
             if new_symbol is None:
                 return symbol, context[i:]
             else:
                 symbol = new_symbol
 
         return symbol, []
 
     def start(self):
         while True:
             ident = self.reply_socket.recv()
             assert self.reply_socket.rcvmore(), "Unexpected missing message part."
             msg = self.reply_socket.recv_json()
             omsg = Message(msg)
             print>>sys.__stdout__
             print>>sys.__stdout__, omsg
             handler = self.handlers.get(omsg.msg_type, None)
             if handler is None:
                 print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg
             else:
                 handler(ident, omsg)
 
 
 def bind_port(socket, ip, port):
     """ Binds the specified ZMQ socket. If the port is less than zero, a random
     port is chosen. Returns the port that was bound.
     """
     connection = 'tcp://%s' % ip
     if port < 0:
         port = socket.bind_to_random_port(connection)
     else:
         connection += ':%i' % port
         socket.bind(connection)
     return port
 
-def main(ip='127.0.0.1', rep_port=-1, pub_port=-1):
-    """ Start a kernel on 'ip' (default localhost) at the specified ports. If
-    ports are not specified, they are chosen at random.
+def main():
+    """ Main entry point for launching a kernel.
     """
+    # Parse command line arguments.
+    parser = ArgumentParser()
+    parser.add_argument('--ip', type=str, default='127.0.0.1',
+                        help='set the kernel\'s IP address [default: local]')
+    parser.add_argument('--xrep', type=int, metavar='PORT', default=-1,
+                        help='set the XREP Channel port [default: random]')
+    parser.add_argument('--pub', type=int, metavar='PORT', default=-1,
+                        help='set the PUB Channel port [default: random]')
+    namespace = parser.parse_args()
+
+    # Create context, session, and kernel sockets.
     print >>sys.__stdout__, "Starting the kernel..."
-
     context = zmq.Context()
     session = Session(username=u'kernel')
 
     reply_socket = context.socket(zmq.XREP)
-    rep_port = bind_port(reply_socket, ip, rep_port)
-    print >>sys.__stdout__, "XREP Channel on port", rep_port
+    xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep)
+    print >>sys.__stdout__, "XREP Channel on port", xrep_port
 
     pub_socket = context.socket(zmq.PUB)
-    pub_port = bind_port(pub_socket, ip, pub_port)
+    pub_port = bind_port(pub_socket, namespace.ip, namespace.pub)
     print >>sys.__stdout__, "PUB Channel on port", pub_port
 
+    # Redirect input streams and set a display hook.
     sys.stdout = OutStream(session, pub_socket, u'stdout')
     sys.stderr = OutStream(session, pub_socket, u'stderr')
     sys.displayhook = DisplayHook(session, pub_socket)
 
     kernel = Kernel(session, reply_socket, pub_socket)
 
     # For debugging convenience, put sleep and a string in the namespace, so we
     # have them every time we start.
     kernel.user_ns['sleep'] = time.sleep
     kernel.user_ns['s'] = 'Test string'
     
     print >>sys.__stdout__, "Use Ctrl-\\ (NOT Ctrl-C!) to terminate."
     kernel.start()
 
-def launch_kernel():
-    """ Launches a kernel on this machine and binds its to channels to open
-    ports as it determined by the OS.
+def launch_kernel(xrep_port=-1, pub_port=-1):
+    """ Launches a localhost kernel, binding to the specified ports. For any
+    port that is left unspecified, a port is chosen by the operating system.
 
     Returns a tuple of form:
         (kernel_process [Popen], rep_port [int], sub_port [int])
     """
     import socket
     from subprocess import Popen
 
-    # Find some open ports.
+    # Find open ports as necessary.
     ports = []
-    for i in xrange(2):
+    ports_needed = int(xrep_port < 0) + int(pub_port < 0)
+    for i in xrange(ports_needed):
         sock = socket.socket()
         sock.bind(('', 0))
         ports.append(sock)
     for i, sock in enumerate(ports):
         port = sock.getsockname()[1]
         sock.close()
         ports[i] = port
-    rep_port, sub_port = ports
+    if xrep_port < 0:
+        xrep_port = ports.pop()
+    if pub_port < 0:
+        pub_port = ports.pop()
 
     # Spawn a kernel.
-    command = 'from IPython.zmq.kernel import main;' \
-              'main(rep_port=%i, pub_port=%i)'
-    proc = Popen([sys.executable, '-c', command % (rep_port, sub_port)])
-
-    return proc, rep_port, sub_port
+    command = 'from IPython.zmq.kernel import main; main()'
+    proc = Popen([ sys.executable, '-c', command, 
+                   '--xrep', str(xrep_port), '--pub', str(pub_port) ])
+    return proc, xrep_port, pub_port
 
 
 if __name__ == '__main__':
-    base_port = 5575
-    main(rep_port = base_port, 
-         pub_port = base_port + 1)
+    main()

IPython/zmq/kernelmanager.py

@@ -1,433 +1,451 b''
 """Kernel frontend classes.
 
 TODO: Create logger to handle debugging and console messages.
 
 """
 
 # Standard library imports.
 from Queue import Queue, Empty
+from subprocess import Popen
 from threading import Thread
 import time
 import traceback
 
 # System library imports.
 import zmq
 from zmq import POLLIN, POLLOUT, POLLERR
 from zmq.eventloop import ioloop
 
 # Local imports.
 from IPython.utils.traitlets import HasTraits, Any, Bool, Int, Instance, Str, \
     Type
+from kernel import launch_kernel
 from session import Session
 
+# Constants.
+LOCALHOST = '127.0.0.1'
+
 
 class MissingHandlerError(Exception):
     pass
 
 
 class ZmqSocketChannel(Thread):
     """ The base class for the channels that use ZMQ sockets.
     """
 
     def __init__(self, context, session, address=None):
         super(ZmqSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         self.address = address
         self.socket = None
 
     def stop(self):
         """ Stop the thread's activity. Returns when the thread terminates.
         """
         self.join()
 
         # Allow the thread to be started again.
         # FIXME: Although this works (and there's no reason why it shouldn't),
         #        it feels wrong. Is there a cleaner way to achieve this?
         Thread.__init__(self)
 
     def get_address(self):
-        """ Get the channel's address.
+        """ Get the channel's address. By the default, a channel is on 
+            localhost with no port specified (a negative port number).
         """
         return self._address
 
     def set_adresss(self, address):
         """ Set the channel's address. Should be a tuple of form:
-                (ip address [str], port [int])
-            or 'None' to indicate that no address has been specified.
+                (ip address [str], port [int]).
+            or None, in which case the address is reset to its default value.
         """
         # FIXME: Validate address.
         if self.is_alive():
             raise RuntimeError("Cannot set address on a running channel!")
         else:
+            if address is None:
+                address = (LOCALHOST, -1)
             self._address = address
 
     address = property(get_address, set_adresss)
 
 
 class SubSocketChannel(ZmqSocketChannel):
 
     handlers = None
     _overriden_call_handler = None
 
     def __init__(self, context, session, address=None):
         self.handlers = {}
         super(SubSocketChannel, self).__init__(context, session, address)
 
     def run(self):
         self.socket = self.context.socket(zmq.SUB)
         self.socket.setsockopt(zmq.SUBSCRIBE,'')
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.ioloop = ioloop.IOLoop()
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 POLLIN|POLLERR)
         self.ioloop.start()
 
     def stop(self):
         self.ioloop.stop()
         super(SubSocketChannel, self).stop()
 
     def _handle_events(self, socket, events):
         # Turn on and off POLLOUT depending on if we have made a request
         if events & POLLERR:
             self._handle_err()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_err(self):
         raise zmq.ZmqError()
 
     def _handle_recv(self):
         msg = self.socket.recv_json()
         self.call_handlers(msg)
 
     def override_call_handler(self, func):
         """Permanently override the call_handler.
     
         The function func will be called as::
 
             func(handler, msg)
 
         And must call::
         
             handler(msg)
 
         in the main thread.
         """
         assert callable(func), "not a callable: %r" % func
         self._overriden_call_handler = func
 
     def call_handlers(self, msg):
         handler = self.handlers.get(msg['msg_type'], None)
         if handler is not None:
             try:
                 self.call_handler(handler, msg)
             except:
                 # XXX: This should be logged at least
                 traceback.print_last()
 
     def call_handler(self, handler, msg):
         if self._overriden_call_handler is not None:
             self._overriden_call_handler(handler, msg)
         elif hasattr(self, '_call_handler'):
            call_handler = getattr(self, '_call_handler')
            call_handler(handler, msg)
         else:
             raise RuntimeError('no handler!')
 
     def add_handler(self, callback, msg_type):
         """Register a callback for msg type."""
         self.handlers[msg_type] = callback
 
     def remove_handler(self, msg_type):
         """Remove the callback for msg type."""
         self.handlers.pop(msg_type, None)
 
     def flush(self):
         """Immediately processes all pending messages on the SUB channel. This
            method is thread safe.
         """
         self._flushed = False
         self.ioloop.add_callback(self._flush)
         while not self._flushed:
             time.sleep(0.01)
         
     def _flush(self):
         """Called in this thread by the IOLoop to indicate that all events have
            been processed.
         """
         self._flushed = True
 
 
 class XReqSocketChannel(ZmqSocketChannel):
 
     handler_queue = None
     command_queue = None
     handlers = None
     _overriden_call_handler = None
 
     def __init__(self, context, session, address=None):
         self.handlers = {}
         self.handler_queue = Queue()
         self.command_queue = Queue()
         super(XReqSocketChannel, self).__init__(context, session, address)
 
     def run(self):
         self.socket = self.context.socket(zmq.XREQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.ioloop = ioloop.IOLoop()
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 POLLIN|POLLOUT|POLLERR)
         self.ioloop.start()
 
     def stop(self):
         self.ioloop.stop()
         super(XReqSocketChannel, self).stop()
 
     def _handle_events(self, socket, events):
         # Turn on and off POLLOUT depending on if we have made a request
         if events & POLLERR:
             self._handle_err()
         if events & POLLOUT:
             self._handle_send()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_recv(self):
         msg = self.socket.recv_json()
         self.call_handlers(msg)
 
     def _handle_send(self):
         try:
             msg = self.command_queue.get(False)
         except Empty:
             pass
         else:
             self.socket.send_json(msg)
 
     def _handle_err(self):
         raise zmq.ZmqError()
 
     def _queue_request(self, msg, callback):
         handler = self._find_handler(msg['msg_type'], callback)
         self.handler_queue.put(handler)
         self.command_queue.put(msg)
 
     def execute(self, code, callback=None):
         # Create class for content/msg creation. Related to, but possibly
         # not in Session.
         content = dict(code=code)
         msg = self.session.msg('execute_request', content)
         self._queue_request(msg, callback)
         return msg['header']['msg_id']
 
     def complete(self, text, line, block=None, callback=None):
         content = dict(text=text, line=line)
         msg = self.session.msg('complete_request', content)
         self._queue_request(msg, callback)
         return msg['header']['msg_id']
 
     def object_info(self, oname, callback=None):
         content = dict(oname=oname)
         msg = self.session.msg('object_info_request', content)
         self._queue_request(msg, callback)
         return msg['header']['msg_id']
 
     def _find_handler(self, name, callback):
         if callback is not None:
             return callback
         handler = self.handlers.get(name)
         if handler is None:
             raise MissingHandlerError(
                 'No handler defined for method: %s' % name)
         return handler
 
     def override_call_handler(self, func):
         """Permanently override the call_handler.
     
         The function func will be called as::
 
             func(handler, msg)
 
         And must call::
         
             handler(msg)
 
         in the main thread.
         """
         assert callable(func), "not a callable: %r" % func
         self._overriden_call_handler = func
 
     def call_handlers(self, msg):
         try:
             handler = self.handler_queue.get(False)
         except Empty:
             print "Message received with no handler!!!"
             print msg
         else:
             self.call_handler(handler, msg)
 
     def call_handler(self, handler, msg):
         if self._overriden_call_handler is not None:
             self._overriden_call_handler(handler, msg)
         elif hasattr(self, '_call_handler'):
            call_handler = getattr(self, '_call_handler')
            call_handler(handler, msg)
         else:
             raise RuntimeError('no handler!')
 
 
 class RepSocketChannel(ZmqSocketChannel):
 
     def on_raw_input(self):
         pass
 
 
 class KernelManager(HasTraits):
     """ Manages a kernel for a frontend.
 
     The SUB channel is for the frontend to receive messages published by the
     kernel.
         
     The REQ channel is for the frontend to make requests of the kernel.
     
     The REP channel is for the kernel to request stdin (raw_input) from the
     frontend.
     """
 
     # Whether the kernel manager is currently listening on its channels.
     is_listening = Bool(False)
 
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context, ())
 
     # The Session to use for communication with the kernel.
     session = Instance(Session, ())
 
     # The classes to use for the various channels.
     sub_channel_class = Type(SubSocketChannel)
     xreq_channel_class = Type(XReqSocketChannel)
     rep_channel_class = Type(RepSocketChannel)
     
     # Protected traits.
+    _kernel = Instance(Popen)
     _sub_channel = Any
     _xreq_channel = Any
     _rep_channel = Any
 
     def __init__(self, **traits):
         super(KernelManager, self).__init__()
 
         # FIXME: This should be the business of HasTraits. The convention is:
         #        HasTraits.__init__(self, **traits_to_be_initialized.)
         for trait in traits:
             setattr(self, trait, traits[trait])
 
     def start_listening(self):
         """Start listening on the specified ports. If already listening, raises
         a RuntimeError.
         """
         if self.is_listening:
             raise RuntimeError("Cannot start listening. Already listening!")
         else:
             self.is_listening = True
             self.sub_channel.start()
             self.xreq_channel.start()
             self.rep_channel.start()
 
     def stop_listening(self):
         """Stop listening. If not listening, does nothing. """
         if self.is_listening:
             self.is_listening = False
             self.sub_channel.stop()
             self.xreq_channel.stop()
             self.rep_channel.stop()
 
     def start_kernel(self):
-        """Start a localhost kernel. If ports have been specified, use them.
-        Otherwise, choose an open port at random.
+        """Start a localhost kernel. If ports have been specified via the
+        address attributes, use them. Otherwise, choose open ports at random.
         """
-        # TODO: start a kernel.
-        self.start_listening()
+        xreq, sub = self.xreq_address, self.sub_address
+        if xreq[0] != LOCALHOST or sub[0] != LOCALHOST:
+            raise RuntimeError("Can only launch a kernel on localhost."
+                               "Make sure that the '*_address' attributes are "
+                               "configured properly.")
+
+        self._kernel, xrep, pub = launch_kernel(xrep_port=xreq[1], 
+                                                pub_port=sub[1])
+        self.xreq_address = (LOCALHOST, xrep)
+        self.sub_address = (LOCALHOST, pub)
 
     def kill_kernel(self):
-        """Kill the running kernel.
+        """Kill the running kernel, if there is one.
         """
-        # TODO: kill the kernel.
-        self.stop_listening()
+        if self._kernel:
+            self._kernel.kill()
+            self._kernel = None
 
     @property
     def is_alive(self):
         """ Returns whether the kernel is alive. """
         if self.is_listening:
             # TODO: check if alive.
             return True
         else:
             return False
 
     def signal_kernel(self, signum):
         """Send signum to the kernel."""
         # TODO: signal the kernel.
 
     #--------------------------------------------------------------------------
     # Channels used for communication with the kernel:
     #--------------------------------------------------------------------------
 
     @property
     def sub_channel(self):
         """Get the SUB socket channel object."""
         if self._sub_channel is None:
             self._sub_channel = self.sub_channel_class(self.context,
                                                        self.session)
         return self._sub_channel
 
     @property
     def xreq_channel(self):
         """Get the REQ socket channel object to make requests of the kernel."""
         if self._xreq_channel is None:
             self._xreq_channel = self.xreq_channel_class(self.context, 
                                                          self.session)
         return self._xreq_channel
 
     @property
     def rep_channel(self):
         """Get the REP socket channel object to handle stdin (raw_input)."""
         if self._rep_channel is None:
             self._rep_channel = self.rep_channel_class(self.context, 
                                                        self.session)
         return self._rep_channel
 
     #--------------------------------------------------------------------------
     # Channel address attributes:
     #--------------------------------------------------------------------------
 
     def get_sub_address(self):
         return self.sub_channel.address
 
     def set_sub_address(self, address):
         self.sub_channel.address = address
 
     sub_address = property(get_sub_address, set_sub_address,
                            doc="The address used by SUB socket channel.")
 
     def get_xreq_address(self):
         return self.xreq_channel.address
 
     def set_xreq_address(self, address):
         self.xreq_channel.address = address
 
     xreq_address = property(get_xreq_address, set_xreq_address,
                             doc="The address used by XREQ socket channel.")
     
     def get_rep_address(self):
         return self.rep_channel.address
 
     def set_rep_address(self, address):
         self.rep_channel.address = address
 
     rep_address = property(get_rep_address, set_rep_address,
                            doc="The address used by REP socket channel.")