Update upload.py from upstream at 40853b0f868a.

third_party/upload.py

 #!/usr/bin/env python
 # coding: utf-8
 #
 # Copyright 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 152 matching lines @@
   """Raised to indicate there was an error authenticating with ClientLogin."""
 
   def __init__(self, url, code, msg, headers, args):
     urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
     self.args = args
     self._reason = args["Error"]
     self.info = args.get("Info", None)
 
   @property
   def reason(self):
+    # reason is a property on python 2.7 but a member variable on <=2.6.
+    # self.args is modified so it cannot be used as-is so save the value in
+    # self._reason.
     return self._reason
 
 
 class AbstractRpcServer(object):
   """Provides a common interface for a simple RPC server."""
 
   def __init__(self, host, auth_function, host_override=None, extra_headers={},
                save_cookies=False, account_type=AUTH_ACCOUNT_TYPE):
-    """Creates a new HttpRpcServer.
+    """Creates a new AbstractRpcServer.
 
     Args:
       host: The host to send requests to.
       auth_function: A function that takes no arguments and returns an
         (email, password) tuple when called. Will be called if authentication
         is required.
       host_override: The host header to send to the server (defaults to host).
       extra_headers: A dict of extra headers to append to every request.
       save_cookies: If True, save the authentication cookies to local disk.
         If False, use an in-memory cookiejar instead.  Subclasses must
@@ skipping 400 matching lines @@
 group.add_option("--p4_changelist", action="store", dest="p4_changelist",
                  metavar="P4_CHANGELIST", default=None,
                  help=("Perforce changelist id"))
 group.add_option("--p4_client", action="store", dest="p4_client",
                  metavar="P4_CLIENT", default=None,
                  help=("Perforce client/workspace"))
 group.add_option("--p4_user", action="store", dest="p4_user",
                  metavar="P4_USER", default=None,
                  help=("Perforce user"))
 
+
+class KeyringCreds(object):
+  def __init__(self, server, host, email):
+    self.server = server
+    self.host = host
+    self.email = email
+    self.accounts_seen = set()
+
+  def GetUserCredentials(self):
+    """Prompts the user for a username and password.
+
+    Only use keyring on the initial call. If the keyring contains the wrong
+    password, we want to give the user a chance to enter another one.
+    """
+    # Create a local alias to the email variable to avoid Python's crazy
+    # scoping rules.
+    global keyring
+    email = self.email
+    if email is None:
+      email = GetEmail("Email (login for uploading to %s)" % self.server)
+    password = None
+    if keyring and not email in self.accounts_seen:
+      try:
+        password = keyring.get_password(self.host, email)
+      except:
+        # Sadly, we have to trap all errors here as
+        # gnomekeyring.IOError inherits from object. :/
+        print "Failed to get password from keyring"
+        keyring = None
+    if password is not None:
+      print "Using password from system keyring."
+      self.accounts_seen.add(email)
+    else:
+      password = getpass.getpass("Password for %s: " % email)
+      if keyring:
+        answer = raw_input("Store password in system keyring?(y/N) ").strip()
+        if answer == "y":
+          keyring.set_password(host, email, password)
+          self.accounts_seen.add(email)
+    return (email, password)
+
+
 def GetRpcServer(server, email=None, host_override=None, save_cookies=True,
                  account_type=AUTH_ACCOUNT_TYPE):
   """Returns an instance of an AbstractRpcServer.
 
   Args:
     server: String containing the review server URL.
     email: String containing user's email address.
     host_override: If not None, string containing an alternate hostname to use
       in the host header.
     save_cookies: Whether authentication cookies should be saved to disk.
     account_type: Account type for authentication, either 'GOOGLE'
       or 'HOSTED'. Defaults to AUTH_ACCOUNT_TYPE.
 
   Returns:
-    A new AbstractRpcServer, on which RPC calls can be made.
+    A new HttpRpcServer, on which RPC calls can be made.
   """
 
-  rpc_server_class = HttpRpcServer
-
   # If this is the dev_appserver, use fake authentication.
   host = (host_override or server).lower()
   if re.match(r'(http://)?localhost([:/]|$)', host):
     if email is None:
       email = "test@example.com"
       logging.info("Using debug user %s.  Override with --email" % email)
-    server = rpc_server_class(
+    server = HttpRpcServer(
         server,
         lambda: (email, "password"),
         host_override=host_override,
         extra_headers={"Cookie":
                        'dev_appserver_login="%s:False"' % email},
         save_cookies=save_cookies,
         account_type=account_type)
     # Don't try to talk to ClientLogin.
     server.authenticated = True
     return server
 
-  def GetUserCredentials():
-    """Prompts the user for a username and password."""
-    # Create a local alias to the email variable to avoid Python's crazy
-    # scoping rules.
-    global keyring
-    local_email = email
-    if local_email is None:
-      local_email = GetEmail("Email (login for uploading to %s)" % server)
-    password = None
-    if keyring:
-      try:
-        password = keyring.get_password(host, local_email)
-      except:
-        # Sadly, we have to trap all errors here as
-        # gnomekeyring.IOError inherits from object. :/
-        print "Failed to get password from keyring"
-        keyring = None
-    if password is not None:
-      print "Using password from system keyring."
-    else:
-      password = getpass.getpass("Password for %s: " % local_email)
-      if keyring:
-        answer = raw_input("Store password in system keyring?(y/N) ").strip()
-        if answer == "y":
-          keyring.set_password(host, local_email, password)
-    return (local_email, password)
-
-  return rpc_server_class(server,
-                          GetUserCredentials,
-                          host_override=host_override,
-                          save_cookies=save_cookies)
+  return HttpRpcServer(server,
+                       KeyringCreds(server, host, email).GetUserCredentials,
+                       host_override=host_override,
+                       save_cookies=save_cookies)
 
 
 def EncodeMultipartFormData(fields, files):
   """Encode form fields for multipart/form-data.
 
   Args:
     fields: A sequence of (name, value) elements for regular form fields.
     files: A sequence of (name, filename, value) elements for data to be
            uploaded as files.
   Returns:
@@ skipping 612 matching lines @@
     if self.options.revision:
       if ":" in self.options.revision:
         extra_args = self.options.revision.split(":", 1) + extra_args
       else:
         extra_args = [self.options.revision] + extra_args
 
     # --no-ext-diff is broken in some versions of Git, so try to work around
     # this by overriding the environment (but there is still a problem if the
     # git config key "diff.external" is used).
     env = os.environ.copy()
-    if 'GIT_EXTERNAL_DIFF' in env: del env['GIT_EXTERNAL_DIFF']
+    if "GIT_EXTERNAL_DIFF" in env:
+      del env["GIT_EXTERNAL_DIFF"]
     # -M/-C will not print the diff for the deleted file when a file is renamed.
     # This is confusing because the original file will not be shown on the
-    # review when a file is renamed. So first get the diff of all deleted files,
-    # then the diff of everything except deleted files with rename and copy
-    # support enabled.
+    # review when a file is renamed. So, get a diff with ONLY deletes, then
+    # append a diff (with rename detection), without deletes.
     cmd = [
         "git", "diff", "--no-color", "--no-ext-diff", "--full-index",
         "--ignore-submodules",
     ]
     diff = RunShell(
-        cmd + ["--diff-filter=D"] + extra_args, env=env, silent_ok=True)
+        cmd + ["--no-renames", "--diff-filter=D"] + extra_args,
+        env=env, silent_ok=True)
     diff += RunShell(
-        cmd + ["--find-copies-harder", "--diff-filter=ACMRT"] + extra_args,
+        cmd + ["--find-copies-harder", "-l100000", "--diff-filter=AMCRT"]
+            + extra_args,
         env=env, silent_ok=True)
+
     # The CL could be only file deletion or not. So accept silent diff for both
     # commands then check for an empty diff manually.
     if not diff:
       ErrorExit("No output from %s" % (cmd + extra_args))
     return diff
 
   def GetUnknownFiles(self):
     status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
                       silent_ok=True)
     return status.splitlines()
@@ skipping 1025 matching lines @@
     os.environ['LC_ALL'] = 'C'
     RealMain(sys.argv)
   except KeyboardInterrupt:
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()