Add --prefix option to cygtar; all paths are prefixed.

build/cygtar.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import glob
 import hashlib
 import optparse
 import os
+import posixpath
 import shutil
 import subprocess
 import stat
 import sys
 import tarfile
 
 """A Cygwin aware version compress/extract object.
 
 This module supports creating and unpacking a tarfile on all platforms.  For
 Cygwin, Mac, and Linux, it will use the standard tarfile implementation.  For
@@ skipping 102 matching lines @@
         return False
       except EnvironmentError:
         print 'Try %d: Failed hardlink %s -> %s\n' % (cnt, filepath, targpath)
     print 'Giving up.'
   return try_mklink
 
 
 def ComputeFileHash(filepath):
   """Generate a sha1 hash for the file at the given path."""
   sha1 = hashlib.sha1()
-  sha1.update(open(filepath, 'rb').read())
+  with open(filepath, 'rb') as fp:
+    sha1.update(fp.read())
   return sha1.hexdigest()
 
 
 def ReadableSizeOf(num):
   """Convert to a human readable number."""
   if num < 1024.0:
     return '[%5dB]' % num
   for x in ['B','K','M','G','T']:
      if num < 1024.0:
        return '[%5.1f%s]' % (num, x)
      num /= 1024.0
   return '[%dT]' % int(num)
 
 
 class CygTar(object):
   """ CygTar is an object which represents a Win32 and Cygwin aware tarball."""
   def __init__(self, filename, mode='r', verbose=False):
     self.size_map = {}
+    self.file_hashes = {}
     # Set errorlevel=1 so that fatal errors actually raise!
     self.tar = tarfile.open(filename, mode, errorlevel=1)
     self.verbose = verbose
 
   def __DumpInfo(self, tarinfo):
     """Prints information on a single object in the tarball."""
     typeinfo = '?'
     lnk = ''
     if tarinfo.issym():
       typeinfo = 'S'
@@ skipping 15 matching lines @@
       self.__DumpInfo(tarinfo)
     self.tar.addfile(tarinfo, fileobj)
 
   def __AddLink(self, tarinfo, linktype, linkpath):
     """Add a Win32 symlink or hardlink to the archive."""
     tarinfo.linkname = linkpath
     tarinfo.type = linktype
     tarinfo.size = 0
     self.__AddFile(tarinfo)
 
-  def Add(self, filepath):
+  def Add(self, filepath, prefix=None):
     """Add path filepath to the archive which may be Native style.
 
     Add files individually recursing on directories.  For POSIX we use
     tarfile.addfile directly on symlinks and hardlinks.  For files, we
     must check if they are duplicates which we convert to hardlinks
     or Cygwin style symlinks which we convert form a file to a symlink
     in the tarfile.  All other files are added as a standard file.
     """
 
     # At this point tarinfo.name will contain a POSIX style path regardless
     # of the original filepath.
     tarinfo = self.tar.gettarinfo(filepath)
+    if prefix:
+      tarinfo.name = posixpath.join(prefix, tarinfo.name)
+
     if sys.platform == 'win32':
       # On win32 os.stat() always claims that files are world writable
       # which means that unless we remove this bit here we end up with
       # world writables files in the archive, which is almost certainly
-      # not indented.
+      # not intended.
       tarinfo.mode &= ~stat.S_IWOTH
       tarinfo.mode &= ~stat.S_IWGRP
 
     # If this a symlink or hardlink, add it
     if tarinfo.issym() or tarinfo.islnk():
       tarinfo.size = 0
       self.__AddFile(tarinfo)
       return True
 
     # If it's a directory, then you want to recurse into it
     if tarinfo.isdir():
       self.__AddFile(tarinfo)
       native_files = glob.glob(os.path.join(filepath, '*'))
       for native_file in native_files:
-        if not self.Add(native_file): return False
+        if not self.Add(native_file, prefix): return False
       return True
 
     # At this point we only allow addition of "FILES"
     if not tarinfo.isfile():
       print 'Failed to add non real file: %s' % filepath
       return False
 
     # Now check if it is a Cygwin style link disguised as a file.
     # We go ahead and check on all platforms just in case we are tar'ing a
     # mount shared with windows.
     if tarinfo.size <= 524:
-      symtext = open(tarinfo.name).read()
+      with open(filepath) as fp:
+        symtext = fp.read()
       if IsCygwinSymlink(symtext):
         self.__AddLink(tarinfo, tarfile.SYMTYPE, SymDatToPath(symtext))
         return True
 
     # Otherwise, check if its a hardlink by seeing if it matches any unique
     # hash within the list of hashed files for that file size.
     nodelist = self.size_map.get(tarinfo.size, [])
 
     # If that size bucket is empty, add this file, no need to get the hash until
     # we get a bucket collision for the first time..
     if not nodelist:
-      self.size_map[tarinfo.size] = [(tarinfo.name, None)]
-      fp = open(tarinfo.name, 'rb')
-      self.__AddFile(tarinfo, fp)
-      fp.close()
+      self.size_map[tarinfo.size] = [filepath]
+      with open(filepath, 'rb') as fp:
+        self.__AddFile(tarinfo, fp)
       return True
 
     # If the size collides with anything, we'll need to check hashes.  We assume
     # no hash collisions for SHA1 on a given bucket, since the number of files
     # in a bucket over possible SHA1 values is near zero.
-    newhash = ComputeFileHash(tarinfo.name)
-    for (oldname, oldhash) in nodelist:
-      # if this is the first collision, we may need to compute the hash
-      # for this first node.
-      if oldhash is None:
+    newhash = ComputeFileHash(filepath)
+    self.file_hashes[filepath] = newhash
+
+    for oldname in nodelist:
+      oldhash = self.file_hashes.get(oldname, None)
+      if not oldhash:
         oldhash = ComputeFileHash(oldname)
+        self.file_hashes[oldname] = oldhash
 
       if oldhash == newhash:
         self.__AddLink(tarinfo, tarfile.LNKTYPE, oldname)
         return True
 
     # Otherwise, we missed, so add it to the bucket for this size
-    self.size_map[tarinfo.size].append((tarinfo.name, newhash))
-    fp = open(tarinfo.name, 'rb')
-    self.__AddFile(tarinfo, fp)
-    fp.close()
+    self.size_map[tarinfo.size].append(filepath)
+    with open(filepath, 'rb') as fp:
+      self.__AddFile(tarinfo, fp)
     return True
 
   def Extract(self):
     """Extract the tarfile to the current directory."""
     try_mklink = True
     div = float(len(self.tar.getmembers())) / 50.0
     dots = 0
     cnt = 0
 
     if self.verbose:
@@ skipping 49 matching lines @@
       action='store_const', const=':bz2', dest='format', default='')
   parser.add_option('-z', '--gzip', help='Create a gzip tarball.',
       action='store_const', const=':gz', dest='format', )
   # Misc
   parser.add_option('-v', '--verbose', help='Use verbose output.',
       action='store_true', dest='verbose', default=False)
   parser.add_option('-f', '--file', help='Name of tarball.',
       dest='filename', default='')
   parser.add_option('-C', '--directory', help='Change directory.',
       dest='cd', default='')
+  parser.add_option('--prefix', help='Subdirectory prefix for all paths')
 
   options, args = parser.parse_args(args[1:])
   if not options.action:
     parser.error('Expecting compress or extract')
   if not options.filename:
     parser.error('Expecting a filename')
 
   if options.action in ['c'] and not args:
     parser.error('Expecting list of sources to add')
   if options.action in ['x', 't'] and args:
@@ skipping 11 matching lines @@
   if options.action == 't':
     tar.List()
     return 0
 
   if options.action == 'x':
     tar.Extract()
     return 0
 
   if options.action == 'c':
     for filepath in args:
-      if not tar.Add(filepath):
+      if not tar.Add(filepath, options.prefix):
         return -1
     tar.Close()
     return 0
 
   parser.error('Missing action c, t, or x.')
   return -1
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))