Make git cl patch authenticate the request for the diff.

git_cl.py

 #!/usr/bin/python
 # git-cl -- a git-command for integrating reviews on Rietveld
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 import errno
 import logging
 import optparse
 import os
 import re
 import subprocess
@@ skipping 319 matching lines @@
     else:
       self.branch = None
     self.rietveld_server = None
     self.upstream_branch = None
     self.has_issue = False
     self.issue = None
     self.has_description = False
     self.description = None
     self.has_patchset = False
     self.patchset = None
+    self._rpc_server = None
 
   def GetBranch(self):
     """Returns the short branch name, e.g. 'master'."""
     if not self.branch:
       self.branchref = RunGit(['symbolic-ref', 'HEAD']).strip()
       self.branch = ShortBranchName(self.branchref)
     return self.branch
 
   def GetBranchRef(self):
     """Returns the full branch name, e.g. 'refs/heads/master'."""
@@ skipping 107 matching lines @@
 
   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(
+        '/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()])
       self.SetPatchset(0)
     self.has_issue = False
 
   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'})
 
     # 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', body, ctype)
 
   def _RpcServer(self):
     """Returns an upload.RpcServer() to access this review's rietveld instance.
     """
-    server = self.GetRietveldServer()
-    return upload.GetRpcServer(server, save_cookies=True)
+    if not self._rpc_server:
+      server = self.GetRietveldServer()
+      self._rpc_server = upload.GetRpcServer(server, save_cookies=True)
+    return self._rpc_server
 
   def _IssueSetting(self):
     """Return the git setting that stores this change's issue."""
     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):
@@ skipping 705 matching lines @@
                     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]
 
   if re.match(r'\d+', issue_arg):
     # Input is an issue id.  Figure out the URL.
     issue = issue_arg
-    server = settings.GetDefaultServerUrl()
-    fetch = urllib2.urlopen('%s/%s' % (server, issue)).read()
-    m = re.search(r'/download/issue[0-9]+_[0-9]+.diff', fetch)
-    if not m:
-      DieWithError('Must pass an issue ID or full URL for '
-          '\'Download raw patch set\'')
-    url = '%s%s' % (server, m.group(0).strip())
+    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 match:
-      issue = match.group(1)
-      url = issue_arg
-    else:
+    if not match:
       DieWithError('Must pass an issue ID or full URL for '
           '\'Download raw patch set\'')
+    issue = match.group(1)
+    patch_data = urllib2.urlopen(issue_arg).read()
 
   if options.newbranch:
     if options.force:
       RunGit(['branch', '-D', options.newbranch],
          swallow_stderr=True, error_ok=True)
     RunGit(['checkout', '-b', options.newbranch,
             Changelist().GetUpstreamBranch()])
 
   # Switch up to the top-level directory, if necessary, in preparation for
   # applying the patch.
   top = RunGit(['rev-parse', '--show-cdup']).strip()
   if top:
     os.chdir(top)
 
-  patch_data = urllib2.urlopen(url).read()
   # Git patches have a/ at the beginning of source paths.  We strip that out
   # with a sed script rather than the -p flag to patch so we can feed either
   # Git or svn-style patches into the same apply command.
   # re.sub() should be used but flags=re.MULTILINE is only in python 2.7.
   sed_proc = Popen(['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'],
       stdin=subprocess.PIPE, stdout=subprocess.PIPE)
   patch_data = sed_proc.communicate(patch_data)[0]
   if sed_proc.returncode:
     DieWithError('Git patch mungling failed.')
   logging.info(patch_data)
@@ skipping 138 matching lines @@
             ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
              '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__':
   sys.exit(main(sys.argv[1:]))