archival.py
226 lines
| 7.4 KiB
| text/x-python
|
PythonLexer
/ mercurial / archival.py
|
r2112 | # archival.py - revision archival for mercurial | ||
# | ||||
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
# GNU General Public License version 2, incorporated herein by reference. | ||||
|
r2112 | |||
|
r3891 | from i18n import _ | ||
|
r6211 | from node import hex | ||
|
r8312 | import util | ||
import cStringIO, os, stat, tarfile, time, zipfile | ||||
|
r4652 | import zlib, gzip | ||
|
r2112 | |||
def tidyprefix(dest, prefix, suffixes): | ||||
'''choose prefix to use for names in archive. make sure prefix is | ||||
safe for consumers.''' | ||||
if prefix: | ||||
|
r5842 | prefix = util.normpath(prefix) | ||
|
r2112 | else: | ||
if not isinstance(dest, str): | ||||
raise ValueError('dest must be string if no prefix') | ||||
prefix = os.path.basename(dest) | ||||
lower = prefix.lower() | ||||
for sfx in suffixes: | ||||
if lower.endswith(sfx): | ||||
prefix = prefix[:-len(sfx)] | ||||
break | ||||
lpfx = os.path.normpath(util.localpath(prefix)) | ||||
prefix = util.pconvert(lpfx) | ||||
if not prefix.endswith('/'): | ||||
prefix += '/' | ||||
if prefix.startswith('../') or os.path.isabs(lpfx) or '/../' in prefix: | ||||
raise util.Abort(_('archive prefix contains illegal components')) | ||||
return prefix | ||||
class tarit: | ||||
'''write archive to tar file or stream. can write uncompressed, | ||||
or compress with gzip or bzip2.''' | ||||
|
r4652 | class GzipFileWithTime(gzip.GzipFile): | ||
def __init__(self, *args, **kw): | ||||
timestamp = None | ||||
if 'timestamp' in kw: | ||||
timestamp = kw.pop('timestamp') | ||||
|
r8527 | if timestamp is None: | ||
|
r4652 | self.timestamp = time.time() | ||
else: | ||||
self.timestamp = timestamp | ||||
gzip.GzipFile.__init__(self, *args, **kw) | ||||
def _write_gzip_header(self): | ||||
self.fileobj.write('\037\213') # magic header | ||||
self.fileobj.write('\010') # compression method | ||||
|
r6495 | # Python 2.6 deprecates self.filename | ||
|
r6498 | fname = getattr(self, 'name', None) or self.filename | ||
|
r4652 | flags = 0 | ||
if fname: | ||||
flags = gzip.FNAME | ||||
self.fileobj.write(chr(flags)) | ||||
gzip.write32u(self.fileobj, long(self.timestamp)) | ||||
self.fileobj.write('\002') | ||||
self.fileobj.write('\377') | ||||
if fname: | ||||
self.fileobj.write(fname + '\000') | ||||
|
r2477 | def __init__(self, dest, prefix, mtime, kind=''): | ||
|
r2112 | self.prefix = tidyprefix(dest, prefix, ['.tar', '.tar.bz2', '.tar.gz', | ||
|
r3615 | '.tgz', '.tbz2']) | ||
|
r2477 | self.mtime = mtime | ||
|
r4652 | |||
def taropen(name, mode, fileobj=None): | ||||
if kind == 'gz': | ||||
mode = mode[0] | ||||
if not fileobj: | ||||
|
r4731 | fileobj = open(name, mode + 'b') | ||
|
r4652 | gzfileobj = self.GzipFileWithTime(name, mode + 'b', | ||
zlib.Z_BEST_COMPRESSION, | ||||
fileobj, timestamp=mtime) | ||||
return tarfile.TarFile.taropen(name, mode, gzfileobj) | ||||
else: | ||||
return tarfile.open(name, mode + kind, fileobj) | ||||
|
r2112 | if isinstance(dest, str): | ||
|
r4652 | self.z = taropen(dest, mode='w:') | ||
|
r2112 | else: | ||
|
r4357 | # Python 2.5-2.5.1 have a regression that requires a name arg | ||
|
r4652 | self.z = taropen(name='', mode='w|', fileobj=dest) | ||
|
r2112 | |||
|
r4831 | def addfile(self, name, mode, islink, data): | ||
|
r2112 | i = tarfile.TarInfo(self.prefix + name) | ||
i.mtime = self.mtime | ||||
i.size = len(data) | ||||
|
r4831 | if islink: | ||
i.type = tarfile.SYMTYPE | ||||
i.mode = 0777 | ||||
i.linkname = data | ||||
data = None | ||||
|
r7770 | i.size = 0 | ||
|
r4831 | else: | ||
i.mode = mode | ||||
data = cStringIO.StringIO(data) | ||||
self.z.addfile(i, data) | ||||
|
r2112 | |||
def done(self): | ||||
self.z.close() | ||||
class tellable: | ||||
'''provide tell method for zipfile.ZipFile when writing to http | ||||
response file object.''' | ||||
def __init__(self, fp): | ||||
self.fp = fp | ||||
self.offset = 0 | ||||
def __getattr__(self, key): | ||||
return getattr(self.fp, key) | ||||
def write(self, s): | ||||
self.fp.write(s) | ||||
self.offset += len(s) | ||||
def tell(self): | ||||
return self.offset | ||||
class zipit: | ||||
'''write archive to zip file or stream. can write uncompressed, | ||||
or compressed with deflate.''' | ||||
|
r2477 | def __init__(self, dest, prefix, mtime, compress=True): | ||
|
r2112 | self.prefix = tidyprefix(dest, prefix, ('.zip',)) | ||
|
r2168 | if not isinstance(dest, str): | ||
try: | ||||
dest.tell() | ||||
|
r2169 | except (AttributeError, IOError): | ||
|
r2168 | dest = tellable(dest) | ||
|
r2112 | self.z = zipfile.ZipFile(dest, 'w', | ||
compress and zipfile.ZIP_DEFLATED or | ||||
zipfile.ZIP_STORED) | ||||
|
r2477 | self.date_time = time.gmtime(mtime)[:6] | ||
|
r2112 | |||
|
r4831 | def addfile(self, name, mode, islink, data): | ||
|
r2112 | i = zipfile.ZipInfo(self.prefix + name, self.date_time) | ||
i.compress_type = self.z.compression | ||||
# unzip will not honor unix file modes unless file creator is | ||||
# set to unix (id 3). | ||||
i.create_system = 3 | ||||
|
r4831 | ftype = stat.S_IFREG | ||
if islink: | ||||
mode = 0777 | ||||
ftype = stat.S_IFLNK | ||||
i.external_attr = (mode | ftype) << 16L | ||||
|
r2112 | self.z.writestr(i, data) | ||
def done(self): | ||||
self.z.close() | ||||
class fileit: | ||||
'''write archive as files in directory.''' | ||||
|
r2477 | def __init__(self, name, prefix, mtime): | ||
|
r2112 | if prefix: | ||
raise util.Abort(_('cannot give prefix when archiving to files')) | ||||
self.basedir = name | ||||
|
r4830 | self.opener = util.opener(self.basedir) | ||
|
r2112 | |||
|
r4831 | def addfile(self, name, mode, islink, data): | ||
if islink: | ||||
self.opener.symlink(data, name) | ||||
return | ||||
|
r4830 | f = self.opener(name, "w", atomictemp=True) | ||
f.write(data) | ||||
f.rename() | ||||
|
r2112 | destfile = os.path.join(self.basedir, name) | ||
|
r4830 | os.chmod(destfile, mode) | ||
|
r2112 | |||
def done(self): | ||||
pass | ||||
archivers = { | ||||
'files': fileit, | ||||
'tar': tarit, | ||||
|
r2477 | 'tbz2': lambda name, prefix, mtime: tarit(name, prefix, mtime, 'bz2'), | ||
'tgz': lambda name, prefix, mtime: tarit(name, prefix, mtime, 'gz'), | ||||
'uzip': lambda name, prefix, mtime: zipit(name, prefix, mtime, False), | ||||
|
r2112 | 'zip': zipit, | ||
} | ||||
def archive(repo, dest, node, kind, decode=True, matchfn=None, | ||||
|
r2477 | prefix=None, mtime=None): | ||
|
r2112 | '''create archive of repo as it was at node. | ||
dest can be name of directory, name of archive file, or file | ||||
object to write archive to. | ||||
kind is type of archive to create. | ||||
decode tells whether to put files through decode filters from | ||||
hgrc. | ||||
matchfn is function to filter names of files to write to archive. | ||||
prefix is name of path to put before every archive member.''' | ||||
|
r4951 | def write(name, mode, islink, getdata): | ||
|
r2112 | if matchfn and not matchfn(name): return | ||
|
r4951 | data = getdata() | ||
|
r2112 | if decode: | ||
|
r4005 | data = repo.wwritedata(name, data) | ||
|
r4831 | archiver.addfile(name, mode, islink, data) | ||
|
r2112 | |||
|
r6019 | if kind not in archivers: | ||
|
r6913 | raise util.Abort(_("unknown archive type '%s'") % kind) | ||
|
r6749 | |||
ctx = repo[node] | ||||
|
r3968 | archiver = archivers[kind](dest, prefix, mtime or ctx.date()[0]) | ||
|
r6749 | |||
|
r6183 | if repo.ui.configbool("ui", "archivemeta", True): | ||
write('.hg_archival.txt', 0644, False, | ||||
lambda: 'repo: %s\nnode: %s\n' % ( | ||||
hex(repo.changelog.node(0)), hex(node))) | ||||
|
r6749 | for f in ctx: | ||
ff = ctx.flags(f) | ||||
write(f, 'x' in ff and 0755 or 0644, 'l' in ff, ctx[f].data) | ||||
|
r2112 | archiver.done() | ||