code.vuplus.com Git - vuplus_webkit/blob - Source/ThirdParty/gtest/scripts/upload.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 """Tool for uploading diffs from a version control system to the codereview app.
  18
  19 Usage summary: upload.py [options] [-- diff_options]
  20
  21 Diff options are passed to the diff command of the underlying system.
  22
  23 Supported version control systems:
  24   Git
  25   Mercurial
  26   Subversion
  27
  28 It is important for Git/Mercurial users to specify a tree/node/branch to diff
  29 against by using the '--rev' option.
  30 """
  31 # This code is derived from appcfg.py in the App Engine SDK (open source),
  32 # and from ASPN recipe #146306.
  33
  34 import cookielib
  35 import getpass
  36 import logging
  37 import md5
  38 import mimetypes
  39 import optparse
  40 import os
  41 import re
  42 import socket
  43 import subprocess
  44 import sys
  45 import urllib
  46 import urllib2
  47 import urlparse
  48
  49 try:
  50   import readline
  51 except ImportError:
  52   pass
  53
  54 # The logging verbosity:
  55 #  0: Errors only.
  56 #  1: Status messages.
  57 #  2: Info logs.
  58 #  3: Debug logs.
  59 verbosity = 1
  60
  61 # Max size of patch or base file.
  62 MAX_UPLOAD_SIZE = 900 * 1024
  63
  64
  65 def GetEmail(prompt):
  66   """Prompts the user for their email address and returns it.
  67
  68   The last used email address is saved to a file and offered up as a suggestion
  69   to the user. If the user presses enter without typing in anything the last
  70   used email address is used. If the user enters a new address, it is saved
  71   for next time we prompt.
  72
  73   """
  74   last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
  75   last_email = ""
  76   if os.path.exists(last_email_file_name):
  77     try:
  78       last_email_file = open(last_email_file_name, "r")
  79       last_email = last_email_file.readline().strip("\n")
  80       last_email_file.close()
  81       prompt += " [%s]" % last_email
  82     except IOError, e:
  83       pass
  84   email = raw_input(prompt + ": ").strip()
  85   if email:
  86     try:
  87       last_email_file = open(last_email_file_name, "w")
  88       last_email_file.write(email)
  89       last_email_file.close()
  90     except IOError, e:
  91       pass
  92   else:
  93     email = last_email
  94   return email
  95
  96
  97 def StatusUpdate(msg):
  98   """Print a status message to stdout.
  99
 100   If 'verbosity' is greater than 0, print the message.
 101
 102   Args:
 103     msg: The string to print.
 104   """
 105   if verbosity > 0:
 106     print msg
 107
 108
 109 def ErrorExit(msg):
 110   """Print an error message to stderr and exit."""
 111   print >>sys.stderr, msg
 112   sys.exit(1)
 113
 114
 115 class ClientLoginError(urllib2.HTTPError):
 116   """Raised to indicate there was an error authenticating with ClientLogin."""
 117
 118   def __init__(self, url, code, msg, headers, args):
 119     urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
 120     self.args = args
 121     self.reason = args["Error"]
 122
 123
 124 class AbstractRpcServer(object):
 125   """Provides a common interface for a simple RPC server."""
 126
 127   def __init__(self, host, auth_function, host_override=None, extra_headers={},
 128                save_cookies=False):
 129     """Creates a new HttpRpcServer.
 130
 131     Args:
 132       host: The host to send requests to.
 133       auth_function: A function that takes no arguments and returns an
 134         (email, password) tuple when called. Will be called if authentication
 135         is required.
 136       host_override: The host header to send to the server (defaults to host).
 137       extra_headers: A dict of extra headers to append to every request.
 138       save_cookies: If True, save the authentication cookies to local disk.
 139         If False, use an in-memory cookiejar instead.  Subclasses must
 140         implement this functionality.  Defaults to False.
 141     """
 142     self.host = host
 143     self.host_override = host_override
 144     self.auth_function = auth_function
 145     self.authenticated = False
 146     self.extra_headers = extra_headers
 147     self.save_cookies = save_cookies
 148     self.opener = self._GetOpener()
 149     if self.host_override:
 150       logging.info("Server: %s; Host: %s", self.host, self.host_override)
 151     else:
 152       logging.info("Server: %s", self.host)
 153
 154   def _GetOpener(self):
 155     """Returns an OpenerDirector for making HTTP requests.
 156
 157     Returns:
 158       A urllib2.OpenerDirector object.
 159     """
 160     raise NotImplementedError()
 161
 162   def _CreateRequest(self, url, data=None):
 163     """Creates a new urllib request."""
 164     logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
 165     req = urllib2.Request(url, data=data)
 166     if self.host_override:
 167       req.add_header("Host", self.host_override)
 168     for key, value in self.extra_headers.iteritems():
 169       req.add_header(key, value)
 170     return req
 171
 172   def _GetAuthToken(self, email, password):
 173     """Uses ClientLogin to authenticate the user, returning an auth token.
 174
 175     Args:
 176       email:    The user's email address
 177       password: The user's password
 178
 179     Raises:
 180       ClientLoginError: If there was an error authenticating with ClientLogin.
 181       HTTPError: If there was some other form of HTTP error.
 182
 183     Returns:
 184       The authentication token returned by ClientLogin.
 185     """
 186     account_type = "GOOGLE"
 187     if self.host.endswith(".google.com"):
 188       # Needed for use inside Google.
 189       account_type = "HOSTED"
 190     req = self._CreateRequest(
 191         url="https://www.google.com/accounts/ClientLogin",
 192         data=urllib.urlencode({
 193             "Email": email,
 194             "Passwd": password,
 195             "service": "ah",
 196             "source": "rietveld-codereview-upload",
 197             "accountType": account_type,
 198         }),
 199     )
 200     try:
 201       response = self.opener.open(req)
 202       response_body = response.read()
 203       response_dict = dict(x.split("=")
 204                            for x in response_body.split("\n") if x)
 205       return response_dict["Auth"]
 206     except urllib2.HTTPError, e:
 207       if e.code == 403:
 208         body = e.read()
 209         response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
 210         raise ClientLoginError(req.get_full_url(), e.code, e.msg,
 211                                e.headers, response_dict)
 212       else:
 213         raise
 214
 215   def _GetAuthCookie(self, auth_token):
 216     """Fetches authentication cookies for an authentication token.
 217
 218     Args:
 219       auth_token: The authentication token returned by ClientLogin.
 220
 221     Raises:
 222       HTTPError: If there was an error fetching the authentication cookies.
 223     """
 224     # This is a dummy value to allow us to identify when we're successful.
 225     continue_location = "http://localhost/"
 226     args = {"continue": continue_location, "auth": auth_token}
 227     req = self._CreateRequest("http://%s/_ah/login?%s" %
 228                               (self.host, urllib.urlencode(args)))
 229     try:
 230       response = self.opener.open(req)
 231     except urllib2.HTTPError, e:
 232       response = e
 233     if (response.code != 302 or
 234         response.info()["location"] != continue_location):
 235       raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
 236                               response.headers, response.fp)
 237     self.authenticated = True
 238
 239   def _Authenticate(self):
 240     """Authenticates the user.
 241
 242     The authentication process works as follows:
 243      1) We get a username and password from the user
 244      2) We use ClientLogin to obtain an AUTH token for the user
 245         (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
 246      3) We pass the auth token to /_ah/login on the server to obtain an
 247         authentication cookie. If login was successful, it tries to redirect
 248         us to the URL we provided.
 249
 250     If we attempt to access the upload API without first obtaining an
 251     authentication cookie, it returns a 401 response and directs us to
 252     authenticate ourselves with ClientLogin.
 253     """
 254     for i in range(3):
 255       credentials = self.auth_function()
 256       try:
 257         auth_token = self._GetAuthToken(credentials[0], credentials[1])
 258       except ClientLoginError, e:
 259         if e.reason == "BadAuthentication":
 260           print >>sys.stderr, "Invalid username or password."
 261           continue
 262         if e.reason == "CaptchaRequired":
 263           print >>sys.stderr, (
 264               "Please go to\n"
 265               "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
 266               "and verify you are a human.  Then try again.")
 267           break
 268         if e.reason == "NotVerified":
 269           print >>sys.stderr, "Account not verified."
 270           break
 271         if e.reason == "TermsNotAgreed":
 272           print >>sys.stderr, "User has not agreed to TOS."
 273           break
 274         if e.reason == "AccountDeleted":
 275           print >>sys.stderr, "The user account has been deleted."
 276           break
 277         if e.reason == "AccountDisabled":
 278           print >>sys.stderr, "The user account has been disabled."
 279           break
 280         if e.reason == "ServiceDisabled":
 281           print >>sys.stderr, ("The user's access to the service has been "
 282                                "disabled.")
 283           break
 284         if e.reason == "ServiceUnavailable":
 285           print >>sys.stderr, "The service is not available; try again later."
 286           break
 287         raise
 288       self._GetAuthCookie(auth_token)
 289       return
 290
 291   def Send(self, request_path, payload=None,
 292            content_type="application/octet-stream",
 293            timeout=None,
 294            **kwargs):
 295     """Sends an RPC and returns the response.
 296
 297     Args:
 298       request_path: The path to send the request to, eg /api/appversion/create.
 299       payload: The body of the request, or None to send an empty request.
 300       content_type: The Content-Type header to use.
 301       timeout: timeout in seconds; default None i.e. no timeout.
 302         (Note: for large requests on OS X, the timeout doesn't work right.)
 303       kwargs: Any keyword arguments are converted into query string parameters.
 304
 305     Returns:
 306       The response body, as a string.
 307     """
 308     # TODO: Don't require authentication.  Let the server say
 309     # whether it is necessary.
 310     if not self.authenticated:
 311       self._Authenticate()
 312
 313     old_timeout = socket.getdefaulttimeout()
 314     socket.setdefaulttimeout(timeout)
 315     try:
 316       tries = 0
 317       while True:
 318         tries += 1
 319         args = dict(kwargs)
 320         url = "http://%s%s" % (self.host, request_path)
 321         if args:
 322           url += "?" + urllib.urlencode(args)
 323         req = self._CreateRequest(url=url, data=payload)
 324         req.add_header("Content-Type", content_type)
 325         try:
 326           f = self.opener.open(req)
 327           response = f.read()
 328           f.close()
 329           return response
 330         except urllib2.HTTPError, e:
 331           if tries > 3:
 332             raise
 333           elif e.code == 401:
 334             self._Authenticate()
 335 ##           elif e.code >= 500 and e.code < 600:
 336 ##             # Server Error - try again.
 337 ##             continue
 338           else:
 339             raise
 340     finally:
 341       socket.setdefaulttimeout(old_timeout)
 342
 343
 344 class HttpRpcServer(AbstractRpcServer):
 345   """Provides a simplified RPC-style interface for HTTP requests."""
 346
 347   def _Authenticate(self):
 348     """Save the cookie jar after authentication."""
 349     super(HttpRpcServer, self)._Authenticate()
 350     if self.save_cookies:
 351       StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
 352       self.cookie_jar.save()
 353
 354   def _GetOpener(self):
 355     """Returns an OpenerDirector that supports cookies and ignores redirects.
 356
 357     Returns:
 358       A urllib2.OpenerDirector object.
 359     """
 360     opener = urllib2.OpenerDirector()
 361     opener.add_handler(urllib2.ProxyHandler())
 362     opener.add_handler(urllib2.UnknownHandler())
 363     opener.add_handler(urllib2.HTTPHandler())
 364     opener.add_handler(urllib2.HTTPDefaultErrorHandler())
 365     opener.add_handler(urllib2.HTTPSHandler())
 366     opener.add_handler(urllib2.HTTPErrorProcessor())
 367     if self.save_cookies:
 368       self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies")
 369       self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
 370       if os.path.exists(self.cookie_file):
 371         try:
 372           self.cookie_jar.load()
 373           self.authenticated = True
 374           StatusUpdate("Loaded authentication cookies from %s" %
 375                        self.cookie_file)
 376         except (cookielib.LoadError, IOError):
 377           # Failed to load cookies - just ignore them.
 378           pass
 379       else:
 380         # Create an empty cookie file with mode 600
 381         fd = os.open(self.cookie_file, os.O_CREAT, 0600)
 382         os.close(fd)
 383       # Always chmod the cookie file
 384       os.chmod(self.cookie_file, 0600)
 385     else:
 386       # Don't save cookies across runs of update.py.
 387       self.cookie_jar = cookielib.CookieJar()
 388     opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
 389     return opener
 390
 391
 392 parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
 393 parser.add_option("-y", "--assume_yes", action="store_true",
 394                   dest="assume_yes", default=False,
 395                   help="Assume that the answer to yes/no questions is 'yes'.")
 396 # Logging
 397 group = parser.add_option_group("Logging options")
 398 group.add_option("-q", "--quiet", action="store_const", const=0,
 399                  dest="verbose", help="Print errors only.")
 400 group.add_option("-v", "--verbose", action="store_const", const=2,
 401                  dest="verbose", default=1,
 402                  help="Print info level logs (default).")
 403 group.add_option("--noisy", action="store_const", const=3,
 404                  dest="verbose", help="Print all logs.")
 405 # Review server
 406 group = parser.add_option_group("Review server options")
 407 group.add_option("-s", "--server", action="store", dest="server",
 408                  default="codereview.appspot.com",
 409                  metavar="SERVER",
 410                  help=("The server to upload to. The format is host[:port]. "
 411                        "Defaults to 'codereview.appspot.com'."))
 412 group.add_option("-e", "--email", action="store", dest="email",
 413                  metavar="EMAIL", default=None,
 414                  help="The username to use. Will prompt if omitted.")
 415 group.add_option("-H", "--host", action="store", dest="host",
 416                  metavar="HOST", default=None,
 417                  help="Overrides the Host header sent with all RPCs.")
 418 group.add_option("--no_cookies", action="store_false",
 419                  dest="save_cookies", default=True,
 420                  help="Do not save authentication cookies to local disk.")
 421 # Issue
 422 group = parser.add_option_group("Issue options")
 423 group.add_option("-d", "--description", action="store", dest="description",
 424                  metavar="DESCRIPTION", default=None,
 425                  help="Optional description when creating an issue.")
 426 group.add_option("-f", "--description_file", action="store",
 427                  dest="description_file", metavar="DESCRIPTION_FILE",
 428                  default=None,
 429                  help="Optional path of a file that contains "
 430                       "the description when creating an issue.")
 431 group.add_option("-r", "--reviewers", action="store", dest="reviewers",
 432                  metavar="REVIEWERS", default=None,
 433                  help="Add reviewers (comma separated email addresses).")
 434 group.add_option("--cc", action="store", dest="cc",
 435                  metavar="CC", default=None,
 436                  help="Add CC (comma separated email addresses).")
 437 # Upload options
 438 group = parser.add_option_group("Patch options")
 439 group.add_option("-m", "--message", action="store", dest="message",
 440                  metavar="MESSAGE", default=None,
 441                  help="A message to identify the patch. "
 442                       "Will prompt if omitted.")
 443 group.add_option("-i", "--issue", type="int", action="store",
 444                  metavar="ISSUE", default=None,
 445                  help="Issue number to which to add. Defaults to new issue.")
 446 group.add_option("--download_base", action="store_true",
 447                  dest="download_base", default=False,
 448                  help="Base files will be downloaded by the server "
 449                  "(side-by-side diffs may not work on files with CRs).")
 450 group.add_option("--rev", action="store", dest="revision",
 451                  metavar="REV", default=None,
 452                  help="Branch/tree/revision to diff against (used by DVCS).")
 453 group.add_option("--send_mail", action="store_true",
 454                  dest="send_mail", default=False,
 455                  help="Send notification email to reviewers.")
 456
 457
 458 def GetRpcServer(options):
 459   """Returns an instance of an AbstractRpcServer.
 460
 461   Returns:
 462     A new AbstractRpcServer, on which RPC calls can be made.
 463   """
 464
 465   rpc_server_class = HttpRpcServer
 466
 467   def GetUserCredentials():
 468     """Prompts the user for a username and password."""
 469     email = options.email
 470     if email is None:
 471       email = GetEmail("Email (login for uploading to %s)" % options.server)
 472     password = getpass.getpass("Password for %s: " % email)
 473     return (email, password)
 474
 475   # If this is the dev_appserver, use fake authentication.
 476   host = (options.host or options.server).lower()
 477   if host == "localhost" or host.startswith("localhost:"):
 478     email = options.email
 479     if email is None:
 480       email = "test@example.com"
 481       logging.info("Using debug user %s.  Override with --email" % email)
 482     server = rpc_server_class(
 483         options.server,
 484         lambda: (email, "password"),
 485         host_override=options.host,
 486         extra_headers={"Cookie":
 487                        'dev_appserver_login="%s:False"' % email},
 488         save_cookies=options.save_cookies)
 489     # Don't try to talk to ClientLogin.
 490     server.authenticated = True
 491     return server
 492
 493   return rpc_server_class(options.server, GetUserCredentials,
 494                           host_override=options.host,
 495                           save_cookies=options.save_cookies)
 496
 497
 498 def EncodeMultipartFormData(fields, files):
 499   """Encode form fields for multipart/form-data.
 500
 501   Args:
 502     fields: A sequence of (name, value) elements for regular form fields.
 503     files: A sequence of (name, filename, value) elements for data to be
 504            uploaded as files.
 505   Returns:
 506     (content_type, body) ready for httplib.HTTP instance.
 507
 508   Source:
 509     http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
 510   """
 511   BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
 512   CRLF = '\r\n'
 513   lines = []
 514   for (key, value) in fields:
 515     lines.append('--' + BOUNDARY)
 516     lines.append('Content-Disposition: form-data; name="%s"' % key)
 517     lines.append('')
 518     lines.append(value)
 519   for (key, filename, value) in files:
 520     lines.append('--' + BOUNDARY)
 521     lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' %
 522              (key, filename))
 523     lines.append('Content-Type: %s' % GetContentType(filename))
 524     lines.append('')
 525     lines.append(value)
 526   lines.append('--' + BOUNDARY + '--')
 527   lines.append('')
 528   body = CRLF.join(lines)
 529   content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
 530   return content_type, body
 531
 532
 533 def GetContentType(filename):
 534   """Helper to guess the content-type from the filename."""
 535   return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
 536
 537
 538 # Use a shell for subcommands on Windows to get a PATH search.
 539 use_shell = sys.platform.startswith("win")
 540
 541 def RunShellWithReturnCode(command, print_output=False,
 542                            universal_newlines=True):
 543   """Executes a command and returns the output from stdout and the return code.
 544
 545   Args:
 546     command: Command to execute.
 547     print_output: If True, the output is printed to stdout.
 548                   If False, both stdout and stderr are ignored.
 549     universal_newlines: Use universal_newlines flag (default: True).
 550
 551   Returns:
 552     Tuple (output, return code)
 553   """
 554   logging.info("Running %s", command)
 555   p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
 556                        shell=use_shell, universal_newlines=universal_newlines)
 557   if print_output:
 558     output_array = []
 559     while True:
 560       line = p.stdout.readline()
 561       if not line:
 562         break
 563       print line.strip("\n")
 564       output_array.append(line)
 565     output = "".join(output_array)
 566   else:
 567     output = p.stdout.read()
 568   p.wait()
 569   errout = p.stderr.read()
 570   if print_output and errout:
 571     print >>sys.stderr, errout
 572   p.stdout.close()
 573   p.stderr.close()
 574   return output, p.returncode
 575
 576
 577 def RunShell(command, silent_ok=False, universal_newlines=True,
 578              print_output=False):
 579   data, retcode = RunShellWithReturnCode(command, print_output,
 580                                          universal_newlines)
 581   if retcode:
 582     ErrorExit("Got error status from %s:\n%s" % (command, data))
 583   if not silent_ok and not data:
 584     ErrorExit("No output from %s" % command)
 585   return data
 586
 587
 588 class VersionControlSystem(object):
 589   """Abstract base class providing an interface to the VCS."""
 590
 591   def __init__(self, options):
 592     """Constructor.
 593
 594     Args:
 595       options: Command line options.
 596     """
 597     self.options = options
 598
 599   def GenerateDiff(self, args):
 600     """Return the current diff as a string.
 601
 602     Args:
 603       args: Extra arguments to pass to the diff command.
 604     """
 605     raise NotImplementedError(
 606         "abstract method -- subclass %s must override" % self.__class__)
 607
 608   def GetUnknownFiles(self):
 609     """Return a list of files unknown to the VCS."""
 610     raise NotImplementedError(
 611         "abstract method -- subclass %s must override" % self.__class__)
 612
 613   def CheckForUnknownFiles(self):
 614     """Show an "are you sure?" prompt if there are unknown files."""
 615     unknown_files = self.GetUnknownFiles()
 616     if unknown_files:
 617       print "The following files are not added to version control:"
 618       for line in unknown_files:
 619         print line
 620       prompt = "Are you sure to continue?(y/N) "
 621       answer = raw_input(prompt).strip()
 622       if answer != "y":
 623         ErrorExit("User aborted")
 624
 625   def GetBaseFile(self, filename):
 626     """Get the content of the upstream version of a file.
 627
 628     Returns:
 629       A tuple (base_content, new_content, is_binary, status)
 630         base_content: The contents of the base file.
 631         new_content: For text files, this is empty.  For binary files, this is
 632           the contents of the new file, since the diff output won't contain
 633           information to reconstruct the current file.
 634         is_binary: True iff the file is binary.
 635         status: The status of the file.
 636     """
 637
 638     raise NotImplementedError(
 639         "abstract method -- subclass %s must override" % self.__class__)
 640
 641
 642   def GetBaseFiles(self, diff):
 643     """Helper that calls GetBase file for each file in the patch.
 644
 645     Returns:
 646       A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
 647       are retrieved based on lines that start with "Index:" or
 648       "Property changes on:".
 649     """
 650     files = {}
 651     for line in diff.splitlines(True):
 652       if line.startswith('Index:') or line.startswith('Property changes on:'):
 653         unused, filename = line.split(':', 1)
 654         # On Windows if a file has property changes its filename uses '\'
 655         # instead of '/'.
 656         filename = filename.strip().replace('\\', '/')
 657         files[filename] = self.GetBaseFile(filename)
 658     return files
 659
 660
 661   def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
 662                       files):
 663     """Uploads the base files (and if necessary, the current ones as well)."""
 664
 665     def UploadFile(filename, file_id, content, is_binary, status, is_base):
 666       """Uploads a file to the server."""
 667       file_too_large = False
 668       if is_base:
 669         type = "base"
 670       else:
 671         type = "current"
 672       if len(content) > MAX_UPLOAD_SIZE:
 673         print ("Not uploading the %s file for %s because it's too large." %
 674                (type, filename))
 675         file_too_large = True
 676         content = ""
 677       checksum = md5.new(content).hexdigest()
 678       if options.verbose > 0 and not file_too_large:
 679         print "Uploading %s file for %s" % (type, filename)
 680       url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
 681       form_fields = [("filename", filename),
 682                      ("status", status),
 683                      ("checksum", checksum),
 684                      ("is_binary", str(is_binary)),
 685                      ("is_current", str(not is_base)),
 686                     ]
 687       if file_too_large:
 688         form_fields.append(("file_too_large", "1"))
 689       if options.email:
 690         form_fields.append(("user", options.email))
 691       ctype, body = EncodeMultipartFormData(form_fields,
 692                                             [("data", filename, content)])
 693       response_body = rpc_server.Send(url, body,
 694                                       content_type=ctype)
 695       if not response_body.startswith("OK"):
 696         StatusUpdate("  --> %s" % response_body)
 697         sys.exit(1)
 698
 699     patches = dict()
 700     [patches.setdefault(v, k) for k, v in patch_list]
 701     for filename in patches.keys():
 702       base_content, new_content, is_binary, status = files[filename]
 703       file_id_str = patches.get(filename)
 704       if file_id_str.find("nobase") != -1:
 705         base_content = None
 706         file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
 707       file_id = int(file_id_str)
 708       if base_content != None:
 709         UploadFile(filename, file_id, base_content, is_binary, status, True)
 710       if new_content != None:
 711         UploadFile(filename, file_id, new_content, is_binary, status, False)
 712
 713   def IsImage(self, filename):
 714     """Returns true if the filename has an image extension."""
 715     mimetype =  mimetypes.guess_type(filename)[0]
 716     if not mimetype:
 717       return False
 718     return mimetype.startswith("image/")
 719
 720
 721 class SubversionVCS(VersionControlSystem):
 722   """Implementation of the VersionControlSystem interface for Subversion."""
 723
 724   def __init__(self, options):
 725     super(SubversionVCS, self).__init__(options)
 726     if self.options.revision:
 727       match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
 728       if not match:
 729         ErrorExit("Invalid Subversion revision %s." % self.options.revision)
 730       self.rev_start = match.group(1)
 731       self.rev_end = match.group(3)
 732     else:
 733       self.rev_start = self.rev_end = None
 734     # Cache output from "svn list -r REVNO dirname".
 735     # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
 736     self.svnls_cache = {}
 737     # SVN base URL is required to fetch files deleted in an older revision.
 738     # Result is cached to not guess it over and over again in GetBaseFile().
 739     required = self.options.download_base or self.options.revision is not None
 740     self.svn_base = self._GuessBase(required)
 741
 742   def GuessBase(self, required):
 743     """Wrapper for _GuessBase."""
 744     return self.svn_base
 745
 746   def _GuessBase(self, required):
 747     """Returns the SVN base URL.
 748
 749     Args:
 750       required: If true, exits if the url can't be guessed, otherwise None is
 751         returned.
 752     """
 753     info = RunShell(["svn", "info"])
 754     for line in info.splitlines():
 755       words = line.split()
 756       if len(words) == 2 and words[0] == "URL:":
 757         url = words[1]
 758         scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
 759         username, netloc = urllib.splituser(netloc)
 760         if username:
 761           logging.info("Removed username from base URL")
 762         if netloc.endswith("svn.python.org"):
 763           if netloc == "svn.python.org":
 764             if path.startswith("/projects/"):
 765               path = path[9:]
 766           elif netloc != "pythondev@svn.python.org":
 767             ErrorExit("Unrecognized Python URL: %s" % url)
 768           base = "http://svn.python.org/view/*checkout*%s/" % path
 769           logging.info("Guessed Python base = %s", base)
 770         elif netloc.endswith("svn.collab.net"):
 771           if path.startswith("/repos/"):
 772             path = path[6:]
 773           base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
 774           logging.info("Guessed CollabNet base = %s", base)
 775         elif netloc.endswith(".googlecode.com"):
 776           path = path + "/"
 777           base = urlparse.urlunparse(("http", netloc, path, params,
 778                                       query, fragment))
 779           logging.info("Guessed Google Code base = %s", base)
 780         else:
 781           path = path + "/"
 782           base = urlparse.urlunparse((scheme, netloc, path, params,
 783                                       query, fragment))
 784           logging.info("Guessed base = %s", base)
 785         return base
 786     if required:
 787       ErrorExit("Can't find URL in output from svn info")
 788     return None
 789
 790   def GenerateDiff(self, args):
 791     cmd = ["svn", "diff"]
 792     if self.options.revision:
 793       cmd += ["-r", self.options.revision]
 794     cmd.extend(args)
 795     data = RunShell(cmd)
 796     count = 0
 797     for line in data.splitlines():
 798       if line.startswith("Index:") or line.startswith("Property changes on:"):
 799         count += 1
 800         logging.info(line)
 801     if not count:
 802       ErrorExit("No valid patches found in output from svn diff")
 803     return data
 804
 805   def _CollapseKeywords(self, content, keyword_str):
 806     """Collapses SVN keywords."""
 807     # svn cat translates keywords but svn diff doesn't. As a result of this
 808     # behavior patching.PatchChunks() fails with a chunk mismatch error.
 809     # This part was originally written by the Review Board development team
 810     # who had the same problem (http://reviews.review-board.org/r/276/).
 811     # Mapping of keywords to known aliases
 812     svn_keywords = {
 813       # Standard keywords
 814       'Date':                ['Date', 'LastChangedDate'],
 815       'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
 816       'Author':              ['Author', 'LastChangedBy'],
 817       'HeadURL':             ['HeadURL', 'URL'],
 818       'Id':                  ['Id'],
 819
 820       # Aliases
 821       'LastChangedDate':     ['LastChangedDate', 'Date'],
 822       'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
 823       'LastChangedBy':       ['LastChangedBy', 'Author'],
 824       'URL':                 ['URL', 'HeadURL'],
 825     }
 826
 827     def repl(m):
 828        if m.group(2):
 829          return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
 830        return "$%s$" % m.group(1)
 831     keywords = [keyword
 832                 for name in keyword_str.split(" ")
 833                 for keyword in svn_keywords.get(name, [])]
 834     return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
 835
 836   def GetUnknownFiles(self):
 837     status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
 838     unknown_files = []
 839     for line in status.split("\n"):
 840       if line and line[0] == "?":
 841         unknown_files.append(line)
 842     return unknown_files
 843
 844   def ReadFile(self, filename):
 845     """Returns the contents of a file."""
 846     file = open(filename, 'rb')
 847     result = ""
 848     try:
 849       result = file.read()
 850     finally:
 851       file.close()
 852     return result
 853
 854   def GetStatus(self, filename):
 855     """Returns the status of a file."""
 856     if not self.options.revision:
 857       status = RunShell(["svn", "status", "--ignore-externals", filename])
 858       if not status:
 859         ErrorExit("svn status returned no output for %s" % filename)
 860       status_lines = status.splitlines()
 861       # If file is in a cl, the output will begin with
 862       # "\n--- Changelist 'cl_name':\n".  See
 863       # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
 864       if (len(status_lines) == 3 and
 865           not status_lines[0] and
 866           status_lines[1].startswith("--- Changelist")):
 867         status = status_lines[2]
 868       else:
 869         status = status_lines[0]
 870     # If we have a revision to diff against we need to run "svn list"
 871     # for the old and the new revision and compare the results to get
 872     # the correct status for a file.
 873     else:
 874       dirname, relfilename = os.path.split(filename)
 875       if dirname not in self.svnls_cache:
 876         cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
 877         out, returncode = RunShellWithReturnCode(cmd)
 878         if returncode:
 879           ErrorExit("Failed to get status for %s." % filename)
 880         old_files = out.splitlines()
 881         args = ["svn", "list"]
 882         if self.rev_end:
 883           args += ["-r", self.rev_end]
 884         cmd = args + [dirname or "."]
 885         out, returncode = RunShellWithReturnCode(cmd)
 886         if returncode:
 887           ErrorExit("Failed to run command %s" % cmd)
 888         self.svnls_cache[dirname] = (old_files, out.splitlines())
 889       old_files, new_files = self.svnls_cache[dirname]
 890       if relfilename in old_files and relfilename not in new_files:
 891         status = "D   "
 892       elif relfilename in old_files and relfilename in new_files:
 893         status = "M   "
 894       else:
 895         status = "A   "
 896     return status
 897
 898   def GetBaseFile(self, filename):
 899     status = self.GetStatus(filename)
 900     base_content = None
 901     new_content = None
 902
 903     # If a file is copied its status will be "A  +", which signifies
 904     # "addition-with-history".  See "svn st" for more information.  We need to
 905     # upload the original file or else diff parsing will fail if the file was
 906     # edited.
 907     if status[0] == "A" and status[3] != "+":
 908       # We'll need to upload the new content if we're adding a binary file
 909       # since diff's output won't contain it.
 910       mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
 911                           silent_ok=True)
 912       base_content = ""
 913       is_binary = mimetype and not mimetype.startswith("text/")
 914       if is_binary and self.IsImage(filename):
 915         new_content = self.ReadFile(filename)
 916     elif (status[0] in ("M", "D", "R") or
 917           (status[0] == "A" and status[3] == "+") or  # Copied file.
 918           (status[0] == " " and status[1] == "M")):  # Property change.
 919       args = []
 920       if self.options.revision:
 921         url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
 922       else:
 923         # Don't change filename, it's needed later.
 924         url = filename
 925         args += ["-r", "BASE"]
 926       cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
 927       mimetype, returncode = RunShellWithReturnCode(cmd)
 928       if returncode:
 929         # File does not exist in the requested revision.
 930         # Reset mimetype, it contains an error message.
 931         mimetype = ""
 932       get_base = False
 933       is_binary = mimetype and not mimetype.startswith("text/")
 934       if status[0] == " ":
 935         # Empty base content just to force an upload.
 936         base_content = ""
 937       elif is_binary:
 938         if self.IsImage(filename):
 939           get_base = True
 940           if status[0] == "M":
 941             if not self.rev_end:
 942               new_content = self.ReadFile(filename)
 943             else:
 944               url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
 945               new_content = RunShell(["svn", "cat", url],
 946                                      universal_newlines=True, silent_ok=True)
 947         else:
 948           base_content = ""
 949       else:
 950         get_base = True
 951
 952       if get_base:
 953         if is_binary:
 954           universal_newlines = False
 955         else:
 956           universal_newlines = True
 957         if self.rev_start:
 958           # "svn cat -r REV delete_file.txt" doesn't work. cat requires
 959           # the full URL with "@REV" appended instead of using "-r" option.
 960           url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
 961           base_content = RunShell(["svn", "cat", url],
 962                                   universal_newlines=universal_newlines,
 963                                   silent_ok=True)
 964         else:
 965           base_content = RunShell(["svn", "cat", filename],
 966                                   universal_newlines=universal_newlines,
 967                                   silent_ok=True)
 968         if not is_binary:
 969           args = []
 970           if self.rev_start:
 971             url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
 972           else:
 973             url = filename
 974             args += ["-r", "BASE"]
 975           cmd = ["svn"] + args + ["propget", "svn:keywords", url]
 976           keywords, returncode = RunShellWithReturnCode(cmd)
 977           if keywords and not returncode:
 978             base_content = self._CollapseKeywords(base_content, keywords)
 979     else:
 980       StatusUpdate("svn status returned unexpected output: %s" % status)
 981       sys.exit(1)
 982     return base_content, new_content, is_binary, status[0:5]
 983
 984
 985 class GitVCS(VersionControlSystem):
 986   """Implementation of the VersionControlSystem interface for Git."""
 987
 988   def __init__(self, options):
 989     super(GitVCS, self).__init__(options)
 990     # Map of filename -> hash of base file.
 991     self.base_hashes = {}
 992
 993   def GenerateDiff(self, extra_args):
 994     # This is more complicated than svn's GenerateDiff because we must convert
 995     # the diff output to include an svn-style "Index:" line as well as record
 996     # the hashes of the base files, so we can upload them along with our diff.
 997     if self.options.revision:
 998       extra_args = [self.options.revision] + extra_args
 999     gitdiff = RunShell(["git", "diff", "--full-index"] + extra_args)
1000     svndiff = []
1001     filecount = 0
1002     filename = None
1003     for line in gitdiff.splitlines():
1004       match = re.match(r"diff --git a/(.*) b/.*$", line)
1005       if match:
1006         filecount += 1
1007         filename = match.group(1)
1008         svndiff.append("Index: %s\n" % filename)
1009       else:
1010         # The "index" line in a git diff looks like this (long hashes elided):
1011         #   index 82c0d44..b2cee3f 100755
1012         # We want to save the left hash, as that identifies the base file.
1013         match = re.match(r"index (\w+)\.\.", line)
1014         if match:
1015           self.base_hashes[filename] = match.group(1)
1016       svndiff.append(line + "\n")
1017     if not filecount:
1018       ErrorExit("No valid patches found in output from git diff")
1019     return "".join(svndiff)
1020
1021   def GetUnknownFiles(self):
1022     status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
1023                       silent_ok=True)
1024     return status.splitlines()
1025
1026   def GetBaseFile(self, filename):
1027     hash = self.base_hashes[filename]
1028     base_content = None
1029     new_content = None
1030     is_binary = False
1031     if hash == "0" * 40:  # All-zero hash indicates no base file.
1032       status = "A"
1033       base_content = ""
1034     else:
1035       status = "M"
1036       base_content, returncode = RunShellWithReturnCode(["git", "show", hash])
1037       if returncode:
1038         ErrorExit("Got error status from 'git show %s'" % hash)
1039     return (base_content, new_content, is_binary, status)
1040
1041
1042 class MercurialVCS(VersionControlSystem):
1043   """Implementation of the VersionControlSystem interface for Mercurial."""
1044
1045   def __init__(self, options, repo_dir):
1046     super(MercurialVCS, self).__init__(options)
1047     # Absolute path to repository (we can be in a subdir)
1048     self.repo_dir = os.path.normpath(repo_dir)
1049     # Compute the subdir
1050     cwd = os.path.normpath(os.getcwd())
1051     assert cwd.startswith(self.repo_dir)
1052     self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
1053     if self.options.revision:
1054       self.base_rev = self.options.revision
1055     else:
1056       self.base_rev = RunShell(["hg", "parent", "-q"]).split(':')[1].strip()
1057
1058   def _GetRelPath(self, filename):
1059     """Get relative path of a file according to the current directory,
1060     given its logical path in the repo."""
1061     assert filename.startswith(self.subdir), filename
1062     return filename[len(self.subdir):].lstrip(r"\/")
1063
1064   def GenerateDiff(self, extra_args):
1065     # If no file specified, restrict to the current subdir
1066     extra_args = extra_args or ["."]
1067     cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
1068     data = RunShell(cmd, silent_ok=True)
1069     svndiff = []
1070     filecount = 0
1071     for line in data.splitlines():
1072       m = re.match("diff --git a/(\S+) b/(\S+)", line)
1073       if m:
1074         # Modify line to make it look like as it comes from svn diff.
1075         # With this modification no changes on the server side are required
1076         # to make upload.py work with Mercurial repos.
1077         # NOTE: for proper handling of moved/copied files, we have to use
1078         # the second filename.
1079         filename = m.group(2)
1080         svndiff.append("Index: %s" % filename)
1081         svndiff.append("=" * 67)
1082         filecount += 1
1083         logging.info(line)
1084       else:
1085         svndiff.append(line)
1086     if not filecount:
1087       ErrorExit("No valid patches found in output from hg diff")
1088     return "\n".join(svndiff) + "\n"
1089
1090   def GetUnknownFiles(self):
1091     """Return a list of files unknown to the VCS."""
1092     args = []
1093     status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
1094         silent_ok=True)
1095     unknown_files = []
1096     for line in status.splitlines():
1097       st, fn = line.split(" ", 1)
1098       if st == "?":
1099         unknown_files.append(fn)
1100     return unknown_files
1101
1102   def GetBaseFile(self, filename):
1103     # "hg status" and "hg cat" both take a path relative to the current subdir
1104     # rather than to the repo root, but "hg diff" has given us the full path
1105     # to the repo root.
1106     base_content = ""
1107     new_content = None
1108     is_binary = False
1109     oldrelpath = relpath = self._GetRelPath(filename)
1110     # "hg status -C" returns two lines for moved/copied files, one otherwise
1111     out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
1112     out = out.splitlines()
1113     # HACK: strip error message about missing file/directory if it isn't in
1114     # the working copy
1115     if out[0].startswith('%s: ' % relpath):
1116       out = out[1:]
1117     if len(out) > 1:
1118       # Moved/copied => considered as modified, use old filename to
1119       # retrieve base contents
1120       oldrelpath = out[1].strip()
1121       status = "M"
1122     else:
1123       status, _ = out[0].split(' ', 1)
1124     if status != "A":
1125       base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
1126         silent_ok=True)
1127       is_binary = "\0" in base_content  # Mercurial's heuristic
1128     if status != "R":
1129       new_content = open(relpath, "rb").read()
1130       is_binary = is_binary or "\0" in new_content
1131     if is_binary and base_content:
1132       # Fetch again without converting newlines
1133       base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
1134         silent_ok=True, universal_newlines=False)
1135     if not is_binary or not self.IsImage(relpath):
1136       new_content = None
1137     return base_content, new_content, is_binary, status
1138
1139
1140 # NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
1141 def SplitPatch(data):
1142   """Splits a patch into separate pieces for each file.
1143
1144   Args:
1145     data: A string containing the output of svn diff.
1146
1147   Returns:
1148     A list of 2-tuple (filename, text) where text is the svn diff output
1149       pertaining to filename.
1150   """
1151   patches = []
1152   filename = None
1153   diff = []
1154   for line in data.splitlines(True):
1155     new_filename = None
1156     if line.startswith('Index:'):
1157       unused, new_filename = line.split(':', 1)
1158       new_filename = new_filename.strip()
1159     elif line.startswith('Property changes on:'):
1160       unused, temp_filename = line.split(':', 1)
1161       # When a file is modified, paths use '/' between directories, however
1162       # when a property is modified '\' is used on Windows.  Make them the same
1163       # otherwise the file shows up twice.
1164       temp_filename = temp_filename.strip().replace('\\', '/')
1165       if temp_filename != filename:
1166         # File has property changes but no modifications, create a new diff.
1167         new_filename = temp_filename
1168     if new_filename:
1169       if filename and diff:
1170         patches.append((filename, ''.join(diff)))
1171       filename = new_filename
1172       diff = [line]
1173       continue
1174     if diff is not None:
1175       diff.append(line)
1176   if filename and diff:
1177     patches.append((filename, ''.join(diff)))
1178   return patches
1179
1180
1181 def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
1182   """Uploads a separate patch for each file in the diff output.
1183
1184   Returns a list of [patch_key, filename] for each file.
1185   """
1186   patches = SplitPatch(data)
1187   rv = []
1188   for patch in patches:
1189     if len(patch[1]) > MAX_UPLOAD_SIZE:
1190       print ("Not uploading the patch for " + patch[0] +
1191              " because the file is too large.")
1192       continue
1193     form_fields = [("filename", patch[0])]
1194     if not options.download_base:
1195       form_fields.append(("content_upload", "1"))
1196     files = [("data", "data.diff", patch[1])]
1197     ctype, body = EncodeMultipartFormData(form_fields, files)
1198     url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
1199     print "Uploading patch for " + patch[0]
1200     response_body = rpc_server.Send(url, body, content_type=ctype)
1201     lines = response_body.splitlines()
1202     if not lines or lines[0] != "OK":
1203       StatusUpdate("  --> %s" % response_body)
1204       sys.exit(1)
1205     rv.append([lines[1], patch[0]])
1206   return rv
1207
1208
1209 def GuessVCS(options):
1210   """Helper to guess the version control system.
1211
1212   This examines the current directory, guesses which VersionControlSystem
1213   we're using, and returns an instance of the appropriate class.  Exit with an
1214   error if we can't figure it out.
1215
1216   Returns:
1217     A VersionControlSystem instance. Exits if the VCS can't be guessed.
1218   """
1219   # Mercurial has a command to get the base directory of a repository
1220   # Try running it, but don't die if we don't have hg installed.
1221   # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
1222   try:
1223     out, returncode = RunShellWithReturnCode(["hg", "root"])
1224     if returncode == 0:
1225       return MercurialVCS(options, out.strip())
1226   except OSError, (errno, message):
1227     if errno != 2:  # ENOENT -- they don't have hg installed.
1228       raise
1229
1230   # Subversion has a .svn in all working directories.
1231   if os.path.isdir('.svn'):
1232     logging.info("Guessed VCS = Subversion")
1233     return SubversionVCS(options)
1234
1235   # Git has a command to test if you're in a git tree.
1236   # Try running it, but don't die if we don't have git installed.
1237   try:
1238     out, returncode = RunShellWithReturnCode(["git", "rev-parse",
1239                                               "--is-inside-work-tree"])
1240     if returncode == 0:
1241       return GitVCS(options)
1242   except OSError, (errno, message):
1243     if errno != 2:  # ENOENT -- they don't have git installed.
1244       raise
1245
1246   ErrorExit(("Could not guess version control system. "
1247              "Are you in a working copy directory?"))
1248
1249
1250 def RealMain(argv, data=None):
1251   """The real main function.
1252
1253   Args:
1254     argv: Command line arguments.
1255     data: Diff contents. If None (default) the diff is generated by
1256       the VersionControlSystem implementation returned by GuessVCS().
1257
1258   Returns:
1259     A 2-tuple (issue id, patchset id).
1260     The patchset id is None if the base files are not uploaded by this
1261     script (applies only to SVN checkouts).
1262   """
1263   logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
1264                               "%(lineno)s %(message)s "))
1265   os.environ['LC_ALL'] = 'C'
1266   options, args = parser.parse_args(argv[1:])
1267   global verbosity
1268   verbosity = options.verbose
1269   if verbosity >= 3:
1270     logging.getLogger().setLevel(logging.DEBUG)
1271   elif verbosity >= 2:
1272     logging.getLogger().setLevel(logging.INFO)
1273   vcs = GuessVCS(options)
1274   if isinstance(vcs, SubversionVCS):
1275     # base field is only allowed for Subversion.
1276     # Note: Fetching base files may become deprecated in future releases.
1277     base = vcs.GuessBase(options.download_base)
1278   else:
1279     base = None
1280   if not base and options.download_base:
1281     options.download_base = True
1282     logging.info("Enabled upload of base file")
1283   if not options.assume_yes:
1284     vcs.CheckForUnknownFiles()
1285   if data is None:
1286     data = vcs.GenerateDiff(args)
1287   files = vcs.GetBaseFiles(data)
1288   if verbosity >= 1:
1289     print "Upload server:", options.server, "(change with -s/--server)"
1290   if options.issue:
1291     prompt = "Message describing this patch set: "
1292   else:
1293     prompt = "New issue subject: "
1294   message = options.message or raw_input(prompt).strip()
1295   if not message:
1296     ErrorExit("A non-empty message is required")
1297   rpc_server = GetRpcServer(options)
1298   form_fields = [("subject", message)]
1299   if base:
1300     form_fields.append(("base", base))
1301   if options.issue:
1302     form_fields.append(("issue", str(options.issue)))
1303   if options.email:
1304     form_fields.append(("user", options.email))
1305   if options.reviewers:
1306     for reviewer in options.reviewers.split(','):
1307       if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
1308         ErrorExit("Invalid email address: %s" % reviewer)
1309     form_fields.append(("reviewers", options.reviewers))
1310   if options.cc:
1311     for cc in options.cc.split(','):
1312       if "@" in cc and not cc.split("@")[1].count(".") == 1:
1313         ErrorExit("Invalid email address: %s" % cc)
1314     form_fields.append(("cc", options.cc))
1315   description = options.description
1316   if options.description_file:
1317     if options.description:
1318       ErrorExit("Can't specify description and description_file")
1319     file = open(options.description_file, 'r')
1320     description = file.read()
1321     file.close()
1322   if description:
1323     form_fields.append(("description", description))
1324   # Send a hash of all the base file so the server can determine if a copy
1325   # already exists in an earlier patchset.
1326   base_hashes = ""
1327   for file, info in files.iteritems():
1328     if not info[0] is None:
1329       checksum = md5.new(info[0]).hexdigest()
1330       if base_hashes:
1331         base_hashes += "|"
1332       base_hashes += checksum + ":" + file
1333   form_fields.append(("base_hashes", base_hashes))
1334   # If we're uploading base files, don't send the email before the uploads, so
1335   # that it contains the file status.
1336   if options.send_mail and options.download_base:
1337     form_fields.append(("send_mail", "1"))
1338   if not options.download_base:
1339     form_fields.append(("content_upload", "1"))
1340   if len(data) > MAX_UPLOAD_SIZE:
1341     print "Patch is large, so uploading file patches separately."
1342     uploaded_diff_file = []
1343     form_fields.append(("separate_patches", "1"))
1344   else:
1345     uploaded_diff_file = [("data", "data.diff", data)]
1346   ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
1347   response_body = rpc_server.Send("/upload", body, content_type=ctype)
1348   patchset = None
1349   if not options.download_base or not uploaded_diff_file:
1350     lines = response_body.splitlines()
1351     if len(lines) >= 2:
1352       msg = lines[0]
1353       patchset = lines[1].strip()
1354       patches = [x.split(" ", 1) for x in lines[2:]]
1355     else:
1356       msg = response_body
1357   else:
1358     msg = response_body
1359   StatusUpdate(msg)
1360   if not response_body.startswith("Issue created.") and \
1361   not response_body.startswith("Issue updated."):
1362     sys.exit(0)
1363   issue = msg[msg.rfind("/")+1:]
1364
1365   if not uploaded_diff_file:
1366     result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
1367     if not options.download_base:
1368       patches = result
1369
1370   if not options.download_base:
1371     vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
1372     if options.send_mail:
1373       rpc_server.Send("/" + issue + "/mail", payload="")
1374   return issue, patchset
1375
1376
1377 def main():
1378   try:
1379     RealMain(sys.argv)
1380   except KeyboardInterrupt:
1381     print
1382     StatusUpdate("Interrupted.")
1383     sys.exit(1)
1384
1385
1386 if __name__ == "__main__":
1387   main()