zmq kernels now started via newapp

IPython/zmq/kernelapp.py

@@ -0,0 +1,213 b''
+#!/usr/bin/env python
+"""An Application for launching a kernel
+
+Authors
+-------
+* MinRK
+"""
+#-----------------------------------------------------------------------------
+#  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
+#-----------------------------------------------------------------------------
+
+# Standard library imports.
+import os
+import sys
+
+# System library imports.
+import zmq
+
+# IPython imports.
+from IPython.core.ultratb import FormattedTB
+from IPython.core.newapplication import (
+    BaseIPythonApplication, base_flags, base_aliases
+)
+from IPython.utils import io
+from IPython.utils.localinterfaces import LOCALHOST
+from IPython.utils.traitlets import Any, Instance, Dict, Unicode, Int, Bool
+from IPython.utils.importstring import import_item
+# local imports
+from IPython.zmq.heartbeat import Heartbeat
+from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows
+from IPython.zmq.session import Session
+
+
+#-----------------------------------------------------------------------------
+# Flags and Aliases
+#-----------------------------------------------------------------------------
+
+kernel_aliases = dict(base_aliases)
+kernel_aliases.update({
+    'ip' : 'KernelApp.ip',
+    'hb' : 'KernelApp.hb_port',
+    'shell' : 'KernelApp.shell_port',
+    'iopub' : 'KernelApp.iopub_port',
+    'stdin' : 'KernelApp.stdin_port',
+    'parent': 'KernelApp.parent',
+})
+if sys.platform.startswith('win'):
+    kernel_aliases['interrupt'] = 'KernelApp.interrupt'
+
+kernel_flags = dict(base_flags)
+kernel_flags.update({
+    'no-stdout' : (
+            {'KernelApp' : {'no_stdout' : True}},
+            "redirect stdout to the null device"),
+    'no-stderr' : (
+            {'KernelApp' : {'no_stderr' : True}},
+            "redirect stderr to the null device"),
+})
+
+
+#-----------------------------------------------------------------------------
+# Application class for starting a Kernel
+#-----------------------------------------------------------------------------
+
+class KernelApp(BaseIPythonApplication):
+    name='pykernel'
+    aliases = Dict(kernel_aliases)
+    flags = Dict(kernel_flags)
+
+    # the kernel class, as an importstring
+    kernel_class = Unicode('IPython.zmq.pykernel.Kernel')
+    kernel = Any()
+    poller = Any() # don't restrict this even though current pollers are all Threads
+    heartbeat = Instance(Heartbeat)
+    session = Instance('IPython.zmq.session.Session')
+    ports = Dict()
+
+    # connection info:
+    ip = Unicode(LOCALHOST, config=True,
+        help="Set the IP or interface on which the kernel will listen.")
+    hb_port = Int(0, config=True, help="set the heartbeat port [default: random]")
+    shell_port = Int(0, config=True, help="set the shell (XREP) port [default: random]")
+    iopub_port = Int(0, config=True, help="set the iopub (PUB) port [default: random]")
+    stdin_port = Int(0, config=True, help="set the stdin (XREQ) port [default: random]")
+
+    # streams, etc.
+    no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
+    no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
+    outstream_class = Unicode('IPython.zmq.iostream.OutStream', config=True,
+        help="The importstring for the OutStream factory")
+    displayhook_class = Unicode('IPython.zmq.displayhook.DisplayHook', config=True,
+        help="The importstring for the DisplayHook factory")
+
+    # polling
+    parent = Int(0, config=True,
+        help="""kill this process if its parent dies.  On Windows, the argument
+        specifies the HANDLE of the parent process, otherwise it is simply boolean.
+        """)
+    interrupt = Int(0, config=True,
+        help="""ONLY USED ON WINDOWS
+        Interrupt this process when the parent is signalled.
+        """)
+
+    def init_crash_handler(self):
+        # Install minimal exception handling
+        sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor',
+                                     ostream=sys.__stdout__)
+
+    def init_poller(self):
+        if sys.platform == 'win32':
+            if self.interrupt or self.parent:
+                self.poller = ParentPollerWindows(self.interrupt, self.parent)
+        elif self.parent:
+            self.poller = ParentPollerUnix()
+
+    def _bind_socket(self, s, port):
+        iface = 'tcp://%s' % self.ip
+        if port <= 0:
+            port = s.bind_to_random_port(iface)
+        else:
+            s.bind(iface + ':%i'%port)
+        return port
+
+    def init_sockets(self):
+        # Create a context, a session, and the kernel sockets.
+        io.raw_print("Starting the kernel at pid:", os.getpid())
+        context = zmq.Context.instance()
+        # Uncomment this to try closing the context.
+        # atexit.register(context.term)
+
+        self.shell_socket = context.socket(zmq.XREP)
+        self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
+        self.log.debug("shell XREP Channel on port: %i"%self.shell_port)
+
+        self.iopub_socket = context.socket(zmq.PUB)
+        self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
+        self.log.debug("iopub PUB Channel on port: %i"%self.iopub_port)
+
+        self.stdin_socket = context.socket(zmq.XREQ)
+        self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
+        self.log.debug("stdin XREQ Channel on port: %i"%self.stdin_port)
+
+        self.heartbeat = Heartbeat(context, (self.ip, self.hb_port))
+        self.hb_port = self.heartbeat.port
+        self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port)
+
+        # Helper to make it easier to connect to an existing kernel, until we have
+        # single-port connection negotiation fully implemented.
+        self.log.info("To connect another client to this kernel, use:")
+        self.log.info("--external shell={0} iopub={1} stdin={2} hb={3}".format(
+            self.shell_port, self.iopub_port, self.stdin_port, self.hb_port))
+
+
+        self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
+                                stdin=self.stdin_port, hb=self.hb_port)
+
+    def init_session(self):
+        """create our session object"""
+        self.session = Session(username=u'kernel')
+
+    def init_io(self):
+        """redirects stdout/stderr, and installs a display hook"""
+        # Re-direct stdout/stderr, if necessary.
+        if self.no_stdout or self.no_stderr:
+            blackhole = file(os.devnull, 'w')
+            if self.no_stdout:
+                sys.stdout = sys.__stdout__ = blackhole
+            if self.no_stderr:
+                sys.stderr = sys.__stderr__ = blackhole
+
+        # Redirect input streams and set a display hook.
+
+        if self.outstream_class:
+            outstream_factory = import_item(str(self.outstream_class))
+            sys.stdout = outstream_factory(self.session, self.iopub_socket, u'stdout')
+            sys.stderr = outstream_factory(self.session, self.iopub_socket, u'stderr')
+        if self.displayhook_class:
+            displayhook_factory = import_item(str(self.displayhook_class))
+            sys.displayhook = displayhook_factory(self.session, self.iopub_socket)
+
+    def init_kernel(self):
+        """Create the Kernel object itself"""
+        kernel_factory = import_item(str(self.kernel_class))
+        self.kernel = kernel_factory(config=self.config, session=self.session,
+                                shell_socket=self.shell_socket,
+                                iopub_socket=self.iopub_socket,
+                                stdin_socket=self.stdin_socket,
+        )
+        self.kernel.record_ports(self.ports)
+
+    def initialize(self, argv=None):
+        super(KernelApp, self).initialize(argv)
+        self.init_session()
+        self.init_poller()
+        self.init_sockets()
+        self.init_io()
+        self.init_kernel()
+
+    def start(self):
+        self.heartbeat.start()
+        if self.poller is not None:
+            self.poller.start()
+        try:
+            self.kernel.start()
+        except KeyboardInterrupt:
+            pass

IPython/zmq/logtopics.rst

@@ -0,0 +1,13 b''
+=======================
+Log Topic Specification
+=======================
+
+we use pyzmq to broadcast log events over a PUB socket. Engines, Controllers, etc. can all
+broadcast. SUB sockets can be used to view the logs, and ZMQ topics are used to help
+select out what to follow.
+
+the PUBHandler object that emits the logs can ascribe topics to log messages. The order is:
+
+<root_topic>.<loglevel>.<subtopic>[.<etc>]
+
+root_topic is specified as an attribute

IPython/zmq/tests/test_session.py

@@ -0,0 +1,111 b''
+"""test building messages with streamsession"""
+
+#-------------------------------------------------------------------------------
+#  Copyright (C) 2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# Imports
+#-------------------------------------------------------------------------------
+
+import os
+import uuid
+import zmq
+
+from zmq.tests import BaseZMQTestCase
+from zmq.eventloop.zmqstream import ZMQStream
+# from IPython.zmq.tests import SessionTestCase
+from IPython.parallel import streamsession as ss
+
+class SessionTestCase(BaseZMQTestCase):
+    
+    def setUp(self):
+        BaseZMQTestCase.setUp(self)
+        self.session = ss.StreamSession()
+
+class TestSession(SessionTestCase):
+    
+    def test_msg(self):
+        """message format"""
+        msg = self.session.msg('execute')
+        thekeys = set('header msg_id parent_header msg_type content'.split())
+        s = set(msg.keys())
+        self.assertEquals(s, thekeys)
+        self.assertTrue(isinstance(msg['content'],dict))
+        self.assertTrue(isinstance(msg['header'],dict))
+        self.assertTrue(isinstance(msg['parent_header'],dict))
+        self.assertEquals(msg['msg_type'], 'execute')
+        
+            
+    
+    def test_args(self):
+        """initialization arguments for StreamSession"""
+        s = self.session
+        self.assertTrue(s.pack is ss.default_packer)
+        self.assertTrue(s.unpack is ss.default_unpacker)
+        self.assertEquals(s.username, os.environ.get('USER', 'username'))
+        
+        s = ss.StreamSession()
+        self.assertEquals(s.username, os.environ.get('USER', 'username'))
+        
+        self.assertRaises(TypeError, ss.StreamSession, pack='hi')
+        self.assertRaises(TypeError, ss.StreamSession, unpack='hi')
+        u = str(uuid.uuid4())
+        s = ss.StreamSession(username='carrot', session=u)
+        self.assertEquals(s.session, u)
+        self.assertEquals(s.username, 'carrot')
+        
+    def test_tracking(self):
+        """test tracking messages"""
+        a,b = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
+        s = self.session
+        stream = ZMQStream(a)
+        msg = s.send(a, 'hello', track=False)
+        self.assertTrue(msg['tracker'] is None)
+        msg = s.send(a, 'hello', track=True)
+        self.assertTrue(isinstance(msg['tracker'], zmq.MessageTracker))
+        M = zmq.Message(b'hi there', track=True)
+        msg = s.send(a, 'hello', buffers=[M], track=True)
+        t = msg['tracker']
+        self.assertTrue(isinstance(t, zmq.MessageTracker))
+        self.assertRaises(zmq.NotDone, t.wait, .1)
+        del M
+        t.wait(1) # this will raise
+        
+        
+    # def test_rekey(self):
+    #     """rekeying dict around json str keys"""
+    #     d = {'0': uuid.uuid4(), 0:uuid.uuid4()}
+    #     self.assertRaises(KeyError, ss.rekey, d)
+    #     
+    #     d = {'0': uuid.uuid4(), 1:uuid.uuid4(), 'asdf':uuid.uuid4()}
+    #     d2 = {0:d['0'],1:d[1],'asdf':d['asdf']}
+    #     rd = ss.rekey(d)
+    #     self.assertEquals(d2,rd)
+    #     
+    #     d = {'1.5':uuid.uuid4(),'1':uuid.uuid4()}
+    #     d2 = {1.5:d['1.5'],1:d['1']}
+    #     rd = ss.rekey(d)
+    #     self.assertEquals(d2,rd)
+    #     
+    #     d = {'1.0':uuid.uuid4(),'1':uuid.uuid4()}
+    #     self.assertRaises(KeyError, ss.rekey, d)
+    # 
+    def test_unique_msg_ids(self):
+        """test that messages receive unique ids"""
+        ids = set()
+        for i in range(2**12):
+            h = self.session.msg_header('test')
+            msg_id = h['msg_id']
+            self.assertTrue(msg_id not in ids)
+            ids.add(msg_id)
+    
+    def test_feed_identities(self):
+        """scrub the front for zmq IDENTITIES"""
+        theids = "engine client other".split()
+        content = dict(code='whoda',stuff=object())
+        themsg = self.session.msg('execute',content=content)
+        pmsg = theids

IPython/frontend/qt/console/ipythonqt.py

@@ -1,277 +1,280 b''
 """ A minimal application using the Qt console-style IPython frontend.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Systemm library imports
 from IPython.external.qt import QtGui
 from pygments.styles import get_all_styles
 
 # Local imports
 from IPython.external.argparse import ArgumentParser
 from IPython.frontend.qt.console.frontend_widget import FrontendWidget
 from IPython.frontend.qt.console.ipython_widget import IPythonWidget
 from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.frontend.qt.console import styles
 from IPython.frontend.qt.kernelmanager import QtKernelManager
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class MainWindow(QtGui.QMainWindow):
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, app, frontend, existing=False, may_close=True):
         """ Create a MainWindow for the specified FrontendWidget.
         
         The app is passed as an argument to allow for different
         closing behavior depending on whether we are the Kernel's parent.
         
         If existing is True, then this Console does not own the Kernel.
         
         If may_close is True, then this Console is permitted to close the kernel
         """
         super(MainWindow, self).__init__()
         self._app = app
         self._frontend = frontend
         self._existing = existing
         if existing:
             self._may_close = may_close
         else:
             self._may_close = True
         self._frontend.exit_requested.connect(self.close)
         self.setCentralWidget(frontend)
     
     #---------------------------------------------------------------------------
     # QWidget interface
     #---------------------------------------------------------------------------
     
     def closeEvent(self, event):
         """ Close the window and the kernel (if necessary).
         
         This will prompt the user if they are finished with the kernel, and if
         so, closes the kernel cleanly. Alternatively, if the exit magic is used,
         it closes without prompt.
         """
         keepkernel = None #Use the prompt by default
         if hasattr(self._frontend,'_keep_kernel_on_exit'): #set by exit magic
             keepkernel = self._frontend._keep_kernel_on_exit
         
         kernel_manager = self._frontend.kernel_manager
         
         if keepkernel is None: #show prompt
             if kernel_manager and kernel_manager.channels_running:
                 title = self.window().windowTitle()
                 cancel = QtGui.QMessageBox.Cancel
                 okay = QtGui.QMessageBox.Ok
                 if self._may_close:
                     msg = "You are closing this Console window."
                     info = "Would you like to quit the Kernel and all attached Consoles as well?"
                     justthis = QtGui.QPushButton("&No, just this Console", self)
                     justthis.setShortcut('N')
                     closeall = QtGui.QPushButton("&Yes, quit everything", self)
                     closeall.setShortcut('Y')
                     box = QtGui.QMessageBox(QtGui.QMessageBox.Question,
                                             title, msg)
                     box.setInformativeText(info)
                     box.addButton(cancel)
                     box.addButton(justthis, QtGui.QMessageBox.NoRole)
                     box.addButton(closeall, QtGui.QMessageBox.YesRole)
                     box.setDefaultButton(closeall)
                     box.setEscapeButton(cancel)
                     reply = box.exec_()
                     if reply == 1: # close All
                         kernel_manager.shutdown_kernel()
                         #kernel_manager.stop_channels()
                         event.accept()
                     elif reply == 0: # close Console
                         if not self._existing:
                             # Have kernel: don't quit, just close the window
                             self._app.setQuitOnLastWindowClosed(False)
                             self.deleteLater()
                         event.accept()
                     else:
                         event.ignore()
                 else:
                     reply = QtGui.QMessageBox.question(self, title,
                         "Are you sure you want to close this Console?"+
                         "\nThe Kernel and other Consoles will remain active.",
                         okay|cancel,
                         defaultButton=okay
                         )
                     if reply == okay:
                         event.accept()
                     else:
                         event.ignore()
         elif keepkernel: #close console but leave kernel running (no prompt)
             if kernel_manager and kernel_manager.channels_running:
                 if not self._existing:
                     # I have the kernel: don't quit, just close the window
                     self._app.setQuitOnLastWindowClosed(False)
                 event.accept()
         else: #close console and kernel (no prompt)
             if kernel_manager and kernel_manager.channels_running:
                 kernel_manager.shutdown_kernel()
                 event.accept()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     """ Entry point for application.
     """
     # Parse command line arguments.
     parser = ArgumentParser()
     kgroup = parser.add_argument_group('kernel options')
     kgroup.add_argument('-e', '--existing', action='store_true',
                         help='connect to an existing kernel')
     kgroup.add_argument('--ip', type=str, default=LOCALHOST,
                         help=\
             "set the kernel\'s IP address [default localhost].\
             If the IP address is something other than localhost, then \
             Consoles on other machines will be able to connect\
             to the Kernel, so be careful!")
     kgroup.add_argument('--xreq', type=int, metavar='PORT', default=0,
                         help='set the XREQ channel port [default random]')
     kgroup.add_argument('--sub', type=int, metavar='PORT', default=0,
                         help='set the SUB channel port [default random]')
     kgroup.add_argument('--rep', type=int, metavar='PORT', default=0,
                         help='set the REP channel port [default random]')
     kgroup.add_argument('--hb', type=int, metavar='PORT', default=0,
                         help='set the heartbeat port [default random]')
 
     egroup = kgroup.add_mutually_exclusive_group()
     egroup.add_argument('--pure', action='store_true', help = \
                         'use a pure Python kernel instead of an IPython kernel')
     egroup.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
                        const='auto', help = \
         "Pre-load matplotlib and numpy for interactive use. If GUI is not \
          given, the GUI backend is matplotlib's, otherwise use one of: \
          ['tk', 'gtk', 'qt', 'wx', 'inline'].")
 
     wgroup = parser.add_argument_group('widget options')
     wgroup.add_argument('--paging', type=str, default='inside',
                         choices = ['inside', 'hsplit', 'vsplit', 'none'],
                         help='set the paging style [default inside]')
     wgroup.add_argument('--plain', action='store_true',
                         help='disable rich text support')
     wgroup.add_argument('--gui-completion', action='store_true',
                         help='use a GUI widget for tab completion')
     wgroup.add_argument('--style', type=str,
                         choices = list(get_all_styles()),
                         help='specify a pygments style for by name')
     wgroup.add_argument('--stylesheet', type=str,
                         help='path to a custom CSS stylesheet')
     wgroup.add_argument('--colors', type=str, help = \
         "Set the color scheme (LightBG,Linux,NoColor). This is guessed \
          based on the pygments style if not set.")
 
     args = parser.parse_args()
 
     # parse the colors arg down to current known labels
     if args.colors:
         colors=args.colors.lower()
         if colors in ('lightbg', 'light'):
             colors='lightbg'
         elif colors in ('dark', 'linux'):
             colors='linux'
         else:
             colors='nocolor'
     elif args.style:
         if args.style=='bw':
             colors='nocolor'
         elif styles.dark_style(args.style):
             colors='linux'
         else:
             colors='lightbg'
     else:
         colors=None
 
     # Don't let Qt or ZMQ swallow KeyboardInterupts.
     import signal
     signal.signal(signal.SIGINT, signal.SIG_DFL)
 
     # Create a KernelManager and start a kernel.
     kernel_manager = QtKernelManager(xreq_address=(args.ip, args.xreq),
                                      sub_address=(args.ip, args.sub),
                                      rep_address=(args.ip, args.rep),
                                      hb_address=(args.ip, args.hb))
     if not args.existing:
         # if not args.ip in LOCAL_IPS+ALL_ALIAS:
         #     raise ValueError("Must bind a local ip, such as: %s"%LOCAL_IPS)
 
         kwargs = dict(ip=args.ip)
         if args.pure:
             kwargs['ipython']=False
         else:
-            kwargs['colors']=colors
+            extra = []
+            if colors:
+                extra.append("colors=%s"%colors)
             if args.pylab:
-                kwargs['pylab']=args.pylab
+                extra.append("pylab=%s"%args.pylab)
+            kwargs['extra_arguments'] = extra
 
         kernel_manager.start_kernel(**kwargs)
     kernel_manager.start_channels()
 
     # Create the widget.
     app = QtGui.QApplication([])
     local_kernel = (not args.existing) or args.ip in LOCAL_IPS
     if args.pure:
         kind = 'plain' if args.plain else 'rich'
         widget = FrontendWidget(kind=kind, paging=args.paging, 
                                 local_kernel=local_kernel)
     elif args.plain:
         widget = IPythonWidget(paging=args.paging, local_kernel=local_kernel)
     else:
         widget = RichIPythonWidget(paging=args.paging, 
                                    local_kernel=local_kernel)
     widget.gui_completion = args.gui_completion
     widget.kernel_manager = kernel_manager
 
     # Configure the style.
     if not args.pure: # only IPythonWidget supports styles
         if args.style:
             widget.syntax_style = args.style
             widget.style_sheet = styles.sheet_from_template(args.style, colors)
             widget._syntax_style_changed()
             widget._style_sheet_changed()
         elif colors:
             # use a default style
             widget.set_default_style(colors=colors)
         else:
             # this is redundant for now, but allows the widget's
             # defaults to change
             widget.set_default_style()
 
         if args.stylesheet:
             # we got an expicit stylesheet
             if os.path.isfile(args.stylesheet):
                 with open(args.stylesheet) as f:
                     sheet = f.read()
                 widget.style_sheet = sheet
                 widget._style_sheet_changed()
             else:
                 raise IOError("Stylesheet %r not found."%args.stylesheet)
 
     # Create the main window.
     window = MainWindow(app, widget, args.existing, may_close=local_kernel)
     window.setWindowTitle('Python' if args.pure else 'IPython')
     window.show()
 
     # Start the application main loop.
     app.exec_()
 
 
 if __name__ == '__main__':
     main()

IPython/zmq/entry_point.py

@@ -1,299 +1,160 b''
 """ Defines helper functions for creating kernel entry points and process
 launchers.
 """
 
 # Standard library imports.
 import atexit
 import os
 import socket
 from subprocess import Popen, PIPE
 import sys
 
-# System library imports.
-import zmq
-
 # Local imports.
-from IPython.core.ultratb import FormattedTB
-from IPython.external.argparse import ArgumentParser
-from IPython.utils import io
-from IPython.utils.localinterfaces import LOCALHOST
-from displayhook import DisplayHook
-from heartbeat import Heartbeat
-from iostream import OutStream
-from parentpoller import ParentPollerUnix, ParentPollerWindows
-from session import Session
-
-
-def bind_port(socket, ip, port):
-    """ Binds the specified ZMQ socket. If the port is 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 make_argument_parser():
-    """ Creates an ArgumentParser for the generic arguments supported by all 
-    kernel entry points.
-    """
-    parser = ArgumentParser()
-    parser.add_argument('--ip', type=str, default=LOCALHOST,
-                        help='set the kernel\'s IP address [default: local]')
-    parser.add_argument('--xrep', type=int, metavar='PORT', default=0,
-                        help='set the XREP channel port [default: random]')
-    parser.add_argument('--pub', type=int, metavar='PORT', default=0,
-                        help='set the PUB channel port [default: random]')
-    parser.add_argument('--req', type=int, metavar='PORT', default=0,
-                        help='set the REQ channel port [default: random]')
-    parser.add_argument('--hb', type=int, metavar='PORT', default=0,
-                        help='set the heartbeat port [default: random]')
-    parser.add_argument('--no-stdout', action='store_true',
-                        help='redirect stdout to the null device')
-    parser.add_argument('--no-stderr', action='store_true',
-                        help='redirect stderr to the null device')
-
-    if sys.platform == 'win32':
-        parser.add_argument('--interrupt', type=int, metavar='HANDLE', 
-                            default=0, help='interrupt this process when '
-                            'HANDLE is signaled')
-        parser.add_argument('--parent', type=int, metavar='HANDLE', 
-                            default=0, help='kill this process if the process '
-                            'with HANDLE dies')
-    else:
-        parser.add_argument('--parent', action='store_true', 
-                            help='kill this process if its parent dies')
-
-    return parser
-
-
-def make_kernel(namespace, kernel_factory, 
-                out_stream_factory=None, display_hook_factory=None):
-    """ Creates a kernel, redirects stdout/stderr, and installs a display hook
-    and exception handler.
-    """
-    # Re-direct stdout/stderr, if necessary.
-    if namespace.no_stdout or namespace.no_stderr:
-        blackhole = file(os.devnull, 'w')
-        if namespace.no_stdout:
-            sys.stdout = sys.__stdout__ = blackhole
-        if namespace.no_stderr:
-            sys.stderr = sys.__stderr__ = blackhole
-
-    # Install minimal exception handling
-    sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', 
-                                 ostream=sys.__stdout__)
+from parentpoller import ParentPollerWindows
 
-    # Create a context, a session, and the kernel sockets.
-    io.raw_print("Starting the kernel at pid:", os.getpid())
-    context = zmq.Context()
-    # Uncomment this to try closing the context.
-    # atexit.register(context.close)
-    session = Session(username=u'kernel')
 
-    reply_socket = context.socket(zmq.XREP)
-    xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep)
-    io.raw_print("XREP Channel on port", xrep_port)
 
-    pub_socket = context.socket(zmq.PUB)
-    pub_port = bind_port(pub_socket, namespace.ip, namespace.pub)
-    io.raw_print("PUB Channel on port", pub_port)
-
-    req_socket = context.socket(zmq.XREQ)
-    req_port = bind_port(req_socket, namespace.ip, namespace.req)
-    io.raw_print("REQ Channel on port", req_port)
-
-    hb = Heartbeat(context, (namespace.ip, namespace.hb))
-    hb.start()
-    hb_port = hb.port
-    io.raw_print("Heartbeat REP Channel on port", hb_port)
-
-    # Helper to make it easier to connect to an existing kernel, until we have
-    # single-port connection negotiation fully implemented.
-    io.raw_print("To connect another client to this kernel, use:")
-    io.raw_print("-e --xreq {0} --sub {1} --rep {2} --hb {3}".format(
-        xrep_port, pub_port, req_port, hb_port))
-
-    # Redirect input streams and set a display hook.
-    if out_stream_factory:
-        sys.stdout = out_stream_factory(session, pub_socket, u'stdout')
-        sys.stderr = out_stream_factory(session, pub_socket, u'stderr')
-    if display_hook_factory:
-        sys.displayhook = display_hook_factory(session, pub_socket)
-
-    # Create the kernel.
-    kernel = kernel_factory(session=session, reply_socket=reply_socket, 
-                            pub_socket=pub_socket, req_socket=req_socket)
-    kernel.record_ports(xrep_port=xrep_port, pub_port=pub_port,
-                        req_port=req_port, hb_port=hb_port)
-    return kernel
-
-
-def start_kernel(namespace, kernel):
-    """ Starts a kernel.
-    """
-    # Configure this kernel process to poll the parent process, if necessary.
-    if sys.platform == 'win32':
-        if namespace.interrupt or namespace.parent:
-            poller = ParentPollerWindows(namespace.interrupt, namespace.parent)
-            poller.start()
-    elif namespace.parent:
-        poller = ParentPollerUnix()
-        poller.start()
-
-    # Start the kernel mainloop.
-    kernel.start()
-
-
-def make_default_main(kernel_factory):
-    """ Creates the simplest possible kernel entry point.
-    """
-    def main():
-        namespace = make_argument_parser().parse_args()
-        kernel = make_kernel(namespace, kernel_factory, OutStream, DisplayHook)
-        start_kernel(namespace, kernel)
-    return main
-
-
-def base_launch_kernel(code, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                       stdin=None, stdout=None, stderr=None,
-                       executable=None, independent=False, extra_arguments=[]):
+def base_launch_kernel(code, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0,
+                        ip=None, stdin=None, stdout=None, stderr=None,
+                        executable=None, independent=False, extra_arguments=[]):
     """ Launches a localhost kernel, binding to the specified ports.
 
     Parameters
     ----------
     code : str,
         A string of Python code that imports and executes a kernel entry point.
 
-    xrep_port : int, optional
+    shell_port : int, optional
         The port to use for XREP channel.
 
-    pub_port : int, optional
+    iopub_port : int, optional
         The port to use for the SUB channel.
 
-    req_port : int, optional
+    stdin_port : int, optional
         The port to use for the REQ (raw input) channel.
 
     hb_port : int, optional
         The port to use for the hearbeat REP channel.
 
+    ip  : str, optional
+        The ip address the kernel will bind to.
+
     stdin, stdout, stderr : optional (default None)
         Standards streams, as defined in subprocess.Popen.
 
     executable : str, optional (default sys.executable)
         The Python executable to use for the kernel process.
 
     independent : bool, optional (default False) 
         If set, the kernel process is guaranteed to survive if this process
         dies. If not set, an effort is made to ensure that the kernel is killed
         when this process dies. Note that in this case it is still good practice
         to kill kernels manually before exiting.
 
     extra_arguments = list, optional
         A list of extra arguments to pass when executing the launch code.
 
     Returns
     -------
     A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
+        (kernel_process, shell_port, iopub_port, stdin_port, hb_port)
     where kernel_process is a Popen object and the ports are integers.
     """
     # Find open ports as necessary.
     ports = []
-    ports_needed = int(xrep_port <= 0) + int(pub_port <= 0) + \
-                   int(req_port <= 0) + int(hb_port <= 0)
+    ports_needed = int(shell_port <= 0) + int(iopub_port <= 0) + \
+                   int(stdin_port <= 0) + int(hb_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
-    if xrep_port <= 0:
-        xrep_port = ports.pop(0)
-    if pub_port <= 0:
-        pub_port = ports.pop(0)
-    if req_port <= 0:
-        req_port = ports.pop(0)
+    if shell_port <= 0:
+        shell_port = ports.pop(0)
+    if iopub_port <= 0:
+        iopub_port = ports.pop(0)
+    if stdin_port <= 0:
+        stdin_port = ports.pop(0)
     if hb_port <= 0:
         hb_port = ports.pop(0)
 
     # Build the kernel launch command.
     if executable is None:
         executable = sys.executable
-    arguments = [ executable, '-c', code, '--xrep', str(xrep_port), 
-                  '--pub', str(pub_port), '--req', str(req_port),
-                  '--hb', str(hb_port) ]
+    arguments = [ executable, '-c', code, 'shell=%i'%shell_port,
+                  'iopub=%i'%iopub_port, 'stdin=%i'%stdin_port,
+                  'hb=%i'%hb_port
+    ]
+    if ip is not None:
+        arguments.append('ip=%s'%ip)
     arguments.extend(extra_arguments)
 
     # Spawn a kernel.
     if sys.platform == 'win32':
         # Create a Win32 event for interrupting the kernel.
         interrupt_event = ParentPollerWindows.create_interrupt_event()
-        arguments += [ '--interrupt', str(int(interrupt_event)) ]
+        arguments += [ 'interrupt=%i'%interrupt_event ]
 
         # If this process in running on pythonw, stdin, stdout, and stderr are
         # invalid. Popen will fail unless they are suitably redirected. We don't
         # read from the pipes, but they must exist.
         if sys.executable.endswith('pythonw.exe'):
             redirect = True
             _stdin = PIPE if stdin is None else stdin
             _stdout = PIPE if stdout is None else stdout
             _stderr = PIPE if stderr is None else stderr
         else:
             redirect = False
             _stdin, _stdout, _stderr = stdin, stdout, stderr
 
         # If the kernel is running on pythonw and stdout/stderr are not been
         # re-directed, it will crash when more than 4KB of data is written to
         # stdout or stderr. This is a bug that has been with Python for a very
         # long time; see http://bugs.python.org/issue706263.
         # A cleaner solution to this problem would be to pass os.devnull to
         # Popen directly. Unfortunately, that does not work.
         if executable.endswith('pythonw.exe'):
             if stdout is None:
                 arguments.append('--no-stdout')
             if stderr is None:
                 arguments.append('--no-stderr')
 
         # Launch the kernel process.
         if independent:
             proc = Popen(arguments, 
                          creationflags=512, # CREATE_NEW_PROCESS_GROUP
                          stdin=_stdin, stdout=_stdout, stderr=_stderr)
         else:
             from _subprocess import DuplicateHandle, GetCurrentProcess, \
                 DUPLICATE_SAME_ACCESS
             pid = GetCurrentProcess()
             handle = DuplicateHandle(pid, pid, pid, 0, 
                                      True, # Inheritable by new processes.
                                      DUPLICATE_SAME_ACCESS)
-            proc = Popen(arguments + ['--parent', str(int(handle))],
+            proc = Popen(arguments + ['parent=%i'%int(handle)],
                          stdin=_stdin, stdout=_stdout, stderr=_stderr)
 
         # Attach the interrupt event to the Popen objet so it can be used later.
         proc.win32_interrupt_event = interrupt_event
 
         # Clean up pipes created to work around Popen bug.
         if redirect:
             if stdin is None:
                 proc.stdin.close()
             if stdout is None:
                 proc.stdout.close()
             if stderr is None:
                 proc.stderr.close()
 
     else:
         if independent:
             proc = Popen(arguments, preexec_fn=lambda: os.setsid(),
                          stdin=stdin, stdout=stdout, stderr=stderr)
         else:
-            proc = Popen(arguments + ['--parent'],
+            proc = Popen(arguments + ['parent=1'],
                          stdin=stdin, stdout=stdout, stderr=stderr)
 
-    return proc, xrep_port, pub_port, req_port, hb_port
+    return proc, shell_port, iopub_port, stdin_port, hb_port

IPython/zmq/ipkernel.py

@@ -1,689 +1,746 b''
 #!/usr/bin/env python
 """A simple interactive kernel that talks to a frontend over 0MQ.
 
 Things to do:
 
 * 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.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports.
 import __builtin__
 import atexit
 import sys
 import time
 import traceback
 import logging
 # System library imports.
 import zmq
 
 # Local imports.
 from IPython.config.configurable import Configurable
+from IPython.config.application import boolean_flag
+from IPython.core.newapplication import ProfileDir
 from IPython.utils import io
 from IPython.utils.jsonutil import json_clean
 from IPython.lib import pylabtools
-from IPython.utils.traitlets import Instance, Float
-from entry_point import (base_launch_kernel, make_argument_parser, make_kernel,
-                         start_kernel)
+from IPython.utils.traitlets import (
+    List, Instance, Float, Dict, Bool, Int, Unicode, CaselessStrEnum
+)
+from entry_point import base_launch_kernel
+from kernelapp import KernelApp, kernel_flags, kernel_aliases
 from iostream import OutStream
 from session import Session, Message
 from zmqshell import ZMQInteractiveShell
 
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Module-level logger
-logger = logging.getLogger(__name__)
 
-# FIXME: this needs to be done more cleanly later, once we have proper
-# configuration support.  This is a library, so it shouldn't set a stream
-# handler, see:
-# http://docs.python.org/library/logging.html#configuring-logging-for-a-library
-# But this lets us at least do developer debugging for now by manually turning
-# it on/off.  And once we have full config support, the client entry points
-# will select their logging handlers, as well as passing to this library the
-# logging level.
-
-if 0:  # dbg - set to 1 to actually see the messages.
-    logger.addHandler(logging.StreamHandler())
-    logger.setLevel(logging.DEBUG)
-
-# /FIXME
 
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
 class Kernel(Configurable):
 
     #---------------------------------------------------------------------------
     # Kernel interface
     #---------------------------------------------------------------------------
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     session = Instance(Session)
-    reply_socket = Instance('zmq.Socket')
-    pub_socket = Instance('zmq.Socket')
-    req_socket = Instance('zmq.Socket')
+    shell_socket = Instance('zmq.Socket')
+    iopub_socket = Instance('zmq.Socket')
+    stdin_socket = Instance('zmq.Socket')
+    log = Instance(logging.Logger)
 
     # Private interface
 
     # Time to sleep after flushing the stdout/err buffers in each execute
     # cycle.  While this introduces a hard limit on the minimal latency of the
     # execute cycle, it helps prevent output synchronization problems for
     # clients.
     # Units are in seconds.  The minimum zmq latency on local host is probably
     # ~150 microseconds, set this to 500us for now.  We may need to increase it
     # a little if it's not enough after more interactive testing.
     _execute_sleep = Float(0.0005, config=True)
 
     # Frequency of the kernel's event loop.
     # Units are in seconds, kernel subclasses for GUI toolkits may need to
     # adapt to milliseconds.
     _poll_interval = Float(0.05, config=True)
 
     # If the shutdown was requested over the network, we leave here the
     # necessary reply message so it can be sent by our registered atexit
     # handler.  This ensures that the reply is only sent to clients truly at
     # the end of our shutdown process (which happens after the underlying
     # IPython shell's own shutdown).
     _shutdown_message = None
 
     # This is a dict of port number that the kernel is listening on. It is set
     # by record_ports and used by connect_request.
-    _recorded_ports = None
+    _recorded_ports = Dict()
+
 
 
     def __init__(self, **kwargs):
         super(Kernel, self).__init__(**kwargs)
 
         # Before we even start up the shell, register *first* our exit handlers
         # so they come before the shell's
         atexit.register(self._at_shutdown)
 
         # Initialize the InteractiveShell subclass
-        self.shell = ZMQInteractiveShell.instance()
+        self.shell = ZMQInteractiveShell.instance(config=self.config)
         self.shell.displayhook.session = self.session
-        self.shell.displayhook.pub_socket = self.pub_socket
+        self.shell.displayhook.pub_socket = self.iopub_socket
         self.shell.display_pub.session = self.session
-        self.shell.display_pub.pub_socket = self.pub_socket
+        self.shell.display_pub.pub_socket = self.iopub_socket
 
         # TMP - hack while developing
         self.shell._reply_content = None
 
         # Build dict of handlers for message types
         msg_types = [ 'execute_request', 'complete_request', 
                       'object_info_request', 'history_request',
                       'connect_request', 'shutdown_request']
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def do_one_iteration(self):
         """Do one iteration of the kernel's evaluation loop.
         """
-        ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
+        ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK)
         if msg is None:
             return
         
         # This assert will raise in versions of zeromq 2.0.7 and lesser.
         # We now require 2.0.8 or above, so we can uncomment for safety.
         # print(ident,msg, file=sys.__stdout__)
         assert ident is not None, "Missing message part."
         
         # Print some info about this message and leave a '--->' marker, so it's
         # easier to trace visually the message chain when debugging.  Each
         # handler prints its message at the end.
-        # Eventually we'll move these from stdout to a logger.
-        logger.debug('\n*** MESSAGE TYPE:'+str(msg['msg_type'])+'***')
-        logger.debug('   Content: '+str(msg['content'])+'\n   --->\n   ')
+        self.log.debug('\n*** MESSAGE TYPE:'+str(msg['msg_type'])+'***')
+        self.log.debug('   Content: '+str(msg['content'])+'\n   --->\n   ')
 
         # Find and call actual handler for message
         handler = self.handlers.get(msg['msg_type'], None)
         if handler is None:
-            logger.error("UNKNOWN MESSAGE TYPE:" +str(msg))
+            self.log.error("UNKNOWN MESSAGE TYPE:" +str(msg))
         else:
             handler(ident, msg)
             
         # Check whether we should exit, in case the incoming message set the
         # exit flag on
         if self.shell.exit_now:
-            logger.debug('\nExiting IPython kernel...')
+            self.log.debug('\nExiting IPython kernel...')
             # We do a normal, clean exit, which allows any actions registered
             # via atexit (such as history saving) to take place.
             sys.exit(0)
 
 
     def start(self):
         """ Start the kernel main loop.
         """
+        poller = zmq.Poller()
+        poller.register(self.shell_socket, zmq.POLLIN)
         while True:
             try:
-                time.sleep(self._poll_interval)
+                # scale by extra factor of 10, because there is no
+                # reason for this to be anything less than ~ 0.1s
+                # since it is a real poller and will respond
+                # to events immediately
+                poller.poll(10*1000*self._poll_interval)
                 self.do_one_iteration()
             except KeyboardInterrupt:
                 # Ctrl-C shouldn't crash the kernel
                 io.raw_print("KeyboardInterrupt caught in kernel")
 
-    def record_ports(self, xrep_port, pub_port, req_port, hb_port):
+    def record_ports(self, ports):
         """Record the ports that this kernel is using.
 
         The creator of the Kernel instance must call this methods if they
         want the :meth:`connect_request` method to return the port numbers.
         """
-        self._recorded_ports = {
-            'xrep_port' : xrep_port,
-            'pub_port' : pub_port,
-            'req_port' : req_port,
-            'hb_port' : hb_port
-        }
+        self._recorded_ports = ports
 
     #---------------------------------------------------------------------------
     # Kernel request handlers
     #---------------------------------------------------------------------------
 
     def _publish_pyin(self, code, parent):
         """Publish the code request on the pyin stream."""
 
-        pyin_msg = self.session.send(self.pub_socket, u'pyin',{u'code':code}, parent=parent)
+        pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent)
 
     def execute_request(self, ident, parent):
         
-        status_msg = self.session.send(self.pub_socket,
+        status_msg = self.session.send(self.iopub_socket,
             u'status',
             {u'execution_state':u'busy'},
             parent=parent
         )
         
         try:
             content = parent[u'content']
             code = content[u'code']
             silent = content[u'silent'] 
         except:
-            logger.error("Got bad msg: ")
-            logger.error(str(Message(parent)))
+            self.log.error("Got bad msg: ")
+            self.log.error(str(Message(parent)))
             return
 
         shell = self.shell # we'll need this a lot here
 
         # Replace raw_input. Note that is not sufficient to replace 
         # raw_input in the user namespace.
         raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
         __builtin__.raw_input = raw_input
 
         # Set the parent message of the display hook and out streams.
         shell.displayhook.set_parent(parent)
         shell.display_pub.set_parent(parent)
         sys.stdout.set_parent(parent)
         sys.stderr.set_parent(parent)
 
         # Re-broadcast our input for the benefit of listening clients, and
         # start computing output
         if not silent:
             self._publish_pyin(code, parent)
 
         reply_content = {}
         try:
             if silent:
                 # run_code uses 'exec' mode, so no displayhook will fire, and it
                 # doesn't call logging or history manipulations.  Print
                 # statements in that code will obviously still execute.
                 shell.run_code(code)
             else:
                 # FIXME: the shell calls the exception handler itself.
                 shell.run_cell(code)
         except:
             status = u'error'
             # FIXME: this code right now isn't being used yet by default,
             # because the run_cell() call above directly fires off exception
             # reporting.  This code, therefore, is only active in the scenario
             # where runlines itself has an unhandled exception.  We need to
             # uniformize this, for all exception construction to come from a
             # single location in the codbase.
             etype, evalue, tb = sys.exc_info()
             tb_list = traceback.format_exception(etype, evalue, tb)
             reply_content.update(shell._showtraceback(etype, evalue, tb_list))
         else:
             status = u'ok'
 
         reply_content[u'status'] = status
         
         # Return the execution counter so clients can display prompts
         reply_content['execution_count'] = shell.execution_count -1
 
         # FIXME - fish exception info out of shell, possibly left there by
         # runlines.  We'll need to clean up this logic later.
         if shell._reply_content is not None:
             reply_content.update(shell._reply_content)
             # reset after use
             shell._reply_content = None
 
         # At this point, we can tell whether the main code execution succeeded
         # or not.  If it did, we proceed to evaluate user_variables/expressions
         if reply_content['status'] == 'ok':
             reply_content[u'user_variables'] = \
                          shell.user_variables(content[u'user_variables'])
             reply_content[u'user_expressions'] = \
                          shell.user_expressions(content[u'user_expressions'])
         else:
             # If there was an error, don't even try to compute variables or
             # expressions
             reply_content[u'user_variables'] = {}
             reply_content[u'user_expressions'] = {}
 
         # Payloads should be retrieved regardless of outcome, so we can both
         # recover partial output (that could have been generated early in a
         # block, before an error) and clear the payload system always.
         reply_content[u'payload'] = shell.payload_manager.read_payload()
         # Be agressive about clearing the payload because we don't want
         # it to sit in memory until the next execute_request comes in.
         shell.payload_manager.clear_payload()
 
         # Flush output before sending the reply.
         sys.stdout.flush()
         sys.stderr.flush()
         # FIXME: on rare occasions, the flush doesn't seem to make it to the
         # clients... This seems to mitigate the problem, but we definitely need
         # to better understand what's going on.
         if self._execute_sleep:
             time.sleep(self._execute_sleep)
         
         # Send the reply.
-        reply_msg = self.session.send(self.reply_socket, u'execute_reply',
+        reply_msg = self.session.send(self.shell_socket, u'execute_reply',
                                       reply_content, parent, ident=ident)
-        logger.debug(str(reply_msg))
+        self.log.debug(str(reply_msg))
 
         if reply_msg['content']['status'] == u'error':
             self._abort_queue()
 
-        status_msg = self.session.send(self.pub_socket,
+        status_msg = self.session.send(self.iopub_socket,
             u'status',
             {u'execution_state':u'idle'},
             parent=parent
         )
 
     def complete_request(self, ident, parent):
         txt, matches = self._complete(parent)
         matches = {'matches' : matches,
                    'matched_text' : txt,
                    'status' : 'ok'}
-        completion_msg = self.session.send(self.reply_socket, 'complete_reply',
+        completion_msg = self.session.send(self.shell_socket, 'complete_reply',
                                            matches, parent, ident)
-        logger.debug(str(completion_msg))
+        self.log.debug(str(completion_msg))
 
     def object_info_request(self, ident, parent):
         object_info = self.shell.object_inspect(parent['content']['oname'])
         # Before we send this object over, we scrub it for JSON usage
         oinfo = json_clean(object_info)
-        msg = self.session.send(self.reply_socket, 'object_info_reply',
+        msg = self.session.send(self.shell_socket, 'object_info_reply',
                                 oinfo, parent, ident)
-        logger.debug(msg)
+        self.log.debug(msg)
 
     def history_request(self, ident, parent):
         # We need to pull these out, as passing **kwargs doesn't work with
         # unicode keys before Python 2.6.5.
         hist_access_type = parent['content']['hist_access_type']
         raw = parent['content']['raw']
         output = parent['content']['output']
         if hist_access_type == 'tail':
             n = parent['content']['n']
             hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,
                                                             include_latest=True)
         
         elif hist_access_type == 'range':
             session = parent['content']['session']
             start = parent['content']['start']
             stop = parent['content']['stop']
             hist = self.shell.history_manager.get_range(session, start, stop,
                                                         raw=raw, output=output)
         
         elif hist_access_type == 'search':
             pattern = parent['content']['pattern']
             hist = self.shell.history_manager.search(pattern, raw=raw, output=output)
         
         else:
             hist = []
         content = {'history' : list(hist)}
-        msg = self.session.send(self.reply_socket, 'history_reply',
+        msg = self.session.send(self.shell_socket, 'history_reply',
                                 content, parent, ident)
-        logger.debug(str(msg))
+        self.log.debug(str(msg))
 
     def connect_request(self, ident, parent):
         if self._recorded_ports is not None:
             content = self._recorded_ports.copy()
         else:
             content = {}
-        msg = self.session.send(self.reply_socket, 'connect_reply',
+        msg = self.session.send(self.shell_socket, 'connect_reply',
                                 content, parent, ident)
-        logger.debug(msg)
+        self.log.debug(msg)
 
     def shutdown_request(self, ident, parent):
         self.shell.exit_now = True
         self._shutdown_message = self.session.msg(u'shutdown_reply', parent['content'], parent)
         sys.exit(0)
 
     #---------------------------------------------------------------------------
     # Protected interface
     #---------------------------------------------------------------------------
 
     def _abort_queue(self):
         while True:
-            ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
+            ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK)
             if msg is None:
                 break
             else:
                 assert ident is not None, \
                        "Unexpected missing message part."
 
-            logger.debug("Aborting:\n"+str(Message(msg)))
+            self.log.debug("Aborting:\n"+str(Message(msg)))
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
-            reply_msg = self.session.send(self.reply_socket, reply_type, 
+            reply_msg = self.session.send(self.shell_socket, reply_type,
                     {'status' : 'aborted'}, msg, ident=ident)
-            logger.debug(reply_msg)
+            self.log.debug(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 _raw_input(self, prompt, ident, parent):
         # Flush output before making the request.
         sys.stderr.flush()
         sys.stdout.flush()
 
         # Send the input request.
         content = dict(prompt=prompt)
-        msg = self.session.send(self.req_socket, u'input_request', content, parent)
+        msg = self.session.send(self.stdin_socket, u'input_request', content, parent)
 
         # Await a response.
-        ident, reply = self.session.recv(self.req_socket, 0)
+        ident, reply = self.session.recv(self.stdin_socket, 0)
         try:
             value = reply['content']['value']
         except:
-            logger.error("Got bad raw_input reply: ")
-            logger.error(str(Message(parent)))
+            self.log.error("Got bad raw_input reply: ")
+            self.log.error(str(Message(parent)))
             value = ''
         return value
     
     def _complete(self, msg):
         c = msg['content']
         try:
             cpos = int(c['cursor_pos'])
         except:
             # If we don't get something that we can convert to an integer, at
             # least attempt the completion guessing the cursor is at the end of
             # the text, if there's any, and otherwise of the line
             cpos = len(c['text'])
             if cpos==0:
                 cpos = len(c['line'])
         return self.shell.complete(c['text'], c['line'], cpos)
 
     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.shell.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 _at_shutdown(self):
         """Actions taken at shutdown by the kernel, called by python's atexit.
         """
         # io.rprint("Kernel at_shutdown") # dbg
         if self._shutdown_message is not None:
-            self.session.send(self.reply_socket, self._shutdown_message)
-            self.session.send(self.pub_socket, self._shutdown_message)
-            logger.debug(str(self._shutdown_message))
+            self.session.send(self.shell_socket, self._shutdown_message)
+            self.session.send(self.iopub_socket, self._shutdown_message)
+            self.log.debug(str(self._shutdown_message))
             # A very short sleep to give zmq time to flush its message buffers
             # before Python truly shuts down.
             time.sleep(0.01)
 
 
 class QtKernel(Kernel):
     """A Kernel subclass with Qt support."""
 
     def start(self):
         """Start a kernel with QtPy4 event loop integration."""
 
         from PyQt4 import QtCore
         from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
 
         self.app = get_app_qt4([" "])
         self.app.setQuitOnLastWindowClosed(False)
         self.timer = QtCore.QTimer()
         self.timer.timeout.connect(self.do_one_iteration)
         # Units for the timer are in milliseconds
         self.timer.start(1000*self._poll_interval)
         start_event_loop_qt4(self.app)
 
 
 class WxKernel(Kernel):
     """A Kernel subclass with Wx support."""
 
     def start(self):
         """Start a kernel with wx event loop support."""
 
         import wx
         from IPython.lib.guisupport import start_event_loop_wx
 
         doi = self.do_one_iteration
          # Wx uses milliseconds
         poll_interval = int(1000*self._poll_interval)
 
         # We have to put the wx.Timer in a wx.Frame for it to fire properly.
         # We make the Frame hidden when we create it in the main app below.
         class TimerFrame(wx.Frame):
             def __init__(self, func):
                 wx.Frame.__init__(self, None, -1)
                 self.timer = wx.Timer(self)
                 # Units for the timer are in milliseconds
                 self.timer.Start(poll_interval)
                 self.Bind(wx.EVT_TIMER, self.on_timer)
                 self.func = func
 
             def on_timer(self, event):
                 self.func()
 
         # We need a custom wx.App to create our Frame subclass that has the
         # wx.Timer to drive the ZMQ event loop.
         class IPWxApp(wx.App):
             def OnInit(self):
                 self.frame = TimerFrame(doi)
                 self.frame.Show(False)
                 return True
 
         # The redirect=False here makes sure that wx doesn't replace
         # sys.stdout/stderr with its own classes.
         self.app = IPWxApp(redirect=False)
         start_event_loop_wx(self.app)
 
 
 class TkKernel(Kernel):
     """A Kernel subclass with Tk support."""
 
     def start(self):
         """Start a Tk enabled event loop."""
 
         import Tkinter
         doi = self.do_one_iteration
         # Tk uses milliseconds
         poll_interval = int(1000*self._poll_interval)
         # For Tkinter, we create a Tk object and call its withdraw method.
         class Timer(object):
             def __init__(self, func):
                 self.app = Tkinter.Tk()
                 self.app.withdraw()
                 self.func = func
                 
             def on_timer(self):
                 self.func()
                 self.app.after(poll_interval, self.on_timer)
                 
             def start(self):
                 self.on_timer()  # Call it once to get things going.
                 self.app.mainloop()
 
         self.timer = Timer(doi)
         self.timer.start()
 
 
 class GTKKernel(Kernel):
     """A Kernel subclass with GTK support."""
     
     def start(self):
         """Start the kernel, coordinating with the GTK event loop"""
         from .gui.gtkembed import GTKEmbed
         
         gtk_kernel = GTKEmbed(self)
         gtk_kernel.start()
 
 
 #-----------------------------------------------------------------------------
-# Kernel main and launch functions
+# Aliases and Flags for the IPKernelApp
 #-----------------------------------------------------------------------------
 
-def launch_kernel(ip=None, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                  stdin=None, stdout=None, stderr=None,
-                  executable=None, independent=False, pylab=False, colors=None):
-    """Launches a localhost kernel, binding to the specified ports.
+flags = dict(kernel_flags)
+
+addflag = lambda *args: flags.update(boolean_flag(*args))
+addflag('automagic', 'InteractiveShell.automagic',
+        """Turn on the auto calling of magic commands. Type %%magic at the
+        IPython  prompt  for  more information.""",
+        'Turn off the auto calling of magic commands.'
+)
+addflag('banner', 'InteractiveShell.display_banner',
+        "Display a banner upon starting IPython.",
+        "Don't display a banner upon starting IPython."
+)
+addflag('pdb', 'InteractiveShell.pdb',
+    "Enable auto calling the pdb debugger after every exception.",
+    "Disable auto calling the pdb debugger after every exception."
+)
+addflag('pprint', 'PlainTextFormatter.pprint',
+    "Enable auto pretty printing of results.",
+    "Disable auto auto pretty printing of results."
+)
+addflag('color-info', 'InteractiveShell.color_info',
+    """IPython can display information about objects via a set of func-
+    tions, and optionally can use colors for this, syntax highlighting
+    source code and various other elements.  However, because this
+    information is passed through a pager (like 'less') and many pagers get
+    confused with color codes, this option is off by default.  You can test
+    it and turn it on permanently in your ipython_config.py file if it
+    works for you.  Test it and turn it on permanently if it works with
+    your system.  The magic function %%color_info allows you to toggle this
+    inter- actively for testing.""",
+    "Disable using colors for info related things."
+)
+addflag('deep-reload', 'InteractiveShell.deep_reload',
+    """Enable deep (recursive) reloading by default. IPython can use the
+    deep_reload module which reloads changes in modules recursively (it
+    replaces the reload() function, so you don't need to change anything to
+    use it). deep_reload() forces a full reload of modules whose code may
+    have changed, which the default reload() function does not.  When
+    deep_reload is off, IPython will use the normal reload(), but
+    deep_reload will still be available as dreload(). This fea- ture is off
+    by default [which means that you have both normal reload() and
+    dreload()].""",
+    "Disable deep (recursive) reloading by default."
+)
+addflag('readline', 'InteractiveShell.readline_use',
+    "Enable readline for command line usage.",
+    "Disable readline for command line usage."
+)
+
+flags['pylab'] = (
+    {'IPKernelApp' : {'pylab' : 'auto'}},
+    """Pre-load matplotlib and numpy for interactive use with
+    the default matplotlib backend."""
+)
+
+aliases = dict(kernel_aliases)
+
+# it's possible we don't want short aliases for *all* of these:
+aliases.update(dict(
+    autocall='InteractiveShell.autocall',
+    cache_size='InteractiveShell.cache_size',
+    colors='InteractiveShell.colors',
+    logfile='InteractiveShell.logfile',
+    log_append='InteractiveShell.logappend',
+    pi1='InteractiveShell.prompt_in1',
+    pi2='InteractiveShell.prompt_in2',
+    po='InteractiveShell.prompt_out',
+    si='InteractiveShell.separate_in',
+    so='InteractiveShell.separate_out',
+    so2='InteractiveShell.separate_out2',
+    xmode='InteractiveShell.xmode',
+    c='IPKernelApp.code_to_run',
+    ext='IPKernelApp.extra_extension',
+    pylab='IPKernelApp.pylab',
+))
 
-    Parameters
-    ----------
-    ip  : str, optional
-        The ip address the kernel will bind to.
-    
-    xrep_port : int, optional
-        The port to use for XREP channel.
+#-----------------------------------------------------------------------------
+# The IPKernelApp class
+#-----------------------------------------------------------------------------
 
-    pub_port : int, optional
-        The port to use for the SUB channel.
+class IPKernelApp(KernelApp):
+    name = 'ipkernel'
+
+    aliases = Dict(aliases)
+    flags = Dict(flags)
+    classes = [Kernel, ZMQInteractiveShell, ProfileDir]
+    # configurables
+    pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'inline', 'auto'],
+        config=True,
+        help="""Pre-load matplotlib and numpy for interactive use,
+        selecting a particular matplotlib backend and loop integration.
+        """
+    )
+    extensions = List(Unicode, config=True,
+        help="A list of dotted module names of IPython extensions to load."
+    )
+    extra_extension = Unicode('', config=True,
+        help="dotted module name of an IPython extension to load."
+    )
+    def _extra_extension_changed(self, name, old, new):
+        if new:
+            # add to self.extensions
+            self.extensions.append(new)
+
+    exec_files = List(Unicode, config=True,
+        help="""List of files to run at IPython startup."""
+    )
+    file_to_run = Unicode('', config=True,
+        help="""A file to be run""")
+    def _file_to_run_changed(self, name, old, new):
+        self.exec_files.append(new)
+
+    exec_lines = List(Unicode, config=True,
+        help="""lines of code to run at IPython startup."""
+    )
+    code_to_run = Unicode('', config=True,
+        help="Execute the given command string."
+    )
+    def _code_to_run_changed(self, name, old, new):
+        self.exec_lines.append(new)
+
+    def init_kernel(self):
+        kernel_factory = Kernel
+
+        kernel_map = {
+            'qt' : QtKernel,
+            'qt4': QtKernel,
+            'inline': Kernel,
+            'osx': TkKernel,
+            'wx' : WxKernel,
+            'tk' : TkKernel,
+            'gtk': GTKKernel,
+        }
 
-    req_port : int, optional
-        The port to use for the REQ (raw input) channel.
+        if self.pylab:
+            key = None if self.pylab == 'auto' else self.pylab
+            gui, backend = pylabtools.find_gui_and_backend(key)
+            kernel_factory = kernel_map.get(gui)
+            if kernel_factory is None:
+                raise ValueError('GUI is not supported: %r' % gui)
+            pylabtools.activate_matplotlib(backend)
+
+        kernel = kernel_factory(config=self.config, session=self.session,
+                                shell_socket=self.shell_socket,
+                                iopub_socket=self.iopub_socket,
+                                stdin_socket=self.stdin_socket,
+                                log=self.log
+        )
+        self.kernel = kernel
+        kernel.record_ports(self.ports)
 
-    hb_port : int, optional
-        The port to use for the hearbeat REP channel.
+        if self.pylab:
+            pylabtools.import_pylab(kernel.shell.user_ns, backend,
+                                    shell=kernel.shell)
 
-    stdin, stdout, stderr : optional (default None)
-        Standards streams, as defined in subprocess.Popen.
 
-    executable : str, optional (default sys.executable)
-        The Python executable to use for the kernel process.
 
-    independent : bool, optional (default False) 
-        If set, the kernel process is guaranteed to survive if this process
-        dies. If not set, an effort is made to ensure that the kernel is killed
-        when this process dies. Note that in this case it is still good practice
-        to kill kernels manually before exiting.
+#-----------------------------------------------------------------------------
+# Kernel main and launch functions
+#-----------------------------------------------------------------------------
 
-    pylab : bool or string, optional (default False)
-        If not False, the kernel will be launched with pylab enabled. If a
-        string is passed, matplotlib will use the specified backend. Otherwise,
-        matplotlib's default backend will be used.
+def launch_kernel(*args, **kwargs):
+    """Launches a localhost IPython kernel, binding to the specified ports.
 
-    colors : None or string, optional (default None)
-        If not None, specify the color scheme. One of (NoColor, LightBG, Linux)
+    This function simply calls entry_point.base_launch_kernel with the right first
+    command to start an ipkernel.  See base_launch_kernel for arguments.
 
     Returns
     -------
     A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
+        (kernel_process, shell_port, iopub_port, stdin_port, hb_port)
     where kernel_process is a Popen object and the ports are integers.
     """
-    extra_arguments = []
-    if pylab:
-        extra_arguments.append('--pylab')
-        if isinstance(pylab, basestring):
-            extra_arguments.append(pylab)
-    if ip is not None:
-        extra_arguments.append('--ip')
-        if isinstance(ip, basestring):
-            extra_arguments.append(ip)
-    if colors is not None:
-        extra_arguments.append('--colors')
-        extra_arguments.append(colors)
     return base_launch_kernel('from IPython.zmq.ipkernel import main; main()',
-                              xrep_port, pub_port, req_port, hb_port, 
-                              stdin, stdout, stderr,
-                              executable, independent, extra_arguments)
+                              *args, **kwargs)
 
 
 def main():
-    """ The IPython kernel main entry point.
-    """
-    parser = make_argument_parser()
-    parser.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
-                        const='auto', help = \
-"Pre-load matplotlib and numpy for interactive use. If GUI is not \
-given, the GUI backend is matplotlib's, otherwise use one of: \
-['tk', 'gtk', 'qt', 'wx', 'osx', 'inline'].")
-    parser.add_argument('--colors',
-        type=str, dest='colors',
-        help="Set the color scheme (NoColor, Linux, and LightBG).",
-        metavar='ZMQInteractiveShell.colors')
-    namespace = parser.parse_args()
-
-    kernel_class = Kernel
-
-    kernel_classes = {
-        'qt' : QtKernel,
-        'qt4': QtKernel,
-        'inline': Kernel,
-        'osx': TkKernel,
-        'wx' : WxKernel,
-        'tk' : TkKernel,
-        'gtk': GTKKernel,
-    }
-    if namespace.pylab:
-        if namespace.pylab == 'auto':
-            gui, backend = pylabtools.find_gui_and_backend()
-        else:
-            gui, backend = pylabtools.find_gui_and_backend(namespace.pylab)
-        kernel_class = kernel_classes.get(gui)
-        if kernel_class is None:
-            raise ValueError('GUI is not supported: %r' % gui)
-        pylabtools.activate_matplotlib(backend)
-    if namespace.colors:
-        ZMQInteractiveShell.colors=namespace.colors
-
-    kernel = make_kernel(namespace, kernel_class, OutStream)
-
-    if namespace.pylab:
-        pylabtools.import_pylab(kernel.shell.user_ns, backend,
-                                shell=kernel.shell)
-
-    start_kernel(namespace, kernel)
+    """Run a PyKernel as an application"""
+    app = IPKernelApp()
+    app.initialize()
+    app.start()
 
 
 if __name__ == '__main__':
     main()

IPython/zmq/kernelmanager.py

@@ -1,968 +1,968 b''
 """Base classes to manage the interaction with a running kernel.
 
 TODO
 * Create logger to handle debugging and console messages.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import atexit
 import errno
 from Queue import Queue, Empty
 from subprocess import Popen
 import signal
 import sys
 from threading import Thread
 import time
 import logging
 
 # System library imports.
 import zmq
 from zmq import POLLIN, POLLOUT, POLLERR
 from zmq.eventloop import ioloop
 
 # Local imports.
 from IPython.utils import io
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 from IPython.utils.traitlets import HasTraits, Any, Instance, Type, TCPAddress
 from session import Session, Message
 
 #-----------------------------------------------------------------------------
 # Constants and exceptions
 #-----------------------------------------------------------------------------
 
 class InvalidPortNumber(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, basestring):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in dct.iteritems():
         if not isinstance(k, basestring):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, basestring):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 #-----------------------------------------------------------------------------
 # ZMQ Socket Channel classes
 #-----------------------------------------------------------------------------
 
 class ZmqSocketChannel(Thread):
     """The base class for the channels that use ZMQ sockets.
     """
     context = None
     session = None
     socket = None
     ioloop = None
     iostate = None
     _address = None
 
     def __init__(self, context, session, address):
         """Create a channel
 
         Parameters
         ----------
         context : :class:`zmq.Context`
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
         address : tuple
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZmqSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         if address[1] == 0:
             message = 'The port number for a channel cannot be 0.'
             raise InvalidPortNumber(message)
         self._address = address
 
     def _run_loop(self):
         """Run my loop, ignoring EINTR events in the poller"""
         while True:
             try:
                 self.ioloop.start()
             except zmq.ZMQError as e:
                 if e.errno == errno.EINTR:
                     continue
                 else:
                     raise
             else:
                 break
     
     def stop(self):
         """Stop the channel's activity.
 
         This calls :method:`Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if 
         :method:`self.start` is called again.
         """
         self.join()
 
     @property
     def address(self):
         """Get the channel's address as an (ip, port) tuple.
         
         By the default, the address is (localhost, 0), where 0 means a random
         port.
         """
         return self._address
 
     def add_io_state(self, state):
         """Add IO state to the eventloop.
 
         Parameters
         ----------
         state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
             The IO state flag to set.
 
         This is thread safe as it uses the thread safe IOLoop.add_callback.
         """
         def add_io_state_callback():
             if not self.iostate & state:
                 self.iostate = self.iostate | state
                 self.ioloop.update_handler(self.socket, self.iostate)
         self.ioloop.add_callback(add_io_state_callback)
 
     def drop_io_state(self, state):
         """Drop IO state from the eventloop.
 
         Parameters
         ----------
         state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
             The IO state flag to set.
 
         This is thread safe as it uses the thread safe IOLoop.add_callback.
         """
         def drop_io_state_callback():
             if self.iostate & state:
                 self.iostate = self.iostate & (~state)
                 self.ioloop.update_handler(self.socket, self.iostate)
         self.ioloop.add_callback(drop_io_state_callback)
 
 
 class XReqSocketChannel(ZmqSocketChannel):
     """The XREQ channel for issues request/replies to the kernel.
     """
 
     command_queue = None
 
     def __init__(self, context, session, address):
         super(XReqSocketChannel, self).__init__(context, session, address)
         self.command_queue = Queue()
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.XREQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.iostate = POLLERR|POLLIN
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self._run_loop()
 
     def stop(self):
         self.ioloop.stop()
         super(XReqSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def execute(self, code, silent=False,
                 user_variables=None, user_expressions=None):
         """Execute code in the kernel.
 
         Parameters
         ----------
         code : str
             A string of Python code.
             
         silent : bool, optional (default False)
             If set, the kernel will execute the code as quietly possible.
 
         user_variables : list, optional
             A list of variable names to pull from the user's namespace.  They
             will come back as a dict with these names as keys and their
             :func:`repr` as values.
             
         user_expressions : dict, optional
             A dict with string keys and  to pull from the user's
             namespace.  They will come back as a dict with these names as keys
             and their :func:`repr` as values.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if user_variables is None:
             user_variables = []
         if user_expressions is None:
             user_expressions = {}
             
         # Don't waste network traffic if inputs are invalid
         if not isinstance(code, basestring):
             raise ValueError('code %r must be a string' % code)
         validate_string_list(user_variables)
         validate_string_dict(user_expressions)
 
         # Create class for content/msg creation. Related to, but possibly
         # not in Session.
         content = dict(code=code, silent=silent,
                        user_variables=user_variables,
                        user_expressions=user_expressions)
         msg = self.session.msg('execute_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         """Tab complete text in the kernel's namespace.
 
         Parameters
         ----------
         text : str
             The text to complete.
         line : str
             The full line of text that is the surrounding context for the 
             text to complete.
         cursor_pos : int
             The position of the cursor in the line where the completion was
             requested.
         block : str, optional
             The full block of code in which the completion is being requested.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.session.msg('complete_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname):
         """Get metadata information about an object.
 
         Parameters
         ----------
         oname : str
             A string specifying the object name.
         
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(oname=oname)
         msg = self.session.msg('object_info_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
         """Get entries from the history list.
 
         Parameters
         ----------
         raw : bool
             If True, return the raw input.
         output : bool
             If True, then return the output as well.
         hist_access_type : str
             'range' (fill in session, start and stop params), 'tail' (fill in n)
              or 'search' (fill in pattern param).
         
         session : int
             For a range request, the session from which to get lines. Session
             numbers are positive integers; negative ones count back from the
             current session.
         start : int
             The first line number of a history range.
         stop : int
             The final (excluded) line number of a history range.
         
         n : int
             The number of lines of history to get for a tail request.
             
         pattern : str
             The glob-syntax pattern for a search request.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(raw=raw, output=output, hist_access_type=hist_access_type,
                                                                     **kwargs)
         msg = self.session.msg('history_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def shutdown(self, restart=False):
         """Request an immediate kernel shutdown.
 
         Upon receipt of the (empty) reply, client code can safely assume that
         the kernel has shut down and it's safe to forcefully terminate it if
         it's still alive.
 
         The kernel will send the reply via a function registered with Python's
         atexit module, ensuring it's truly done as the kernel is done with all
         normal operation.
         """
         # Send quit message to kernel. Once we implement kernel-side setattr,
         # this should probably be done that way, but for now this will do.
         msg = self.session.msg('shutdown_request', {'restart':restart})
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def _handle_events(self, socket, events):
         if events & POLLERR:
             self._handle_err()
         if events & POLLOUT:
             self._handle_send()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_recv(self):
         ident,msg = self.session.recv(self.socket, 0)
         self.call_handlers(msg)
 
     def _handle_send(self):
         try:
             msg = self.command_queue.get(False)
         except Empty:
             pass
         else:
             self.session.send(self.socket,msg)
         if self.command_queue.empty():
             self.drop_io_state(POLLOUT)
 
     def _handle_err(self):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _queue_request(self, msg):
         self.command_queue.put(msg)
         self.add_io_state(POLLOUT)
 
 
 class SubSocketChannel(ZmqSocketChannel):
     """The SUB channel which listens for messages that the kernel publishes.
     """
 
     def __init__(self, context, session, address):
         super(SubSocketChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         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.iostate = POLLIN|POLLERR
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self._run_loop()
 
     def stop(self):
         self.ioloop.stop()
         super(SubSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on the SUB channel.
 
         Callers should use this method to ensure that :method:`call_handlers`
         has been called for all messages that have been received on the
         0MQ SUB socket of this channel.
 
         This method is thread safe.
 
         Parameters
         ----------
         timeout : float, optional
             The maximum amount of time to spend flushing, in seconds. The
             default is one second.
         """
         # We do the IOLoop callback process twice to ensure that the IOLoop
         # gets to perform at least one full poll.
         stop_time = time.time() + timeout
         for i in xrange(2):
             self._flushed = False
             self.ioloop.add_callback(self._flush)
             while not self._flushed and time.time() < stop_time:
                 time.sleep(0.01)
 
     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):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _handle_recv(self):
         # Get all of the messages we can
         while True:
             try:
                 ident,msg = self.session.recv(self.socket)
             except zmq.ZMQError:
                 # Check the errno?
                 # Will this trigger POLLERR?
                 break
             else:
                 if msg is None:
                     break
                 self.call_handlers(msg)
 
     def _flush(self):
         """Callback for :method:`self.flush`."""
         self._flushed = True
 
 
 class RepSocketChannel(ZmqSocketChannel):
     """A reply channel to handle raw_input requests that the kernel makes."""
 
     msg_queue = None
 
     def __init__(self, context, session, address):
         super(RepSocketChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
         self.msg_queue = Queue()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.XREQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.iostate = POLLERR|POLLIN
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self._run_loop()
 
     def stop(self):
         self.ioloop.stop()
         super(RepSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def input(self, string):
         """Send a string of raw input to the kernel."""
         content = dict(value=string)
         msg = self.session.msg('input_reply', content)
         self._queue_reply(msg)
 
     def _handle_events(self, socket, events):
         if events & POLLERR:
             self._handle_err()
         if events & POLLOUT:
             self._handle_send()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_recv(self):
         ident,msg = self.session.recv(self.socket, 0)
         self.call_handlers(msg)
 
     def _handle_send(self):
         try:
             msg = self.msg_queue.get(False)
         except Empty:
             pass
         else:
             self.session.send(self.socket,msg)
         if self.msg_queue.empty():
             self.drop_io_state(POLLOUT)
 
     def _handle_err(self):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _queue_reply(self, msg):
         self.msg_queue.put(msg)
         self.add_io_state(POLLOUT)
 
 
 class HBSocketChannel(ZmqSocketChannel):
     """The heartbeat channel which monitors the kernel heartbeat.
 
     Note that the heartbeat channel is paused by default. As long as you start
     this channel, the kernel manager will ensure that it is paused and un-paused
     as appropriate.
     """
 
     time_to_dead = 3.0
     socket = None
     poller = None
     _running = None
     _pause = None
 
     def __init__(self, context, session, address):
         super(HBSocketChannel, self).__init__(context, session, address)
         self._running = False
         self._pause = True
 
     def _create_socket(self):
         self.socket = self.context.socket(zmq.REQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.poller = zmq.Poller()
         self.poller.register(self.socket, zmq.POLLIN)
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self._create_socket()
         self._running = True
         while self._running:
             if self._pause:
                 time.sleep(self.time_to_dead)
             else:
                 since_last_heartbeat = 0.0
                 request_time = time.time()
                 try:
                     #io.rprint('Ping from HB channel') # dbg
                     self.socket.send(b'ping')
                 except zmq.ZMQError, e:
                     #io.rprint('*** HB Error:', e) # dbg
                     if e.errno == zmq.EFSM:
                         #io.rprint('sleep...', self.time_to_dead) # dbg
                         time.sleep(self.time_to_dead)
                         self._create_socket()
                     else:
                         raise
                 else:
                     while True:
                         try:
                             self.socket.recv(zmq.NOBLOCK)
                         except zmq.ZMQError, e:
                             #io.rprint('*** HB Error 2:', e) # dbg
                             if e.errno == zmq.EAGAIN:
                                 before_poll = time.time()
                                 until_dead = self.time_to_dead - (before_poll -
                                                                   request_time)
 
                                 # When the return value of poll() is an empty
                                 # list, that is when things have gone wrong
                                 # (zeromq bug). As long as it is not an empty
                                 # list, poll is working correctly even if it
                                 # returns quickly. Note: poll timeout is in
                                 # milliseconds.
                                 if until_dead > 0.0:
                                     while True:
                                         try:
                                             self.poller.poll(1000 * until_dead)
                                         except zmq.ZMQError as e:
                                             if e.errno == errno.EINTR:
                                                 continue
                                             else:
                                                 raise
                                         else:
                                             break
                             
                                 since_last_heartbeat = time.time()-request_time
                                 if since_last_heartbeat > self.time_to_dead:
                                     self.call_handlers(since_last_heartbeat)
                                     break
                             else:
                                 # FIXME: We should probably log this instead.
                                 raise
                         else:
                             until_dead = self.time_to_dead - (time.time() -
                                                               request_time)
                             if until_dead > 0.0:
                                 #io.rprint('sleep...', self.time_to_dead) # dbg
                                 time.sleep(until_dead)
                             break
 
     def pause(self):
         """Pause the heartbeat."""
         self._pause = True
 
     def unpause(self):
         """Unpause the heartbeat."""
         self._pause = False
 
     def is_beating(self):
         """Is the heartbeat running and not paused."""
         if self.is_alive() and not self._pause:
             return True
         else:
             return False
 
     def stop(self):
         self._running = False
         super(HBSocketChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 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.
     """
     # 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 kernel process with which the KernelManager is communicating.
     kernel = Instance(Popen)
 
     # The addresses for the communication channels. 
     xreq_address = TCPAddress((LOCALHOST, 0))
     sub_address = TCPAddress((LOCALHOST, 0))
     rep_address = TCPAddress((LOCALHOST, 0))
     hb_address = TCPAddress((LOCALHOST, 0))
 
     # The classes to use for the various channels.
     xreq_channel_class = Type(XReqSocketChannel)
     sub_channel_class = Type(SubSocketChannel)
     rep_channel_class = Type(RepSocketChannel)
     hb_channel_class = Type(HBSocketChannel)
 
     # Protected traits.
     _launch_args = Any
     _xreq_channel = Any
     _sub_channel = Any
     _rep_channel = Any
     _hb_channel = Any
 
     def __init__(self, **kwargs):
         super(KernelManager, self).__init__(**kwargs)
         # Uncomment this to try closing the context.
         # atexit.register(self.context.close)
 
     #--------------------------------------------------------------------------
     # Channel management methods:
     #--------------------------------------------------------------------------
 
     def start_channels(self, xreq=True, sub=True, rep=True, hb=True):
         """Starts the channels for this kernel.
 
         This will create the channels if they do not exist and then start
         them. If port numbers of 0 are being used (random ports) then you
         must first call :method:`start_kernel`. If the channels have been
         stopped and you call this, :class:`RuntimeError` will be raised.
         """
         if xreq:
             self.xreq_channel.start()
         if sub:
             self.sub_channel.start()
         if rep:
             self.rep_channel.start()
         if hb:
             self.hb_channel.start()
 
     def stop_channels(self):
         """Stops all the running channels for this kernel.
         """
         if self.xreq_channel.is_alive():
             self.xreq_channel.stop()
         if self.sub_channel.is_alive():
             self.sub_channel.stop()
         if self.rep_channel.is_alive():
             self.rep_channel.stop()
         if self.hb_channel.is_alive():
             self.hb_channel.stop()
 
     @property
     def channels_running(self):
         """Are any of the channels created and running?"""
         return (self.xreq_channel.is_alive() or self.sub_channel.is_alive() or
                 self.rep_channel.is_alive() or self.hb_channel.is_alive())
 
     #--------------------------------------------------------------------------
     # Kernel process management methods:
     #--------------------------------------------------------------------------
 
     def start_kernel(self, **kw):
         """Starts a kernel process and configures the manager to use it.
 
         If random ports (port=0) are being used, this method must be called
         before the channels are created.
 
         Parameters:
         -----------
         ipython : bool, optional (default True)
              Whether to use an IPython kernel instead of a plain Python kernel.
 
         **kw : optional
              See respective options for IPython and Python kernels.
         """
         xreq, sub, rep, hb = self.xreq_address, self.sub_address, \
             self.rep_address, self.hb_address
         if xreq[0] not in LOCAL_IPS or sub[0] not in LOCAL_IPS or \
                 rep[0] not in LOCAL_IPS or hb[0] not in LOCAL_IPS:
             raise RuntimeError("Can only launch a kernel on a local interface. "
                                "Make sure that the '*_address' attributes are "
                                "configured properly. "
                                "Currently valid addresses are: %s"%LOCAL_IPS
                                )
                     
         self._launch_args = kw.copy()
         if kw.pop('ipython', True):
             from ipkernel import launch_kernel
         else:
             from pykernel import launch_kernel
         self.kernel, xrep, pub, req, _hb = launch_kernel(
-            xrep_port=xreq[1], pub_port=sub[1], 
-            req_port=rep[1], hb_port=hb[1], **kw)
+            shell_port=xreq[1], iopub_port=sub[1],
+            stdin_port=rep[1], hb_port=hb[1], **kw)
         self.xreq_address = (xreq[0], xrep)
         self.sub_address = (sub[0], pub)
         self.rep_address = (rep[0], req)
         self.hb_address = (hb[0], _hb)
 
     def shutdown_kernel(self, restart=False):
         """ Attempts to the stop the kernel process cleanly. If the kernel
         cannot be stopped, it is killed, if possible.
         """
         # FIXME: Shutdown does not work on Windows due to ZMQ errors!
         if sys.platform == 'win32':
             self.kill_kernel()
             return
 
         # Pause the heart beat channel if it exists.
         if self._hb_channel is not None:
             self._hb_channel.pause()
 
         # Don't send any additional kernel kill messages immediately, to give
         # the kernel a chance to properly execute shutdown actions. Wait for at
         # most 1s, checking every 0.1s.
         self.xreq_channel.shutdown(restart=restart)
         for i in range(10):
             if self.is_alive:
                 time.sleep(0.1)
             else:
                 break
         else:
             # OK, we've waited long enough.
             if self.has_kernel:
                 self.kill_kernel()
     
     def restart_kernel(self, now=False, **kw):
         """Restarts a kernel with the arguments that were used to launch it.
         
         If the old kernel was launched with random ports, the same ports will be
         used for the new kernel.
 
         Parameters
         ----------
         now : bool, optional
             If True, the kernel is forcefully restarted *immediately*, without
             having a chance to do any cleanup action.  Otherwise the kernel is
             given 1s to clean up before a forceful restart is issued.
 
             In all cases the kernel is restarted, the only difference is whether
             it is given a chance to perform a clean shutdown or not.
 
         **kw : optional
             Any options specified here will replace those used to launch the
             kernel.
         """
         if self._launch_args is None:
             raise RuntimeError("Cannot restart the kernel. "
                                "No previous call to 'start_kernel'.")
         else:
             # Stop currently running kernel.
             if self.has_kernel:
                 if now:
                     self.kill_kernel()
                 else:
                     self.shutdown_kernel(restart=True)
 
             # Start new kernel.
             self._launch_args.update(kw)
             self.start_kernel(**self._launch_args)
 
             # FIXME: Messages get dropped in Windows due to probable ZMQ bug
             # unless there is some delay here.
             if sys.platform == 'win32':
                 time.sleep(0.2)
 
     @property
     def has_kernel(self):
         """Returns whether a kernel process has been specified for the kernel
         manager.
         """
         return self.kernel is not None
 
     def kill_kernel(self):
         """ Kill the running kernel. """
         if self.has_kernel:
             # Pause the heart beat channel if it exists.
             if self._hb_channel is not None:
                 self._hb_channel.pause()
 
             # Attempt to kill the kernel.
             try:
                 self.kernel.kill()
             except OSError, e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if sys.platform == 'win32':
                     if e.winerror != 5:
                         raise
                 # On Unix, we may get an ESRCH error if the process has already
                 # terminated. Ignore it.
                 else:
                     from errno import ESRCH
                     if e.errno != ESRCH:
                         raise
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def interrupt_kernel(self):
         """ Interrupts the kernel. Unlike ``signal_kernel``, this operation is
         well supported on all platforms.
         """
         if self.has_kernel:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(self.kernel.win32_interrupt_event)
             else:
                 self.kernel.send_signal(signal.SIGINT)
         else:
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
         """ Sends a signal to the kernel. Note that since only SIGTERM is
         supported on Windows, this function is only useful on Unix systems.
         """
         if self.has_kernel:
             self.kernel.send_signal(signum)
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
     @property
     def is_alive(self):
         """Is the kernel process still running?"""
         # FIXME: not using a heartbeat means this method is broken for any
         # remote kernel, it's only capable of handling local kernels.
         if self.has_kernel:
             if self.kernel.poll() is None:
                 return True
             else:
                 return False
         else:
             # We didn't start the kernel with this KernelManager so we don't
             # know if it is running. We should use a heartbeat for this case.
             return True
 
     #--------------------------------------------------------------------------
     # Channels used for communication with the kernel:
     #--------------------------------------------------------------------------
 
     @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,
                                                          self.xreq_address)
         return self._xreq_channel
 
     @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,
                                                        self.sub_address)
         return self._sub_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,
                                                        self.rep_address)
         return self._rep_channel
 
     @property
     def hb_channel(self):
         """Get the heartbeat socket channel object to check that the
         kernel is alive."""
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self.context, 
                                                        self.session,
                                                        self.hb_address)
         return self._hb_channel

IPython/zmq/pykernel.py

@@ -1,316 +1,280 b''
 #!/usr/bin/env python
 """A simple interactive kernel that talks to a frontend over 0MQ.
 
 Things to do:
 
 * 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.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import __builtin__
 from code import CommandCompiler
 import sys
 import time
 import traceback
 
 # System library imports.
 import zmq
 
 # Local imports.
-from IPython.utils.traitlets import HasTraits, Instance, Float
+from IPython.utils.traitlets import HasTraits, Instance, Dict, Float
 from completer import KernelCompleter
-from entry_point import base_launch_kernel, make_default_main
+from entry_point import base_launch_kernel
 from session import Session, Message
+from kernelapp import KernelApp
 
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
 class Kernel(HasTraits):
 
     # Private interface
 
     # Time to sleep after flushing the stdout/err buffers in each execute
     # cycle.  While this introduces a hard limit on the minimal latency of the
     # execute cycle, it helps prevent output synchronization problems for
     # clients.
     # Units are in seconds.  The minimum zmq latency on local host is probably
     # ~150 microseconds, set this to 500us for now.  We may need to increase it
     # a little if it's not enough after more interactive testing.
     _execute_sleep = Float(0.0005, config=True)
 
     # This is a dict of port number that the kernel is listening on. It is set
     # by record_ports and used by connect_request.
-    _recorded_ports = None
+    _recorded_ports = Dict()
 
     #---------------------------------------------------------------------------
     # Kernel interface
     #---------------------------------------------------------------------------
 
     session = Instance(Session)
-    reply_socket = Instance('zmq.Socket')
-    pub_socket = Instance('zmq.Socket')
-    req_socket = Instance('zmq.Socket')
+    shell_socket = Instance('zmq.Socket')
+    iopub_socket = Instance('zmq.Socket')
+    stdin_socket = Instance('zmq.Socket')
 
     def __init__(self, **kwargs):
         super(Kernel, self).__init__(**kwargs)
         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', 'shutdown_request' ]
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def start(self):
         """ Start the kernel main loop.
         """
         while True:
-            ident,msg = self.session.recv(self.reply_socket,0)
+            ident,msg = self.session.recv(self.shell_socket,0)
             assert ident is not None, "Missing message part."
             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 record_ports(self, xrep_port, pub_port, req_port, hb_port):
+    def record_ports(self, ports):
         """Record the ports that this kernel is using.
 
         The creator of the Kernel instance must call this methods if they
         want the :meth:`connect_request` method to return the port numbers.
         """
-        self._recorded_ports = {
-            'xrep_port' : xrep_port,
-            'pub_port' : pub_port,
-            'req_port' : req_port,
-            'hb_port' : hb_port
-        }
+        self._recorded_ports = ports
 
     #---------------------------------------------------------------------------
     # Kernel request handlers
     #---------------------------------------------------------------------------
 
     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.send(self.pub_socket, u'pyin',{u'code':code}, parent=parent)
+        pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent)
 
         try:
             comp_code = self.compiler(code, '<zmq-kernel>')
 
             # Replace raw_input. Note that is not sufficient to replace 
             # raw_input in the user namespace.
             raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
             __builtin__.raw_input = raw_input
 
             # Set the parent message of the display hook and out streams.
             sys.displayhook.set_parent(parent)
             sys.stdout.set_parent(parent)
             sys.stderr.set_parent(parent)
 
             exec comp_code in self.user_ns, self.user_ns
         except:
             etype, evalue, tb = sys.exc_info()
             tb = traceback.format_exception(etype, evalue, tb)
             exc_content = {
                 u'status' : u'error',
                 u'traceback' : tb,
                 u'ename' : unicode(etype.__name__),
                 u'evalue' : unicode(evalue)
             }
-            exc_msg = self.session.send(self.pub_socket, u'pyerr', exc_content, parent)
+            exc_msg = self.session.send(self.iopub_socket, u'pyerr', exc_content, parent)
             reply_content = exc_content
         else:
             reply_content = { 'status' : 'ok', 'payload' : {} }
             
         # Flush output before sending the reply.
         sys.stderr.flush()
         sys.stdout.flush()
         # FIXME: on rare occasions, the flush doesn't seem to make it to the
         # clients... This seems to mitigate the problem, but we definitely need
         # to better understand what's going on.
         if self._execute_sleep:
             time.sleep(self._execute_sleep)
 
         # Send the reply.
-        reply_msg = self.session.send(self.reply_socket, u'execute_reply', reply_content, parent, ident=ident)
+        reply_msg = self.session.send(self.shell_socket, u'execute_reply', reply_content, parent, ident=ident)
         print>>sys.__stdout__, Message(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',
+        completion_msg = self.session.send(self.shell_socket, 'complete_reply',
                                            matches, parent, ident)
         print >> sys.__stdout__, completion_msg
 
     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',
+        msg = self.session.send(self.shell_socket, 'object_info_reply',
                                 object_info, parent, ident)
         print >> sys.__stdout__, msg
 
     def shutdown_request(self, ident, parent):
         content = dict(parent['content'])
-        msg = self.session.send(self.reply_socket, 'shutdown_reply',
+        msg = self.session.send(self.shell_socket, 'shutdown_reply',
                                 content, parent, ident)
-        msg = self.session.send(self.pub_socket, 'shutdown_reply',
+        msg = self.session.send(self.iopub_socket, 'shutdown_reply',
                                 content, parent, ident)
         print >> sys.__stdout__, msg
         time.sleep(0.1)
         sys.exit(0)
 
     #---------------------------------------------------------------------------
     # Protected interface
     #---------------------------------------------------------------------------
 
     def _abort_queue(self):
         while True:
             ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
             if msg is None:
                 break
             else:
                 assert ident is not None, "Unexpected missing message part."
             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.send(self.reply_socket, reply_type, {'status':'aborted'}, msg, ident=ident)
+            reply_msg = self.session.send(self.shell_socket, reply_type, {'status':'aborted'}, msg, ident=ident)
             print>>sys.__stdout__, Message(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 _raw_input(self, prompt, ident, parent):
         # Flush output before making the request.
         sys.stderr.flush()
         sys.stdout.flush()
 
         # Send the input request.
         content = dict(prompt=prompt)
-        msg = self.session.send(self.req_socket, u'input_request', content, parent)
+        msg = self.session.send(self.stdin_socket, u'input_request', content, parent)
 
         # Await a response.
-        ident,reply = self.session.recv(self.req_socket, 0)
+        ident,reply = self.session.recv(self.stdin_socket, 0)
         try:
             value = reply['content']['value']
         except:
             print>>sys.__stderr__, "Got bad raw_input reply: "
             print>>sys.__stderr__, Message(parent)
             value = ''
         return value
 
     def _complete(self, msg):
         return self.completer.complete(msg.content.line, msg.content.text)
 
     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, []
 
 #-----------------------------------------------------------------------------
 # Kernel main and launch functions
 #-----------------------------------------------------------------------------
 
-def launch_kernel(ip=None, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                  stdin=None, stdout=None, stderr=None,
-                  executable=None, independent=False):
-    """ Launches a localhost kernel, binding to the specified ports.
-
-    Parameters
-    ----------
-    ip  : str, optional
-        The ip address the kernel will bind to.
+def launch_kernel(*args, **kwargs):
+    """ Launches a simple Python kernel, binding to the specified ports.
     
-    xrep_port : int, optional
-        The port to use for XREP channel.
-
-    pub_port : int, optional
-        The port to use for the SUB channel.
-
-    req_port : int, optional
-        The port to use for the REQ (raw input) channel.
-
-    hb_port : int, optional
-        The port to use for the hearbeat REP channel.
-
-    stdin, stdout, stderr : optional (default None)
-        Standards streams, as defined in subprocess.Popen.
-
-    executable : str, optional (default sys.executable)
-        The Python executable to use for the kernel process.
-
-    independent : bool, optional (default False) 
-        If set, the kernel process is guaranteed to survive if this process
-        dies. If not set, an effort is made to ensure that the kernel is killed
-        when this process dies. Note that in this case it is still good practice
-        to kill kernels manually before exiting.
+    This function simply calls entry_point.base_launch_kernel with the right first
+    command to start a pykernel.  See base_launch_kernel for arguments.
 
     Returns
     -------
     A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
+        (kernel_process, xrep_port, pub_port, req_port, hb_port)
     where kernel_process is a Popen object and the ports are integers.
     """
-    extra_arguments = []
-    if ip is not None:
-        extra_arguments.append('--ip')
-        if isinstance(ip, basestring):
-            extra_arguments.append(ip)
-    
     return base_launch_kernel('from IPython.zmq.pykernel import main; main()',
-                              xrep_port, pub_port, req_port, hb_port,
-                              stdin, stdout, stderr,
-                              executable, independent, extra_arguments)
+                                *args, **kwargs)
 
-main = make_default_main(Kernel)
+def main():
+    """Run a PyKernel as an application"""
+    app = KernelApp()
+    app.initialize()
+    app.start()
 
 if __name__ == '__main__':
     main()