archival.py
323 lines
| 10.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 | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2112 | |||
|
r3891 | from i18n import _ | ||
|
r17108 | import match as matchmod | ||
|
r9614 | import cmdutil | ||
|
r13970 | import scmutil, util, encoding | ||
|
r13668 | import cStringIO, os, tarfile, time, zipfile | ||
|
r4652 | import zlib, gzip | ||
|
r17628 | import struct | ||
|
r18967 | import error | ||
|
r2112 | |||
|
r17429 | # from unzip source code: | ||
_UNX_IFREG = 0x8000 | ||||
_UNX_IFLNK = 0xa000 | ||||
|
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 | ||||
|
r24681 | def _rootctx(repo): | ||
# repo[0] may be hidden | ||||
for rev in repo: | ||||
return repo[rev] | ||||
return repo['null'] | ||||
|
r24678 | def buildmetadata(ctx): | ||
'''build content of .hg_archival.txt''' | ||||
repo = ctx.repo() | ||||
base = 'repo: %s\nnode: %s\nbranch: %s\n' % ( | ||||
|
r24681 | _rootctx(repo).hex(), ctx.hex(), encoding.fromlocal(ctx.branch())) | ||
|
r24678 | |||
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') | ||||
ltags = ltags.split(':') | ||||
|
r25665 | # XXX: ctx.rev() needs to be handled differently with wdir() | ||
changessince = len(repo.revs('only(%d,%s)', ctx.rev(), ltags[0])) | ||||
|
r24678 | tags = ''.join('latesttag: %s\n' % t for t in ltags) | ||
tags += 'latesttagdistance: %s\n' % dist | ||||
tags += 'changessincelatesttag: %s\n' % changessince | ||||
return base + tags | ||||
|
r11557 | |||
|
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 | ||||
|
r18302 | # Python 2.6 introduced self.name and deprecated self.filename | ||
try: | ||||
fname = self.name | ||||
except AttributeError: | ||||
fname = self.filename | ||||
|
r13102 | if fname and fname.endswith('.gz'): | ||
fname = fname[:-3] | ||||
|
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 | ||
|
r13400 | self.fileobj = None | ||
|
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) | ||||
|
r13400 | self.fileobj = gzfileobj | ||
|
r4652 | 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() | ||||
|
r13400 | if self.fileobj: | ||
self.fileobj.close() | ||||
|
r2112 | |||
|
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 | ||||
|
r17628 | self.mtime = mtime | ||
|
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 | ||||
|
r17429 | ftype = _UNX_IFREG | ||
|
r4831 | if islink: | ||
mode = 0777 | ||||
|
r17429 | ftype = _UNX_IFLNK | ||
|
r4831 | i.external_attr = (mode | ftype) << 16L | ||
|
r17628 | # add "extended-timestamp" extra block, because zip archives | ||
# without this will be extracted with unexpected timestamp, | ||||
# if TZ is not configured as GMT | ||||
i.extra += struct.pack('<hhBl', | ||||
0x5455, # block type: "extended-timestamp" | ||||
1 + 4, # size of this block | ||||
1, # "modification time is present" | ||||
|
r18301 | int(self.mtime)) # last modification (UTC) | ||
|
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 | ||
|
r13970 | self.opener = scmutil.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) | ||||
|
r15057 | f.close() | ||
|
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, | ||||
|
r24172 | prefix='', 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): | ||
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): | ||
|
r16919 | name = '.hg_archival.txt' | ||
if not matchfn or matchfn(name): | ||||
|
r24678 | write(name, 0644, False, lambda: buildmetadata(ctx)) | ||
|
r9614 | |||
|
r16919 | if matchfn: | ||
files = [f for f in ctx.manifest().keys() if matchfn(f)] | ||||
else: | ||||
files = ctx.manifest().keys() | ||||
total = len(files) | ||||
|
r18967 | if total: | ||
files.sort() | ||||
repo.ui.progress(_('archiving'), 0, unit=_('files'), total=total) | ||||
for i, f in enumerate(files): | ||||
ff = ctx.flags(f) | ||||
write(f, 'x' in ff and 0755 or 0644, 'l' in ff, ctx[f].data) | ||||
repo.ui.progress(_('archiving'), i + 1, item=f, | ||||
unit=_('files'), total=total) | ||||
repo.ui.progress(_('archiving'), None) | ||||
|
r12323 | |||
if subrepos: | ||||
|
r18364 | for subpath in sorted(ctx.substate): | ||
|
r12323 | sub = ctx.sub(subpath) | ||
|
r17108 | submatch = matchmod.narrowmatcher(subpath, matchfn) | ||
|
r23575 | total += sub.archive(archiver, prefix, submatch) | ||
|
r18967 | |||
if total == 0: | ||||
raise error.Abort(_('no files match the archive pattern')) | ||||
|
r12323 | |||
|
r2112 | archiver.done() | ||
|
r18967 | return total | ||