Add subprocess.Popen().kill() to python 2.5.

tests/fake_repos.py

 #!/usr/bin/env python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generate fake repositories for testing."""
 
 import atexit
 import datetime
 import errno
 import logging
 import os
 import pprint
 import re
 import socket
-import subprocess
 import sys
 import tempfile
 import time
 
 # trial_dir must be first for non-system libraries.
 from tests import trial_dir
 import gclient_utils
 import scm
-
-## Utility functions
-
-
-def kill_pid(pid):
-  """Kills a process by its process id."""
-  try:
-    # Unable to import 'module'
-    # pylint: disable=F0401
-    import signal
-    return os.kill(pid, signal.SIGKILL)
-  except ImportError:
-    pass
-
-
-def kill_win(process):
-  """Kills a process with its windows handle.
-
-  Has no effect on other platforms.
-  """
-  try:
-    # Unable to import 'module'
-    # pylint: disable=F0401
-    import win32process
-    # Access to a protected member _handle of a client class
-    # pylint: disable=W0212
-    return win32process.TerminateProcess(process._handle, -1)
-  except ImportError:
-    pass
-
-
-def add_kill():
-  """Adds kill() method to subprocess.Popen for python <2.6"""
-  if hasattr(subprocess.Popen, 'kill'):
-    return
-
-  if sys.platform == 'win32':
-    subprocess.Popen.kill = kill_win
-  else:
-    def kill_nix(process):
-      return kill_pid(process.pid)
-    subprocess.Popen.kill = kill_nix
+import subprocess2
 
 
 def write(path, content):
   f = open(path, 'wb')
   f.write(content)
   f.close()
 
 
 join = os.path.join
 
 
-def check_call(*args, **kwargs):
-  logging.debug(args[0])
-  subprocess.check_call(*args, **kwargs)
-
-
-def Popen(*args, **kwargs):
-  kwargs.setdefault('stdout', subprocess.PIPE)
-  kwargs.setdefault('stderr', subprocess.STDOUT)
-  logging.debug(args[0])
-  return subprocess.Popen(*args, **kwargs)
-
-
 def read_tree(tree_root):
   """Returns a dict of all the files in a tree. Defaults to self.root_dir."""
   tree = {}
   for root, dirs, files in os.walk(tree_root):
     for d in filter(lambda x: x.startswith('.'), dirs):
       dirs.remove(d)
     for f in [join(root, f) for f in files if not f.startswith('.')]:
       filepath = f[len(tree_root) + 1:].replace(os.sep, '/')
       assert len(filepath), f
       tree[filepath] = open(join(root, f), 'rU').read()
@@ skipping 16 matching lines @@
 def commit_svn(repo, usr, pwd):
   """Commits the changes and returns the new revision number."""
   to_add = []
   to_remove = []
   for status, filepath in scm.SVN.CaptureStatus(repo):
     if status[0] == '?':
       to_add.append(filepath)
     elif status[0] == '!':
       to_remove.append(filepath)
   if to_add:
-    check_call(['svn', 'add', '--no-auto-props', '-q'] + to_add, cwd=repo)
+    subprocess2.check_output(
+        ['svn', 'add', '--no-auto-props', '-q'] + to_add, cwd=repo)
   if to_remove:
-    check_call(['svn', 'remove', '-q'] + to_remove, cwd=repo)
-  proc = Popen(
+    subprocess2.check_output(['svn', 'remove', '-q'] + to_remove, cwd=repo)
+
+  out = subprocess2.check_output(
       ['svn', 'commit', repo, '-m', 'foo', '--non-interactive',
         '--no-auth-cache',
         '--username', usr, '--password', pwd],
       cwd=repo)
-  out, err = proc.communicate()
   match = re.search(r'(\d+)', out)
   if not match:
-    raise Exception('Commit failed', out, err, proc.returncode)
+    raise Exception('Commit failed', out)
   rev = match.group(1)
-  st = Popen(['svn', 'status'], cwd=repo).communicate()[0]
-  assert len(st) == 0, st
+  status = subprocess2.check_output(['svn', 'status'], cwd=repo)
+  assert len(status) == 0, status
   logging.debug('At revision %s' % rev)
   return rev
 
 
 def commit_git(repo):
   """Commits the changes and returns the new hash."""
-  check_call(['git', 'add', '-A', '-f'], cwd=repo)
-  check_call(['git', 'commit', '-q', '--message', 'foo'], cwd=repo)
-  rev = Popen(['git', 'show-ref', '--head', 'HEAD'],
-              cwd=repo).communicate()[0].split(' ', 1)[0]
+  subprocess2.check_call(['git', 'add', '-A', '-f'], cwd=repo)
+  subprocess2.check_call(['git', 'commit', '-q', '--message', 'foo'], cwd=repo)
+  rev = subprocess2.check_output(
+      ['git', 'show-ref', '--head', 'HEAD'], cwd=repo).split(' ', 1)[0]
   logging.debug('At revision %s' % rev)
   return rev
 
 
 def test_port(host, port):
   s = socket.socket()
   try:
     return s.connect_ex((host, port)) == 0
   finally:
     s.close()
@@ skipping 103 matching lines @@
 
   @property
   def root_dir(self):
     return self.trial.root_dir
 
   def set_up(self):
     """All late initialization comes here."""
     self.cleanup_dirt()
     if not self.root_dir:
       try:
-        add_kill()
         # self.root_dir is not set before this call.
         self.trial.set_up()
         self.git_root = join(self.root_dir, 'git')
         self.svn_checkout = join(self.root_dir, 'svn_checkout')
         self.svn_repo = join(self.root_dir, 'svn')
       finally:
         # Registers cleanup.
         atexit.register(self.tear_down)
 
   def cleanup_dirt(self):
@@ skipping 36 matching lines @@
 
   def tear_down_git(self):
     if self.gitdaemon:
       logging.debug('Killing git-daemon pid %s' % self.gitdaemon.pid)
       self.gitdaemon.kill()
       self.gitdaemon = None
       if self.git_pid_file:
         pid = int(self.git_pid_file.read())
         self.git_pid_file.close()
         logging.debug('Killing git daemon pid %s' % pid)
-        kill_pid(pid)
+        subprocess2.kill_pid(pid)
         self.git_pid_file = None
       wait_for_port_to_free(self.host, self.git_port)
       self.git_port = None
       self.git_base = None
       if not self.trial.SHOULD_LEAK:
         logging.debug('Removing %s' % self.git_root)
         gclient_utils.rmtree(self.git_root)
       else:
         return False
     return True
@@ skipping 14 matching lines @@
         os.remove(join(root, k))
       else:
         write(join(root, k), v)
 
   def set_up_svn(self):
     """Creates subversion repositories and start the servers."""
     self.set_up()
     if self.svnserve:
       return True
     try:
-      check_call(['svnadmin', 'create', self.svn_repo])
-    except OSError, e:
+      subprocess2.check_call(['svnadmin', 'create', self.svn_repo])
+    except subprocess2.CalledProcessError, e:
       logging.debug('Failed with : %s' % e)
       return False
     write(join(self.svn_repo, 'conf', 'svnserve.conf'),
         '[general]\n'
         'anon-access = read\n'
         'auth-access = write\n'
         'password-db = passwd\n')
     text = '[users]\n'
     text += ''.join('%s = %s\n' % (usr, pwd) for usr, pwd in self.USERS)
     write(join(self.svn_repo, 'conf', 'passwd'), text)
 
     # Mac 10.6 ships with a buggy subversion build and we need this line
     # to work around the bug.
     write(join(self.svn_repo, 'db', 'fsfs.conf'),
         '[rep-sharing]\n'
         'enable-rep-sharing = false\n')
 
     # Start the daemon.
     self.svn_port = find_free_port(self.host, 10000)
     logging.debug('Using port %d' % self.svn_port)
     cmd = ['svnserve', '-d', '--foreground', '-r', self.root_dir,
         '--listen-port=%d' % self.svn_port]
     if self.host == '127.0.0.1':
       cmd.append('--listen-host=' + self.host)
     self.check_port_is_free(self.svn_port)
-    self.svnserve = Popen(cmd, cwd=self.svn_repo)
+    self.svnserve = subprocess2.Popen(
+        cmd,
+        cwd=self.svn_repo,
+        stdout=subprocess2.PIPE,
+        stderr=subprocess2.PIPE)
     wait_for_port_to_bind(self.host, self.svn_port, self.svnserve)
     self.svn_base = 'svn://%s:%d/svn/' % (self.host, self.svn_port)
     self.populateSvn()
     self.svn_dirty = False
     return True
 
   def set_up_git(self):
     """Creates git repositories and start the servers."""
     self.set_up()
     if self.gitdaemon:
       return True
     if sys.platform == 'win32':
       return False
     assert self.git_pid_file == None
     for repo in ['repo_%d' % r for r in range(1, self.NB_GIT_REPOS + 1)]:
-      check_call(['git', 'init', '-q', join(self.git_root, repo)])
+      subprocess2.check_call(['git', 'init', '-q', join(self.git_root, repo)])
       self.git_hashes[repo] = [None]
     self.git_port = find_free_port(self.host, 20000)
     self.git_base = 'git://%s:%d/git/' % (self.host, self.git_port)
     # Start the daemon.
     self.git_pid_file = tempfile.NamedTemporaryFile()
     cmd = ['git', 'daemon',
         '--export-all',
         '--reuseaddr',
         '--base-path=' + self.root_dir,
         '--pid-file=' + self.git_pid_file.name,
         '--port=%d' % self.git_port]
     if self.host == '127.0.0.1':
       cmd.append('--listen=' + self.host)
     self.check_port_is_free(self.git_port)
-    self.gitdaemon = Popen(cmd, cwd=self.root_dir)
+    self.gitdaemon = subprocess2.Popen(
+        cmd,
+        cwd=self.root_dir,
+        stdout=subprocess2.PIPE,
+        stderr=subprocess2.PIPE)
     wait_for_port_to_bind(self.host, self.git_port, self.gitdaemon)
     self.populateGit()
     self.git_dirty = False
     return True
 
   def _commit_svn(self, tree):
     self._genTree(self.svn_checkout, tree)
     commit_svn(self.svn_checkout, self.USERS[0][0], self.USERS[0][1])
     if self.svn_revs and self.svn_revs[-1]:
       new_tree = self.svn_revs[-1].copy()
@@ skipping 31 matching lines @@
     raise NotImplementedError()
 
 
 class FakeRepos(FakeReposBase):
   """Implements populateSvn() and populateGit()."""
   NB_GIT_REPOS = 4
 
   def populateSvn(self):
     """Creates a few revisions of changes including DEPS files."""
     # Repos
-    check_call(['svn', 'checkout', self.svn_base, self.svn_checkout,
-                '-q', '--non-interactive', '--no-auth-cache',
-                '--username', self.USERS[0][0], '--password', self.USERS[0][1]])
+    subprocess2.check_call(
+        ['svn', 'checkout', self.svn_base, self.svn_checkout,
+         '-q', '--non-interactive', '--no-auth-cache',
+         '--username', self.USERS[0][0], '--password', self.USERS[0][1]])
     assert os.path.isdir(join(self.svn_checkout, '.svn'))
     def file_system(rev, DEPS):
       fs = {
         'origin': 'svn@%(rev)d\n',
         'trunk/origin': 'svn/trunk@%(rev)d\n',
         'trunk/src/origin': 'svn/trunk/src@%(rev)d\n',
         'trunk/src/third_party/origin': 'svn/trunk/src/third_party@%(rev)d\n',
         'trunk/other/origin': 'src/trunk/other@%(rev)d\n',
         'trunk/third_party/origin': 'svn/trunk/third_party@%(rev)d\n',
         'trunk/third_party/foo/origin': 'svn/trunk/third_party/foo@%(rev)d\n',
@@ skipping 288 matching lines @@
     fake.set_up_git()
     print('Fake setup, press enter to quit or Ctrl-C to keep the checkouts.')
     sys.stdin.readline()
   except KeyboardInterrupt:
     trial_dir.TrialDir.SHOULD_LEAK.leak = True
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))