Add automatic retry on HTTP 502 for svn and connection drop for git.

gclient_scm.py

 # Copyright (c) 2009 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 161 matching lines @@
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if revision:
       rev_str = ' at %s' % revision
 
     if options.verbose:
       print("\n_____ %s%s" % (self.relpath, rev_str))
 
     if not os.path.exists(self.checkout_path):
-      self._Run(['clone', url, self.checkout_path],
-                cwd=self._root_dir, redirect_stdout=False)
+      # Cloning
+      for i in range(3):
+        try:
+          self._Run(['clone', url, self.checkout_path],
+                    cwd=self._root_dir, redirect_stdout=False)
+          break
+        except gclient_utils.Error, e:
+          # TODO(maruel): Hackish, should be fixed by moving _Run() to
+          # CheckCall().
+          # Too bad we don't have access to the actual output.
+          # We should check for "transfer closed with NNN bytes remaining to
+          # read". In the meantime, just make sure .git exists.
+          if (e.args[0] == 'git command clone returned 128' and
+              os.path.exists(os.path.join(self.checkout_path, '.git'))):
+            print str(e)
+            print "Retrying..."
+            continue
+          raise e
+
       if revision:
         self._Run(['reset', '--hard', revision], redirect_stdout=False)
       files = self._Run(['ls-files']).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       return
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
     new_base = 'origin'
     if revision:
       new_base = revision
     cur_branch = self._GetCurrentBranch()
 
     # Check if we are in a rebase conflict
     if cur_branch is None:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tAlready in a conflict, i.e. (no branch).\n'
                                 '\tFix the conflict and run gclient again.\n'
                                 '\tOr to abort run:\n\t\tgit-rebase --abort\n'
                                 '\tSee man git-rebase for details.\n'
                                  % (self.relpath, rev_str))
 
+    # TODO(maruel): Do we need to do an automatic retry here? Probably overkill
     merge_base = self._Run(['merge-base', 'HEAD', new_base])
     self._Run(['remote', 'update'], redirect_stdout=False)
     files = self._Run(['diff', new_base, '--name-only']).split()
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
     if options.force:
       self._Run(['reset', '--hard', merge_base], redirect_stdout=False)
-    self._Run(['rebase', '-v', '--onto', new_base, merge_base, cur_branch],
-                redirect_stdout=False, checkrc=False)
+    try:
+      self._Run(['rebase', '-v', '--onto', new_base, merge_base, cur_branch],
+                  redirect_stdout=False)
+    except gclient_utils.Error:
+      pass
 
     # If the rebase generated a conflict, abort and ask user to fix
     if self._GetCurrentBranch() is None:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\nConflict while rebasing this branch.\n'
                                 'Fix the conflict and run gclient again.\n'
                                 'See man git-rebase for details.\n'
                                 % (self.relpath, rev_str))
 
     print "Checked out revision %s." % self.revinfo(options, (), None)
@@ skipping 61 matching lines @@
 
   def _GetCurrentBranch(self):
     # Returns name of current branch
     # Returns None if inside a (no branch)
     tokens = self._Run(['branch']).split()
     branch = tokens[tokens.index('*') + 1]
     if branch == '(no':
       return None
     return branch
 
-  def _Run(self, args, cwd=None, checkrc=True, redirect_stdout=True):
-    # TODO(maruel): Merge with Capture?
+  def _Run(self, args, cwd=None, redirect_stdout=True):
+    # TODO(maruel): Merge with Capture or better gclient_utils.CheckCall().
     if cwd is None:
         cwd = self.checkout_path
-    stdout=None
+    stdout = None
     if redirect_stdout:
-      stdout=subprocess.PIPE
+      stdout = subprocess.PIPE
     if cwd == None:
       cwd = self.checkout_path
     cmd = [self.COMMAND]
     cmd.extend(args)
     logging.debug(cmd)
     try:
       sp = subprocess.Popen(cmd, cwd=cwd, stdout=stdout)
       output = sp.communicate()[0]
     except OSError:
       raise gclient_utils.Error("git command '%s' failed to run." %
               ' '.join(cmd) + "\nCheck that you have git installed.")
-    if checkrc and sp.returncode:
+    if sp.returncode:
       raise gclient_utils.Error('git command %s returned %d' %
                                 (args[0], sp.returncode))
     if output is not None:
       return output.strip()
 
 
 class SVNWrapper(SCMWrapper, scm.SVN):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
@@ skipping 219 matching lines @@
       print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
             "does not exist."
             % (' '.join(command), path))
       # There's no file list to retrieve.
     else:
       self.RunAndGetFileList(options, command, path, file_list)
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url