Switching most of the logging to debug

generate_au_zip.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
   Script to generate a zip file of delta-generator and it's dependencies.
 """
 import logging.handlers
 import optparse
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 
 # GLOBALS
 
 logging_format = '%(asctime)s - %(filename)s - %(levelname)-8s: %(message)s'
 date_format = '%Y/%m/%d %H:%M:%S'
 logging.basicConfig(level=logging.INFO, format=logging_format,
                     datefmt=date_format)
 
 def CreateTempDir():
   """Creates a tempdir and returns the name of the tempdir."""
   temp_dir = tempfile.mkdtemp(suffix='au', prefix='tmp')
-  logging.info('Using tempdir = %s', temp_dir)
+  logging.debug('Using tempdir = %s', temp_dir)
   return temp_dir
 
 
 def _SplitAndStrip(data):
   """Prunes the ldd output, and return a list of needed library names
     Example of data:
         linux-vdso.so.1 =>  (0x00007ffffc96a000)
         libbz2.so.1 => /lib/libbz2.so.1 (0x00007f3ff8782000)
         libc.so.6 => /lib/libc.so.6 (0x00007f3ff83ff000)
         /lib64/ld-linux-x86-64.so.2 (0x00007f3ff89b3000)
@@ skipping 19 matching lines @@
 
 def DepsToCopy(ldd_files, black_list):
   """Returns a list of deps for a given dynamic executables list.
     Args:
       ldd_files: List of dynamic files that needs to have the deps evaluated
       black_list: List of files that we should ignore
    Returns:
      library_list: List of files that are dependencies
   """
   for file_name in ldd_files:
-    logging.info('Running ldd on %s', file_name)
+    logging.debug('Running ldd on %s', file_name)
     cmd = ['/usr/bin/ldd', file_name]
     stdout_data = ''
     stderr_data = ''
 
     try:
       proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
       (stdout_data, stderr_data) = proc.communicate(input=None)
     except subprocess.CalledProcessError, e:
       logging.error('Command %s failed', cmd)
@@ skipping 50 matching lines @@
   all_files = map(os.path.expanduser, all_files)
 
   for file_name in all_files:
     if not os.path.isfile(file_name):
       logging.error('file = %s does not exist', file_name)
       sys.exit(1)
 
   logging.debug('Given files that need to be copied = %s' % '' .join(all_files))
   all_files += DepsToCopy(ldd_files=ldd_files,black_list=black_list)
   for file_name in all_files:
-    logging.info('Copying file  %s to %s', file_name, dest_files_root)
+    logging.debug('Copying file  %s to %s', file_name, dest_files_root)
     shutil.copy2(file_name, dest_files_root)
 
   for source_dir, target_dir in recurse_dirs.iteritems():
-    logging.info('Processing directory %s', source_dir)
+    logging.debug('Processing directory %s', source_dir)
     full_path = os.path.expanduser(source_dir)
     if not os.path.isdir(full_path):
       logging.error("Directory given for %s expanded to %s doens't exist.",
                     source_dir, full_path)
       sys.exit(1)
   dest = os.path.join(dest_files_root, target_dir)
-  logging.info('Copying directory %s to %s.', full_path, target_dir)
+  logging.debug('Copying directory %s to %s.', full_path, target_dir)
   shutil.copytree(full_path, dest)
 
 def CleanUp(temp_dir):
   """Cleans up the tempdir
     Args:
       temp_dir = name of the directory to cleanup
   """
   if os.path.exists(temp_dir):
     shutil.rmtree(temp_dir, ignore_errors=True)
-    logging.info('Removed tempdir = %s', temp_dir)
+    logging.debug('Removed tempdir = %s', temp_dir)
 
 def GenerateZipFile(base_name, root_dir):
   """Returns true if able to generate zip file
     Args:
       base_name: name of the zip file
       root_dir: location of the directory that we should zip
     Returns:
       True if successfully generates the zip file otherwise False
   """
-  logging.info('Generating zip file %s with contents from %s', base_name,
+  logging.debug('Generating zip file %s with contents from %s', base_name,
                root_dir)
   current_dir = os.getcwd()
   os.chdir(root_dir)
   try:
     subprocess.Popen(['zip', '-r', '-9', base_name, '.'],
                      stdout=subprocess.PIPE).communicate()[0]
   except OSError, e:
    logging.error('Execution failed:%s', e.strerror)
    return False
   finally:
@@ skipping 34 matching lines @@
   Returns:
     True on Success False on Failure
   """
   if not os.path.isfile(zip_file_name):
     logging.error("Zip file %s doesn't exist. Returning False", zip_file_name)
     return False
 
   if not os.path.isdir(output_dir):
     logging.debug('Creating %s', output_dir)
     os.makedirs(output_dir)
-  logging.info('Copying %s to %s', zip_file_name, output_dir)
+  logging.debug('Copying %s to %s', zip_file_name, output_dir)
   shutil.copy2(zip_file_name, output_dir)
   return True
 
 
 def main():
   """Main function to start the script"""
   parser = optparse.OptionParser()
 
   parser.add_option( '-d', '--debug', dest='debug', action='store_true',
                      default=False, help='Verbose Default: False',)
@@ skipping 11 matching lines @@
 
   logging.debug('Options are %s ', options)
 
   temp_dir = CreateTempDir()
   dest_files_root = os.path.join(temp_dir, 'au-generator')
   os.makedirs(dest_files_root)
   CopyRequiredFiles(dest_files_root=dest_files_root)
   zip_file_name = os.path.join(temp_dir, options.zip_name)
   GenerateZipFile(zip_file_name, dest_files_root)
   CopyZipToFinalDestination(options.output_dir, zip_file_name)
+  logging.info('Generated %s/%s' % (options.output_dir, options.zip_name))
 
   if not options.keep_temp:
     CleanUp(temp_dir)
 
 if __name__ == '__main__':
   main()