Find CmdException in common

[stgit] / stgit / run.py

diff --git a/stgit/run.py b/stgit/run.py
index 1bc47595b1f9dabb3bffbbf498b27cc839068e9a..0b79729d2a5c84657fb17bd02c722ff6c699dfd2 100644 (file)
--- a/stgit/run.py
+++ b/stgit/run.py
@@ -17,61 +17,101 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 

-# popen2 and os.spawn* suck. We should really use subprocess instead,
-# but that's only available in Python 2.4 and up, and we try our best
-# to stay Python 2.3 compatible.
-import popen2, os
+import datetime, os, subprocess

 
 

-class RunException(Exception):
+from stgit.exception import *
+from stgit.out import *
+
+class RunException(StgException):

     """Thrown when something bad happened when we tried to run the
     subprocess."""
     pass
 
     """Thrown when something bad happened when we tried to run the
     subprocess."""
     pass
 

+_all_log_modes = ['debug', 'profile']
+_log_mode = os.environ.get('STGIT_SUBPROCESS_LOG', '')
+if _log_mode and not _log_mode in _all_log_modes:
+    out.warn(('Unknown log mode "%s" specified in $STGIT_SUBPROCESS_LOG.'
+              % _log_mode),
+             'Valid values are: %s' % ', '.join(_all_log_modes))
+

 class Run:
     exc = RunException
     def __init__(self, *cmd):
         self.__cmd = list(cmd)
         for c in cmd:
             if type(c) != str:
 class Run:
     exc = RunException
     def __init__(self, *cmd):
         self.__cmd = list(cmd)
         for c in cmd:
             if type(c) != str:

-                raise Exception, 'Bad command: %r' % cmd
+                raise Exception, 'Bad command: %r' % (cmd,)

         self.__good_retvals = [0]
         self.__good_retvals = [0]

-        self.__env = None
+        self.__env = self.__cwd = None

         self.__indata = None
         self.__indata = None

-    def __run_io(self, cmd):
-        """Run with captured IO. Note: arguments are parsed by the
-        shell. We single-quote them, so don't use anything with single
-        quotes in it."""
-        if self.__env == None:
-            ecmd = cmd
-        else:
-            ecmd = (['env'] + ['%s=%s' % (key, val)
-                               for key, val in self.__env.iteritems()]
-                    + cmd)
-        p = popen2.Popen3(' '.join(["'%s'" % c for c in ecmd]), True)
-        if self.__indata != None:
-            p.tochild.write(self.__indata)
-        p.tochild.close()
-        outdata = p.fromchild.read()
-        errdata = p.childerr.read()
-        self.exitcode = p.wait() >> 8
-        if errdata or self.exitcode not in self.__good_retvals:
-            raise self.exc('%s failed with code %d:\n%s'
-                           % (cmd[0], self.exitcode, errdata))
+        self.__discard_stderr = False
+    def __log_start(self):
+        if _log_mode == 'debug':
+            out.start('Running subprocess %s' % self.__cmd)
+            if self.__cwd != None:
+                out.info('cwd: %s' % self.__cwd)
+            if self.__env != None:
+                for k in sorted(self.__env.iterkeys()):
+                    if k not in os.environ or os.environ[k] != self.__env[k]:
+                        out.info('%s: %s' % (k, self.__env[k]))
+        elif _log_mode == 'profile':
+            out.start('Running subprocess %s' % self.__cmd[0])
+            self.__starttime = datetime.datetime.now()
+    def __log_end(self, retcode):
+        if _log_mode == 'debug':
+            out.done('return code: %d' % retcode)
+        elif _log_mode == 'profile':
+            duration = datetime.datetime.now() - self.__starttime
+            out.done('%1.3f s' % (duration.microseconds/1e6 + duration.seconds))
+    def __check_exitcode(self):
+        if self.__good_retvals == None:
+            return
+        if self.exitcode not in self.__good_retvals:
+            raise self.exc('%s failed with code %d'
+                           % (self.__cmd[0], self.exitcode))
+    def __run_io(self):
+        """Run with captured IO."""
+        self.__log_start()
+        try:
+            p = subprocess.Popen(self.__cmd, env = self.__env, cwd = self.__cwd,
+                                 stdin = subprocess.PIPE,
+                                 stdout = subprocess.PIPE,
+                                 stderr = subprocess.PIPE)
+            outdata, errdata = p.communicate(self.__indata)
+            self.exitcode = p.returncode
+        except OSError, e:
+            raise self.exc('%s failed: %s' % (self.__cmd[0], e))
+        if errdata and not self.__discard_stderr:
+            out.err_raw(errdata)
+        self.__log_end(self.exitcode)
+        self.__check_exitcode()

         return outdata
         return outdata

-    def __run_noshell(self, cmd):
-        """Run without captured IO. Note: arguments are not parsed by
-        the shell."""
-        assert self.__env == None
+    def __run_noio(self):
+        """Run without captured IO."""

         assert self.__indata == None
         assert self.__indata == None

-        self.exitcode = os.spawnvp(os.P_WAIT, cmd[0], cmd)
-        if not self.exitcode in self.__good_retvals:
-            raise self.exc('%s failed with code %d'
-                           % (cmd[0], self.exitcode))
+        self.__log_start()
+        try:
+            p = subprocess.Popen(self.__cmd, env = self.__env, cwd = self.__cwd)
+            self.exitcode = p.wait()
+        except OSError, e:
+            raise self.exc('%s failed: %s' % (self.__cmd[0], e))
+        self.__log_end(self.exitcode)
+        self.__check_exitcode()

     def returns(self, retvals):
         self.__good_retvals = retvals
         return self
     def returns(self, retvals):
         self.__good_retvals = retvals
         return self

+    def discard_exitcode(self):
+        self.__good_retvals = None
+        return self
+    def discard_stderr(self, discard = True):
+        self.__discard_stderr = discard
+        return self

     def env(self, env):
     def env(self, env):

-        self.__env = env
+        self.__env = dict(os.environ)
+        self.__env.update(env)
+        return self
+    def cwd(self, cwd):
+        self.__cwd = cwd

         return self
     def raw_input(self, indata):
         self.__indata = indata
         return self
     def raw_input(self, indata):
         self.__indata = indata


@@ -79,16 +119,19 @@ class Run:
     def input_lines(self, lines):
         self.__indata = ''.join(['%s\n' % line for line in lines])
         return self
     def input_lines(self, lines):
         self.__indata = ''.join(['%s\n' % line for line in lines])
         return self

+    def input_nulterm(self, lines):
+        self.__indata = ''.join('%s\0' % line for line in lines)
+        return self

     def no_output(self):
     def no_output(self):

-        outdata = self.__run_io(self.__cmd)
+        outdata = self.__run_io()

         if outdata:
             raise self.exc, '%s produced output' % self.__cmd[0]
     def discard_output(self):
         if outdata:
             raise self.exc, '%s produced output' % self.__cmd[0]
     def discard_output(self):

-        self.__run_io(self.__cmd)
+        self.__run_io()

     def raw_output(self):
     def raw_output(self):

-        return self.__run_io(self.__cmd)
+        return self.__run_io()

     def output_lines(self):
     def output_lines(self):

-        outdata = self.__run_io(self.__cmd)
+        outdata = self.__run_io()

         if outdata.endswith('\n'):
             outdata = outdata[:-1]
         if outdata:
         if outdata.endswith('\n'):
             outdata = outdata[:-1]
         if outdata:


@@ -104,11 +147,14 @@ class Run:
                            % (self.__cmd[0], len(outlines)))
     def run(self):
         """Just run, with no IO redirection."""
                            % (self.__cmd[0], len(outlines)))
     def run(self):
         """Just run, with no IO redirection."""

-        self.__run_noshell(self.__cmd)
+        self.__run_noio()

     def xargs(self, xargs):
         """Just run, with no IO redirection. The extra arguments are
         appended to the command line a few at a time; the command is
         run as many times as needed to consume them all."""
         step = 100
     def xargs(self, xargs):
         """Just run, with no IO redirection. The extra arguments are
         appended to the command line a few at a time; the command is
         run as many times as needed to consume them all."""
         step = 100

+        basecmd = self.__cmd

         for i in xrange(0, len(xargs), step):
         for i in xrange(0, len(xargs), step):

-            self.__run_noshell(self.__cmd + xargs[i:i+step])
+            self.__cmd = basecmd + xargs[i:i+step]
+            self.__run_noio()
+        self.__cmd = basecmd