build/util/lastchange.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """
   7 lastchange.py -- Chromium revision fetching utility.
   8 """
   9
  10 import re
  11 import optparse
  12 import os
  13 import subprocess
  14 import sys
  15
  16 _GIT_SVN_ID_REGEX = re.compile(r'.*git-svn-id:\s*([^@]*)@([0-9]+)', re.DOTALL)
  17
  18 class VersionInfo(object):
  19   def __init__(self, url, revision):
  20     self.url = url
  21     self.revision = revision
  22
  23
  24 def FetchSVNRevision(directory, svn_url_regex):
  25   """
  26   Fetch the Subversion branch and revision for a given directory.
  27
  28   Errors are swallowed.
  29
  30   Returns:
  31     A VersionInfo object or None on error.
  32   """
  33   try:
  34     proc = subprocess.Popen(['svn', 'info'],
  35                             stdout=subprocess.PIPE,
  36                             stderr=subprocess.PIPE,
  37                             cwd=directory,
  38                             shell=(sys.platform=='win32'))
  39   except OSError:
  40     # command is apparently either not installed or not executable.
  41     return None
  42   if not proc:
  43     return None
  44
  45   attrs = {}
  46   for line in proc.stdout:
  47     line = line.strip()
  48     if not line:
  49       continue
  50     key, val = line.split(': ', 1)
  51     attrs[key] = val
  52
  53   try:
  54     match = svn_url_regex.search(attrs['URL'])
  55     if match:
  56       url = match.group(2)
  57     else:
  58       url = ''
  59     revision = attrs['Revision']
  60   except KeyError:
  61     return None
  62
  63   return VersionInfo(url, revision)
  64
  65
  66 def RunGitCommand(directory, command):
  67   """
  68   Launches git subcommand.
  69
  70   Errors are swallowed.
  71
  72   Returns:
  73     A process object or None.
  74   """
  75   command = ['git'] + command
  76   # Force shell usage under cygwin. This is a workaround for
  77   # mysterious loss of cwd while invoking cygwin's git.
  78   # We can't just pass shell=True to Popen, as under win32 this will
  79   # cause CMD to be used, while we explicitly want a cygwin shell.
  80   if sys.platform == 'cygwin':
  81     command = ['sh', '-c', ' '.join(command)]
  82   try:
  83     proc = subprocess.Popen(command,
  84                             stdout=subprocess.PIPE,
  85                             stderr=subprocess.PIPE,
  86                             cwd=directory,
  87                             shell=(sys.platform=='win32'))
  88     return proc
  89   except OSError:
  90     return None
  91
  92
  93 def FetchGitRevision(directory):
  94   """
  95   Fetch the Git hash for a given directory.
  96
  97   Errors are swallowed.
  98
  99   Returns:
 100     A VersionInfo object or None on error.
 101   """
 102   hsh = ''
 103   proc = RunGitCommand(directory, ['rev-parse', 'HEAD'])
 104   if proc:
 105     output = proc.communicate()[0].strip()
 106     if proc.returncode == 0 and output:
 107       hsh = output
 108   if not hsh:
 109     return None
 110   pos = ''
 111   proc = RunGitCommand(directory, ['cat-file', 'commit', 'HEAD'])
 112   if proc:
 113     output = proc.communicate()[0]
 114     if proc.returncode == 0 and output:
 115       for line in reversed(output.splitlines()):
 116         if line.startswith('Cr-Commit-Position:'):
 117           pos = line.rsplit()[-1].strip()
 118           break
 119   if not pos:
 120     return VersionInfo('git', hsh)
 121   return VersionInfo('git', '%s-%s' % (hsh, pos))
 122
 123
 124 def FetchGitSVNURLAndRevision(directory, svn_url_regex, go_deeper):
 125   """
 126   Fetch the Subversion URL and revision through Git.
 127
 128   Errors are swallowed.
 129
 130   Returns:
 131     A tuple containing the Subversion URL and revision.
 132   """
 133   git_args = ['log', '-1', '--format=%b']
 134   if go_deeper:
 135     git_args.append('--grep=git-svn-id')
 136   proc = RunGitCommand(directory, git_args)
 137   if proc:
 138     output = proc.communicate()[0].strip()
 139     if proc.returncode == 0 and output:
 140       # Extract the latest SVN revision and the SVN URL.
 141       # The target line is the last "git-svn-id: ..." line like this:
 142       # git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85528 0039d316....
 143       match = _GIT_SVN_ID_REGEX.search(output)
 144       if match:
 145         revision = match.group(2)
 146         url_match = svn_url_regex.search(match.group(1))
 147         if url_match:
 148           url = url_match.group(2)
 149         else:
 150           url = ''
 151         return url, revision
 152   return None, None
 153
 154
 155 def FetchGitSVNRevision(directory, svn_url_regex, go_deeper):
 156   """
 157   Fetch the Git-SVN identifier for the local tree.
 158
 159   Errors are swallowed.
 160   """
 161   url, revision = FetchGitSVNURLAndRevision(directory, svn_url_regex, go_deeper)
 162   if url and revision:
 163     return VersionInfo(url, revision)
 164   return None
 165
 166
 167 def FetchVersionInfo(default_lastchange, directory=None,
 168                      directory_regex_prior_to_src_url='chrome|blink|svn',
 169                      go_deeper=False):
 170   """
 171   Returns the last change (in the form of a branch, revision tuple),
 172   from some appropriate revision control system.
 173   """
 174   svn_url_regex = re.compile(
 175       r'.*/(' + directory_regex_prior_to_src_url + r')(/.*)')
 176
 177   version_info = (FetchSVNRevision(directory, svn_url_regex) or
 178                   FetchGitSVNRevision(directory, svn_url_regex, go_deeper) or
 179                   FetchGitRevision(directory))
 180   if not version_info:
 181     if default_lastchange and os.path.exists(default_lastchange):
 182       revision = open(default_lastchange, 'r').read().strip()
 183       version_info = VersionInfo(None, revision)
 184     else:
 185       version_info = VersionInfo(None, None)
 186   return version_info
 187
 188 def GetHeaderGuard(path):
 189   """
 190   Returns the header #define guard for the given file path.
 191   This treats everything after the last instance of "src/" as being a
 192   relevant part of the guard. If there is no "src/", then the entire path
 193   is used.
 194   """
 195   src_index = path.rfind('src/')
 196   if src_index != -1:
 197     guard = path[src_index + 4:]
 198   else:
 199     guard = path
 200   guard = guard.upper()
 201   return guard.replace('/', '_').replace('.', '_').replace('\\', '_') + '_'
 202
 203 def GetHeaderContents(path, define, version):
 204   """
 205   Returns what the contents of the header file should be that indicate the given
 206   revision. Note that the #define is specified as a string, even though it's
 207   currently always a SVN revision number, in case we need to move to git hashes.
 208   """
 209   header_guard = GetHeaderGuard(path)
 210
 211   header_contents = """/* Generated by lastchange.py, do not edit.*/
 212
 213 #ifndef %(header_guard)s
 214 #define %(header_guard)s
 215
 216 #define %(define)s "%(version)s"
 217
 218 #endif  // %(header_guard)s
 219 """
 220   header_contents = header_contents % { 'header_guard': header_guard,
 221                                         'define': define,
 222                                         'version': version }
 223   return header_contents
 224
 225 def WriteIfChanged(file_name, contents):
 226   """
 227   Writes the specified contents to the specified file_name
 228   iff the contents are different than the current contents.
 229   """
 230   try:
 231     old_contents = open(file_name, 'r').read()
 232   except EnvironmentError:
 233     pass
 234   else:
 235     if contents == old_contents:
 236       return
 237     os.unlink(file_name)
 238   open(file_name, 'w').write(contents)
 239
 240
 241 def main(argv=None):
 242   if argv is None:
 243     argv = sys.argv
 244
 245   parser = optparse.OptionParser(usage="lastchange.py [options]")
 246   parser.add_option("-d", "--default-lastchange", metavar="FILE",
 247                     help="Default last change input FILE.")
 248   parser.add_option("-m", "--version-macro",
 249                     help="Name of C #define when using --header. Defaults to " +
 250                     "LAST_CHANGE.",
 251                     default="LAST_CHANGE")
 252   parser.add_option("-o", "--output", metavar="FILE",
 253                     help="Write last change to FILE. " +
 254                     "Can be combined with --header to write both files.")
 255   parser.add_option("", "--header", metavar="FILE",
 256                     help="Write last change to FILE as a C/C++ header. " +
 257                     "Can be combined with --output to write both files.")
 258   parser.add_option("--revision-only", action='store_true',
 259                     help="Just print the SVN revision number. Overrides any " +
 260                     "file-output-related options.")
 261   parser.add_option("-s", "--source-dir", metavar="DIR",
 262                     help="Use repository in the given directory.")
 263   parser.add_option("--git-svn-go-deeper", action='store_true',
 264                     help="In a Git-SVN repo, dig down to the last committed " +
 265                     "SVN change (historic behaviour).")
 266   opts, args = parser.parse_args(argv[1:])
 267
 268   out_file = opts.output
 269   header = opts.header
 270
 271   while len(args) and out_file is None:
 272     if out_file is None:
 273       out_file = args.pop(0)
 274   if args:
 275     sys.stderr.write('Unexpected arguments: %r\n\n' % args)
 276     parser.print_help()
 277     sys.exit(2)
 278
 279   if opts.source_dir:
 280     src_dir = opts.source_dir
 281   else:
 282     src_dir = os.path.dirname(os.path.abspath(__file__))
 283
 284   version_info = FetchVersionInfo(opts.default_lastchange,
 285                                   directory=src_dir,
 286                                   go_deeper=opts.git_svn_go_deeper)
 287
 288   if version_info.revision == None:
 289     version_info.revision = '0'
 290
 291   if opts.revision_only:
 292     print version_info.revision
 293   else:
 294     contents = "LASTCHANGE=%s\n" % version_info.revision
 295     if not out_file and not opts.header:
 296       sys.stdout.write(contents)
 297     else:
 298       if out_file:
 299         WriteIfChanged(out_file, contents)
 300       if header:
 301         WriteIfChanged(header,
 302                        GetHeaderContents(header, opts.version_macro,
 303                                          version_info.revision))
 304
 305   return 0
 306
 307
 308 if __name__ == '__main__':
 309   sys.exit(main())