Gerrit git cl upload: record issue id for a branch.

git_cl.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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld."""
 
 from distutils.version import LooseVersion
@@ skipping 1065 matching lines @@
       # with that branch.
       if self.GetIssue():
         rietveld_server_config = self._RietveldServer()
         if rietveld_server_config:
           self.rietveld_server = gclient_utils.UpgradeToHttps(RunGit(
               ['config', rietveld_server_config], error_ok=True).strip())
       if not self.rietveld_server:
         self.rietveld_server = settings.GetDefaultServerUrl()
     return self.rietveld_server
 
+  def GetGerritServer(self):
+    # We don't support multiple Gerrit servers, and assume it to be same as
+    # origin, except with a '-review' suffix for first subdomain.
+    parts = urlparse.urlparse(self.GetRemoteUrl()).netloc.split('.')
+    parts[0] = parts[0] + '-review'
+    return 'https://%s' % '.'.join(parts)
+
   def GetIssueURL(self):
     """Get the URL for a particular issue."""
     if not self.GetIssue():
       return None
+    if settings.GetIsGerrit():
+      return '%s/%s' % (self.GetGerritServer(), self.GetIssue())
     return '%s/%s' % (self.GetRietveldServer(), self.GetIssue())
 
   def GetDescription(self, pretty=False):
     if not self.has_description:
       if self.GetIssue():
         issue = self.GetIssue()
         try:
           self.description = self.RpcServer().get_description(issue).strip()
         except urllib2.HTTPError as e:
           if e.code == 404:
@@ skipping 56 matching lines @@
       else:
         self._props = self.RpcServer().get_issue_properties(issue, True)
     return self._props
 
   def GetApprovingReviewers(self):
     return get_approving_reviewers(self.GetIssueProperties())
 
   def AddComment(self, message):
     return self.RpcServer().add_comment(self.GetIssue(), message)
 
-  def SetIssue(self, issue):
-    """Set this branch's issue.  If issue=0, clears the issue."""
+  def SetIssue(self, issue=None):
+    """Set this branch's issue.  If issue isn't given, clears the issue."""
     if issue:
       self.issue = issue
       RunGit(['config', self._IssueSetting(), str(issue)])
-      if self.rietveld_server:
+      if not settings.GetIsGerrit() and self.rietveld_server:
         RunGit(['config', self._RietveldServer(), self.rietveld_server])
     else:
       current_issue = self.GetIssue()
       if current_issue:
         RunGit(['config', '--unset', self._IssueSetting()])
       self.issue = None
       self.SetPatchset(None)
 
   def GetChange(self, upstream_branch, author):
     if not self.GitSanityChecks(upstream_branch):
@@ skipping 130 matching lines @@
     """Returns an upload.RpcServer() to access this review's rietveld instance.
     """
     if not self._rpc_server:
       self._rpc_server = rietveld.CachingRietveld(
           self.GetRietveldServer(),
           self._auth_config or auth.make_auth_config())
     return self._rpc_server
 
   def _IssueSetting(self):
     """Return the git setting that stores this change's issue."""
+    if settings.GetIsGerrit():
+      return 'branch.%s.gerritissue' % self.GetBranch()
     return 'branch.%s.rietveldissue' % self.GetBranch()
 
   def _PatchsetSetting(self):
     """Return the git setting that stores this change's most recent patchset."""
     return 'branch.%s.rietveldpatchset' % self.GetBranch()
 
   def _RietveldServer(self):
     """Returns the git setting that stores this change's rietveld server."""
     branch = self.GetBranch()
     if branch:
@@ skipping 821 matching lines @@
 def AddChangeIdToCommitMessage(options, args):
   """Re-commits using the current message, assumes the commit hook is in
   place.
   """
   log_desc = options.message or CreateDescriptionFromLog(args)
   git_command = ['commit', '--amend', '-m', log_desc]
   RunGit(git_command)
   new_log_desc = CreateDescriptionFromLog(args)
   if git_footers.get_footer_change_id(new_log_desc):
     print 'git-cl: Added Change-Id to commit message.'
+    return new_log_desc

[Michael Achenbach, 2016/03/16 09:44:28]

Where is this used? It's a bit odd that the method doesn't return in all
control-flow cases. Or is this pythonish as the default will be None?

[tandrii(chromium), 2016/03/16 10:09:24]

it's not pythonic, but yes default is None. I'll fix this in the next CL, thanks
for comment. That said, that codepath still fails anyway immediately afterwards.

   else:
     print >> sys.stderr, 'ERROR: Gerrit commit-msg hook not available.'
 
 
 def GenerateGerritChangeId(message):
   """Returns Ixxxxxx...xxx change id.
 
   Works the same way as
   https://gerrit-review.googlesource.com/tools/hooks/commit-msg
   but can be called on demand on all platforms.
@@ skipping 52 matching lines @@
         print "Description is empty; aborting."
         return 1
       message = change_desc.description
       change_ids = git_footers.get_footer_change_id(message)
       if len(change_ids) > 1:
         DieWithError('too many Change-Id footers in %s branch' % shadow_branch)
       if not change_ids:
         message = git_footers.add_footer_change_id(
             message, GenerateGerritChangeId(message))
         change_desc.set_description(message)
+        change_ids = git_footers.get_footer_change_id(message)
+        assert len(change_ids) == 1
+
+      change_id = change_ids[0]
 
     remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
     if remote is '.':
       # If our upstream branch is local, we base our squashed commit on its
       # squashed version.
       parent = ('refs/heads/git_cl_uploads/' +
                 scm.GIT.ShortBranchName(upstream_branch))
 
       # Verify that the upstream branch has been uploaded too, otherwise Gerrit
       # will create additional CLs when uploading.
       if (RunGitSilent(['rev-parse', upstream_branch + ':']) !=
           RunGitSilent(['rev-parse', parent + ':'])):
         print 'Upload upstream branch ' + upstream_branch + ' first.'
         return 1
     else:
       parent = cl.GetCommonAncestorWithUpstream()
 
     tree = RunGit(['rev-parse', 'HEAD:']).strip()
     ref_to_push = RunGit(['commit-tree', tree, '-p', parent,
                           '-m', message]).strip()
   else:
     if not git_footers.get_footer_change_id(change_desc.description):
       DownloadGerritHook(False)
-      AddChangeIdToCommitMessage(options, args)
+      change_desc.set_description(AddChangeIdToCommitMessage(options, args))
     ref_to_push = 'HEAD'
     parent = '%s/%s' % (gerrit_remote, branch)
+    change_id = git_footers.get_footer_change_id(change_desc.description)[0]
 
   commits = RunGitSilent(['rev-list', '%s..%s' % (parent,
                                                   ref_to_push)]).splitlines()
   if len(commits) > 1:
     print('WARNING: This will upload %d commits. Run the following command '
           'to see which commits will be uploaded: ' % len(commits))
     print('git log %s..%s' % (parent, ref_to_push))
     print('You can also use `git squash-branch` to squash these into a single '
           'commit.')
     ask_for_data('About to upload; enter to confirm.')
@@ skipping 10 matching lines @@
     receive_options += ['--cc=' + email for email in cc]
   if change_desc.get_reviewers():
     receive_options.extend(
         '--reviewer=' + email for email in change_desc.get_reviewers())
 
   git_command = ['push']
   if receive_options:
     git_command.append('--receive-pack=git receive-pack %s' %
                        ' '.join(receive_options))
   git_command += [gerrit_remote, ref_to_push + ':refs/for/' + branch]
-  RunGit(git_command)
+  push_stdout = gclient_utils.CheckCallAndFilter(
+      ['git'] + git_command,
+      print_stdout=True,
+      # Flush after every line: useful for seeing progress when running as
+      # recipe.
+      filter_fn=lambda _: sys.stdout.flush())
 
   if options.squash:
+    regex = re.compile(r'remote:\s+https?://[\w\-\.\/]*/(\d+)\s.*')
+    change_numbers = [m.group(1)
+                      for m in map(regex.match, push_stdout.splitlines())
+                      if m]
+    if len(change_numbers) != 1:
+      DieWithError(
+        ('Created|Updated %d issues on Gerrit, but only 1 expected.\n'
+         'Change-Id: %s') % (len(change_numbers), change_id))
+    cl.SetIssue(change_numbers[0])
     head = RunGit(['rev-parse', 'HEAD']).strip()
     RunGit(['update-ref', '-m', 'Uploaded ' + head, shadow_branch, ref_to_push])
-
-  # TODO(ukai): parse Change-Id: and set issue number?
   return 0
 
 
 def GetTargetRef(remote, remote_branch, target_branch, pending_prefix):
   """Computes the remote branch ref to use for the CL.
 
   Args:
     remote (str): The git remote for the CL.
     remote_branch (str): The git remote branch for the CL.
     target_branch (str): The target branch specified by the user.
@@ skipping 1675 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   colorama.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)