trychange.py: Gerrit protocol

trychange.py

 #!/usr/bin/env python
 # 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.
 
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn/git repository or by directly
 connecting to the server by HTTP.
 """
 
 import contextlib
 import datetime
 import errno
 import getpass
 import itertools
 import json
 import logging
 import optparse
 import os
 import posixpath
 import re
 import shutil
 import sys
 import tempfile
 import urllib
 import urllib2
+import urlparse
 
 import breakpad  # pylint: disable=W0611
 
+import fix_encoding
 import gcl
-import fix_encoding
 import gclient_utils
+import gerrit_util
 import scm
 import subprocess2
 
 
 __version__ = '1.2'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
 USAGE = r"""%prog [options]
@@ skipping 45 matching lines @@
       DieWithError(
           'Command "%s" failed.\n%s' % (
             ' '.join(args), error_message or e.stdout or ''))
     return e.stdout
 
 
 def RunGit(args, **kwargs):
   """Returns stdout."""
   return RunCommand(['git'] + args, **kwargs)
 
+class Error(Exception):
+  """An error during a try job submission.
 
-class InvalidScript(Exception):
+  For this error, trychange.py does not display stack trace, only message
+  """
+
+class InvalidScript(Error):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
-class NoTryServerAccess(Exception):
+class NoTryServerAccess(Error):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
-
 def Escape(name):
   """Escapes characters that could interfere with the file system or try job
   parsing.
   """
   return re.sub(r'[^\w#-]', '_', name)
 
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
   def __init__(self, options, path, file_list):
@@ skipping 42 matching lines @@
     """Set default settings based on the gcl-style settings from the repository.
 
     The settings in the self.options object will only be set if no previous
     value exists (i.e. command line flags to the try command will override the
     settings in codereview.settings).
     """
     settings = {
       'port': self.GetCodeReviewSetting('TRYSERVER_HTTP_PORT'),
       'host': self.GetCodeReviewSetting('TRYSERVER_HTTP_HOST'),
       'svn_repo': self.GetCodeReviewSetting('TRYSERVER_SVN_URL'),
+      'gerrit_url': self.GetCodeReviewSetting('TRYSERVER_GERRIT_URL'),
       'git_repo': self.GetCodeReviewSetting('TRYSERVER_GIT_URL'),
       'project': self.GetCodeReviewSetting('TRYSERVER_PROJECT'),
       # Primarily for revision=auto
       'revision': self.GetCodeReviewSetting('TRYSERVER_REVISION'),
       'root': self.GetCodeReviewSetting('TRYSERVER_ROOT'),
       'patchlevel': self.GetCodeReviewSetting('TRYSERVER_PATCHLEVEL'),
     }
     logging.info('\n'.join(['%s: %s' % (k, v)
                             for (k, v) in settings.iteritems() if v]))
     for (k, v) in settings.iteritems():
@@ skipping 303 matching lines @@
       raise NoTryServerAccess('%s is unaccessible. Reason: %s' % (url,
                                                                   str(e.args)))
   if not connection:
     raise NoTryServerAccess('%s is unaccessible.' % url)
   logging.info('Reading response...')
   response = connection.read()
   logging.info('Done')
   if response != 'OK':
     raise NoTryServerAccess('%s is unaccessible. Got:\n%s' % (url, response))
 
+  PrintSuccess(bot_spec, options)
 
 @contextlib.contextmanager
 def _TempFilename(name, contents=None):
   """Create a temporary directory, append the specified name and yield.
 
   In contrast to NamedTemporaryFile, does not keep the file open.
   Deletes the file on __exit__.
   """
   temp_dir = tempfile.mkdtemp(prefix=name)
   try:
@@ skipping 57 matching lines @@
     command = [exe, 'import', '-q', patch_dir, options.svn_repo, '--file',
                description_filename]
     if scm.SVN.AssertVersion("1.5")[0]:
       command.append('--no-ignore')
 
     try:
       subprocess2.check_call(command)
     except subprocess2.CalledProcessError, e:
       raise NoTryServerAccess(str(e))
 
+  PrintSuccess(bot_spec, options)
 
 def _GetPatchGitRepo(git_url):
   """Gets a path to a Git repo with patches.
 
   Stores patches in .git/git-try/patches-git directory, a git repo. If it
   doesn't exist yet or its origin URL is different, cleans up and clones it.
   If it existed before, then pulls changes.
 
   Does not support SVN repo.
 
@@ skipping 118 matching lines @@
           # Fetch, reset, update branch file again.
           patch_git('fetch', 'origin')
           patch_git('reset', '--hard', 'origin/master')
           update_branch()
     except subprocess2.CalledProcessError, e:
       # Restore state.
       patch_git('checkout', 'master')
       patch_git('reset', '--hard', 'origin/master')
       raise
 
+  PrintSuccess(bot_spec, options)
+
+def _SendChangeGerrit(bot_spec, options):
+  """Posts a try job to a Gerrit change.
+
+  Reads Change-Id from the HEAD commit, resolves the current revision, checks
+  that local revision matches the uploaded one, posts a try job in form of a
+  message, sets Tryjob label to 1.
+
+  Gerrit message format: starts with !tryjob, optionally followed by a tryjob
+  definition in JSON format:
+      buildNames: list of strings specifying build names.
+  """
+
+  logging.info('Sending by Gerrit')
+  if not options.gerrit_url:
+    raise NoTryServerAccess('Please use --gerrit_url option to specify the '
+                            'Gerrit instance url to connect to')
+  gerrit_host = urlparse.urlparse(options.gerrit_url).hostname
+  logging.debug('Gerrit host: %s' % gerrit_host)
+
+  def getChangeId(commmitish):

[Vadim Sh., 2014/04/30 22:06:26]

mm.. GetChangeId, not getChangeId.

[nodir, 2014/04/30 22:43:40]

Done.

+    """Finds Change-ID of the HEAD commit."""
+    CHANGE_ID_RGX = '^Change-Id: (I[a-f0-9]{10,})'
+    comment = scm.GIT.Capture(['log', '-1', commmitish, '--format=%b'],
+                              cwd=os.getcwd())
+    change_id_match = re.search(CHANGE_ID_RGX, comment, re.I | re.M)
+    if not change_id_match:
+      raise Error('Change-Id was not found in the HEAD commit. Make sure you '
+                  'have a Git hook installed that generates and inserts a '
+                  'Change-Id into a commit message automatically.')
+    change_id = change_id_match.group(1)
+    return change_id
+
+  def formatMessage():
+    # Build job definition.
+    job_def = {}
+    builderNames = [builder for builder, _ in bot_spec]
+    if builderNames:
+      job_def['builderNames'] = builderNames
+
+    # Format message.
+    msg = '!tryjob'
+    if job_def:
+      msg = '%s %s' % (msg, json.dumps(job_def, sort_keys=True))
+    return msg
+
+  def postTryjob(message):
+    logging.info('Posting gerrit message: %s' % message)
+    if not options.dry_run:
+      # Post a message and set TryJob=1 label.
+      try:
+        gerrit_util.SetReview(gerrit_host, change_id, msg=message,
+                              labels={'Tryjob': 1})
+      except gerrit_util.GerritError, e:
+        if e.http_status == 400:
+          raise Error(e.reason)
+        else:
+          raise
+
+  head_sha = scm.GIT.Capture(['log', '-1', '--format=%H'], cwd=os.getcwd())
+
+  change_id = getChangeId(head_sha)
+
+  # Check that the uploaded revision matches the local one.
+  changes = gerrit_util.GetChangeCurrentRevision(gerrit_host, change_id)
+  assert len(changes) <= 1, 'Multiple changes with id %s' % change_id
+  if not changes:
+    raise Error('A change %s was not found on the server. Was it uploaded?' %
+                change_id)
+  logging.debug('Found Gerrit change: %s' % changes[0])
+  if changes[0]['current_revision'] != head_sha:
+    raise Error('Please upload your latest local changes to Gerrit.')
+
+  # Post a try job.
+  message = formatMessage()
+  postTryjob(message)
+  change_url = urlparse.urljoin(options.gerrit_url,
+                                '/#/c/%s' % changes[0]['_number'])
+  print('A tryjob was posted on change %s' % change_url)
 
 def PrintSuccess(bot_spec, options):
   if not options.dry_run:
     text = 'Patch \'%s\' sent to try server' % options.name
     if bot_spec:
       text += ': %s' % ', '.join(
           '%s:%s' % (b[0], ','.join(b[1])) for b in bot_spec)
     print(text)
 
 
@@ skipping 194 matching lines @@
   group.add_option("--use_git",
                    action="store_const",
                    const=_SendChangeGit,
                    dest="send_patch",
                    help="Use GIT to talk to the try server")
   group.add_option("-G", "--git_repo",
                    metavar="GIT_URL",
                    help="GIT url to use to write the changes in; --use_git is "
                         "implied when using --git_repo")
   parser.add_option_group(group)
+
+  group = optparse.OptionGroup(parser, "Access the try server with Gerrit")
+  group.add_option("--use_gerrit",
+                   action="store_const",
+                   const=_SendChangeGerrit,
+                   dest="send_patch",
+                   help="Use Gerrit to talk to the try server")
+  group.add_option("--gerrit_url",
+                   metavar="GERRIT_URL",
+                   help="Gerrit url to post a tryjob to; --use_gerrit is "
+                        "implied when using --gerrit_url")
+  parser.add_option_group(group)
+
   return parser
 
 
 def TryChange(argv,
               change,
               swallow_exception,
               prog=None,
               extra_epilog=None):
   """
   Args:
@@ skipping 93 matching lines @@
                           os.path.join(current_vcs.checkout_root, item),
                           None)
       if checkout.checkout_root in [c.checkout_root for c in checkouts]:
         parser.error('Specified the root %s two times.' %
                      checkout.checkout_root)
       checkouts.append(checkout)
 
     can_http = options.port and options.host
     can_svn = options.svn_repo
     can_git = options.git_repo
+    can_gerrit = options.gerrit_url
+    can_something = can_http or can_svn or can_git or can_gerrit
     # If there was no transport selected yet, now we must have enough data to
     # select one.
-    if not options.send_patch and not (can_http or can_svn or can_git):
+    if not options.send_patch and not can_something:
       parser.error('Please specify an access method.')
 
     # Convert options.diff into the content of the diff.
     if options.url:
       if options.files:
         parser.error('You cannot specify files and --url at the same time.')
       options.diff = urllib2.urlopen(options.url).read()
     elif options.diff:
       if options.files:
         parser.error('You cannot specify files and --diff at the same time.')
@@ skipping 66 matching lines @@
 
     # Determine sending protocol
     if options.send_patch:
       # If forced.
       senders = [options.send_patch]
     else:
       # Try sending patch using avaialble protocols
       all_senders = [
         (_SendChangeHTTP, can_http),
         (_SendChangeSVN, can_svn),
-        (_SendChangeGit, can_git)
+        (_SendChangeGerrit, can_gerrit),
+        (_SendChangeGit, can_git),
       ]
       senders = [sender for sender, can in all_senders if can]
 
     # Send the patch.
     for sender in senders:
       try:
         sender(bot_spec, options)
-        PrintSuccess(bot_spec, options)
         return 0
       except NoTryServerAccess:
         is_last = sender == senders[-1]
         if is_last:
           raise
     assert False, "Unreachable code"
-  except (InvalidScript, NoTryServerAccess), e:
+  except Error, e:
     if swallow_exception:
       return 1
     print >> sys.stderr, e
     return 1
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   fix_encoding.fix_encoding()
   sys.exit(TryChange(None, None, False))