config/MozZipFile.py

   1 # This Source Code Form is subject to the terms of the Mozilla Public
   2 # License, v. 2.0. If a copy of the MPL was not distributed with this
   3 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   4
   5 import os
   6 import time
   7 import zipfile
   8
   9 import six
  10 from mozbuild.util import lock_file
  11
  12
  13 class ZipFile(zipfile.ZipFile):
  14     """Class with methods to open, read, write, close, list zip files.
  15
  16     Subclassing zipfile.ZipFile to allow for overwriting of existing
  17     entries, though only for writestr, not for write.
  18     """
  19
  20     def __init__(self, file, mode="r", compression=zipfile.ZIP_STORED, lock=False):
  21         if lock:
  22             assert isinstance(file, six.text_type)
  23             self.lockfile = lock_file(file + ".lck")
  24         else:
  25             self.lockfile = None
  26
  27         if mode == "a" and lock:
  28             # appending to a file which doesn't exist fails, but we can't check
  29             # existence util we hold the lock
  30             if (not os.path.isfile(file)) or os.path.getsize(file) == 0:
  31                 mode = "w"
  32
  33         zipfile.ZipFile.__init__(self, file, mode, compression)
  34         self._remove = []
  35         self.end = self.fp.tell()
  36         self.debug = 0
  37
  38     def writestr(self, zinfo_or_arcname, bytes):
  39         """Write contents into the archive.
  40
  41         The contents is the argument 'bytes',  'zinfo_or_arcname' is either
  42         a ZipInfo instance or the name of the file in the archive.
  43         This method is overloaded to allow overwriting existing entries.
  44         """
  45         if not isinstance(zinfo_or_arcname, zipfile.ZipInfo):
  46             zinfo = zipfile.ZipInfo(
  47                 filename=zinfo_or_arcname, date_time=time.localtime(time.time())
  48             )
  49             zinfo.compress_type = self.compression
  50             # Add some standard UNIX file access permissions (-rw-r--r--).
  51             zinfo.external_attr = (0x81A4 & 0xFFFF) << 16
  52         else:
  53             zinfo = zinfo_or_arcname
  54
  55         # Now to the point why we overwrote this in the first place,
  56         # remember the entry numbers if we already had this entry.
  57         # Optimizations:
  58         # If the entry to overwrite is the last one, just reuse that.
  59         # If we store uncompressed and the new content has the same size
  60         # as the old, reuse the existing entry.
  61
  62         doSeek = False  # store if we need to seek to the eof after overwriting
  63         if zinfo.filename in self.NameToInfo:
  64             # Find the last ZipInfo with our name.
  65             # Last, because that's catching multiple overwrites
  66             i = len(self.filelist)
  67             while i > 0:
  68                 i -= 1
  69                 if self.filelist[i].filename == zinfo.filename:
  70                     break
  71             zi = self.filelist[i]
  72             if (
  73                 zinfo.compress_type == zipfile.ZIP_STORED
  74                 and zi.compress_size == len(bytes)
  75             ) or (i + 1) == len(self.filelist):
  76                 # make sure we're allowed to write, otherwise done by writestr below
  77                 self._writecheck(zi)
  78                 # overwrite existing entry
  79                 self.fp.seek(zi.header_offset)
  80                 if (i + 1) == len(self.filelist):
  81                     # this is the last item in the file, just truncate
  82                     self.fp.truncate()
  83                 else:
  84                     # we need to move to the end of the file afterwards again
  85                     doSeek = True
  86                 # unhook the current zipinfo, the writestr of our superclass
  87                 # will add a new one
  88                 self.filelist.pop(i)
  89                 self.NameToInfo.pop(zinfo.filename)
  90             else:
  91                 # Couldn't optimize, sadly, just remember the old entry for removal
  92                 self._remove.append(self.filelist.pop(i))
  93         zipfile.ZipFile.writestr(self, zinfo, bytes)
  94         self.filelist.sort(key=lambda l: l.header_offset)
  95         if doSeek:
  96             self.fp.seek(self.end)
  97         self.end = self.fp.tell()
  98
  99     def close(self):
 100         """Close the file, and for mode "w" and "a" write the ending
 101         records.
 102
 103         Overwritten to compact overwritten entries.
 104         """
 105         if not self._remove:
 106             # we don't have anything special to do, let's just call base
 107             r = zipfile.ZipFile.close(self)
 108             self.lockfile = None
 109             return r
 110
 111         if self.fp.mode != "r+b":
 112             # adjust file mode if we originally just wrote, now we rewrite
 113             self.fp.close()
 114             self.fp = open(self.filename, "r+b")
 115         all = map(lambda zi: (zi, True), self.filelist) + map(
 116             lambda zi: (zi, False), self._remove
 117         )
 118         all.sort(key=lambda l: l[0].header_offset)
 119         # empty _remove for multiple closes
 120         self._remove = []
 121
 122         lengths = [
 123             all[i + 1][0].header_offset - all[i][0].header_offset
 124             for i in xrange(len(all) - 1)
 125         ]
 126         lengths.append(self.end - all[-1][0].header_offset)
 127         to_pos = 0
 128         for (zi, keep), length in zip(all, lengths):
 129             if not keep:
 130                 continue
 131             oldoff = zi.header_offset
 132             # python <= 2.4 has file_offset
 133             if hasattr(zi, "file_offset"):
 134                 zi.file_offset = zi.file_offset + to_pos - oldoff
 135             zi.header_offset = to_pos
 136             self.fp.seek(oldoff)
 137             content = self.fp.read(length)
 138             self.fp.seek(to_pos)
 139             self.fp.write(content)
 140             to_pos += length
 141         self.fp.truncate()
 142         zipfile.ZipFile.close(self)
 143         self.lockfile = None