Add support for tar.gz archive files to download from download_from_google_storage

download_from_google_storage.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Download files from Google Storage based on SHA1 sums."""
 
 
 import hashlib
 import optparse
 import os
 import Queue
 import re
+import shutil
 import stat
 import sys
+import tarfile
 import threading
 import time
 
 import subprocess2
 
 
 GSUTIL_DEFAULT_PATH = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), 'gsutil.py')
 # Maps sys.platform to what we actually want to call them.
 PLATFORM_MAPPING = {
@@ skipping 171 matching lines @@
               (sha1_match.groups(1)[0], full_path.replace('.sha1', '')))
           work_queue_size += 1
         else:
           if not ignore_errors:
             raise InvalidFileError('No sha1 sum found in %s.' % filename)
           print >> sys.stderr, 'No sha1 sum found in %s.' % filename
   return work_queue_size
 
 
 def _downloader_worker_thread(thread_num, q, force, base_url,
-                              gsutil, out_q, ret_codes, verbose):
+                              gsutil, out_q, ret_codes, verbose, extract):
   while True:
     input_sha1_sum, output_filename = q.get()
     if input_sha1_sum is None:
       return
     if os.path.exists(output_filename) and not force:
       if get_sha1(output_filename) == input_sha1_sum:
         if verbose:
           out_q.put(
               '%d> File %s exists and SHA1 matches. Skipping.' % (
                   thread_num, output_filename))
@@ skipping 12 matching lines @@
       os.remove(output_filename)  # Delete the file if it exists already.
     except OSError:
       if os.path.exists(output_filename):
         out_q.put('%d> Warning: deleting %s failed.' % (
             thread_num, output_filename))
     code, _, err = gsutil.check_call('cp', file_url, output_filename)
     if code != 0:
       out_q.put('%d> %s' % (thread_num, err))
       ret_codes.put((code, err))
 
+    if extract:
+      if (not tarfile.is_tarfile(output_filename)
+          or not output_filename.endswith('tar.gz')):

[hinoka, 2015/02/05 18:44:16]

'.tar.gz' to match with expectations on 251

[ricow1, 2015/02/06 11:52:29]

Done.

+        out_q.put('%d> Error: %s is not a tar.gz archive.' % (
+                  thread_num, output_filename))   
+        ret_codes.put((1, '%s is not a tar.gz archive.' % (output_filename)))
+        continue
+      tar = tarfile.open(output_filename, 'r:gz')

[hinoka, 2015/02/05 18:44:16]

Also validate all paths in the tarfile here (Only having checks in the upload
scripts isn't going to prevent malicious out-of-band uploads).  May have to
iterate through each file.

[ricow1, 2015/02/06 11:52:29]

Added check

+      dirname = os.path.dirname(os.path.abspath(output_filename))
+      extract_dir = output_filename[0:len(output_filename)-7]
+      out_q.put('%d> extracting %s...' % (thread_num, extract_dir))
+      if os.path.exists(extract_dir):
+        try:
+          shutil.rmtree(extract_dir)
+          out_q.put('%d> Removed %s...' % (thread_num, extract_dir))
+        except OSError:
+          out_q.put('%d> Warning: Can\'t delete: %s' % (
+                    thread_num, extract_dir))   
+          ret_codes.put((1, 'Can\'t delete %s.' % (extract_dir)))
+          continue
+        out_q.put('%d> Extracting %s to %s' % (thread_num, output_filename,
+                                               extract_dir))
+      tar.extractall(path=dirname)
     # Set executable bit.
     if sys.platform == 'cygwin':
       # Under cygwin, mark all files as executable. The executable flag in
       # Google Storage will not be set when uploading from Windows, so if
       # this script is running under cygwin and we're downloading an
       # executable, it will be unrunnable from inside cygwin without this.
       st = os.stat(output_filename)
       os.chmod(output_filename, st.st_mode | stat.S_IEXEC)
     elif sys.platform != 'win32':
       # On non-Windows platforms, key off of the custom header
@@ skipping 10 matching lines @@
   while True:
     line = output_queue.get()
     # Its plausible we want to print empty lines.
     if line is None:
       break
     print line
 
 
 def download_from_google_storage(
     input_filename, base_url, gsutil, num_threads, directory, recursive,
-    force, output, ignore_errors, sha1_file, verbose, auto_platform):
+    force, output, ignore_errors, sha1_file, verbose, auto_platform, extract):
   # Start up all the worker threads.
   all_threads = []
   download_start = time.time()
   stdout_queue = Queue.Queue()
   work_queue = Queue.Queue()
   ret_codes = Queue.Queue()
   ret_codes.put((0, None))
   for thread_num in range(num_threads):
     t = threading.Thread(
         target=_downloader_worker_thread,
         args=[thread_num, work_queue, force, base_url,
-              gsutil, stdout_queue, ret_codes, verbose])
+              gsutil, stdout_queue, ret_codes, verbose, extract])
     t.daemon = True
     t.start()
     all_threads.append(t)
   printer_thread = threading.Thread(target=printer_worker, args=[stdout_queue])
   printer_thread.daemon = True
   printer_thread.start()
 
   # Enumerate our work queue.
   work_queue_size = enumerate_work_queue(
       input_filename, work_queue, directory, recursive,
@@ skipping 67 matching lines @@
   parser.add_option('-p', '--platform',
                     help='A regular expression that is compared against '
                          'Python\'s sys.platform. If this option is specified, '
                          'the download will happen only if there is a match.')
   parser.add_option('-a', '--auto_platform',
                     action='store_true',
                     help='Detects if any parent folder of the target matches '
                          '(linux|mac|win).  If so, the script will only '
                          'process files that are in the paths that '
                          'that matches the current platform.')
+  parser.add_option('-u', '--extract',
+                    action='store_true',
+                    help='Extract a downloaded tar.gz file after download. '
+                         'Leaves the tar.gz file around for sha verification1'
+                         'If a directory with the same name as the tar.gz '
+                         'file already exists, this is deleted (to get a '
+                         'clean state in case of update.)')
   parser.add_option('-v', '--verbose', action='store_true',
                     help='Output extra diagnostic and progress information.')
 
   (options, args) = parser.parse_args()
 
   # Make sure we should run at all based on platform matching.
   if options.platform:
     if options.auto_platform:
       parser.error('--platform can not be specified with --auto_platform')
     if not re.match(options.platform, GetNormalizedPlatform()):
@@ skipping 76 matching lines @@
 
   # Check we have a valid bucket with valid permissions.
   if not options.no_auth:
     code = check_bucket_permissions(base_url, gsutil)
     if code:
       return code
 
   return download_from_google_storage(
       input_filename, base_url, gsutil, options.num_threads, options.directory,
       options.recursive, options.force, options.output, options.ignore_errors,
-      options.sha1_file, options.verbose, options.auto_platform)
+      options.sha1_file, options.verbose, options.auto_platform,
+      options.extract)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))