remove all uses of Python's logging module until we resolve http://skbug.com/2784

py/utils/gs_utils.py

 #!/usr/bin/python
 
 # pylint: disable=C0301
 """
 Copyright 2014 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Utilities for accessing Google Cloud Storage, using the boto library (wrapper
 for the XML API).
 
 API/library references:
 - https://developers.google.com/storage/docs/reference-guide
 - http://googlecloudstorage.blogspot.com/2012/09/google-cloud-storage-tutorial-using-boto.html
 """
 # pylint: enable=C0301
 
 # System-level imports
 import errno
 import hashlib
-import logging
 import os
 import posixpath
 import Queue
 import re
 import sys
 import threading
 
 # Imports from third-party code
 TRUNK_DIRECTORY = os.path.abspath(os.path.join(
     os.path.dirname(__file__), os.pardir, os.pardir))
@@ skipping 86 matching lines @@
     take longer than just uploading the file.
     See http://skbug.com/2778 ('gs_utils: when uploading IF_NEW, batch up
     checks for existing files within a single remote directory')
     """
     ALWAYS = 1      # always upload the file
     IF_NEW = 2      # if there is an existing file with the same name,
                     # leave it alone
     IF_MODIFIED = 3 # if there is an existing file with the same name and
                     # contents, leave it alone
 
-  def __init__(self, boto_file_path=None, logger=None):
+  def __init__(self, boto_file_path=None):
     """Constructor.
 
     Params:
       boto_file_path: full path (local-OS-style) on local disk where .boto
           credentials file can be found.  If None, then the GSUtils object
           created will be able to access only public files in Google Storage.
-      logger: a logging.Logger instance to use for logging output; if None,
-          one will be created with default characteristics
 
     Raises an exception if no file is found at boto_file_path, or if the file
     found there is malformed.
     """
-    self.logger = logger or logging.getLogger(__name__)
     self._gs_access_key_id = None
     self._gs_secret_access_key = None
     if boto_file_path:
-      self.logger.info('Reading boto file from %s' % boto_file_path)
+      print ('Reading boto file from %s' % boto_file_path)
       boto_dict = _config_file_as_dict(filepath=boto_file_path)
       self._gs_access_key_id = boto_dict['gs_access_key_id']
       self._gs_secret_access_key = boto_dict['gs_secret_access_key']
     # Which field we get/set in ACL entries, depending on IdType.
     self._field_by_id_type = {
         self.IdType.GROUP_BY_DOMAIN: 'domain',
         self.IdType.GROUP_BY_EMAIL:  'email_address',
         self.IdType.GROUP_BY_ID:     'id',
         self.IdType.USER_BY_EMAIL:   'email_address',
         self.IdType.USER_BY_ID:      'id',
@@ skipping 64 matching lines @@
     so that HTTP downloads of the file would be unzipped automatically.
     See https://developers.google.com/storage/docs/gsutil/addlhelp/
         WorkingWithObjectMetadata#content-encoding
     """
     b = self._connect_to_bucket(bucket=dest_bucket)
     local_md5 = None  # filled in lazily
 
     if upload_if == self.UploadIf.IF_NEW:
       old_key = b.get_key(key_name=dest_path)
       if old_key:
-        self.logger.info('Skipping upload of existing file gs://%s/%s' % (
+        print ('Skipping upload of existing file gs://%s/%s' % (
             b.name, dest_path))
         return
     elif upload_if == self.UploadIf.IF_MODIFIED:
       old_key = b.get_key(key_name=dest_path)
       if old_key:
         if not local_md5:
           local_md5 = _get_local_md5(path=source_path)
         if ('"%s"' % local_md5) == old_key.etag:
-          self.logger.info(
+          print (
               'Skipping upload of unmodified file gs://%s/%s : %s' % (
                   b.name, dest_path, local_md5))
           return
     elif upload_if != self.UploadIf.ALWAYS:
       raise Exception('unknown value of upload_if: %s' % upload_if)
 
     # Upload the file using a temporary name at first, in case the transfer
     # is interrupted partway through.
     if not local_md5:
       local_md5 = _get_local_md5(path=source_path)
@@ skipping 103 matching lines @@
           local_md5 = '"%s"' % _get_local_md5(path=os.path.join(
               source_dir, rel_path))
           key = existing_dest_filemap[rel_path]
           if local_md5 == key.etag:
             source_fileset.remove(rel_path)
       else:
         raise Exception('unknown value of upload_if: %s' % upload_if)
 
     # Upload any files still in source_fileset.
     num_files_to_upload = len(source_fileset)
-    self.logger.info('Uploading %d files, skipping %d ...' % (
+    print ('Uploading %d files, skipping %d ...' % (
         num_files_to_upload, num_files_total - num_files_to_upload))
     if num_files_to_upload == 0:
       return
     if num_threads > num_files_to_upload:
       num_threads = num_files_to_upload
 
     # Create a work queue with all files that need to be uploaded.
     q = Queue.Queue(maxsize=num_files_to_upload)
     for rel_path in source_fileset:
       q.put(rel_path)
 
     # Spin up worker threads to read from the task queue.
     def worker():
       while True:
         try:
           rel_path = q.get(block=False)
         except Queue.Empty:
           return  # no more tasks in the queue, so exit
-        self.logger.info(' Uploading file %d/%d: %s' % (
+        print (' Uploading file %d/%d: %s' % (
             num_files_to_upload - q.qsize(), num_files_to_upload, rel_path))
         self.upload_file(
             source_path=os.path.join(source_dir, rel_path),
             dest_bucket=b,
             dest_path=posixpath.join(dest_dir, rel_path),
             upload_if=self.UploadIf.ALWAYS,
             **kwargs)
         q.task_done()
     for _ in range(num_threads):
       t = threading.Thread(target=worker)
@@ skipping 255 matching lines @@
 
 def _get_local_md5(path):
   """Returns the MD5 hash of a file on local disk."""
   hasher = hashlib.md5()
   with open(path, 'rb') as f:
     while True:
       data = f.read(64*1024)
       if not data:
         return hasher.hexdigest()
       hasher.update(data)