Work on default config files and docstrings.

* Updated and documentated all the default config files.
* Updated docstrings in launcher.py and clientconnector.py.

IPython/config/default/ipcluster_config.py

@@ -1,67 +1,155 b''
 import os
 
 c = get_config()
 
-# Options are:
-# * LocalControllerLauncher
-# * PBSControllerLauncher
+#-----------------------------------------------------------------------------
+# Select which launchers to use
+#-----------------------------------------------------------------------------
+
+# This allows you to control what method is used to start the controller
+# and engines.  The following methods are currently supported:
+# * Start as a regular process on localhost.
+# * Start using mpiexec.
+# * Start using PBS
+# * Start using SSH (currently broken)
+
+# The selected launchers can be configured below.
+
+# Options are (LocalControllerLauncher, MPIExecControllerLauncher,
+# PBSControllerLauncher)
 # c.Global.controller_launcher = 'IPython.kernel.launcher.LocalControllerLauncher'
 
-# Options are:
-# * LocalEngineSetLauncher
-# * MPIExecEngineSetLauncher
-# * PBSEngineSetLauncher
+# Options are (LocalEngineSetLauncher, MPIExecEngineSetLauncher,
+# PBSEngineSetLauncher)
 # c.Global.engine_launcher = 'IPython.kernel.launcher.LocalEngineSetLauncher'
 
-# c.Global.log_to_file = False
+#-----------------------------------------------------------------------------
+# Global configuration
+#-----------------------------------------------------------------------------
+
+# The default number of engine that will be started. This is overridden by
+# the -n command line option: "ipcluster start -n 4"
 # c.Global.n = 2
-# c.Global.reset_config = False
-# c.Global.clean_logs = True
 
-# c.MPIExecLauncher.mpi_cmd = ['mpiexec']
-# c.MPIExecLauncher.mpi_args = []
-# c.MPIExecLauncher.program = []
-# c.MPIExecLauncher.program_args = []
-# c.MPIExecLauncher.n = 1
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
+# c.Global.log_to_file = False
 
-# c.SSHLauncher.ssh_cmd = ['ssh']
-# c.SSHLauncher.ssh_args = []
-# c.SSHLauncher.program = []
-# s.SSHLauncher.program_args = []
-# c.SSHLauncher.hostname = ''
-# c.SSHLauncher.user = os.environ['USER']
+# Remove old logs from cluster_dir/log before starting.
+# c.Global.clean_logs = True
 
-# c.PBSLauncher.submit_command = 'qsub'
-# c.PBSLauncher.delete_command = 'qdel'
-# c.PBSLauncher.job_id_regexp = '\d+'
-# c.PBSLauncher.batch_template = """"""
-# c.PBSLauncher.batch_file_name = u'pbs_batch_script'
+#-----------------------------------------------------------------------------
+# Controller launcher configuration
+#-----------------------------------------------------------------------------
 
-# c.LocalControllerLauncher.controller_args = []
+# Configure how the controller is started. The configuration of the controller
+# can also bet setup by editing the controller config file: 
+# ipcontroller_config.py
 
+# The command line arguments to call the controller with.
+# c.LocalControllerLauncher.controller_args = \
+#    ['--log-to-file','--log-level', '40']
+
+# The mpiexec/mpirun command to use in started the controller.
 # c.MPIExecControllerLauncher.mpi_cmd = ['mpiexec']
+
+# Additional arguments to pass to the actual mpiexec command.
 # c.MPIExecControllerLauncher.mpi_args = []
-# c.MPIExecControllerLauncher.controller_args = []
-# c.MPIExecControllerLauncher.n = 1
 
+# The command line argument to call the controller with.
+# c.MPIExecControllerLauncher.controller_args = \
+#     ['--log-to-file','--log-level', '40']
+
+# The command line program to use to submit a PBS job.
 # c.PBSControllerLauncher.submit_command = 'qsub'
+
+# The command line program to use to delete a PBS job.
 # c.PBSControllerLauncher.delete_command = 'qdel'
+
+# A regular expression that takes the output of qsub and find the job id.
 # c.PBSControllerLauncher.job_id_regexp = '\d+'
+
+# The batch submission script used to start the controller. This is where
+# environment variables would be setup, etc. This string is interpolated using
+# the Itpl module in IPython.external. Basically, you can use ${profile} for 
+# the controller profile or ${cluster_dir} for the cluster_dir.
 # c.PBSControllerLauncher.batch_template = """"""
-# c.PBSLauncher.batch_file_name = u'pbs_batch_script'
 
-# c.LocalEngineLauncher.engine_args = []
+# The name of the instantiated batch script that will actually be used to
+# submit the job. This will be written to the cluster directory.
+# c.PBSControllerLauncher.batch_file_name = u'pbs_batch_script_controller'
+
+#-----------------------------------------------------------------------------
+# Engine launcher configuration
+#-----------------------------------------------------------------------------
 
-# c.LocalEngineSetLauncher.engine_args = []
+# Command line argument passed to the engines.
+# c.LocalEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
 
+# The mpiexec/mpirun command to use in started the controller.
 # c.MPIExecEngineSetLauncher.mpi_cmd = ['mpiexec']
+
+# Additional arguments to pass to the actual mpiexec command.
 # c.MPIExecEngineSetLauncher.mpi_args = []
-# c.MPIExecEngineSetLauncher.controller_args = []
+
+# Command line argument passed to the engines.
+# c.MPIExecEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
+
+# The default number of engines to start if not given elsewhere.
 # c.MPIExecEngineSetLauncher.n = 1
 
+# The command line program to use to submit a PBS job.
 # c.PBSEngineSetLauncher.submit_command = 'qsub'
+
+# The command line program to use to delete a PBS job.
 # c.PBSEngineSetLauncher.delete_command = 'qdel'
+
+# A regular expression that takes the output of qsub and find the job id.
 # c.PBSEngineSetLauncher.job_id_regexp = '\d+'
+
+# The batch submission script used to start the engines. This is where
+# environment variables would be setup, etc. This string is interpolated using
+# the Itpl module in IPython.external. Basically, you can use ${n} for the
+# number of engine, ${profile} or the engine profile and ${cluster_dir} 
+# for the cluster_dir.
 # c.PBSEngineSetLauncher.batch_template = """"""
-# c.PBSEngineSetLauncher.batch_file_name = u'pbs_batch_script'
+
+# The name of the instantiated batch script that will actually be used to
+# submit the job. This will be written to the cluster directory.
+# c.PBSEngineSetLauncher.batch_file_name = u'pbs_batch_script_engines'
+
+#-----------------------------------------------------------------------------
+# Base launcher configuration
+#-----------------------------------------------------------------------------
+
+# The various launchers are organized into an inheritance hierarchy. 
+# The configurations can also be iherited and the following attributes 
+# allow you to configure the base classes.
+
+# c.MPIExecLauncher.mpi_cmd = ['mpiexec']
+# c.MPIExecLauncher.mpi_args = []
+# c.MPIExecLauncher.program = []
+# c.MPIExecLauncher.program_args = []
+# c.MPIExecLauncher.n = 1
+
+# c.SSHLauncher.ssh_cmd = ['ssh']
+# c.SSHLauncher.ssh_args = []
+# c.SSHLauncher.program = []
+# s.SSHLauncher.program_args = []
+# c.SSHLauncher.hostname = ''
+# c.SSHLauncher.user = os.environ['USER']
+
+# c.BatchSystemLauncher.submit_command
+# c.BatchSystemLauncher.delete_command
+# c.BatchSystemLauncher.job_id_regexp
+# c.BatchSystemLauncher.batch_template
+# c.BatchSystemLauncher.batch_file_name
+
+# c.PBSLauncher.submit_command = 'qsub'
+# c.PBSLauncher.delete_command = 'qdel'
+# c.PBSLauncher.job_id_regexp = '\d+'
+# c.PBSLauncher.batch_template = """"""
+# c.PBSLauncher.batch_file_name = u'pbs_batch_script'
+
+
+
 

IPython/config/default/ipcontroller_config.py

@@ -1,68 +1,132 b''
 from IPython.config.loader import Config
 
 c = get_config()
 
 #-----------------------------------------------------------------------------
 # Global configuration
 #-----------------------------------------------------------------------------
 
 # Basic Global config attributes
+
+# Start up messages are logged to stdout using the logging module.
+# These all happen before the twisted reactor is started and are
+# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
+# and smaller is more verbose.
+# c.Global.log_level = 20
+
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
 # c.Global.log_to_file = False
+
+# Remove old logs from cluster_dir/log before starting.
 # c.Global.clean_logs = True
+
+# A list of Python statements that will be run before starting the 
+# controller. This is provided because occasionally certain things need to 
+# be imported in the controller for pickling to work.
 # c.Global.import_statements = ['import math']
+
+# Reuse the controller's FURL files. If False, FURL files are regenerated
+# each time the controller is run. If True, they will be reused, *but*, you
+# also must set the network ports by hand. If set, this will override the
+# values set for the client and engine connections below.
 # c.Global.reuse_furls = True
+
+# Enable SSL encryption on all connections to the controller. If set, this
+# will override the values set for the client and engine connections below.
 # c.Global.secure = True
 
 #-----------------------------------------------------------------------------
 # Configure the client services
 #-----------------------------------------------------------------------------
 
 # Basic client service config attributes
+
+# The network interface the controller will listen on for client connections.
+# This should be an IP address or hostname of the controller's host. The empty
+# string means listen on all interfaces.
 # c.FCClientServiceFactory.ip = ''
+
+# The TCP/IP port the controller will listen on for client connections. If 0
+# a random port will be used. If the controller's host has a firewall running
+# it must allow incoming traffic on this port.
 # c.FCClientServiceFactory.port = 0
+
+# The client learns how to connect to the controller by looking at the
+# location field embedded in the FURL. If this field is empty, all network
+# interfaces that the controller is listening on will be listed. To have the
+# client connect on a particular interface, list it here.
 # c.FCClientServiceFactory.location = ''
+
+# Use SSL encryption for the client connection.
 # c.FCClientServiceFactory.secure =  True
+
+# Reuse the client FURL each time the controller is started. If set, you must
+# also pick a specific network port above (FCClientServiceFactory.port).
 # c.FCClientServiceFactory.reuse_furls = False
 
-# You shouldn't have to modify the rest of this section
+#-----------------------------------------------------------------------------
+# Configure the engine services
+#-----------------------------------------------------------------------------
+
+# Basic config attributes for the engine services.
+
+# The network interface the controller will listen on for engine connections.
+# This should be an IP address or hostname of the controller's host. The empty
+# string means listen on all interfaces.
+# c.FCEngineServiceFactory.ip = ''
+
+# The TCP/IP port the controller will listen on for engine connections. If 0
+# a random port will be used. If the controller's host has a firewall running
+# it must allow incoming traffic on this port.
+# c.FCEngineServiceFactory.port = 0
+
+# The engine learns how to connect to the controller by looking at the
+# location field embedded in the FURL. If this field is empty, all network
+# interfaces that the controller is listening on will be listed. To have the
+# client connect on a particular interface, list it here.
+# c.FCEngineServiceFactory.location = ''
+
+# Use SSL encryption for the engine connection.
+# c.FCEngineServiceFactory.secure = True
+
+# Reuse the client FURL each time the controller is started. If set, you must
+# also pick a specific network port above (FCClientServiceFactory.port).
+# c.FCEngineServiceFactory.reuse_furls = False
+
+#-----------------------------------------------------------------------------
+# Developer level configuration attributes
+#-----------------------------------------------------------------------------
+
+# You shouldn't have to modify anything in this section. These attributes
+# are more for developers who want to change the behavior of the controller
+# at a fundamental level.
+
 # c.FCClientServiceFactory.cert_file = 'ipcontroller-client.pem'
 
 # default_client_interfaces = Config()
 # default_client_interfaces.Task.interface_chain = [
 #     'IPython.kernel.task.ITaskController',
 #     'IPython.kernel.taskfc.IFCTaskController'
 # ]
 # 
 # default_client_interfaces.Task.furl_file = 'ipcontroller-tc.furl'
 # 
 # default_client_interfaces.MultiEngine.interface_chain = [
 #     'IPython.kernel.multiengine.IMultiEngine',
 #     'IPython.kernel.multienginefc.IFCSynchronousMultiEngine'
 # ]
 # 
 # default_client_interfaces.MultiEngine.furl_file = 'ipcontroller-mec.furl'
 # 
 # c.FCEngineServiceFactory.interfaces = default_client_interfaces
 
-#-----------------------------------------------------------------------------
-# Configure the engine services
-#-----------------------------------------------------------------------------
-
-# Basic config attributes for the engine services
-# c.FCEngineServiceFactory.ip = ''
-# c.FCEngineServiceFactory.port = 0
-# c.FCEngineServiceFactory.location = ''
-# c.FCEngineServiceFactory.secure = True
-# c.FCEngineServiceFactory.reuse_furls = False
-
-# You shouldn't have to modify the rest of this section
 # c.FCEngineServiceFactory.cert_file = 'ipcontroller-engine.pem'
 
 # default_engine_interfaces = Config()
 # default_engine_interfaces.Default.interface_chain = [
 #     'IPython.kernel.enginefc.IFCControllerBase'
 # ]
 # 
 # default_engine_interfaces.Default.furl_file = 'ipcontroller-engine.furl'
 # 
 # c.FCEngineServiceFactory.interfaces = default_engine_interfaces

IPython/config/default/ipengine_config.py

@@ -1,28 +1,86 b''
 c = get_config()
 
+#-----------------------------------------------------------------------------
+# Global configuration
+#-----------------------------------------------------------------------------
+
+# Start up messages are logged to stdout using the logging module.
+# These all happen before the twisted reactor is started and are
+# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
+# and smaller is more verbose.
+# c.Global.log_level = 20
+
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
 # c.Global.log_to_file = False
-# c.Global.clean_logs = False
+
+# Remove old logs from cluster_dir/log before starting.
+# c.Global.clean_logs = True
+
+# A list of strings that will be executed in the users namespace on the engine
+# before it connects to the controller.
 # c.Global.exec_lines = ['import numpy']
-# c.Global.log_level = 10
-# c.Global.shell_class = 'IPython.kernel.core.interpreter.Interpreter'
-# c.Global.furl_file_name = 'ipcontroller-engine.furl'
-# c.Global.furl_file = ''
-# The max number of connection attemps and the initial delay between
+
+# The engine will try to connect to the controller multiple times, to allow
+# the controller time to startup and write its FURL file. These parameters 
+# control the number of retries (connect_max_tries) and the initial delay
+# (connect_delay) between attemps. The actual delay between attempts gets
+# longer each time by a factor of 1.5 (delay[i] = 1.5*delay[i-1])
 # those attemps.
 # c.Global.connect_delay = 0.1
 # c.Global.connect_max_tries = 15
 
+# By default, the engine will look for the controller's FURL file in its own
+# cluster directory. Sometimes, the FURL file will be elsewhere and this 
+# attribute can be set to the full path of the FURL file.
+# c.Global.furl_file = ''
+
+#-----------------------------------------------------------------------------
+# MPI configuration
+#-----------------------------------------------------------------------------
 
+# Upon starting the engine can be configured to call MPI_Init. This section
+# configures that.
+
+# Select which MPI section to execute to setup MPI. The value of this 
+# attribute must match the name of another attribute in the MPI config 
+# section (mpi4py, pytrilinos, etc.). This can also be set by the --mpi
+# command line option.
 # c.MPI.use = ''
+
+# Initialize MPI using mpi4py. To use this, set c.MPI.use = 'mpi4py' to use
+# --mpi=mpi4py at the command line.
 # c.MPI.mpi4py = """from mpi4py import MPI as mpi
 # mpi.size = mpi.COMM_WORLD.Get_size()
 # mpi.rank = mpi.COMM_WORLD.Get_rank()
 # """
+
+# Initialize MPI using pytrilinos. To use this, set c.MPI.use = 'pytrilinos' 
+# to use --mpi=pytrilinos at the command line.
 # c.MPI.pytrilinos = """from PyTrilinos import Epetra
 # class SimpleStruct:
 # pass
 # mpi = SimpleStruct()
 # mpi.rank = 0
 # mpi.size = 0
 # """
 
+#-----------------------------------------------------------------------------
+# Developer level configuration attributes
+#-----------------------------------------------------------------------------
+
+# You shouldn't have to modify anything in this section. These attributes
+# are more for developers who want to change the behavior of the controller
+# at a fundamental level.
+
+# You should not have to change these attributes.
+
+# c.Global.shell_class = 'IPython.kernel.core.interpreter.Interpreter'
+
+# c.Global.furl_file_name = 'ipcontroller-engine.furl'
+
+
+
+
+
+
+

IPython/kernel/clientconnector.py

@@ -1,713 +1,766 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 """Facilities for handling client connections to the controller."""
 
 #-----------------------------------------------------------------------------
 #  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
 
 from IPython.kernel.fcutil import (
     Tub,
     find_furl,
     is_valid_furl_or_file,
     validate_furl_or_file,
     FURLError
 )
 from IPython.kernel.clusterdir import ClusterDir, ClusterDirError
 from IPython.kernel.launcher import IPClusterLauncher
 from IPython.kernel.twistedutil import (
     gatherBoth, 
     make_deferred,
     blockingCallFromThread, 
     sleep_deferred
 )
 from IPython.utils.importstring import import_item
 from IPython.utils.genutils import get_ipython_dir
 
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks, returnValue
 from twisted.python import failure, log
 
 #-----------------------------------------------------------------------------
 # The ClientConnector class
 #-----------------------------------------------------------------------------
 
 DELAY = 0.2
 MAX_TRIES = 9
 
 
 class ClientConnectorError(Exception):
     pass
 
 
 class AsyncClientConnector(object):
     """A class for getting remote references and clients from furls.
 
     This start a single :class:`Tub` for all remote reference and caches
     references.
     """
 
     def __init__(self):
         self._remote_refs = {}
         self.tub = Tub()
         self.tub.startService()
 
     def _find_furl(self, profile='default', cluster_dir=None, 
                    furl_or_file=None, furl_file_name=None,
                    ipythondir=None):
         """Find a FURL file by profile+ipythondir or cluster dir.
 
         This raises an :exc:`~IPython.kernel.fcutil.FURLError` exception 
         if a FURL file can't be found.
         """
         # Try by furl_or_file
         if furl_or_file is not None:
             validate_furl_or_file(furl_or_file)
             return furl_or_file
 
         if furl_file_name is None:
             raise FURLError('A furl_file_name must be provided')
 
         # Try by cluster_dir
         if cluster_dir is not None:
             cluster_dir_obj = ClusterDir.find_cluster_dir(cluster_dir)
             sdir = cluster_dir_obj.security_dir
             furl_file = os.path.join(sdir, furl_file_name)
             validate_furl_or_file(furl_file)
             return furl_file
 
         # Try by profile
         if ipythondir is None:
             ipythondir = get_ipython_dir()
         if profile is not None:
             cluster_dir_obj = ClusterDir.find_cluster_dir_by_profile(
                 ipythondir, profile)
             sdir = cluster_dir_obj.security_dir
             furl_file = os.path.join(sdir, furl_file_name)
             validate_furl_or_file(furl_file)
             return furl_file
 
         raise FURLError('Could not find a valid FURL file.')
 
     def get_reference(self, furl_or_file):
         """Get a remote reference using a furl or a file containing a furl.
 
         Remote references are cached locally so once a remote reference
         has been retrieved for a given furl, the cached version is 
         returned.
 
         Parameters
         ----------
         furl_or_file : str
             A furl or a filename containing a furl. This should already be
             validated, but might not yet exist.
 
         Returns
         -------
         A deferred to a remote reference
         """
         furl = furl_or_file
         if furl in self._remote_refs:
             d = defer.succeed(self._remote_refs[furl])
         else:
             d = self.tub.getReference(furl)
             d.addCallback(self._save_ref, furl)
         return d
         
     def _save_ref(self, ref, furl):
         """Cache a remote reference by its furl."""
         self._remote_refs[furl] = ref
         return ref
         
     def get_task_client(self, profile='default', cluster_dir=None,
                         furl_or_file=None, ipythondir=None,
                         delay=DELAY, max_tries=MAX_TRIES):
         """Get the task controller client.
         
         This method is a simple wrapper around `get_client` that passes in
         the default name of the task client FURL file.  Usually only
         the ``profile`` option will be needed.  If a FURL file can't be
         found by its profile, use ``cluster_dir`` or ``furl_or_file``.
         
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         furl_or_file : str
             A furl or a filename containing a FURLK. This is useful if you 
             simply know the location of the FURL file.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
 
         Returns
         -------
         A deferred to the actual client class.
         """
         return self.get_client(
             profile, cluster_dir, furl_or_file, 
             'ipcontroller-tc.furl', ipythondir,
             delay, max_tries
         )
 
     def get_multiengine_client(self, profile='default', cluster_dir=None,
                                furl_or_file=None, ipythondir=None,
                                delay=DELAY, max_tries=MAX_TRIES):
         """Get the multiengine controller client.
         
         This method is a simple wrapper around `get_client` that passes in
         the default name of the task client FURL file.  Usually only
         the ``profile`` option will be needed.  If a FURL file can't be
         found by its profile, use ``cluster_dir`` or ``furl_or_file``.
         
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         furl_or_file : str
             A furl or a filename containing a FURLK. This is useful if you 
             simply know the location of the FURL file.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
-                
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
+
         Returns
         -------
         A deferred to the actual client class.
         """
         return self.get_client(
             profile, cluster_dir, furl_or_file, 
             'ipcontroller-mec.furl', ipythondir,
             delay, max_tries
         )
     
     def get_client(self, profile='default', cluster_dir=None,
                    furl_or_file=None, furl_file_name=None, ipythondir=None,
                    delay=DELAY, max_tries=MAX_TRIES):
         """Get a remote reference and wrap it in a client by furl.
 
         This method is a simple wrapper around `get_client` that passes in
         the default name of the task client FURL file.  Usually only
         the ``profile`` option will be needed.  If a FURL file can't be
         found by its profile, use ``cluster_dir`` or ``furl_or_file``.
         
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         furl_or_file : str
             A furl or a filename containing a FURL. This is useful if you 
             simply know the location of the FURL file.
         furl_file_name : str
             The filename (not the full path) of the FURL. This must be
             provided if ``furl_or_file`` is not.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
 
         Returns
         -------
         A deferred to the actual client class. Or a failure to a 
         :exc:`FURLError`.
         """
         try:
             furl_file = self._find_furl(
                 profile, cluster_dir, furl_or_file,
                 furl_file_name, ipythondir
             )
         except FURLError:
             return defer.fail(failure.Failure())
 
         def _wrap_remote_reference(rr):
             d = rr.callRemote('get_client_name')
             d.addCallback(lambda name: import_item(name))
             def adapt(client_interface):
                 client = client_interface(rr)
                 client.tub = self.tub
                 return client
             d.addCallback(adapt)
 
             return d
 
         d = self._try_to_connect(furl_file, delay, max_tries, attempt=0)
         d.addCallback(_wrap_remote_reference)
         return d
 
     @inlineCallbacks
     def _try_to_connect(self, furl_or_file, delay, max_tries, attempt):
         """Try to connect to the controller with retry logic."""
         if attempt < max_tries:
             log.msg("Connecting to controller [%r]: %s" % \
                 (attempt, furl_or_file))
             try:
                 self.furl = find_furl(furl_or_file)
                 # Uncomment this to see the FURL being tried.
                 # log.msg("FURL: %s" % self.furl)
                 rr = yield self.get_reference(self.furl)
             except:
                 if attempt==max_tries-1:
                     # This will propagate the exception all the way to the top
                     # where it can be handled.
                     raise
                 else:
                     yield sleep_deferred(delay)
                     rr = yield self._try_to_connect(
                         furl_or_file, 1.5*delay, max_tries, attempt+1
                     )
                     returnValue(rr)
             else:
                 returnValue(rr)
         else:
             raise ClientConnectorError(
                 'Could not connect to controller, max_tries (%r) exceeded. '
                 'This usually means that i) the controller was not started, '
                 'or ii) a firewall was blocking the client from connecting '
                 'to the controller.' % max_tries
             )
 
 
 class ClientConnector(object):
     """A blocking version of a client connector.
 
     This class creates a single :class:`Tub` instance and allows remote
     references and client to be retrieved by their FURLs.  Remote references
     are cached locally and FURL files can be found using profiles and cluster
     directories.
     """
 
     def __init__(self):
         self.async_cc = AsyncClientConnector()
 
     def get_task_client(self, profile='default', cluster_dir=None,
                         furl_or_file=None, ipythondir=None,
                         delay=DELAY, max_tries=MAX_TRIES):
         """Get the task client.
         
         Usually only the ``profile`` option will be needed. If a FURL file
         can't be found by its profile, use ``cluster_dir`` or
         ``furl_or_file``.
         
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         furl_or_file : str
             A furl or a filename containing a FURLK. This is useful if you 
             simply know the location of the FURL file.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
 
         Returns
         -------
         The task client instance.
         """
         client = blockingCallFromThread(
             self.async_cc.get_task_client, profile, cluster_dir,
             furl_or_file, ipythondir, delay, max_tries
         )
         return client.adapt_to_blocking_client()
 
     def get_multiengine_client(self, profile='default', cluster_dir=None,
                                furl_or_file=None, ipythondir=None,
                                delay=DELAY, max_tries=MAX_TRIES):
         """Get the multiengine client.
         
         Usually only the ``profile`` option will be needed. If a FURL file
         can't be found by its profile, use ``cluster_dir`` or
         ``furl_or_file``.
         
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         furl_or_file : str
             A furl or a filename containing a FURLK. This is useful if you 
             simply know the location of the FURL file.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
 
         Returns
         -------
         The multiengine client instance.
         """
         client = blockingCallFromThread(
             self.async_cc.get_multiengine_client, profile, cluster_dir,
             furl_or_file, ipythondir, delay, max_tries
         )
         return client.adapt_to_blocking_client()
 
     def get_client(self, profile='default', cluster_dir=None,
                    furl_or_file=None, ipythondir=None,
                    delay=DELAY, max_tries=MAX_TRIES):
         client = blockingCallFromThread(
             self.async_cc.get_client, profile, cluster_dir,
             furl_or_file, ipythondir,
             delay, max_tries
         )
         return client.adapt_to_blocking_client()
 
 
 class ClusterStateError(Exception):
     pass
 
 
 class AsyncCluster(object):
     """An class that wraps the :command:`ipcluster` script."""
 
     def __init__(self, profile='default', cluster_dir=None, ipythondir=None,
                  auto_create=False, auto_stop=True):
         """Create a class to manage an IPython cluster.
 
         This class calls the :command:`ipcluster` command with the right
         options to start an IPython cluster.  Typically a cluster directory
         must be created (:command:`ipcluster create`) and configured before 
         using this class. Configuration is done by editing the 
         configuration files in the top level of the cluster directory.
 
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
         auto_create : bool
             Automatically create the cluster directory it is dones't exist.
             This will usually only make sense if using a local cluster 
             (default=False).
         auto_stop : bool
             Automatically stop the cluster when this instance is garbage 
             collected (default=True).  This is useful if you want the cluster
             to live beyond your current process. There is also an instance
             attribute ``auto_stop`` to change this behavior.
         """
         self._setup_cluster_dir(profile, cluster_dir, ipythondir, auto_create)
         self.state = 'before'
         self.launcher = None
         self.client_connector = None
         self.auto_stop = auto_stop
 
     def __del__(self):
         if self.auto_stop and self.state=='running':
             print "Auto stopping the cluster..."
             self.stop()
 
     @property
     def location(self):
         if hasattr(self, 'cluster_dir_obj'):
             return self.cluster_dir_obj.location
         else:
             return ''
 
     @property
     def running(self):
         if self.state=='running':
             return True
         else:
             return False
 
     def _setup_cluster_dir(self, profile, cluster_dir, ipythondir, auto_create):
         if ipythondir is None:
             ipythondir = get_ipython_dir()
         if cluster_dir is not None:
             try:
                 self.cluster_dir_obj = ClusterDir.find_cluster_dir(cluster_dir)
             except ClusterDirError:
                 pass
         if profile is not None:
             try:
                 self.cluster_dir_obj = ClusterDir.find_cluster_dir_by_profile(
                     ipythondir, profile)
             except ClusterDirError:
                 pass
         if auto_create or profile=='default':
             # This should call 'ipcluster create --profile default
             self.cluster_dir_obj = ClusterDir.create_cluster_dir_by_profile(
                 ipythondir, profile)
         else:
             raise ClusterDirError('Cluster dir not found.')
 
     @make_deferred
     def start(self, n=2):
         """Start the IPython cluster with n engines.
 
         Parameters
         ----------
         n : int
             The number of engine to start.
         """
         # We might want to add logic to test if the cluster has started
         # by another process....
         if not self.state=='running':
             self.launcher = IPClusterLauncher(os.getcwd())
             self.launcher.ipcluster_n = n
             self.launcher.ipcluster_subcommand = 'start'
             d = self.launcher.start()
             d.addCallback(self._handle_start)
             return d
         else:
             raise ClusterStateError('Cluster is already running')
 
     @make_deferred
     def stop(self):
         """Stop the IPython cluster if it is running."""
         if self.state=='running':
             d1 = self.launcher.observe_stop()
             d1.addCallback(self._handle_stop)
             d2 = self.launcher.stop()
             return gatherBoth([d1, d2], consumeErrors=True)
         else:
             raise ClusterStateError("Cluster not running")
 
     def get_multiengine_client(self, delay=DELAY, max_tries=MAX_TRIES):
         """Get the multiengine client for the running cluster.
 
         If this fails, it means that the cluster has not finished starting.
         Usually waiting a few seconds are re-trying will solve this.    
         """
         if self.client_connector is None:
             self.client_connector = AsyncClientConnector()
         return self.client_connector.get_multiengine_client(
             cluster_dir=self.cluster_dir_obj.location,
             delay=delay, max_tries=max_tries
         )
 
     def get_task_client(self, delay=DELAY, max_tries=MAX_TRIES):
         """Get the task client for the running cluster.
 
         If this fails, it means that the cluster has not finished starting.
         Usually waiting a few seconds are re-trying will solve this.    
         """
         if self.client_connector is None:
             self.client_connector = AsyncClientConnector()
         return self.client_connector.get_task_client(
             cluster_dir=self.cluster_dir_obj.location,
             delay=delay, max_tries=max_tries
         )
 
     def get_ipengine_logs(self):
         return self.get_logs_by_name('ipengine')
 
     def get_ipcontroller_logs(self):
         return self.get_logs_by_name('ipcontroller')
 
     def get_ipcluster_logs(self):
         return self.get_logs_by_name('ipcluster')
 
     def get_logs_by_name(self, name='ipcluster'):
         log_dir = self.cluster_dir_obj.log_dir
         logs = {}
         for log in os.listdir(log_dir):
             if log.startswith(name + '-') and log.endswith('.log'):
                 with open(os.path.join(log_dir, log), 'r') as f:
                     logs[log] = f.read()
         return logs
 
     def get_logs(self):
         d = self.get_ipcluster_logs()
         d.update(self.get_ipengine_logs())
         d.update(self.get_ipcontroller_logs())
         return d
 
     def _handle_start(self, r):
         self.state = 'running'
 
     def _handle_stop(self, r):
         self.state = 'after'
 
 
 class Cluster(object):
 
 
     def __init__(self, profile='default', cluster_dir=None, ipythondir=None,
                  auto_create=False, auto_stop=True):
         """Create a class to manage an IPython cluster.
 
         This class calls the :command:`ipcluster` command with the right
         options to start an IPython cluster.  Typically a cluster directory
         must be created (:command:`ipcluster create`) and configured before 
         using this class. Configuration is done by editing the 
         configuration files in the top level of the cluster directory.
 
         Parameters
         ----------
         profile : str
             The name of a cluster directory profile (default="default"). The
             cluster directory "cluster_<profile>" will be searched for
             in ``os.getcwd()``, the ipythondir and then in the directories
             listed in the :env:`IPCLUSTERDIR_PATH` environment variable.
         cluster_dir : str
             The full path to a cluster directory.  This is useful if profiles
             are not being used.
         ipythondir : str
             The location of the ipythondir if different from the default.
             This is used if the cluster directory is being found by profile.
         auto_create : bool
             Automatically create the cluster directory it is dones't exist.
             This will usually only make sense if using a local cluster 
             (default=False).
         auto_stop : bool
             Automatically stop the cluster when this instance is garbage 
             collected (default=True).  This is useful if you want the cluster
             to live beyond your current process. There is also an instance
             attribute ``auto_stop`` to change this behavior.
         """
         self.async_cluster = AsyncCluster(
             profile, cluster_dir, ipythondir, auto_create, auto_stop
         )
         self.cluster_dir_obj = self.async_cluster.cluster_dir_obj
         self.client_connector = None
 
     def _set_auto_stop(self, value):
         self.async_cluster.auto_stop = value
 
     def _get_auto_stop(self):
         return self.async_cluster.auto_stop
 
     auto_stop = property(_get_auto_stop, _set_auto_stop)
 
     @property
     def location(self):
         return self.async_cluster.location
 
     @property
     def running(self):
         return self.async_cluster.running
 
     def start(self, n=2):
         """Start the IPython cluster with n engines.
 
         Parameters
         ----------
         n : int
             The number of engine to start.
         """
         return blockingCallFromThread(self.async_cluster.start, n)
 
     def stop(self):
         """Stop the IPython cluster if it is running."""
         return blockingCallFromThread(self.async_cluster.stop)
 
     def get_multiengine_client(self, delay=DELAY, max_tries=MAX_TRIES):
         """Get the multiengine client for the running cluster.
 
-        If this fails, it means that the cluster has not finished starting.
-        Usually waiting a few seconds are re-trying will solve this.    
+        This will try to attempt to the controller multiple times. If this 
+        fails altogether, try looking at the following:
+        * Make sure the controller is starting properly by looking at its
+          log files.
+        * Make sure the controller is writing its FURL file in the location
+          expected by the client.
+        * Make sure a firewall on the controller's host is not blocking the
+          client from connecting.
+
+        Parameters
+        ----------
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
         """
         if self.client_connector is None:
             self.client_connector = ClientConnector()
         return self.client_connector.get_multiengine_client(
             cluster_dir=self.cluster_dir_obj.location,
             delay=delay, max_tries=max_tries
         )
 
     def get_task_client(self, delay=DELAY, max_tries=MAX_TRIES):
         """Get the task client for the running cluster.
 
-        If this fails, it means that the cluster has not finished starting.
-        Usually waiting a few seconds are re-trying will solve this.    
+        This will try to attempt to the controller multiple times. If this 
+        fails altogether, try looking at the following:
+        * Make sure the controller is starting properly by looking at its
+          log files.
+        * Make sure the controller is writing its FURL file in the location
+          expected by the client.
+        * Make sure a firewall on the controller's host is not blocking the
+          client from connecting.
+
+        Parameters
+        ----------
+        delay : float
+            The initial delay between re-connection attempts. Susequent delays
+            get longer according to ``delay[i] = 1.5*delay[i-1]``.
+        max_tries : int
+            The max number of re-connection attempts.
         """
         if self.client_connector is None:
             self.client_connector = ClientConnector()
         return self.client_connector.get_task_client(
             cluster_dir=self.cluster_dir_obj.location,
             delay=delay, max_tries=max_tries
         )
 
     def __repr__(self):
         s = "<Cluster(running=%r, location=%s)" % (self.running, self.location)
         return s
 
     def get_logs_by_name(self, name='ipcluter'):
         """Get a dict of logs by process name (ipcluster, ipengine, etc.)"""
         return self.async_cluster.get_logs_by_name(name)
 
     def get_ipengine_logs(self):
         """Get a dict of logs for all engines in this cluster."""
         return self.async_cluster.get_ipengine_logs()
 
     def get_ipcontroller_logs(self):
         """Get a dict of logs for the controller in this cluster."""
         return self.async_cluster.get_ipcontroller_logs()
 
     def get_ipcluster_logs(self):
         """Get a dict of the ipcluster logs for this cluster."""
         return self.async_cluster.get_ipcluster_logs()
 
     def get_logs(self):
         """Get a dict of all logs for this cluster."""
         return self.async_cluster.get_logs()
 
     def _print_logs(self, logs):
         for k, v in logs.iteritems():
             print "==================================="
             print "Logfile: %s" % k
             print "==================================="
             print v
             print
 
     def print_ipengine_logs(self):
         """Print the ipengine logs for this cluster to stdout."""
         self._print_logs(self.get_ipengine_logs())
 
     def print_ipcontroller_logs(self):
         """Print the ipcontroller logs for this cluster to stdout."""
         self._print_logs(self.get_ipcontroller_logs())
 
     def print_ipcluster_logs(self):
         """Print the ipcluster logs for this cluster to stdout."""
         self._print_logs(self.get_ipcluster_logs())
 
     def print_logs(self):
         """Print all the logs for this cluster to stdout."""
         self._print_logs(self.get_logs())
 

IPython/kernel/launcher.py

@@ -1,628 +1,700 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Facilities for launching processing asynchronously.
 """
 
 #-----------------------------------------------------------------------------
 #  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 re
 import sys
 
 from IPython.core.component import Component
 from IPython.external import Itpl
 from IPython.utils.traitlets import Str, Int, List, Unicode
 from IPython.kernel.twistedutil import gatherBoth, make_deferred, sleep_deferred
 
 from twisted.internet import reactor, defer
 from twisted.internet.defer import inlineCallbacks
 from twisted.internet.protocol import ProcessProtocol
 from twisted.internet.utils import getProcessOutput
 from twisted.internet.error import ProcessDone, ProcessTerminated
 from twisted.python import log
 from twisted.python.failure import Failure
 
 #-----------------------------------------------------------------------------
 # Generic launchers
 #-----------------------------------------------------------------------------
 
 
 class LauncherError(Exception):
     pass
 
 
 class ProcessStateError(LauncherError):
     pass
 
 
 class UnknownStatus(LauncherError):
     pass
 
 
 class BaseLauncher(Component):
     """An asbtraction for starting, stopping and signaling a process."""
 
+    # A directory for files related to the process. But, we don't cd to 
+    # this directory, 
     working_dir = Unicode(u'')
 
     def __init__(self, working_dir, parent=None, name=None, config=None):
         super(BaseLauncher, self).__init__(parent, name, config)
         self.working_dir = working_dir
         self.state = 'before' # can be before, running, after
         self.stop_deferreds = []
         self.start_data = None
         self.stop_data = None
 
     @property
     def args(self):
-        """A list of cmd and args that will be used to start the process."""
+        """A list of cmd and args that will be used to start the process.
+
+        This is what is passed to :func:`spawnProcess` and the first element
+        will be the process name.
+        """
         return self.find_args()
 
     def find_args(self):
-        """The ``.args`` property calls this to find the args list."""
+        """The ``.args`` property calls this to find the args list.
+
+        Subcommand should implement this to construct the cmd and args.
+        """
         raise NotImplementedError('find_args must be implemented in a subclass')
 
     @property
     def arg_str(self):
         """The string form of the program arguments."""
         return ' '.join(self.args)
 
     @property
     def running(self):
+        """Am I running."""
         if self.state == 'running':
             return True
         else:
             return False
 
     def start(self):
         """Start the process.
 
         This must return a deferred that fires with information about the
-        process starting (like a pid, job id, etc.)
+        process starting (like a pid, job id, etc.).
         """
         return defer.fail(
             Failure(NotImplementedError(
                 'start must be implemented in a subclass')
             )
         )
 
     def stop(self):
-        """Stop the process and notify observers of ProcessStopped.
+        """Stop the process and notify observers of stopping.
 
-        This must return a deferred that fires with any errors that occur
-        while the process is attempting to be shut down.  This deferred
-        won't fire when the process actually stops.  These events are 
-        handled by calling :func:`observe_stop`.
+        This must return a deferred that fires with information about the
+        processing stopping, like errors that occur while the process is
+        attempting to be shut down. This deferred won't fire when the process
+        actually stops. To observe the actual process stopping, see
+        :func:`observe_stop`.
         """
         return defer.fail(
             Failure(NotImplementedError(
                 'stop must be implemented in a subclass')
             )
         )
 
     def observe_stop(self):
         """Get a deferred that will fire when the process stops.
 
         The deferred will fire with data that contains information about
         the exit status of the process.
         """
         if self.state=='after':
             return defer.succeed(self.stop_data)
         else:
             d = defer.Deferred()
             self.stop_deferreds.append(d)
             return d
 
     def notify_start(self, data):
-        """Call this to tigger startup actions.
+        """Call this to trigger startup actions.
 
-        This logs the process startup and sets the state to running.  It is
+        This logs the process startup and sets the state to 'running'.  It is
         a pass-through so it can be used as a callback.
         """
 
         log.msg('Process %r started: %r' % (self.args[0], data))
         self.start_data = data
         self.state = 'running'
         return data
 
     def notify_stop(self, data):
-        """Call this to trigger all the deferreds from :func:`observe_stop`."""
+        """Call this to trigger process stop actions.
+
+        This logs the process stopping and sets the state to 'after'. Call
+        this to trigger all the deferreds from :func:`observe_stop`."""
 
         log.msg('Process %r stopped: %r' % (self.args[0], data))
         self.stop_data = data
         self.state = 'after'
         for i in range(len(self.stop_deferreds)):
             d = self.stop_deferreds.pop()
             d.callback(data)
         return data
 
     def signal(self, sig):
         """Signal the process.
 
         Return a semi-meaningless deferred after signaling the process.
 
         Parameters
         ----------
         sig : str or int
             'KILL', 'INT', etc., or any signal number
         """
         return defer.fail(
             Failure(NotImplementedError(
                 'signal must be implemented in a subclass')
             )
         )
 
 
 class LocalProcessLauncherProtocol(ProcessProtocol):
     """A ProcessProtocol to go with the LocalProcessLauncher."""
 
     def __init__(self, process_launcher):
         self.process_launcher = process_launcher
         self.pid = None
 
     def connectionMade(self):
         self.pid = self.transport.pid
         self.process_launcher.notify_start(self.transport.pid)
 
     def processEnded(self, status):
         value = status.value
         if isinstance(value, ProcessDone):
             self.process_launcher.notify_stop(
                 {'exit_code':0,
                  'signal':None,
                  'status':None,
                  'pid':self.pid
                 }
             )
         elif isinstance(value, ProcessTerminated):
             self.process_launcher.notify_stop(
                 {'exit_code':value.exitCode,
                  'signal':value.signal,
                  'status':value.status,
                  'pid':self.pid
                 }
             )
         else:
             raise UnknownStatus("Unknown exit status, this is probably a "
                                 "bug in Twisted")
 
     def outReceived(self, data):
         log.msg(data)
 
     def errReceived(self, data):
         log.err(data)
 
 
 class LocalProcessLauncher(BaseLauncher):
     """Start and stop an external process in an asynchronous manner."""
 
+    # This is used to to construct self.args, which is passed to 
+    # spawnProcess.
     cmd_and_args = List([])
 
     def __init__(self, working_dir, parent=None, name=None, config=None):
         super(LocalProcessLauncher, self).__init__(
             working_dir, parent, name, config
         )
         self.process_protocol = None
         self.start_deferred = None
 
     def find_args(self):
         return self.cmd_and_args
 
     def start(self):
         if self.state == 'before':
             self.process_protocol = LocalProcessLauncherProtocol(self)
             self.start_deferred = defer.Deferred()
             self.process_transport = reactor.spawnProcess(
                 self.process_protocol,
                 str(self.args[0]),
                 [str(a) for a in self.args],
                 env=os.environ
             )
             return self.start_deferred
         else:
             s = 'The process was already started and has state: %r' % self.state
             return defer.fail(ProcessStateError(s))
 
     def notify_start(self, data):
         super(LocalProcessLauncher, self).notify_start(data)
         self.start_deferred.callback(data)
 
     def stop(self):
         return self.interrupt_then_kill()
 
     @make_deferred
     def signal(self, sig):
         if self.state == 'running':
             self.process_transport.signalProcess(sig)
 
     @inlineCallbacks
     def interrupt_then_kill(self, delay=2.0):
+        """Send INT, wait a delay and then send KILL."""
         yield self.signal('INT')
         yield sleep_deferred(delay)
         yield self.signal('KILL')
 
 
 class MPIExecLauncher(LocalProcessLauncher):
+    """Launch an external process using mpiexec."""
 
+    # The mpiexec command to use in starting the process.
     mpi_cmd = List(['mpiexec'], config=True)
+    # The command line arguments to pass to mpiexec.
     mpi_args = List([], config=True)
+    # The program to start using mpiexec.
     program = List(['date'], config=True)
+    # The command line argument to the program.
     program_args = List([], config=True)
+    # The number of instances of the program to start.
     n = Int(1, config=True)
 
     def find_args(self):
+        """Build self.args using all the fields."""
         return self.mpi_cmd + ['-n', self.n] + self.mpi_args + \
                self.program + self.program_args
 
     def start(self, n):
+        """Start n instances of the program using mpiexec."""
         self.n = n
         return super(MPIExecLauncher, self).start()
 
 
 class SSHLauncher(BaseLauncher):
     """A minimal launcher for ssh.
 
     To be useful this will probably have to be extended to use the ``sshx``
     idea for environment variables.  There could be other things this needs
     as well.
     """
 
     ssh_cmd = List(['ssh'], config=True)
     ssh_args = List([], config=True)
     program = List(['date'], config=True)
     program_args = List([], config=True)
     hostname = Str('', config=True)
     user = Str(os.environ['USER'], config=True)
     location = Str('')
 
     def _hostname_changed(self, name, old, new):
         self.location = '%s@%s' % (self.user, new)
 
     def _user_changed(self, name, old, new):
         self.location = '%s@%s' % (new, self.hostname)
 
     def find_args(self):
         return self.ssh_cmd + self.ssh_args + [self.location] + \
                self.program + self.program_args
 
     def start(self, n, hostname=None, user=None):
         if hostname is not None:
             self.hostname = hostname
         if user is not None:
             self.user = user
         return super(SSHLauncher, self).start()
 
 
 class WindowsHPCLauncher(BaseLauncher):
     pass
 
 
 class BatchSystemLauncher(BaseLauncher):
+    """Launch an external process using a batch system.
+
+    This class is designed to work with UNIX batch systems like PBS, LSF,
+    GridEngine, etc.  The overall model is that there are different commands
+    like qsub, qdel, etc. that handle the starting and stopping of the process.
+
+    This class also has the notion of a batch script. The ``batch_template``
+    attribute can be set to a string that is a template for the batch script.
+    This template is instantiated using Itpl. Thus the template can use
+    ${n} fot the number of instances. Subclasses can add additional variables
+    to the template dict.
+    """
 
     # Subclasses must fill these in.  See PBSEngineSet
+    # The name of the command line program used to submit jobs.
     submit_command = Str('', config=True)
+    # The name of the command line program used to delete jobs.
     delete_command = Str('', config=True)
+    # A regular expression used to get the job id from the output of the 
+    # submit_command.
     job_id_regexp = Str('', config=True)
+    # The string that is the batch script template itself.
     batch_template = Str('', config=True)
+    # The filename of the instantiated batch script.
     batch_file_name = Unicode(u'batch_script', config=True)
+    # The full path to the instantiated batch script.
     batch_file = Unicode(u'')
 
     def __init__(self, working_dir, parent=None, name=None, config=None):
         super(BatchSystemLauncher, self).__init__(
             working_dir, parent, name, config
         )
         self.batch_file = os.path.join(self.working_dir, self.batch_file_name)
         self.context = {}
 
     def parse_job_id(self, output):
+        """Take the output of the submit command and return the job id."""
         m = re.match(self.job_id_regexp, output)
         if m is not None:
             job_id = m.group()
         else:
             raise LauncherError("Job id couldn't be determined: %s" % output)
         self.job_id = job_id
         log.msg('Job started with job id: %r' % job_id)
         return job_id
 
     def write_batch_script(self, n):
+        """Instantiate and write the batch script to the working_dir."""
         self.context['n'] = n
         script_as_string = Itpl.itplns(self.batch_template, self.context)
         log.msg('Writing instantiated batch script: %s' % self.batch_file)
         f = open(self.batch_file, 'w')
         f.write(script_as_string)
         f.close()
 
     @inlineCallbacks
     def start(self, n):
         """Start n copies of the process using a batch system."""
         self.write_batch_script(n)
         output = yield getProcessOutput(self.submit_command,
             [self.batch_file], env=os.environ)
         job_id = self.parse_job_id(output)
         self.notify_start(job_id)
         defer.returnValue(job_id)
 
     @inlineCallbacks
     def stop(self):
         output = yield getProcessOutput(self.delete_command,
             [self.job_id], env=os.environ
         )
         self.notify_stop(output)  # Pass the output of the kill cmd
         defer.returnValue(output)
 
 
 class PBSLauncher(BatchSystemLauncher):
+    """A BatchSystemLauncher subclass for PBS."""
 
     submit_command = Str('qsub', config=True)
     delete_command = Str('qdel', config=True)
     job_id_regexp = Str('\d+', config=True)
     batch_template = Str('', config=True)
     batch_file_name = Unicode(u'pbs_batch_script', config=True)
     batch_file = Unicode(u'')
 
 
 #-----------------------------------------------------------------------------
 # Controller launchers
 #-----------------------------------------------------------------------------
 
 def find_controller_cmd():
+    """Find the command line ipcontroller program in a cross platform way."""
     if sys.platform == 'win32':
         # This logic is needed because the ipcontroller script doesn't
         # always get installed in the same way or in the same location.
         from IPython.kernel import ipcontrollerapp
         script_location = ipcontrollerapp.__file__.replace('.pyc', '.py')
         # The -u option here turns on unbuffered output, which is required
         # on Win32 to prevent wierd conflict and problems with Twisted.
         # Also, use sys.executable to make sure we are picking up the 
         # right python exe.
         cmd = [sys.executable, '-u', script_location]
     else:
         # ipcontroller has to be on the PATH in this case.
         cmd = ['ipcontroller']
     return cmd
 
 
 class LocalControllerLauncher(LocalProcessLauncher):
+    """Launch a controller as a regular external process."""
 
     controller_cmd = List(find_controller_cmd())
+    # Command line arguments to ipcontroller.
     controller_args = List(['--log-to-file','--log-level', '40'], config=True)
 
     def find_args(self):
         return self.controller_cmd + self.controller_args
 
     def start(self, profile=None, cluster_dir=None):
+        """Start the controller by profile or cluster_dir."""
         if cluster_dir is not None:
             self.controller_args.extend(['--cluster-dir', cluster_dir])
         if profile is not None:
             self.controller_args.extend(['--profile', profile])
         log.msg("Starting LocalControllerLauncher: %r" % self.args)
         return super(LocalControllerLauncher, self).start()
 
 
 class WindowsHPCControllerLauncher(WindowsHPCLauncher):
     pass
 
 
 class MPIExecControllerLauncher(MPIExecLauncher):
+    """Launch a controller using mpiexec."""
 
     controller_cmd = List(find_controller_cmd(), config=False)
+    # Command line arguments to ipcontroller.
     controller_args = List(['--log-to-file','--log-level', '40'], config=True)
     n = Int(1, config=False)
 
     def start(self, profile=None, cluster_dir=None):
+        """Start the controller by profile or cluster_dir."""
         if cluster_dir is not None:
             self.controller_args.extend(['--cluster-dir', cluster_dir])
         if profile is not None:
             self.controller_args.extend(['--profile', profile])
         log.msg("Starting MPIExecControllerLauncher: %r" % self.args)
         return super(MPIExecControllerLauncher, self).start(1)
 
-
     def find_args(self):
         return self.mpi_cmd + ['-n', self.n] + self.mpi_args + \
                self.controller_cmd + self.controller_args
 
 
 class PBSControllerLauncher(PBSLauncher):
+    """Launch a controller using PBS."""
+
+    batch_file_name = Unicode(u'pbs_batch_script_controller', config=True)
 
     def start(self, profile=None, cluster_dir=None):
+        """Start the controller by profile or cluster_dir."""
         # Here we save profile and cluster_dir in the context so they
         # can be used in the batch script template as ${profile} and
         # ${cluster_dir}
         if cluster_dir is not None:
             self.context['cluster_dir'] = cluster_dir
         if profile is not None:
             self.context['profile'] = profile
         log.msg("Starting PBSControllerLauncher: %r" % self.args)
         return super(PBSControllerLauncher, self).start(1)
 
 
 class SSHControllerLauncher(SSHLauncher):
     pass
 
 
 #-----------------------------------------------------------------------------
 # Engine launchers
 #-----------------------------------------------------------------------------
 
 
 def find_engine_cmd():
+    """Find the command line ipengine program in a cross platform way."""
     if sys.platform == 'win32':
         # This logic is needed because the ipengine script doesn't
         # always get installed in the same way or in the same location.
         from IPython.kernel import ipengineapp
         script_location = ipengineapp.__file__.replace('.pyc', '.py')
         # The -u option here turns on unbuffered output, which is required
         # on Win32 to prevent wierd conflict and problems with Twisted.
         # Also, use sys.executable to make sure we are picking up the 
         # right python exe.
         cmd = [sys.executable, '-u', script_location]
     else:
         # ipcontroller has to be on the PATH in this case.
         cmd = ['ipengine']
     return cmd
 
 
 class LocalEngineLauncher(LocalProcessLauncher):
+    """Launch a single engine as a regular externall process."""
 
     engine_cmd = List(find_engine_cmd())
+    # Command line arguments for ipengine.
     engine_args = List(
         ['--log-to-file','--log-level', '40'], config=True
     )
 
     def find_args(self):
         return self.engine_cmd + self.engine_args
 
     def start(self, profile=None, cluster_dir=None):
+        """Start the engine by profile or cluster_dir."""
         if cluster_dir is not None:
             self.engine_args.extend(['--cluster-dir', cluster_dir])
         if profile is not None:
             self.engine_args.extend(['--profile', profile])
         return super(LocalEngineLauncher, self).start()
 
 
 class LocalEngineSetLauncher(BaseLauncher):
+    """Launch a set of engines as regular external processes."""
 
+    # Command line arguments for ipengine.
     engine_args = List(
         ['--log-to-file','--log-level', '40'], config=True
     )
 
     def __init__(self, working_dir, parent=None, name=None, config=None):
         super(LocalEngineSetLauncher, self).__init__(
             working_dir, parent, name, config
         )
         self.launchers = []
 
     def start(self, n, profile=None, cluster_dir=None):
+        """Start n engines by profile or cluster_dir."""
         dlist = []
         for i in range(n):
             el = LocalEngineLauncher(self.working_dir, self)
             # Copy the engine args over to each engine launcher.
             import copy
             el.engine_args = copy.deepcopy(self.engine_args)
             d = el.start(profile, cluster_dir)
             if i==0:
                 log.msg("Starting LocalEngineSetLauncher: %r" % el.args)
             self.launchers.append(el)
             dlist.append(d)
         # The consumeErrors here could be dangerous
         dfinal = gatherBoth(dlist, consumeErrors=True)
         dfinal.addCallback(self.notify_start)
         return dfinal
 
     def find_args(self):
         return ['engine set']
 
     def signal(self, sig):
         dlist = []
         for el in self.launchers:
             d = el.signal(sig)
             dlist.append(d)
         dfinal = gatherBoth(dlist, consumeErrors=True)
         return dfinal
 
     def interrupt_then_kill(self, delay=1.0):
         dlist = []
         for el in self.launchers:
             d = el.interrupt_then_kill(delay)
             dlist.append(d)
         dfinal = gatherBoth(dlist, consumeErrors=True)
         return dfinal
 
     def stop(self):
         return self.interrupt_then_kill()
 
     def observe_stop(self):
         dlist = [el.observe_stop() for el in self.launchers]
         dfinal = gatherBoth(dlist, consumeErrors=False)
         dfinal.addCallback(self.notify_stop)
         return dfinal
 
 
 class MPIExecEngineSetLauncher(MPIExecLauncher):
 
     engine_cmd = List(find_engine_cmd(), config=False)
+    # Command line arguments for ipengine.
     engine_args = List(
         ['--log-to-file','--log-level', '40'], config=True
     )    
     n = Int(1, config=True)
 
     def start(self, n, profile=None, cluster_dir=None):
+        """Start n engines by profile or cluster_dir."""
         if cluster_dir is not None:
             self.engine_args.extend(['--cluster-dir', cluster_dir])
         if profile is not None:
             self.engine_args.extend(['--profile', profile])
         log.msg('Starting MPIExecEngineSetLauncher: %r' % self.args)
         return super(MPIExecEngineSetLauncher, self).start(n)
 
     def find_args(self):
         return self.mpi_cmd + ['-n', self.n] + self.mpi_args + \
                self.engine_cmd + self.engine_args
 
 
 class WindowsHPCEngineSetLauncher(WindowsHPCLauncher):
     pass
 
 
 class PBSEngineSetLauncher(PBSLauncher):
 
+    batch_file_name = Unicode(u'pbs_batch_script_engines', config=True)
+
     def start(self, n, profile=None, cluster_dir=None):
+        """Start n engines by profile or cluster_dir."""
         if cluster_dir is not None:
             self.program_args.extend(['--cluster-dir', cluster_dir])
         if profile is not None:
             self.program_args.extend(['-p', profile])
         log.msg('Starting PBSEngineSetLauncher: %r' % self.args)
         return super(PBSEngineSetLauncher, self).start(n)
 
 
 class SSHEngineSetLauncher(BaseLauncher):
     pass
 
 
 #-----------------------------------------------------------------------------
 # A launcher for ipcluster itself!
 #-----------------------------------------------------------------------------
 
 
 def find_ipcluster_cmd():
+    """Find the command line ipcluster program in a cross platform way."""
     if sys.platform == 'win32':
         # This logic is needed because the ipcluster script doesn't
         # always get installed in the same way or in the same location.
         from IPython.kernel import ipclusterapp
         script_location = ipclusterapp.__file__.replace('.pyc', '.py')
         # The -u option here turns on unbuffered output, which is required
         # on Win32 to prevent wierd conflict and problems with Twisted.
         # Also, use sys.executable to make sure we are picking up the 
         # right python exe.
         cmd = [sys.executable, '-u', script_location]
     else:
         # ipcontroller has to be on the PATH in this case.
         cmd = ['ipcluster']
     return cmd
 
 
 class IPClusterLauncher(LocalProcessLauncher):
+    """Launch the ipcluster program in an external process."""
 
     ipcluster_cmd = List(find_ipcluster_cmd())
+    # Command line arguments to pass to ipcluster.
     ipcluster_args = List(
         ['--clean-logs', '--log-to-file', '--log-level', '40'], config=True)
     ipcluster_subcommand = Str('start')
     ipcluster_n = Int(2)
 
     def find_args(self):
         return self.ipcluster_cmd + [self.ipcluster_subcommand] + \
             ['-n', repr(self.ipcluster_n)] + self.ipcluster_args
 
     def start(self):
         log.msg("Starting ipcluster: %r" % self.args)
         return super(IPClusterLauncher, self).start()