Initial version of Win HPC job scehduler support.

IPython/config/default/ipcluster_config.py

@@ -1,155 +1,194 b''
 import os
 
 c = get_config()
 
 #-----------------------------------------------------------------------------
 # 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)
+# PBSControllerLauncher, WindowsHPCControllerLauncher)
 # c.Global.controller_launcher = 'IPython.kernel.launcher.LocalControllerLauncher'
 
 # Options are (LocalEngineSetLauncher, MPIExecEngineSetLauncher,
 # PBSEngineSetLauncher)
 # c.Global.engine_launcher = 'IPython.kernel.launcher.LocalEngineSetLauncher'
 
 #-----------------------------------------------------------------------------
 # 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
 
 # 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
 
 #-----------------------------------------------------------------------------
 # Controller launcher configuration
 #-----------------------------------------------------------------------------
 
 # 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 = []
 
 # 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 = """"""
 
 # 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'
 
 #-----------------------------------------------------------------------------
+# Windows HPC Server 2008 launcher configuration
+#-----------------------------------------------------------------------------
+
+# c.WinHPCJob.username = 'DOMAIN\\user'
+# c.WinHPCJob.priority = 'Highest'
+# c.WinHPCJob.requested_nodes = ''
+# c.WinHPCJob.project = ''
+# c.WinHPCJob.is_exclusive = False
+
+# c.WinHPCTask.environment_variables = {}
+# c.WinHPCTask.work_directory = ''
+# c.WinHPCTask.is_rerunnable = True
+
+# c.IPControllerTask.task_name = 'IPController'
+# c.IPControllerTask.controller_cmd = ['ipcontroller.exe']
+# c.IPControllerTask.controller_args = ['--log-to-file', '--log-level', '40']
+# c.IPControllerTask.environment_variables = {}
+
+# c.IPEngineTask.task_name = 'IPController'
+# c.IPEngineTask.engine_cmd = ['ipengine.exe']
+# c.IPEngineTask.engine_args = ['--log-to-file', '--log-level', '40']
+# c.IPEngineTask.environment_variables = {}
+
+# c.WindowsHPCLauncher.scheduler = 'HEADNODE'
+# c.WindowsHPCLauncher.username = '\\DOMAIN\USERNAME'
+# c.WindowsHPCLauncher.priority = 'Highest'
+# c.WindowsHPCLauncher.requested_nodes = ''
+# c.WindowsHPCLauncher.job_file_name = u'ipython_job.xml'
+# c.WindowsHPCLauncher.project = 'MyProject'
+
+# c.WindowsHPCControllerLauncher.scheduler = 'HEADNODE'
+# c.WindowsHPCControllerLauncher.username = '\\DOMAIN\USERNAME'
+# c.WindowsHPCControllerLauncher.priority = 'Highest'
+# c.WindowsHPCControllerLauncher.requested_nodes = ''
+# c.WindowsHPCControllerLauncher.job_file_name = u'ipcontroller_job.xml'
+# c.WindowsHPCControllerLauncher.project = 'MyProject'
+
+
+#-----------------------------------------------------------------------------
 # Engine launcher configuration
 #-----------------------------------------------------------------------------
 
 # 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 = []
 
 # 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 = """"""
 
 # 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/kernel/launcher.py

@@ -1,700 +1,808 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.utils.traitlets import Str, Int, List, Unicode, Enum
+from IPython.utils.platutils import find_cmd
 from IPython.kernel.twistedutil import gatherBoth, make_deferred, sleep_deferred
+from IPython.kernel.winhpcjob import (
+    WinHPCJob, WinHPCTask,
+    IPControllerTask, IPEngineTask
+)
 
 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.
 
         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.
 
         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.).
         """
         return defer.fail(
             Failure(NotImplementedError(
                 'start must be implemented in a subclass')
             )
         )
 
     def stop(self):
         """Stop the process and notify observers of stopping.
 
         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 trigger startup actions.
 
         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 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('', 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
 
+    # A regular expression used to get the job id from the output of the 
+    # submit_command.
+    job_id_regexp = Str('\d+', config=True)
+    # The filename of the instantiated job script.
+    job_file_name = Unicode(u'ipython_job.xml', config=True)
+    # The full path to the instantiated job script. This gets made dynamically
+    # by combining the working_dir with the job_file_name.
+    job_file = Unicode(u'')
+    # The hostname of the scheduler to submit the job to
+    scheduler = Str('HEADNODE', config=True)
+    username = Str(os.environ.get('USERNAME', ''), config=True)
+    priority = Enum(('Lowest','BelowNormal','Normal','AboveNormal','Highest'),
+        default_value='Highest', config=True)
+    requested_nodes = Str('', config=True)
+    project = Str('MyProject', config=True)
+    job_cmd = Str(find_cmd('job'), config=True)
+
+    def __init__(self, working_dir, parent=None, name=None, config=None):
+        super(WindowsHPCLauncher, self).__init__(
+            working_dir, parent, name, config
+        )
+        self.job_file = os.path.join(self.working_dir, self.job_file_name)
+
+    def write_job_file(self, n):
+        raise NotImplementedError("Implement write_job_file in a subclass.")
+
+    def find_args(self):
+        return ['job.exe']
+        
+    def parse_job_id(self, output):
+        """Take the output of the submit command and return the job id."""
+        m = re.search(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
+
+    @inlineCallbacks
+    def start(self, n):
+        """Start n copies of the process using the Win HPC job scheduler."""
+        self.write_job_file(n)
+        args = [
+            'submit',
+            '/jobfile:%s' % self.job_file,
+            '/scheduler:%s' % self.scheduler
+        ]
+        log.msg("Starting Win HPC Job: %s" % (self.job_cmd + ' ' + ' '.join(args),))
+        output = yield getProcessOutput(self.job_cmd,
+            args,
+            env=os.environ,
+            path=self.working_dir
+        )
+        job_id = self.parse_job_id(output)
+        self.notify_start(job_id)
+        defer.returnValue(job_id)
+
+    @inlineCallbacks
+    def stop(self):
+        args = [
+            'cancel',
+            self.job_id,
+            '/scheduler:%s' % self.scheduler
+        ]
+        log.msg("Stopping Win HPC Job: %s" % (self.job_cmd + ' ' + ' '.join(args),))
+        try:
+            output = yield getProcessOutput(self.job_cmd,
+                args,
+                env=os.environ,
+                path=self.working_dir
+            )
+        except:
+            output = 'The job already appears to be stoppped: %r' % self.job_id
+        self.notify_stop(output)  # Pass the output of the kill cmd
+        defer.returnValue(output)
+    
 
 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(), config=True)
     # 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
+
+    job_file_name = Unicode(u'ipcontroller_job.xml', config=True)
+    extra_args = List([],config=False)
+
+    def write_job_file(self, n):
+        job = WinHPCJob(self)
+        job.job_name = "IPController"
+        job.username = self.username
+        job.priority = self.priority
+        job.requested_nodes = self.requested_nodes
+        job.project = self.project
+
+        t = IPControllerTask(self)
+        t.work_directory = self.working_dir
+        # Add the --profile and --cluster-dir args from start.
+        t.controller_args.extend(self.extra_args)
+        job.add_task(t)
+        log.msg("Writing job description file: %s" % self.job_file)
+        job.write(self.job_file)
+
+    def start(self, profile=None, cluster_dir=None):
+        """Start the controller by profile or cluster_dir."""
+        if cluster_dir is not None:
+            self.extra_args = ['--cluster-dir', cluster_dir]
+        if profile is not None:
+            self.extra_args = ['--profile', profile]
+        return super(WindowsHPCControllerLauncher, self).start(1)
 
 
 class MPIExecControllerLauncher(MPIExecLauncher):
     """Launch a controller using mpiexec."""
 
     controller_cmd = List(find_controller_cmd(), config=True)
     # 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(), config=True)
     # 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=True)
     # 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(), config=True)
     # 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()
 

IPython/kernel/winhpcjob.py

@@ -1,229 +1,277 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Job and task components for writing .xml files that the Windows HPC Server 
 2008 can use to start jobs.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import with_statement
 
 import os
 import re
+import uuid
 
 from xml.etree import ElementTree as ET
 from xml.dom import minidom
 
 from IPython.core.component import Component
 from IPython.external import Itpl
 from IPython.utils.traitlets import (
     Str, Int, List, Unicode, Instance,
-    Enum, Bool
+    Enum, Bool, CStr
 )
 
 #-----------------------------------------------------------------------------
 # Job and Task Component
 #-----------------------------------------------------------------------------
 
 
 def as_str(value):
     if isinstance(value, str):
         return value
     elif isinstance(value, bool):
         if value:
             return 'true'
         else:
             return 'false'
     elif isinstance(value, (int, float)):
         return repr(value)
     else:
         return value
 
 
 def indent(elem, level=0):
     i = "\n" + level*"  "
     if len(elem):
         if not elem.text or not elem.text.strip():
             elem.text = i + "  "
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
         for elem in elem:
             indent(elem, level+1)
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
     else:
         if level and (not elem.tail or not elem.tail.strip()):
             elem.tail = i
 
 
 class WinHPCJob(Component):
 
     job_id = Str('')
     job_name = Str('MyJob', config=True)
     min_cores = Int(1, config=True)
     max_cores = Int(1, config=True)
     min_sockets = Int(1, config=True)
     max_sockets = Int(1, config=True)
     min_nodes = Int(1, config=True)
     max_nodes = Int(1, config=True)
     unit_type = Str("Core", config=True)
     auto_calculate_min = Bool(True, config=True)
     auto_calculate_max = Bool(True, config=True)
     run_until_canceled = Bool(False, config=True)
     is_exclusive = Bool(False, config=True)
     username = Str(os.environ.get('USERNAME', ''), config=True)
-    owner = Str('', config=True)
     job_type = Str('Batch', config=True)
     priority = Enum(('Lowest','BelowNormal','Normal','AboveNormal','Highest'),
         default_value='Highest', config=True)
     requested_nodes = Str('', config=True)
     project = Str('IPython', config=True)
     xmlns = Str('http://schemas.microsoft.com/HPCS2008/scheduler/')
     version = Str("2.000")
     tasks = List([])
 
-    def _username_changed(self, name, old, new):
-        self.owner = new
+    @property
+    def owner(self):
+        return self.username
 
     def _write_attr(self, root, attr, key):
         s = as_str(getattr(self, attr, ''))
         if s:
             root.set(key, s)
 
     def as_element(self):
         # We have to add _A_ type things to get the right order than
         # the MSFT XML parser expects.
         root = ET.Element('Job')
         self._write_attr(root, 'version', '_A_Version')
         self._write_attr(root, 'job_name', '_B_Name')
         self._write_attr(root, 'unit_type', '_C_UnitType')
         self._write_attr(root, 'min_cores', '_D_MinCores')
         self._write_attr(root, 'max_cores', '_E_MaxCores')
         self._write_attr(root, 'min_sockets', '_F_MinSockets')
         self._write_attr(root, 'max_sockets', '_G_MaxSockets')
         self._write_attr(root, 'min_nodes', '_H_MinNodes')
         self._write_attr(root, 'max_nodes', '_I_MaxNodes')
         self._write_attr(root, 'run_until_canceled', '_J_RunUntilCanceled')
         self._write_attr(root, 'is_exclusive', '_K_IsExclusive')
         self._write_attr(root, 'username', '_L_UserName')
         self._write_attr(root, 'job_type', '_M_JobType')
         self._write_attr(root, 'priority', '_N_Priority')
         self._write_attr(root, 'requested_nodes', '_O_RequestedNodes')
         self._write_attr(root, 'auto_calculate_max', '_P_AutoCalculateMax')
         self._write_attr(root, 'auto_calculate_min', '_Q_AutoCalculateMin')
         self._write_attr(root, 'project', '_R_Project')
         self._write_attr(root, 'owner', '_S_Owner')
         self._write_attr(root, 'xmlns', '_T_xmlns')
         dependencies = ET.SubElement(root, "Dependencies")
         etasks = ET.SubElement(root, "Tasks")
         for t in self.tasks:
             etasks.append(t.as_element())
         return root
 
     def tostring(self):
         """Return the string representation of the job description XML."""
         root = self.as_element()
         indent(root)
         txt = ET.tostring(root, encoding="utf-8")
         # Now remove the tokens used to order the attributes.
         txt = re.sub(r'_[A-Z]_','',txt)
         txt = '<?xml version="1.0" encoding="utf-8"?>\n' + txt
         return txt
 
     def write(self, filename):
         """Write the XML job description to a file."""
         txt = self.tostring()
         with open(filename, 'w') as f:
             f.write(txt)
 
     def add_task(self, task):
         """Add a task to the job.
 
         Parameters
         ----------
         task : :class:`WinHPCTask`
             The task object to add.
         """
         self.tasks.append(task)
 
 
 class WinHPCTask(Component):
 
     task_id = Str('')
     task_name = Str('')
     version = Str("2.000")
     min_cores = Int(1, config=True)
     max_cores = Int(1, config=True)
     min_sockets = Int(1, config=True)
     max_sockets = Int(1, config=True)
     min_nodes = Int(1, config=True)
     max_nodes = Int(1, config=True)
     unit_type = Str("Core", config=True)
-    command_line = Str('', config=True)
-    work_directory = Str('', config=True)
+    command_line = CStr('', config=True)
+    work_directory = CStr('', config=True)
     is_rerunnaable = Bool(True, config=True)
-    std_out_file_path = Str('', config=True)
-    std_err_file_path = Str('', config=True)
+    std_out_file_path = CStr('', config=True)
+    std_err_file_path = CStr('', config=True)
     is_parametric = Bool(False, config=True)
-    environment_variables = Instance(dict, args=())
+    environment_variables = Instance(dict, args=(), config=True)
 
     def _write_attr(self, root, attr, key):
         s = as_str(getattr(self, attr, ''))
         if s:
             root.set(key, s)
 
     def as_element(self):
         root = ET.Element('Task')
         self._write_attr(root, 'version', '_A_Version')
         self._write_attr(root, 'task_name', '_B_Name')
         self._write_attr(root, 'min_cores', '_C_MinCores')
         self._write_attr(root, 'max_cores', '_D_MaxCores')
         self._write_attr(root, 'min_sockets', '_E_MinSockets')
         self._write_attr(root, 'max_sockets', '_F_MaxSockets')
         self._write_attr(root, 'min_nodes', '_G_MinNodes')
         self._write_attr(root, 'max_nodes', '_H_MaxNodes')
         self._write_attr(root, 'command_line', '_I_CommandLine')
         self._write_attr(root, 'work_directory', '_J_WorkDirectory')
         self._write_attr(root, 'is_rerunnaable', '_K_IsRerunnable')
         self._write_attr(root, 'std_out_file_path', '_L_StdOutFilePath')
         self._write_attr(root, 'std_err_file_path', '_M_StdErrFilePath')
         self._write_attr(root, 'is_parametric', '_N_IsParametric')
         self._write_attr(root, 'unit_type', '_O_UnitType')
         root.append(self.get_env_vars())
         return root
 
     def get_env_vars(self):
         env_vars = ET.Element('EnvironmentVariables')
         for k, v in self.environment_variables.items():
             variable = ET.SubElement(env_vars, "Variable")
             name = ET.SubElement(variable, "Name")
             name.text = k
             value = ET.SubElement(variable, "Value")
             value.text = v
         return env_vars
 
 
+
+# By declaring these, we can configure the controller and engine separately!
+        
+class IPControllerTask(WinHPCTask):
+
+    task_name = Str('IPController', config=True)
+    controller_cmd = List(['ipcontroller.exe'], config=True)
+    controller_args = List(['--log-to-file', '--log-level', '40'], config=True)
+    # I don't want these to be configurable
+    std_out_file_path = CStr(os.path.join('log','ipcontroller-out.txt'), config=False)
+    std_err_file_path = CStr(os.path.join('log','ipcontroller-err.txt'), config=False)
+    min_cores = Int(1, config=False)
+    max_cores = Int(1, config=False)
+    min_sockets = Int(1, config=False)
+    max_sockets = Int(1, config=False)
+    min_nodes = Int(1, config=False)
+    max_nodes = Int(1, config=False)
+    unit_type = Str("Core", config=False)
+    work_directory = CStr('', config=False)
+
+    @property
+    def command_line(self):
+        return ' '.join(self.controller_cmd + self.controller_args)
+
+
+class IPEngineTask(WinHPCTask):
+
+    task_name = Str('IPEngine', config=True)
+    engine_cmd = List(['ipengine.exe'], config=True)
+    engine_args = List(['--log-to-file', '--log-level', '40'], config=True)
+    # I don't want these to be configurable
+    std_out_file_path = CStr(os.path.join('log','ipengine-out-%s.txt' % uuid.uuid1()), config=False)
+    std_err_file_path = CStr(os.path.join('log','ipengine-err-%s.txt' % uuid.uuid1()), config=False)
+    min_cores = Int(1, config=False)
+    max_cores = Int(1, config=False)
+    min_sockets = Int(1, config=False)
+    max_sockets = Int(1, config=False)
+    min_nodes = Int(1, config=False)
+    max_nodes = Int(1, config=False)
+    unit_type = Str("Core", config=False)
+    work_directory = CStr('', config=False)
+
+    @property
+    def command_line(self):
+        return ' '.join(self.engine_cmd + self.engine_args)
+
+
 # j = WinHPCJob(None)
 # j.job_name = 'IPCluster'
 # j.username = 'GNET\\bgranger'
 # j.requested_nodes = 'GREEN'
 # 
 # t = WinHPCTask(None)
 # t.task_name = 'Controller'
 # t.command_line = r"\\blue\domainusers$\bgranger\Python\Python25\Scripts\ipcontroller.exe --log-to-file -p default --log-level 10"
 # t.work_directory = r"\\blue\domainusers$\bgranger\.ipython\cluster_default"
 # t.std_out_file_path = 'controller-out.txt'
 # t.std_err_file_path = 'controller-err.txt'
 # t.environment_variables['PYTHONPATH'] = r"\\blue\domainusers$\bgranger\Python\Python25\Lib\site-packages"
 # j.add_task(t)