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
 
 
+# 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)
+        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 75 matching lines @@
     """Reverts local modifications or checks out if the directory is not
     present. Use depot_tools's functionality to do this.
     """
     flags = ['--ignore-externals']
     if revision:
       flags.extend(['--revision', str(revision)])
     if not os.path.isdir(self.project_path):
       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)

[Peter Mayo, 2012/11/08 19:04:59]

I would think checkout and update may be different enough in practice to warrant
separate timeouts.  But if 30 minutes is enough for either, the point is moot.

[M-A Ruel, 2012/11/08 19:07:57]

I think it's fine. I'll change otherwise but I'm confident it's well enough.

     else:
+      # TODO(maruel): This command will shell out without a timeout.
       scm.SVN.Revert(self.project_path, no_ignore=True)
       # 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)
     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 29 matching lines @@
 
     Checks it out if not present and deletes the working branch.
     """
     assert self.remote_branch
     assert os.path.isdir(self.project_path)
     self._check_call_git(['reset', '--hard', '--quiet'])
     if revision:
       try:
         revision = self._check_output_git(['rev-parse', revision])
       except subprocess.CalledProcessError:
-        self._check_call_git(
-            ['fetch', self.remote, self.remote_branch, '--quiet'])
+        self._fetch_remote()
         revision = self._check_output_git(['rev-parse', revision])
       self._check_call_git(['checkout', '--force', '--quiet', revision])
     else:
       branches, active = self._branches()
       if active != 'master':
         self._check_call_git(['checkout', '--force', '--quiet', 'master'])
       self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
       if self.working_branch in branches:
         self._call_git(['branch', '-D', self.working_branch])
 
@@ skipping 90 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)
-    return subprocess2.check_call_out(['git'] + args, **kwargs)
+    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)
-    return subprocess2.call(['git'] + args, **kwargs)
+    return subprocess2.call(['git'] + args, timeout=GLOBAL_TIMEOUT, **kwargs)
 
   def _check_output_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_output(
-        ['git'] + args, stderr=subprocess2.STDOUT, **kwargs)
+        ['git'] + args,
+        stderr=subprocess2.STDOUT,
+        timeout=GLOBAL_TIMEOUT,
+        **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('*'):
         active = l[2:]
         break
@@ skipping 14 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_call_git(
+        ['fetch', self.remote, self.remote_branch, '--quiet'],

[Peter Mayo, 2012/11/08 19:04:59]

Add quiet to CL description.

+        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