Fix upload.py to properly use a local logger

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 60 matching lines @@
   import keyring
 except ImportError:
   keyring = None
 
 # The logging verbosity:
 #  0: Errors only.
 #  1: Status messages.
 #  2: Info logs.
 #  3: Debug logs.
 verbosity = 1
+LOGGER = logging.getLogger('upload')
 
 # The account type used for authentication.
 # This line could be changed by the review server (see handler for
 # upload.py).
 AUTH_ACCOUNT_TYPE = "GOOGLE"
 
 # URL of the default review server. As for AUTH_ACCOUNT_TYPE, this line could be
 # changed by the review server (see handler for upload.py).
 DEFAULT_REVIEW_SERVER = "codereview.appspot.com"
 
@@ skipping 172 matching lines @@
         not self.host.startswith("https://")):
       self.host = "http://" + self.host
     self.host_override = host_override
     self.auth_function = auth_function
     self.authenticated = False
     self.extra_headers = extra_headers or {}
     self.save_cookies = save_cookies
     self.account_type = account_type
     self.opener = self._GetOpener()
     if self.host_override:
-      logging.info("Server: %s; Host: %s", self.host, self.host_override)
+      LOGGER.info("Server: %s; Host: %s", self.host, self.host_override)
     else:
-      logging.info("Server: %s", self.host)
+      LOGGER.info("Server: %s", self.host)
 
   def _GetOpener(self):
     """Returns an OpenerDirector for making HTTP requests.
 
     Returns:
       A urllib2.OpenerDirector object.
     """
     raise NotImplementedError()
 
   def _CreateRequest(self, url, data=None):
     """Creates a new urllib request."""
-    logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
+    LOGGER.debug("Creating request for: '%s' with payload:\n%s", url, data)
     req = urllib2.Request(url, data=data, headers={"Accept": "text/plain"})
     if self.host_override:
       req.add_header("Host", self.host_override)
     for key, value in self.extra_headers.iteritems():
       req.add_header(key, value)
     return req
 
   def _GetAuthToken(self, email, password):
     """Uses ClientLogin to authenticate the user, returning an auth token.
 
@@ skipping 626 matching lines @@
       OAuth, this opens a page in the user's browser to obtain a token.
 
   Returns:
     A new HttpRpcServer, on which RPC calls can be made.
   """
   # 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)
+      LOGGER.info("Using debug user %s.  Override with --email" % email)
     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
@@ skipping 65 matching lines @@
 
   Args:
     command: Command to execute.
     print_output: If True, the output is printed to stdout.
                   If False, both stdout and stderr are ignored.
     universal_newlines: Use universal_newlines flag (default: True).
 
   Returns:
     Tuple (stdout, stderr, return code)
   """
-  logging.info("Running %s", command)
+  LOGGER.info("Running %s", command)
   env = env.copy()
   env['LC_MESSAGES'] = 'C'
   p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                        shell=use_shell, universal_newlines=universal_newlines,
                        env=env)
   if print_output:
     output_array = []
     while True:
       line = p.stdout.readline()
       if not line:
@@ skipping 241 matching lines @@
         if netloc == "svn.python.org" and scheme == "svn+ssh":
           path = "projects" + path
           scheme = "http"
           guess = "Python "
         elif netloc.endswith(".googlecode.com"):
           scheme = "http"
           guess = "Google Code "
         path = path + "/"
         base = urlparse.urlunparse((scheme, netloc, path, params,
                                     query, fragment))
-        logging.info("Guessed %sbase = %s", guess, base)
+        LOGGER.info("Guessed %sbase = %s", guess, base)
         return base
     if required:
       ErrorExit("Can't find URL in output from svn info")
     return None
 
   def _GetInfo(self, key):
     """Parses 'svn info' for current dir. Returns value for key or None"""
     for line in RunShell(["svn", "info"]).splitlines():
       if line.startswith(key + ": "):
         return line.split(":", 1)[1].strip()
 
   def _EscapeFilename(self, filename):
     """Escapes filename for SVN commands."""
     if "@" in filename and not filename.endswith("@"):
       filename = "%s@" % filename
     return filename
 
   def GenerateDiff(self, args):
     cmd = ["svn", "diff"]
     if self.options.revision:
       cmd += ["-r", self.options.revision]
     cmd.extend(args)
     data = RunShell(cmd)
     count = 0
     for line in data.splitlines():
       if line.startswith("Index:") or line.startswith("Property changes on:"):
         count += 1
-        logging.info(line)
+        LOGGER.info(line)
     if not count:
       ErrorExit("No valid patches found in output from svn diff")
     return data
 
   def _CollapseKeywords(self, content, keyword_str):
     """Collapses SVN keywords."""
     # svn cat translates keywords but svn diff doesn't. As a result of this
     # behavior patching.PatchChunks() fails with a chunk mismatch error.
     # This part was originally written by the Review Board development team
     # who had the same problem (http://reviews.review-board.org/r/276/).
@@ skipping 408 matching lines @@
     if self.options.revision:
       cmd += ["-r", self.options.revision]
 
     cmd.extend(extra_args)
     data, retcode = RunShellWithReturnCode(cmd)
     count = 0
     if retcode in [0, 1]:
       for line in data.splitlines():
         if line.startswith("Index:"):
           count += 1
-          logging.info(line)
+          LOGGER.info(line)
 
     if not count:
       ErrorExit("No valid patches found in output from cvs diff")
 
     return data
 
   def GetUnknownFiles(self):
     data, retcode = RunShellWithReturnCode(["cvs", "diff"])
     if retcode not in [0, 1]:
       ErrorExit("Got error status from 'cvs diff':\n%s" % (data,))
@@ skipping 41 matching lines @@
       if m:
         # Modify line to make it look like as it comes from svn diff.
         # With this modification no changes on the server side are required
         # to make upload.py work with Mercurial repos.
         # NOTE: for proper handling of moved/copied files, we have to use
         # the second filename.
         filename = m.group(2)
         svndiff.append("Index: %s" % filename)
         svndiff.append("=" * 67)
         filecount += 1
-        logging.info(line)
+        LOGGER.info(line)
       else:
         svndiff.append(line)
     if not filecount:
       ErrorExit("No valid patches found in output from hg diff")
     return "\n".join(svndiff) + "\n"
 
   def GetUnknownFiles(self):
     """Return a list of files unknown to the VCS."""
     args = []
     status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
@@ skipping 708 matching lines @@
         "For more help, see "
         "http://code.google.com/p/rietveld/wiki/CodeReviewHelp"
         )
       parser.option_groups.remove(parser.get_option_group('--p4_port'))
     parser.print_help()
     sys.exit(0)
 
   global verbosity
   verbosity = options.verbose
   if verbosity >= 3:
-    logging.getLogger().setLevel(logging.DEBUG)
+    LOGGER.setLevel(logging.DEBUG)
   elif verbosity >= 2:
-    logging.getLogger().setLevel(logging.INFO)
+    LOGGER.setLevel(logging.INFO)
 
   vcs = GuessVCS(options)
 
   base = options.base_url
   if isinstance(vcs, SubversionVCS):
     # Guessing the base field is only supported for Subversion.
     # Note: Fetching base files may become deprecated in future releases.
     guessed_base = vcs.GuessBase(options.download_base)
     if base:
       if guessed_base and base != guessed_base:
         print "Using base URL \"%s\" from --base_url instead of \"%s\"" % \
             (base, guessed_base)
     else:
       base = guessed_base
 
   if not base and options.download_base:
     options.download_base = True
-    logging.info("Enabled upload of base file")
+    LOGGER.info("Enabled upload of base file")
   if not options.assume_yes:
     vcs.CheckForUnknownFiles()
   if data is None:
     data = vcs.GenerateDiff(args)
   data = vcs.PostProcessDiff(data)
   if options.print_diffs:
     print "Rietveld diff start:*****"
     print data
     print "Rietveld diff end:*****"
   files = vcs.GetBaseFiles(data)
@@ skipping 11 matching lines @@
                             options.open_oauth2_local_webbrowser)
   form_fields = []
 
   repo_guid = vcs.GetGUID()
   if repo_guid:
     form_fields.append(("repo_guid", repo_guid))
   if base:
     b = urlparse.urlparse(base)
     username, netloc = urllib.splituser(b.netloc)
     if username:
-      logging.info("Removed username from base URL")
+      LOGGER.info("Removed username from base URL")
       base = urlparse.urlunparse((b.scheme, netloc, b.path, b.params,
                                   b.query, b.fragment))
     form_fields.append(("base", base))
   if options.issue:
     form_fields.append(("issue", str(options.issue)))
   if options.email:
     form_fields.append(("user", options.email))
   if options.reviewers:
     for reviewer in options.reviewers.split(','):
       CheckReviewer(reviewer)
@@ skipping 106 matching lines @@
     os.environ['LC_ALL'] = 'C'
     RealMain(sys.argv)
   except KeyboardInterrupt:
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()