Refactor newparallel to use Config system

This is working, but incomplete.

IPython/zmq/parallel/clusterdir.py

@@ -0,0 +1,549 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+The IPython cluster directory
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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
+#-----------------------------------------------------------------------------
+
+from __future__ import with_statement
+
+import os
+import shutil
+import sys
+import logging
+import warnings
+
+from IPython.config.loader import PyFileConfigLoader
+from IPython.core.application import Application, BaseAppConfigLoader
+from IPython.config.configurable import Configurable
+from IPython.core.crashhandler import CrashHandler
+from IPython.core import release
+from IPython.utils.path import (
+    get_ipython_package_dir,
+    expand_path
+)
+from IPython.utils.traitlets import Unicode
+
+#-----------------------------------------------------------------------------
+# Warnings control
+#-----------------------------------------------------------------------------
+# Twisted generates annoying warnings with Python 2.6, as will do other code
+# that imports 'sets' as of today
+warnings.filterwarnings('ignore', 'the sets module is deprecated',
+                        DeprecationWarning )
+
+# This one also comes from Twisted
+warnings.filterwarnings('ignore', 'the sha module is deprecated',
+                        DeprecationWarning)
+
+#-----------------------------------------------------------------------------
+# Module errors
+#-----------------------------------------------------------------------------
+
+class ClusterDirError(Exception):
+    pass
+
+
+class PIDFileError(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------------
+# Class for managing cluster directories
+#-----------------------------------------------------------------------------
+
+class ClusterDir(Configurable):
+    """An object to manage the cluster directory and its resources.
+
+    The cluster directory is used by :command:`ipengine`, 
+    :command:`ipcontroller` and :command:`ipclsuter` to manage the
+    configuration, logging and security of these applications.
+
+    This object knows how to find, create and manage these directories. This
+    should be used by any code that want's to handle cluster directories.
+    """
+
+    security_dir_name = Unicode('security')
+    log_dir_name = Unicode('log')
+    pid_dir_name = Unicode('pid')
+    security_dir = Unicode(u'')
+    log_dir = Unicode(u'')
+    pid_dir = Unicode(u'')
+    location = Unicode(u'')
+
+    def __init__(self, location=u''):
+        super(ClusterDir, self).__init__(location=location)
+
+    def _location_changed(self, name, old, new):
+        if not os.path.isdir(new):
+            os.makedirs(new)
+        self.security_dir = os.path.join(new, self.security_dir_name)
+        self.log_dir = os.path.join(new, self.log_dir_name)
+        self.pid_dir = os.path.join(new, self.pid_dir_name)
+        self.check_dirs()
+
+    def _log_dir_changed(self, name, old, new):
+        self.check_log_dir()
+
+    def check_log_dir(self):
+        if not os.path.isdir(self.log_dir):
+            os.mkdir(self.log_dir)
+
+    def _security_dir_changed(self, name, old, new):
+        self.check_security_dir()
+
+    def check_security_dir(self):
+        if not os.path.isdir(self.security_dir):
+            os.mkdir(self.security_dir, 0700)
+        os.chmod(self.security_dir, 0700)
+
+    def _pid_dir_changed(self, name, old, new):
+        self.check_pid_dir()
+
+    def check_pid_dir(self):
+        if not os.path.isdir(self.pid_dir):
+            os.mkdir(self.pid_dir, 0700)
+        os.chmod(self.pid_dir, 0700)
+
+    def check_dirs(self):
+        self.check_security_dir()
+        self.check_log_dir()
+        self.check_pid_dir()
+
+    def load_config_file(self, filename):
+        """Load a config file from the top level of the cluster dir.
+
+        Parameters
+        ----------
+        filename : unicode or str
+            The filename only of the config file that must be located in
+            the top-level of the cluster directory.
+        """
+        loader = PyFileConfigLoader(filename, self.location)
+        return loader.load_config()
+
+    def copy_config_file(self, config_file, path=None, overwrite=False):
+        """Copy a default config file into the active cluster directory.
+
+        Default configuration files are kept in :mod:`IPython.config.default`.
+        This function moves these from that location to the working cluster
+        directory.
+        """
+        if path is None:
+            import IPython.config.default
+            path = IPython.config.default.__file__.split(os.path.sep)[:-1]
+            path = os.path.sep.join(path)
+        src = os.path.join(path, config_file)
+        dst = os.path.join(self.location, config_file)
+        if not os.path.isfile(dst) or overwrite:
+            shutil.copy(src, dst)
+
+    def copy_all_config_files(self, path=None, overwrite=False):
+        """Copy all config files into the active cluster directory."""
+        for f in [u'ipcontroller_config.py', u'ipengine_config.py',
+                  u'ipcluster_config.py']:
+            self.copy_config_file(f, path=path, overwrite=overwrite)
+
+    @classmethod
+    def create_cluster_dir(csl, cluster_dir):
+        """Create a new cluster directory given a full path.
+
+        Parameters
+        ----------
+        cluster_dir : str
+            The full path to the cluster directory.  If it does exist, it will
+            be used.  If not, it will be created.
+        """
+        return ClusterDir(location=cluster_dir)
+
+    @classmethod
+    def create_cluster_dir_by_profile(cls, path, profile=u'default'):
+        """Create a cluster dir by profile name and path.
+
+        Parameters
+        ----------
+        path : str
+            The path (directory) to put the cluster directory in.
+        profile : str
+            The name of the profile.  The name of the cluster directory will
+            be "clusterz_<profile>".
+        """
+        if not os.path.isdir(path):
+            raise ClusterDirError('Directory not found: %s' % path)
+        cluster_dir = os.path.join(path, u'clusterz_' + profile)
+        return ClusterDir(location=cluster_dir)
+
+    @classmethod
+    def find_cluster_dir_by_profile(cls, ipython_dir, profile=u'default'):
+        """Find an existing cluster dir by profile name, return its ClusterDir.
+
+        This searches through a sequence of paths for a cluster dir.  If it
+        is not found, a :class:`ClusterDirError` exception will be raised.
+
+        The search path algorithm is:
+        1. ``os.getcwd()``
+        2. ``ipython_dir``
+        3. The directories found in the ":" separated 
+           :env:`IPCLUSTER_DIR_PATH` environment variable.
+
+        Parameters
+        ----------
+        ipython_dir : unicode or str
+            The IPython directory to use.
+        profile : unicode or str
+            The name of the profile.  The name of the cluster directory
+            will be "clusterz_<profile>".
+        """
+        dirname = u'clusterz_' + profile
+        cluster_dir_paths = os.environ.get('IPCLUSTER_DIR_PATH','')
+        if cluster_dir_paths:
+            cluster_dir_paths = cluster_dir_paths.split(':')
+        else:
+            cluster_dir_paths = []
+        paths = [os.getcwd(), ipython_dir] + cluster_dir_paths
+        for p in paths:
+            cluster_dir = os.path.join(p, dirname)
+            if os.path.isdir(cluster_dir):
+                return ClusterDir(location=cluster_dir)
+        else:
+            raise ClusterDirError('Cluster directory not found in paths: %s' % dirname)
+
+    @classmethod
+    def find_cluster_dir(cls, cluster_dir):
+        """Find/create a cluster dir and return its ClusterDir.
+
+        This will create the cluster directory if it doesn't exist.
+
+        Parameters
+        ----------
+        cluster_dir : unicode or str
+            The path of the cluster directory.  This is expanded using
+            :func:`IPython.utils.genutils.expand_path`.
+        """
+        cluster_dir = expand_path(cluster_dir)
+        if not os.path.isdir(cluster_dir):
+            raise ClusterDirError('Cluster directory not found: %s' % cluster_dir)
+        return ClusterDir(location=cluster_dir)
+
+
+#-----------------------------------------------------------------------------
+# Command line options
+#-----------------------------------------------------------------------------
+
+class ClusterDirConfigLoader(BaseAppConfigLoader):
+
+    def _add_cluster_profile(self, parser):
+        paa = parser.add_argument
+        paa('-p', '--profile',
+            dest='Global.profile',type=unicode,
+            help=
+            """The string name of the profile to be used. This determines the name
+            of the cluster dir as: cluster_<profile>. The default profile is named
+            'default'.  The cluster directory is resolve this way if the
+            --cluster-dir option is not used.""",
+            metavar='Global.profile')
+
+    def _add_cluster_dir(self, parser):
+        paa = parser.add_argument
+        paa('--cluster-dir',
+            dest='Global.cluster_dir',type=unicode,
+            help="""Set the cluster dir. This overrides the logic used by the
+            --profile option.""",
+            metavar='Global.cluster_dir')
+
+    def _add_work_dir(self, parser):
+        paa = parser.add_argument
+        paa('--work-dir',
+            dest='Global.work_dir',type=unicode,
+            help='Set the working dir for the process.',
+            metavar='Global.work_dir')
+
+    def _add_clean_logs(self, parser):
+        paa = parser.add_argument
+        paa('--clean-logs',
+            dest='Global.clean_logs', action='store_true',
+            help='Delete old log flies before starting.')
+
+    def _add_no_clean_logs(self, parser):
+        paa = parser.add_argument
+        paa('--no-clean-logs',
+            dest='Global.clean_logs', action='store_false',
+            help="Don't Delete old log flies before starting.")
+
+    def _add_arguments(self):
+        super(ClusterDirConfigLoader, self)._add_arguments()
+        self._add_cluster_profile(self.parser)
+        self._add_cluster_dir(self.parser)
+        self._add_work_dir(self.parser)
+        self._add_clean_logs(self.parser)
+        self._add_no_clean_logs(self.parser)
+
+
+#-----------------------------------------------------------------------------
+# Crash handler for this application
+#-----------------------------------------------------------------------------
+
+
+_message_template = """\
+Oops, $self.app_name crashed. We do our best to make it stable, but...
+
+A crash report was automatically generated with the following information:
+  - A verbatim copy of the crash traceback.
+  - Data on your current $self.app_name configuration.
+
+It was left in the file named:
+\t'$self.crash_report_fname'
+If you can email this file to the developers, the information in it will help
+them in understanding and correcting the problem.
+
+You can mail it to: $self.contact_name at $self.contact_email
+with the subject '$self.app_name Crash Report'.
+
+If you want to do it now, the following command will work (under Unix):
+mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
+
+To ensure accurate tracking of this issue, please file a report about it at:
+$self.bug_tracker
+"""
+
+class ClusterDirCrashHandler(CrashHandler):
+    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
+
+    message_template = _message_template
+
+    def __init__(self, app):
+        contact_name = release.authors['Brian'][0]
+        contact_email = release.authors['Brian'][1]
+        bug_tracker = 'http://github.com/ipython/ipython/issues'
+        super(ClusterDirCrashHandler,self).__init__(
+            app, contact_name, contact_email, bug_tracker
+        )
+
+
+#-----------------------------------------------------------------------------
+# Main application
+#-----------------------------------------------------------------------------
+
+class ApplicationWithClusterDir(Application):
+    """An application that puts everything into a cluster directory.
+
+    Instead of looking for things in the ipython_dir, this type of application
+    will use its own private directory called the "cluster directory"
+    for things like config files, log files, etc.
+
+    The cluster directory is resolved as follows:
+
+    * If the ``--cluster-dir`` option is given, it is used.
+    * If ``--cluster-dir`` is not given, the application directory is 
+      resolve using the profile name as ``cluster_<profile>``. The search 
+      path for this directory is then i) cwd if it is found there
+      and ii) in ipython_dir otherwise.
+
+    The config file for the application is to be put in the cluster
+    dir and named the value of the ``config_file_name`` class attribute.
+    """
+
+    command_line_loader = ClusterDirConfigLoader
+    crash_handler_class = ClusterDirCrashHandler
+    auto_create_cluster_dir = True
+    # temporarily override default_log_level to DEBUG
+    default_log_level = logging.DEBUG
+
+    def create_default_config(self):
+        super(ApplicationWithClusterDir, self).create_default_config()
+        self.default_config.Global.profile = u'default'
+        self.default_config.Global.cluster_dir = u''
+        self.default_config.Global.work_dir = os.getcwd()
+        self.default_config.Global.log_to_file = False
+        self.default_config.Global.log_url = None
+        self.default_config.Global.clean_logs = False
+
+    def find_resources(self):
+        """This resolves the cluster directory.
+
+        This tries to find the cluster directory and if successful, it will
+        have done:
+        * Sets ``self.cluster_dir_obj`` to the :class:`ClusterDir` object for 
+          the application.
+        * Sets ``self.cluster_dir`` attribute of the application and config
+          objects.
+
+        The algorithm used for this is as follows:
+        1. Try ``Global.cluster_dir``.
+        2. Try using ``Global.profile``.
+        3. If both of these fail and ``self.auto_create_cluster_dir`` is
+           ``True``, then create the new cluster dir in the IPython directory.
+        4. If all fails, then raise :class:`ClusterDirError`.
+        """
+
+        try:
+            cluster_dir = self.command_line_config.Global.cluster_dir
+        except AttributeError:
+            cluster_dir = self.default_config.Global.cluster_dir
+        cluster_dir = expand_path(cluster_dir)
+        try:
+            self.cluster_dir_obj = ClusterDir.find_cluster_dir(cluster_dir)
+        except ClusterDirError:
+            pass
+        else:
+            self.log.info('Using existing cluster dir: %s' % \
+                self.cluster_dir_obj.location
+            )
+            self.finish_cluster_dir()
+            return
+
+        try:
+            self.profile = self.command_line_config.Global.profile
+        except AttributeError:
+            self.profile = self.default_config.Global.profile
+        try:
+            self.cluster_dir_obj = ClusterDir.find_cluster_dir_by_profile(
+                self.ipython_dir, self.profile)
+        except ClusterDirError:
+            pass
+        else:
+            self.log.info('Using existing cluster dir: %s' % \
+                self.cluster_dir_obj.location
+            )
+            self.finish_cluster_dir()
+            return
+
+        if self.auto_create_cluster_dir:
+            self.cluster_dir_obj = ClusterDir.create_cluster_dir_by_profile(
+                self.ipython_dir, self.profile
+            )
+            self.log.info('Creating new cluster dir: %s' % \
+                self.cluster_dir_obj.location
+            )
+            self.finish_cluster_dir()
+        else:
+            raise ClusterDirError('Could not find a valid cluster directory.')
+
+    def finish_cluster_dir(self):
+        # Set the cluster directory
+        self.cluster_dir = self.cluster_dir_obj.location
+        
+        # These have to be set because they could be different from the one
+        # that we just computed.  Because command line has the highest
+        # priority, this will always end up in the master_config.
+        self.default_config.Global.cluster_dir = self.cluster_dir
+        self.command_line_config.Global.cluster_dir = self.cluster_dir
+
+    def find_config_file_name(self):
+        """Find the config file name for this application."""
+        # For this type of Application it should be set as a class attribute.
+        if not hasattr(self, 'default_config_file_name'):
+            self.log.critical("No config filename found")
+        else:
+            self.config_file_name = self.default_config_file_name
+
+    def find_config_file_paths(self):
+        # Set the search path to to the cluster directory. We should NOT
+        # include IPython.config.default here as the default config files
+        # are ALWAYS automatically moved to the cluster directory.
+        conf_dir = os.path.join(get_ipython_package_dir(), 'config', 'default')
+        self.config_file_paths = (self.cluster_dir,)
+
+    def pre_construct(self):
+        # The log and security dirs were set earlier, but here we put them
+        # into the config and log them.
+        config = self.master_config
+        sdir = self.cluster_dir_obj.security_dir
+        self.security_dir = config.Global.security_dir = sdir
+        ldir = self.cluster_dir_obj.log_dir
+        self.log_dir = config.Global.log_dir = ldir
+        pdir = self.cluster_dir_obj.pid_dir
+        self.pid_dir = config.Global.pid_dir = pdir
+        self.log.info("Cluster directory set to: %s" % self.cluster_dir)
+        config.Global.work_dir = unicode(expand_path(config.Global.work_dir))
+        # Change to the working directory. We do this just before construct
+        # is called so all the components there have the right working dir.
+        self.to_work_dir()
+
+    def to_work_dir(self):
+        wd = self.master_config.Global.work_dir
+        if unicode(wd) != unicode(os.getcwd()):
+            os.chdir(wd)
+            self.log.info("Changing to working dir: %s" % wd)
+
+    def start_logging(self):
+        # Remove old log files
+        if self.master_config.Global.clean_logs:
+            log_dir = self.master_config.Global.log_dir
+            for f in os.listdir(log_dir):
+                if f.startswith(self.name + u'-') and f.endswith('.log'):
+                    os.remove(os.path.join(log_dir, f))
+        # Start logging to the new log file
+        if self.master_config.Global.log_to_file:
+            log_filename = self.name + u'-' + str(os.getpid()) + u'.log'
+            logfile = os.path.join(self.log_dir, log_filename)
+            open_log_file = open(logfile, 'w')
+        elif self.master_config.Global.log_url:
+            open_log_file = None
+        else:
+            open_log_file = sys.stdout
+        logger = logging.getLogger()
+        level = self.log_level
+        self.log = logger
+        # since we've reconnected the logger, we need to reconnect the log-level
+        self.log_level = level
+        if open_log_file is not None and self._log_handler not in self.log.handlers:
+            self.log.addHandler(self._log_handler)
+        # log.startLogging(open_log_file)
+
+    def write_pid_file(self, overwrite=False):
+        """Create a .pid file in the pid_dir with my pid.
+
+        This must be called after pre_construct, which sets `self.pid_dir`.
+        This raises :exc:`PIDFileError` if the pid file exists already.
+        """
+        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
+        if os.path.isfile(pid_file):
+            pid = self.get_pid_from_file()
+            if not overwrite:
+                raise PIDFileError(
+                    'The pid file [%s] already exists. \nThis could mean that this '
+                    'server is already running with [pid=%s].' % (pid_file, pid)
+                )
+        with open(pid_file, 'w') as f:
+            self.log.info("Creating pid file: %s" % pid_file)
+            f.write(repr(os.getpid())+'\n')
+
+    def remove_pid_file(self):
+        """Remove the pid file.
+
+        This should be called at shutdown by registering a callback with
+        :func:`reactor.addSystemEventTrigger`. This needs to return
+        ``None``.
+        """
+        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
+        if os.path.isfile(pid_file):
+            try:
+                self.log.info("Removing pid file: %s" % pid_file)
+                os.remove(pid_file)
+            except:
+                self.log.warn("Error removing the pid file: %s" % pid_file)
+
+    def get_pid_from_file(self):
+        """Get the pid from the pid file.
+
+        If the  pid file doesn't exist a :exc:`PIDFileError` is raised.
+        """
+        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
+        if os.path.isfile(pid_file):
+            with open(pid_file, 'r') as f:
+                pid = int(f.read().strip())
+                return pid
+        else:
+            raise PIDFileError('pid file not found: %s' % pid_file)
+

IPython/zmq/parallel/factory.py

@@ -0,0 +1,149 b''
+"""Base config factories."""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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 logging
+
+import uuid
+
+from zmq.eventloop.ioloop import IOLoop
+
+from IPython.config.configurable import Configurable
+from IPython.utils.traitlets import Str,Int,Instance, CUnicode, CStr
+from IPython.utils.importstring import import_item
+
+from IPython.zmq.parallel.entry_point import select_random_ports
+import IPython.zmq.parallel.streamsession as ss
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+
+class SessionFactory(Configurable):
+    """The Base factory from which every factory in IPython.zmq.parallel inherits"""
+    
+    packer = Str('',config=True)
+    unpacker = Str('',config=True)
+    ident = CStr('',config=True)
+    def _ident_default(self):
+        return str(uuid.uuid4())
+    username = Str(os.environ.get('USER','username'),config=True)
+    exec_key = CUnicode('',config=True)
+    
+    # not configurable:
+    context = Instance('zmq.Context', (), {})
+    session = Instance('IPython.zmq.parallel.streamsession.StreamSession')
+    loop = Instance('zmq.eventloop.ioloop.IOLoop')
+    def _loop_default(self):
+        return IOLoop.instance()
+    
+    def __init__(self, **kwargs):
+        super(SessionFactory, self).__init__(**kwargs)
+        
+        keyfile = self.exec_key or None
+        
+        # set the packers:
+        if not self.packer:
+            packer_f = unpacker_f = None
+        elif self.packer.lower() == 'json':
+            packer_f = ss.json_packer
+            unpacker_f = ss.json_unpacker
+        elif self.packer.lower() == 'pickle':
+            packer_f = ss.pickle_packer
+            unpacker_f = ss.pickle_unpacker
+        else:
+            packer_f = import_item(self.packer)
+            unpacker_f = import_item(self.unpacker)
+        
+        # construct the session
+        self.session = ss.StreamSession(self.username, self.ident, packer=packer_f, unpacker=unpacker_f, keyfile=keyfile)
+    
+
+class RegistrationFactory(SessionFactory):
+    """The Base Configurable for objects that involve registration."""
+    
+    url = Str('', config=True) # url takes precedence over ip,regport,transport
+    transport = Str('tcp', config=True)
+    ip = Str('127.0.0.1', config=True)
+    regport = Instance(int, config=True)
+    def _regport_default(self):
+        return 10101
+        # return select_random_ports(1)[0]
+    
+    def __init__(self, **kwargs):
+        super(RegistrationFactory, self).__init__(**kwargs)
+        self._propagate_url()
+        self._rebuild_url()
+        self.on_trait_change(self._propagate_url, 'url')
+        self.on_trait_change(self._rebuild_url, 'ip')
+        self.on_trait_change(self._rebuild_url, 'transport')
+        self.on_trait_change(self._rebuild_url, 'regport')
+    
+    def _rebuild_url(self):
+        self.url = "%s://%s:%i"%(self.transport, self.ip, self.regport)
+        
+    def _propagate_url(self):
+        """Ensure self.url contains full transport://interface:port"""
+        if self.url:
+            iface = self.url.split('://',1)
+            if len(iface) == 2:
+                self.transport,iface = iface
+            iface = iface.split(':')
+            self.ip = iface[0]
+            if iface[1]:
+                self.regport = int(iface[1])
+
+#-----------------------------------------------------------------------------
+# argparse argument extenders
+#-----------------------------------------------------------------------------
+
+
+def add_session_arguments(parser):
+    paa = parser.add_argument
+    paa('--ident',
+        type=str, dest='SessionFactory.ident', 
+        help='set the ZMQ and session identity [default: random uuid]',
+        metavar='identity')
+    # paa('--execkey',
+    #     type=str, dest='SessionFactory.exec_key', 
+    #     help='path to a file containing an execution key.',
+    #     metavar='execkey')
+    paa('--packer',
+        type=str, dest='SessionFactory.packer', 
+        help='method to serialize messages: {json,pickle} [default: json]',
+        metavar='packer')
+    paa('--unpacker',
+        type=str, dest='SessionFactory.unpacker', 
+        help='inverse function of `packer`.  Only necessary when using something other than json|pickle',
+        metavar='packer')
+
+def add_registration_arguments(parser):
+    paa = parser.add_argument
+    paa('--ip',
+        type=str, dest='RegistrationFactory.ip',
+        help="The IP used for registration [default: localhost]",
+        metavar='ip')
+    paa('--transport',
+        type=str, dest='RegistrationFactory.transport',
+        help="The ZeroMQ transport used for registration [default: tcp]",
+        metavar='transport')
+    paa('--url',
+        type=str, dest='RegistrationFactory.url', 
+        help='set transport,ip,regport in one go, e.g. tcp://127.0.0.1:10101',
+        metavar='url')
+    paa('--regport',
+        type=int, dest='RegistrationFactory.regport',
+        help="The port used for registration [default: 10101]",
+        metavar='ip')

IPython/zmq/parallel/ipcontrollerapp.py

@@ -0,0 +1,322 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+The IPython controller application.
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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
+#-----------------------------------------------------------------------------
+
+from __future__ import with_statement
+
+import copy
+import sys
+import os
+import logging
+# from twisted.application import service
+# from twisted.internet import reactor
+# from twisted.python import log
+
+import zmq
+from zmq.log.handlers import PUBHandler
+
+from IPython.config.loader import Config
+from IPython.zmq.parallel import factory
+from IPython.zmq.parallel.controller import ControllerFactory
+from IPython.zmq.parallel.clusterdir import (
+    ApplicationWithClusterDir,
+    ClusterDirConfigLoader
+)
+# from IPython.kernel.fcutil import FCServiceFactory, FURLError
+from IPython.utils.traitlets import Instance, Unicode
+
+from entry_point import generate_exec_key
+
+
+#-----------------------------------------------------------------------------
+# Module level variables
+#-----------------------------------------------------------------------------
+
+
+#: The default config file name for this application
+default_config_file_name = u'ipcontroller_config.py'
+
+
+_description = """Start the IPython controller for parallel computing.
+
+The IPython controller provides a gateway between the IPython engines and
+clients. The controller needs to be started before the engines and can be
+configured using command line options or using a cluster directory. Cluster
+directories contain config, log and security files and are usually located in
+your .ipython directory and named as "cluster_<profile>". See the --profile
+and --cluster-dir options for details.
+"""
+
+#-----------------------------------------------------------------------------
+# Default interfaces
+#-----------------------------------------------------------------------------
+
+# The default client interfaces for FCClientServiceFactory.interfaces
+default_client_interfaces = Config()
+default_client_interfaces.Default.url_file = 'ipcontroller-client.url'
+
+# Make this a dict we can pass to Config.__init__ for the default
+default_client_interfaces = dict(copy.deepcopy(default_client_interfaces.items()))
+
+
+
+# The default engine interfaces for FCEngineServiceFactory.interfaces
+default_engine_interfaces = Config()
+default_engine_interfaces.Default.url_file = u'ipcontroller-engine.url'
+
+# Make this a dict we can pass to Config.__init__ for the default
+default_engine_interfaces = dict(copy.deepcopy(default_engine_interfaces.items()))
+
+
+#-----------------------------------------------------------------------------
+# Service factories
+#-----------------------------------------------------------------------------
+
+# 
+# class FCClientServiceFactory(FCServiceFactory):
+#     """A Foolscap implementation of the client services."""
+# 
+#     cert_file = Unicode(u'ipcontroller-client.pem', config=True)
+#     interfaces = Instance(klass=Config, kw=default_client_interfaces,
+#                           allow_none=False, config=True)
+# 
+# 
+# class FCEngineServiceFactory(FCServiceFactory):
+#     """A Foolscap implementation of the engine services."""
+# 
+#     cert_file = Unicode(u'ipcontroller-engine.pem', config=True)
+#     interfaces = Instance(klass=dict, kw=default_engine_interfaces,
+#                           allow_none=False, config=True)
+# 
+
+#-----------------------------------------------------------------------------
+# Command line options
+#-----------------------------------------------------------------------------
+
+
+class IPControllerAppConfigLoader(ClusterDirConfigLoader):
+
+    def _add_arguments(self):
+        super(IPControllerAppConfigLoader, self)._add_arguments()
+        paa = self.parser.add_argument
+        
+        ## Hub Config:
+        paa('--mongodb', 
+            dest='HubFactory.db_class', action='store_const',
+            const='IPython.zmq.parallel.mongodb.MongoDB', 
+            help='Use MongoDB task storage [default: in-memory]')
+        paa('--hb',
+            type=int, dest='HubFactory.hb', nargs=2,
+            help='The (2) ports the Hub\'s Heartmonitor will use for the heartbeat '
+            'connections [default: random]',
+            metavar='Hub.hb_ports')
+        
+        # Client config
+        paa('--client-ip',
+            type=str, dest='HubFactory.client_ip', 
+            help='The IP address or hostname the Hub will listen on for '
+            'client connections. Both engine-ip and client-ip can be set simultaneously '
+            'via --ip [default: loopback]',
+            metavar='Hub.client_ip')
+        paa('--client-transport',
+            type=str, dest='HubFactory.client_transport', 
+            help='The ZeroMQ transport the Hub will use for '
+            'client connections. Both engine-transport and client-transport can be set simultaneously '
+            'via --transport [default: tcp]',
+            metavar='Hub.client_transport')
+        paa('--query',
+            type=int, dest='HubFactory.query_port', 
+            help='The port on which the Hub XREP socket will listen for result queries from clients [default: random]',
+            metavar='Hub.query_port')
+        paa('--notifier',
+            type=int, dest='HubFactory.notifier_port', 
+            help='The port on which the Hub PUB socket will listen for notification connections [default: random]',
+            metavar='Hub.notifier_port')
+        
+        # Engine config
+        paa('--engine-ip',
+            type=str, dest='HubFactory.engine_ip', 
+            help='The IP address or hostname the Hub will listen on for '
+            'engine connections. This applies to the Hub and its schedulers'
+            'engine-ip and client-ip can be set simultaneously '
+            'via --ip [default: loopback]',
+            metavar='Hub.engine_ip')
+        paa('--engine-transport',
+            type=str, dest='HubFactory.engine_transport', 
+            help='The ZeroMQ transport the Hub will use for '
+            'client connections. Both engine-transport and client-transport can be set simultaneously '
+            'via --transport [default: tcp]',
+            metavar='Hub.engine_transport')
+        
+        # Scheduler config
+        paa('--mux',
+            type=int, dest='ControllerFactory.mux', nargs=2,
+            help='The (2) ports the MUX scheduler will listen on for client,engine '
+            'connections, respectively [default: random]',
+            metavar='Scheduler.mux_ports')
+        paa('--task',
+            type=int, dest='ControllerFactory.task', nargs=2,
+            help='The (2) ports the Task scheduler will listen on for client,engine '
+            'connections, respectively [default: random]',
+            metavar='Scheduler.task_ports')
+        paa('--control',
+            type=int, dest='ControllerFactory.control', nargs=2,
+            help='The (2) ports the Control scheduler will listen on for client,engine '
+            'connections, respectively [default: random]',
+            metavar='Scheduler.control_ports')
+        paa('--iopub',
+            type=int, dest='ControllerFactory.iopub', nargs=2,
+            help='The (2) ports the IOPub scheduler will listen on for client,engine '
+            'connections, respectively [default: random]',
+            metavar='Scheduler.iopub_ports')
+        paa('--scheme',
+            type=str, dest='ControllerFactory.scheme',
+            choices = ['pure', 'lru', 'plainrandom', 'weighted', 'twobin','leastload'],
+            help='select the task scheduler scheme  [default: Python LRU]',
+            metavar='Scheduler.scheme')
+        paa('--usethreads',
+            dest='ControllerFactory.usethreads', action="store_true",
+            help='Use threads instead of processes for the schedulers',
+            )
+        
+        ## Global config
+        paa('--log-to-file',
+            action='store_true', dest='Global.log_to_file',
+            help='Log to a file in the log directory (default is stdout)')
+        paa('--log-url',
+            type=str, dest='Global.log_url',
+            help='Broadcast logs to an iploggerz process [default: disabled]')
+        paa('-r','--reuse-key', 
+            action='store_true', dest='Global.reuse_key',
+            help='Try to reuse existing execution keys.')
+        paa('--no-secure',
+            action='store_false', dest='Global.secure',
+            help='Turn off execution keys.')
+        paa('--secure',
+            action='store_true', dest='Global.secure',
+            help='Turn on execution keys (default).')
+        paa('--execkey',
+            type=str, dest='Global.exec_key',
+            help='path to a file containing an execution key.',
+            metavar='keyfile')
+        factory.add_session_arguments(self.parser)
+        factory.add_registration_arguments(self.parser)
+
+
+#-----------------------------------------------------------------------------
+# The main application
+#-----------------------------------------------------------------------------
+
+
+class IPControllerApp(ApplicationWithClusterDir):
+
+    name = u'ipcontrollerz'
+    description = _description
+    command_line_loader = IPControllerAppConfigLoader
+    default_config_file_name = default_config_file_name
+    auto_create_cluster_dir = True
+
+    def create_default_config(self):
+        super(IPControllerApp, self).create_default_config()
+        # Don't set defaults for Global.secure or Global.reuse_furls
+        # as those are set in a component.
+        self.default_config.Global.import_statements = []
+        self.default_config.Global.clean_logs = True
+        self.default_config.Global.secure = False
+        self.default_config.Global.reuse_key = False
+        self.default_config.Global.exec_key = "exec_key.key"
+
+    def pre_construct(self):
+        super(IPControllerApp, self).pre_construct()
+        c = self.master_config
+        # The defaults for these are set in FCClientServiceFactory and
+        # FCEngineServiceFactory, so we only set them here if the global
+        # options have be set to override the class level defaults.
+        
+        # if hasattr(c.Global, 'reuse_furls'):
+        #     c.FCClientServiceFactory.reuse_furls = c.Global.reuse_furls
+        #     c.FCEngineServiceFactory.reuse_furls = c.Global.reuse_furls
+        #     del c.Global.reuse_furls
+        # if hasattr(c.Global, 'secure'):
+        #     c.FCClientServiceFactory.secure = c.Global.secure
+        #     c.FCEngineServiceFactory.secure = c.Global.secure
+        #     del c.Global.secure
+
+    def construct(self):
+        # This is the working dir by now.
+        sys.path.insert(0, '')
+        c = self.master_config
+        
+        self.import_statements()
+
+        if c.Global.secure:
+            keyfile = os.path.join(c.Global.security_dir, c.Global.exec_key)
+            if not c.Global.reuse_key or not os.path.exists(keyfile):
+                generate_exec_key(keyfile)
+            c.SessionFactory.exec_key = keyfile
+        else:
+            keyfile = os.path.join(c.Global.security_dir, c.Global.exec_key)
+            if os.path.exists(keyfile):
+                os.remove(keyfile)
+            c.SessionFactory.exec_key = ''
+        
+        try:
+            self.factory = ControllerFactory(config=c)
+            self.start_logging()
+            self.factory.construct()
+        except:
+            self.log.error("Couldn't construct the Controller", exc_info=True)
+            self.exit(1)
+        
+    
+    def import_statements(self):
+        statements = self.master_config.Global.import_statements
+        for s in statements:
+            try:
+                self.log.msg("Executing statement: '%s'" % s)
+                exec s in globals(), locals()
+            except:
+                self.log.msg("Error running statement: %s" % s)
+
+    # def start_logging(self):
+    #     super(IPControllerApp, self).start_logging()
+    #     if self.master_config.Global.log_url:
+    #         context = self.factory.context
+    #         lsock = context.socket(zmq.PUB)
+    #         lsock.connect(self.master_config.Global.log_url)
+    #         handler = PUBHandler(lsock)
+    #         handler.root_topic = 'controller'
+    #         handler.setLevel(self.log_level)
+    #         self.log.addHandler(handler)
+    # 
+    def start_app(self):
+        # Start the controller service.
+        self.factory.start()
+        self.write_pid_file(overwrite=True)
+        try:
+            self.factory.loop.start()
+        except KeyboardInterrupt:
+            self.log.critical("Interrupted, Exiting...\n")
+
+
+def launch_new_instance():
+    """Create and run the IPython controller"""
+    app = IPControllerApp()
+    app.start()
+
+
+if __name__ == '__main__':
+    launch_new_instance()

IPython/zmq/parallel/ipengineapp.py

@@ -0,0 +1,261 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+The IPython engine application
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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 sys
+
+import zmq
+from zmq.eventloop import ioloop
+
+from IPython.zmq.parallel.clusterdir import (
+    ApplicationWithClusterDir,
+    ClusterDirConfigLoader
+)
+from IPython.zmq.log import EnginePUBHandler
+
+from IPython.zmq.parallel import factory
+from IPython.zmq.parallel.engine import EngineFactory
+from IPython.zmq.parallel.streamkernel import Kernel
+from IPython.utils.importstring import import_item
+
+#-----------------------------------------------------------------------------
+# Module level variables
+#-----------------------------------------------------------------------------
+
+#: The default config file name for this application
+default_config_file_name = u'ipengine_config.py'
+
+
+mpi4py_init = """from mpi4py import MPI as mpi
+mpi.size = mpi.COMM_WORLD.Get_size()
+mpi.rank = mpi.COMM_WORLD.Get_rank()
+"""
+
+
+pytrilinos_init = """from PyTrilinos import Epetra
+class SimpleStruct:
+pass
+mpi = SimpleStruct()
+mpi.rank = 0
+mpi.size = 0
+"""
+
+
+_description = """Start an IPython engine for parallel computing.\n\n
+
+IPython engines run in parallel and perform computations on behalf of a client
+and controller. A controller needs to be started before the engines. The
+engine can be configured using command line options or using a cluster
+directory. Cluster directories contain config, log and security files and are
+usually located in your .ipython directory and named as "cluster_<profile>".
+See the --profile and --cluster-dir options for details.
+"""
+
+#-----------------------------------------------------------------------------
+# Command line options
+#-----------------------------------------------------------------------------
+
+
+class IPEngineAppConfigLoader(ClusterDirConfigLoader):
+
+    def _add_arguments(self):
+        super(IPEngineAppConfigLoader, self)._add_arguments()
+        paa = self.parser.add_argument
+        # Controller config
+        paa('--url-file',
+            type=unicode, dest='Global.url_file',
+            help='The full location of the file containing the FURL of the '
+            'controller. If this is not given, the FURL file must be in the '
+            'security directory of the cluster directory.  This location is '
+            'resolved using the --profile and --app-dir options.',
+            metavar='Global.url_file')
+        # MPI
+        paa('--mpi',
+            type=str, dest='MPI.use',
+            help='How to enable MPI (mpi4py, pytrilinos, or empty string to disable).',
+            metavar='MPI.use')
+        # Global config
+        paa('--log-to-file',
+            action='store_true', dest='Global.log_to_file',
+            help='Log to a file in the log directory (default is stdout)')
+        paa('--log-url',
+            dest='Global.log_url',
+            help="url of ZMQ logger, as started with iploggerz")
+        paa('--execkey',
+            type=str, dest='Global.exec_key',
+            help='path to a file containing an execution key.',
+            metavar='keyfile')
+        paa('--no-secure',
+            action='store_false', dest='Global.secure',
+            help='Turn off execution keys.')
+        paa('--secure',
+            action='store_true', dest='Global.secure',
+            help='Turn on execution keys (default).')
+        # init command
+        paa('-c',
+            type=str, dest='Global.extra_exec_lines',
+            help='specify a command to be run at startup')
+        
+        factory.add_session_arguments(self.parser)
+        factory.add_registration_arguments(self.parser)
+
+
+#-----------------------------------------------------------------------------
+# Main application
+#-----------------------------------------------------------------------------
+
+
+class IPEngineApp(ApplicationWithClusterDir):
+
+    name = u'ipenginez'
+    description = _description
+    command_line_loader = IPEngineAppConfigLoader
+    default_config_file_name = default_config_file_name
+    auto_create_cluster_dir = True
+
+    def create_default_config(self):
+        super(IPEngineApp, self).create_default_config()
+
+        # The engine should not clean logs as we don't want to remove the
+        # active log files of other running engines.
+        self.default_config.Global.clean_logs = False
+        self.default_config.Global.secure = True
+
+        # Global config attributes
+        self.default_config.Global.exec_lines = []
+        self.default_config.Global.extra_exec_lines = ''
+
+        # Configuration related to the controller
+        # This must match the filename (path not included) that the controller
+        # used for the FURL file.
+        self.default_config.Global.url = u'tcp://localhost:10101'
+        # If given, this is the actual location of the controller's FURL file.
+        # If not, this is computed using the profile, app_dir and furl_file_name
+        self.default_config.Global.key_file_name = u'exec_key.key'
+        self.default_config.Global.key_file = u''
+
+        # MPI related config attributes
+        self.default_config.MPI.use = ''
+        self.default_config.MPI.mpi4py = mpi4py_init
+        self.default_config.MPI.pytrilinos = pytrilinos_init
+
+    def post_load_command_line_config(self):
+        pass
+
+    def pre_construct(self):
+        super(IPEngineApp, self).pre_construct()
+        # self.find_cont_url_file()
+        self.find_key_file()
+        if self.master_config.Global.extra_exec_lines:
+            self.master_config.Global.exec_lines.append(self.master_config.Global.extra_exec_lines)
+
+    def find_key_file(self):
+        """Set the key file.
+
+        Here we don't try to actually see if it exists for is valid as that
+        is hadled by the connection logic.
+        """
+        config = self.master_config
+        # Find the actual controller key file
+        if not config.Global.key_file:
+            try_this = os.path.join(
+                config.Global.cluster_dir, 
+                config.Global.security_dir,
+                config.Global.key_file_name
+            )
+            config.Global.key_file = try_this
+        
+    def construct(self):
+        # This is the working dir by now.
+        sys.path.insert(0, '')
+        config = self.master_config
+        if os.path.exists(config.Global.key_file) and config.Global.secure:
+            config.SessionFactory.exec_key = config.Global.key_file
+        
+        config.Kernel.exec_lines = config.Global.exec_lines
+
+        self.start_mpi()
+
+        # Create the underlying shell class and EngineService
+        # shell_class = import_item(self.master_config.Global.shell_class)
+        try:
+            self.engine = EngineFactory(config=config)
+        except:
+            self.log.error("Couldn't start the Engine", exc_info=True)
+            self.exit(1)
+        
+        self.start_logging()
+
+        # Create the service hierarchy
+        # self.main_service = service.MultiService()
+        # self.engine_service.setServiceParent(self.main_service)
+        # self.tub_service = Tub()
+        # self.tub_service.setServiceParent(self.main_service)
+        # # This needs to be called before the connection is initiated
+        # self.main_service.startService()
+
+        # This initiates the connection to the controller and calls
+        # register_engine to tell the controller we are ready to do work
+        # self.engine_connector = EngineConnector(self.tub_service)
+
+        # self.log.info("Using furl file: %s" % self.master_config.Global.furl_file)
+
+        # reactor.callWhenRunning(self.call_connect)
+
+
+    def start_logging(self):
+        super(IPEngineApp, self).start_logging()
+        if self.master_config.Global.log_url:
+            context = self.engine.context
+            lsock = context.socket(zmq.PUB)
+            lsock.connect(self.master_config.Global.log_url)
+            handler = EnginePUBHandler(self.engine, lsock)
+            handler.setLevel(self.log_level)
+            self.log.addHandler(handler)
+    
+    def start_mpi(self):
+        global mpi
+        mpikey = self.master_config.MPI.use
+        mpi_import_statement = self.master_config.MPI.get(mpikey, None)
+        if mpi_import_statement is not None:
+            try:
+                self.log.info("Initializing MPI:")
+                self.log.info(mpi_import_statement)
+                exec mpi_import_statement in globals()
+            except:
+                mpi = None
+        else:
+            mpi = None
+
+
+    def start_app(self):
+        self.engine.start()
+        try:
+            self.engine.loop.start()
+        except KeyboardInterrupt:
+            self.log.critical("Engine Interrupted, shutting down...\n")
+
+
+def launch_new_instance():
+    """Create and run the IPython controller"""
+    app = IPEngineApp()
+    app.start()
+
+
+if __name__ == '__main__':
+    launch_new_instance()
+

IPython/zmq/parallel/iploggerapp.py

@@ -0,0 +1,131 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A simple IPython logger application
+"""
+
+#-----------------------------------------------------------------------------
+#  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 sys
+
+import zmq
+
+from IPython.zmq.parallel.clusterdir import (
+    ApplicationWithClusterDir,
+    ClusterDirConfigLoader
+)
+from IPython.zmq.parallel.logwatcher import LogWatcher
+
+#-----------------------------------------------------------------------------
+# Module level variables
+#-----------------------------------------------------------------------------
+
+#: The default config file name for this application
+default_config_file_name = u'iplogger_config.py'
+
+_description = """Start an IPython logger for parallel computing.\n\n
+
+IPython controllers and engines (and your own processes) can broadcast log messages
+by registering a `zmq.log.handlers.PUBHandler` with the `logging` module. The
+logger can be configured using command line options or using a cluster
+directory. Cluster directories contain config, log and security files and are
+usually located in your .ipython directory and named as "cluster_<profile>".
+See the --profile and --cluster-dir options for details.
+"""
+
+#-----------------------------------------------------------------------------
+# Command line options
+#-----------------------------------------------------------------------------
+
+
+class IPLoggerAppConfigLoader(ClusterDirConfigLoader):
+
+    def _add_arguments(self):
+        super(IPLoggerAppConfigLoader, self)._add_arguments()
+        paa = self.parser.add_argument
+        # Controller config
+        paa('--url',
+            type=str, dest='LogWatcher.url',
+            help='The url the LogWatcher will listen on',
+            )
+        # MPI
+        paa('--topics',
+            type=str, dest='LogWatcher.topics', nargs='+',
+            help='What topics to subscribe to',
+            metavar='topics')
+        # Global config
+        paa('--log-to-file',
+            action='store_true', dest='Global.log_to_file',
+            help='Log to a file in the log directory (default is stdout)')
+        
+
+#-----------------------------------------------------------------------------
+# Main application
+#-----------------------------------------------------------------------------
+
+
+class IPLoggerApp(ApplicationWithClusterDir):
+
+    name = u'iploggerz'
+    description = _description
+    command_line_loader = IPLoggerAppConfigLoader
+    default_config_file_name = default_config_file_name
+    auto_create_cluster_dir = True
+
+    def create_default_config(self):
+        super(IPLoggerApp, self).create_default_config()
+
+        # The engine should not clean logs as we don't want to remove the
+        # active log files of other running engines.
+        self.default_config.Global.clean_logs = False
+
+        # If given, this is the actual location of the logger's URL file.
+        # If not, this is computed using the profile, app_dir and furl_file_name
+        self.default_config.Global.url_file_name = u'iplogger.url'
+        self.default_config.Global.url_file = u''
+
+    def post_load_command_line_config(self):
+        pass
+
+    def pre_construct(self):
+        super(IPLoggerApp, self).pre_construct()
+
+    def construct(self):
+        # This is the working dir by now.
+        sys.path.insert(0, '')
+
+        self.start_logging()
+
+        try:
+            self.watcher = LogWatcher(config=self.master_config)
+        except:
+            self.log.error("Couldn't start the LogWatcher", exc_info=True)
+            self.exit(1)
+        
+
+    def start_app(self):
+        try:
+            self.watcher.loop.start()
+        except KeyboardInterrupt:
+            self.log.critical("Logging Interrupted, shutting down...\n")
+
+
+def launch_new_instance():
+    """Create and run the IPython LogWatcher"""
+    app = IPLoggerApp()
+    app.start()
+
+
+if __name__ == '__main__':
+    launch_new_instance()
+

IPython/zmq/parallel/logwatcher.py

@@ -0,0 +1,92 b''
+#!/usr/bin/env python
+"""A simple logger object that consolidates messages incoming from ipclusterz processes."""
+
+#-----------------------------------------------------------------------------
+#  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 sys
+import logging
+
+import zmq
+from zmq.eventloop import ioloop, zmqstream
+from IPython.config.configurable import Configurable
+from IPython.utils.traitlets import Int, Str, Instance, List
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+
+class LogWatcher(Configurable):
+    """A simple class that receives messages on a SUB socket, as published
+    by subclasses of `zmq.log.handlers.PUBHandler`, and logs them itself.
+    
+    This can subscribe to multiple topics, but defaults to all topics.
+    """
+    # configurables
+    topics = List([''], config=True)
+    url = Str('tcp://127.0.0.1:20202', config=True)
+    
+    # internals
+    context = Instance(zmq.Context, (), {})
+    stream = Instance('zmq.eventloop.zmqstream.ZMQStream')
+    loop = Instance('zmq.eventloop.ioloop.IOLoop')
+    def _loop_default(self):
+        return ioloop.IOLoop.instance()
+    
+    def __init__(self, config=None):
+        super(LogWatcher, self).__init__(config=config)
+        s = self.context.socket(zmq.SUB)
+        s.bind(self.url)
+        self.stream = zmqstream.ZMQStream(s, self.loop)
+        self.subscribe()
+        self.on_trait_change(self.subscribe, 'topics')
+        
+        self.stream.on_recv(self.log_message)
+    
+    def subscribe(self):
+        """Update our SUB socket's subscriptions."""
+        self.stream.setsockopt(zmq.UNSUBSCRIBE, '')
+        for topic in self.topics:
+            logging.debug("Subscribing to: %r"%topic)
+            self.stream.setsockopt(zmq.SUBSCRIBE, topic)
+    
+    def _extract_level(self, topic_str):
+        """Turn 'engine.0.INFO.extra' into (logging.INFO, 'engine.0.extra')"""
+        topics = topic_str.split('.')
+        for idx,t in enumerate(topics):
+            level = getattr(logging, t, None)
+            if level is not None:
+                break
+        
+        if level is None:
+            level = logging.INFO
+        else:
+            topics.pop(idx)
+        
+        return level, '.'.join(topics)
+            
+            
+    def log_message(self, raw):
+        """receive and parse a message, then log it."""
+        if len(raw) != 2 or '.' not in raw[0]:
+            logging.error("Invalid log message: %s"%raw)
+            return
+        else:
+            topic, msg = raw
+            # don't newline, since log messages always newline:
+            topic,level_name = topic.rsplit('.',1)
+            level,topic = self._extract_level(topic)
+            if msg[-1] == '\n':
+                msg = msg[:-1]
+            logging.log(level, "[%s] %s" % (topic, msg))
+

IPython/utils/traitlets.py

@@ -1,1075 +1,1095 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A lightweight Traits like module.
 
 This is designed to provide a lightweight, simple, pure Python version of
 many of the capabilities of enthought.traits.  This includes:
 
 * Validation
 * Type specification with defaults
 * Static and dynamic notification
 * Basic predefined types
 * An API that is similar to enthought.traits
 
 We don't support:
 
 * Delegation
 * Automatic GUI generation
 * A full set of trait types.  Most importantly, we don't provide container
   traits (list, dict, tuple) that can trigger notifications if their
   contents change.
 * API compatibility with enthought.traits
 
 There are also some important difference in our design:
 
 * enthought.traits does not validate default values.  We do.
 
 We choose to create this module because we need these capabilities, but
 we need them to be pure Python so they work in all Python implementations,
 including Jython and IronPython.
 
 Authors:
 
 * Brian Granger
 * Enthought, Inc.  Some of the code in this file comes from enthought.traits
   and is licensed under the BSD license.  Also, many of the ideas also come
   from enthought.traits even though our implementation is very different.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 inspect
 import sys
 import types
 from types import (
     InstanceType, ClassType, FunctionType,
     ListType, TupleType
 )
 from .importstring import import_item
 
 ClassTypes = (ClassType, type)
 
-SequenceTypes = (ListType, TupleType)
+SequenceTypes = (ListType, TupleType, set, frozenset)
 
 #-----------------------------------------------------------------------------
 # Basic classes
 #-----------------------------------------------------------------------------
 
 
 class NoDefaultSpecified ( object ): pass
 NoDefaultSpecified = NoDefaultSpecified()
 
 
 class Undefined ( object ): pass
 Undefined = Undefined()
 
 class TraitError(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 
 def class_of ( object ):
     """ Returns a string containing the class name of an object with the
     correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
     'a PlotValue').
     """
     if isinstance( object, basestring ):
         return add_article( object )
 
     return add_article( object.__class__.__name__ )
 
 
 def add_article ( name ):
     """ Returns a string containing the correct indefinite article ('a' or 'an')
     prefixed to the specified string.
     """
     if name[:1].lower() in 'aeiou':
        return 'an ' + name
 
     return 'a ' + name
 
 
 def repr_type(obj):
     """ Return a string representation of a value and its type for readable
     error messages.
     """
     the_type = type(obj)
     if the_type is InstanceType:
         # Old-style class.
         the_type = obj.__class__
     msg = '%r %r' % (obj, the_type)
     return msg
 
 
 def parse_notifier_name(name):
     """Convert the name argument to a list of names.
     
     Examples
     --------
     
     >>> parse_notifier_name('a')
     ['a']
     >>> parse_notifier_name(['a','b'])
     ['a', 'b']
     >>> parse_notifier_name(None)
     ['anytrait']
     """
     if isinstance(name, str):
         return [name]
     elif name is None:
         return ['anytrait']
     elif isinstance(name, (list, tuple)):
         for n in name:
             assert isinstance(n, str), "names must be strings"
         return name
 
 
 class _SimpleTest:
     def __init__ ( self, value ): self.value = value
     def __call__ ( self, test  ):
         return test == self.value
     def __repr__(self):
         return "<SimpleTest(%r)" % self.value
     def __str__(self):
         return self.__repr__()
 
 
 def getmembers(object, predicate=None):
     """A safe version of inspect.getmembers that handles missing attributes.
 
     This is useful when there are descriptor based attributes that for 
     some reason raise AttributeError even though they exist.  This happens
     in zope.inteface with the __provides__ attribute.
     """
     results = []
     for key in dir(object):
         try:
             value = getattr(object, key)
         except AttributeError:
             pass
         else:
             if not predicate or predicate(value):
                 results.append((key, value))
     results.sort()
     return results
 
 
 #-----------------------------------------------------------------------------
 # Base TraitType for all traits
 #-----------------------------------------------------------------------------
 
 
 class TraitType(object):
     """A base class for all trait descriptors.
 
     Notes
     -----
     Our implementation of traits is based on Python's descriptor
     prototol.  This class is the base class for all such descriptors.  The
     only magic we use is a custom metaclass for the main :class:`HasTraits`
     class that does the following:
 
     1. Sets the :attr:`name` attribute of every :class:`TraitType`
        instance in the class dict to the name of the attribute.
     2. Sets the :attr:`this_class` attribute of every :class:`TraitType`
        instance in the class dict to the *class* that declared the trait.
        This is used by the :class:`This` trait to allow subclasses to
        accept superclasses for :class:`This` values.
     """
     
 
     metadata = {}
     default_value = Undefined
     info_text = 'any value'
 
     def __init__(self, default_value=NoDefaultSpecified, **metadata):
         """Create a TraitType.
         """
         if default_value is not NoDefaultSpecified:
             self.default_value = default_value
 
         if len(metadata) > 0:
             if len(self.metadata) > 0:
                 self._metadata = self.metadata.copy()
                 self._metadata.update(metadata)
             else:
                 self._metadata = metadata
         else:
             self._metadata = self.metadata
 
         self.init()
 
     def init(self):
         pass
 
     def get_default_value(self):
         """Create a new instance of the default value."""
         return self.default_value
 
     def instance_init(self, obj):
         """This is called by :meth:`HasTraits.__new__` to finish init'ing.
 
         Some stages of initialization must be delayed until the parent
         :class:`HasTraits` instance has been created.  This method is
         called in :meth:`HasTraits.__new__` after the instance has been
         created.
 
         This method trigger the creation and validation of default values
         and also things like the resolution of str given class names in 
         :class:`Type` and :class`Instance`.
 
         Parameters
         ----------
         obj : :class:`HasTraits` instance
             The parent :class:`HasTraits` instance that has just been
             created.
         """
         self.set_default_value(obj)
 
     def set_default_value(self, obj):
         """Set the default value on a per instance basis.
 
         This method is called by :meth:`instance_init` to create and
         validate the default value.  The creation and validation of 
         default values must be delayed until the parent :class:`HasTraits`
         class has been instantiated.
         """
         # Check for a deferred initializer defined in the same class as the
         # trait declaration or above.
         mro = type(obj).mro()
         meth_name = '_%s_default' % self.name
         for cls in mro[:mro.index(self.this_class)+1]:
             if meth_name in cls.__dict__:
                 break
         else:
             # We didn't find one. Do static initialization.
             dv = self.get_default_value()
             newdv = self._validate(obj, dv)
             obj._trait_values[self.name] = newdv
             return
         # Complete the dynamic initialization.
         obj._trait_dyn_inits[self.name] = cls.__dict__[meth_name]
 
     def __get__(self, obj, cls=None):
         """Get the value of the trait by self.name for the instance.
 
         Default values are instantiated when :meth:`HasTraits.__new__`
         is called.  Thus by the time this method gets called either the 
         default value or a user defined value (they called :meth:`__set__`)
         is in the :class:`HasTraits` instance.
         """
         if obj is None:
             return self
         else:
             try:
                 value = obj._trait_values[self.name]
             except KeyError:
                 # Check for a dynamic initializer.
                 if self.name in obj._trait_dyn_inits:
                     value = obj._trait_dyn_inits[self.name](obj)
                     # FIXME: Do we really validate here?
                     value = self._validate(obj, value)
                     obj._trait_values[self.name] = value
                     return value
                 else:
                     raise TraitError('Unexpected error in TraitType: '
                         'both default value and dynamic initializer are '
                         'absent.')
             except Exception:
                 # HasTraits should call set_default_value to populate
                 # this.  So this should never be reached.
                 raise TraitError('Unexpected error in TraitType: '
                                     'default value not set properly')
             else:
                 return value
 
     def __set__(self, obj, value):
         new_value = self._validate(obj, value)
         old_value = self.__get__(obj)
         if old_value != new_value:
             obj._trait_values[self.name] = new_value
             obj._notify_trait(self.name, old_value, new_value)
 
     def _validate(self, obj, value):
         if hasattr(self, 'validate'):
             return self.validate(obj, value)
         elif hasattr(self, 'is_valid_for'):
             valid = self.is_valid_for(value)
             if valid:
                 return value
             else:
                 raise TraitError('invalid value for type: %r' % value)
         elif hasattr(self, 'value_for'):
             return self.value_for(value)
         else:
             return value
 
     def info(self):
         return self.info_text
 
     def error(self, obj, value):
         if obj is not None:
             e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
                 % (self.name, class_of(obj),
                    self.info(), repr_type(value))
         else:
             e = "The '%s' trait must be %s, but a value of %r was specified." \
                 % (self.name, self.info(), repr_type(value))            
         raise TraitError(e)
 
     def get_metadata(self, key):
         return getattr(self, '_metadata', {}).get(key, None)
 
     def set_metadata(self, key, value):
         getattr(self, '_metadata', {})[key] = value
 
 
 #-----------------------------------------------------------------------------
 # The HasTraits implementation
 #-----------------------------------------------------------------------------
 
 
 class MetaHasTraits(type):
     """A metaclass for HasTraits.
     
     This metaclass makes sure that any TraitType class attributes are
     instantiated and sets their name attribute.
     """
     
     def __new__(mcls, name, bases, classdict):
         """Create the HasTraits class.
         
         This instantiates all TraitTypes in the class dict and sets their
         :attr:`name` attribute.
         """
         # print "MetaHasTraitlets (mcls, name): ", mcls, name
         # print "MetaHasTraitlets (bases): ", bases
         # print "MetaHasTraitlets (classdict): ", classdict
         for k,v in classdict.iteritems():
             if isinstance(v, TraitType):
                 v.name = k
             elif inspect.isclass(v):
                 if issubclass(v, TraitType):
                     vinst = v()
                     vinst.name = k
                     classdict[k] = vinst
         return super(MetaHasTraits, mcls).__new__(mcls, name, bases, classdict)
 
     def __init__(cls, name, bases, classdict):
         """Finish initializing the HasTraits class.
         
         This sets the :attr:`this_class` attribute of each TraitType in the
         class dict to the newly created class ``cls``.
         """
         for k, v in classdict.iteritems():
             if isinstance(v, TraitType):
                 v.this_class = cls
         super(MetaHasTraits, cls).__init__(name, bases, classdict)
 
 class HasTraits(object):
 
     __metaclass__ = MetaHasTraits
 
     def __new__(cls, **kw):
         # This is needed because in Python 2.6 object.__new__ only accepts
         # the cls argument.
         new_meth = super(HasTraits, cls).__new__
         if new_meth is object.__new__:
             inst = new_meth(cls)
         else:
             inst = new_meth(cls, **kw)
         inst._trait_values = {}
         inst._trait_notifiers = {}
         inst._trait_dyn_inits = {}
         # Here we tell all the TraitType instances to set their default
         # values on the instance. 
         for key in dir(cls):
             # Some descriptors raise AttributeError like zope.interface's
             # __provides__ attributes even though they exist.  This causes
             # AttributeErrors even though they are listed in dir(cls).
             try:
                 value = getattr(cls, key)
             except AttributeError:
                 pass
             else:
                 if isinstance(value, TraitType):
                     value.instance_init(inst)
 
         return inst
 
     def __init__(self, **kw):
         # Allow trait values to be set using keyword arguments.
         # We need to use setattr for this to trigger validation and
         # notifications.
         for key, value in kw.iteritems():
             setattr(self, key, value)
 
     def _notify_trait(self, name, old_value, new_value):
 
         # First dynamic ones
         callables = self._trait_notifiers.get(name,[])
         more_callables = self._trait_notifiers.get('anytrait',[])
         callables.extend(more_callables)
 
         # Now static ones
         try:
             cb = getattr(self, '_%s_changed' % name)
         except:
             pass
         else:
             callables.append(cb)
 
         # Call them all now
         for c in callables:
             # Traits catches and logs errors here.  I allow them to raise
             if callable(c):
                 argspec = inspect.getargspec(c)
                 nargs = len(argspec[0])
                 # Bound methods have an additional 'self' argument
                 # I don't know how to treat unbound methods, but they
                 # can't really be used for callbacks.
                 if isinstance(c, types.MethodType):
                     offset = -1
                 else:
                     offset = 0
                 if nargs + offset == 0:
                     c()
                 elif nargs + offset == 1:
                     c(name)
                 elif nargs + offset == 2:
                     c(name, new_value)
                 elif nargs + offset == 3:
                     c(name, old_value, new_value)
                 else:
                     raise TraitError('a trait changed callback '
                                         'must have 0-3 arguments.')
             else:
                 raise TraitError('a trait changed callback '
                                     'must be callable.')
                 
 
     def _add_notifiers(self, handler, name):
         if not self._trait_notifiers.has_key(name):
             nlist = []
             self._trait_notifiers[name] = nlist
         else:
             nlist = self._trait_notifiers[name]
         if handler not in nlist:
             nlist.append(handler)
 
     def _remove_notifiers(self, handler, name):
         if self._trait_notifiers.has_key(name):
             nlist = self._trait_notifiers[name]
             try:
                 index = nlist.index(handler)
             except ValueError:
                 pass
             else:
                 del nlist[index]
 
     def on_trait_change(self, handler, name=None, remove=False):
         """Setup a handler to be called when a trait changes.
 
         This is used to setup dynamic notifications of trait changes.
         
         Static handlers can be created by creating methods on a HasTraits
         subclass with the naming convention '_[traitname]_changed'.  Thus,
         to create static handler for the trait 'a', create the method
         _a_changed(self, name, old, new) (fewer arguments can be used, see
         below).
         
         Parameters
         ----------
         handler : callable
             A callable that is called when a trait changes.  Its 
             signature can be handler(), handler(name), handler(name, new)
             or handler(name, old, new).
         name : list, str, None
             If None, the handler will apply to all traits.  If a list
             of str, handler will apply to all names in the list.  If a
             str, the handler will apply just to that name.
         remove : bool
             If False (the default), then install the handler.  If True
             then unintall it.
         """
         if remove:
             names = parse_notifier_name(name)
             for n in names:
                 self._remove_notifiers(handler, n)
         else:
             names = parse_notifier_name(name)
             for n in names:
                 self._add_notifiers(handler, n)
 
     def trait_names(self, **metadata):
         """Get a list of all the names of this classes traits."""
         return self.traits(**metadata).keys()
 
     def traits(self, **metadata):
         """Get a list of all the traits of this class.
 
         The TraitTypes returned don't know anything about the values
         that the various HasTrait's instances are holding.
 
         This follows the same algorithm as traits does and does not allow
         for any simple way of specifying merely that a metadata name
         exists, but has any value.  This is because get_metadata returns
         None if a metadata key doesn't exist.
         """
         traits = dict([memb for memb in getmembers(self.__class__) if \
                      isinstance(memb[1], TraitType)])
 
         if len(metadata) == 0:
             return traits
 
         for meta_name, meta_eval in metadata.items():
             if type(meta_eval) is not FunctionType:
                 metadata[meta_name] = _SimpleTest(meta_eval)
 
         result = {}
         for name, trait in traits.items():
             for meta_name, meta_eval in metadata.items():
                 if not meta_eval(trait.get_metadata(meta_name)):
                     break
             else:
                 result[name] = trait
 
         return result
 
     def trait_metadata(self, traitname, key):
         """Get metadata values for trait by key."""
         try:
             trait = getattr(self.__class__, traitname)
         except AttributeError:
             raise TraitError("Class %s does not have a trait named %s" %
                                 (self.__class__.__name__, traitname))
         else:
             return trait.get_metadata(key)
 
 #-----------------------------------------------------------------------------
 # Actual TraitTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # TraitTypes subclasses for handling classes and instances of classes
 #-----------------------------------------------------------------------------
 
 
 class ClassBasedTraitType(TraitType):
     """A trait with error reporting for Type, Instance and This."""
 
     def error(self, obj, value):
         kind = type(value)
         if kind is InstanceType:
             msg = 'class %s' % value.__class__.__name__
         else:
             msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
 
         super(ClassBasedTraitType, self).error(obj, msg)
 
 
 class Type(ClassBasedTraitType):
     """A trait whose value must be a subclass of a specified class."""
 
     def __init__ (self, default_value=None, klass=None, allow_none=True, **metadata ):
         """Construct a Type trait
 
         A Type trait specifies that its values must be subclasses of
         a particular class.
 
         If only ``default_value`` is given, it is used for the ``klass`` as
         well.
 
         Parameters
         ----------
         default_value : class, str or None
             The default value must be a subclass of klass.  If an str,
             the str must be a fully specified class name, like 'foo.bar.Bah'.
             The string is resolved into real class, when the parent 
             :class:`HasTraits` class is instantiated.
         klass : class, str, None
             Values of this trait must be a subclass of klass.  The klass
             may be specified in a string like: 'foo.bar.MyClass'.
             The string is resolved into real class, when the parent 
             :class:`HasTraits` class is instantiated.
         allow_none : boolean
             Indicates whether None is allowed as an assignable value. Even if
             ``False``, the default value may be ``None``.
         """
         if default_value is None:
             if klass is None:
                 klass = object
         elif klass is None:
             klass = default_value
 
         if not (inspect.isclass(klass) or isinstance(klass, basestring)):
             raise TraitError("A Type trait must specify a class.")
 
         self.klass       = klass
         self._allow_none = allow_none
 
         super(Type, self).__init__(default_value, **metadata)
 
     def validate(self, obj, value):
         """Validates that the value is a valid object instance."""
         try:
             if issubclass(value, self.klass):
                 return value
         except:
             if (value is None) and (self._allow_none):
                 return value
 
         self.error(obj, value)
 
     def info(self):
         """ Returns a description of the trait."""
         if isinstance(self.klass, basestring):
             klass = self.klass
         else:
             klass = self.klass.__name__
         result = 'a subclass of ' + klass
         if self._allow_none:
             return result + ' or None'
         return result
 
     def instance_init(self, obj):
         self._resolve_classes()
         super(Type, self).instance_init(obj)
 
     def _resolve_classes(self):
         if isinstance(self.klass, basestring):
             self.klass = import_item(self.klass)
         if isinstance(self.default_value, basestring):
             self.default_value = import_item(self.default_value)
 
     def get_default_value(self):
         return self.default_value
 
 
 class DefaultValueGenerator(object):
     """A class for generating new default value instances."""
 
     def __init__(self, *args, **kw):
         self.args = args
         self.kw = kw
 
     def generate(self, klass):
         return klass(*self.args, **self.kw)
 
 
 class Instance(ClassBasedTraitType):
     """A trait whose value must be an instance of a specified class.
     
     The value can also be an instance of a subclass of the specified class.
     """
 
     def __init__(self, klass=None, args=None, kw=None, 
                  allow_none=True, **metadata ):
         """Construct an Instance trait.
 
         This trait allows values that are instances of a particular
         class or its sublclasses.  Our implementation is quite different
         from that of enthough.traits as we don't allow instances to be used
         for klass and we handle the ``args`` and ``kw`` arguments differently.
 
         Parameters
         ----------
         klass : class, str
             The class that forms the basis for the trait.  Class names
             can also be specified as strings, like 'foo.bar.Bar'.
         args : tuple
             Positional arguments for generating the default value.
         kw : dict
             Keyword arguments for generating the default value.
         allow_none : bool
             Indicates whether None is allowed as a value.
 
         Default Value
         -------------
         If both ``args`` and ``kw`` are None, then the default value is None.
         If ``args`` is a tuple and ``kw`` is a dict, then the default is
         created as ``klass(*args, **kw)``.  If either ``args`` or ``kw`` is 
         not (but not both), None is replace by ``()`` or ``{}``.
         """
 
         self._allow_none = allow_none
 
         if (klass is None) or (not (inspect.isclass(klass) or isinstance(klass, basestring))):
             raise TraitError('The klass argument must be a class'
                                 ' you gave: %r' % klass)
         self.klass = klass
         
         # self.klass is a class, so handle default_value
         if args is None and kw is None:
             default_value = None
         else:
             if args is None:
                 # kw is not None
                 args = ()
             elif kw is None:
                 # args is not None
                 kw = {}
         
             if not isinstance(kw, dict):
                 raise TraitError("The 'kw' argument must be a dict or None.")
             if not isinstance(args, tuple):
                 raise TraitError("The 'args' argument must be a tuple or None.")
             
             default_value = DefaultValueGenerator(*args, **kw)
 
         super(Instance, self).__init__(default_value, **metadata)
 
     def validate(self, obj, value):
         if value is None:
             if self._allow_none:
                 return value
             self.error(obj, value)
 
         if isinstance(value, self.klass):
             return value
         else:
             self.error(obj, value)
 
     def info(self):
         if isinstance(self.klass, basestring):
             klass = self.klass
         else:
             klass = self.klass.__name__
         result = class_of(klass)
         if self._allow_none:
             return result + ' or None'
 
         return result
 
     def instance_init(self, obj):
         self._resolve_classes()
         super(Instance, self).instance_init(obj)
 
     def _resolve_classes(self):
         if isinstance(self.klass, basestring):
             self.klass = import_item(self.klass)
 
     def get_default_value(self):
         """Instantiate a default value instance.
         
         This is called when the containing HasTraits classes'
         :meth:`__new__` method is called to ensure that a unique instance
         is created for each HasTraits instance.
         """
         dv  = self.default_value
         if isinstance(dv, DefaultValueGenerator):
             return dv.generate(self.klass)
         else:
             return dv
 
 
 class This(ClassBasedTraitType):
     """A trait for instances of the class containing this trait.
 
     Because how how and when class bodies are executed, the ``This``
     trait can only have a default value of None.  This, and because we 
     always validate default values, ``allow_none`` is *always* true.
     """
 
     info_text = 'an instance of the same type as the receiver or None'
 
     def __init__(self, **metadata):
         super(This, self).__init__(None, **metadata)
 
     def validate(self, obj, value):
         # What if value is a superclass of obj.__class__?  This is
         # complicated if it was the superclass that defined the This
         # trait.
         if isinstance(value, self.this_class) or (value is None):
             return value
         else:
             self.error(obj, value)
 
 
 #-----------------------------------------------------------------------------
 # Basic TraitTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 
 class Any(TraitType):
     default_value = None
     info_text = 'any value'
 
 
 class Int(TraitType):
     """A integer trait."""
 
     default_value = 0
     info_text = 'an integer'
 
     def validate(self, obj, value):
         if isinstance(value, int):
             return value
         self.error(obj, value)
 
 class CInt(Int):
     """A casting version of the int trait."""
 
     def validate(self, obj, value):
         try:
             return int(value)
         except:
             self.error(obj, value)
 
 
 class Long(TraitType):
     """A long integer trait."""
 
     default_value = 0L
     info_text = 'a long'
 
     def validate(self, obj, value):
         if isinstance(value, long):
             return value
         if isinstance(value, int):
             return long(value)
         self.error(obj, value)
 
 
 class CLong(Long):
     """A casting version of the long integer trait."""
 
     def validate(self, obj, value):
         try:
             return long(value)
         except:
             self.error(obj, value)
 
 
 class Float(TraitType):
     """A float trait."""
 
     default_value = 0.0
     info_text = 'a float'
 
     def validate(self, obj, value):
         if isinstance(value, float):
             return value
         if isinstance(value, int):
             return float(value)
         self.error(obj, value)
 
 
 class CFloat(Float):
     """A casting version of the float trait."""
 
     def validate(self, obj, value):
         try:
             return float(value)
         except:
             self.error(obj, value)
 
 class Complex(TraitType):
     """A trait for complex numbers."""
 
     default_value = 0.0 + 0.0j
     info_text = 'a complex number'
 
     def validate(self, obj, value):
         if isinstance(value, complex):
             return value
         if isinstance(value, (float, int)):
             return complex(value)
         self.error(obj, value)
 
 
 class CComplex(Complex):
     """A casting version of the complex number trait."""
 
     def validate (self, obj, value):
         try:
             return complex(value)
         except:
             self.error(obj, value)
 
 
 class Str(TraitType):
     """A trait for strings."""
 
     default_value = ''
     info_text = 'a string'
 
     def validate(self, obj, value):
         if isinstance(value, str):
             return value
         self.error(obj, value)
 
 
 class CStr(Str):
     """A casting version of the string trait."""
 
     def validate(self, obj, value):
         try:
             return str(value)
         except:
             try:
                 return unicode(value)
             except:
                 self.error(obj, value)
 
 
 class Unicode(TraitType):
     """A trait for unicode strings."""
 
     default_value = u''
     info_text = 'a unicode string'
 
     def validate(self, obj, value):
         if isinstance(value, unicode):
             return value
         if isinstance(value, str):
             return unicode(value)
         self.error(obj, value)
 
 
 class CUnicode(Unicode):
     """A casting version of the unicode trait."""
 
     def validate(self, obj, value):
         try:
             return unicode(value)
         except:
             self.error(obj, value)
 
 
 class Bool(TraitType):
     """A boolean (True, False) trait."""
 
     default_value = False
     info_text = 'a boolean'
 
     def validate(self, obj, value):
         if isinstance(value, bool):
             return value
         self.error(obj, value)
 
 
 class CBool(Bool):
     """A casting version of the boolean trait."""
 
     def validate(self, obj, value):
         try:
             return bool(value)
         except:
             self.error(obj, value)
 
 
 class Enum(TraitType):
     """An enum that whose value must be in a given sequence."""
 
     def __init__(self, values, default_value=None, allow_none=True, **metadata):
         self.values = values
         self._allow_none = allow_none
         super(Enum, self).__init__(default_value, **metadata)
 
     def validate(self, obj, value):
         if value is None:
             if self._allow_none:
                 return value
 
         if value in self.values:
                 return value
         self.error(obj, value)
 
     def info(self):
         """ Returns a description of the trait."""
         result = 'any of ' + repr(self.values)
         if self._allow_none:
             return result + ' or None'
         return result
 
 class CaselessStrEnum(Enum):
     """An enum of strings that are caseless in validate."""
 
     def validate(self, obj, value):
         if value is None:
             if self._allow_none:
                 return value
 
         if not isinstance(value, str):
             self.error(obj, value)
 
         for v in self.values:
             if v.lower() == value.lower():
                 return v
         self.error(obj, value)
 
 
 class List(Instance):
     """An instance of a Python list."""
 
     def __init__(self, default_value=None, allow_none=True, **metadata):
-        """Create a list trait type from a list or tuple.
+        """Create a list trait type from a list, set, or tuple.
 
         The default value is created by doing ``list(default_value)``, 
         which creates a copy of the ``default_value``.
         """
         if default_value is None:
             args = ((),)
         elif isinstance(default_value, SequenceTypes):
             args = (default_value,)
         else:
             raise TypeError('default value of List was %s' % default_value)
 
         super(List,self).__init__(klass=list, args=args, 
                                   allow_none=allow_none, **metadata)
 
 
+class Set(Instance):
+    """An instance of a Python set."""
+
+    def __init__(self, default_value=None, allow_none=True, **metadata):
+        """Create a set trait type from a set, list, or tuple.
+
+        The default value is created by doing ``set(default_value)``, 
+        which creates a copy of the ``default_value``.
+        """
+        if default_value is None:
+            args = ((),)
+        elif isinstance(default_value, SequenceTypes):
+            args = (default_value,)
+        else:
+            raise TypeError('default value of Set was %s' % default_value)
+
+        super(Set,self).__init__(klass=set, args=args, 
+                                  allow_none=allow_none, **metadata)
+
+
 class Dict(Instance):
     """An instance of a Python dict."""
 
     def __init__(self, default_value=None, allow_none=True, **metadata):
         """Create a dict trait type from a dict.
 
         The default value is created by doing ``dict(default_value)``, 
         which creates a copy of the ``default_value``.
         """
         if default_value is None:
             args = ((),)
         elif isinstance(default_value, dict):
             args = (default_value,)
         elif isinstance(default_value, SequenceTypes):
             args = (default_value,)
         else:
             raise TypeError('default value of Dict was %s' % default_value)
 
         super(Dict,self).__init__(klass=dict, args=args, 
                                   allow_none=allow_none, **metadata)
 
 
 class TCPAddress(TraitType):
     """A trait for an (ip, port) tuple.
 
     This allows for both IPv4 IP addresses as well as hostnames.
     """
 
     default_value = ('127.0.0.1', 0)
     info_text = 'an (ip, port) tuple'
 
     def validate(self, obj, value):
         if isinstance(value, tuple):
             if len(value) == 2:
                 if isinstance(value[0], basestring) and isinstance(value[1], int):
                     port = value[1]
                     if port >= 0 and port <= 65535:
                         return value
         self.error(obj, value)

IPython/zmq/parallel/controller.py

@@ -1,265 +1,345 b''
 #!/usr/bin/env python
 """The IPython Controller with 0MQ
 This is the master object that handles connections from engines and clients,
 and monitors traffic through the various queues.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import os
+import sys
 import time
 import logging
 from multiprocessing import Process
 
 import zmq
 from zmq.eventloop import  ioloop
 from zmq.eventloop.zmqstream import ZMQStream
-from zmq.devices import ProcessMonitoredQueue
+# from zmq.devices import ProcessMonitoredQueue
 
 # internal:
+from IPython.utils.importstring import import_item
+from IPython.utils.traitlets import Int, Str, Instance, List, Bool
 from IPython.zmq.entry_point import bind_port
 
-from hub import Hub
 from entry_point import (make_base_argument_parser, select_random_ports, split_ports,
                         connect_logger, parse_url, signal_children, generate_exec_key,
                         local_logger)
 
 
 import streamsession as session
 import heartmonitor
 from scheduler import launch_scheduler
+from hub import Hub, HubFactory
 
 from dictdb import DictDB
 try:
     import pymongo
 except ImportError:
     MongoDB=None
 else:
     from mongodb import MongoDB
     
 #-------------------------------------------------------------------------
 # Entry Point
 #-------------------------------------------------------------------------
 
 def make_argument_parser():
     """Make an argument parser"""
     parser = make_base_argument_parser()
     
     parser.add_argument('--client', type=int, metavar='PORT', default=0,
                         help='set the XREP port for clients [default: random]')
     parser.add_argument('--notice', type=int, metavar='PORT', default=0,
                         help='set the PUB socket for registration notification [default: random]')
     parser.add_argument('--hb', type=str, metavar='PORTS',
                         help='set the 2 ports for heartbeats [default: random]')
     parser.add_argument('--ping', type=int, default=100,
                         help='set the heartbeat period in ms [default: 100]')
     parser.add_argument('--monitor', type=int, metavar='PORT', default=0,
                         help='set the SUB port for queue monitoring [default: random]')
     parser.add_argument('--mux', type=str, metavar='PORTS',
                         help='set the XREP ports for the MUX queue [default: random]')
     parser.add_argument('--task', type=str, metavar='PORTS',
                         help='set the XREP/XREQ ports for the task queue [default: random]')
     parser.add_argument('--control', type=str, metavar='PORTS',
                         help='set the XREP ports for the control queue [default: random]')
     parser.add_argument('--iopub', type=str, metavar='PORTS',
                         help='set the PUB/SUB ports for the iopub relay [default: random]')
     parser.add_argument('--scheduler', type=str, default='lru',
                         choices = ['pure', 'lru', 'plainrandom', 'weighted', 'twobin','leastload'],
                         help='select the task scheduler  [default: Python LRU]')
     parser.add_argument('--mongodb', action='store_true',
                         help='Use MongoDB task storage [default: in-memory]')
     parser.add_argument('--session', type=str, default=None,
                         help='Manually specify the session id.')
     
     return parser
+
+class ControllerFactory(HubFactory):
+    """Configurable for setting up a Hub and Schedulers."""
+    
+    scheme = Str('pure', config=True)
+    usethreads = Bool(False, config=True)
+    
+    # internal
+    children = List()
+    mq_class = Str('zmq.devices.ProcessMonitoredQueue')
+    
+    def _update_mq(self):
+        self.mq_class = 'zmq.devices.%sMonitoredQueue'%('Thread' if self.usethreads else 'Process')
+        
+    def __init__(self, **kwargs):
+        super(ControllerFactory, self).__init__(**kwargs)
+        self.subconstructors.append(self.construct_schedulers)
+        self._update_mq()
+        self.on_trait_change(self._update_mq, 'usethreads')
+    
+    def start(self):
+        super(ControllerFactory, self).start()
+        for child in self.children:
+            child.start()
+        if not self.usethreads:
+            signal_children([ getattr(c, 'launcher', c) for c in self.children ])
+        
+    
+    def construct_schedulers(self):
+        children = self.children
+        mq = import_item(self.mq_class)
+        
+        # IOPub relay (in a Process)
+        q = mq(zmq.PUB, zmq.SUB, zmq.PUB, 'N/A','iopub')
+        q.bind_in(self.client_addrs['iopub'])
+        q.bind_out(self.engine_addrs['iopub'])
+        q.setsockopt_out(zmq.SUBSCRIBE, '')
+        q.connect_mon(self.monitor_url)
+        q.daemon=True
+        children.append(q)
+
+        # Multiplexer Queue (in a Process)
+        q = mq(zmq.XREP, zmq.XREP, zmq.PUB, 'in', 'out')
+        q.bind_in(self.client_addrs['mux'])
+        q.bind_out(self.engine_addrs['mux'])
+        q.connect_mon(self.monitor_url)
+        q.daemon=True
+        children.append(q)
+
+        # Control Queue (in a Process)
+        q = mq(zmq.XREP, zmq.XREP, zmq.PUB, 'incontrol', 'outcontrol')
+        q.bind_in(self.client_addrs['control'])
+        q.bind_out(self.engine_addrs['control'])
+        q.connect_mon(self.monitor_url)
+        q.daemon=True
+        children.append(q)
+        # Task Queue (in a Process)
+        if self.scheme == 'pure':
+            logging.warn("task::using pure XREQ Task scheduler")
+            q = mq(zmq.XREP, zmq.XREQ, zmq.PUB, 'intask', 'outtask')
+            q.bind_in(self.client_addrs['task'])
+            q.bind_out(self.engine_addrs['task'])
+            q.connect_mon(self.monitor_url)
+            q.daemon=True
+            children.append(q)
+        elif self.scheme == 'none':
+            logging.warn("task::using no Task scheduler")
+            
+        else:
+            logging.warn("task::using Python %s Task scheduler"%self.scheme)
+            sargs = (self.client_addrs['task'], self.engine_addrs['task'], self.monitor_url, self.client_addrs['notification'])
+            q = Process(target=launch_scheduler, args=sargs, kwargs = dict(scheme=self.scheme))
+            q.daemon=True
+            children.append(q)
+        
     
 def main(argv=None):
+    """DO NOT USE ME ANYMORE"""
     
     parser = make_argument_parser()
     
     args = parser.parse_args(argv)
     parse_url(args)
     
     iface="%s://%s"%(args.transport,args.ip)+':%i'
     
     random_ports = 0
     if args.hb:
         hb = split_ports(args.hb, 2)
     else:
         hb = select_random_ports(2)
     if args.mux:
         mux = split_ports(args.mux, 2)
     else:
         mux = None
         random_ports += 2
     if args.iopub:
         iopub = split_ports(args.iopub, 2)
     else:
         iopub = None
         random_ports += 2
     if args.task:
         task = split_ports(args.task, 2)
     else:
         task = None
         random_ports += 2
     if args.control:
         control = split_ports(args.control, 2)
     else:
         control = None
         random_ports += 2
     
     ctx = zmq.Context()
     loop = ioloop.IOLoop.instance()
     
     
     # Registrar socket
     reg = ZMQStream(ctx.socket(zmq.XREP), loop)
     regport = bind_port(reg, args.ip, args.regport)
     
     ### Engine connections ###
     
     # heartbeat
     hpub = ctx.socket(zmq.PUB)
     bind_port(hpub, args.ip, hb[0])
     hrep = ctx.socket(zmq.XREP)
     bind_port(hrep, args.ip, hb[1])
     
     hmon = heartmonitor.HeartMonitor(loop, ZMQStream(hpub,loop), ZMQStream(hrep,loop),args.ping)
     hmon.start()
     
     ### Client connections ###
     # Clientele socket
     c = ZMQStream(ctx.socket(zmq.XREP), loop)
     cport = bind_port(c, args.ip, args.client)
     # Notifier socket
     n = ZMQStream(ctx.socket(zmq.PUB), loop)
     nport = bind_port(n, args.ip, args.notice)
     
     ### Key File ###
     if args.execkey and not os.path.isfile(args.execkey):
             generate_exec_key(args.execkey)
     
     thesession = session.StreamSession(username=args.ident or "controller", 
                     keyfile=args.execkey, session=args.session)
     
     ### build and launch the queues ###
     
     # monitor socket
     sub = ctx.socket(zmq.SUB)
     sub.setsockopt(zmq.SUBSCRIBE, "")
     monport = bind_port(sub, args.ip, args.monitor)
     sub = ZMQStream(sub, loop)
     
     ports = select_random_ports(random_ports)
     children = []
     
     # IOPub relay (in a Process)
     if not iopub:
         iopub = (ports.pop(),ports.pop())
     q = ProcessMonitoredQueue(zmq.SUB, zmq.PUB, zmq.PUB, 'iopub', 'N/A')
     q.bind_in(iface%iopub[1])
     q.bind_out(iface%iopub[0])
     q.setsockopt_in(zmq.SUBSCRIBE, '')
     q.connect_mon(iface%monport)
     q.daemon=True
     q.start()
     children.append(q.launcher)
     
     # Multiplexer Queue (in a Process)
     if not mux:
         mux = (ports.pop(),ports.pop())
     q = ProcessMonitoredQueue(zmq.XREP, zmq.XREP, zmq.PUB, 'in', 'out')
     q.bind_in(iface%mux[0])
     q.bind_out(iface%mux[1])
     q.connect_mon(iface%monport)
     q.daemon=True
     q.start()
     children.append(q.launcher)
     
     # Control Queue (in a Process)
     if not control:
         control = (ports.pop(),ports.pop())
     q = ProcessMonitoredQueue(zmq.XREP, zmq.XREP, zmq.PUB, 'incontrol', 'outcontrol')
     q.bind_in(iface%control[0])
     q.bind_out(iface%control[1])
     q.connect_mon(iface%monport)
     q.daemon=True
     q.start()
     children.append(q.launcher)
     # Task Queue (in a Process)
     if not task:
         task = (ports.pop(),ports.pop())
     if args.scheduler == 'pure':
         q = ProcessMonitoredQueue(zmq.XREP, zmq.XREQ, zmq.PUB, 'intask', 'outtask')
         q.bind_in(iface%task[0])
         q.bind_out(iface%task[1])
         q.connect_mon(iface%monport)
         q.daemon=True
         q.start()
         children.append(q.launcher)
     else:
         log_addr = iface%args.logport if args.logport else None
         sargs = (iface%task[0], iface%task[1], iface%monport, iface%nport,
                     log_addr, args.loglevel, args.scheduler)
         print (sargs)
         q = Process(target=launch_scheduler, args=sargs)
         q.daemon=True
         q.start()
         children.append(q)
     
     if args.mongodb:
         from mongodb import MongoDB
         db = MongoDB(thesession.session)
     else:
         db = DictDB()
     time.sleep(.25)
     
     # build connection dicts
     engine_addrs = {
         'control' : iface%control[1],
         'mux': iface%mux[1],
         'heartbeat': (iface%hb[0], iface%hb[1]),
         'task' : iface%task[1],
         'iopub' : iface%iopub[1],
         'monitor' : iface%monport,
         }
     
     client_addrs = {
         'control' : iface%control[0],
         'query': iface%cport,
         'mux': iface%mux[0],
         'task' : iface%task[0],
         'iopub' : iface%iopub[0],
         'notification': iface%nport
         }
     
     # setup logging
     if args.logport:
         connect_logger(ctx, iface%args.logport, root="controller", loglevel=args.loglevel)
     else:
         local_logger(args.loglevel)
         
     # register relay of signals to the children
     signal_children(children)
     hub = Hub(loop=loop, session=thesession, monitor=sub, heartmonitor=hmon,
                 registrar=reg, clientele=c, notifier=n, db=db,
                 engine_addrs=engine_addrs, client_addrs=client_addrs)
     
     dc = ioloop.DelayedCallback(lambda : print("Controller started..."), 100, loop)
     dc.start()
-    loop.start()
-    
-    
+    try:
+        loop.start()
+    except KeyboardInterrupt:
+        print ("interrupted, exiting...", file=sys.__stderr__)
     
 
 if __name__ == '__main__':
     main()

IPython/zmq/parallel/dictdb.py

@@ -1,148 +1,152 b''
 """A Task logger that presents our DB interface, 
 but exists entirely in memory and implemented with dicts.
 
 TaskRecords are dicts of the form:
 {
     'msg_id' : str(uuid),
     'client_uuid' : str(uuid),
     'engine_uuid' : str(uuid) or None,
     'header' : dict(header),
     'content': dict(content),
     'buffers': list(buffers),
     'submitted': datetime,
     'started': datetime or None,
     'completed': datetime or None,
     'resubmitted': datetime or None,
     'result_header' : dict(header) or None,
     'result_content' : dict(content) or None,
     'result_buffers' : list(buffers) or None,
 }
 With this info, many of the special categories of tasks can be defined by query:
 
 pending:  completed is None
 client's outstanding: client_uuid = uuid && completed is None
 MIA: arrived is None (and completed is None)
 etc.
 
 EngineRecords are dicts of the form:
 {
     'eid' : int(id),
     'uuid': str(uuid)
 }
 This may be extended, but is currently.
 
 We support a subset of mongodb operators:
     $lt,$gt,$lte,$gte,$ne,$in,$nin,$all,$mod,$exists
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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.
 #-----------------------------------------------------------------------------
 
 
 from datetime import datetime
 
 filters = {
  '$eq' : lambda a,b: a==b,
  '$lt' : lambda a,b: a < b,
  '$gt' : lambda a,b: b > a,
  '$lte': lambda a,b: a <= b,
  '$gte': lambda a,b: a >= b,
  '$ne' : lambda a,b: not a==b,
  '$in' : lambda a,b: a in b,
  '$nin': lambda a,b: a not in b,
  '$all' : lambda a,b: all([ a in bb for bb in b ]),
  '$mod': lambda a,b: a%b[0] == b[1],
  '$exists' : lambda a,b: (b and a is not None) or (a is None and not b)
 }
 
 
 class CompositeFilter(object):
     """Composite filter for matching multiple properties."""
     
     def __init__(self, dikt):
         self.tests = []
         self.values = []
         for key, value in dikt.iteritems():
             self.tests.append(filters[key])
             self.values.append(value)
 
     def __call__(self, value):
         for test,check in zip(self.tests, self.values):
             if not test(value, check):
                 return False
         return True
 
-class DictDB(object):
+class BaseDB(object):
+    """Empty Parent class so traitlets work on DB."""
+    pass
+
+class DictDB(BaseDB):
     """Basic in-memory dict-based object for saving Task Records.
     
     This is the first object to present the DB interface
     for logging tasks out of memory.
     
     The interface is based on MongoDB, so adding a MongoDB
     backend should be straightforward.
     """
     _records = None
     
     def __init__(self):
         self._records = dict()
     
     def _match_one(self, rec, tests):
         """Check if a specific record matches tests."""
         for key,test in tests.iteritems():
             if not test(rec.get(key, None)):
                 return False
         return True
         
     def _match(self, check, id_only=True):
         """Find all the matches for a check dict."""
         matches = {}
         tests = {}
         for k,v in check.iteritems():
             if isinstance(v, dict):
                 tests[k] = CompositeFilter(v)
             else:
                 tests[k] = lambda o: o==v
         
         for msg_id, rec in self._records.iteritems():
             if self._match_one(rec, tests):
                 matches[msg_id] = rec
         if id_only:
             return matches.keys()
         else:
             return matches
             
     
     def add_record(self, msg_id, rec):
         """Add a new Task Record, by msg_id."""
         if self._records.has_key(msg_id):
             raise KeyError("Already have msg_id %r"%(msg_id))
         self._records[msg_id] = rec
     
     def get_record(self, msg_id):
         """Get a specific Task Record, by msg_id."""
         if not self._records.has_key(msg_id):
             raise KeyError("No such msg_id %r"%(msg_id))
         return self._records[msg_id]
     
     def update_record(self, msg_id, rec):
         """Update the data in an existing record."""
         self._records[msg_id].update(rec)
     
     def drop_matching_records(self, check):
         """Remove a record from the DB."""
         matches = self._match(check, id_only=True)
         for m in matches:
             del self._records[m]
         
     def drop_record(self, msg_id):
         """Remove a record from the DB."""
         del self._records[msg_id]
         
     
     def find_records(self, check, id_only=False):
         """Find records matching a query dict."""
         matches = self._match(check, id_only)
         return matches
  No newline at end of file

IPython/zmq/parallel/engine.py

@@ -1,144 +1,190 b''
 #!/usr/bin/env python
 """A simple engine that talks to a controller over 0MQ.
 it handles registration, etc. and launches a kernel
 connected to the Controller's queue(s).
 """
 from __future__ import print_function
 import sys
 import time
 import traceback
 import uuid
 import logging
 from pprint import pprint
 
 import zmq
 from zmq.eventloop import ioloop, zmqstream
 
 # internal
 from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Instance, Str, Dict
+from IPython.utils.traitlets import Instance, Str, Dict, Int, Type
 # from IPython.utils.localinterfaces import LOCALHOST 
 
+from factory import RegistrationFactory
+
 from streamsession import Message, StreamSession
 from streamkernel import Kernel, make_kernel
 import heartmonitor
 from entry_point import (make_base_argument_parser, connect_engine_logger, parse_url,
                         local_logger)
 # import taskthread
-logger = logging.getLogger()
 
 def printer(*msg):
-    # print (logger.handlers, file=sys.__stdout__)
-    logger.info(str(msg))
+    # print (logging.handlers, file=sys.__stdout__)
+    logging.info(str(msg))
 
-class Engine(Configurable):
+class EngineFactory(RegistrationFactory):
     """IPython engine"""
     
-    kernel=None
-    id=None
-    
     # configurables:
-    context=Instance(zmq.Context)
-    loop=Instance(ioloop.IOLoop)
-    session=Instance(StreamSession)
-    ident=Str()
-    registrar=Instance(zmqstream.ZMQStream)
-    user_ns=Dict()
+    user_ns=Dict(config=True)
+    out_stream_factory=Type('IPython.zmq.iostream.OutStream', config=True)
+    display_hook_factory=Type('IPython.zmq.displayhook.DisplayHook', config=True)
+    
+    # not configurable:
+    id=Int(allow_none=True)
+    registrar=Instance('zmq.eventloop.zmqstream.ZMQStream')
+    kernel=Instance(Kernel)
+    
     
     def __init__(self, **kwargs):
-        super(Engine, self).__init__(**kwargs)
-        if not self.ident:
-            self.ident =  str(uuid.uuid4())
-        self.registrar.on_send(printer)
+        super(EngineFactory, self).__init__(**kwargs)
+        ctx = self.context
+        
+        reg = ctx.socket(zmq.PAIR)
+        reg.setsockopt(zmq.IDENTITY, self.ident)
+        reg.connect(self.url)
+        self.registrar = zmqstream.ZMQStream(reg, self.loop)
         
     def register(self):
+        """send the registration_request"""
         
+        logging.info("registering")
         content = dict(queue=self.ident, heartbeat=self.ident, control=self.ident)
         self.registrar.on_recv(self.complete_registration)
         # print (self.session.key)
         self.session.send(self.registrar, "registration_request",content=content)
     
     def complete_registration(self, msg):
         # print msg
+        ctx = self.context
+        loop = self.loop
+        identity = self.ident
+        print (identity)
+        
         idents,msg = self.session.feed_identities(msg)
         msg = Message(self.session.unpack_message(msg))
+        
         if msg.content.status == 'ok':
             self.id = int(msg.content.id)
-            self.session.username = 'engine-%i'%self.id
+            
+            # create Shell Streams (MUX, Task, etc.):
             queue_addr = msg.content.mux
             shell_addrs = [ str(queue_addr) ]
-            control_addr = str(msg.content.control)
             task_addr = msg.content.task
-            iopub_addr = msg.content.iopub
             if task_addr:
                 shell_addrs.append(str(task_addr))
+            shell_streams = []
+            for addr in shell_addrs:
+                stream = zmqstream.ZMQStream(ctx.socket(zmq.PAIR), loop)
+                stream.setsockopt(zmq.IDENTITY, identity)
+                stream.connect(addr)
+                shell_streams.append(stream)
+            
+            # control stream:
+            control_addr = str(msg.content.control)
+            control_stream = zmqstream.ZMQStream(ctx.socket(zmq.PAIR), loop)
+            control_stream.setsockopt(zmq.IDENTITY, identity)
+            control_stream.connect(control_addr)
             
+            # create iopub stream:
+            iopub_addr = msg.content.iopub
+            iopub_stream = zmqstream.ZMQStream(ctx.socket(zmq.PUB), loop)
+            iopub_stream.setsockopt(zmq.IDENTITY, identity)
+            iopub_stream.connect(iopub_addr)
+            
+            # launch heartbeat
             hb_addrs = msg.content.heartbeat
+            # print (hb_addrs)
+            
+            # # Redirect input streams and set a display hook.
+            # if self.out_stream_factory:
+            #     sys.stdout = self.out_stream_factory(self.session, iopub_stream, u'stdout')
+            #     sys.stdout.topic = 'engine.%i.stdout'%self.id
+            #     sys.stderr = self.out_stream_factory(self.session, iopub_stream, u'stderr')
+            #     sys.stderr.topic = 'engine.%i.stderr'%self.id
+            # if self.display_hook_factory:
+            #     sys.displayhook = self.display_hook_factory(self.session, iopub_stream)
+            #     sys.displayhook.topic = 'engine.%i.pyout'%self.id
+            
             # ioloop.DelayedCallback(self.heart.start, 1000, self.loop).start()
-            k = make_kernel(self.id, self.ident, control_addr, shell_addrs, iopub_addr,
-                            hb_addrs, client_addr=None, loop=self.loop,
-                            context=self.context, key=self.session.key)[-1]
-            self.kernel = k
-            if self.user_ns is not None:
-                self.user_ns.update(self.kernel.user_ns)
-                self.kernel.user_ns = self.user_ns
+            self.kernel = Kernel(int_id=self.id, ident=self.ident, session=self.session, 
+                    control_stream=control_stream,
+                    shell_streams=shell_streams, iopub_stream=iopub_stream, loop=loop,
+                    user_ns = self.user_ns, config=self.config)
+            self.kernel.start()
+            
+            heart = heartmonitor.Heart(*map(str, hb_addrs), heart_id=identity)
+            heart.start()
+            
             
         else:
-            logger.error("Registration Failed: %s"%msg)
+            logging.error("Registration Failed: %s"%msg)
             raise Exception("Registration Failed: %s"%msg)
         
-        logger.info("completed registration with id %i"%self.id)
-        
-        # logger.info(str(msg))
+        logging.info("Completed registration with id %i"%self.id)
+    
     
     def unregister(self):
-        self.session.send(self.registrar, "unregistration_request", content=dict(id=int(self.session.username)))
+        self.session.send(self.registrar, "unregistration_request", content=dict(id=self.id))
         time.sleep(1)
         sys.exit(0)
     
     def start(self):
-        logger.info("registering")
-        self.register()
+        dc = ioloop.DelayedCallback(self.register, 0, self.loop)
+        dc.start()
+
 
-        
 
 def main(argv=None, user_ns=None):
-    
+    """DO NOT USE ME ANYMORE"""
     parser = make_base_argument_parser()
     
     args = parser.parse_args(argv)
     
     parse_url(args)
     
     iface="%s://%s"%(args.transport,args.ip)+':%i'
     
     loop = ioloop.IOLoop.instance()
     session = StreamSession(keyfile=args.execkey)
     # print (session.key)
     ctx = zmq.Context()
 
     # setup logging
     
     reg_conn = iface % args.regport
     print (reg_conn, file=sys.__stdout__)
     print ("Starting the engine...", file=sys.__stderr__)
     
     reg = ctx.socket(zmq.PAIR)
     reg.connect(reg_conn)
     reg = zmqstream.ZMQStream(reg, loop)
     
     e = Engine(context=ctx, loop=loop, session=session, registrar=reg, 
             ident=args.ident or '', user_ns=user_ns)
     if args.logport:
         print ("connecting logger to %s"%(iface%args.logport), file=sys.__stdout__)
         connect_engine_logger(ctx, iface%args.logport, e, loglevel=args.loglevel)
     else:
         local_logger(args.loglevel)
     
     dc = ioloop.DelayedCallback(e.start, 0, loop)
     dc.start()
-    loop.start()
+    try:
+        loop.start()
+    except KeyboardInterrupt:
+        print ("interrupted, exiting...", file=sys.__stderr__)
 
 # Execution as a script
 if __name__ == '__main__':
     main()

IPython/zmq/parallel/entry_point.py

@@ -1,147 +1,167 b''
 """ Defines helper functions for creating kernel entry points and process
 launchers.
+
+************
+NOTE: Most of this module has been deprecated by moving to Configurables
+************
 """
 
 # Standard library imports.
 import logging
 import atexit
 import sys
 import os
 import stat
 import socket
 from subprocess import Popen, PIPE
 from signal import signal, SIGINT, SIGABRT, SIGTERM
 try:
     from signal import SIGKILL
 except ImportError:
     SIGKILL=None
 
 # System library imports.
 import zmq
 from zmq.log import handlers
 # Local imports.
 from IPython.core.ultratb import FormattedTB
 from IPython.external.argparse import ArgumentParser
 from IPython.zmq.log import EnginePUBHandler
 
 def split_ports(s, n):
     """Parser helper for multiport strings"""
     if not s:
         return tuple([0]*n)
     ports = map(int, s.split(','))
     if len(ports) != n:
         raise ValueError
     return ports
 
+_random_ports = set()
+
 def select_random_ports(n):
     """Selects and return n random ports that are available."""
     ports = []
     for i in xrange(n):
         sock = socket.socket()
         sock.bind(('', 0))
+        while sock.getsockname()[1] in _random_ports:
+            sock.close()
+            sock = socket.socket()
+            sock.bind(('', 0))
         ports.append(sock)
     for i, sock in enumerate(ports):
         port = sock.getsockname()[1]
         sock.close()
         ports[i] = port
+        _random_ports.add(port)
     return ports
 
 def parse_url(args):
     """Ensure args.url contains full transport://interface:port"""
     if args.url:
         iface = args.url.split('://',1)
         if len(args) == 2:
             args.transport,iface = iface
         iface = iface.split(':')
         args.ip = iface[0]
         if iface[1]:
             args.regport = iface[1]
     args.url = "%s://%s:%i"%(args.transport, args.ip,args.regport)
 
 def signal_children(children):
     """Relay interupt/term signals to children, for more solid process cleanup."""
     def terminate_children(sig, frame):
+        logging.critical("Got signal %i, terminating children..."%sig)
         for child in children:
             child.terminate()
+        
+        sys.exit(sig != SIGINT)
         # sys.exit(sig)
     for sig in (SIGINT, SIGABRT, SIGTERM):
         signal(sig, terminate_children)
 
 def generate_exec_key(keyfile):
     import uuid
     newkey = str(uuid.uuid4())
     with open(keyfile, 'w') as f:
         # f.write('ipython-key ')
-        f.write(newkey)
+        f.write(newkey+'\n')
     # set user-only RW permissions (0600)
     # this will have no effect on Windows
     os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
         
 
 def make_base_argument_parser():
     """ Creates an ArgumentParser for the generic arguments supported by all 
     ipcluster entry points.
     """
     
     parser = ArgumentParser()
     parser.add_argument('--ip', type=str, default='127.0.0.1',
                         help='set the controller\'s IP address [default: local]')
     parser.add_argument('--transport', type=str, default='tcp',
                         help='set the transport to use [default: tcp]')
     parser.add_argument('--regport', type=int, metavar='PORT', default=10101,
                         help='set the XREP port for registration [default: 10101]')
     parser.add_argument('--logport', type=int, metavar='PORT', default=0,
                         help='set the PUB port for remote logging [default: log to stdout]')
     parser.add_argument('--loglevel', type=str, metavar='LEVEL', default=logging.INFO,
                         help='set the log level [default: INFO]')
     parser.add_argument('--ident', type=str,
                         help='set the ZMQ identity [default: random]')
     parser.add_argument('--packer', type=str, default='json',
                         choices=['json','pickle'],
                         help='set the message format method [default: json]')
     parser.add_argument('--url', type=str,
                         help='set transport,ip,regport in one arg, e.g. tcp://127.0.0.1:10101')
     parser.add_argument('--execkey', type=str,
                         help="File containing key for authenticating requests.")
 
     return parser
 
 def integer_loglevel(loglevel):
     try:
         loglevel = int(loglevel)
     except ValueError:
         if isinstance(loglevel, str):
             loglevel = getattr(logging, loglevel)
     return loglevel
 
 def connect_logger(context, iface, root="ip", loglevel=logging.DEBUG):
+    logger = logging.getLogger()
+    if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
+        # don't add a second PUBHandler
+        return
     loglevel = integer_loglevel(loglevel)
     lsock = context.socket(zmq.PUB)
     lsock.connect(iface)
     handler = handlers.PUBHandler(lsock)
     handler.setLevel(loglevel)
     handler.root_topic = root
-    logger = logging.getLogger()
     logger.addHandler(handler)
     logger.setLevel(loglevel)
 
 def connect_engine_logger(context, iface, engine, loglevel=logging.DEBUG):
     logger = logging.getLogger()
+    if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
+        # don't add a second PUBHandler
+        return
     loglevel = integer_loglevel(loglevel)
     lsock = context.socket(zmq.PUB)
     lsock.connect(iface)
     handler = EnginePUBHandler(engine, lsock)
     handler.setLevel(loglevel)
     logger.addHandler(handler)
     logger.setLevel(loglevel)
 
 def local_logger(loglevel=logging.DEBUG):
     loglevel = integer_loglevel(loglevel)
     logger = logging.getLogger()
-    if logger.handlers:
-        # if there are any handlers, skip the hookup
+    if any([isinstance(h, logging.StreamHandler) for h in logger.handlers]):
+        # don't add a second StreamHandler
         return
     handler = logging.StreamHandler()
     handler.setLevel(loglevel)
     logger.addHandler(handler)
     logger.setLevel(loglevel)

IPython/zmq/parallel/heartmonitor.py

@@ -1,159 +1,156 b''
 #!/usr/bin/env python
 """
 A multi-heart Heartbeat system using PUB and XREP sockets. pings are sent out on the PUB,
 and hearts are tracked based on their XREQ identities.
 """
 
 from __future__ import print_function
 import time
 import uuid
 import logging
 
 import zmq
 from zmq.devices import ProcessDevice,ThreadDevice
 from zmq.eventloop import ioloop, zmqstream
 
-logger = logging.getLogger()
-
 class Heart(object):
     """A basic heart object for responding to a HeartMonitor.
     This is a simple wrapper with defaults for the most common
     Device model for responding to heartbeats.
     
     It simply builds a threadsafe zmq.FORWARDER Device, defaulting to using 
     SUB/XREQ for in/out.
     
     You can specify the XREQ's IDENTITY via the optional heart_id argument."""
     device=None
     id=None
     def __init__(self, in_addr, out_addr, in_type=zmq.SUB, out_type=zmq.XREQ, heart_id=None):
         self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
         self.device.daemon=True
         self.device.connect_in(in_addr)
         self.device.connect_out(out_addr)
         if in_type == zmq.SUB:
             self.device.setsockopt_in(zmq.SUBSCRIBE, "")
         if heart_id is None:
             heart_id = str(uuid.uuid4())
         self.device.setsockopt_out(zmq.IDENTITY, heart_id)
         self.id = heart_id
     
     def start(self):
         return self.device.start()
         
 class HeartMonitor(object):
     """A basic HeartMonitor class
     pingstream: a PUB stream
     pongstream: an XREP stream
     period: the period of the heartbeat in milliseconds"""
     loop=None
     pingstream=None
     pongstream=None
     period=None
     hearts=None
     on_probation=None
     last_ping=None
     # debug=False
     
     def __init__(self, loop, pingstream, pongstream, period=1000):
         self.loop = loop
         self.period = period
         
         self.pingstream = pingstream
         self.pongstream = pongstream
         self.pongstream.on_recv(self.handle_pong)
         
         self.hearts = set()
         self.responses = set()
         self.on_probation = set()
         self.lifetime = 0
         self.tic = time.time()
         
         self._new_handlers = set()
         self._failure_handlers = set()
     
     def start(self):
         self.caller = ioloop.PeriodicCallback(self.beat, self.period, self.loop)
         self.caller.start()
     
     def add_new_heart_handler(self, handler):
         """add a new handler for new hearts"""
-        logger.debug("heartbeat::new_heart_handler: %s"%handler)
+        logging.debug("heartbeat::new_heart_handler: %s"%handler)
         self._new_handlers.add(handler)
         
     def add_heart_failure_handler(self, handler):
         """add a new handler for heart failure"""
-        logger.debug("heartbeat::new heart failure handler: %s"%handler)
+        logging.debug("heartbeat::new heart failure handler: %s"%handler)
         self._failure_handlers.add(handler)
             
     def beat(self):
         self.pongstream.flush() 
         self.last_ping = self.lifetime
         
         toc = time.time()
         self.lifetime += toc-self.tic
         self.tic = toc
-        # logger.debug("heartbeat::%s"%self.lifetime)
+        # logging.debug("heartbeat::%s"%self.lifetime)
         goodhearts = self.hearts.intersection(self.responses)
         missed_beats = self.hearts.difference(goodhearts)
         heartfailures = self.on_probation.intersection(missed_beats)
         newhearts = self.responses.difference(goodhearts)
         map(self.handle_new_heart, newhearts)
         map(self.handle_heart_failure, heartfailures)
         self.on_probation = missed_beats.intersection(self.hearts)
         self.responses = set()
         # print self.on_probation, self.hearts
-        # logger.debug("heartbeat::beat %.3f, %i beating hearts"%(self.lifetime, len(self.hearts)))
+        # logging.debug("heartbeat::beat %.3f, %i beating hearts"%(self.lifetime, len(self.hearts)))
         self.pingstream.send(str(self.lifetime))
     
     def handle_new_heart(self, heart):
         if self._new_handlers:
             for handler in self._new_handlers:
                 handler(heart)
         else:
-            logger.info("heartbeat::yay, got new heart %s!"%heart)
+            logging.info("heartbeat::yay, got new heart %s!"%heart)
         self.hearts.add(heart)
     
     def handle_heart_failure(self, heart):
         if self._failure_handlers:
             for handler in self._failure_handlers:
                 try:
                     handler(heart)
                 except Exception as e:
-                    print (e)
-                    logger.error("heartbeat::Bad Handler! %s"%handler)
+                    logging.error("heartbeat::Bad Handler! %s"%handler, exc_info=True)
                     pass
         else:
-            logger.info("heartbeat::Heart %s failed :("%heart)
+            logging.info("heartbeat::Heart %s failed :("%heart)
         self.hearts.remove(heart)
         
     
     def handle_pong(self, msg):
         "a heart just beat"
         if msg[1] == str(self.lifetime):
             delta = time.time()-self.tic
-            # logger.debug("heartbeat::heart %r took %.2f ms to respond"%(msg[0], 1000*delta))
+            # logging.debug("heartbeat::heart %r took %.2f ms to respond"%(msg[0], 1000*delta))
             self.responses.add(msg[0])
         elif msg[1] == str(self.last_ping):
             delta = time.time()-self.tic + (self.lifetime-self.last_ping)
-            logger.warn("heartbeat::heart %r missed a beat, and took %.2f ms to respond"%(msg[0], 1000*delta))
+            logging.warn("heartbeat::heart %r missed a beat, and took %.2f ms to respond"%(msg[0], 1000*delta))
             self.responses.add(msg[0])
         else:
-            logger.warn("heartbeat::got bad heartbeat (possibly old?): %s (current=%.3f)"%
+            logging.warn("heartbeat::got bad heartbeat (possibly old?): %s (current=%.3f)"%
             (msg[1],self.lifetime))
 
 
 if __name__ == '__main__':
     loop = ioloop.IOLoop.instance()
     context = zmq.Context()
     pub = context.socket(zmq.PUB)
     pub.bind('tcp://127.0.0.1:5555')
     xrep = context.socket(zmq.XREP)
     xrep.bind('tcp://127.0.0.1:5556')
     
     outstream = zmqstream.ZMQStream(pub, loop)
     instream = zmqstream.ZMQStream(xrep, loop)
     
     hb = HeartMonitor(loop, outstream, instream)
     
     loop.start()

IPython/zmq/parallel/hub.py

@@ -1,906 +1,1079 b''
 #!/usr/bin/env python
 """The IPython Controller Hub with 0MQ
 This is the master object that handles connections from engines and clients,
 and monitors traffic through the various queues.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import sys
 from datetime import datetime
 import time
 import logging
 
 import zmq
-from zmq.eventloop import ioloop, zmqstream
+from zmq.eventloop import ioloop
+from zmq.eventloop.zmqstream import ZMQStream
 
 # internal:
 from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import HasTraits, Instance, Int, Str, Dict
-# from IPython.zmq.log import logger # a Logger object
+from IPython.utils.traitlets import HasTraits, Instance, Int, Str, Dict, Set, List, Bool
+from IPython.utils.importstring import import_item
+
+from entry_point import select_random_ports
+from factory import RegistrationFactory
 
 from streamsession import Message, wrap_exception, ISO8601
 from heartmonitor import HeartMonitor
 from util import validate_url_container
 
 try:
     from pymongo.binary import Binary
 except ImportError:
     MongoDB=None
 else:
     from mongodb import MongoDB
     
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
-logger = logging.getLogger()
-
 def _passer(*args, **kwargs):
     return
 
 def _printer(*args, **kwargs):
     print (args)
     print (kwargs)
 
 def init_record(msg):
     """Initialize a TaskRecord based on a request."""
     header = msg['header']
     return {
         'msg_id' : header['msg_id'],
         'header' : header,
         'content': msg['content'],
         'buffers': msg['buffers'],
         'submitted': datetime.strptime(header['date'], ISO8601),
         'client_uuid' : None,
         'engine_uuid' : None,
         'started': None,
         'completed': None,
         'resubmitted': None,
         'result_header' : None,
         'result_content' : None,
         'result_buffers' : None,
         'queue' : None,
         'pyin' : None,
         'pyout': None,
         'pyerr': None,
         'stdout': '',
         'stderr': '',
     }
 
 
 class EngineConnector(HasTraits):
     """A simple object for accessing the various zmq connections of an object.
     Attributes are:
     id (int): engine ID
     uuid (str): uuid (unused?)
     queue (str): identity of queue's XREQ socket
     registration (str): identity of registration XREQ socket
     heartbeat (str): identity of heartbeat XREQ socket
     """
     id=Int(0)
     queue=Str()
     control=Str()
     registration=Str()
     heartbeat=Str()
-    pending=Instance(set)
+    pending=Set()
     
     def __init__(self, **kwargs):
         super(EngineConnector, self).__init__(**kwargs)
-        logger.info("engine::Engine Connected: %i"%self.id)
+        logging.info("engine::Engine Connected: %i"%self.id)
+
+class HubFactory(RegistrationFactory):
+    """The Configurable for setting up a Hub."""
+    
+    # port-pairs for monitoredqueues:
+    hb = Instance(list, config=True)
+    def _hb_default(self):
+        return select_random_ports(2)
+    
+    mux = Instance(list, config=True)
+    def _mux_default(self):
+        return select_random_ports(2)
+    
+    task = Instance(list, config=True)
+    def _task_default(self):
+        return select_random_ports(2)
+    
+    control = Instance(list, config=True)
+    def _control_default(self):
+        return select_random_ports(2)
+    
+    iopub = Instance(list, config=True)
+    def _iopub_default(self):
+        return select_random_ports(2)
+    
+    # single ports:
+    mon_port = Instance(int, config=True)
+    def _mon_port_default(self):
+        return select_random_ports(1)[0]
+    
+    query_port = Instance(int, config=True)
+    def _query_port_default(self):
+        return select_random_ports(1)[0]
+    
+    notifier_port = Instance(int, config=True)
+    def _notifier_port_default(self):
+        return select_random_ports(1)[0]
+    
+    ping = Int(1000, config=True) # ping frequency
+    
+    engine_ip = Str('127.0.0.1', config=True)
+    engine_transport = Str('tcp', config=True)
+    
+    client_ip = Str('127.0.0.1', config=True)
+    client_transport = Str('tcp', config=True)
+    
+    monitor_ip = Str('127.0.0.1', config=True)
+    monitor_transport = Str('tcp', config=True)
+    
+    monitor_url = Str('')
+    
+    db_class = Str('IPython.zmq.parallel.dictdb.DictDB', config=True)
+    
+    # not configurable
+    db = Instance('IPython.zmq.parallel.dictdb.BaseDB')
+    heartmonitor = Instance('IPython.zmq.parallel.heartmonitor.HeartMonitor')
+    subconstructors = List()
+    _constructed = Bool(False)
+    
+    def _update_monitor_url(self):
+        self.monitor_url = "%s://%s:%i"%(self.monitor_transport, self.monitor_ip, self.mon_port)
+    
+    def _sync_ips(self):
+        self.engine_ip = self.ip
+        self.client_ip = self.ip
+        self.monitor_ip = self.ip
+        self._update_monitor_url()
+    
+    def _sync_transports(self):
+        self.engine_transport = self.transport
+        self.client_transport = self.transport
+        self.monitor_transport = self.transport
+        self._update_monitor_url()
+        
+    def __init__(self, **kwargs):
+        super(HubFactory, self).__init__(**kwargs)
+        self._update_monitor_url()
+        self.on_trait_change(self._sync_ips, 'ip')
+        self.on_trait_change(self._sync_transports, 'transport')
+        self.subconstructors.append(self.construct_hub)
+    
+    
+    def construct(self):
+        assert not self._constructed, "already constructed!"
+        
+        for subc in self.subconstructors:
+            subc()
+        
+        self._constructed = True
+        
+    
+    def start(self):
+        assert self._constructed, "must be constructed by self.construct() first!"
+        self.heartmonitor.start()
+        logging.info("Heartmonitor started")
+    
+    def construct_hub(self):
+        """construct"""
+        client_iface = "%s://%s:"%(self.client_transport, self.client_ip) + "%i"
+        engine_iface = "%s://%s:"%(self.engine_transport, self.engine_ip) + "%i"
+        
+        ctx = self.context
+        loop = self.loop
+        
+        # Registrar socket
+        reg = ZMQStream(ctx.socket(zmq.XREP), loop)
+        reg.bind(client_iface % self.regport)
+        logging.info("Hub listening on %s for registration."%(client_iface%self.regport))
+        if self.client_ip != self.engine_ip:
+            reg.bind(engine_iface % self.regport)
+            logging.info("Hub listening on %s for registration."%(engine_iface%self.regport))
+        
+        ### Engine connections ###
+
+        # heartbeat
+        hpub = ctx.socket(zmq.PUB)
+        hpub.bind(engine_iface % self.hb[0])
+        hrep = ctx.socket(zmq.XREP)
+        hrep.bind(engine_iface % self.hb[1])
+
+        self.heartmonitor = HeartMonitor(loop, ZMQStream(hpub,loop), ZMQStream(hrep,loop), self.ping)
+
+        ### Client connections ###
+        # Clientele socket
+        c = ZMQStream(ctx.socket(zmq.XREP), loop)
+        c.bind(client_iface%self.query_port)
+        # Notifier socket
+        n = ZMQStream(ctx.socket(zmq.PUB), loop)
+        n.bind(client_iface%self.notifier_port)
+
+        ### build and launch the queues ###
+
+        # monitor socket
+        sub = ctx.socket(zmq.SUB)
+        sub.setsockopt(zmq.SUBSCRIBE, "")
+        sub.bind(self.monitor_url)
+        sub = ZMQStream(sub, loop)
         
-class Hub(Configurable):
+        # connect the db
+        self.db = import_item(self.db_class)()
+        time.sleep(.25)
+
+        # build connection dicts
+        self.engine_addrs = {
+            'control' : engine_iface%self.control[1],
+            'mux': engine_iface%self.mux[1],
+            'heartbeat': (engine_iface%self.hb[0], engine_iface%self.hb[1]),
+            'task' : engine_iface%self.task[1],
+            'iopub' : engine_iface%self.iopub[1],
+            # 'monitor' : engine_iface%self.mon_port,
+            }
+
+        self.client_addrs = {
+            'control' : client_iface%self.control[0],
+            'query': client_iface%self.query_port,
+            'mux': client_iface%self.mux[0],
+            'task' : client_iface%self.task[0],
+            'iopub' : client_iface%self.iopub[0],
+            'notification': client_iface%self.notifier_port
+            }
+        logging.debug("hub::Hub engine addrs: %s"%self.engine_addrs)
+        logging.debug("hub::Hub client addrs: %s"%self.client_addrs)
+        self.hub = Hub(loop=loop, session=self.session, monitor=sub, heartmonitor=self.heartmonitor,
+                registrar=reg, clientele=c, notifier=n, db=self.db,
+                engine_addrs=self.engine_addrs, client_addrs=self.client_addrs)
+    
+
+class Hub(HasTraits):
     """The IPython Controller Hub with 0MQ connections
     
     Parameters
     ==========
     loop: zmq IOLoop instance
     session: StreamSession object
     <removed> context: zmq context for creating new connections (?)
     queue: ZMQStream for monitoring the command queue (SUB)
     registrar: ZMQStream for engine registration requests (XREP)
     heartbeat: HeartMonitor object checking the pulse of the engines
     clientele: ZMQStream for client connections (XREP)
                 not used for jobs, only query/control commands
     notifier: ZMQStream for broadcasting engine registration changes (PUB)
     db: connection to db for out of memory logging of commands
                 NotImplemented
     engine_addrs: dict of zmq connection information for engines to connect
                 to the queues.
     client_addrs: dict of zmq connection information for engines to connect
                 to the queues.
     """
     # internal data structures:
-    ids=None # engine IDs
-    keytable=None
-    engines=None
-    clients=None
-    hearts=None
-    pending=None
-    tasks=None
-    completed=None
+    ids=Set() # engine IDs
+    keytable=Dict()
+    by_ident=Dict()
+    engines=Dict()
+    clients=Dict()
+    hearts=Dict()
+    pending=Set()
+    queues=Dict()  # pending msg_ids keyed by engine_id
+    tasks=Dict() # pending msg_ids submitted as tasks, keyed by client_id
+    completed=Dict() # completed msg_ids keyed by engine_id
+    all_completed=Set() # completed msg_ids keyed by engine_id
     # mia=None
-    incoming_registrations=None
-    registration_timeout=None
+    incoming_registrations=Dict()
+    registration_timeout=Int()
+    _idcounter=Int(0)
     
     # objects from constructor:
     loop=Instance(ioloop.IOLoop)
-    registrar=Instance(zmqstream.ZMQStream)
-    clientele=Instance(zmqstream.ZMQStream)
-    monitor=Instance(zmqstream.ZMQStream)
+    registrar=Instance(ZMQStream)
+    clientele=Instance(ZMQStream)
+    monitor=Instance(ZMQStream)
     heartmonitor=Instance(HeartMonitor)
-    notifier=Instance(zmqstream.ZMQStream)
+    notifier=Instance(ZMQStream)
     db=Instance(object)
     client_addrs=Dict()
     engine_addrs=Dict()
     
     
     def __init__(self, **kwargs):
         """
         # universal:
         loop: IOLoop for creating future connections
         session: streamsession for sending serialized data
         # engine:
         queue: ZMQStream for monitoring queue messages
         registrar: ZMQStream for engine registration
         heartbeat: HeartMonitor object for tracking engines
         # client:
         clientele: ZMQStream for client connections
         # extra:
         db: ZMQStream for db connection (NotImplemented)
         engine_addrs: zmq address/protocol dict for engine connections
         client_addrs: zmq address/protocol dict for client connections
         """
         
         super(Hub, self).__init__(**kwargs)
         self.ids = set()
-        self.keytable={}
-        self.incoming_registrations={}
-        self.engines = {}
-        self.by_ident = {}
-        self.clients = {}
-        self.hearts = {}
+        self.pending = set()
+        # self.keytable={}
+        # self.incoming_registrations={}
+        # self.engines = {}
+        # self.by_ident = {}
+        # self.clients = {}
+        # self.hearts = {}
         # self.mia = set()
         self.registration_timeout = max(5000, 2*self.heartmonitor.period)
         # this is the stuff that will move to DB:
-        self.pending = set() # pending messages, keyed by msg_id
-        self.queues = {} # pending msg_ids keyed by engine_id
-        self.tasks = {} # pending msg_ids submitted as tasks, keyed by client_id
-        self.completed = {} # completed msg_ids keyed by engine_id
-        self.all_completed = set()
-        self._idcounter = 0
+        # self.pending = set() # pending messages, keyed by msg_id
+        # self.queues = {} # pending msg_ids keyed by engine_id
+        # self.tasks = {} # pending msg_ids submitted as tasks, keyed by client_id
+        # self.completed = {} # completed msg_ids keyed by engine_id
+        # self.all_completed = set()
+        # self._idcounter = 0
         # self.sockets = {}
         # self.loop = loop
         # self.session = session
         # self.registrar = registrar
         # self.clientele = clientele
         # self.queue = queue
         # self.heartmonitor = heartbeat
         # self.notifier = notifier
         # self.db = db
         
         # validate connection dicts:
         # self.client_addrs = client_addrs
         validate_url_container(self.client_addrs)
         
         # assert isinstance(self.client_addrs['queue'], str)
         # assert isinstance(self.client_addrs['control'], str)
         # self.hb_addrs = hb_addrs
         validate_url_container(self.engine_addrs)
         # self.engine_addrs = engine_addrs
         # assert isinstance(self.engine_addrs['queue'], str)
         # assert isinstance(self.engine_addrs['control'], str)
         # assert len(engine_addrs['heartbeat']) == 2
         
         # register our callbacks
         self.registrar.on_recv(self.dispatch_register_request)
         self.clientele.on_recv(self.dispatch_client_msg)
         self.monitor.on_recv(self.dispatch_monitor_traffic)
         
         self.heartmonitor.add_heart_failure_handler(self.handle_heart_failure)
         self.heartmonitor.add_new_heart_handler(self.handle_new_heart)
         
         self.monitor_handlers = { 'in' : self.save_queue_request,
                                 'out': self.save_queue_result,
                                 'intask': self.save_task_request,
                                 'outtask': self.save_task_result,
                                 'tracktask': self.save_task_destination,
                                 'incontrol': _passer,
                                 'outcontrol': _passer,
                                 'iopub': self.save_iopub_message,
         }
         
         self.client_handlers = {'queue_request': self.queue_status,
                                 'result_request': self.get_results,
                                 'purge_request': self.purge_results,
                                 'load_request': self.check_load,
                                 'resubmit_request': self.resubmit_task,
                                 'shutdown_request': self.shutdown_request,
                                 }
         
         self.registrar_handlers = {'registration_request' : self.register_engine,
                                 'unregistration_request' : self.unregister_engine,
                                 'connection_request': self.connection_request,
         }
         
-        logger.info("controller::created controller")
+        logging.info("hub::created hub")
     
     @property
     def _next_id(self):
         """gemerate a new ID"""
         newid = self._idcounter
         self._idcounter += 1
         return newid
         # newid = 0
         # incoming = [id[0] for id in self.incoming_registrations.itervalues()]
         # # print newid, self.ids, self.incoming_registrations
         # while newid in self.ids or newid in incoming:
         #     newid += 1
         # return newid
     
     #-----------------------------------------------------------------------------
     # message validation
     #-----------------------------------------------------------------------------
     
     def _validate_targets(self, targets):
         """turn any valid targets argument into a list of integer ids"""
         if targets is None:
             # default to all
             targets = self.ids
             
         if isinstance(targets, (int,str,unicode)):
             # only one target specified
             targets = [targets]
         _targets = []
         for t in targets:
             # map raw identities to ids
             if isinstance(t, (str,unicode)):
                 t = self.by_ident.get(t, t)
             _targets.append(t)
         targets = _targets
         bad_targets = [ t for t in targets if t not in self.ids ]
         if bad_targets:
             raise IndexError("No Such Engine: %r"%bad_targets)
         if not targets:
             raise IndexError("No Engines Registered")
         return targets
     
     def _validate_client_msg(self, msg):
         """validates and unpacks headers of a message. Returns False if invalid,
         (ident, header, parent, content)"""
         client_id = msg[0]
         try:
             msg = self.session.unpack_message(msg[1:], content=True)
         except:
-            logger.error("client::Invalid Message %s"%msg, exc_info=True)
+            logging.error("client::Invalid Message %s"%msg, exc_info=True)
             return False
         
         msg_type = msg.get('msg_type', None)
         if msg_type is None:
             return False
         header = msg.get('header')
         # session doesn't handle split content for now:
         return client_id, msg
         
     
     #-----------------------------------------------------------------------------
     # dispatch methods (1 per stream)
     #-----------------------------------------------------------------------------
     
     def dispatch_register_request(self, msg):
         """"""
-        logger.debug("registration::dispatch_register_request(%s)"%msg)
+        logging.debug("registration::dispatch_register_request(%s)"%msg)
         idents,msg = self.session.feed_identities(msg)
         if not idents:
-            logger.error("Bad Queue Message: %s"%msg, exc_info=True)
+            logging.error("Bad Queue Message: %s"%msg, exc_info=True)
             return
         try:
             msg = self.session.unpack_message(msg,content=True)
         except:
-            logger.error("registration::got bad registration message: %s"%msg, exc_info=True)
+            logging.error("registration::got bad registration message: %s"%msg, exc_info=True)
             return
         
         msg_type = msg['msg_type']
         content = msg['content']
         
         handler = self.registrar_handlers.get(msg_type, None)
         if handler is None:
-            logger.error("registration::got bad registration message: %s"%msg)
+            logging.error("registration::got bad registration message: %s"%msg)
         else:
             handler(idents, msg)
     
     def dispatch_monitor_traffic(self, msg):
         """all ME and Task queue messages come through here, as well as
         IOPub traffic."""
-        logger.debug("monitor traffic: %s"%msg[:2])
+        logging.debug("monitor traffic: %s"%msg[:2])
         switch = msg[0]
         idents, msg = self.session.feed_identities(msg[1:])
         if not idents:
-            logger.error("Bad Monitor Message: %s"%msg)
+            logging.error("Bad Monitor Message: %s"%msg)
             return
         handler = self.monitor_handlers.get(switch, None)
         if handler is not None:
             handler(idents, msg)
         else:
-            logger.error("Invalid monitor topic: %s"%switch)
+            logging.error("Invalid monitor topic: %s"%switch)
         
     
     def dispatch_client_msg(self, msg):
         """Route messages from clients"""
         idents, msg = self.session.feed_identities(msg)
         if not idents:
-            logger.error("Bad Client Message: %s"%msg)
+            logging.error("Bad Client Message: %s"%msg)
             return
         client_id = idents[0]
         try:
             msg = self.session.unpack_message(msg, content=True)
         except:
             content = wrap_exception()
-            logger.error("Bad Client Message: %s"%msg, exc_info=True)
-            self.session.send(self.clientele, "controller_error", ident=client_id, 
+            logging.error("Bad Client Message: %s"%msg, exc_info=True)
+            self.session.send(self.clientele, "hub_error", ident=client_id, 
                     content=content)
             return
         
         # print client_id, header, parent, content
         #switch on message type:
         msg_type = msg['msg_type']
-        logger.info("client:: client %s requested %s"%(client_id, msg_type))
+        logging.info("client:: client %s requested %s"%(client_id, msg_type))
         handler = self.client_handlers.get(msg_type, None)
         try:
             assert handler is not None, "Bad Message Type: %s"%msg_type
         except:
             content = wrap_exception()
-            logger.error("Bad Message Type: %s"%msg_type, exc_info=True)
-            self.session.send(self.clientele, "controller_error", ident=client_id, 
+            logging.error("Bad Message Type: %s"%msg_type, exc_info=True)
+            self.session.send(self.clientele, "hub_error", ident=client_id, 
                     content=content)
             return
         else:
             handler(client_id, msg)
             
     def dispatch_db(self, msg):
         """"""
         raise NotImplementedError
     
     #---------------------------------------------------------------------------
     # handler methods (1 per event)
     #---------------------------------------------------------------------------
     
     #----------------------- Heartbeat --------------------------------------
     
     def handle_new_heart(self, heart):
         """handler to attach to heartbeater.
         Called when a new heart starts to beat.
         Triggers completion of registration."""
-        logger.debug("heartbeat::handle_new_heart(%r)"%heart)
+        logging.debug("heartbeat::handle_new_heart(%r)"%heart)
         if heart not in self.incoming_registrations:
-            logger.info("heartbeat::ignoring new heart: %r"%heart)
+            logging.info("heartbeat::ignoring new heart: %r"%heart)
         else:
             self.finish_registration(heart)
         
     
     def handle_heart_failure(self, heart):
         """handler to attach to heartbeater.
         called when a previously registered heart fails to respond to beat request.
         triggers unregistration"""
-        logger.debug("heartbeat::handle_heart_failure(%r)"%heart)
+        logging.debug("heartbeat::handle_heart_failure(%r)"%heart)
         eid = self.hearts.get(heart, None)
         queue = self.engines[eid].queue
         if eid is None:
-            logger.info("heartbeat::ignoring heart failure %r"%heart)
+            logging.info("heartbeat::ignoring heart failure %r"%heart)
         else:
             self.unregister_engine(heart, dict(content=dict(id=eid, queue=queue)))
     
     #----------------------- MUX Queue Traffic ------------------------------
     
     def save_queue_request(self, idents, msg):
         if len(idents) < 2:
-            logger.error("invalid identity prefix: %s"%idents)
+            logging.error("invalid identity prefix: %s"%idents)
             return
         queue_id, client_id = idents[:2]
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
-            logger.error("queue::client %r sent invalid message to %r: %s"%(client_id, queue_id, msg), exc_info=True)
+            logging.error("queue::client %r sent invalid message to %r: %s"%(client_id, queue_id, msg), exc_info=True)
             return
         
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
-            logger.error("queue::target %r not registered"%queue_id)
-            logger.debug("queue::    valid are: %s"%(self.by_ident.keys()))
+            logging.error("queue::target %r not registered"%queue_id)
+            logging.debug("queue::    valid are: %s"%(self.by_ident.keys()))
             return
             
         header = msg['header']
         msg_id = header['msg_id']
         record = init_record(msg)
         record['engine_uuid'] = queue_id
         record['client_uuid'] = client_id
         record['queue'] = 'mux'
         if MongoDB is not None and isinstance(self.db, MongoDB):
             record['buffers'] = map(Binary, record['buffers'])
         self.pending.add(msg_id)
         self.queues[eid].append(msg_id)
         self.db.add_record(msg_id, record)
     
     def save_queue_result(self, idents, msg):
         if len(idents) < 2:
-            logger.error("invalid identity prefix: %s"%idents)
+            logging.error("invalid identity prefix: %s"%idents)
             return
             
         client_id, queue_id = idents[:2]
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
-            logger.error("queue::engine %r sent invalid message to %r: %s"%(
+            logging.error("queue::engine %r sent invalid message to %r: %s"%(
                     queue_id,client_id, msg), exc_info=True)
             return
         
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
-            logger.error("queue::unknown engine %r is sending a reply: "%queue_id)
-            logger.debug("queue::       %s"%msg[2:])
+            logging.error("queue::unknown engine %r is sending a reply: "%queue_id)
+            logging.debug("queue::       %s"%msg[2:])
             return
         
         parent = msg['parent_header']
         if not parent:
             return
         msg_id = parent['msg_id']
         if msg_id in self.pending:
             self.pending.remove(msg_id)
             self.all_completed.add(msg_id)
             self.queues[eid].remove(msg_id)
             self.completed[eid].append(msg_id)
             rheader = msg['header']
             completed = datetime.strptime(rheader['date'], ISO8601)
             started = rheader.get('started', None)
             if started is not None:
                 started = datetime.strptime(started, ISO8601)
             result = {
                 'result_header' : rheader,
                 'result_content': msg['content'],
                 'started' : started,
                 'completed' : completed
             }
             if MongoDB is not None and isinstance(self.db, MongoDB):
                 result['result_buffers'] = map(Binary, msg['buffers'])
             else:
                 result['result_buffers'] = msg['buffers']
             self.db.update_record(msg_id, result)
         else:
-            logger.debug("queue:: unknown msg finished %s"%msg_id)
+            logging.debug("queue:: unknown msg finished %s"%msg_id)
             
     #--------------------- Task Queue Traffic ------------------------------
     
     def save_task_request(self, idents, msg):
         """Save the submission of a task."""
         client_id = idents[0]
         
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
-            logger.error("task::client %r sent invalid task message: %s"%(
+            logging.error("task::client %r sent invalid task message: %s"%(
                     client_id, msg), exc_info=True)
             return
         record = init_record(msg)
         if MongoDB is not None and isinstance(self.db, MongoDB):
             record['buffers'] = map(Binary, record['buffers'])
         record['client_uuid'] = client_id
         record['queue'] = 'task'
         header = msg['header']
         msg_id = header['msg_id']
         self.pending.add(msg_id)
         self.db.add_record(msg_id, record)
     
     def save_task_result(self, idents, msg):
         """save the result of a completed task."""
         client_id = idents[0]
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
-            logger.error("task::invalid task result message send to %r: %s"%(
+            logging.error("task::invalid task result message send to %r: %s"%(
                     client_id, msg), exc_info=True)
             raise
             return
         
         parent = msg['parent_header']
         if not parent:
             # print msg
-            logger.warn("Task %r had no parent!"%msg)
+            logging.warn("Task %r had no parent!"%msg)
             return
         msg_id = parent['msg_id']
         
         header = msg['header']
         engine_uuid = header.get('engine', None)
         eid = self.by_ident.get(engine_uuid, None)
         
         if msg_id in self.pending:
             self.pending.remove(msg_id)
             self.all_completed.add(msg_id)
             if eid is not None:
                 self.completed[eid].append(msg_id)
                 if msg_id in self.tasks[eid]:
                     self.tasks[eid].remove(msg_id)
             completed = datetime.strptime(header['date'], ISO8601)
             started = header.get('started', None)
             if started is not None:
                 started = datetime.strptime(started, ISO8601)
             result = {
                 'result_header' : header,
                 'result_content': msg['content'],
                 'started' : started,
                 'completed' : completed,
                 'engine_uuid': engine_uuid
             }
             if MongoDB is not None and isinstance(self.db, MongoDB):
                 result['result_buffers'] = map(Binary, msg['buffers'])
             else:
                 result['result_buffers'] = msg['buffers']
             self.db.update_record(msg_id, result)
             
         else:
-            logger.debug("task::unknown task %s finished"%msg_id)
+            logging.debug("task::unknown task %s finished"%msg_id)
     
     def save_task_destination(self, idents, msg):
         try:
             msg = self.session.unpack_message(msg, content=True)
         except:
-            logger.error("task::invalid task tracking message", exc_info=True)
+            logging.error("task::invalid task tracking message", exc_info=True)
             return
         content = msg['content']
         print (content)
         msg_id = content['msg_id']
         engine_uuid = content['engine_id']
         eid = self.by_ident[engine_uuid]
         
-        logger.info("task::task %s arrived on %s"%(msg_id, eid))
+        logging.info("task::task %s arrived on %s"%(msg_id, eid))
         # if msg_id in self.mia:
         #     self.mia.remove(msg_id)
         # else:
-        #     logger.debug("task::task %s not listed as MIA?!"%(msg_id))
+        #     logging.debug("task::task %s not listed as MIA?!"%(msg_id))
         
         self.tasks[eid].append(msg_id)
         # self.pending[msg_id][1].update(received=datetime.now(),engine=(eid,engine_uuid))
         self.db.update_record(msg_id, dict(engine_uuid=engine_uuid))
     
     def mia_task_request(self, idents, msg):
         raise NotImplementedError
         client_id = idents[0]
         # content = dict(mia=self.mia,status='ok')
         # self.session.send('mia_reply', content=content, idents=client_id)
         
         
     #--------------------- IOPub Traffic ------------------------------
     
     def save_iopub_message(self, topics, msg):
         """save an iopub message into the db"""
         print (topics)
         try:
             msg = self.session.unpack_message(msg, content=True)
         except:
-            logger.error("iopub::invalid IOPub message", exc_info=True)
+            logging.error("iopub::invalid IOPub message", exc_info=True)
             return
         
         parent = msg['parent_header']
         if not parent:
-            logger.error("iopub::invalid IOPub message: %s"%msg)
+            logging.error("iopub::invalid IOPub message: %s"%msg)
             return
         msg_id = parent['msg_id']
         msg_type = msg['msg_type']
         content = msg['content']
         
         # ensure msg_id is in db
         try:
             rec = self.db.get_record(msg_id)
         except:
-            logger.error("iopub::IOPub message has invalid parent", exc_info=True)
+            logging.error("iopub::IOPub message has invalid parent", exc_info=True)
             return
         # stream
         d = {}
         if msg_type == 'stream':
             name = content['name']
             s = rec[name] or ''
             d[name] = s + content['data']
             
         elif msg_type == 'pyerr':
             d['pyerr'] = content
         else:
             d[msg_type] = content['data']
         
         self.db.update_record(msg_id, d)
         
     
             
     #-------------------------------------------------------------------------
     # Registration requests
     #-------------------------------------------------------------------------
         
     def connection_request(self, client_id, msg):
         """Reply with connection addresses for clients."""
-        logger.info("client::client %s connected"%client_id)
+        logging.info("client::client %s connected"%client_id)
         content = dict(status='ok')
         content.update(self.client_addrs)
         jsonable = {}
         for k,v in self.keytable.iteritems():
             jsonable[str(k)] = v
         content['engines'] = jsonable
         self.session.send(self.registrar, 'connection_reply', content, parent=msg, ident=client_id)
     
     def register_engine(self, reg, msg):
         """Register a new engine."""
         content = msg['content']
         try:
             queue = content['queue']
         except KeyError:
-            logger.error("registration::queue not specified", exc_info=True)
+            logging.error("registration::queue not specified", exc_info=True)
             return
         heart = content.get('heartbeat', None)
         """register a new engine, and create the socket(s) necessary"""
         eid = self._next_id
         # print (eid, queue, reg, heart)
         
-        logger.debug("registration::register_engine(%i, %r, %r, %r)"%(eid, queue, reg, heart))
+        logging.debug("registration::register_engine(%i, %r, %r, %r)"%(eid, queue, reg, heart))
         
         content = dict(id=eid,status='ok')
         content.update(self.engine_addrs)
         # check if requesting available IDs:
         if queue in self.by_ident:
             try:
                 raise KeyError("queue_id %r in use"%queue)
             except:
                 content = wrap_exception()
-                logger.error("queue_id %r in use"%queue, exc_info=True)
+                logging.error("queue_id %r in use"%queue, exc_info=True)
         elif heart in self.hearts: # need to check unique hearts?
             try:
                 raise KeyError("heart_id %r in use"%heart)
             except:
-                logger.error("heart_id %r in use"%heart, exc_info=True)
+                logging.error("heart_id %r in use"%heart, exc_info=True)
                 content = wrap_exception()
         else:
             for h, pack in self.incoming_registrations.iteritems():
                 if heart == h:
                     try:
                         raise KeyError("heart_id %r in use"%heart)
                     except:
-                        logger.error("heart_id %r in use"%heart, exc_info=True)
+                        logging.error("heart_id %r in use"%heart, exc_info=True)
                         content = wrap_exception()
                     break
                 elif queue == pack[1]:
                     try:
                         raise KeyError("queue_id %r in use"%queue)
                     except:
-                        logger.error("queue_id %r in use"%queue, exc_info=True)
+                        logging.error("queue_id %r in use"%queue, exc_info=True)
                         content = wrap_exception()
                     break
         
         msg = self.session.send(self.registrar, "registration_reply", 
                 content=content, 
                 ident=reg)
         
         if content['status'] == 'ok':
             if heart in self.heartmonitor.hearts:
                 # already beating
                 self.incoming_registrations[heart] = (eid,queue,reg[0],None)
                 self.finish_registration(heart)
             else:
                 purge = lambda : self._purge_stalled_registration(heart)
                 dc = ioloop.DelayedCallback(purge, self.registration_timeout, self.loop)
                 dc.start()
                 self.incoming_registrations[heart] = (eid,queue,reg[0],dc)
         else:
-            logger.error("registration::registration %i failed: %s"%(eid, content['evalue']))
+            logging.error("registration::registration %i failed: %s"%(eid, content['evalue']))
         return eid
     
     def unregister_engine(self, ident, msg):
         """Unregister an engine that explicitly requested to leave."""
         try:
             eid = msg['content']['id']
         except:
-            logger.error("registration::bad engine id for unregistration: %s"%ident, exc_info=True)
+            logging.error("registration::bad engine id for unregistration: %s"%ident, exc_info=True)
             return
-        logger.info("registration::unregister_engine(%s)"%eid)
+        logging.info("registration::unregister_engine(%s)"%eid)
         content=dict(id=eid, queue=self.engines[eid].queue)
         self.ids.remove(eid)
         self.keytable.pop(eid)
         ec = self.engines.pop(eid)
         self.hearts.pop(ec.heartbeat)
         self.by_ident.pop(ec.queue)
         self.completed.pop(eid)
         for msg_id in self.queues.pop(eid):
             msg = self.pending.remove(msg_id)
             ############## TODO: HANDLE IT ################
         
         if self.notifier:
             self.session.send(self.notifier, "unregistration_notification", content=content)
     
     def finish_registration(self, heart):
         """Second half of engine registration, called after our HeartMonitor
         has received a beat from the Engine's Heart."""
         try: 
             (eid,queue,reg,purge) = self.incoming_registrations.pop(heart)
         except KeyError:
-            logger.error("registration::tried to finish nonexistant registration", exc_info=True)
+            logging.error("registration::tried to finish nonexistant registration", exc_info=True)
             return
-        logger.info("registration::finished registering engine %i:%r"%(eid,queue))
+        logging.info("registration::finished registering engine %i:%r"%(eid,queue))
         if purge is not None:
             purge.stop()
         control = queue
         self.ids.add(eid)
         self.keytable[eid] = queue
         self.engines[eid] = EngineConnector(id=eid, queue=queue, registration=reg, 
                                     control=control, heartbeat=heart)
         self.by_ident[queue] = eid
         self.queues[eid] = list()
         self.tasks[eid] = list()
         self.completed[eid] = list()
         self.hearts[heart] = eid
         content = dict(id=eid, queue=self.engines[eid].queue)
         if self.notifier:
             self.session.send(self.notifier, "registration_notification", content=content)
     
     def _purge_stalled_registration(self, heart):
         if heart in self.incoming_registrations:
             eid = self.incoming_registrations.pop(heart)[0]
-            logger.info("registration::purging stalled registration: %i"%eid)
+            logging.info("registration::purging stalled registration: %i"%eid)
         else:
             pass
             
     #-------------------------------------------------------------------------
     # Client Requests
     #-------------------------------------------------------------------------
     
     def shutdown_request(self, client_id, msg):
         """handle shutdown request."""
         # s = self.context.socket(zmq.XREQ)
         # s.connect(self.client_connections['mux'])
         # time.sleep(0.1)
         # for eid,ec in self.engines.iteritems():
         #     self.session.send(s, 'shutdown_request', content=dict(restart=False), ident=ec.queue)
         # time.sleep(1)
         self.session.send(self.clientele, 'shutdown_reply', content={'status': 'ok'}, ident=client_id)
         dc = ioloop.DelayedCallback(lambda : self._shutdown(), 1000, self.loop)
         dc.start()
     
     def _shutdown(self):
-        logger.info("controller::controller shutting down.")
+        logging.info("hub::hub shutting down.")
         time.sleep(0.1)
         sys.exit(0)
         
     
     def check_load(self, client_id, msg):
         content = msg['content']
         try:
             targets = content['targets']
             targets = self._validate_targets(targets)
         except:
             content = wrap_exception()
-            self.session.send(self.clientele, "controller_error", 
+            self.session.send(self.clientele, "hub_error", 
                     content=content, ident=client_id)
             return
         
         content = dict(status='ok')
         # loads = {}
         for t in targets:
             content[bytes(t)] = len(self.queues[t])+len(self.tasks[t])
         self.session.send(self.clientele, "load_reply", content=content, ident=client_id)
             
     
     def queue_status(self, client_id, msg):
         """Return the Queue status of one or more targets.
         if verbose: return the msg_ids
         else: return len of each type.
         keys: queue (pending MUX jobs)
             tasks (pending Task jobs)
             completed (finished jobs from both queues)"""
         content = msg['content']
         targets = content['targets']
         try:
             targets = self._validate_targets(targets)
         except:
             content = wrap_exception()
-            self.session.send(self.clientele, "controller_error", 
+            self.session.send(self.clientele, "hub_error", 
                     content=content, ident=client_id)
             return
         verbose = content.get('verbose', False)
         content = dict(status='ok')
         for t in targets:
             queue = self.queues[t]
             completed = self.completed[t]
             tasks = self.tasks[t]
             if not verbose:
                 queue = len(queue)
                 completed = len(completed)
                 tasks = len(tasks)
             content[bytes(t)] = {'queue': queue, 'completed': completed , 'tasks': tasks}
             # pending
         self.session.send(self.clientele, "queue_reply", content=content, ident=client_id)
     
     def purge_results(self, client_id, msg):
         """Purge results from memory. This method is more valuable before we move
         to a DB based message storage mechanism."""
         content = msg['content']
         msg_ids = content.get('msg_ids', [])
         reply = dict(status='ok')
         if msg_ids == 'all':
             self.db.drop_matching_records(dict(completed={'$ne':None}))
         else:
             for msg_id in msg_ids:
                 if msg_id in self.all_completed:
                     self.db.drop_record(msg_id)
                 else:
                     if msg_id in self.pending:
                         try:
                             raise IndexError("msg pending: %r"%msg_id)
                         except:
                             reply = wrap_exception()
                     else:
                         try:
                             raise IndexError("No such msg: %r"%msg_id)
                         except:
                             reply = wrap_exception()
                     break
             eids = content.get('engine_ids', [])
             for eid in eids:
                 if eid not in self.engines:
                     try:
                         raise IndexError("No such engine: %i"%eid)
                     except:
                         reply = wrap_exception()
                     break
                 msg_ids = self.completed.pop(eid)
                 uid = self.engines[eid].queue
                 self.db.drop_matching_records(dict(engine_uuid=uid, completed={'$ne':None}))
         
         self.session.send(self.clientele, 'purge_reply', content=reply, ident=client_id)
     
     def resubmit_task(self, client_id, msg, buffers):
         """Resubmit a task."""
         raise NotImplementedError
     
     def get_results(self, client_id, msg):
         """Get the result of 1 or more messages."""
         content = msg['content']
         msg_ids = sorted(set(content['msg_ids']))
         statusonly = content.get('status_only', False)
         pending = []
         completed = []
         content = dict(status='ok')
         content['pending'] = pending
         content['completed'] = completed
         buffers = []
         if not statusonly:
             content['results'] = {}
             records = self.db.find_records(dict(msg_id={'$in':msg_ids}))
         for msg_id in msg_ids:
             if msg_id in self.pending:
                 pending.append(msg_id)
             elif msg_id in self.all_completed:
                 completed.append(msg_id)
                 if not statusonly:
                     rec = records[msg_id]
                     io_dict = {}
                     for key in 'pyin pyout pyerr stdout stderr'.split():
                             io_dict[key] = rec[key]
                     content[msg_id] = { 'result_content': rec['result_content'],
                                         'header': rec['header'],
                                         'result_header' : rec['result_header'],
                                         'io' : io_dict,
                                       }
                     buffers.extend(map(str, rec['result_buffers']))
             else:
                 try:
                     raise KeyError('No such message: '+msg_id)
                 except:
                     content = wrap_exception()
                 break
         self.session.send(self.clientele, "result_reply", content=content, 
                                             parent=msg, ident=client_id,
                                             buffers=buffers)
 

IPython/zmq/parallel/ipcluster.py

@@ -1,93 +1,88 b''
 #!/usr/bin/env python
 from __future__ import print_function
 import sys,os
 import time
 from subprocess import Popen, PIPE
 
-from entry_point import parse_url
-from controller import make_argument_parser
+from IPython.external.argparse import ArgumentParser, SUPPRESS
 
 def _filter_arg(flag, args):
     filtered = []
     if flag in args:
         filtered.append(flag)
         idx = args.index(flag)
         if len(args) > idx+1:
             if not args[idx+1].startswith('-'):
                 filtered.append(args[idx+1])
     return filtered
 
 def filter_args(flags, args=sys.argv[1:]):
     filtered = []
     for flag in flags:
         if isinstance(flag, (list,tuple)):
             for f in flag:
                 filtered.extend(_filter_arg(f, args))
         else:
             filtered.extend(_filter_arg(flag, args))
     return filtered
 
 def _strip_arg(flag, args):
     while flag in args:
         idx = args.index(flag)
         args.pop(idx)
         if len(args) > idx:
             if not args[idx].startswith('-'):
                 args.pop(idx)
 
 def strip_args(flags, args=sys.argv[1:]):
     args = list(args)
     for flag in flags:
         if isinstance(flag, (list,tuple)):
             for f in flag:
                 _strip_arg(f, args)
         else:
             _strip_arg(flag, args)
     return args
     
 
 def launch_process(mod, args):
     """Launch a controller or engine in a subprocess."""
-    code = "from IPython.zmq.parallel.%s import main;main()"%mod
+    code = "from IPython.zmq.parallel.%s import launch_new_instance;launch_new_instance()"%mod
     arguments = [ sys.executable, '-c', code ] + args
     blackholew = file(os.devnull, 'w')
     blackholer = file(os.devnull, 'r')
     
     proc = Popen(arguments, stdin=blackholer, stdout=blackholew, stderr=PIPE)
     return proc
 
 def main():
-    parser = make_argument_parser()
+    parser = ArgumentParser(argument_default=SUPPRESS)
     parser.add_argument('--n', '-n', type=int, default=1,
                 help="The number of engines to start.")
-    args = parser.parse_args()
-    parse_url(args)
-
-    controller_args = strip_args([('--n','-n')])
-    engine_args = filter_args(['--url', '--regport', '--logport', '--ip', 
-                '--transport','--loglevel','--packer', '--execkey'])+['--ident']
+    ns,args = parser.parse_known_args()
+    n = ns.n
     
-    controller = launch_process('controller', controller_args)
+    controller = launch_process('ipcontrollerapp', args)
     for i in range(10):
         time.sleep(.1)
         if controller.poll() is not None:
             print("Controller failed to launch:")
             print (controller.stderr.read())
             sys.exit(255)
     
-    print("Launched Controller at %s"%args.url)
-    engines = [ launch_process('engine', engine_args+['engine-%i'%i]) for i in range(args.n) ]
-    print("%i Engines started"%args.n)
+    print("Launched Controller")
+    engines = [ launch_process('ipengineapp', args+['--ident', 'engine-%i'%i]) for i in range(n) ]
+    print("%i Engines started"%n)
     
     def wait_quietly(p):
         try:
             p.wait()
         except KeyboardInterrupt:
             pass
     
     wait_quietly(controller)
     map(wait_quietly, engines)
     print ("Engines cleaned up.")
 
 if __name__ == '__main__':
     main()
  No newline at end of file

IPython/zmq/parallel/mongodb.py

@@ -1,60 +1,61 b''
 """A TaskRecord backend using mongodb"""
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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.
 #-----------------------------------------------------------------------------
 
 from datetime import datetime
 
 from pymongo import Connection
 
+from dictdb import BaseDB
 #----------------------
 # MongoDB class
 #----------------------
-class MongoDB(object):
+class MongoDB(BaseDB):
     """MongoDB TaskRecord backend."""
     def __init__(self, session_uuid, *args, **kwargs):
         self._connection = Connection(*args, **kwargs)
         self._db = self._connection[session_uuid]
         self._records = self._db['task_records']
         self._table = {}
     
     
     def add_record(self, msg_id, rec):
         """Add a new Task Record, by msg_id."""
         # print rec
         obj_id = self._records.insert(rec)
         self._table[msg_id] = obj_id
     
     def get_record(self, msg_id):
         """Get a specific Task Record, by msg_id."""
         return self._records.find_one(self._table[msg_id])
     
     def update_record(self, msg_id, rec):
         """Update the data in an existing record."""
         obj_id = self._table[msg_id]
         self._records.update({'_id':obj_id}, {'$set': rec})
     
     def drop_matching_records(self, check):
         """Remove a record from the DB."""
         self._records.remove(check)
         
     def drop_record(self, msg_id):
         """Remove a record from the DB."""
         obj_id = self._table.pop(msg_id)
         self._records.remove(obj_id)
     
     def find_records(self, check, id_only=False):
         """Find records matching a query dict."""
         matches = list(self._records.find(check))
         if id_only:
             return [ rec['msg_id'] for rec in matches ]
         else:
             data = {}
             for rec in matches:
                 data[rec['msg_id']] = rec
             return data
 
 

IPython/zmq/parallel/scheduler.py

@@ -1,434 +1,426 b''
 """The Python scheduler for rich scheduling.
 
 The Pure ZMQ scheduler does not allow routing schemes other than LRU,
 nor does it check msg_id DAG dependencies. For those, a slightly slower
 Python Scheduler exists.
 """
 
 #----------------------------------------------------------------------
 # Imports
 #----------------------------------------------------------------------
 
 from __future__ import print_function
 from random import randint,random
 import logging
 from types import FunctionType
 
 try:
     import numpy
 except ImportError:
     numpy = None
 
 import zmq
 from zmq.eventloop import ioloop, zmqstream
 
 # local imports
 from IPython.external.decorator import decorator
 from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Instance
+from IPython.utils.traitlets import Instance, Dict, List, Set
 
 from client import Client
 from dependency import Dependency
 import streamsession as ss
 from entry_point import connect_logger, local_logger
 
 
-logger = logging.getLogger()
-
 @decorator
 def logged(f,self,*args,**kwargs):
     # print ("#--------------------")
-    logger.debug("scheduler::%s(*%s,**%s)"%(f.func_name, args, kwargs))
+    logging.debug("scheduler::%s(*%s,**%s)"%(f.func_name, args, kwargs))
     # print ("#--")
     return f(self,*args, **kwargs)
 
 #----------------------------------------------------------------------
 # Chooser functions
 #----------------------------------------------------------------------
 
 def plainrandom(loads):
     """Plain random pick."""
     n = len(loads)
     return randint(0,n-1)
 
 def lru(loads):
     """Always pick the front of the line.
     
     The content of `loads` is ignored.
     
     Assumes LRU ordering of loads, with oldest first.
     """
     return 0
 
 def twobin(loads):
     """Pick two at random, use the LRU of the two.
     
     The content of loads is ignored.
     
     Assumes LRU ordering of loads, with oldest first.
     """
     n = len(loads)
     a = randint(0,n-1)
     b = randint(0,n-1)
     return min(a,b)
 
 def weighted(loads):
     """Pick two at random using inverse load as weight.
     
     Return the less loaded of the two.
     """
     # weight 0 a million times more than 1:
     weights = 1./(1e-6+numpy.array(loads))
     sums = weights.cumsum()
     t = sums[-1]
     x = random()*t
     y = random()*t
     idx = 0
     idy = 0
     while sums[idx] < x:
         idx += 1
     while sums[idy] < y:
         idy += 1
     if weights[idy] > weights[idx]:
         return idy
     else:
         return idx
 
 def leastload(loads):
     """Always choose the lowest load.
     
     If the lowest load occurs more than once, the first
     occurance will be used.  If loads has LRU ordering, this means
     the LRU of those with the lowest load is chosen.
     """
     return loads.index(min(loads))
 
 #---------------------------------------------------------------------
 # Classes
 #---------------------------------------------------------------------
 class TaskScheduler(Configurable):
     """Python TaskScheduler object.
     
     This is the simplest object that supports msg_id based
     DAG dependencies. *Only* task msg_ids are checked, not
     msg_ids of jobs submitted via the MUX queue.
     
     """
     
-    # configurables:
+    # input arguments:
     scheme = Instance(FunctionType, default=leastload) # function for determining the destination
     client_stream = Instance(zmqstream.ZMQStream) # client-facing stream
     engine_stream = Instance(zmqstream.ZMQStream) # engine-facing stream
     notifier_stream = Instance(zmqstream.ZMQStream) # hub-facing sub stream
     mon_stream = Instance(zmqstream.ZMQStream) # hub-facing pub stream
     io_loop = Instance(ioloop.IOLoop)
     
     # internals:
-    dependencies = None # dict by msg_id of [ msg_ids that depend on key ]
-    depending = None # dict by msg_id of (msg_id, raw_msg, after, follow)
-    pending = None # dict by engine_uuid of submitted tasks
-    completed = None # dict by engine_uuid of completed tasks
-    clients = None # dict by msg_id for who submitted the task
-    targets = None # list of target IDENTs
-    loads = None # list of engine loads
-    all_done = None # set of all completed tasks
-    blacklist = None # dict by msg_id of locations where a job has encountered UnmetDependency
+    dependencies = Dict() # dict by msg_id of [ msg_ids that depend on key ]
+    depending = Dict() # dict by msg_id of (msg_id, raw_msg, after, follow)
+    pending = Dict() # dict by engine_uuid of submitted tasks
+    completed = Dict() # dict by engine_uuid of completed tasks
+    clients = Dict() # dict by msg_id for who submitted the task
+    targets = List() # list of target IDENTs
+    loads = List() # list of engine loads
+    all_done = Set() # set of all completed tasks
+    blacklist = Dict() # dict by msg_id of locations where a job has encountered UnmetDependency
+    session = Instance(ss.StreamSession)
     
     
     def __init__(self, **kwargs):
         super(TaskScheduler, self).__init__(**kwargs)
         
         self.session = ss.StreamSession(username="TaskScheduler")
-        self.dependencies = {}
-        self.depending = {}
-        self.completed = {}
-        self.pending = {}
-        self.all_done = set()
-        self.blacklist = {}
-        
-        self.targets = []
-        self.loads = []
         
         self.engine_stream.on_recv(self.dispatch_result, copy=False)
         self._notification_handlers = dict(
             registration_notification = self._register_engine,
             unregistration_notification = self._unregister_engine
         )
         self.notifier_stream.on_recv(self.dispatch_notification)
-        logger.info("Scheduler started...%r"%self)
+        logging.info("Scheduler started...%r"%self)
     
     def resume_receiving(self):
         """Resume accepting jobs."""
         self.client_stream.on_recv(self.dispatch_submission, copy=False)
     
     def stop_receiving(self):
         """Stop accepting jobs while there are no engines.
         Leave them in the ZMQ queue."""
         self.client_stream.on_recv(None)
     
     #-----------------------------------------------------------------------
     # [Un]Registration Handling
     #-----------------------------------------------------------------------
     
     def dispatch_notification(self, msg):
         """dispatch register/unregister events."""
         idents,msg = self.session.feed_identities(msg)
         msg = self.session.unpack_message(msg)
         msg_type = msg['msg_type']
         handler = self._notification_handlers.get(msg_type, None)
         if handler is None:
             raise Exception("Unhandled message type: %s"%msg_type)
         else:
             try:
                 handler(str(msg['content']['queue']))
             except KeyError:
-                logger.error("task::Invalid notification msg: %s"%msg)
+                logging.error("task::Invalid notification msg: %s"%msg)
     
     @logged
     def _register_engine(self, uid):
         """New engine with ident `uid` became available."""
         # head of the line:
         self.targets.insert(0,uid)
         self.loads.insert(0,0)
         # initialize sets
         self.completed[uid] = set()
         self.pending[uid] = {}
         if len(self.targets) == 1:
             self.resume_receiving()
 
     def _unregister_engine(self, uid):
         """Existing engine with ident `uid` became unavailable."""
         if len(self.targets) == 1:
             # this was our only engine
             self.stop_receiving()
         
         # handle any potentially finished tasks:
         self.engine_stream.flush()
         
         self.completed.pop(uid)
         lost = self.pending.pop(uid)
         
         idx = self.targets.index(uid)
         self.targets.pop(idx)
         self.loads.pop(idx)
         
         self.handle_stranded_tasks(lost)
     
     def handle_stranded_tasks(self, lost):
         """Deal with jobs resident in an engine that died."""
         # TODO: resubmit the tasks?
         for msg_id in lost:
             pass
     
     
     #-----------------------------------------------------------------------
     # Job Submission
     #-----------------------------------------------------------------------
     @logged
     def dispatch_submission(self, raw_msg):
         """Dispatch job submission to appropriate handlers."""
         # ensure targets up to date:
         self.notifier_stream.flush()
         try:
             idents, msg = self.session.feed_identities(raw_msg, copy=False)
         except Exception as e:
-            logger.error("task::Invaid msg: %s"%msg)
+            logging.error("task::Invaid msg: %s"%msg)
             return
         
         # send to monitor
         self.mon_stream.send_multipart(['intask']+raw_msg, copy=False)
         
         msg = self.session.unpack_message(msg, content=False, copy=False)
         header = msg['header']
         msg_id = header['msg_id']
         
         # time dependencies
         after = Dependency(header.get('after', []))
         if after.mode == 'all':
             after.difference_update(self.all_done)
         if after.check(self.all_done):
             # recast as empty set, if `after` already met,
             # to prevent unnecessary set comparisons
             after = Dependency([])
         
         # location dependencies
         follow = Dependency(header.get('follow', []))
         if len(after) == 0:
             # time deps already met, try to run
             if not self.maybe_run(msg_id, raw_msg, follow):
                 # can't run yet
                 self.save_unmet(msg_id, raw_msg, after, follow)
         else:
             self.save_unmet(msg_id, raw_msg, after, follow)
     
     @logged
     def maybe_run(self, msg_id, raw_msg, follow=None):
         """check location dependencies, and run if they are met."""
             
         if follow:
             def can_run(idx):
                 target = self.targets[idx]
                 return target not in self.blacklist.get(msg_id, []) and\
                         follow.check(self.completed[target])
             
             indices = filter(can_run, range(len(self.targets)))
             if not indices:
                 return False
         else:
             indices = None
             
         self.submit_task(msg_id, raw_msg, indices)
         return True
             
     @logged
     def save_unmet(self, msg_id, msg, after, follow):
         """Save a message for later submission when its dependencies are met."""
         self.depending[msg_id] = (msg_id,msg,after,follow)
         # track the ids in both follow/after, but not those already completed
         for dep_id in after.union(follow).difference(self.all_done):
             if dep_id not in self.dependencies:
                 self.dependencies[dep_id] = set()
             self.dependencies[dep_id].add(msg_id)
     
     @logged
     def submit_task(self, msg_id, msg, follow=None, indices=None):
         """Submit a task to any of a subset of our targets."""
         if indices:
             loads = [self.loads[i] for i in indices]
         else:
             loads = self.loads
         idx = self.scheme(loads)
         if indices:
             idx = indices[idx]
         target = self.targets[idx]
         # print (target, map(str, msg[:3]))
         self.engine_stream.send(target, flags=zmq.SNDMORE, copy=False)
         self.engine_stream.send_multipart(msg, copy=False)
         self.add_job(idx)
         self.pending[target][msg_id] = (msg, follow)
         content = dict(msg_id=msg_id, engine_id=target)
         self.session.send(self.mon_stream, 'task_destination', content=content, 
                         ident=['tracktask',self.session.session])
     
     #-----------------------------------------------------------------------
     # Result Handling
     #-----------------------------------------------------------------------
     @logged
     def dispatch_result(self, raw_msg):
         try:
             idents,msg = self.session.feed_identities(raw_msg, copy=False)
         except Exception as e:
-            logger.error("task::Invaid result: %s"%msg)
+            logging.error("task::Invaid result: %s"%msg)
             return
         msg = self.session.unpack_message(msg, content=False, copy=False)
         header = msg['header']
         if header.get('dependencies_met', True):
             self.handle_result_success(idents, msg['parent_header'], raw_msg)
             # send to monitor
             self.mon_stream.send_multipart(['outtask']+raw_msg, copy=False)
         else:
             self.handle_unmet_dependency(idents, msg['parent_header'])
         
     @logged
     def handle_result_success(self, idents, parent, raw_msg):
         # first, relay result to client
         engine = idents[0]
         client = idents[1]
         # swap_ids for XREP-XREP mirror
         raw_msg[:2] = [client,engine]
         # print (map(str, raw_msg[:4]))
         self.client_stream.send_multipart(raw_msg, copy=False)
         # now, update our data structures
         msg_id = parent['msg_id']
         self.pending[engine].pop(msg_id)
         self.completed[engine].add(msg_id)
         self.all_done.add(msg_id)
         
         self.update_dependencies(msg_id)
         
     @logged
     def handle_unmet_dependency(self, idents, parent):
         engine = idents[0]
         msg_id = parent['msg_id']
         if msg_id not in self.blacklist:
             self.blacklist[msg_id] = set()
         self.blacklist[msg_id].add(engine)
         raw_msg,follow = self.pending[engine].pop(msg_id)
         if not self.maybe_run(msg_id, raw_msg, follow):
             # resubmit failed, put it back in our dependency tree
             self.save_unmet(msg_id, raw_msg, Dependency(), follow)
         pass
     @logged
     def update_dependencies(self, dep_id):
         """dep_id just finished. Update our dependency
         table and submit any jobs that just became runable."""
         
         if dep_id not in self.dependencies:
             return
         jobs = self.dependencies.pop(dep_id)
         for job in jobs:
             msg_id, raw_msg, after, follow = self.depending[job]
             if dep_id in after:
                 after.remove(dep_id)
             if not after: # time deps met, maybe run
                 if self.maybe_run(msg_id, raw_msg, follow):
                     self.depending.pop(job)
                     for mid in follow:
                         if mid in self.dependencies:
                             self.dependencies[mid].remove(msg_id)
     
     #----------------------------------------------------------------------
     # methods to be overridden by subclasses
     #----------------------------------------------------------------------
     
     def add_job(self, idx):
         """Called after self.targets[idx] just got the job with header.
         Override with subclasses.  The default ordering is simple LRU.
         The default loads are the number of outstanding jobs."""
         self.loads[idx] += 1
         for lis in (self.targets, self.loads):
             lis.append(lis.pop(idx))
             
     
     def finish_job(self, idx):
         """Called after self.targets[idx] just finished a job.
         Override with subclasses."""
         self.loads[idx] -= 1
     
 
 
 def launch_scheduler(in_addr, out_addr, mon_addr, not_addr, log_addr=None, loglevel=logging.DEBUG, scheme='weighted'):
     from zmq.eventloop import ioloop
     from zmq.eventloop.zmqstream import ZMQStream
     
     ctx = zmq.Context()
     loop = ioloop.IOLoop()
     
-    scheme = globals().get(scheme)
-    
     ins = ZMQStream(ctx.socket(zmq.XREP),loop)
     ins.bind(in_addr)
     outs = ZMQStream(ctx.socket(zmq.XREP),loop)
     outs.bind(out_addr)
     mons = ZMQStream(ctx.socket(zmq.PUB),loop)
     mons.connect(mon_addr)
     nots = ZMQStream(ctx.socket(zmq.SUB),loop)
     nots.setsockopt(zmq.SUBSCRIBE, '')
     nots.connect(not_addr)
     
+    scheme = globals().get(scheme, None)
     # setup logging
     if log_addr:
         connect_logger(ctx, log_addr, root="scheduler", loglevel=loglevel)
     else:
         local_logger(loglevel)
     
     scheduler = TaskScheduler(client_stream=ins, engine_stream=outs,
                             mon_stream=mons,notifier_stream=nots,
                             scheme=scheme,io_loop=loop)
     
-    loop.start()
+    try:
+        loop.start()
+    except KeyboardInterrupt:
+        print ("interrupted, exiting...", file=sys.__stderr__)
 
 
 if __name__ == '__main__':
     iface = 'tcp://127.0.0.1:%i'
     launch_scheduler(iface%12345,iface%1236,iface%12347,iface%12348)

IPython/zmq/parallel/streamkernel.py

@@ -1,461 +1,490 b''
 #!/usr/bin/env python
 """
 Kernel adapted from kernel.py to use ZMQ Streams
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 from __future__ import print_function
 import __builtin__
 from code import CommandCompiler
 import os
 import sys
 import time
 import traceback
 import logging
 from datetime import datetime
 from signal import SIGTERM, SIGKILL
 from pprint import pprint
 
 # System library imports.
 import zmq
 from zmq.eventloop import ioloop, zmqstream
 
 # Local imports.
 from IPython.core import ultratb
-from IPython.utils.traitlets import HasTraits, Instance, List, Int
+from IPython.utils.traitlets import HasTraits, Instance, List, Int, Dict, Set, Str
 from IPython.zmq.completer import KernelCompleter
 from IPython.zmq.iostream import OutStream
 from IPython.zmq.displayhook import DisplayHook
 
-
+from factory import SessionFactory
 from streamsession import StreamSession, Message, extract_header, serialize_object,\
                 unpack_apply_message, ISO8601, wrap_exception
 from dependency import UnmetDependency
 import heartmonitor
 from client import Client
 
-logger = logging.getLogger()
-
 def printer(*args):
     pprint(args, stream=sys.__stdout__)
 
+
+class _Passer:
+    """Empty class that implements `send()` that does nothing."""
+    def send(self, *args, **kwargs):
+        pass
+    send_multipart = send
+    
+
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
-class Kernel(HasTraits):
+class Kernel(SessionFactory):
 
     #---------------------------------------------------------------------------
     # Kernel interface
     #---------------------------------------------------------------------------
-
-    id = Int(-1)
-    session = Instance(StreamSession)
-    shell_streams = List()
+    
+    # kwargs:
+    int_id = Int(-1, config=True)
+    user_ns = Dict(config=True)
+    exec_lines = List(config=True)
+    
     control_stream = Instance(zmqstream.ZMQStream)
     task_stream = Instance(zmqstream.ZMQStream)
     iopub_stream = Instance(zmqstream.ZMQStream)
-    client = Instance(Client)
-    loop = Instance(ioloop.IOLoop)
+    client = Instance('IPython.zmq.parallel.client.Client')
+    
+    # internals
+    shell_streams = List()
+    compiler = Instance(CommandCompiler, (), {})
+    completer = Instance(KernelCompleter)
+    
+    aborted = Set()
+    shell_handlers = Dict()
+    control_handlers = Dict()
+    
+    def _set_prefix(self):
+        self.prefix = "engine.%s"%self.int_id
+    
+    def _connect_completer(self):
+        self.completer = KernelCompleter(self.user_ns)
     
     def __init__(self, **kwargs):
         super(Kernel, self).__init__(**kwargs)
-        self.identity = self.shell_streams[0].getsockopt(zmq.IDENTITY)
-        self.prefix = 'engine.%s'%self.id
-        logger.root_topic = self.prefix
-        self.user_ns = {}
-        self.history = []
-        self.compiler = CommandCompiler()
-        self.completer = KernelCompleter(self.user_ns)
-        self.aborted = set()
+        self._set_prefix()
+        self._connect_completer()
+        
+        self.on_trait_change(self._set_prefix, 'id')
+        self.on_trait_change(self._connect_completer, 'user_ns')
         
         # Build dict of handlers for message types
-        self.shell_handlers = {}
-        self.control_handlers = {}
         for msg_type in ['execute_request', 'complete_request', 'apply_request', 
                 'clear_request']:
             self.shell_handlers[msg_type] = getattr(self, msg_type)
         
         for msg_type in ['shutdown_request', 'abort_request']+self.shell_handlers.keys():
             self.control_handlers[msg_type] = getattr(self, msg_type)
-    
+        
+        self._initial_exec_lines()
     
     def _wrap_exception(self, method=None):
-        e_info = dict(engineid=self.identity, method=method)
+        e_info = dict(engineid=self.ident, method=method)
         content=wrap_exception(e_info)
         return content
     
+    def _initial_exec_lines(self):
+        s = _Passer()
+        content = dict(silent=True, user_variable=[],user_expressions=[])
+        for line in self.exec_lines:
+            logging.debug("executing initialization: %s"%line)
+            content.update({'code':line})
+            msg = self.session.msg('execute_request', content)
+            self.execute_request(s, [], msg)
+        
+        
     #-------------------- control handlers -----------------------------
     def abort_queues(self):
         for stream in self.shell_streams:
             if stream:
                 self.abort_queue(stream)
     
     def abort_queue(self, stream):
         while True:
             try:
                 msg = self.session.recv(stream, zmq.NOBLOCK,content=True)
             except zmq.ZMQError as e:
                 if e.errno == zmq.EAGAIN:
                     break
                 else:
                     return
             else:
                 if msg is None:
                     return
                 else:
                     idents,msg = msg
                 
                 # assert self.reply_socketly_socket.rcvmore(), "Unexpected missing message part."
                 # msg = self.reply_socket.recv_json()
-            logger.info("Aborting:")
-            logger.info(str(msg))
+            logging.info("Aborting:")
+            logging.info(str(msg))
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             # reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
             # self.reply_socket.send(ident,zmq.SNDMORE)
             # self.reply_socket.send_json(reply_msg)
             reply_msg = self.session.send(stream, reply_type, 
                         content={'status' : 'aborted'}, parent=msg, ident=idents)[0]
-            logger.debug(str(reply_msg))
+            logging.debug(str(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.05)
     
     def abort_request(self, stream, ident, parent):
         """abort a specifig msg by id"""
         msg_ids = parent['content'].get('msg_ids', None)
         if isinstance(msg_ids, basestring):
             msg_ids = [msg_ids]
         if not msg_ids:
             self.abort_queues()
         for mid in msg_ids:
             self.aborted.add(str(mid))
         
         content = dict(status='ok')
         reply_msg = self.session.send(stream, 'abort_reply', content=content, 
                 parent=parent, ident=ident)[0]
-        logger(Message(reply_msg), file=sys.__stdout__)
+        logging.debug(str(reply_msg))
     
     def shutdown_request(self, stream, ident, parent):
         """kill ourself.  This should really be handled in an external process"""
         try:
             self.abort_queues()
         except:
             content = self._wrap_exception('shutdown')
         else:
             content = dict(parent['content'])
             content['status'] = 'ok'
         msg = self.session.send(stream, 'shutdown_reply',
                                 content=content, parent=parent, ident=ident)
         # msg = self.session.send(self.pub_socket, 'shutdown_reply',
         #                         content, parent, ident)
         # print >> sys.__stdout__, msg
         # time.sleep(0.2)
         dc = ioloop.DelayedCallback(lambda : sys.exit(0), 1000, self.loop)
         dc.start()
     
     def dispatch_control(self, msg):
         idents,msg = self.session.feed_identities(msg, copy=False)
         try:
             msg = self.session.unpack_message(msg, content=True, copy=False)
         except:
-            logger.error("Invalid Message", exc_info=True)
+            logging.error("Invalid Message", exc_info=True)
             return
         
         header = msg['header']
         msg_id = header['msg_id']
         
         handler = self.control_handlers.get(msg['msg_type'], None)
         if handler is None:
-            logger.error("UNKNOWN CONTROL MESSAGE TYPE: %r"%msg['msg_type'])
+            logging.error("UNKNOWN CONTROL MESSAGE TYPE: %r"%msg['msg_type'])
         else:
             handler(self.control_stream, idents, msg)
     
 
     #-------------------- queue helpers ------------------------------
     
     def check_dependencies(self, dependencies):
         if not dependencies:
             return True
         if len(dependencies) == 2 and dependencies[0] in 'any all'.split():
             anyorall = dependencies[0]
             dependencies = dependencies[1]
         else:
             anyorall = 'all'
         results = self.client.get_results(dependencies,status_only=True)
         if results['status'] != 'ok':
             return False
         
         if anyorall == 'any':
             if not results['completed']:
                 return False
         else:
             if results['pending']:
                 return False
         
         return True
     
     def check_aborted(self, msg_id):
         return msg_id in self.aborted
     
     #-------------------- queue handlers -----------------------------
     
     def clear_request(self, stream, idents, parent):
         """Clear our namespace."""
         self.user_ns = {}
         msg = self.session.send(stream, 'clear_reply', ident=idents, parent=parent, 
                 content = dict(status='ok'))
+        self._initial_exec_lines()
     
     def execute_request(self, stream, ident, parent):
+        logging.debug('execute request %s'%parent)
         try:
             code = parent[u'content'][u'code']
         except:
-            logger.error("Got bad msg: %s"%parent, exc_info=True)
+            logging.error("Got bad msg: %s"%parent, exc_info=True)
             return
-        # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
-        # self.iopub_stream.send(pyin_msg)
         self.session.send(self.iopub_stream, u'pyin', {u'code':code},parent=parent,
                             ident='%s.pyin'%self.prefix)
         started = datetime.now().strftime(ISO8601)
         try:
             comp_code = self.compiler(code, '<zmq-kernel>')
             # allow for not overriding displayhook
             if hasattr(sys.displayhook, 'set_parent'):
                 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:
             exc_content = self._wrap_exception('execute')
             # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.session.send(self.iopub_stream, u'pyerr', exc_content, parent=parent,
                             ident='%s.pyerr'%self.prefix)
             reply_content = exc_content
         else:
             reply_content = {'status' : 'ok'}
         # reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         # self.reply_socket.send(ident, zmq.SNDMORE)
         # self.reply_socket.send_json(reply_msg)
         reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent=parent, 
                     ident=ident, subheader = dict(started=started))
-        logger.debug(str(reply_msg))
+        logging.debug(str(reply_msg))
         if reply_msg['content']['status'] == u'error':
             self.abort_queues()
 
     def complete_request(self, stream, ident, parent):
         matches = {'matches' : self.complete(parent),
                    'status' : 'ok'}
         completion_msg = self.session.send(stream, 'complete_reply',
                                            matches, parent, ident)
         # print >> sys.__stdout__, completion_msg
 
     def complete(self, msg):
         return self.completer.complete(msg.content.line, msg.content.text)
     
     def apply_request(self, stream, ident, parent):
         # print (parent)
         try:
             content = parent[u'content']
             bufs = parent[u'buffers']
             msg_id = parent['header']['msg_id']
             bound = content.get('bound', False)
         except:
-            logger.error("Got bad msg: %s"%parent, exc_info=True)
+            logging.error("Got bad msg: %s"%parent, exc_info=True)
             return
         # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
         # self.iopub_stream.send(pyin_msg)
         # self.session.send(self.iopub_stream, u'pyin', {u'code':code},parent=parent)
-        sub = {'dependencies_met' : True, 'engine' : self.identity,
+        sub = {'dependencies_met' : True, 'engine' : self.ident,
                 'started': datetime.now().strftime(ISO8601)}
         try:
             # allow for not overriding displayhook
             if hasattr(sys.displayhook, 'set_parent'):
                 sys.displayhook.set_parent(parent)
                 sys.stdout.set_parent(parent)
                 sys.stderr.set_parent(parent)
             # exec "f(*args,**kwargs)" in self.user_ns, self.user_ns
             if bound:
                 working = self.user_ns
                 suffix = str(msg_id).replace("-","")
                 prefix = "_"
                 
             else:
                 working = dict()
                 suffix = prefix = "_" # prevent keyword collisions with lambda
             f,args,kwargs = unpack_apply_message(bufs, working, copy=False)
             # if f.fun
             if hasattr(f, 'func_name'):
                 fname = f.func_name
             else:
                 fname = f.__name__
             
             fname = prefix+fname.strip('<>')+suffix
             argname = prefix+"args"+suffix
             kwargname = prefix+"kwargs"+suffix
             resultname = prefix+"result"+suffix
             
             ns = { fname : f, argname : args, kwargname : kwargs }
             # print ns
             working.update(ns)
             code = "%s=%s(*%s,**%s)"%(resultname, fname, argname, kwargname)
             exec code in working, working
             result = working.get(resultname)
             # clear the namespace
             if bound:
                 for key in ns.iterkeys():
                     self.user_ns.pop(key)
             else:
                 del working
             
             packed_result,buf = serialize_object(result)
             result_buf = [packed_result]+buf
         except:
             exc_content = self._wrap_exception('apply')
             # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.session.send(self.iopub_stream, u'pyerr', exc_content, parent=parent,
                                 ident='%s.pyerr'%self.prefix)
             reply_content = exc_content
             result_buf = []
             
             if exc_content['ename'] == UnmetDependency.__name__:
                 sub['dependencies_met'] = False
         else:
             reply_content = {'status' : 'ok'}
         # reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         # self.reply_socket.send(ident, zmq.SNDMORE)
         # self.reply_socket.send_json(reply_msg)
         reply_msg = self.session.send(stream, u'apply_reply', reply_content, 
                     parent=parent, ident=ident,buffers=result_buf, subheader=sub)
         # print(Message(reply_msg), file=sys.__stdout__)
         # if reply_msg['content']['status'] == u'error':
         #     self.abort_queues()
     
     def dispatch_queue(self, stream, msg):
         self.control_stream.flush()
         idents,msg = self.session.feed_identities(msg, copy=False)
         try:
             msg = self.session.unpack_message(msg, content=True, copy=False)
         except:
-            logger.error("Invalid Message", exc_info=True)
+            logging.error("Invalid Message", exc_info=True)
             return
             
         
         header = msg['header']
         msg_id = header['msg_id']
         if self.check_aborted(msg_id):
             self.aborted.remove(msg_id)
             # is it safe to assume a msg_id will not be resubmitted?
             reply_type = msg['msg_type'].split('_')[0] + '_reply'
             reply_msg = self.session.send(stream, reply_type, 
                         content={'status' : 'aborted'}, parent=msg, ident=idents)
             return
         handler = self.shell_handlers.get(msg['msg_type'], None)
         if handler is None:
-            logger.error("UNKNOWN MESSAGE TYPE: %r"%msg['msg_type'])
+            logging.error("UNKNOWN MESSAGE TYPE: %r"%msg['msg_type'])
         else:
             handler(stream, idents, msg)
     
     def start(self):
         #### stream mode:
         if self.control_stream:
             self.control_stream.on_recv(self.dispatch_control, copy=False)
             self.control_stream.on_err(printer)
         
         def make_dispatcher(stream):
             def dispatcher(msg):
                 return self.dispatch_queue(stream, msg)
             return dispatcher
         
         for s in self.shell_streams:
+            # s.on_recv(printer)
             s.on_recv(make_dispatcher(s), copy=False)
-            s.on_err(printer)
+            # s.on_err(printer)
         
         if self.iopub_stream:
             self.iopub_stream.on_err(printer)
             # self.iopub_stream.on_send(printer)
         
         #### while True mode:
         # while True:
         #     idle = True
         #     try:
         #         msg = self.shell_stream.socket.recv_multipart(
         #                     zmq.NOBLOCK, copy=False)
         #     except zmq.ZMQError, e:
         #         if e.errno != zmq.EAGAIN:
         #             raise e
         #     else:
         #         idle=False
         #         self.dispatch_queue(self.shell_stream, msg)
         #             
         #     if not self.task_stream.empty():
         #         idle=False
         #         msg = self.task_stream.recv_multipart()
         #         self.dispatch_queue(self.task_stream, msg)
         #     if idle:
         #         # don't busywait
         #         time.sleep(1e-3)
 
 def make_kernel(int_id, identity, control_addr, shell_addrs, iopub_addr, hb_addrs, 
                 client_addr=None, loop=None, context=None, key=None,
                 out_stream_factory=OutStream, display_hook_factory=DisplayHook):
-    
+    """NO LONGER IN USE"""
     # create loop, context, and session:
     if loop is None:
         loop = ioloop.IOLoop.instance()
     if context is None:
         context = zmq.Context()
     c = context
     session = StreamSession(key=key)
     # print (session.key)
     # print (control_addr, shell_addrs, iopub_addr, hb_addrs)
     
     # create Control Stream
     control_stream = zmqstream.ZMQStream(c.socket(zmq.PAIR), loop)
     control_stream.setsockopt(zmq.IDENTITY, identity)
     control_stream.connect(control_addr)
     
     # create Shell Streams (MUX, Task, etc.):
     shell_streams = []
     for addr in shell_addrs:
         stream = zmqstream.ZMQStream(c.socket(zmq.PAIR), loop)
         stream.setsockopt(zmq.IDENTITY, identity)
         stream.connect(addr)
         shell_streams.append(stream)
     
     # create iopub stream:
     iopub_stream = zmqstream.ZMQStream(c.socket(zmq.PUB), loop)
     iopub_stream.setsockopt(zmq.IDENTITY, identity)
     iopub_stream.connect(iopub_addr)
     
     # Redirect input streams and set a display hook.
     if out_stream_factory:
         sys.stdout = out_stream_factory(session, iopub_stream, u'stdout')
         sys.stdout.topic = 'engine.%i.stdout'%int_id
         sys.stderr = out_stream_factory(session, iopub_stream, u'stderr')
         sys.stderr.topic = 'engine.%i.stderr'%int_id
     if display_hook_factory:
         sys.displayhook = display_hook_factory(session, iopub_stream)
         sys.displayhook.topic = 'engine.%i.pyout'%int_id
     
     
     # launch heartbeat
     heart = heartmonitor.Heart(*map(str, hb_addrs), heart_id=identity)
     heart.start()
     
     # create (optional) Client
     if client_addr:
         client = Client(client_addr, username=identity)
     else:
         client = None
     
-    kernel = Kernel(id=int_id, session=session, control_stream=control_stream, 
+    kernel = Kernel(id=int_id, session=session, control_stream=control_stream,
             shell_streams=shell_streams, iopub_stream=iopub_stream, 
             client=client, loop=loop)
     kernel.start()
     return loop, c, kernel
 

IPython/zmq/parallel/streamsession.py

@@ -1,543 +1,549 b''
 #!/usr/bin/env python
 """edited session.py to work with streams, and move msg_type to the header
 """
 
 
 import os
 import sys
 import traceback
 import pprint
 import uuid
 from datetime import datetime
 
 import zmq
 from zmq.utils import jsonapi
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.utils.pickleutil import can, uncan, canSequence, uncanSequence
 from IPython.utils.newserialized import serialize, unserialize
 
 from IPython.zmq.parallel.error import RemoteError
 
 try:
     import cPickle
     pickle = cPickle
 except:
     cPickle = None
     import pickle
 
 # packer priority: jsonlib[2], cPickle, simplejson/json, pickle
 json_name = '' if not jsonapi.jsonmod else jsonapi.jsonmod.__name__
 if json_name in ('jsonlib', 'jsonlib2'):
     use_json = True
 elif json_name:
     if cPickle is None:
         use_json = True
     else:
         use_json = False
 else:
     use_json = False
 
 def squash_unicode(obj):
     if isinstance(obj,dict):
         for key in obj.keys():
             obj[key] = squash_unicode(obj[key])
             if isinstance(key, unicode):
                 obj[squash_unicode(key)] = obj.pop(key)
     elif isinstance(obj, list):
         for i,v in enumerate(obj):
             obj[i] = squash_unicode(v)
     elif isinstance(obj, unicode):
         obj = obj.encode('utf8')
     return obj
 
+json_packer = jsonapi.dumps
+json_unpacker = lambda s: squash_unicode(jsonapi.loads(s))
+
+pickle_packer = lambda o: pickle.dumps(o,-1)
+pickle_unpacker = pickle.loads
+
 if use_json:
-    default_packer = jsonapi.dumps
-    default_unpacker = lambda s: squash_unicode(jsonapi.loads(s))
+    default_packer = json_packer
+    default_unpacker = json_unpacker
 else:
-    default_packer = lambda o: pickle.dumps(o,-1)
-    default_unpacker = pickle.loads
+    default_packer = pickle_packer
+    default_unpacker = pickle_unpacker
 
 
 DELIM="<IDS|MSG>"
 ISO8601="%Y-%m-%dT%H:%M:%S.%f"
 
 def wrap_exception(engine_info={}):
     etype, evalue, tb = sys.exc_info()
     stb = traceback.format_exception(etype, evalue, tb)
     exc_content = {
         'status' : 'error',
         'traceback' : stb,
         'ename' : unicode(etype.__name__),
         'evalue' : unicode(evalue),
         'engine_info' : engine_info
     }
     return exc_content
 
 def unwrap_exception(content):
     err = RemoteError(content['ename'], content['evalue'], 
                 ''.join(content['traceback']),
                 content.get('engine_info', {}))
     return err
     
 
 class Message(object):
     """A simple message object that maps dict keys to attributes.
 
     A Message can be created from a dict and a dict from a Message instance
     simply by calling dict(msg_obj)."""
     
     def __init__(self, msg_dict):
         dct = self.__dict__
         for k, v in dict(msg_dict).iteritems():
             if isinstance(v, dict):
                 v = Message(v)
             dct[k] = v
 
     # Having this iterator lets dict(msg_obj) work out of the box.
     def __iter__(self):
         return iter(self.__dict__.iteritems())
     
     def __repr__(self):
         return repr(self.__dict__)
 
     def __str__(self):
         return pprint.pformat(self.__dict__)
 
     def __contains__(self, k):
         return k in self.__dict__
 
     def __getitem__(self, k):
         return self.__dict__[k]
 
 
 def msg_header(msg_id, msg_type, username, session):
     date=datetime.now().strftime(ISO8601)
     return locals()
 
 def extract_header(msg_or_header):
     """Given a message or header, return the header."""
     if not msg_or_header:
         return {}
     try:
         # See if msg_or_header is the entire message.
         h = msg_or_header['header']
     except KeyError:
         try:
             # See if msg_or_header is just the header
             h = msg_or_header['msg_id']
         except KeyError:
             raise
         else:
             h = msg_or_header
     if not isinstance(h, dict):
         h = dict(h)
     return h
 
 def rekey(dikt):
     """Rekey a dict that has been forced to use str keys where there should be
     ints by json.  This belongs in the jsonutil added by fperez."""
     for k in dikt.iterkeys():
         if isinstance(k, str):
             ik=fk=None
             try:
                 ik = int(k)
             except ValueError:
                 try:
                     fk = float(k)
                 except ValueError:
                     continue
             if ik is not None:
                 nk = ik
             else:
                 nk = fk
             if nk in dikt:
                 raise KeyError("already have key %r"%nk)
             dikt[nk] = dikt.pop(k)
     return dikt
 
 def serialize_object(obj, threshold=64e-6):
     """Serialize an object into a list of sendable buffers.
     
     Parameters
     ----------
     
     obj : object
         The object to be serialized
     threshold : float
         The threshold for not double-pickling the content.
         
     
     Returns
     -------
     ('pmd', [bufs]) :
         where pmd is the pickled metadata wrapper,
         bufs is a list of data buffers
     """
     databuffers = []
     if isinstance(obj, (list, tuple)):
         clist = canSequence(obj)
         slist = map(serialize, clist)
         for s in slist:
             if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
                 databuffers.append(s.getData())
                 s.data = None
         return pickle.dumps(slist,-1), databuffers
     elif isinstance(obj, dict):
         sobj = {}
         for k in sorted(obj.iterkeys()):
             s = serialize(can(obj[k]))
             if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
                 databuffers.append(s.getData())
                 s.data = None
             sobj[k] = s
         return pickle.dumps(sobj,-1),databuffers
     else:
         s = serialize(can(obj))
         if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
             databuffers.append(s.getData())
             s.data = None
         return pickle.dumps(s,-1),databuffers
             
         
 def unserialize_object(bufs):
     """reconstruct an object serialized by serialize_object from data buffers."""
     bufs = list(bufs)
     sobj = pickle.loads(bufs.pop(0))
     if isinstance(sobj, (list, tuple)):
         for s in sobj:
             if s.data is None:
                 s.data = bufs.pop(0)
         return uncanSequence(map(unserialize, sobj)), bufs
     elif isinstance(sobj, dict):
         newobj = {}
         for k in sorted(sobj.iterkeys()):
             s = sobj[k]
             if s.data is None:
                 s.data = bufs.pop(0)
             newobj[k] = uncan(unserialize(s))
         return newobj, bufs
     else:
         if sobj.data is None:
             sobj.data = bufs.pop(0)
         return uncan(unserialize(sobj)), bufs
 
 def pack_apply_message(f, args, kwargs, threshold=64e-6):
     """pack up a function, args, and kwargs to be sent over the wire
     as a series of buffers. Any object whose data is larger than `threshold`
     will not have their data copied (currently only numpy arrays support zero-copy)"""
     msg = [pickle.dumps(can(f),-1)]
     databuffers = [] # for large objects
     sargs, bufs = serialize_object(args,threshold)
     msg.append(sargs)
     databuffers.extend(bufs)
     skwargs, bufs = serialize_object(kwargs,threshold)
     msg.append(skwargs)
     databuffers.extend(bufs)
     msg.extend(databuffers)
     return msg
 
 def unpack_apply_message(bufs, g=None, copy=True):
     """unpack f,args,kwargs from buffers packed by pack_apply_message()
     Returns: original f,args,kwargs"""
     bufs = list(bufs) # allow us to pop
     assert len(bufs) >= 3, "not enough buffers!"
     if not copy:
         for i in range(3):
             bufs[i] = bufs[i].bytes
     cf = pickle.loads(bufs.pop(0))
     sargs = list(pickle.loads(bufs.pop(0)))
     skwargs = dict(pickle.loads(bufs.pop(0)))
     # print sargs, skwargs
     f = uncan(cf, g)
     for sa in sargs:
         if sa.data is None:
             m = bufs.pop(0)
             if sa.getTypeDescriptor() in ('buffer', 'ndarray'):
                 if copy:
                     sa.data = buffer(m)
                 else:
                     sa.data = m.buffer
             else:
                 if copy:
                     sa.data = m
                 else:
                     sa.data = m.bytes
     
     args = uncanSequence(map(unserialize, sargs), g)
     kwargs = {}
     for k in sorted(skwargs.iterkeys()):
         sa = skwargs[k]
         if sa.data is None:
             sa.data = bufs.pop(0)
         kwargs[k] = uncan(unserialize(sa), g)
     
     return f,args,kwargs
 
 class StreamSession(object):
     """tweaked version of IPython.zmq.session.Session, for development in Parallel"""
     debug=False
     key=None
     
     def __init__(self, username=None, session=None, packer=None, unpacker=None, key=None, keyfile=None):
         if username is None:
             username = os.environ.get('USER','username')
         self.username = username
         if session is None:
             self.session = str(uuid.uuid4())
         else:
             self.session = session
         self.msg_id = str(uuid.uuid4())
         if packer is None:
             self.pack = default_packer
         else:
             if not callable(packer):
                 raise TypeError("packer must be callable, not %s"%type(packer))
             self.pack = packer
         
         if unpacker is None:
             self.unpack = default_unpacker
         else:
             if not callable(unpacker):
                 raise TypeError("unpacker must be callable, not %s"%type(unpacker))
             self.unpack = unpacker
         
         if key is not None and keyfile is not None:
             raise TypeError("Must specify key OR keyfile, not both")
         if keyfile is not None:
             with open(keyfile) as f:
                 self.key = f.read().strip()
         else:
             self.key = key
         # print key, keyfile, self.key
         self.none = self.pack({})
             
     def msg_header(self, msg_type):
         h = msg_header(self.msg_id, msg_type, self.username, self.session)
         self.msg_id = str(uuid.uuid4())
         return h
 
     def msg(self, msg_type, content=None, parent=None, subheader=None):
         msg = {}
         msg['header'] = self.msg_header(msg_type)
         msg['msg_id'] = msg['header']['msg_id']
         msg['parent_header'] = {} if parent is None else extract_header(parent)
         msg['msg_type'] = msg_type
         msg['content'] = {} if content is None else content
         sub = {} if subheader is None else subheader
         msg['header'].update(sub)
         return msg
 
     def check_key(self, msg_or_header):
         """Check that a message's header has the right key"""
         if self.key is None:
             return True
         header = extract_header(msg_or_header)
         return header.get('key', None) == self.key
             
         
     def send(self, stream, msg_or_type, content=None, buffers=None, parent=None, subheader=None, ident=None):
         """Build and send a message via stream or socket.
         
         Parameters
         ----------
         
         stream : zmq.Socket or ZMQStream
             the socket-like object used to send the data
         msg_or_type : str or Message/dict
             Normally, msg_or_type will be a msg_type unless a message is being sent more
             than once.
         
         Returns
         -------
         (msg,sent) : tuple
             msg : Message
                 the nice wrapped dict-like object containing the headers
             
         """
         if isinstance(msg_or_type, (Message, dict)):
             # we got a Message, not a msg_type
             # don't build a new Message
             msg = msg_or_type
             content = msg['content']
         else:
             msg = self.msg(msg_or_type, content, parent, subheader)
         buffers = [] if buffers is None else buffers
         to_send = []
         if isinstance(ident, list):
             # accept list of idents
             to_send.extend(ident)
         elif ident is not None:
             to_send.append(ident)
         to_send.append(DELIM)
         if self.key is not None:
             to_send.append(self.key)
         to_send.append(self.pack(msg['header']))
         to_send.append(self.pack(msg['parent_header']))
         
         if content is None:
             content = self.none
         elif isinstance(content, dict):
             content = self.pack(content)
         elif isinstance(content, str):
             # content is already packed, as in a relayed message
             pass
         else:
             raise TypeError("Content incorrect type: %s"%type(content))
         to_send.append(content)
         flag = 0
         if buffers:
             flag = zmq.SNDMORE
         stream.send_multipart(to_send, flag, copy=False)
         for b in buffers[:-1]:
             stream.send(b, flag, copy=False)
         if buffers:
             stream.send(buffers[-1], copy=False)
         omsg = Message(msg)
         if self.debug:
             pprint.pprint(omsg)
             pprint.pprint(to_send)
             pprint.pprint(buffers)
         return omsg
     
     def send_raw(self, stream, msg, flags=0, copy=True, ident=None):
         """Send a raw message via ident path.
         
         Parameters
         ----------
         msg : list of sendable buffers"""
         to_send = []
         if isinstance(ident, str):
             ident = [ident]
         if ident is not None:
             to_send.extend(ident)
         to_send.append(DELIM)
         if self.key is not None:
             to_send.append(self.key)
         to_send.extend(msg)
         stream.send_multipart(msg, flags, copy=copy)
     
     def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):
         """receives and unpacks a message
         returns [idents], msg"""
         if isinstance(socket, ZMQStream):
             socket = socket.socket
         try:
             msg = socket.recv_multipart(mode)
         except zmq.ZMQError as e:
             if e.errno == zmq.EAGAIN:
                 # We can convert EAGAIN to None as we know in this case
                 # recv_json won't return None.
                 return None
             else:
                 raise
         # return an actual Message object
         # determine the number of idents by trying to unpack them.
         # this is terrible:
         idents, msg = self.feed_identities(msg, copy)
         try:
             return idents, self.unpack_message(msg, content=content, copy=copy)
         except Exception as e:
             print (idents, msg)
             # TODO: handle it
             raise e
     
     def feed_identities(self, msg, copy=True):
         """feed until DELIM is reached, then return the prefix as idents and remainder as
         msg. This is easily broken by setting an IDENT to DELIM, but that would be silly.
         
         Parameters
         ----------
         msg : a list of Message or bytes objects
             the message to be split
         copy : bool
             flag determining whether the arguments are bytes or Messages
         
         Returns
         -------
         (idents,msg) : two lists
             idents will always be a list of bytes - the indentity prefix
             msg will be a list of bytes or Messages, unchanged from input
             msg should be unpackable via self.unpack_message at this point.
         """
         msg = list(msg)
         idents = []
         while len(msg) > 3:
             if copy:
                 s = msg[0]
             else:
                 s = msg[0].bytes
             if s == DELIM:
                 msg.pop(0)
                 break
             else:
                 idents.append(s)
                 msg.pop(0)
                 
         return idents, msg
     
     def unpack_message(self, msg, content=True, copy=True):
         """Return a message object from the format
         sent by self.send.
         
         Parameters:
         -----------
         
         content : bool (True)
             whether to unpack the content dict (True), 
             or leave it serialized (False)
         
         copy : bool (True)
             whether to return the bytes (True), 
             or the non-copying Message object in each place (False)
         
         """
         ikey = int(self.key is not None)
         minlen = 3 + ikey
         if not len(msg) >= minlen:
             raise TypeError("malformed message, must have at least %i elements"%minlen)
         message = {}
         if not copy:
             for i in range(minlen):
                 msg[i] = msg[i].bytes
         if ikey:
             if not self.key == msg[0]:
                 raise KeyError("Invalid Session Key: %s"%msg[0])
         message['header'] = self.unpack(msg[ikey+0])
         message['msg_type'] = message['header']['msg_type']
         message['parent_header'] = self.unpack(msg[ikey+1])
         if content:
             message['content'] = self.unpack(msg[ikey+2])
         else:
             message['content'] = msg[ikey+2]
     
         # message['buffers'] = msg[3:]
         # else:
         #     message['header'] = self.unpack(msg[0].bytes)
         #     message['msg_type'] = message['header']['msg_type']
         #     message['parent_header'] = self.unpack(msg[1].bytes)
         #     if content:
         #         message['content'] = self.unpack(msg[2].bytes)
         #     else:
         #         message['content'] = msg[2].bytes
         
         message['buffers'] = msg[ikey+3:]# [ m.buffer for m in msg[3:] ]
         return message
             
         
 
 def test_msg2obj():
     am = dict(x=1)
     ao = Message(am)
     assert ao.x == am['x']
 
     am['y'] = dict(z=1)
     ao = Message(am)
     assert ao.y.z == am['y']['z']
     
     k1, k2 = 'y', 'z'
     assert ao[k1][k2] == am[k1][k2]
     
     am2 = dict(ao)
     assert am['x'] == am2['x']
     assert am['y']['z'] == am2['y']['z']

setup.py

@@ -1,250 +1,251 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
 Under Posix environments it works like a typical setup.py script. 
 Under Windows, the command sdist is not supported, since IPython 
 requires utilities which are not available under Windows."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2010, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Minimal Python version sanity check
 #-----------------------------------------------------------------------------
 
 import sys
 
 # This check is also made in IPython/__init__, don't forget to update both when
 # changing Python version requirements.
 if sys.version[0:3] < '2.6':
     error = """\
 ERROR: 'IPython requires Python Version 2.6 or above.'
 Exiting."""
     print >> sys.stderr, error
     sys.exit(1)
 
 # At least we're on the python version we need, move on.
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import shutil
 
 from glob import glob
 
 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
 # update it when the contents of directories change.
 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
 
 from distutils.core import setup
 
 # Our own imports
 from IPython.utils.path import target_update
 
 from setupbase import (
     setup_args, 
     find_packages, 
     find_package_data, 
     find_scripts,
     find_data_files,
     check_for_dependencies,
     record_commit_info,
 )
 
 isfile = os.path.isfile
 pjoin = os.path.join
 
 #-----------------------------------------------------------------------------
 # Function definitions
 #-----------------------------------------------------------------------------
 
 def cleanup():
     """Clean up the junk left around by the build process"""
     if "develop" not in sys.argv:
         try:
             shutil.rmtree('ipython.egg-info')
         except:
             try:
                 os.unlink('ipython.egg-info')
             except:
                 pass
 
 #-------------------------------------------------------------------------------
 # Handle OS specific things
 #-------------------------------------------------------------------------------
 
 if os.name == 'posix':
     os_name = 'posix'
 elif os.name in ['nt','dos']:
     os_name = 'windows'
 else:
     print 'Unsupported operating system:',os.name
     sys.exit(1)
 
 # Under Windows, 'sdist' has not been supported.  Now that the docs build with
 # Sphinx it might work, but let's not turn it on until someone confirms that it
 # actually works.
 if os_name == 'windows' and 'sdist' in sys.argv:
     print 'The sdist command is not available under Windows.  Exiting.'
     sys.exit(1)
 
 #-------------------------------------------------------------------------------
 # Things related to the IPython documentation
 #-------------------------------------------------------------------------------
 
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
     import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
                   # FIXME - Disabled for now: we need to redo an automatic way
                   # of generating the magic info inside the rst.                
                   #('docs/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
 
                  ('docs/man/ipcluster.1.gz',
                   ['docs/man/ipcluster.1'],
                   'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
 
                  ('docs/man/ipcontroller.1.gz',
                   ['docs/man/ipcontroller.1'],
                   'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
 
                  ('docs/man/ipengine.1.gz',
                   ['docs/man/ipengine.1'],
                   'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
 
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
 
                  ('docs/man/ipython-wx.1.gz',
                   ['docs/man/ipython-wx.1'],
                   'cd docs/man && gzip -9c ipython-wx.1 > ipython-wx.1.gz'),
 
                  ('docs/man/ipythonx.1.gz',
                   ['docs/man/ipythonx.1'],
                   'cd docs/man && gzip -9c ipythonx.1 > ipythonx.1.gz'),
 
                  ('docs/man/irunner.1.gz',
                   ['docs/man/irunner.1'],
                   'cd docs/man && gzip -9c irunner.1 > irunner.1.gz'),
 
                  ('docs/man/pycolor.1.gz',
                   ['docs/man/pycolor.1'],
                   'cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz'),
                  ]
 
     # Only build the docs if sphinx is present
     try:
         import sphinx
     except ImportError:
         pass
     else:
         # The Makefile calls the do_sphinx scripts to build html and pdf, so
         # just one target is enough to cover all manual generation
 
         # First, compute all the dependencies that can force us to rebuild the
         # docs.  Start with the main release file that contains metadata
         docdeps = ['IPython/core/release.py']
         # Inculde all the reST sources
         pjoin = os.path.join
         for dirpath,dirnames,filenames in os.walk('docs/source'):
             if dirpath in ['_static','_templates']:
                 continue
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if f.endswith('.txt') ]
         # and the examples
         for dirpath,dirnames,filenames in os.walk('docs/example'):
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if not f.endswith('~') ]
         # then, make them all dependencies for the main PDF (the html will get
         # auto-generated as well).
         to_update.append(
             ('docs/dist/ipython.pdf',
              docdeps,
              "cd docs && make dist")
             )
         
     [ target_update(*t) for t in to_update ]
     
 #---------------------------------------------------------------------------
 # Find all the packages, package data, scripts and data_files
 #---------------------------------------------------------------------------
 
 packages = find_packages()
 package_data = find_package_data()
 scripts = find_scripts()
 data_files = find_data_files()
 
 #---------------------------------------------------------------------------
 # Handle dependencies and setuptools specific things
 #---------------------------------------------------------------------------
 
 # For some commands, use setuptools.  Note that we do NOT list install here!
 # If you want a setuptools-enhanced install, just run 'setupegg.py install'
 if len(set(('develop', 'sdist', 'release', 'bdist_egg', 'bdist_rpm',
            'bdist', 'bdist_dumb', 'bdist_wininst', 'install_egg_info',
            'build_sphinx', 'egg_info', 'easy_install', 'upload',
             )).intersection(sys.argv)) > 0:
     import setuptools
 
 # This dict is used for passing extra arguments that are setuptools 
 # specific to setup
 setuptools_extra_args = {}
 
 if 'setuptools' in sys.modules:
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = {
         'console_scripts': [
             'ipython = IPython.frontend.terminal.ipapp:launch_new_instance',
             'ipython-qtconsole = IPython.frontend.qt.console.ipythonqt:main',
             'pycolor = IPython.utils.PyColorize:main',
-            'ipcontrollerz = IPython.zmq.parallel.controller:main',
-            'ipenginez = IPython.zmq.parallel.engine:main',
+            'ipcontrollerz = IPython.zmq.parallel.ipcontrollerapp:launch_new_instance',
+            'ipenginez = IPython.zmq.parallel.ipengineapp:launch_new_instance',
+            'iploggerz = IPython.zmq.parallel.iploggerapp:launch_new_instance',
             'ipclusterz = IPython.zmq.parallel.ipcluster:main',
             'iptest = IPython.testing.iptest:main',
             'irunner = IPython.lib.irunner:main'
         ]
     }
     setup_args['extras_require'] = dict(
         doc='Sphinx>=0.3',
         test='nose>=0.10.1',
         security='pyOpenSSL>=0.6'
     )
 else:
     # If we are running without setuptools, call this function which will
     # check for dependencies an inform the user what is needed.  This is
     # just to make life easy for users.
     check_for_dependencies()
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
 setup_args['cmdclass'] = {'build_py': record_commit_info('IPython')}
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['scripts'] = scripts
 setup_args['data_files'] = data_files
 setup_args.update(setuptools_extra_args)
 
 
 if __name__ == '__main__':
     setup(**setup_args)
     cleanup()