Enforce 15 minutes timeout for all operations and 30 minutes for checkouts.

checkout.py

 # coding=utf8
 # Copyright (c) 2012 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 import ConfigParser
 import fnmatch
 import logging
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 
 import patch
 import scm
 import subprocess2
 
 
+if sys.platform in ('cygwin', 'win32'):
+  # Disable timeouts on Windows since we can't have shells with timeouts.
+  GLOBAL_TIMEOUT = None
+  FETCH_TIMEOUT = None
+else:
+  # Default timeout of 15 minutes.
+  GLOBAL_TIMEOUT = 15*60
+  # Use a larger timeout for checkout since it can be a genuinely slower
+  # operation.
+  FETCH_TIMEOUT = 30*60
+
+
 def get_code_review_setting(path, key,
     codereview_settings_file='codereview.settings'):
   """Parses codereview.settings and return the value for the key if present.
 
   Don't cache the values in case the file is changed."""
   # TODO(maruel): Do not duplicate code.
   settings = {}
   try:
     settings_file = open(os.path.join(path, codereview_settings_file), 'r')
     try:
@@ skipping 155 matching lines @@
               stdout.append('Copied %s -> %s' % (p.source_filename, p.filename))
             if p.diff_hunks:
               cmd = ['patch', '-u', '--binary', '-p%s' % p.patchlevel]
               if verbose:
                 cmd.append('--verbose')
               stdout.append(
                   subprocess2.check_output(
                       cmd,
                       stdin=p.get(False),
                       stderr=subprocess2.STDOUT,
-                      cwd=self.project_path))
+                      cwd=self.project_path,
+                      timeout=GLOBAL_TIMEOUT))
             elif p.is_new and not os.path.exists(filepath):
               # There is only a header. Just create the file.
               open(filepath, 'w').close()
               stdout.append('Created an empty file.')
         for post in post_processors:
           post(self, p)
         if verbose:
           print p.filename
           print align_stdout(stdout)
       except OSError, e:
@@ skipping 58 matching lines @@
       if self.commit_user:
         args.extend(['--username', self.commit_user])
       if self.commit_pwd:
         args.extend(['--password', self.commit_pwd])
     return args
 
   def _check_call_svn(self, args, **kwargs):
     """Runs svn and throws an exception if the command failed."""
     kwargs.setdefault('cwd', self.project_path)
     kwargs.setdefault('stdout', self.VOID)
+    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
     return subprocess2.check_call_out(
         self._add_svn_flags(args, False), **kwargs)
 
   def _check_output_svn(self, args, credentials=True, **kwargs):
     """Runs svn and throws an exception if the command failed.
 
      Returns the output.
     """
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_output(
         self._add_svn_flags(args, True, credentials),
         stderr=subprocess2.STDOUT,
+        timeout=GLOBAL_TIMEOUT,
         **kwargs)
 
   @staticmethod
   def _parse_svn_info(output, key):
     """Returns value for key from svn info output.
 
     Case insensitive.
     """
     values = {}
     key = key.lower()
@@ skipping 79 matching lines @@
             if p.diff_hunks:
               cmd = [
                 'patch',
                 '-p%s' % p.patchlevel,
                 '--forward',
                 '--force',
                 '--no-backup-if-mismatch',
               ]
               stdout.append(
                   subprocess2.check_output(
-                    cmd, stdin=p.get(False), cwd=self.project_path))
+                    cmd,
+                    stdin=p.get(False),
+                    cwd=self.project_path,
+                    timeout=GLOBAL_TIMEOUT))
             elif p.is_new and not os.path.exists(filepath):
               # There is only a header. Just create the file if it doesn't
               # exist.
               open(filepath, 'w').close()
               stdout.append('Created an empty file.')
           if p.is_new and not p.source_filename:
             # Do not run it if p.source_filename is defined, since svn copy was
             # using above.
             stdout.append(
                 self._check_output_svn(
@@ skipping 77 matching lines @@
     """
     flags = ['--ignore-externals']
     if revision:
       flags.extend(['--revision', str(revision)])
     if os.path.isdir(self.project_path):
       # This may remove any part (or all) of the checkout.
       scm.SVN.Revert(self.project_path, no_ignore=True)
 
     if os.path.isdir(self.project_path):
       # Revive files that were deleted in scm.SVN.Revert().
-      self._check_call_svn(['update', '--force'] + flags)
+      self._check_call_svn(['update', '--force'] + flags,
+                           timeout=FETCH_TIMEOUT)
     else:
       logging.info(
           'Directory %s is not present, checking it out.' % self.project_path)
       self._check_call_svn(
-          ['checkout', self.svn_url, self.project_path] + flags, cwd=None)
+          ['checkout', self.svn_url, self.project_path] + flags, cwd=None,
+          timeout=FETCH_TIMEOUT)
     return self._get_revision()
 
   def _get_revision(self):
     out = self._check_output_svn(['info', '.'])
     revision = int(self._parse_svn_info(out, 'revision'))
     if revision != self._last_seen_revision:
       logging.info('Updated to revision %d' % revision)
       self._last_seen_revision = revision
     return revision
 
@@ skipping 141 matching lines @@
 
     Subclass needs to dcommit or push.
     """
     assert isinstance(commit_message, unicode)
     self._check_call_git(['commit', '--amend', '-m', commit_message])
     return self._check_output_git(['rev-parse', 'HEAD']).strip()
 
   def _check_call_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     kwargs.setdefault('stdout', self.VOID)
+    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
     return subprocess2.check_call_out(['git'] + args, **kwargs)
 
   def _call_git(self, args, **kwargs):
     """Like check_call but doesn't throw on failure."""
     kwargs.setdefault('cwd', self.project_path)
     kwargs.setdefault('stdout', self.VOID)
+    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
     return subprocess2.call(['git'] + args, **kwargs)
 
   def _check_output_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
+    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
     return subprocess2.check_output(
         ['git'] + args, stderr=subprocess2.STDOUT, **kwargs)
 
   def _branches(self):
     """Returns the list of branches and the active one."""
     out = self._check_output_git(['branch']).splitlines(False)
     branches = [l[2:] for l in out]
     active = None
     for l in out:
       if l.startswith('*'):
@@ skipping 16 matching lines @@
 
   def _fetch_remote(self):
     """Fetches the remote without rebasing."""
     raise NotImplementedError()
 
 
 class GitCheckout(GitCheckoutBase):
   """Git checkout implementation."""
   def _fetch_remote(self):
     # git fetch is always verbose even with -q -q so redirect its output.
-    self._check_output_git(['fetch', self.remote, self.remote_branch])
+    self._check_output_git(['fetch', self.remote, self.remote_branch],
+                           timeout=FETCH_TIMEOUT)
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout, post_processors=None):
     super(ReadOnlyCheckout, self).__init__()
     self.checkout = checkout
     self.post_processors = (post_processors or []) + (
         self.checkout.post_processors or [])
 
@@ skipping 15 matching lines @@
   def revisions(self, rev1, rev2):
     return self.checkout.revisions(rev1, rev2)
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path