Teach bot_update to remove partially deleted git repos.

recipe_modules/bot_update/resources/bot_update.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 # TODO(hinoka): Use logging.
 
 import cStringIO
 import codecs
-import collections
 import copy
 import ctypes
 import json
 import optparse
 import os
 import pprint
 import random
 import re
-import socket
 import subprocess
 import sys
 import tempfile
 import threading
 import time
 import urllib2
 import urlparse
 import uuid
 
 import os.path as path
@@ skipping 262 matching lines @@
       del solution['safesync_url']
 
   return solutions
 
 
 def remove(target):
   """Remove a target by moving it into build.dead."""
   dead_folder = path.join(BUILDER_DIR, 'build.dead')
   if not path.exists(dead_folder):
     os.makedirs(dead_folder)
-  os.rename(target, path.join(dead_folder, uuid.uuid4().hex))
+  dest = path.join(dead_folder, uuid.uuid4().hex)
+  print 'Marking for removal %s => %s' % (target, dest)
+  os.rename(target, dest)
 
 
 def ensure_no_checkout(dir_names):
   """Ensure that there is no undesired checkout under build/."""
   build_dir = os.getcwd()
   has_checkout = any(path.exists(path.join(build_dir, dir_name, '.git'))
                      for dir_name in dir_names)
   if has_checkout:
     for filename in os.listdir(build_dir):
       deletion_target = path.join(build_dir, filename)
@@ skipping 138 matching lines @@
     # Support for "branch:revision" syntax.
     branch, revision = split_revision
 
   if revision and revision.upper() != 'HEAD':
     git('checkout', '--force', revision, cwd=folder_name)
   else:
     ref = branch if branch.startswith('refs/') else 'origin/%s' % branch
     git('checkout', '--force', ref, cwd=folder_name)
 
 
+def is_broken_repo_dir(repo_dir):
+  # Treat absence of 'config' as a signal of a partially deleted repo.
+  return not path.exists(os.path.join(repo_dir, '.git', 'config'))
+
+
 def git_checkout(solutions, revisions, shallow, refs, git_cache_dir):
   build_dir = os.getcwd()
   # Before we do anything, break all git_cache locks.
   if path.isdir(git_cache_dir):
     git('cache', 'unlock', '-vv', '--force', '--all',
         '--cache-dir', git_cache_dir)
     for item in os.listdir(git_cache_dir):
       filename = os.path.join(git_cache_dir, item)
       if item.endswith('.lock'):
         raise Exception('%s exists after cache unlock' % filename)
@@ skipping 18 matching lines @@
       for ref in refs:
         populate_cmd.extend(['--ref', ref])
       git(*populate_cmd)
       mirror_dir = git(
           'cache', 'exists', '--quiet',
           '--cache-dir', git_cache_dir, url).strip()
       clone_cmd = (
           'clone', '--no-checkout', '--local', '--shared', mirror_dir, sln_dir)
 
       try:
+        # If repo deletion was aborted midway, it may have left .git in broken
+        # state.
+        if path.exists(sln_dir) and is_broken_repo_dir(sln_dir):
+          print 'Git repo %s appears to be broken, removing it' % sln_dir
+          remove(sln_dir)
+
         if not path.isdir(sln_dir):
           git(*clone_cmd)
         else:
           git('remote', 'set-url', 'origin', mirror_dir, cwd=sln_dir)
           git('fetch', 'origin', cwd=sln_dir)
         for ref in refs:
           refspec = '%s:%s' % (ref, ref.lstrip('+'))
           git('fetch', 'origin', refspec, cwd=sln_dir)
 
         revision = get_target_revision(name, url, revisions) or 'HEAD'
@@ skipping 528 matching lines @@
 def main():
   # Get inputs.
   options, _ = parse_args()
 
   # Check if this script should activate or not.
   active = True
 
   # Print a helpful message to tell developers whats going on with this step.
   print_debug_info()
 
-  # Parse, munipulate, and print the gclient solutions.
+  # Parse, manipulate, and print the gclient solutions.
   specs = {}
   exec(options.specs, specs)
   orig_solutions = specs.get('solutions', [])
   git_slns = modify_solutions(orig_solutions)
 
   solutions_printer(git_slns)
 
   try:
     # Dun dun dun, the main part of bot_update.
     revisions, step_text, shallow = prepare(options, git_slns, active)
     checkout(options, git_slns, specs, revisions, step_text, shallow)
 
   except PatchFailed as e:
     # Return a specific non-zero exit code for patch failure (because it is
     # a failure), but make it different than other failures to distinguish
     # between infra failures (independent from patch author), and patch
     # failures (that patch author can fix). However, PatchFailure due to
     # download patch failure is still an infra problem.
     if e.code == 3:
       # Patch download problem.
       return 87
     # Genuine patch problem.
     return 88
 
 
 if __name__ == '__main__':
   sys.exit(main())