rebase IPython.parallel after removal of IPython.kernel

This commit removes all '*z' suffixes from scripts and docs,
as there is no longer conflict with IPython.kernel.

IPython/config/default/ipcluster_config.py

@@ -11,8 +11,8 b' c = get_config()'
 # - Start as a regular process on localhost.
 # - Start using mpiexec.
 # - Start using the Windows HPC Server 2008 scheduler
-# - Start using PBS
-# - Start using SSH (currently broken)
+# - Start using PBS/SGE
+# - Start using SSH
 
 
 # The selected launchers can be configured below.
@@ -21,15 +21,18 b' c = get_config()'
 # - LocalControllerLauncher
 # - MPIExecControllerLauncher
 # - PBSControllerLauncher
+# - SGEControllerLauncher
 # - WindowsHPCControllerLauncher
-# c.Global.controller_launcher = 'IPython.kernel.launcher.LocalControllerLauncher'
+# c.Global.controller_launcher = 'IPython.parallel.launcher.LocalControllerLauncher'
+# c.Global.controller_launcher = 'IPython.parallel.launcher.PBSControllerLauncher'
 
 # Options are:
 # - LocalEngineSetLauncher
 # - MPIExecEngineSetLauncher
 # - PBSEngineSetLauncher
+# - SGEEngineSetLauncher
 # - WindowsHPCEngineSetLauncher
-# c.Global.engine_launcher = 'IPython.kernel.launcher.LocalEngineSetLauncher'
+# c.Global.engine_launcher = 'IPython.parallel.launcher.LocalEngineSetLauncher'
 
 #-----------------------------------------------------------------------------
 # Global configuration
@@ -68,23 +71,23 b' c = get_config()'
 # MPIExec launchers
 #-----------------------------------------------------------------------------
 
-# The mpiexec/mpirun command to use in started the controller.
-# c.MPIExecControllerLauncher.mpi_cmd = ['mpiexec']
+# The mpiexec/mpirun command to use in both the controller and engines.
+# c.MPIExecLauncher.mpi_cmd = ['mpiexec']
 
 # Additional arguments to pass to the actual mpiexec command.
+# c.MPIExecLauncher.mpi_args = []
+
+# The mpiexec/mpirun command and args can be overridden if they should be different
+# for controller and engines.
+# c.MPIExecControllerLauncher.mpi_cmd = ['mpiexec']
 # c.MPIExecControllerLauncher.mpi_args = []
+# c.MPIExecEngineSetLauncher.mpi_cmd = ['mpiexec']
+# c.MPIExecEngineSetLauncher.mpi_args = []
 
 # The command line argument to call the controller with.
 # c.MPIExecControllerLauncher.controller_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 = []
-
 # Command line argument passed to the engines.
 # c.MPIExecEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
 
@@ -95,51 +98,105 b' c = get_config()'
 # SSH launchers
 #-----------------------------------------------------------------------------
 
-# Todo
+# ipclusterz can be used to launch controller and engines remotely via ssh.
+# Note that currently ipclusterz does not do any file distribution, so if
+# machines are not on a shared filesystem, config and json files must be
+# distributed.  For this reason, the reuse_files defaults to True on an
+# ssh-launched Controller.  This flag can be overridded by the program_args
+# attribute of c.SSHControllerLauncher.
+
+# set the ssh cmd for launching remote commands. The default is ['ssh']
+# c.SSHLauncher.ssh_cmd = ['ssh']
+
+# set the ssh cmd for launching remote commands. The default is ['ssh']
+# c.SSHLauncher.ssh_args = ['tt']
+
+# Set the user and hostname for the controller
+# c.SSHControllerLauncher.hostname = 'controller.example.com'
+# c.SSHControllerLauncher.user = os.environ.get('USER','username')
+
+# Set the arguments to be passed to ipcontrollerz
+# note that remotely launched ipcontrollerz will not get the contents of 
+# the local ipcontrollerz_config.py unless it resides on the *remote host*
+# in the location specified by the --cluster_dir argument.
+# c.SSHControllerLauncher.program_args = ['-r', '-ip', '0.0.0.0', '--cluster_dir', '/path/to/cd']
+
+# Set the default args passed to ipenginez for SSH launched engines
+# c.SSHEngineSetLauncher.engine_args = ['--mpi', 'mpi4py']
 
+# SSH engines are launched as a dict of locations/n-engines.
+# if a value is a tuple instead of an int, it is assumed to be of the form
+# (n, [args]), setting the arguments to passed to ipenginez on `host`.
+# otherwise, c.SSHEngineSetLauncher.engine_args will be used as the default.
+
+# In this case, there will be 3 engines at my.example.com, and
+# 2 at [e-mail] with a special json connector location.
+# c.SSHEngineSetLauncher.engines = {'my.example.com' : 3,
+#                                   '[e-mail]' : (2, ['-f', '/path/to/ipcontroller-engine.json']}
+#                                  }
 
 #-----------------------------------------------------------------------------
 # Unix batch (PBS) schedulers launchers
 #-----------------------------------------------------------------------------
 
+# SGE and PBS are very similar. All configurables in this section called 'PBS*'
+# also exist as 'SGE*'.
+
 # The command line program to use to submit a PBS job.
-# c.PBSControllerLauncher.submit_command = 'qsub'
+# c.PBSLauncher.submit_command = ['qsub']
 
 # The command line program to use to delete a PBS job.
-# c.PBSControllerLauncher.delete_command = 'qdel'
+# c.PBSLauncher.delete_command = ['qdel']
+
+# The PBS queue in which the job should run
+# c.PBSLauncher.queue = 'myqueue'
 
 # A regular expression that takes the output of qsub and find the job id.
-# c.PBSControllerLauncher.job_id_regexp = r'\d+'
+# c.PBSLauncher.job_id_regexp = r'\d+'
+
+# If for some reason the Controller and Engines have different options above, they
+# can be set as c.PBSControllerLauncher.<option> etc.
+
+# PBS and SGE have default templates, but you can specify your own, either as strings
+# or from files, as described here:
 
 # The batch submission script used to start the controller. This is where
-# environment variables would be setup, etc. This string is interpolated using
+# environment variables would be setup, etc. This string is interpreted using
 # the Itpl module in IPython.external. Basically, you can use ${n} for the
 # number of engine and ${cluster_dir} for the cluster_dir.
-# c.PBSControllerLauncher.batch_template = """"""
+# c.PBSControllerLauncher.batch_template = """
+# #PBS -N ipcontroller
+# #PBS -q $queue
+# 
+# ipcontrollerz --cluster-dir $cluster_dir
+# """
+
+# You can also load this template from a file
+# c.PBSControllerLauncher.batch_template_file = u"/path/to/my/template.sh"
 
 # 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'
-
-
-# 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 = r'\d+'
+# c.PBSControllerLauncher.batch_file_name = u'pbs_controller'
 
 # The batch submission script used to start the engines. This is where
-# environment variables would be setup, etc. This string is interpolated using
+# environment variables would be setup, etc. This string is interpreted using
 # the Itpl module in IPython.external. Basically, you can use ${n} for the
 # number of engine and ${cluster_dir} for the cluster_dir.
-# c.PBSEngineSetLauncher.batch_template = """"""
+# c.PBSEngineSetLauncher.batch_template = """
+# #PBS -N ipcontroller
+# #PBS -l nprocs=$n
+# 
+# ipenginez --cluster-dir $cluster_dir$s
+# """
+
+# You can also load this template from a file
+# c.PBSControllerLauncher.batch_template_file = u"/path/to/my/template.sh"
 
 # 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'
+# c.PBSEngineSetLauncher.batch_file_name = u'pbs_engines'
+
+
 
 #-----------------------------------------------------------------------------
 # Windows HPC Server 2008 launcher configuration

IPython/config/default/ipcontroller_config.py

@@ -25,112 +25,156 b' c = get_config()'
 # 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
+# Reuse the controller's JSON files. If False, JSON 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
+# c.Global.reuse_files = 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.
+# Enable exec_key authentication on all messages. Default is True
 # c.Global.secure = True
 
 # The working directory for the process. The application will use os.chdir
 # to change to this directory before starting.
 # c.Global.work_dir = os.getcwd()
 
+# The log url for logging to an `iploggerz` application.  This will override
+# log-to-file.
+# c.Global.log_url = 'tcp://127.0.0.1:20202'
+
+# The specific external IP that is used to disambiguate multi-interface URLs.
+# The default behavior is to guess from external IPs gleaned from `socket`.
+# c.Global.location = '192.168.1.123'
+
+# The ssh server remote clients should use to connect to this controller.
+# It must be a machine that can see the interface specified in client_ip.
+# The default for client_ip is localhost, in which case the sshserver must
+# be an external IP of the controller machine.
+# c.Global.sshserver = 'controller.example.com'
+
+# the url to use for registration.  If set, this overrides engine-ip,
+# engine-transport client-ip,client-transport, and regport.
+# c.RegistrationFactory.url = 'tcp://*:12345'
+
+# the port to use for registration.  Clients and Engines both use this
+# port for registration.
+# c.RegistrationFactory.regport = 10101
+
 #-----------------------------------------------------------------------------
-# Configure the client services
+# Configure the Task Scheduler
 #-----------------------------------------------------------------------------
 
-# Basic client service config attributes
+# The routing scheme. 'pure' will use the pure-ZMQ scheduler. Any other 
+# value will use a Python scheduler with various routing schemes.
+# python schemes are: lru, weighted, random, twobin. Default is 'weighted'.
+# Note that the pure ZMQ scheduler does not support many features, such as
+# dying engines, dependencies, or engine-subset load-balancing.
+# c.ControllerFactory.scheme = 'pure'
 
-# 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 pure ZMQ scheduler can limit the number of outstanding tasks per engine
+# by using the ZMQ HWM option.  This allows engines with long-running tasks
+# to not steal too many tasks from other engines. The default is 0, which
+# means agressively distribute messages, never waiting for them to finish.
+# c.ControllerFactory.hwm = 1
 
-# 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
+# Whether to use Threads or Processes to start the Schedulers.  Threads will
+# use less resources, but potentially reduce throughput. Default is to 
+# use processes.  Note that the a Python scheduler will always be in a Process.
+# c.ControllerFactory.usethreads
 
-# 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 = ''
+#-----------------------------------------------------------------------------
+# Configure the Hub
+#-----------------------------------------------------------------------------
+
+# Which class to use for the db backend.  Currently supported are DictDB (the
+# default), and MongoDB. Uncomment this line to enable MongoDB, which will
+# slow-down the Hub's responsiveness, but also reduce its memory footprint.
+# c.HubFactory.db_class = 'IPython.parallel.mongodb.MongoDB'
 
-# Use SSL encryption for the client connection.
-# c.FCClientServiceFactory.secure =  True
+# The heartbeat ping frequency.  This is the frequency (in ms) at which the
+# Hub pings engines for heartbeats.  This determines how quickly the Hub
+# will react to engines coming and going.  A lower number means faster response
+# time, but more network activity.  The default is 100ms
+# c.HubFactory.ping = 100
 
-# 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
+# HubFactory queue port pairs, to set by name: mux, iopub, control, task.  Set
+# each as a tuple of length 2 of ints.  The default is to find random
+# available ports
+# c.HubFactory.mux = (10102,10112)
 
 #-----------------------------------------------------------------------------
-# Configure the engine services
+# Configure the client connections
 #-----------------------------------------------------------------------------
 
-# Basic config attributes for the engine services.
+# Basic client connection config attributes
 
-# 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 network interface the controller will listen on for client connections.
+# This should be an IP address or interface on the controller. An asterisk
+# means listen on all interfaces. The transport can be any transport
+# supported by zeromq (tcp,epgm,pgm,ib,ipc):
+# c.HubFactory.client_ip = '*'
+# c.HubFactory.client_transport = 'tcp'
 
-# 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
+# individual client ports to configure by name: query_port, notifier_port
+# c.HubFactory.query_port = 12345
 
-# 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 = ''
+#-----------------------------------------------------------------------------
+# Configure the engine connections
+#-----------------------------------------------------------------------------
 
-# Use SSL encryption for the engine connection.
-# c.FCEngineServiceFactory.secure = True
+# Basic config attributes for the engine connections.
 
-# 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
+# The network interface the controller will listen on for engine connections.
+# This should be an IP address or interface on the controller. An asterisk
+# means listen on all interfaces. The transport can be any transport
+# supported by zeromq (tcp,epgm,pgm,ib,ipc):
+# c.HubFactory.engine_ip = '*'
+# c.HubFactory.engine_transport = 'tcp'
+
+# set the engine heartbeat ports to use:
+# c.HubFactory.hb = (10303,10313)
 
 #-----------------------------------------------------------------------------
-# Developer level configuration attributes
+# Configure the TaskRecord database backend
 #-----------------------------------------------------------------------------
 
-# 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 = u'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 = u'ipcontroller-tc.furl'
-# 
-# default_client_interfaces.MultiEngine.interface_chain = [
-#     'IPython.kernel.multiengine.IMultiEngine',
-#     'IPython.kernel.multienginefc.IFCSynchronousMultiEngine'
-# ]
-# 
-# default_client_interfaces.MultiEngine.furl_file = u'ipcontroller-mec.furl'
-# 
-# c.FCEngineServiceFactory.interfaces = default_client_interfaces
-
-# c.FCEngineServiceFactory.cert_file = u'ipcontroller-engine.pem'
-
-# default_engine_interfaces = Config()
-# default_engine_interfaces.Default.interface_chain = [
-#     'IPython.kernel.enginefc.IFCControllerBase'
-# ]
-# 
-# default_engine_interfaces.Default.furl_file = u'ipcontroller-engine.furl'
-# 
-# c.FCEngineServiceFactory.interfaces = default_engine_interfaces
+# For memory/persistance reasons, tasks can be stored out-of-memory in a database.
+# Currently, only sqlite and mongodb are supported as backends, but the interface
+# is fairly simple, so advanced developers could write their own backend.
+
+# ----- in-memory configuration --------
+# this line restores the default behavior: in-memory storage of all results.
+# c.HubFactory.db_class = 'IPython.parallel.dictdb.DictDB'
+
+# ----- sqlite configuration --------
+# use this line to activate sqlite:
+# c.HubFactory.db_class = 'IPython.parallel.sqlitedb.SQLiteDB'
+
+# You can specify the name of the db-file.  By default, this will be located
+# in the active cluster_dir, e.g. ~/.ipython/clusterz_default/tasks.db
+# c.SQLiteDB.filename = 'tasks.db'
+
+# You can also specify the location of the db-file, if you want it to be somewhere
+# other than the cluster_dir.
+# c.SQLiteDB.location = '/scratch/'
+
+# This will specify the name of the table for the controller to use.  The default
+# behavior is to use the session ID of the SessionFactory object (a uuid). Overriding
+# this will result in results persisting for multiple sessions.
+# c.SQLiteDB.table = 'results'
+
+# ----- mongodb configuration --------
+# use this line to activate mongodb:
+# c.HubFactory.db_class = 'IPython.parallel.mongodb.MongoDB'
+
+# You can specify the args and kwargs pymongo will use when creating the Connection.
+# For more information on what these options might be, see pymongo documentation.
+# c.MongoDB.connection_kwargs = {}
+# c.MongoDB.connection_args = []
+
+# This will specify the name of the mongo database for the controller to use.  The default
+# behavior is to use the session ID of the SessionFactory object (a uuid). Overriding
+# this will result in task results persisting through multiple sessions.
+# c.MongoDB.database = 'ipythondb'
+
+

IPython/config/default/ipengine_config.py

@@ -29,10 +29,10 b' c = get_config()'
 # 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 = u''
+# By default, the engine will look for the controller's JSON file in its own
+# cluster directory. Sometimes, the JSON file will be elsewhere and this 
+# attribute can be set to the full path of the JSON file.
+# c.Global.url_file = u'/path/to/my/ipcontroller-engine.json'
 
 # The working directory for the process. The application will use os.chdir
 # to change to this directory before starting.
@@ -78,12 +78,7 b' c = get_config()'
 
 # You should not have to change these attributes.
 
-# c.Global.shell_class = 'IPython.kernel.core.interpreter.Interpreter'
-
-# c.Global.furl_file_name = u'ipcontroller-engine.furl'
-
-
-
+# c.Global.url_file_name = u'ipcontroller-engine.furl'
 
 
 

IPython/parallel/clusterdir.py

@@ -138,8 +138,8 b' class ClusterDir(Configurable):'
 
     def copy_all_config_files(self, path=None, overwrite=False):
         """Copy all config files into the active cluster directory."""
-        for f in [u'ipcontrollerz_config.py', u'ipenginez_config.py',
-                  u'ipclusterz_config.py']:
+        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
@@ -164,11 +164,11 b' class ClusterDir(Configurable):'
             The path (directory) to put the cluster directory in.
         profile : str
             The name of the profile.  The name of the cluster directory will
-            be "clusterz_<profile>".
+            be "cluster_<profile>".
         """
         if not os.path.isdir(path):
             raise ClusterDirError('Directory not found: %s' % path)
-        cluster_dir = os.path.join(path, u'clusterz_' + profile)
+        cluster_dir = os.path.join(path, u'cluster_' + profile)
         return ClusterDir(location=cluster_dir)
 
     @classmethod
@@ -190,9 +190,9 b' class ClusterDir(Configurable):'
             The IPython directory to use.
         profile : unicode or str
             The name of the profile.  The name of the cluster directory
-            will be "clusterz_<profile>".
+            will be "cluster_<profile>".
         """
-        dirname = u'clusterz_' + 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(':')

IPython/parallel/ipclusterapp.py

@@ -37,7 +37,7 b' from IPython.parallel.clusterdir import ('
 #-----------------------------------------------------------------------------
 
 
-default_config_file_name = u'ipclusterz_config.py'
+default_config_file_name = u'ipcluster_config.py'
 
 
 _description = """\
@@ -47,9 +47,9 b' 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 'ipclusterz start -n 4'. For more complex usage 
-you will typically do 'ipclusterz create -p mycluster', then edit
-configuration files, followed by 'ipclusterz start -p mycluster -n 4'.
+local host simply do 'ipcluster start -n 4'. For more complex usage 
+you will typically do 'ipcluster create -p mycluster', then edit
+configuration files, followed by 'ipcluster start -p mycluster -n 4'.
 """
 
 
@@ -108,9 +108,9 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             title='ipcluster subcommands',
             description=
             """ipcluster has a variety of subcommands. The general way of 
-            running ipcluster is 'ipclusterz <cmd> [options]'. To get help
-            on a particular subcommand do 'ipclusterz <cmd> -h'."""
-            # help="For more help, type 'ipclusterz <cmd> -h'",
+            running ipcluster is 'ipcluster <cmd> [options]'. To get help
+            on a particular subcommand do 'ipcluster <cmd> -h'."""
+            # help="For more help, type 'ipcluster <cmd> -h'",
         )
 
         # The "list" subcommand parser
@@ -123,7 +123,7 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             """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
-            'clusterz_<profile>'."""
+            'cluster_<profile>'."""
         )
 
         # The "create" subcommand parser
@@ -136,13 +136,13 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             """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 'clusterz_<profile>'. By default they are
+            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, 
-            'ipclusterz create -p mycluster', which will put the directory
-            in '<ipython_dir>/clusterz_mycluster'. 
+            'ipcluster create -p mycluster', which will put the directory
+            in '<ipython_dir>/cluster_mycluster'. 
             """
         )
         paa = parser_create.add_argument
@@ -162,10 +162,10 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             """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
-            'clusterz_<profile>' and should be creating using the 'start'
+            '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, 'ipclusterz start -n 4 -p <profile>`,
+            using its profile name, 'ipcluster start -n 4 -p <profile>`,
             otherwise use the '--cluster-dir' option.
             """
         )
@@ -200,9 +200,9 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             description=
             """Stop a running ipython cluster by its profile name or cluster 
             directory. Cluster directories are named using the convention
-            'clusterz_<profile>'. If your cluster directory is in 
+            'cluster_<profile>'. If your cluster directory is in 
             the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipclusterz stop -p <profile>`, otherwise
+            using its profile name, 'ipcluster stop -p <profile>`, otherwise
             use the '--cluster-dir' option.
             """
         )
@@ -223,10 +223,10 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
             by profile name or cluster directory.
             Cluster directories contain configuration, log and
             security related files and are named using the convention
-            'clusterz_<profile>' and should be creating using the 'start'
+            '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, 'ipclusterz engines -n 4 -p <profile>`,
+            using its profile name, 'ipcluster engines -n 4 -p <profile>`,
             otherwise use the '--cluster-dir' option.
             """
         )
@@ -249,7 +249,7 b' class IPClusterAppConfigLoader(ClusterDirConfigLoader):'
 
 class IPClusterApp(ApplicationWithClusterDir):
 
-    name = u'ipclusterz'
+    name = u'ipcluster'
     description = _description
     usage = None
     command_line_loader = IPClusterAppConfigLoader
@@ -286,8 +286,8 b' class IPClusterApp(ApplicationWithClusterDir):'
             except ClusterDirError:
                 raise ClusterDirError(
                     "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipclusterz start'.  Do "
-                    "'ipclusterz create -h' or 'ipclusterz list -h' for more "
+                    "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':
@@ -297,8 +297,8 b' class IPClusterApp(ApplicationWithClusterDir):'
             except ClusterDirError:
                 raise ClusterDirError(
                     "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipclusterz start'.  Do "
-                    "'ipclusterz create -h' or 'ipclusterz list -h' for more "
+                    "be created before running 'ipcluster start'.  Do "
+                    "'ipcluster create -h' or 'ipcluster list -h' for more "
                     "information about creating and listing cluster dirs."
                 )
 
@@ -322,9 +322,9 b' class IPClusterApp(ApplicationWithClusterDir):'
             files = os.listdir(path)
             for f in files:
                 full_path = os.path.join(path, f)
-                if os.path.isdir(full_path) and f.startswith('clusterz_'):
+                if os.path.isdir(full_path) and f.startswith('cluster_'):
                     profile = full_path.split('_')[-1]
-                    start_cmd = 'ipclusterz start -p %s -n 4' % profile
+                    start_cmd = 'ipcluster start -p %s -n 4' % profile
                     print start_cmd + " ==> " + full_path
 
     def pre_construct(self):
@@ -498,7 +498,7 b' class IPClusterApp(ApplicationWithClusterDir):'
         else:
             self.log.critical(
                 'Cluster is already running with [pid=%s]. '
-                'use "ipclusterz stop" to stop the cluster.' % pid
+                '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.
@@ -506,7 +506,7 b' class IPClusterApp(ApplicationWithClusterDir):'
 
         # Now log and daemonize
         self.log.info(
-            'Starting ipclusterz with [daemon=%r]' % config.Global.daemonize
+            'Starting ipcluster with [daemon=%r]' % config.Global.daemonize
         )
         # TODO: Get daemonize working on Windows or as a Windows Server.
         if config.Global.daemonize:

IPython/parallel/ipcontrollerapp.py

@@ -48,7 +48,7 b' from IPython.utils.traitlets import Instance, Unicode'
 
 
 #: The default config file name for this application
-default_config_file_name = u'ipcontrollerz_config.py'
+default_config_file_name = u'ipcontroller_config.py'
 
 
 _description = """Start the IPython controller for parallel computing.
@@ -57,7 +57,7 b' 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 "clusterz_<profile>". See the --profile
+your ipython directory and named as "cluster_<profile>". See the --profile
 and --cluster-dir options for details.
 """
 
@@ -251,7 +251,7 b' class IPControllerAppConfigLoader(ClusterDirConfigLoader):'
 
 class IPControllerApp(ApplicationWithClusterDir):
 
-    name = u'ipcontrollerz'
+    name = u'ipcontroller'
     description = _description
     command_line_loader = IPControllerAppConfigLoader
     default_config_file_name = default_config_file_name

IPython/parallel/ipengineapp.py

@@ -40,7 +40,7 b' from IPython.utils.importstring import import_item'
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application
-default_config_file_name = u'ipenginez_config.py'
+default_config_file_name = u'ipengine_config.py'
 
 
 mpi4py_init = """from mpi4py import MPI as mpi
@@ -64,7 +64,7 b' 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 "clusterz_<profile>".
+usually located in your ipython directory and named as "cluster_<profile>".
 See the --profile and --cluster-dir options for details.
 """
 
@@ -124,7 +124,7 b' class IPEngineAppConfigLoader(ClusterDirConfigLoader):'
 
 class IPEngineApp(ApplicationWithClusterDir):
 
-    name = u'ipenginez'
+    name = u'ipengine'
     description = _description
     command_line_loader = IPEngineAppConfigLoader
     default_config_file_name = default_config_file_name

IPython/parallel/iploggerapp.py

@@ -39,7 +39,7 b' IPython controllers and engines (and your own processes) can broadcast log messa'
 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 "clusterz_<profile>".
+usually located in your ipython directory and named as "cluster_<profile>".
 See the --profile and --cluster-dir options for details.
 """
 

IPython/parallel/launcher.py

@@ -63,15 +63,15 b' except ImportError:'
 #-----------------------------------------------------------------------------
 
 
-ipclusterz_cmd_argv = pycmd2argv(get_ipython_module_path(
+ipcluster_cmd_argv = pycmd2argv(get_ipython_module_path(
     'IPython.parallel.ipclusterapp'
 ))
 
-ipenginez_cmd_argv = pycmd2argv(get_ipython_module_path(
+ipengine_cmd_argv = pycmd2argv(get_ipython_module_path(
     'IPython.parallel.ipengineapp'
 ))
 
-ipcontrollerz_cmd_argv = pycmd2argv(get_ipython_module_path(
+ipcontroller_cmd_argv = pycmd2argv(get_ipython_module_path(
     'IPython.parallel.ipcontrollerapp'
 ))
 
@@ -304,7 +304,7 b' class LocalProcessLauncher(BaseLauncher):'
 class LocalControllerLauncher(LocalProcessLauncher):
     """Launch a controller as a regular external process."""
 
-    controller_cmd = List(ipcontrollerz_cmd_argv, config=True)
+    controller_cmd = List(ipcontroller_cmd_argv, config=True)
     # Command line arguments to ipcontroller.
     controller_args = List(['--log-to-file','--log-level', str(logging.INFO)], config=True)
 
@@ -322,7 +322,7 b' class LocalControllerLauncher(LocalProcessLauncher):'
 class LocalEngineLauncher(LocalProcessLauncher):
     """Launch a single engine as a regular externall process."""
 
-    engine_cmd = List(ipenginez_cmd_argv, config=True)
+    engine_cmd = List(ipengine_cmd_argv, config=True)
     # Command line arguments for ipengine.
     engine_args = List(
         ['--log-to-file','--log-level', str(logging.INFO)], config=True
@@ -443,7 +443,7 b' class MPIExecLauncher(LocalProcessLauncher):'
 class MPIExecControllerLauncher(MPIExecLauncher):
     """Launch a controller using mpiexec."""
 
-    controller_cmd = List(ipcontrollerz_cmd_argv, config=True)
+    controller_cmd = List(ipcontroller_cmd_argv, config=True)
     # Command line arguments to ipcontroller.
     controller_args = List(['--log-to-file','--log-level', str(logging.INFO)], config=True)
     n = Int(1, config=False)
@@ -462,7 +462,7 b' class MPIExecControllerLauncher(MPIExecLauncher):'
 
 class MPIExecEngineSetLauncher(MPIExecLauncher):
 
-    program = List(ipenginez_cmd_argv, config=True)
+    program = List(ipengine_cmd_argv, config=True)
     # Command line arguments for ipengine.
     program_args = List(
         ['--log-to-file','--log-level', str(logging.INFO)], config=True
@@ -531,13 +531,13 b' class SSHLauncher(LocalProcessLauncher):'
 
 class SSHControllerLauncher(SSHLauncher):
 
-    program = List(ipcontrollerz_cmd_argv, config=True)
+    program = List(ipcontroller_cmd_argv, config=True)
     # Command line arguments to ipcontroller.
     program_args = List(['-r', '--log-to-file','--log-level', str(logging.INFO)], config=True)
 
 
 class SSHEngineLauncher(SSHLauncher):
-    program = List(ipenginez_cmd_argv, config=True)
+    program = List(ipengine_cmd_argv, config=True)
     # Command line arguments for ipengine.
     program_args = List(
         ['--log-to-file','--log-level', str(logging.INFO)], config=True
@@ -883,9 +883,9 b' class PBSControllerLauncher(PBSLauncher):'
     batch_file_name = CUnicode(u'pbs_controller', config=True)
     default_template= CUnicode("""#!/bin/sh
 #PBS -V
-#PBS -N ipcontrollerz
+#PBS -N ipcontroller
 %s --log-to-file --cluster-dir $cluster_dir
-"""%(' '.join(ipcontrollerz_cmd_argv)))
+"""%(' '.join(ipcontroller_cmd_argv)))
 
     def start(self, cluster_dir):
         """Start the controller by profile or cluster_dir."""
@@ -898,9 +898,9 b' class PBSEngineSetLauncher(PBSLauncher):'
     batch_file_name = CUnicode(u'pbs_engines', config=True)
     default_template= CUnicode(u"""#!/bin/sh
 #PBS -V
-#PBS -N ipenginez
+#PBS -N ipengine
 %s --cluster-dir $cluster_dir
-"""%(' '.join(ipenginez_cmd_argv)))
+"""%(' '.join(ipengine_cmd_argv)))
 
     def start(self, n, cluster_dir):
         """Start n engines by profile or cluster_dir."""
@@ -922,9 +922,9 b' class SGEControllerLauncher(SGELauncher):'
     batch_file_name = CUnicode(u'sge_controller', config=True)
     default_template= CUnicode(u"""#$$ -V
 #$$ -S /bin/sh
-#$$ -N ipcontrollerz
+#$$ -N ipcontroller
 %s --log-to-file --cluster-dir $cluster_dir
-"""%(' '.join(ipcontrollerz_cmd_argv)))
+"""%(' '.join(ipcontroller_cmd_argv)))
 
     def start(self, cluster_dir):
         """Start the controller by profile or cluster_dir."""
@@ -936,9 +936,9 b' class SGEEngineSetLauncher(SGELauncher):'
     batch_file_name = CUnicode(u'sge_engines', config=True)
     default_template = CUnicode("""#$$ -V
 #$$ -S /bin/sh
-#$$ -N ipenginez
+#$$ -N ipengine
 %s --cluster-dir $cluster_dir
-"""%(' '.join(ipenginez_cmd_argv)))
+"""%(' '.join(ipengine_cmd_argv)))
 
     def start(self, n, cluster_dir):
         """Start n engines by profile or cluster_dir."""
@@ -954,7 +954,7 b' class SGEEngineSetLauncher(SGELauncher):'
 class IPClusterLauncher(LocalProcessLauncher):
     """Launch the ipcluster program in an external process."""
 
-    ipcluster_cmd = List(ipclusterz_cmd_argv, config=True)
+    ipcluster_cmd = List(ipcluster_cmd_argv, config=True)
     # Command line arguments to pass to ipcluster.
     ipcluster_args = List(
         ['--clean-logs', '--log-to-file', '--log-level', str(logging.INFO)], config=True)

IPython/parallel/logwatcher.py

@@ -1,5 +1,5 b''
 #!/usr/bin/env python
-"""A simple logger object that consolidates messages incoming from ipclusterz processes."""
+"""A simple logger object that consolidates messages incoming from ipcluster processes."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team

IPython/parallel/tests/__init__.py

@@ -23,7 +23,7 b' blackhole = tempfile.TemporaryFile()'
 # nose setup/teardown
 
 def setup():
-    cp = Popen('ipcontrollerz --profile iptest -r --log-level 10 --log-to-file'.split(), stdout=blackhole, stderr=STDOUT)
+    cp = Popen('ipcontroller --profile iptest -r --log-level 10 --log-to-file'.split(), stdout=blackhole, stderr=STDOUT)
     processes.append(cp)
     time.sleep(.5)
     add_engines(1)
@@ -38,7 +38,7 b" def add_engines(n=1, profile='iptest'):"
     base = len(rc)
     eps = []
     for i in range(n):
-        ep = Popen(['ipenginez']+ ['--profile', profile, '--log-level', '10', '--log-to-file'], stdout=blackhole, stderr=STDOUT)
+        ep = Popen(['ipengine']+ ['--profile', profile, '--log-level', '10', '--log-to-file'], stdout=blackhole, stderr=STDOUT)
         # ep.start()
         processes.append(ep)
         eps.append(ep)

IPython/parallel/tests/test_newserialized.py

@@ -13,7 +13,7 b''
 
 from unittest import TestCase
 
-from IPython.testing.parametric import parametric
+from IPython.testing.decorators import parametric
 from IPython.utils import newserialized as ns
 from IPython.utils.pickleutil import can, uncan, CannedObject, CannedFunction
 from IPython.parallel.tests.clienttest import skip_without

IPython/testing/iptest.py

@@ -185,6 +185,7 b' def make_exclude():'
 
     if not have['zmq']:
         exclusions.append(ipjoin('zmq'))
+        exclusions.append(ipjoin('parallel'))
 
     # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
     if sys.platform == 'win32':

docs/source/index.txt

@@ -19,8 +19,7 b' Contents'
    whatsnew/index.txt
    install/index.txt
    interactive/index.txt
-   .. parallel/index.txt
-   parallelz/index.txt
+   parallel/index.txt
    config/index.txt
    development/index.txt
    api/index.txt

docs/source/install/install.txt

@@ -9,16 +9,16 b' install all of its dependencies.'
 
 
 Please let us know if you have problems installing IPython or any of its
-dependencies. Officially, IPython requires Python version 2.5 or 2.6.  We
-have *not* yet started to port IPython to Python 3.0.
+dependencies. Officially, IPython requires Python version 2.6 or 2.7.  There
+is an experimental port of IPython for Python3 `on GitHub 
+<https://github.com/ipython/ipython-py3k>`_
 
 .. warning::
 
-    Officially, IPython supports Python versions 2.5 and 2.6.
+    Officially, IPython supports Python versions 2.6 and 2.7.
 
-    IPython 0.10 has only been well tested with Python 2.5 and 2.6.  Parts of
-    it may work with Python 2.4, but we do not officially support Python 2.4
-    anymore.  If you need to use 2.4, you can still run IPython 0.9.
+    IPython 0.11 has a hard syntax dependency on 2.6, and will no longer work
+    on Python <= 2.5.
 
 Some of the installation approaches use the :mod:`setuptools` package and its
 :command:`easy_install` command line program.  In many scenarios, this provides
@@ -38,9 +38,9 b' optional dependencies:'
 
 .. code-block:: bash
 
-    $ easy_install ipython[kernel,security,test]
+    $ easy_install ipython[zmq,test]
 
-This will get Twisted, zope.interface and Foolscap, which are needed for
+This will get pyzmq, which is needed for
 IPython's parallel computing features as well as the nose package, which will
 enable you to run IPython's test suite.  
 
@@ -221,8 +221,7 b' On Windows, you will need the PyReadline module. PyReadline is a separate,'
 Windows only implementation of readline that uses native Windows calls through
 :mod:`ctypes`. The easiest way of installing PyReadline is you use the binary
 installer available `here <http://ipython.scipy.org/dist/>`_. The :mod:`ctypes`
-module, which comes with Python 2.5 and greater, is required by PyReadline. It
-is available for Python 2.4 at http://python.net/crew/theller/ctypes.
+module, which comes with Python 2.5 and greater, is required by PyReadline.
 
 nose
 ----
@@ -267,91 +266,30 b" The `pexpect <http://www.noah.org/wiki/Pexpect>`_ package is used in IPython's"
 
 Windows users are out of luck as pexpect does not run there.
 
-Dependencies for IPython.kernel (parallel computing)
-====================================================
+Dependencies for IPython.parallel (parallel computing)
+======================================================
 
-The IPython kernel provides a nice architecture for parallel computing.  The
-main focus of this architecture is on interactive parallel computing.  These
-features require a number of additional packages:
+:mod:`IPython.kernel` has been replaced by :mod:`IPython.parallel`, 
+which uses ZeroMQ for all communication.
 
-* zope.interface (yep, we use interfaces)
-* Twisted (asynchronous networking framework)
-* Foolscap (a nice, secure network protocol)
-* pyOpenSSL (security for network connections)
+IPython.parallel provides a nice architecture for parallel computing.  The
+main focus of this architecture is on interactive parallel computing.  These
+features require just one package: pyzmq.  See the next section for pyzmq
+details.
 
 On a Unix style platform (including OS X), if you want to use
 :mod:`setuptools`, you can just do:
 
 .. code-block:: bash
 
-    $ easy_install ipython[kernel]    # the first three
-    $ easy_install ipython[security]  # pyOpenSSL
-
-zope.interface and Twisted
---------------------------
-
-Twisted [Twisted]_ and zope.interface [ZopeInterface]_ are used for networking
-related things. On Unix style platforms (including OS X), the simplest way of
-getting the these is to use :command:`easy_install`:
-
-.. code-block:: bash
-
-    $ easy_install zope.interface
-    $ easy_install Twisted
+    $ easy_install ipython[zmq]    # will include pyzmq
 
-Of course, you can also download the source tarballs from the Twisted website
-[Twisted]_ and the 
-`zope.interface page at PyPI <http://pypi.python.org/pypi/zope.interface>`_ 
-and do the usual ``python setup.py install`` if you prefer.
+Security in IPython.parallel is provided by SSH tunnels.  By default, Linux
+and OSX clients will use the shell ssh command, but on Windows, we also
+support tunneling with paramiko [paramiko]_.
 
-Windows is a bit different. For zope.interface and Twisted, simply get the
-latest binary ``.exe`` installer from the Twisted website. This installer
-includes both zope.interface and Twisted and should just work.
-
-Foolscap
---------
-
-Foolscap [Foolscap]_ uses Twisted to provide a very nice secure RPC protocol that we use to implement our parallel computing features.
-
-On all platforms a simple:
-
-.. code-block:: bash
-
-    $ easy_install foolscap
-
-should work.  You can also download the source tarballs from the `Foolscap
-website <http://foolscap.lothar.com/trac>`_ and do ``python setup.py install``
-if you prefer.
-
-pyOpenSSL
----------
-
-IPython does not work with version 0.7 of pyOpenSSL [pyOpenSSL]_. It is known
-to work with version 0.6 and will likely work with the more recent 0.8 and 0.9
-versions. There are a couple of options for getting this:
-
-1. Most Linux distributions have packages for pyOpenSSL.
-2. The built-in Python 2.5 on OS X 10.5 already has it installed.
-3. There are source tarballs on the pyOpenSSL website.  On Unix-like
-   platforms, these can be built using ``python seutp.py install``.
-4. There is also a binary ``.exe`` Windows installer on the 
-   `pyOpenSSL website <http://pyopenssl.sourceforge.net/>`_.
-
-Dependencies for IPython.frontend (the IPython GUI)
-===================================================
-
-wxPython
---------
-
-Starting with IPython 0.9, IPython has a new :mod:`IPython.frontend` package
-that has a nice wxPython based IPython GUI. As you would expect, this GUI
-requires wxPython. Most Linux distributions have wxPython packages available
-and the built-in Python on OS X comes with wxPython preinstalled. For Windows,
-a binary installer is available on the `wxPython website
-<http://www.wxpython.org/>`_.
-
-Dependencies for IPython.zmq (new parallel)
-===========================================
+Dependencies for IPython.zmq
+============================
 
 pyzmq
 -----
@@ -359,9 +297,11 b' pyzmq'
 IPython 0.11 introduced some new functionality, including a two-process
 execution model using ZeroMQ for communication [ZeroMQ]_. The Python bindings
 to ZeroMQ are found in the pyzmq project, which is easy_install-able once you
-have ZeroMQ installed. :mod:`IPython.kernel` is also in the process of being
-replaced by :mod:`IPython.zmq.parallel`, which uses ZeroMQ for all
-communication.
+have ZeroMQ installed (or even if you don't).
+
+IPython.zmq depends on pyzmq >= 2.0.10.1, but IPython.parallel requires the more
+recent 2.1.4.  2.1.4 also has binary releases for OSX and Windows, that do not
+require prior installation of libzmq.
 
 Dependencies for ipython-qtconsole (new GUI)
 ============================================
@@ -377,11 +317,12 b' which can be installed from the'
 pygments
 --------
 
-The syntax-highlighting in ``ipython-qtconsole`` is done with the pygments project, which is easy_install-able.
+The syntax-highlighting in ``ipython-qtconsole`` is done with the pygments project, 
+which is easy_install-able.
 
 .. [Twisted] Twisted matrix.  http://twistedmatrix.org
 .. [ZopeInterface] http://pypi.python.org/pypi/zope.interface
 .. [Foolscap] Foolscap network protocol.  http://foolscap.lothar.com/trac
 .. [pyOpenSSL] pyOpenSSL.  http://pyopenssl.sourceforge.net
 .. [ZeroMQ] ZeroMQ.  http://www.zeromq.org
-
+.. [paramiko] paramiko. https://github.com/robey/paramiko

docs/source/parallel/index.txt

@@ -4,9 +4,19 b''
 Using IPython for parallel computing
 ====================================
 
-The twisted-based :mod:`IPython.kernel` has been removed, in favor of
-the new 0MQ-based :mod:`IPython.parallel`, whose merge into master is imminent.
+.. toctree::
+   :maxdepth: 2
+
+   parallel_intro.txt
+   parallel_process.txt
+   parallel_multiengine.txt
+   parallel_task.txt
+   parallel_mpi.txt
+   parallel_security.txt
+   parallel_winhpc.txt
+   parallel_demos.txt
+   dag_dependencies.txt
+   parallel_details.txt
+   parallel_transition.txt
+
 
-Until that code is merged, it can be found in the `newparallel branch 
-<https://github.com/ipython/ipython/tree/newparallel>`_, and its draft documentation can be
-found `here <http://minrk.github.com/ipython-doc/newparallel>`_.
  No newline at end of file

docs/source/parallel/parallel_demos.txt

@@ -110,7 +110,7 b' results. The code to run this calculation in parallel is contained in'
 :file:`docs/examples/newparallel/parallelpi.py`. This code can be run in parallel
 using IPython by following these steps:
 
-1. Use :command:`ipclusterz` to start 15 engines. We used an 8 core (2 quad 
+1. Use :command:`ipcluster` to start 15 engines. We used an 8 core (2 quad 
    core CPUs) cluster with hyperthreading enabled which makes the 8 cores 
    looks like 16 (1 controller + 15 engines) in the OS. However, the maximum
    speedup we can observe is still only 8x.
@@ -230,7 +230,7 b' plot using Matplotlib.'
 .. literalinclude:: ../../examples/newparallel/mcdriver.py
    :language: python
 
-To use this code, start an IPython cluster using :command:`ipclusterz`, open
+To use this code, start an IPython cluster using :command:`ipcluster`, open
 IPython in the pylab mode with the file :file:`mcdriver.py` in your current
 working directory and then type:
 

docs/source/parallel/parallel_intro.txt

@@ -156,7 +156,7 b' To connect and authenticate to the controller an engine or client needs'
 some information that the controller has stored in a JSON file.
 Thus, the JSON files need to be copied to a location where
 the clients and engines can find them. Typically, this is the
-:file:`~/.ipython/clusterz_default/security` directory on the host where the 
+:file:`~/.ipython/cluster_default/security` directory on the host where the 
 client/engine is running (which could be a different host than the controller). 
 Once the JSON files are copied over, everything should work fine.
 
@@ -192,10 +192,10 b' Getting Started'
 To use IPython for parallel computing, you need to start one instance of the
 controller and one or more instances of the engine. Initially, it is best to
 simply start a controller and engines on a single host using the
-:command:`ipclusterz` command. To start a controller and 4 engines on your
+:command:`ipcluster` command. To start a controller and 4 engines on your
 localhost, just do::
 
-    $ ipclusterz start -n 4
+    $ ipcluster start -n 4
 
 More details about starting the IPython controller and engines can be found
 :ref:`here <parallel_process>`
@@ -218,7 +218,7 b' everything is working correctly, try the following commands:'
 
 
 When a client is created with no arguments, the client tries to find the corresponding JSON file
-in the local `~/.ipython/clusterz_default/security` directory. Or if you specified a profile,
+in the local `~/.ipython/cluster_default/security` directory. Or if you specified a profile,
 you can use that with the Client.  This should cover most cases:
 
 .. sourcecode:: ipython

docs/source/parallel/parallel_mpi.txt

@@ -50,16 +50,16 b' To use code that calls MPI, there are typically two things that MPI requires.'
 There are a couple of ways that you can start the IPython engines and get
 these things to happen.
 
-Automatic starting using :command:`mpiexec` and :command:`ipclusterz`
+Automatic starting using :command:`mpiexec` and :command:`ipcluster`
 --------------------------------------------------------------------
 
-The easiest approach is to use the `mpiexec` mode of :command:`ipclusterz`,
+The easiest approach is to use the `mpiexec` mode of :command:`ipcluster`,
 which will first start a controller and then a set of engines using
 :command:`mpiexec`::
 
-    $ ipclusterz mpiexec -n 4
+    $ ipcluster mpiexec -n 4
 
-This approach is best as interrupting :command:`ipclusterz` will automatically
+This approach is best as interrupting :command:`ipcluster` will automatically
 stop and clean up the controller and engines.
 
 Manual starting using :command:`mpiexec`
@@ -68,20 +68,20 b' Manual starting using :command:`mpiexec`'
 If you want to start the IPython engines using the :command:`mpiexec`, just
 do::
 
-    $ mpiexec -n 4 ipenginez --mpi=mpi4py
+    $ mpiexec -n 4 ipengine --mpi=mpi4py
 
 This requires that you already have a controller running and that the FURL
 files for the engines are in place. We also have built in support for
 PyTrilinos [PyTrilinos]_, which can be used (assuming is installed) by
 starting the engines with::
 
-    $ mpiexec -n 4 ipenginez --mpi=pytrilinos
+    $ mpiexec -n 4 ipengine --mpi=pytrilinos
 
-Automatic starting using PBS and :command:`ipclusterz`
+Automatic starting using PBS and :command:`ipcluster`
 ------------------------------------------------------
 
-The :command:`ipclusterz` command also has built-in integration with PBS. For
-more information on this approach, see our documentation on :ref:`ipclusterz
+The :command:`ipcluster` command also has built-in integration with PBS. For
+more information on this approach, see our documentation on :ref:`ipcluster
 <parallel_process>`.
 
 Actually using MPI
@@ -110,7 +110,7 b' distributed array. Save the following text in a file called :file:`psum.py`:'
 
 Now, start an IPython cluster::
 
-    $ ipclusterz start -p mpi -n 4
+    $ ipcluster start -p mpi -n 4
     
 .. note::
 

docs/source/parallel/parallel_multiengine.txt

@@ -17,9 +17,9 b' Starting the IPython controller and engines'
 
 To follow along with this tutorial, you will need to start the IPython
 controller and four IPython engines. The simplest way of doing this is to use
-the :command:`ipclusterz` command::
+the :command:`ipcluster` command::
 
-    $ ipclusterz start -n 4
+    $ ipcluster start -n 4
     
 For more detailed information about starting the controller and engines, see
 our :ref:`introduction <ip1par>` to using IPython for parallel computing.
@@ -37,7 +37,7 b' module and then create a :class:`.Client` instance:'
     In [2]: rc = Client()
 
 This form assumes that the default connection information (stored in
-:file:`ipcontroller-client.json` found in :file:`IPYTHON_DIR/clusterz_default/security`) is
+:file:`ipcontroller-client.json` found in :file:`IPYTHON_DIR/cluster_default/security`) is
 accurate. If the controller was started on a remote machine, you must copy that connection
 file to the client machine, or enter its contents as arguments to the Client constructor:
 

docs/source/parallel/parallel_process.txt

@@ -11,12 +11,12 b' Because of this, there are many different possibilities.'
 
 Broadly speaking, there are two ways of going about starting a controller and engines:
 
-* In an automated manner using the :command:`ipclusterz` command.
-* In a more manual way using the :command:`ipcontrollerz` and 
-  :command:`ipenginez` commands.
+* In an automated manner using the :command:`ipcluster` command.
+* In a more manual way using the :command:`ipcontroller` and 
+  :command:`ipengine` commands.
 
 This document describes both of these methods. We recommend that new users
-start with the :command:`ipclusterz` command as it simplifies many common usage
+start with the :command:`ipcluster` command as it simplifies many common usage
 cases.
 
 General considerations
@@ -30,29 +30,29 b' matter which method you use to start your IPython cluster.'
 Let's say that you want to start the controller on ``host0`` and engines on
 hosts ``host1``-``hostn``. The following steps are then required:
 
-1. Start the controller on ``host0`` by running :command:`ipcontrollerz` on
+1. Start the controller on ``host0`` by running :command:`ipcontroller` on
    ``host0``.
 2. Move the JSON file (:file:`ipcontroller-engine.json`) created by the 
    controller from ``host0`` to hosts ``host1``-``hostn``.
 3. Start the engines on hosts ``host1``-``hostn`` by running 
-   :command:`ipenginez`.  This command has to be told where the JSON file 
+   :command:`ipengine`.  This command has to be told where the JSON file 
    (:file:`ipcontroller-engine.json`) is located.
 
 At this point, the controller and engines will be connected. By default, the JSON files
-created by the controller are put into the :file:`~/.ipython/clusterz_default/security`
+created by the controller are put into the :file:`~/.ipython/cluster_default/security`
 directory. If the engines share a filesystem with the controller, step 2 can be skipped as
 the engines will automatically look at that location.
 
 The final step required to actually use the running controller from a client is to move
 the JSON file :file:`ipcontroller-client.json` from ``host0`` to any host where clients
-will be run. If these file are put into the :file:`~/.ipython/clusterz_default/security`
+will be run. If these file are put into the :file:`~/.ipython/cluster_default/security`
 directory of the client's host, they will be found automatically. Otherwise, the full path
 to them has to be passed to the client's constructor.
 
-Using :command:`ipclusterz`
+Using :command:`ipcluster`
 ===========================
 
-The :command:`ipclusterz` command provides a simple way of starting a
+The :command:`ipcluster` command provides a simple way of starting a
 controller and engines in the following situations:
 
 1. When the controller and engines are all run on localhost. This is useful
@@ -67,24 +67,24 b' controller and engines in the following situations:'
 
 .. note::
 
-    Currently :command:`ipclusterz` requires that the
+    Currently :command:`ipcluster` requires that the
     :file:`~/.ipython/cluster_<profile>/security` directory live on a shared filesystem that is
     seen by both the controller and engines. If you don't have a shared file
-    system you will need to use :command:`ipcontrollerz` and
-    :command:`ipenginez` directly.
+    system you will need to use :command:`ipcontroller` and
+    :command:`ipengine` directly.
 
-Under the hood, :command:`ipclusterz` just uses :command:`ipcontrollerz`
-and :command:`ipenginez` to perform the steps described above.
+Under the hood, :command:`ipcluster` just uses :command:`ipcontroller`
+and :command:`ipengine` to perform the steps described above.
 
-The simplest way to use ipclusterz requires no configuration, and will
+The simplest way to use ipcluster requires no configuration, and will
 launch a controller and a number of engines on the local machine. For instance, 
 to start one controller and 4 engines on localhost, just do::
 
-    $ ipclusterz start -n 4
+    $ ipcluster start -n 4
 
 To see other command line options for the local mode, do::
 
-    $ ipclusterz -h
+    $ ipcluster -h
 
 
 Configuring an IPython cluster
@@ -92,25 +92,25 b' Configuring an IPython cluster'
 
 Cluster configurations are stored as `profiles`.  You can create a new profile with::
 
-    $ ipclusterz create -p myprofile
+    $ ipcluster create -p myprofile
 
-This will create the directory :file:`IPYTHONDIR/clusterz_myprofile`, and populate it
+This will create the directory :file:`IPYTHONDIR/cluster_myprofile`, and populate it
 with the default configuration files for the three IPython cluster commands. Once
-you edit those files, you can continue to call ipclusterz/ipcontrollerz/ipenginez
+you edit those files, you can continue to call ipcluster/ipcontroller/ipengine
 with no arguments beyond ``-p myprofile``, and any configuration will be maintained.
 
 There is no limit to the number of profiles you can have, so you can maintain a profile for each
 of your common use cases. The default profile will be used whenever the
-profile argument is not specified, so edit :file:`IPYTHONDIR/clusterz_default/*_config.py` to
+profile argument is not specified, so edit :file:`IPYTHONDIR/cluster_default/*_config.py` to
 represent your most common use case.
 
 The configuration files are loaded with commented-out settings and explanations,
 which should cover most of the available possibilities.
 
-Using various batch systems with :command:`ipclusterz`
+Using various batch systems with :command:`ipcluster`
 ------------------------------------------------------
 
-:command:`ipclusterz` has a notion of Launchers that can start controllers
+:command:`ipcluster` has a notion of Launchers that can start controllers
 and engines with various remote execution schemes.  Currently supported
 models include `mpiexec`, PBS-style (Torque, SGE), and Windows HPC Server.
 
@@ -120,7 +120,7 b' models include `mpiexec`, PBS-style (Torque, SGE), and Windows HPC Server.'
     users can subclass and configure them to fit their own system that we
     have not yet supported (such as Condor)
 
-Using :command:`ipclusterz` in mpiexec/mpirun mode
+Using :command:`ipcluster` in mpiexec/mpirun mode
 --------------------------------------------------
 
 
@@ -132,11 +132,11 b' The mpiexec/mpirun mode is useful if you:'
 
 If these are satisfied, you can create a new profile::
 
-    $ ipclusterz create -p mpi
+    $ ipcluster create -p mpi
 
-and edit the file :file:`IPYTHONDIR/clusterz_mpi/ipclusterz_config.py`.
+and edit the file :file:`IPYTHONDIR/cluster_mpi/ipcluster_config.py`.
 
-There, instruct ipclusterz to use the MPIExec launchers by adding the lines:
+There, instruct ipcluster to use the MPIExec launchers by adding the lines:
 
 .. sourcecode:: python
 
@@ -144,7 +144,7 b' There, instruct ipclusterz to use the MPIExec launchers by adding the lines:'
 
 If the default MPI configuration is correct, then you can now start your cluster, with::
 
-    $ ipclusterz start -n 4 -p mpi
+    $ ipcluster start -n 4 -p mpi
 
 This does the following:
 
@@ -166,7 +166,7 b' On newer MPI implementations (such as OpenMPI), this will work even if you'
 don't make any calls to MPI or call :func:`MPI_Init`. However, older MPI
 implementations actually require each process to call :func:`MPI_Init` upon
 starting. The easiest way of having this done is to install the mpi4py
-[mpi4py]_ package and then specify the ``c.MPI.use`` option in :file:`ipenginez_config.py`:
+[mpi4py]_ package and then specify the ``c.MPI.use`` option in :file:`ipengine_config.py`:
 
 .. sourcecode:: python
 
@@ -177,21 +177,21 b' having problems with this, you will likely have to use a custom Python'
 executable that itself calls :func:`MPI_Init` at the appropriate time.
 Fortunately, mpi4py comes with such a custom Python executable that is easy to
 install and use. However, this custom Python executable approach will not work
-with :command:`ipclusterz` currently.
+with :command:`ipcluster` currently.
 
 More details on using MPI with IPython can be found :ref:`here <parallelmpi>`.
 
 
-Using :command:`ipclusterz` in PBS mode
+Using :command:`ipcluster` in PBS mode
 ---------------------------------------
 
 The PBS mode uses the Portable Batch System [PBS]_ to start the engines. 
 
 As usual, we will start by creating a fresh profile::
 
-    $ ipclusterz create -p pbs
+    $ ipcluster create -p pbs
 
-And in :file:`ipclusterz_config.py`, we will select the PBS launchers for the controller
+And in :file:`ipcluster_config.py`, we will select the PBS launchers for the controller
 and engines:
 
 .. sourcecode:: python
@@ -213,7 +213,7 b' to specify your own. Here is a sample PBS script template:'
     cd $$PBS_O_WORKDIR
     export PATH=$$HOME/usr/local/bin
     export PYTHONPATH=$$HOME/usr/local/lib/python2.7/site-packages
-    /usr/local/bin/mpiexec -n ${n} ipenginez --cluster_dir=${cluster_dir}
+    /usr/local/bin/mpiexec -n ${n} ipengine --cluster_dir=${cluster_dir}
 
 There are a few important points about this template:
 
@@ -232,8 +232,8 b' There are a few important points about this template:'
    environment variables in the template, or in SGE, where the config lines start
    with ``#$``, which will have to be ``#$$``.
 
-4. Any options to :command:`ipenginez` can be given in the batch script 
-   template, or in :file:`ipenginez_config.py`.
+4. Any options to :command:`ipengine` can be given in the batch script 
+   template, or in :file:`ipengine_config.py`.
 
 5. Depending on the configuration of you system, you may have to set 
    environment variables in the script template.
@@ -251,11 +251,11 b' The controller template should be similar, but simpler:'
     cd $$PBS_O_WORKDIR
     export PATH=$$HOME/usr/local/bin
     export PYTHONPATH=$$HOME/usr/local/lib/python2.7/site-packages
-    ipcontrollerz --cluster_dir=${cluster_dir}
+    ipcontroller --cluster_dir=${cluster_dir}
 
 
 Once you have created these scripts, save them with names like
-:file:`pbs.engine.template`. Now you can load them into the :file:`ipclusterz_config` with:
+:file:`pbs.engine.template`. Now you can load them into the :file:`ipcluster_config` with:
 
 .. sourcecode:: python
 
@@ -264,12 +264,12 b' Once you have created these scripts, save them with names like'
     c.PBSControllerLauncher.batch_template_file = "pbs.controller.template"
         
 
-Alternately, you can just define the templates as strings inside :file:`ipclusterz_config`.
+Alternately, you can just define the templates as strings inside :file:`ipcluster_config`.
 
 Whether you are using your own templates or our defaults, the extra configurables available are
 the number of engines to launch (``$n``, and the batch system queue to which the jobs are to be
 submitted (``$queue``)). These are configurables, and can be specified in
-:file:`ipclusterz_config`:
+:file:`ipcluster_config`:
 
 .. sourcecode:: python
 
@@ -279,7 +279,7 b' submitted (``$queue``)). These are configurables, and can be specified in'
 Note that assuming you are running PBS on a multi-node cluster, the Controller's default behavior
 of listening only on localhost is likely too restrictive.  In this case, also assuming the
 nodes are safely behind a firewall, you can simply instruct the Controller to listen for
-connections on all its interfaces, by adding in :file:`ipcontrollerz_config`:
+connections on all its interfaces, by adding in :file:`ipcontroller_config`:
 
 .. sourcecode:: python
 
@@ -287,9 +287,9 b' connections on all its interfaces, by adding in :file:`ipcontrollerz_config`:'
 
 You can now run the cluster with::
 
-    $ ipclusterz start -p pbs -n 128
+    $ ipcluster start -p pbs -n 128
 
-Additional configuration options can be found in the PBS section of :file:`ipclusterz_config`.
+Additional configuration options can be found in the PBS section of :file:`ipcluster_config`.
 
 .. note::
 
@@ -298,12 +298,12 b' Additional configuration options can be found in the PBS section of :file:`ipclu'
     and with further configuration in similar batch systems like Condor.
 
 
-Using :command:`ipclusterz` in SSH mode
+Using :command:`ipcluster` in SSH mode
 ---------------------------------------
 
 
-The SSH mode uses :command:`ssh` to execute :command:`ipenginez` on remote
-nodes and :command:`ipcontrollerz` can be run remotely as well, or on localhost.
+The SSH mode uses :command:`ssh` to execute :command:`ipengine` on remote
+nodes and :command:`ipcontroller` can be run remotely as well, or on localhost.
 
 .. note::
 
@@ -312,9 +312,9 b' nodes and :command:`ipcontrollerz` can be run remotely as well, or on localhost.'
 
 As usual, we start by creating a clean profile::
 
-    $ ipclusterz create -p ssh
+    $ ipcluster create -p ssh
 
-To use this mode, select the SSH launchers in :file:`ipclusterz_config.py`:
+To use this mode, select the SSH launchers in :file:`ipcluster_config.py`:
 
 .. sourcecode:: python
 
@@ -331,9 +331,9 b" The controller's remote location and configuration can be specified:"
     # c.SSHControllerLauncher.hostname = 'controller.example.com'
     # c.SSHControllerLauncher.user = os.environ.get('USER','username')
 
-    # Set the arguments to be passed to ipcontrollerz
-    # note that remotely launched ipcontrollerz will not get the contents of 
-    # the local ipcontrollerz_config.py unless it resides on the *remote host*
+    # Set the arguments to be passed to ipcontroller
+    # note that remotely launched ipcontroller will not get the contents of 
+    # the local ipcontroller_config.py unless it resides on the *remote host*
     # in the location specified by the --cluster_dir argument.
     # c.SSHControllerLauncher.program_args = ['-r', '-ip', '0.0.0.0', '--cluster_dir', '/path/to/cd']
 
@@ -357,46 +357,46 b' on that host.'
 * The `engines` dict, where the keys are the host we want to run engines on and
   the value is the number of engines to run on that host.
 * on host3, the value is a tuple, where the number of engines is first, and the arguments
-  to be passed to :command:`ipenginez` are the second element.
+  to be passed to :command:`ipengine` are the second element.
 
 For engines without explicitly specified arguments, the default arguments are set in
 a single location:
 
 .. sourcecode:: python
 
-    c.SSHEngineSetLauncher.engine_args = ['--cluster_dir', '/path/to/clusterz_ssh']
+    c.SSHEngineSetLauncher.engine_args = ['--cluster_dir', '/path/to/cluster_ssh']
 
-Current limitations of the SSH mode of :command:`ipclusterz` are:
+Current limitations of the SSH mode of :command:`ipcluster` are:
 
 * Untested on Windows. Would require a working :command:`ssh` on Windows.
   Also, we are using shell scripts to setup and execute commands on remote
   hosts.
 * No file movement - 
 
-Using the :command:`ipcontrollerz` and :command:`ipenginez` commands
+Using the :command:`ipcontroller` and :command:`ipengine` commands
 ====================================================================
 
-It is also possible to use the :command:`ipcontrollerz` and :command:`ipenginez`
+It is also possible to use the :command:`ipcontroller` and :command:`ipengine`
 commands to start your controller and engines. This approach gives you full
 control over all aspects of the startup process.
 
 Starting the controller and engine on your local machine
 --------------------------------------------------------
 
-To use :command:`ipcontrollerz` and :command:`ipenginez` to start things on your
+To use :command:`ipcontroller` and :command:`ipengine` to start things on your
 local machine, do the following.
 
 First start the controller::
 
-    $ ipcontrollerz
+    $ ipcontroller
     
 Next, start however many instances of the engine you want using (repeatedly)
 the command::
 
-    $ ipenginez
+    $ ipengine
 
 The engines should start and automatically connect to the controller using the
-JSON files in :file:`~/.ipython/clusterz_default/security`. You are now ready to use the
+JSON files in :file:`~/.ipython/cluster_default/security`. You are now ready to use the
 controller and engines from IPython.
 
 .. warning:: 
@@ -418,18 +418,18 b' Starting the controller and engines on different hosts'
 When the controller and engines are running on different hosts, things are
 slightly more complicated, but the underlying ideas are the same:
 
-1. Start the controller on a host using :command:`ipcontrollerz`.
+1. Start the controller on a host using :command:`ipcontroller`.
 2. Copy :file:`ipcontroller-engine.json` from :file:`~/.ipython/cluster_<profile>/security` on
    the controller's host to the host where the engines will run.
-3. Use :command:`ipenginez` on the engine's hosts to start the engines.
+3. Use :command:`ipengine` on the engine's hosts to start the engines.
 
-The only thing you have to be careful of is to tell :command:`ipenginez` where
+The only thing you have to be careful of is to tell :command:`ipengine` where
 the :file:`ipcontroller-engine.json` file is located. There are two ways you
 can do this:
 
 * Put :file:`ipcontroller-engine.json` in the :file:`~/.ipython/cluster_<profile>/security`
   directory on the engine's host, where it will be found automatically.
-* Call :command:`ipenginez` with the ``--file=full_path_to_the_file``
+* Call :command:`ipengine` with the ``--file=full_path_to_the_file``
   flag.
 
 The ``--file`` flag works like this::
@@ -455,7 +455,7 b' any point in the future.'
 To do this, the only thing you have to do is specify the `-r` flag, so that
 the connection information in the JSON files remains accurate::
 
-    $ ipcontrollerz -r
+    $ ipcontroller -r
 
 Then, just copy the JSON files over the first time and you are set. You can
 start and stop the controller and engines any many times as you want in the
@@ -478,7 +478,7 b' IPython and can be found in the directory :file:`~/.ipython/cluster_<profile>/lo'
 Sending the log files to us will often help us to debug any problems.
 
 
-Configuring `ipcontrollerz`
+Configuring `ipcontroller`
 ---------------------------
 
 Ports and addresses
@@ -493,7 +493,7 b' Database Backend'
 
     
 
-Configuring `ipenginez`
+Configuring `ipengine`
 -----------------------
 
 .. note::

docs/source/parallel/parallel_security.txt

@@ -130,7 +130,7 b' way.'
 There is exactly one key per cluster - it must be the same everywhere. Typically, the
 controller creates this key, and stores it in the private connection files
 `ipython-{engine|client}.json`. These files are typically stored in the
-`~/.ipython/clusterz_<profile>/security` directory, and are maintained as readable only by
+`~/.ipython/cluster_<profile>/security` directory, and are maintained as readable only by
 the owner, just as is common practice with a user's keys in their `.ssh` directory.
 
 .. warning::

docs/source/parallel/parallel_task.txt

@@ -22,9 +22,9 b' Starting the IPython controller and engines'
 
 To follow along with this tutorial, you will need to start the IPython
 controller and four IPython engines. The simplest way of doing this is to use
-the :command:`ipclusterz` command::
+the :command:`ipcluster` command::
 
-	$ ipclusterz start -n 4
+	$ ipcluster start -n 4
 	
 For more detailed information about starting the controller and engines, see
 our :ref:`introduction <ip1par>` to using IPython for parallel computing.
@@ -321,16 +321,16 b' Schedulers'
 There are a variety of valid ways to determine where jobs should be assigned in a 
 load-balancing situation.  In IPython, we support several standard schemes, and
 even make it easy to define your own.  The scheme can be selected via the ``--scheme``
-argument to :command:`ipcontrollerz`, or in the :attr:`HubFactory.scheme` attribute
+argument to :command:`ipcontroller`, or in the :attr:`HubFactory.scheme` attribute
 of a controller config object.
 
 The built-in routing schemes:
 
 To select one of these schemes, simply do::
 
-    $ ipcontrollerz --scheme <schemename>
+    $ ipcontroller --scheme <schemename>
     for instance:
-    $ ipcontrollerz --scheme lru
+    $ ipcontroller --scheme lru
 
 lru: Least Recently Used
 

docs/source/parallel/parallel_winhpc.txt

@@ -144,25 +144,25 b' in parallel on the engines from within the IPython shell using an appropriate'
 client. This includes the ability to interact with, plot and visualize data
 from the engines.
 
-IPython has a command line program called :command:`ipclusterz` that automates
+IPython has a command line program called :command:`ipcluster` that automates
 all aspects of starting the controller and engines on the compute nodes.
-:command:`ipclusterz` has full support for the Windows HPC job scheduler,
-meaning that :command:`ipclusterz` can use this job scheduler to start the
+:command:`ipcluster` has full support for the Windows HPC job scheduler,
+meaning that :command:`ipcluster` can use this job scheduler to start the
 controller and engines. In our experience, the Windows HPC job scheduler is
 particularly well suited for interactive applications, such as IPython. Once
-:command:`ipclusterz` is configured properly, a user can start an IPython
+:command:`ipcluster` is configured properly, a user can start an IPython
 cluster from their local workstation almost instantly, without having to log
 on to the head node (as is typically required by Unix based job schedulers).
 This enables a user to move seamlessly between serial and parallel
 computations.
 
-In this section we show how to use :command:`ipclusterz` to start an IPython
+In this section we show how to use :command:`ipcluster` to start an IPython
 cluster using the Windows HPC Server 2008 job scheduler. To make sure that
-:command:`ipclusterz` is installed and working properly, you should first try
+:command:`ipcluster` is installed and working properly, you should first try
 to start an IPython cluster on your local host. To do this, open a Windows
 Command Prompt and type the following command::
 
-    ipclusterz start -n 2
+    ipcluster start -n 2
 
 You should see a number of messages printed to the screen, ending with 
 "IPython cluster: started". The result should look something like the following
@@ -174,12 +174,12 b' At this point, the controller and two engines are running on your local host.'
 This configuration is useful for testing and for situations where you want to
 take advantage of multiple cores on your local computer. 
 
-Now that we have confirmed that :command:`ipclusterz` is working properly, we
+Now that we have confirmed that :command:`ipcluster` is working properly, we
 describe how to configure and run an IPython cluster on an actual compute
 cluster running Windows HPC Server 2008. Here is an outline of the needed
 steps:
 
-1. Create a cluster profile using: ``ipclusterz create -p mycluster``
+1. Create a cluster profile using: ``ipcluster create -p mycluster``
 
 2. Edit configuration files in the directory :file:`.ipython\\cluster_mycluster`
 
@@ -191,7 +191,7 b' Creating a cluster profile'
 In most cases, you will have to create a cluster profile to use IPython on a
 cluster. A cluster profile is a name (like "mycluster") that is associated
 with a particular cluster configuration. The profile name is used by
-:command:`ipclusterz` when working with the cluster.
+:command:`ipcluster` when working with the cluster.
 
 Associated with each cluster profile is a cluster directory. This cluster
 directory is a specially named directory (typically located in the
@@ -204,10 +204,10 b' security keys. The naming convention for cluster directories is:'
 To create a new cluster profile (named "mycluster") and the associated cluster
 directory, type the following command at the Windows Command Prompt::
 
-    ipclusterz create -p mycluster
+    ipcluster create -p mycluster
 
 The output of this command is shown in the screenshot below. Notice how
-:command:`ipclusterz` prints out the location of the newly created cluster
+:command:`ipcluster` prints out the location of the newly created cluster
 directory.
 
 .. image:: ipcluster_create.*
@@ -218,19 +218,19 b' Configuring a cluster profile'
 Next, you will need to configure the newly created cluster profile by editing
 the following configuration files in the cluster directory:
 
-* :file:`ipclusterz_config.py`
+* :file:`ipcluster_config.py`
 * :file:`ipcontroller_config.py`
 * :file:`ipengine_config.py`
 
-When :command:`ipclusterz` is run, these configuration files are used to 
+When :command:`ipcluster` is run, these configuration files are used to 
 determine how the engines and controller will be started. In most cases,
 you will only have to set a few of the attributes in these files.
 
-To configure :command:`ipclusterz` to use the Windows HPC job scheduler, you
+To configure :command:`ipcluster` to use the Windows HPC job scheduler, you
 will need to edit the following attributes in the file
-:file:`ipclusterz_config.py`::
+:file:`ipcluster_config.py`::
 
-    # Set these at the top of the file to tell ipclusterz to use the
+    # Set these at the top of the file to tell ipcluster to use the
     # Windows HPC job scheduler.
     c.Global.controller_launcher = \
         'IPython.parallel.launcher.WindowsHPCControllerLauncher'
@@ -257,15 +257,15 b' Starting the cluster profile'
 Once a cluster profile has been configured, starting an IPython cluster using
 the profile is simple::
 
-    ipclusterz start -p mycluster -n 32
+    ipcluster start -p mycluster -n 32
 
-The ``-n`` option tells :command:`ipclusterz` how many engines to start (in
+The ``-n`` option tells :command:`ipcluster` how many engines to start (in
 this case 32). Stopping the cluster is as simple as typing Control-C.
 
 Using the HPC Job Manager
 -------------------------
 
-When ``ipclusterz start`` is run the first time, :command:`ipclusterz` creates
+When ``ipcluster start`` is run the first time, :command:`ipcluster` creates
 two XML job description files in the cluster directory:
 
 * :file:`ipcontroller_job.xml`
@@ -273,8 +273,8 b' two XML job description files in the cluster directory:'
 
 Once these files have been created, they can be imported into the HPC Job
 Manager application. Then, the controller and engines for that profile can be
-started using the HPC Job Manager directly, without using :command:`ipclusterz`.
-However, anytime the cluster profile is re-configured, ``ipclusterz start``
+started using the HPC Job Manager directly, without using :command:`ipcluster`.
+However, anytime the cluster profile is re-configured, ``ipcluster start``
 must be run again to regenerate the XML job description files. The
 following screenshot shows what the HPC Job Manager interface looks like
 with a running IPython cluster.

setup.py

@@ -215,16 +215,16 b" if 'setuptools' in sys.modules:"
             'ipython = IPython.frontend.terminal.ipapp:launch_new_instance',
             'ipython-qtconsole = IPython.frontend.qt.console.ipythonqt:main',
             'pycolor = IPython.utils.PyColorize:main',
-            'ipcontrollerz = IPython.parallel.ipcontrollerapp:launch_new_instance',
-            'ipenginez = IPython.parallel.ipengineapp:launch_new_instance',
-            'iploggerz = IPython.parallel.iploggerapp:launch_new_instance',
-            'ipclusterz = IPython.parallel.ipclusterapp:launch_new_instance',
+            'ipcontroller = IPython.parallel.ipcontrollerapp:launch_new_instance',
+            'ipengine = IPython.parallel.ipengineapp:launch_new_instance',
+            'iplogger = IPython.parallel.iploggerapp:launch_new_instance',
+            'ipcluster = IPython.parallel.ipclusterapp:launch_new_instance',
             'iptest = IPython.testing.iptest:main',
             'irunner = IPython.lib.irunner:main'
         ]
     }
     setup_args['extras_require'] = dict(
-        zmq = 'pyzmq>=2.0.10',
+        zmq = 'pyzmq>=2.0.10.1',
         doc='Sphinx>=0.3',
         test='nose>=0.10.1',
         security='pyOpenSSL>=0.6'

setupbase.py

@@ -127,6 +127,7 b' def find_packages():'
     add_package(packages, 'frontend.qt.console', tests=True)
     add_package(packages, 'frontend.terminal', tests=True)    
     add_package(packages, 'lib', tests=True)
+    add_package(packages, 'parallel', tests=True)
     add_package(packages, 'quarantine', tests=True)
     add_package(packages, 'scripts')
     add_package(packages, 'testing', tests=True)
@@ -134,7 +135,6 b' def find_packages():'
     add_package(packages, 'utils', tests=True)
     add_package(packages, 'zmq')
     add_package(packages, 'zmq.pylab')
-    add_package(packages, 'parallel')
     return packages
 
 #---------------------------------------------------------------------------
@@ -265,10 +265,10 b' def find_scripts():'
     parallel_scripts = pjoin('IPython','parallel','scripts')
     main_scripts = pjoin('IPython','scripts')
     scripts = [
-               pjoin(parallel_scripts, 'ipenginez'),
-               pjoin(parallel_scripts, 'ipcontrollerz'),
-               pjoin(parallel_scripts, 'ipclusterz'),
-               pjoin(parallel_scripts, 'iploggerz'),
+               pjoin(parallel_scripts, 'ipengine'),
+               pjoin(parallel_scripts, 'ipcontroller'),
+               pjoin(parallel_scripts, 'ipcluster'),
+               pjoin(parallel_scripts, 'iplogger'),
                pjoin(main_scripts, 'ipython'),
                pjoin(main_scripts, 'ipython-qtconsole'),
                pjoin(main_scripts, 'pycolor'),