ipcluster implemented with new subcommands

IPython/parallel/apps/clusterdir.py

@@ -1,492 +1,525 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 logging
 import re
 import shutil
 import sys
 
 from subprocess import Popen, PIPE
 
 from IPython.config.loader import PyFileConfigLoader, Config
 from IPython.config.configurable import Configurable
 from IPython.config.application import Application
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.newapplication import BaseIPythonApplication
 from IPython.core import release
 from IPython.utils.path import (
     get_ipython_package_dir,
     get_ipython_dir,
     expand_path
 )
 from IPython.utils.traitlets import Unicode, Bool, CStr, Instance, Dict
 
 #-----------------------------------------------------------------------------
 # 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'', config=True,
         help="""Set the cluster dir. This overrides the logic used by the
         `profile` option.""",
         )
     profile = Unicode(u'default',
         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.""", config=True
         )
+    auto_create = Bool(False,
+        help="""Whether to automatically create the ClusterDirectory if it does
+        not exist""")
+    overwrite = Bool(False,
+        help="""Whether to overwrite existing config files""")
 
     _location_isset = Bool(False) # flag for detecting multiply set location
     _new_dir = Bool(False) # flag for whether a new dir was created
 
     def __init__(self, **kwargs):
         super(ClusterDir, self).__init__(**kwargs)
         if not self.location:
             self._profile_changed('profile', 'default', self.profile)
 
     def _location_changed(self, name, old, new):
         if self._location_isset:
             raise RuntimeError("Cannot set ClusterDir more than once.")
         self._location_isset = True
         if not os.path.isdir(new):
+            if self.auto_create:
             os.makedirs(new)
             self._new_dir = True
+            else:
+                raise ClusterDirError('Directory not found: %s' % new)
+        
         # ensure config files exist:
-        self.copy_all_config_files(overwrite=False)
+        self.copy_all_config_files(overwrite=self.overwrite)
         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 _profile_changed(self, name, old, new):
         if self._location_isset:
             raise RuntimeError("ClusterDir already set.  Cannot set by profile.")
         self.location = os.path.join(get_ipython_dir(), 'cluster_'+new)
 
     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 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 "cluster_<profile>".
         """
         if not os.path.isdir(path):
             raise ClusterDirError('Directory not found: %s' % path)
         cluster_dir = os.path.join(path, u'cluster_' + 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 "cluster_<profile>".
         """
         dirname = u'cluster_' + 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)
 
 
 #-----------------------------------------------------------------------------
 # 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['Min'][0]
         contact_email = release.authors['Min'][1]
         bug_tracker = 'http://github.com/ipython/ipython/issues'
         super(ClusterDirCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
 
 #-----------------------------------------------------------------------------
 # Main application
 #-----------------------------------------------------------------------------
 base_aliases = {
     'profile' : "ClusterDir.profile",
     'cluster_dir' : 'ClusterDir.location',
-    'log_level' : 'Application.log_level',
-    'work_dir' : 'ClusterDirApplicaiton.work_dir',
-    'log_to_file' : 'ClusterDirApplicaiton.log_to_file',
-    'clean_logs' : 'ClusterDirApplicaiton.clean_logs',
-    'log_url' : 'ClusterDirApplicaiton.log_url',
+    'auto_create' : 'ClusterDirApplication.auto_create',
+    'log_level' : 'ClusterApplication.log_level',
+    'work_dir' : 'ClusterApplication.work_dir',
+    'log_to_file' : 'ClusterApplication.log_to_file',
+    'clean_logs' : 'ClusterApplication.clean_logs',
+    'log_url' : 'ClusterApplication.log_url',
 }
 
 base_flags = {
-    'debug' : ( {"Application" : {"log_level" : logging.DEBUG}}, "set loglevel to DEBUG"),
-    'clean-logs' : ( {"ClusterDirApplication" : {"clean_logs" : True}}, "cleanup old logfiles"),
-    'log-to-file' : ( {"ClusterDirApplication" : {"log_to_file" : True}}, "log to a file")
+    'debug' : ( {"ClusterApplication" : {"log_level" : logging.DEBUG}}, "set loglevel to DEBUG"),
+    'quiet' : ( {"ClusterApplication" : {"log_level" : logging.CRITICAL}}, "set loglevel to CRITICAL (minimal output)"),
+    'log-to-file' : ( {"ClusterApplication" : {"log_to_file" : True}}, "redirect log output to a file"),
 }
 for k,v in base_flags.iteritems():
     base_flags[k] = (Config(v[0]),v[1])
 
-class ClusterDirApplication(BaseIPythonApplication):
+class ClusterApplication(BaseIPythonApplication):
     """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.
     """
 
     crash_handler_class = ClusterDirCrashHandler
     auto_create_cluster_dir = Bool(True, config=True,
         help="whether to create the cluster_dir if it doesn't exist")
-    # temporarily override default_log_level to INFO
-    default_log_level = logging.INFO
     cluster_dir = Instance(ClusterDir)
+    classes = [ClusterDir]
+    
+    def _log_level_default(self):
+        # temporarily override default_log_level to INFO
+        return logging.INFO
 
     work_dir = Unicode(os.getcwdu(), config=True,
         help='Set the working dir for the process.'
     )
     def _work_dir_changed(self, name, old, new):
         self.work_dir = unicode(expand_path(new))
 
     log_to_file = Bool(config=True,
         help="whether to log to a file")
 
-    clean_logs = Bool(True, shortname='--clean-logs', config=True,
+    clean_logs = Bool(False, shortname='--clean-logs', config=True,
         help="whether to cleanup old logfiles before starting")
 
     log_url = CStr('', shortname='--log-url', config=True,
         help="The ZMQ URL of the iplooger to aggregate logging.")
 
     config_file = Unicode(u'', config=True,
         help="""Path to ipcontroller configuration file.  The default is to use
          <appname>_config.py, as found by cluster-dir."""
     )
 
+    loop = Instance('zmq.eventloop.ioloop.IOLoop')
+    def _loop_default(self):
+        from zmq.eventloop.ioloop import IOLoop
+        return IOLoop.instance()
+
     aliases = Dict(base_aliases)
     flags = Dict(base_flags)
 
     def init_clusterdir(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`.
         """
-        self.cluster_dir = ClusterDir(config=self.config)
+        self.cluster_dir = ClusterDir(config=self.config, auto_create=self.auto_create_cluster_dir)
         if self.cluster_dir._new_dir:
             self.log.info('Creating new cluster dir: %s' % \
                             self.cluster_dir.location)
         else:
             self.log.info('Using existing cluster dir: %s' % \
                             self.cluster_dir.location)
 
+    def initialize(self, argv=None):
+        """initialize the app"""
+        self.parse_command_line(argv)
+        cl_config = self.config
+        self.init_clusterdir()
+        if self.config_file:
+            self.load_config_file(self.config_file)
+        else:
+            self.load_config_file(self.default_config_file_name, path=self.cluster_dir.location)
+        # command-line should *override* config file, but command-line is necessary
+        # to determine clusterdir, etc.
+        self.update_config(cl_config)
+        self.reinit_logging()
+
+        self.to_work_dir()
+        
     def to_work_dir(self):
         wd = self.work_dir
         if unicode(wd) != os.getcwdu():
             os.chdir(wd)
             self.log.info("Changing to working dir: %s" % wd)
 
     def load_config_file(self, filename, path=None):
         """Load a .py based config file by filename and path."""
+        # use config.application.Application.load_config
+        # instead of inflexible
+        # core.newapplication.BaseIPythonApplication.load_config
         return Application.load_config_file(self, filename, path=path)
     #
     # def load_default_config_file(self):
     #     """Load a .py based config file by filename and path."""
     #     return BaseIPythonApplication.load_config_file(self)
 
     # disable URL-logging
-    # def init_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 re.match(r'%s-\d+\.(log|err|out)'%self.name,f):
-    #             # 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
-    #     if open_log_file is not None:
-    #         self.log.removeHandler(self._log_handler)
-    #         self._log_handler = logging.StreamHandler(open_log_file)
-    #         self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
-    #         self._log_handler.setFormatter(self._log_formatter)
-    #         self.log.addHandler(self._log_handler)
-    #     # log.startLogging(open_log_file)
+    def reinit_logging(self):
+        # Remove old log files
+        log_dir = self.cluster_dir.log_dir
+        if self.clean_logs:
+            for f in os.listdir(log_dir):
+                if re.match(r'%s-\d+\.(log|err|out)'%self.name,f):
+                    os.remove(os.path.join(log_dir, f))
+        if self.log_to_file:
+            # Start logging to the new log file
+            log_filename = self.name + u'-' + str(os.getpid()) + u'.log'
+            logfile = os.path.join(log_dir, log_filename)
+            open_log_file = open(logfile, 'w')
+        else:
+            open_log_file = None
+        if open_log_file is not None:
+            self.log.removeHandler(self._log_handler)
+            self._log_handler = logging.StreamHandler(open_log_file)
+            self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
+            self._log_handler.setFormatter(self._log_formatter)
+            self.log.addHandler(self._log_handler)
 
     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.cluster_dir.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.cluster_dir.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.cluster_dir.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)
     
     def check_pid(self, pid):
         if os.name == 'nt':
             try:
                 import ctypes
                 # returns 0 if no such process (of ours) exists
                 # positive int otherwise
                 p = ctypes.windll.kernel32.OpenProcess(1,0,pid)
             except Exception:
                 self.log.warn(
                     "Could not determine whether pid %i is running via `OpenProcess`. "
                     " Making the likely assumption that it is."%pid
                 )
                 return True
             return bool(p)
         else:
             try:
                 p = Popen(['ps','x'], stdout=PIPE, stderr=PIPE)
                 output,_ = p.communicate()
             except OSError:
                 self.log.warn(
                     "Could not determine whether pid %i is running via `ps x`. "
                     " Making the likely assumption that it is."%pid
                 )
                 return True
             pids = map(int, re.findall(r'^\W*\d+', output, re.MULTILINE))
             return pid in pids

IPython/parallel/apps/ipclusterapp.py

@@ -1,550 +1,542 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The ipcluster 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 errno
 import logging
 import os
 import re
 import signal
 
 from subprocess import check_call, CalledProcessError, PIPE
 import zmq
 from zmq.eventloop import ioloop
 
+from IPython.config.application import Application, boolean_flag
 from IPython.config.loader import Config
+from IPython.core.newapplication import BaseIPythonApplication
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Int, CStr, CUnicode, Str, Bool, CFloat, Dict, List
 
 from IPython.parallel.apps.clusterdir import (
-    ClusterDirApplication, ClusterDirError,
+    ClusterApplication, ClusterDirError, ClusterDir,
     PIDFileError,
-    base_flags,
+    base_flags, base_aliases
 )
 
 
 #-----------------------------------------------------------------------------
 # Module level variables
 #-----------------------------------------------------------------------------
 
 
 default_config_file_name = u'ipcluster_config.py'
 
 
 _description = """\
 Start an IPython cluster for parallel computing.\n\n
 
 An IPython cluster consists of 1 controller and 1 or more engines.
 This command automates the startup of these processes using a wide
 range of startup methods (SSH, local processes, PBS, mpiexec,
 Windows HPC Server 2008). To start a cluster with 4 engines on your
 local host simply do 'ipcluster start n=4'. For more complex usage
-you will typically do 'ipcluster --create profile=mycluster', then edit
-configuration files, followed by 'ipcluster --start -p mycluster -n 4'.
+you will typically do 'ipcluster create profile=mycluster', then edit
+configuration files, followed by 'ipcluster start profile=mycluster n=4'.
 """
 
 
 # Exit codes for ipcluster
 
 # This will be the exit code if the ipcluster appears to be running because
 # a .pid file exists
 ALREADY_STARTED = 10
 
 
 # This will be the exit code if ipcluster stop is run, but there is not .pid
 # file to be found.
 ALREADY_STOPPED = 11
 
 # This will be the exit code if ipcluster engines is run, but there is not .pid
 # file to be found.
 NO_CLUSTER = 12
 
 
 #-----------------------------------------------------------------------------
 # Main application
 #-----------------------------------------------------------------------------
-start_help = """Start an ipython cluster by its profile name or cluster
+start_help = """
+Start an ipython cluster by its profile name or cluster
             directory. Cluster directories contain configuration, log and
             security related files and are named using the convention
             'cluster_<profile>' and should be creating using the 'start'
             subcommand of 'ipcluster'. If your cluster directory is in 
             the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster start -n 4 -p <profile>`,
-            otherwise use the '--cluster-dir' option.
+using its profile name, 'ipcluster start n=4 profile=<profile>`,
+otherwise use the 'cluster_dir' option.
             """
-stop_help = """Stop a running ipython cluster by its profile name or cluster
+stop_help = """
+Stop a running ipython cluster by its profile name or cluster
             directory. Cluster directories are named using the convention
             'cluster_<profile>'. If your cluster directory is in 
             the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster stop -p <profile>`, otherwise
-            use the '--cluster-dir' option.
+using its profile name, 'ipcluster stop profile=<profile>`, otherwise
+use the 'cluster_dir' option.
             """
-engines_help = """Start one or more engines to connect to an existing Cluster
+engines_help = """
+Start one or more engines to connect to an existing Cluster
             by profile name or cluster directory.
             Cluster directories contain configuration, log and
             security related files and are named using the convention
             'cluster_<profile>' and should be creating using the 'start'
             subcommand of 'ipcluster'. If your cluster directory is in 
             the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster --engines -n 4 -p <profile>`,
+using its profile name, 'ipcluster engines n=4 profile=<profile>`,
             otherwise use the 'cluster_dir' option.
             """
-create_help = """Create an ipython cluster directory by its profile name or
+create_help = """
+Create an ipython cluster directory by its profile name or
             cluster directory path. Cluster directories contain
             configuration, log and security related files and are named
             using the convention 'cluster_<profile>'. By default they are
             located in your ipython directory. Once created, you will
             probably need to edit the configuration files in the cluster
             directory to configure your cluster. Most users will create a
             cluster directory by profile name,
-            'ipcluster create -p mycluster', which will put the directory
-            in '<ipython_dir>/cluster_mycluster'.
+`ipcluster create profile=mycluster`, which will put the directory
+in `<ipython_dir>/cluster_mycluster`.
             """
 list_help = """List all available clusters, by cluster directory, that can
             be found in the current working directly or in the ipython
             directory. Cluster directories are named using the convention
-            'cluster_<profile>'."""
-
-
-flags = {}
-flags.update(base_flags)
-flags.update({
-    'start' : ({ 'IPClusterApp': Config({'subcommand' : 'start'})} , start_help),
-    'stop' : ({ 'IPClusterApp': Config({'subcommand' : 'stop'})} , stop_help),
-    'create' : ({ 'IPClusterApp': Config({'subcommand' : 'create'})} , create_help),
-    'engines' : ({ 'IPClusterApp': Config({'subcommand' : 'engines'})} , engines_help),
-    'list' : ({ 'IPClusterApp': Config({'subcommand' : 'list'})} , list_help),
-
-})
-
-class IPClusterApp(ClusterDirApplication):
-
-    name = u'ipcluster'
-    description = _description
-    usage = None
-    default_config_file_name = default_config_file_name
-    default_log_level = logging.INFO
-    auto_create_cluster_dir = False
-    classes = List()
-    def _classes_default(self,):
-        from IPython.parallel.apps import launcher
-        return launcher.all_launchers
-
-    n = Int(0, config=True,
-        help="The number of engines to start.")
-    signal = Int(signal.SIGINT, config=True,
-        help="signal to use for stopping. [default: SIGINT]")
-    delay = CFloat(1., config=True,
-        help="delay (in s) between starting the controller and the engines")
-
-    subcommand = Str('', config=True,
-        help="""ipcluster has a variety of subcommands. The general way of
-        running ipcluster is 'ipcluster --<cmd> [options]'."""
-        )
+'cluster_<profile>'.
+"""
 
-    controller_launcher_class = Str('IPython.parallel.apps.launcher.LocalControllerLauncher',
-        config=True,
-        help="The class for launching a Controller."
-        )
-    engine_launcher_class = Str('IPython.parallel.apps.launcher.LocalEngineSetLauncher',
-        config=True,
-        help="The class for launching Engines."
-        )
-    reset = Bool(False, config=True,
-        help="Whether to reset config files as part of '--create'."
-        )
-    daemonize = Bool(False, config=True,
-        help='Daemonize the ipcluster program. This implies --log-to-file')
 
-    def _daemonize_changed(self, name, old, new):
-        if new:
-            self.log_to_file = True
+class IPClusterList(BaseIPythonApplication):
+    name = u'ipcluster-list'
+    description = list_help
 
-    def _n_changed(self, name, old, new):
-        # propagate n all over the place...
-        # TODO make this clean
-        # ensure all classes are covered.
-        self.config.LocalEngineSetLauncher.n=new
-        self.config.MPIExecEngineSetLauncher.n=new
-        self.config.SSHEngineSetLauncher.n=new
-        self.config.PBSEngineSetLauncher.n=new
-        self.config.SGEEngineSetLauncher.n=new
-        self.config.WinHPEngineSetLauncher.n=new
-
-    aliases = Dict(dict(
-        n='IPClusterApp.n',
-        signal = 'IPClusterApp.signal',
-        delay = 'IPClusterApp.delay',
-        clauncher = 'IPClusterApp.controller_launcher_class',
-        elauncher = 'IPClusterApp.engine_launcher_class',
-    ))
-    flags = Dict(flags)
+    # empty aliases
+    aliases=Dict()
+    flags = Dict(base_flags)
 
-    def init_clusterdir(self):
-        subcommand = self.subcommand
-        if subcommand=='list':
-            self.list_cluster_dirs()
-            self.exit(0)
-        if subcommand=='create':
-            reset = self.reset_config
-            self.auto_create_cluster_dir = True
-            super(IPClusterApp, self).init_clusterdir()
-            self.log.info('Copying default config files to cluster directory '
-            '[overwrite=%r]' % (reset,))
-            self.cluster_dir.copy_all_config_files(overwrite=reset)
-        elif subcommand=='start' or subcommand=='stop':
-            self.auto_create_cluster_dir = True
-            try:
-                super(IPClusterApp, self).init_clusterdir()
-            except ClusterDirError:
-                raise ClusterDirError(
-                    "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipcluster start'.  Do "
-                    "'ipcluster create -h' or 'ipcluster list -h' for more "
-                    "information about creating and listing cluster dirs."
-                )
-        elif subcommand=='engines':
-            self.auto_create_cluster_dir = False
-            try:
-                super(IPClusterApp, self).init_clusterdir()
-            except ClusterDirError:
-                raise ClusterDirError(
-                    "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipcluster start'.  Do "
-                    "'ipcluster create -h' or 'ipcluster list -h' for more "
-                    "information about creating and listing cluster dirs."
-                )
+    def _log_level_default(self):
+        return 20
 
     def list_cluster_dirs(self):
         # Find the search paths
         cluster_dir_paths = os.environ.get('IPCLUSTER_DIR_PATH','')
         if cluster_dir_paths:
             cluster_dir_paths = cluster_dir_paths.split(':')
         else:
             cluster_dir_paths = []
-        try:
-            ipython_dir = self.ipython_dir
-        except AttributeError:
+        
             ipython_dir = self.ipython_dir
-        paths = [os.getcwd(), ipython_dir] + \
-            cluster_dir_paths
+        
+        paths = [os.getcwd(), ipython_dir] + cluster_dir_paths
         paths = list(set(paths))
 
         self.log.info('Searching for cluster dirs in paths: %r' % paths)
         for path in paths:
             files = os.listdir(path)
             for f in files:
                 full_path = os.path.join(path, f)
                 if os.path.isdir(full_path) and f.startswith('cluster_'):
                     profile = full_path.split('_')[-1]
-                    start_cmd = 'ipcluster --start profile=%s n=4' % profile
+                    start_cmd = 'ipcluster start profile=%s n=4' % profile
                     print start_cmd + " ==> " + full_path
 
-    def init_launchers(self):
-        config = self.config
-        subcmd = self.subcommand
-        if subcmd =='start':
-            self.start_logging()
-            self.loop = ioloop.IOLoop.instance()
-            # reactor.callWhenRunning(self.start_launchers)
-            dc = ioloop.DelayedCallback(self.start_launchers, 0, self.loop)
-            dc.start()
-        if subcmd == 'engines':
-            self.start_logging()
-            self.loop = ioloop.IOLoop.instance()
-            # reactor.callWhenRunning(self.start_launchers)
-            engine_only = lambda : self.start_launchers(controller=False)
-            dc = ioloop.DelayedCallback(engine_only, 0, self.loop)
-            dc.start()
+    def start(self):
+        self.list_cluster_dirs()
 
-    def start_launchers(self, controller=True):
-        config = self.config
+create_flags = {}
+create_flags.update(base_flags)
+create_flags.update(boolean_flag('reset', 'IPClusterCreate.reset', 
+                "reset config files to defaults", "leave existing config files"))
 
-        # Create the launchers. In both bases, we set the work_dir of
-        # the launcher to the cluster_dir. This is where the launcher's
-        # subprocesses will be launched. It is not where the controller
-        # and engine will be launched.
-        if controller:
-            clsname = self.controller_launcher_class
-            if '.' not in clsname:
-                clsname = 'IPython.parallel.apps.launcher.'+clsname
-            cl_class = import_item(clsname)
-            self.controller_launcher = cl_class(
-                work_dir=self.cluster_dir.location, config=config,
-                logname=self.log.name
+class IPClusterCreate(ClusterApplication):
+    name = u'ipcluster'
+    description = create_help
+    auto_create_cluster_dir = Bool(True,
+        help="whether to create the cluster_dir if it doesn't exist")
+    default_config_file_name = default_config_file_name
+    
+    reset = Bool(False, config=True,
+        help="Whether to reset config files as part of 'create'."
             )
-            # Setup the observing of stopping. If the controller dies, shut
-            # everything down as that will be completely fatal for the engines.
-            self.controller_launcher.on_stop(self.stop_launchers)
-            # But, we don't monitor the stopping of engines. An engine dying
-            # is just fine and in principle a user could start a new engine.
-            # Also, if we did monitor engine stopping, it is difficult to
-            # know what to do when only some engines die. Currently, the
-            # observing of engine stopping is inconsistent. Some launchers
-            # might trigger on a single engine stopping, other wait until
-            # all stop.  TODO: think more about how to handle this.
-        else:
-            self.controller_launcher = None
         
-        clsname = self.engine_launcher_class
-        if '.' not in clsname:
-            # not a module, presume it's the raw name in apps.launcher
-            clsname = 'IPython.parallel.apps.launcher.'+clsname
-        print repr(clsname)
-        el_class = import_item(clsname)
+    flags = Dict(create_flags)
+    
+    aliases = Dict(dict(profile='ClusterDir.profile'))
+    
+    classes = [ClusterDir]
+    
+    def init_clusterdir(self):
+        super(IPClusterCreate, self).init_clusterdir()
+        self.log.info('Copying default config files to cluster directory '
+        '[overwrite=%r]' % (self.reset,))
+        self.cluster_dir.copy_all_config_files(overwrite=self.reset)
+    
+    def initialize(self, argv=None):
+        self.parse_command_line(argv)
+        self.init_clusterdir()
 
-        self.engine_launcher = el_class(
-            work_dir=self.cluster_dir.location, config=config, logname=self.log.name
+stop_aliases = dict(
+    signal='IPClusterStop.signal',
+    profile='ClusterDir.profile',
+    cluster_dir='ClusterDir.location',
         )
 
-        # Setup signals
-        signal.signal(signal.SIGINT, self.sigint_handler)
+class IPClusterStop(ClusterApplication):
+    name = u'ipcluster'
+    description = stop_help
+    auto_create_cluster_dir = Bool(False,
+        help="whether to create the cluster_dir if it doesn't exist")
+    default_config_file_name = default_config_file_name
 
-        # Start the controller and engines
-        self._stopping = False  # Make sure stop_launchers is not called 2x.
-        if controller:
-            self.start_controller()
-        dc = ioloop.DelayedCallback(self.start_engines, 1000*self.delay*controller, self.loop)
-        dc.start()
-        self.startup_message()
+    signal = Int(signal.SIGINT, config=True,
+        help="signal to use for stopping processes.")
 
-    def startup_message(self, r=None):
-        self.log.info("IPython cluster: started")
-        return r
+    aliases = Dict(stop_aliases)
         
-    def start_controller(self, r=None):
-        # self.log.info("In start_controller")
-        config = self.config
-        d = self.controller_launcher.start(
-            cluster_dir=self.cluster_dir.location
+    def start(self):
+        """Start the app for the stop subcommand."""
+        try:
+            pid = self.get_pid_from_file()
+        except PIDFileError:
+            self.log.critical(
+                'Could not read pid file, cluster is probably not running.'
         )
-        return d
+            # Here I exit with a unusual exit status that other processes
+            # can watch for to learn how I existed.
+            self.remove_pid_file()
+            self.exit(ALREADY_STOPPED)
+        
+        if not self.check_pid(pid):
+            self.log.critical(
+                'Cluster [pid=%r] is not running.' % pid
+            )
+            self.remove_pid_file()
+            # Here I exit with a unusual exit status that other processes
+            # can watch for to learn how I existed.
+            self.exit(ALREADY_STOPPED)
+            
+        elif os.name=='posix':
+            sig = self.signal
+            self.log.info(
+                "Stopping cluster [pid=%r] with [signal=%r]" % (pid, sig)
+            )
+            try:
+                os.kill(pid, sig)
+            except OSError:
+                self.log.error("Stopping cluster failed, assuming already dead.",
+                    exc_info=True)
+                self.remove_pid_file()
+        elif os.name=='nt':
+            try:
+                # kill the whole tree
+                p = check_call(['taskkill', '-pid', str(pid), '-t', '-f'], stdout=PIPE,stderr=PIPE)
+            except (CalledProcessError, OSError):
+                self.log.error("Stopping cluster failed, assuming already dead.",
+                    exc_info=True)
+            self.remove_pid_file()
+    
+engine_aliases = {}
+engine_aliases.update(base_aliases)
+engine_aliases.update(dict(
+    n='IPClusterEngines.n',
+    elauncher = 'IPClusterEngines.engine_launcher_class',
+))
+class IPClusterEngines(ClusterApplication):
             
-    def start_engines(self, r=None):
-        # self.log.info("In start_engines")
-        config = self.config
+    name = u'ipcluster'
+    description = engines_help
+    usage = None
+    default_config_file_name = default_config_file_name
+    default_log_level = logging.INFO
+    auto_create_cluster_dir = Bool(False)
+    classes = List()
+    def _classes_default(self):
+        from IPython.parallel.apps import launcher
+        launchers = launcher.all_launchers
+        eslaunchers = [ l for l in launchers if 'EngineSet' in l.__name__]
+        return [ClusterDir]+eslaunchers
+    
+    n = Int(2, config=True,
+        help="The number of engines to start.")
+
+    engine_launcher_class = Str('LocalEngineSetLauncher',
+        config=True,
+        help="The class for launching a set of Engines."
+        )
+    daemonize = Bool(False, config=True,
+        help='Daemonize the ipcluster program. This implies --log-to-file')
+
+    def _daemonize_changed(self, name, old, new):
+        if new:
+            self.log_to_file = True
+
+    aliases = Dict(engine_aliases)
+    # flags = Dict(flags)
+    _stopping = False
+
+    def initialize(self, argv=None):
+        super(IPClusterEngines, self).initialize(argv)
+        self.init_signal()
+        self.init_launchers()
+    
+    def init_launchers(self):
+        self.engine_launcher = self.build_launcher(self.engine_launcher_class)
+        self.engine_launcher.on_stop(lambda r: self.loop.stop())
+    
+    def init_signal(self):
+        # Setup signals
+        signal.signal(signal.SIGINT, self.sigint_handler)
         
-        d = self.engine_launcher.start(
+    def build_launcher(self, clsname):
+        """import and instantiate a Launcher based on importstring"""
+        if '.' not in clsname:
+            # not a module, presume it's the raw name in apps.launcher
+            clsname = 'IPython.parallel.apps.launcher.'+clsname
+        # print repr(clsname)
+        klass = import_item(clsname)
+
+        launcher = klass(
+            work_dir=self.cluster_dir.location, config=self.config, logname=self.log.name
+        )
+        return launcher
+    
+    def start_engines(self):
+        self.log.info("Starting %i engines"%self.n)
+        self.engine_launcher.start(
             self.n,
             cluster_dir=self.cluster_dir.location
         )
-        return d
-
-    def stop_controller(self, r=None):
-        # self.log.info("In stop_controller")
-        if self.controller_launcher and self.controller_launcher.running:
-            return self.controller_launcher.stop()
 
-    def stop_engines(self, r=None):
-        # self.log.info("In stop_engines")
+    def stop_engines(self):
+        self.log.info("Stopping Engines...")
         if self.engine_launcher.running:
             d = self.engine_launcher.stop()
-            # d.addErrback(self.log_err)
             return d
         else:
             return None
 
-    def log_err(self, f):
-        self.log.error(f.getTraceback())
-        return None
-        
     def stop_launchers(self, r=None):
         if not self._stopping:
             self._stopping = True
-            # if isinstance(r, failure.Failure):
-            #     self.log.error('Unexpected error in ipcluster:')
-            #     self.log.info(r.getTraceback())
             self.log.error("IPython cluster: stopping")
-            # These return deferreds. We are not doing anything with them
-            # but we are holding refs to them as a reminder that they 
-            # do return deferreds.
-            d1 = self.stop_engines()
-            d2 = self.stop_controller()
+            self.stop_engines()
             # Wait a few seconds to let things shut down.
             dc = ioloop.DelayedCallback(self.loop.stop, 4000, self.loop)
             dc.start()
-            # reactor.callLater(4.0, reactor.stop)
 
     def sigint_handler(self, signum, frame):
+        self.log.debug("SIGINT received, stopping launchers...")
         self.stop_launchers()
         
     def start_logging(self):
         # Remove old log files of the controller and engine
         if self.clean_logs:
             log_dir = self.cluster_dir.log_dir
             for f in os.listdir(log_dir):
                 if re.match(r'ip(engine|controller)z-\d+\.(log|err|out)',f):
                     os.remove(os.path.join(log_dir, f))
         # This will remove old log files for ipcluster itself
         # super(IPClusterApp, self).start_logging()
 
     def start(self):
-        """Start the application, depending on what subcommand is used."""
-        subcmd = self.subcommand
-        if subcmd=='create':
-            # init_clusterdir step completed create action
-            return
-        elif subcmd=='start':
-            self.start_app_start()
-        elif subcmd=='stop':
-            self.start_app_stop()
-        elif subcmd=='engines':
-            self.start_app_engines()
+        """Start the app for the engines subcommand."""
+        self.log.info("IPython cluster: started")
+        # First see if the cluster is already running
+        
+        # Now log and daemonize
+        self.log.info(
+            'Starting engines with [daemon=%r]' % self.daemonize
+        )
+        # TODO: Get daemonize working on Windows or as a Windows Server.
+        if self.daemonize:
+            if os.name=='posix':
+                from twisted.scripts._twistd_unix import daemonize
+                daemonize()
+
+        dc = ioloop.DelayedCallback(self.start_engines, 0, self.loop)
+        dc.start()
+        # Now write the new pid file AFTER our new forked pid is active.
+        # self.write_pid_file()
+        try:
+            self.loop.start()
+        except KeyboardInterrupt:
+            pass
+        except zmq.ZMQError as e:
+            if e.errno == errno.EINTR:
+                pass
         else:
-            self.log.fatal("one command of '--start', '--stop', '--list', '--create', '--engines'"
-            " must be specified")
-            self.exit(-1)
+                raise
+
+start_aliases = {}
+start_aliases.update(engine_aliases)
+start_aliases.update(dict(
+    delay='IPClusterStart.delay',
+    clean_logs='IPClusterStart.clean_logs',
+))
 
-    def start_app_start(self):
+class IPClusterStart(IPClusterEngines):
+
+    name = u'ipcluster'
+    description = start_help
+    usage = None
+    default_config_file_name = default_config_file_name
+    default_log_level = logging.INFO
+    auto_create_cluster_dir = Bool(True, config=True,
+        help="whether to create the cluster_dir if it doesn't exist")
+    classes = List()
+    def _classes_default(self,):
+        from IPython.parallel.apps import launcher
+        return [ClusterDir]+launcher.all_launchers
+    
+    clean_logs = Bool(True, config=True, 
+        help="whether to cleanup old logs before starting")
+
+    delay = CFloat(1., config=True,
+        help="delay (in s) between starting the controller and the engines")
+
+    controller_launcher_class = Str('LocalControllerLauncher',
+        config=True,
+        help="The class for launching a Controller."
+        )
+    reset = Bool(False, config=True,
+        help="Whether to reset config files as part of '--create'."
+        )
+    
+    # flags = Dict(flags)
+    aliases = Dict(start_aliases)
+
+    def init_clusterdir(self):
+        try:
+            super(IPClusterStart, self).init_clusterdir()
+        except ClusterDirError:
+            raise ClusterDirError(
+                "Could not find a cluster directory. A cluster dir must "
+                "be created before running 'ipcluster start'.  Do "
+                "'ipcluster create -h' or 'ipcluster list -h' for more "
+                "information about creating and listing cluster dirs."
+            )
+    
+    def init_launchers(self):
+        self.controller_launcher = self.build_launcher(self.controller_launcher_class)
+        self.engine_launcher = self.build_launcher(self.engine_launcher_class)
+        self.controller_launcher.on_stop(self.stop_launchers)
+    
+    def start_controller(self):
+        self.controller_launcher.start(
+            cluster_dir=self.cluster_dir.location
+        )
+        
+    def stop_controller(self):
+        # self.log.info("In stop_controller")
+        if self.controller_launcher and self.controller_launcher.running:
+            return self.controller_launcher.stop()
+
+    def stop_launchers(self, r=None):
+        if not self._stopping:
+            self.stop_controller()
+            super(IPClusterStart, self).stop_launchers()
+
+    def start(self):
         """Start the app for the start subcommand."""
-        config = self.config
         # First see if the cluster is already running
         try:
             pid = self.get_pid_from_file()
         except PIDFileError:
             pass
         else:
             if self.check_pid(pid):
                 self.log.critical(
                     'Cluster is already running with [pid=%s]. '
                     'use "ipcluster stop" to stop the cluster.' % pid
                 )
                 # Here I exit with a unusual exit status that other processes
                 # can watch for to learn how I existed.
                 self.exit(ALREADY_STARTED)
             else:
                 self.remove_pid_file()
                 
 
         # Now log and daemonize
         self.log.info(
             'Starting ipcluster with [daemon=%r]' % self.daemonize
         )
         # TODO: Get daemonize working on Windows or as a Windows Server.
         if self.daemonize:
             if os.name=='posix':
                 from twisted.scripts._twistd_unix import daemonize
                 daemonize()
 
+        dc = ioloop.DelayedCallback(self.start_controller, 0, self.loop)
+        dc.start()
+        dc = ioloop.DelayedCallback(self.start_engines, 1000*self.delay, self.loop)
+        dc.start()
         # Now write the new pid file AFTER our new forked pid is active.
         self.write_pid_file()
         try:
             self.loop.start()
         except KeyboardInterrupt:
             pass
         except zmq.ZMQError as e:
             if e.errno == errno.EINTR:
                 pass
             else:
                 raise
         finally:
             self.remove_pid_file()
 
-    def start_app_engines(self):
-        """Start the app for the start subcommand."""
-        config = self.config
-        # First see if the cluster is already running
-        
-        # Now log and daemonize
-        self.log.info(
-            'Starting engines with [daemon=%r]' % self.daemonize
-        )
-        # TODO: Get daemonize working on Windows or as a Windows Server.
-        if self.daemonize:
-            if os.name=='posix':
-                from twisted.scripts._twistd_unix import daemonize
-                daemonize()
+base='IPython.parallel.apps.ipclusterapp.IPCluster'
 
-        # Now write the new pid file AFTER our new forked pid is active.
-        # self.write_pid_file()
-        try:
-            self.loop.start()
-        except KeyboardInterrupt:
-            pass
-        except zmq.ZMQError as e:
-            if e.errno == errno.EINTR:
-                pass
-            else:
-                raise
-        # self.remove_pid_file()
-    
-    def start_app_stop(self):
-        """Start the app for the stop subcommand."""
-        config = self.config
-        try:
-            pid = self.get_pid_from_file()
-        except PIDFileError:
-            self.log.critical(
-                'Could not read pid file, cluster is probably not running.'
-            )
-            # Here I exit with a unusual exit status that other processes
-            # can watch for to learn how I existed.
-            self.remove_pid_file()
-            self.exit(ALREADY_STOPPED)
+class IPClusterApp(Application):
+    name = u'ipcluster'
+    description = _description
         
-        if not self.check_pid(pid):
-            self.log.critical(
-                'Cluster [pid=%r] is not running.' % pid
-            )
-            self.remove_pid_file()
-            # Here I exit with a unusual exit status that other processes
-            # can watch for to learn how I existed.
-            self.exit(ALREADY_STOPPED)
+    subcommands = {'create' : (base+'Create', create_help),
+                'list' : (base+'List', list_help),
+                'start' : (base+'Start', start_help),
+                'stop' : (base+'Stop', stop_help),
+                'engines' : (base+'Engines', engines_help),
+    }
             
-        elif os.name=='posix':
-            sig = self.signal
-            self.log.info(
-                "Stopping cluster [pid=%r] with [signal=%r]" % (pid, sig)
-            )
-            try:
-                os.kill(pid, sig)
-            except OSError:
-                self.log.error("Stopping cluster failed, assuming already dead.",
-                    exc_info=True)
-                self.remove_pid_file()
-        elif os.name=='nt':
-            try:
-                # kill the whole tree
-                p = check_call(['taskkill', '-pid', str(pid), '-t', '-f'], stdout=PIPE,stderr=PIPE)
-            except (CalledProcessError, OSError):
-                self.log.error("Stopping cluster failed, assuming already dead.",
-                    exc_info=True)
-            self.remove_pid_file()
+    # no aliases or flags for parent App
+    aliases = Dict()
+    flags = Dict()
 
+    def start(self):
+        if self.subapp is None:
+            print "No subcommand specified! Must specify one of: %s"%(self.subcommands.keys())
+            print
+            self.print_subcommands()
+            self.exit(1)
+        else:
+            return self.subapp.start()
 
 def launch_new_instance():
     """Create and run the IPython cluster."""
     app = IPClusterApp()
-    app.parse_command_line()
-    cl_config = app.config
-    app.init_clusterdir()
-    if app.config_file:
-        app.load_config_file(app.config_file)
-    else:
-        app.load_config_file(app.default_config_file_name, path=app.cluster_dir.location)
-    # command-line should *override* config file, but command-line is necessary
-    # to determine clusterdir, etc.
-    app.update_config(cl_config)
-
-    app.to_work_dir()
-    app.init_launchers()
-
+    app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()
 

IPython/parallel/apps/ipcontrollerapp.py

@@ -1,408 +1,400 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 os
 import logging
 import socket
 import stat
 import sys
 import uuid
 
 from multiprocessing import Process
 
 import zmq
 from zmq.devices import ProcessMonitoredQueue
 from zmq.log.handlers import PUBHandler
 from zmq.utils import jsonapi as json
 
 from IPython.config.loader import Config
 
 from IPython.parallel import factory
 
 from IPython.parallel.apps.clusterdir import (
     ClusterDir,
-    ClusterDirApplication,
+    ClusterApplication,
     base_flags
     # ClusterDirConfigLoader
 )
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Instance, Unicode, Bool, List, CStr, Dict
 
 # from IPython.parallel.controller.controller import ControllerFactory
 from IPython.parallel.streamsession import StreamSession
 from IPython.parallel.controller.heartmonitor import HeartMonitor
 from IPython.parallel.controller.hub import Hub, HubFactory
 from IPython.parallel.controller.scheduler import TaskScheduler,launch_scheduler
 from IPython.parallel.controller.sqlitedb import SQLiteDB
 
 from IPython.parallel.util import signal_children,disambiguate_ip_address, split_url
 
 # conditional import of MongoDB backend class
 
 try:
     from IPython.parallel.controller.mongodb import MongoDB
 except ImportError:
     maybe_mongo = []
 else:
     maybe_mongo = [MongoDB]
 
 
 #-----------------------------------------------------------------------------
 # 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.
 """
 
 
 
 
 #-----------------------------------------------------------------------------
 # The main application
 #-----------------------------------------------------------------------------
 flags = {}
 flags.update(base_flags)
 flags.update({
     'usethreads' : ( {'IPControllerApp' : {'usethreads' : True}},
                     'Use threads instead of processes for the schedulers'),
     'sqlitedb' : ({'HubFactory' : {'db_class' : 'IPython.parallel.controller.sqlitedb.SQLiteDB'}},
                     'use the SQLiteDB backend'),
     'mongodb' : ({'HubFactory' : {'db_class' : 'IPython.parallel.controller.mongodb.MongoDB'}},
                     'use the MongoDB backend'),
     'dictdb' : ({'HubFactory' : {'db_class' : 'IPython.parallel.controller.dictdb.DictDB'}},
                     'use the in-memory DictDB backend'),
 })
 
 flags.update()
 
-class IPControllerApp(ClusterDirApplication):
+class IPControllerApp(ClusterApplication):
 
     name = u'ipcontroller'
     description = _description
     # command_line_loader = IPControllerAppConfigLoader
     default_config_file_name = default_config_file_name
     auto_create_cluster_dir = True
     classes = [ClusterDir, StreamSession, HubFactory, TaskScheduler, HeartMonitor, SQLiteDB] + maybe_mongo
     
     reuse_files = Bool(False, config=True,
         help='Whether to reuse existing json connection files [default: False]'
     )
     secure = Bool(True, config=True,
         help='Whether to use exec_keys for extra authentication [default: True]'
     )
     ssh_server = Unicode(u'', config=True,
         help="""ssh url for clients to use when connecting to the Controller
         processes. It should be of the form: [user@]server[:port]. The
         Controller\'s listening addresses must be accessible from the ssh server""",
     )
     location = Unicode(u'', config=True,
         help="""The external IP or domain name of the Controller, used for disambiguating
         engine and client connections.""",
     )
     import_statements = List([], config=True,
         help="import statements to be run at startup.  Necessary in some environments"
     )
 
     usethreads = Bool(False, config=True,
         help='Use threads instead of processes for the schedulers',
         )
 
     # internal
     children = List()
     mq_class = CStr('zmq.devices.ProcessMonitoredQueue')
 
     def _usethreads_changed(self, name, old, new):
         self.mq_class = 'zmq.devices.%sMonitoredQueue'%('Thread' if new else 'Process')
 
     aliases = Dict(dict(
         config = 'IPControllerApp.config_file',
         # file = 'IPControllerApp.url_file',
         log_level = 'IPControllerApp.log_level',
         reuse_files = 'IPControllerApp.reuse_files',
         secure = 'IPControllerApp.secure',
         ssh = 'IPControllerApp.ssh_server',
         usethreads = 'IPControllerApp.usethreads',
         import_statements = 'IPControllerApp.import_statements',
         location = 'IPControllerApp.location',
 
         ident = 'StreamSession.session',
         user = 'StreamSession.username',
         exec_key = 'StreamSession.keyfile',
 
         url = 'HubFactory.url',
         ip = 'HubFactory.ip',
         transport = 'HubFactory.transport',
         port = 'HubFactory.regport',
 
         ping = 'HeartMonitor.period',
 
         scheme = 'TaskScheduler.scheme_name',
         hwm = 'TaskScheduler.hwm',
 
 
         profile = "ClusterDir.profile",
         cluster_dir = 'ClusterDir.location',
         
     ))
     flags = Dict(flags)
     
 
     def save_connection_dict(self, fname, cdict):
         """save a connection dict to json file."""
         c = self.config
         url = cdict['url']
         location = cdict['location']
         if not location:
             try:
                 proto,ip,port = split_url(url)
             except AssertionError:
                 pass
             else:
                 location = socket.gethostbyname_ex(socket.gethostname())[2][-1]
             cdict['location'] = location
         fname = os.path.join(self.cluster_dir.security_dir, fname)
         with open(fname, 'w') as f:
             f.write(json.dumps(cdict, indent=2))
         os.chmod(fname, stat.S_IRUSR|stat.S_IWUSR)
     
     def load_config_from_json(self):
         """load config from existing json connector files."""
         c = self.config
         # load from engine config
         with open(os.path.join(self.cluster_dir.security_dir, 'ipcontroller-engine.json')) as f:
             cfg = json.loads(f.read())
         key = c.StreamSession.key = cfg['exec_key']
         xport,addr = cfg['url'].split('://')
         c.HubFactory.engine_transport = xport
         ip,ports = addr.split(':')
         c.HubFactory.engine_ip = ip
         c.HubFactory.regport = int(ports)
         self.location = cfg['location']
         
         # load client config
         with open(os.path.join(self.cluster_dir.security_dir, 'ipcontroller-client.json')) as f:
             cfg = json.loads(f.read())
         assert key == cfg['exec_key'], "exec_key mismatch between engine and client keys"
         xport,addr = cfg['url'].split('://')
         c.HubFactory.client_transport = xport
         ip,ports = addr.split(':')
         c.HubFactory.client_ip = ip
         self.ssh_server = cfg['ssh']
         assert int(ports) == c.HubFactory.regport, "regport mismatch"
     
     def init_hub(self):
         # This is the working dir by now.
         sys.path.insert(0, '')
         c = self.config
         
         self.do_import_statements()
         reusing = self.reuse_files
         if reusing:
             try:
                 self.load_config_from_json()
             except (AssertionError,IOError):
                 reusing=False
         # check again, because reusing may have failed:
         if reusing:
             pass
         elif self.secure:
             key = str(uuid.uuid4())
             # keyfile = os.path.join(self.cluster_dir.security_dir, self.exec_key)
             # with open(keyfile, 'w') as f:
             #     f.write(key)
             # os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
             c.StreamSession.key = key
         else:
             key = c.StreamSession.key = ''
         
         try:
             self.factory = HubFactory(config=c, log=self.log)
             # self.start_logging()
             self.factory.init_hub()
         except:
             self.log.error("Couldn't construct the Controller", exc_info=True)
             self.exit(1)
         
         if not reusing:
             # save to new json config files
             f = self.factory
             cdict = {'exec_key' : key,
                     'ssh' : self.ssh_server,
                     'url' : "%s://%s:%s"%(f.client_transport, f.client_ip, f.regport),
                     'location' : self.location
                     }
             self.save_connection_dict('ipcontroller-client.json', cdict)
             edict = cdict
             edict['url']="%s://%s:%s"%((f.client_transport, f.client_ip, f.regport))
             self.save_connection_dict('ipcontroller-engine.json', edict)
 
     #
     def init_schedulers(self):
         children = self.children
         mq = import_item(self.mq_class)
         
         hub = self.factory
         # maybe_inproc = 'inproc://monitor' if self.usethreads else self.monitor_url
         # IOPub relay (in a Process)
         q = mq(zmq.PUB, zmq.SUB, zmq.PUB, 'N/A','iopub')
         q.bind_in(hub.client_info['iopub'])
         q.bind_out(hub.engine_info['iopub'])
         q.setsockopt_out(zmq.SUBSCRIBE, '')
         q.connect_mon(hub.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(hub.client_info['mux'])
         q.setsockopt_in(zmq.IDENTITY, 'mux')
         q.bind_out(hub.engine_info['mux'])
         q.connect_mon(hub.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(hub.client_info['control'])
         q.setsockopt_in(zmq.IDENTITY, 'control')
         q.bind_out(hub.engine_info['control'])
         q.connect_mon(hub.monitor_url)
         q.daemon=True
         children.append(q)
         try:
             scheme = self.config.TaskScheduler.scheme_name
         except AttributeError:
             scheme = TaskScheduler.scheme_name.get_default_value()
         # Task Queue (in a Process)
         if scheme == 'pure':
             self.log.warn("task::using pure XREQ Task scheduler")
             q = mq(zmq.XREP, zmq.XREQ, zmq.PUB, 'intask', 'outtask')
             # q.setsockopt_out(zmq.HWM, hub.hwm)
             q.bind_in(hub.client_info['task'][1])
             q.setsockopt_in(zmq.IDENTITY, 'task')
             q.bind_out(hub.engine_info['task'])
             q.connect_mon(hub.monitor_url)
             q.daemon=True
             children.append(q)
         elif scheme == 'none':
             self.log.warn("task::using no Task scheduler")
 
         else:
             self.log.info("task::using Python %s Task scheduler"%scheme)
             sargs = (hub.client_info['task'][1], hub.engine_info['task'],
                                 hub.monitor_url, hub.client_info['notification'])
             kwargs = dict(logname=self.log.name, loglevel=self.log_level,
                                                             config=dict(self.config))
             q = Process(target=launch_scheduler, args=sargs, kwargs=kwargs)
             q.daemon=True
             children.append(q)
 
     
     def save_urls(self):
         """save the registration urls to files."""
         c = self.config
         
         sec_dir = self.cluster_dir.security_dir
         cf = self.factory
         
         with open(os.path.join(sec_dir, 'ipcontroller-engine.url'), 'w') as f:
             f.write("%s://%s:%s"%(cf.engine_transport, cf.engine_ip, cf.regport))
         
         with open(os.path.join(sec_dir, 'ipcontroller-client.url'), 'w') as f:
             f.write("%s://%s:%s"%(cf.client_transport, cf.client_ip, cf.regport))
         
     
     def do_import_statements(self):
         statements = self.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.config.Global.log_url:
     #         context = self.factory.context
     #         lsock = context.socket(zmq.PUB)
     #         lsock.connect(self.config.Global.log_url)
     #         handler = PUBHandler(lsock)
     #         handler.root_topic = 'controller'
     #         handler.setLevel(self.log_level)
     #         self.log.addHandler(handler)
     # #
+    
+    def initialize(self, argv=None):
+        super(IPControllerApp, self).initialize(argv)
+        self.init_hub()
+        self.init_schedulers()
+    
     def start(self):
         # Start the subprocesses:
         self.factory.start()
         child_procs = []
         for child in self.children:
             child.start()
             if isinstance(child, ProcessMonitoredQueue):
                 child_procs.append(child.launcher)
             elif isinstance(child, Process):
                 child_procs.append(child)
         if child_procs:
             signal_children(child_procs)
 
         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.parse_command_line()
-    cl_config = app.config
-    # app.load_config_file()
-    app.init_clusterdir()
-    if app.config_file:
-        app.load_config_file(app.config_file)
-    else:
-        app.load_config_file(app.default_config_file_name, path=app.cluster_dir.location)
-    # command-line should *override* config file, but command-line is necessary
-    # to determine clusterdir, etc.
-    app.update_config(cl_config)
-
-    app.to_work_dir()
-    app.init_hub()
-    app.init_schedulers()
-
+    app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()

IPython/parallel/apps/ipengineapp.py

@@ -1,301 +1,290 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 json
 import os
 import sys
 
 import zmq
 from zmq.eventloop import ioloop
 
 from IPython.parallel.apps.clusterdir import (
-    ClusterDirApplication,
+    ClusterApplication,
     ClusterDir,
     base_aliases,
     # ClusterDirConfigLoader
 )
 from IPython.zmq.log import EnginePUBHandler
 
 from IPython.config.configurable import Configurable
 from IPython.parallel.streamsession import StreamSession
 from IPython.parallel.engine.engine import EngineFactory
 from IPython.parallel.engine.streamkernel import Kernel
 from IPython.parallel.util import disambiguate_url
 
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Str, Bool, Unicode, Dict, List, CStr
 
 
 #-----------------------------------------------------------------------------
 # Module level variables
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application
 default_config_file_name = u'ipengine_config.py'
 
 _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.
 """
 
 
 #-----------------------------------------------------------------------------
 # MPI configuration
 #-----------------------------------------------------------------------------
 
 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
 """
 
 class MPI(Configurable):
     """Configurable for MPI initialization"""
     use = Str('', config=True,
         help='How to enable MPI (mpi4py, pytrilinos, or empty string to disable).'
         )
 
     def _on_use_changed(self, old, new):
         # load default init script if it's not set
         if not self.init_script:
             self.init_script = self.default_inits.get(new, '')
 
     init_script = Str('', config=True,
         help="Initialization code for MPI")
 
     default_inits = Dict({'mpi4py' : mpi4py_init, 'pytrilinos':pytrilinos_init},
         config=True)
 
 
 #-----------------------------------------------------------------------------
 # Main application
 #-----------------------------------------------------------------------------
 
 
-class IPEngineApp(ClusterDirApplication):
+class IPEngineApp(ClusterApplication):
 
     app_name = Unicode(u'ipengine')
     description = Unicode(_description)
     default_config_file_name = default_config_file_name
     classes = List([ClusterDir, StreamSession, EngineFactory, Kernel, MPI])
 
+    auto_create_cluster_dir = Bool(False, config=True,
+        help="whether to create the cluster_dir if it doesn't exist")
+    
     startup_script = Unicode(u'', config=True,
         help='specify a script to be run at startup')
     startup_command = Str('', config=True,
             help='specify a command to be run at startup')
 
     url_file = Unicode(u'', config=True,
         help="""The full location of the file containing the connection information for
         the controller. If this is not given, the file must be in the
         security directory of the cluster directory.  This location is
         resolved using the `profile` or `cluster_dir` options.""",
         )
 
     url_file_name = Unicode(u'ipcontroller-engine.json')
 
     aliases = Dict(dict(
         config = 'IPEngineApp.config_file',
         file = 'IPEngineApp.url_file',
         c = 'IPEngineApp.startup_command',
         s = 'IPEngineApp.startup_script',
 
         ident = 'StreamSession.session',
         user = 'StreamSession.username',
         exec_key = 'StreamSession.keyfile',
 
         url = 'EngineFactory.url',
         ip = 'EngineFactory.ip',
         transport = 'EngineFactory.transport',
         port = 'EngineFactory.regport',
         location = 'EngineFactory.location',
 
         timeout = 'EngineFactory.timeout',
 
         profile = "ClusterDir.profile",
         cluster_dir = 'ClusterDir.location',
 
         mpi = 'MPI.use',
 
         log_level = 'IPEngineApp.log_level',
     ))
 
     # 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 find_url_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.config
         # Find the actual controller key file
         if not self.url_file:
             self.url_file = os.path.join(
                 self.cluster_dir.security_dir,
                 self.url_file_name
             )
         
     def init_engine(self):
         # This is the working dir by now.
         sys.path.insert(0, '')
         config = self.config
         # print config
         self.find_url_file()
 
         # if os.path.exists(config.Global.key_file) and config.Global.secure:
         #     config.SessionFactory.exec_key = config.Global.key_file
         if os.path.exists(self.url_file):
             with open(self.url_file) as f:
                 d = json.loads(f.read())
                 for k,v in d.iteritems():
                     if isinstance(v, unicode):
                         d[k] = v.encode()
             if d['exec_key']:
                 config.StreamSession.key = d['exec_key']
             d['url'] = disambiguate_url(d['url'], d['location'])
             config.EngineFactory.url = d['url']
             config.EngineFactory.location = d['location']
         
         try:
             exec_lines = config.Kernel.exec_lines
         except AttributeError:
             config.Kernel.exec_lines = []
             exec_lines = config.Kernel.exec_lines
         
         if self.startup_script:
             enc = sys.getfilesystemencoding() or 'utf8'
             cmd="execfile(%r)"%self.startup_script.encode(enc)
             exec_lines.append(cmd)
         if self.startup_command:
             exec_lines.append(self.startup_command)
 
         # Create the underlying shell class and Engine
         # shell_class = import_item(self.master_config.Global.shell_class)
         # print self.config
         try:
             self.engine = EngineFactory(config=config, log=self.log)
         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 init_mpi(self):
         global mpi
         self.mpi = MPI(config=self.config)
 
         mpi_import_statement = self.mpi.init_script
         if mpi_import_statement:
             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 initialize(self, argv=None):
+        super(IPEngineApp, self).initialize(argv)
+        self.init_mpi()
+        self.init_engine()
 
     def start(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 engine"""
     app = IPEngineApp()
-    app.parse_command_line()
-    cl_config = app.config
-    app.init_clusterdir()
-    # app.load_config_file()
-    # print app.config
-    if app.config_file:
-        app.load_config_file(app.config_file)
-    else:
-        app.load_config_file(app.default_config_file_name, path=app.cluster_dir.location)
-
-    # command-line should *override* config file, but command-line is necessary
-    # to determine clusterdir, etc.
-    app.update_config(cl_config)
-
-    # print app.config
-    app.to_work_dir()
-    app.init_mpi()
-    app.init_engine()
-    print app.config
+    app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()
 

IPython/parallel/apps/iploggerapp.py

@@ -1,132 +1,132 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.parallel.apps.clusterdir import (
-    ClusterDirApplication,
+    ClusterApplication,
     ClusterDirConfigLoader
 )
 from IPython.parallel.apps.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(ClusterDirApplication):
+class IPLoggerApp(ClusterApplication):
 
     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, logname=self.log.name)
         except:
             self.log.error("Couldn't start the LogWatcher", exc_info=True)
             self.exit(1)
         
 
     def start_app(self):
         try:
             self.watcher.start()
             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()