Add commit_queue.py tool to toggle the bit of the commit queue from command line

git_cl.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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."""
 
 import errno
@@ skipping 445 matching lines @@
     self.GetIssue()
     return self.rietveld_server
 
   def GetIssueURL(self):
     """Get the URL for a particular issue."""
     return '%s/%s' % (self.GetRietveldServer(), self.GetIssue())
 
   def GetDescription(self, pretty=False):
     if not self.has_description:
       if self.GetIssue():
-        path = '/' + self.GetIssue() + '/description'
-        rpc_server = self.RpcServer()
-        self.description = rpc_server.Send(path).strip()
+        self.description = self.RpcServer().get_description(
+            int(self.GetIssue())).strip()
       self.has_description = True
     if pretty:
       wrapper = textwrap.TextWrapper()
       wrapper.initial_indent = wrapper.subsequent_indent = '  '
       return wrapper.fill(self.description)
     return self.description
 
   def GetPatchset(self):
     if not self.has_patchset:
       patchset = RunGit(['config', self._PatchsetSetting()],
                         error_ok=True).strip()
       if patchset:
         self.patchset = patchset
       else:
         self.patchset = None
       self.has_patchset = True
     return self.patchset
 
   def SetPatchset(self, patchset):
     """Set this branch's patchset.  If patchset=0, clears the patchset."""
     if patchset:
       RunGit(['config', self._PatchsetSetting(), str(patchset)])
     else:
       RunGit(['config', '--unset', self._PatchsetSetting()],
              swallow_stderr=True, error_ok=True)
     self.has_patchset = False
 
   def GetPatchSetDiff(self, issue):
-    # Grab the last patchset of the issue first.
-    data = json.loads(self.RpcServer().Send('/api/%s' % issue))
-    patchset = data['patchsets'][-1]
-    return self.RpcServer().Send(
+    patchset = self.RpcServer().get_issue_properties(
+        int(issue), False)['patchsets'][-1]
+    return self.RpcServer().get(
         '/download/issue%s_%s.diff' % (issue, patchset))
 
   def SetIssue(self, issue):
     """Set this branch's issue.  If issue=0, clears the issue."""
     if issue:
       RunGit(['config', self._IssueSetting(), str(issue)])
       if self.rietveld_server:
         RunGit(['config', self._RietveldServer(), self.rietveld_server])
     else:
       RunGit(['config', '--unset', self._IssueSetting()])
@@ skipping 46 matching lines @@
            'If all fails, contact maruel@') % e)
 
     # TODO(dpranke): We should propagate the error out instead of calling
     # exit().
     if not output.should_continue():
       sys.exit(1)
 
     return output
 
   def CloseIssue(self):
-    rpc_server = self.RpcServer()
-    # Newer versions of Rietveld require us to pass an XSRF token to POST, so
-    # we fetch it from the server.  (The version used by Chromium has been
-    # modified so the token isn't required when closing an issue.)
-    xsrf_token = rpc_server.Send('/xsrf_token',
-                                 extra_headers={'X-Requesting-XSRF-Token': '1'})
+    return self.RpcServer().close_issue(int(self.GetIssue()))
 
-    # You cannot close an issue with a GET.
-    # We pass an empty string for the data so it is a POST rather than a GET.
-    data = [("description", self.description),
-            ("xsrf_token", xsrf_token)]
-    ctype, body = upload.EncodeMultipartFormData(data, [])
-    rpc_server.Send(
-        '/' + self.GetIssue() + '/close', payload=body, content_type=ctype)
+  def SetFlag(self, flag, value):
+    """Patchset must match."""
+    if not self.GetPatchset():
+      DieWithError('The patchset needs to match. Send another patchset.')
+    try:
+      return self.RpcServer().set_flag(
+          int(self.GetIssue()), int(self.GetPatchset()), flag, value)
+    except urllib2.HTTPError, e:
+      if e.code == 404:
+        DieWithError('The issue %s doesn\'t exist.' % self.GetIssue())
+      if e.code == 403:
+        DieWithError(
+            ('Access denied to issue %s. Maybe the patchset %s doesn\'t '
+             'match?') % (self.GetIssue(), self.GetPatchset()))
+      raise
 
   def RpcServer(self):
     """Returns an upload.RpcServer() to access this review's rietveld instance.
     """
     if not self._rpc_server:
       self.GetIssue()
       self._rpc_server = rietveld.Rietveld(self.rietveld_server, None, None)
     return self._rpc_server
 
   def _IssueSetting(self):
@@ skipping 315 matching lines @@
                     help='cc email addresses')
   parser.add_option('--send-mail', action='store_true',
                     help='send email to reviewer immediately')
   parser.add_option("--emulate_svn_auto_props", action="store_true",
                     dest="emulate_svn_auto_props",
                     help="Emulate Subversion's auto properties feature.")
   parser.add_option("--desc_from_logs", action="store_true",
                     dest="from_logs",
                     help="""Squashes git commit logs into change description and
                             uses message as subject""")
+  parser.add_option('-c', '--use-commit-queue', action='store_true',
+                    help='tell the commit queue to commit this patchset')
   (options, args) = parser.parse_args(args)
 
   # Make sure index is up-to-date before running diff-index.
   RunGit(['update-index', '--refresh', '-q'], error_ok=True)
   if RunGit(['diff-index', 'HEAD']):
     print 'Cannot upload with a dirty tree.  You must commit locally first.'
     return 1
 
   cl = Changelist()
   if args:
@@ skipping 88 matching lines @@
       print '\nGot exception while uploading -- saving description to %s\n' \
           % backup_path
       backup_file = open(backup_path, 'w')
       backup_file.write(change_desc.description)
       backup_file.close()
     raise
 
   if not cl.GetIssue():
     cl.SetIssue(issue)
   cl.SetPatchset(patchset)
+
+  if options.use_commit_queue:
+    cl.SetFlag('commit', '1')
   return 0
 
 
 def SendUpstream(parser, args, cmd):
   """Common code for CmdPush and CmdDCommit
 
   Squashed commit into a single.
   Updates changelog with metadata (e.g. pointer to review).
   Pushes/dcommits the code upstream.
   Updates review and closes.
@@ skipping 224 matching lines @@
   parser.add_option('--reject', action='store_true', dest='reject',
                     help='allow failed patches and spew .rej files')
   parser.add_option('-n', '--no-commit', action='store_true', dest='nocommit',
                     help="don't commit after patch applies")
   (options, args) = parser.parse_args(args)
   if len(args) != 1:
     parser.print_help()
     return 1
   issue_arg = args[0]
 
+  # TODO(maruel): Use apply_issue.py
+
   if re.match(r'\d+', issue_arg):
     # Input is an issue id.  Figure out the URL.
     issue = issue_arg
     patch_data = Changelist().GetPatchSetDiff(issue)
   else:
     # Assume it's a URL to the patch. Default to http.
     issue_url = FixUrl(issue_arg)
     match = re.match(r'.*?/issue(\d+)_\d+.diff', issue_url)
     if not match:
       DieWithError('Must pass an issue ID or full URL for '
@@ skipping 93 matching lines @@
   print
   print GetTreeStatusReason()
   if status != 'open':
     return 1
   return 0
 
 
 def CMDupstream(parser, args):
   """print the name of the upstream branch, if any"""
   _, args = parser.parse_args(args)
+  if args:
+    parser.error('Unrecognized args: %s' % ' '.join(args))
   cl = Changelist()
   print cl.GetUpstreamBranch()
   return 0
 
 
+def CMDset_commit(parser, args):
+  """set the commit bit"""
+  _, args = parser.parse_args(args)
+  if args:
+    parser.error('Unrecognized args: %s' % ' '.join(args))
+  cl = Changelist()
+  cl.SetFlag('commit', '1')
+  return 0
+
+
 def Command(name):
   return getattr(sys.modules[__name__], 'CMD' + name, None)
 
 
 def CMDhelp(parser, args):
   """print list of commands or help for a specific command"""
   _, args = parser.parse_args(args)
   if len(args) == 1:
     return main(args + ['--help'])
   parser.print_help()
@@ skipping 52 matching lines @@
              'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
 
   # Not a known command. Default to help.
   GenUsage(parser, 'help')
   return CMDhelp(parser, argv)
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(main(sys.argv[1:]))