archival.py
272 lines
| 8.6 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 | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2112 | |||
|
r3891 | from i18n import _ | ||
|
r6211 | from node import hex | ||
|
r9614 | import cmdutil | ||
|
r13047 | import util, encoding | ||
|
r8312 | import cStringIO, os, stat, tarfile, time, zipfile | ||
|
r4652 | import zlib, gzip | ||
|
r2112 | |||
|
r11558 | def tidyprefix(dest, kind, prefix): | ||
|
r2112 | '''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() | ||||
|
r11558 | for sfx in exts.get(kind, []): | ||
|
r2112 | 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 | ||||
|
r11557 | exts = { | ||
'tar': ['.tar'], | ||||
'tbz2': ['.tbz2', '.tar.bz2'], | ||||
'tgz': ['.tgz', '.tar.gz'], | ||||
'zip': ['.zip'], | ||||
} | ||||
def guesskind(dest): | ||||
for kind, extensions in exts.iteritems(): | ||||
if util.any(dest.endswith(ext) for ext in extensions): | ||||
return kind | ||||
return None | ||||
|
r8778 | class tarit(object): | ||
|
r2112 | '''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') | ||||
|
r11558 | def __init__(self, dest, mtime, kind=''): | ||
|
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): | ||
|
r11558 | i = tarfile.TarInfo(name) | ||
|
r2112 | 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() | ||||
|
r8778 | class tellable(object): | ||
|
r2112 | '''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 | ||||
|
r8778 | class zipit(object): | ||
|
r2112 | '''write archive to zip file or stream. can write uncompressed, | ||
or compressed with deflate.''' | ||||
|
r11558 | def __init__(self, dest, mtime, compress=True): | ||
|
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) | ||||
|
r12319 | |||
# Python's zipfile module emits deprecation warnings if we try | ||||
# to store files with a date before 1980. | ||||
epoch = 315532800 # calendar.timegm((1980, 1, 1, 0, 0, 0, 1, 1, 0)) | ||||
if mtime < epoch: | ||||
mtime = epoch | ||||
|
r2477 | self.date_time = time.gmtime(mtime)[:6] | ||
|
r2112 | |||
|
r4831 | def addfile(self, name, mode, islink, data): | ||
|
r11558 | i = zipfile.ZipInfo(name, self.date_time) | ||
|
r2112 | 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() | ||||
|
r8778 | class fileit(object): | ||
|
r2112 | '''write archive as files in directory.''' | ||
|
r11558 | def __init__(self, name, mtime): | ||
|
r2112 | 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, | ||||
|
r11558 | 'tbz2': lambda name, mtime: tarit(name, mtime, 'bz2'), | ||
'tgz': lambda name, mtime: tarit(name, mtime, 'gz'), | ||||
'uzip': lambda name, mtime: zipit(name, mtime, False), | ||||
|
r2112 | 'zip': zipit, | ||
} | ||||
def archive(repo, dest, node, kind, decode=True, matchfn=None, | ||||
|
r12323 | prefix=None, mtime=None, subrepos=False): | ||
|
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.''' | ||||
|
r11558 | if kind == 'files': | ||
if prefix: | ||||
raise util.Abort(_('cannot give prefix when archiving to files')) | ||||
else: | ||||
prefix = tidyprefix(dest, kind, prefix) | ||||
|
r4951 | def write(name, mode, islink, getdata): | ||
|
r10282 | if matchfn and not matchfn(name): | ||
return | ||||
|
r4951 | data = getdata() | ||
|
r2112 | if decode: | ||
|
r4005 | data = repo.wwritedata(name, data) | ||
|
r11558 | archiver.addfile(prefix + name, mode, islink, data) | ||
|
r2112 | |||
|
r6019 | if kind not in archivers: | ||
|
r6913 | raise util.Abort(_("unknown archive type '%s'") % kind) | ||
|
r6749 | |||
ctx = repo[node] | ||||
|
r11558 | archiver = archivers[kind](dest, mtime or ctx.date()[0]) | ||
|
r6749 | |||
|
r6183 | if repo.ui.configbool("ui", "archivemeta", True): | ||
|
r9614 | def metadata(): | ||
base = 'repo: %s\nnode: %s\nbranch: %s\n' % ( | ||||
|
r13047 | repo[0].hex(), hex(node), encoding.fromlocal(ctx.branch())) | ||
|
r9614 | |||
tags = ''.join('tag: %s\n' % t for t in ctx.tags() | ||||
if repo.tagtype(t) == 'global') | ||||
if not tags: | ||||
repo.ui.pushbuffer() | ||||
opts = {'template': '{latesttag}\n{latesttagdistance}', | ||||
'style': '', 'patch': None, 'git': None} | ||||
cmdutil.show_changeset(repo.ui, repo, opts).show(ctx) | ||||
ltags, dist = repo.ui.popbuffer().split('\n') | ||||
tags = ''.join('latesttag: %s\n' % t for t in ltags.split(':')) | ||||
tags += 'latesttagdistance: %s\n' % dist | ||||
return base + tags | ||||
write('.hg_archival.txt', 0644, False, metadata) | ||||
|
r6749 | for f in ctx: | ||
ff = ctx.flags(f) | ||||
write(f, 'x' in ff and 0755 or 0644, 'l' in ff, ctx[f].data) | ||||
|
r12323 | |||
if subrepos: | ||||
for subpath in ctx.substate: | ||||
sub = ctx.sub(subpath) | ||||
sub.archive(archiver, prefix) | ||||
|
r2112 | archiver.done() | ||