Allow to skip revision check in roll-dep.

roll_dep.py

 #!/usr/bin/env python
 # Copyright (c) 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.
 
 """This scripts takes the path to a dep and an svn revision, and updates the
 parent repo's DEPS file with the corresponding git revision.  Sample invocation:
 
 [chromium/src]$ roll-dep third_party/WebKit 12345
 
 After the script completes, the DEPS file will be dirty with the new revision.
 The user can then:
 
 $ git add DEPS
 $ git commit
 """
 
 import ast
+import optparse
 import os
 import re
 import sys
 
 from itertools import izip
 from subprocess import check_output, Popen, PIPE
 from textwrap import dedent
 
 
 SHA1_RE = re.compile('^[a-fA-F0-9]{40}$')
@@ skipping 44 matching lines @@
   gclient_locals = {}
   execfile(gclient_path, {}, gclient_locals)
   for soln in gclient_locals['solutions']:
     soln_relpath = platform_path(soln['name'].rstrip('/')) + os.sep
     if (dep_path.startswith(soln_relpath) or
         cwd.startswith(os.path.join(gclient_root, soln_relpath))):
       return soln
   assert False, 'Could not determine the parent project for %s' % dep_path
 
 
+def is_git_hash(revision):
+  """Determines if a given revision is a git hash."""
+  return SHA1_RE.match(revision)
+
+
 def verify_git_revision(dep_path, revision):
   """Verify that a git revision exists in a repository."""
   p = Popen(['git', 'rev-list', '-n', '1', revision],
             cwd=dep_path, stdout=PIPE, stderr=PIPE)
   result = p.communicate()[0].strip()
-  if p.returncode != 0 or not SHA1_RE.match(result):
+  if p.returncode != 0 or not is_git_hash(result):
     result = None
   return result
 
 
 def get_svn_revision(dep_path, git_revision):
   """Given a git revision, return the corresponding svn revision."""
   p = Popen(['git', 'log', '-n', '1', '--pretty=format:%B', git_revision],
             stdout=PIPE, cwd=dep_path)
   (log, _) = p.communicate()
   assert p.returncode == 0, 'git log %s failed.' % git_revision
@@ skipping 47 matching lines @@
         log_p.terminate()
         grep_p.terminate()
   raise RuntimeError('No match for revision %d; %s' % (revision, err_msg))
 
 
 def get_git_revision(dep_path, revision):
   """Convert the revision argument passed to the script to a git revision."""
   svn_revision = None
   if revision.startswith('r'):
     git_revision = convert_svn_revision(dep_path, revision[1:])
     svn_revision = revision[1:]

[jochen (gone - plz use gerrit), 2014/12/12 10:08:36]

nit. add if not git_revision: raise RuntimeError('please git fetch origin')

[Michael Achenbach, 2014/12/12 10:24:06]

Done. I assume you meant two lines below as this condition is for incoming svn
numbers.

   elif re.search('[a-fA-F]', revision):
     git_revision = verify_git_revision(dep_path, revision)
     svn_revision = get_svn_revision(dep_path, git_revision)
   elif len(revision) > 6:
     git_revision = verify_git_revision(dep_path, revision)
     if git_revision:
       svn_revision = get_svn_revision(dep_path, git_revision)
     else:
       git_revision = convert_svn_revision(dep_path, revision)
       svn_revision = revision
@@ skipping 98 matching lines @@
                       cwd=dep_path).rstrip()
 
 
 def generate_commit_message(deps_section, dep_path, dep_name, new_rev):
   (url, _, old_rev) = deps_section[dep_name].partition('@')
   if url.endswith('.git'):
     url = url[:-4]
   old_rev_short = short_rev(old_rev, dep_path)
   new_rev_short = short_rev(new_rev, dep_path)
   url += '/+log/%s..%s' % (old_rev_short, new_rev_short)
-  old_svn_rev = get_svn_revision(dep_path, old_rev)
-  new_svn_rev = get_svn_revision(dep_path, new_rev)
+  try:
+    old_svn_rev = get_svn_revision(dep_path, old_rev)
+    new_svn_rev = get_svn_revision(dep_path, new_rev)
+  except Exception:

[jochen (gone - plz use gerrit), 2014/12/12 10:08:36]

when can this happen? I thought get_svn_revision just returns None if it can't
find it?

[Michael Achenbach, 2014/12/12 10:24:06]

It contains also an assertion that raises if git log doesn't work.

+    # Ignore failures that might arise from the repo not being checked out.
+    old_svn_rev = new_svn_rev = None
   svn_range_str = ''
   if old_svn_rev and new_svn_rev:
     svn_range_str = ' (svn %s:%s)' % (old_svn_rev, new_svn_rev)
   return dedent(ROLL_DESCRIPTION_STR % {
     'dep_path': shorten_dep_path(dep_name),
     'before_rev': old_rev_short,
     'after_rev': new_rev_short,
     'svn_range': svn_range_str,
     'revlog_url': url,
   })
@@ skipping 50 matching lines @@
         ['git', 'rev-parse', '--show-toplevel'],
         cwd=deps_file_dir, stdout=PIPE).communicate()[0].strip()
     with open(os.path.join(deps_file_root, '.git', 'MERGE_MSG'), 'w') as fh:
       fh.write(commit_msg)
   else:
     print 'Could not find an entry in %s to update.' % deps_file
   return 0 if commit_msg else 1
 
 
 def main(argv):
+  parser = optparse.OptionParser()
+  parser.add_option('--no-verify-revision',
+                    help='Don\'t verify the revision passed in. This '
+                         'also skips adding an svn revision comment '
+                         'for git dependencies and requires the passed '
+                         'revision to be a git hash.',
+                    default=False, action='store_true')
+  (options, argv) = parser.parse_args(argv)
   if len(argv) not in (2, 3):
     print >> sys.stderr, (
-        'Usage: roll_dep.py <dep path> <svn revision> [ <DEPS file> ]')
+        'Usage: roll_dep.py [options] <dep path> <svn revision> '
+        '[ <DEPS file> ]')
     return 1
   (arg_dep_path, revision) = argv[0:2]
   gclient_root = find_gclient_root()
   dep_path = platform_path(arg_dep_path)
   if not os.path.exists(dep_path):
     dep_path = os.path.join(gclient_root, dep_path)
-  assert os.path.isdir(dep_path), 'No such directory: %s' % arg_dep_path
+  if not options.no_verify_revision:
+    # Only require the path to exist if the revision should be verified. A path
+    # to e.g. os deps might not be checked out.
+    assert os.path.isdir(dep_path), 'No such directory: %s' % arg_dep_path
   if len(argv) > 2:
     deps_file = argv[2]
   else:
     soln = get_solution(gclient_root, dep_path)
     soln_path = os.path.relpath(os.path.join(gclient_root, soln['name']))
     deps_file = os.path.join(soln_path, 'DEPS')
   dep_name = posix_path(os.path.relpath(dep_path, gclient_root))
-  (git_rev, svn_rev) = get_git_revision(dep_path, revision)
-  comment = ('from svn revision %s' % svn_rev) if svn_rev else None
-  assert git_rev, 'Could not find git revision matching %s.' % revision
+  if options.no_verify_revision:
+    assert is_git_hash(revision), (
+        'The passed revision %s must be a git hash when skipping revision '
+        'verification.' % revision)
+    git_rev = revision
+    comment = None
+  else:
+    (git_rev, svn_rev) = get_git_revision(dep_path, revision)
+    comment = ('from svn revision %s' % svn_rev) if svn_rev else None
+    assert git_rev, 'Could not find git revision matching %s.' % revision
   return update_deps(deps_file, dep_path, dep_name, git_rev, comment)
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))