repair.py
435 lines
| 14.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / repair.py
|
r4702 | # repair.py - functions for repository repair for mercurial | ||
# | ||||
# Copyright 2005, 2006 Chris Mason <mason@suse.com> | ||||
# Copyright 2007 Matt Mackall | ||||
# | ||||
|
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. | ||
|
r4702 | |||
|
r25970 | from __future__ import absolute_import | ||
|
r16440 | import errno | ||
|
r29341 | import hashlib | ||
|
r4702 | |||
|
r25970 | from .i18n import _ | ||
|
r34219 | from .node import ( | ||
hex, | ||||
short, | ||||
) | ||||
|
r25970 | from . import ( | ||
bundle2, | ||||
changegroup, | ||||
r32468 | discovery, | |||
|
r26587 | error, | ||
|
r25970 | exchange, | ||
|
r28868 | obsolete, | ||
r33144 | obsutil, | |||
|
r25970 | util, | ||
) | ||||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r25970 | |||
|
r37034 | def backupbundle(repo, bases, heads, node, suffix, compress=True, | ||
obsolescence=True): | ||||
|
r5905 | """create a bundle with the specified revisions as a backup""" | ||
|
r23898 | |||
|
r20977 | backupdir = "strip-backup" | ||
vfs = repo.vfs | ||||
if not vfs.isdir(backupdir): | ||||
vfs.mkdir(backupdir) | ||||
|
r23835 | |||
# Include a hash of all the nodes in the filename for uniqueness | ||||
|
r25340 | allcommits = repo.set('%ln::%ln', bases, heads) | ||
|
r23835 | allhashes = sorted(c.hex() for c in allcommits) | ||
|
r34219 | totalhash = hashlib.sha1(''.join(allhashes)).digest() | ||
name = "%s/%s-%s-%s.hg" % (backupdir, short(node), | ||||
hex(totalhash[:4]), suffix) | ||||
|
r23835 | |||
|
r34179 | cgversion = changegroup.localversion(repo) | ||
|
r26425 | comp = None | ||
|
r26423 | if cgversion != '01': | ||
|
r24686 | bundletype = "HG20" | ||
|
r26425 | if compress: | ||
comp = 'BZ' | ||||
|
r23898 | elif compress: | ||
|
r11791 | bundletype = "HG10BZ" | ||
else: | ||||
bundletype = "HG10UN" | ||||
r32468 | ||||
outgoing = discovery.outgoing(repo, missingroots=bases, missingheads=heads) | ||||
|
r33032 | contentopts = { | ||
'cg.version': cgversion, | ||||
'obsolescence': obsolescence, | ||||
'phases': True, | ||||
} | ||||
r32468 | return bundle2.writenewbundle(repo.ui, repo, 'strip', name, bundletype, | |||
outgoing, contentopts, vfs, compression=comp) | ||||
|
r4702 | |||
|
r5910 | def _collectfiles(repo, striprev): | ||
"""find out the filelogs affected by the strip""" | ||||
|
r8462 | files = set() | ||
|
r4702 | |||
|
r6750 | for x in xrange(striprev, len(repo)): | ||
|
r8479 | files.update(repo[x].files()) | ||
|
r5902 | |||
|
r8462 | return sorted(files) | ||
|
r5902 | |||
|
r33690 | def _collectrevlog(revlog, striprev): | ||
_, brokenset = revlog.getstrippoint(striprev) | ||||
return [revlog.linkrev(r) for r in brokenset] | ||||
def _collectmanifest(repo, striprev): | ||||
return _collectrevlog(repo.manifestlog._revlog, striprev) | ||||
|
r13702 | def _collectbrokencsets(repo, files, striprev): | ||
"""return the changesets which will be broken by the truncation""" | ||||
|
r13705 | s = set() | ||
|
r5909 | |||
|
r33690 | s.update(_collectmanifest(repo, striprev)) | ||
|
r13705 | for fname in files: | ||
|
r33690 | s.update(_collectrevlog(repo.file(fname), striprev)) | ||
|
r5909 | |||
|
r13705 | return s | ||
|
r5909 | |||
|
r22057 | def strip(ui, repo, nodelist, backup=True, topic='backup'): | ||
|
r32922 | # This function requires the caller to lock the repo, but it operates | ||
# within a transaction of its own, and thus requires there to be no current | ||||
# transaction when it is called. | ||||
|
r32924 | if repo.currenttransaction() is not None: | ||
raise error.ProgrammingError('cannot strip from inside a transaction') | ||||
|
r22057 | # Simple way to maintain backwards compatibility for this | ||
# argument. | ||||
if backup in ['none', 'strip']: | ||||
backup = False | ||||
|
r18004 | repo = repo.unfiltered() | ||
|
r18310 | repo.destroying() | ||
|
r17013 | |||
|
r5901 | cl = repo.changelog | ||
|
r16237 | # TODO handle undo of merge sets | ||
|
r16252 | if isinstance(nodelist, str): | ||
nodelist = [nodelist] | ||||
striplist = [cl.rev(node) for node in nodelist] | ||||
striprev = min(striplist) | ||||
|
r4702 | |||
|
r30707 | files = _collectfiles(repo, striprev) | ||
saverevs = _collectbrokencsets(repo, files, striprev) | ||||
|
r6147 | # Some revisions with rev > striprev may not be descendants of striprev. | ||
# We have to find these revisions and put them in a bundle, so that | ||||
# we can restore them after the truncations. | ||||
# To create the bundle we use repo.changegroupsubset which requires | ||||
# the list of heads and bases of the set of interesting revisions. | ||||
# (head = revision in the set that has no descendant in the set; | ||||
# base = revision in the set that has no ancestor in the set) | ||||
|
r16252 | tostrip = set(striplist) | ||
|
r30707 | saveheads = set(saverevs) | ||
|
r30706 | for r in cl.revs(start=striprev + 1): | ||
if any(p in tostrip for p in cl.parentrevs(r)): | ||||
tostrip.add(r) | ||||
|
r13702 | |||
if r not in tostrip: | ||||
saverevs.add(r) | ||||
saveheads.difference_update(cl.parentrevs(r)) | ||||
saveheads.add(r) | ||||
saveheads = [cl.node(r) for r in saveheads] | ||||
|
r4702 | |||
|
r15386 | # compute base nodes | ||
if saverevs: | ||||
|
r16867 | descendants = set(cl.descendants(saverevs)) | ||
|
r15386 | saverevs.difference_update(descendants) | ||
savebases = [cl.node(r) for r in saverevs] | ||||
|
r16252 | stripbases = [cl.node(r) for r in tostrip] | ||
|
r18040 | |||
r32629 | stripobsidx = obsmarkers = () | |||
r33167 | if repo.ui.configbool('devel', 'strip-obsmarkers'): | |||
r33144 | obsmarkers = obsutil.exclusivemarkers(repo, stripbases) | |||
r32629 | if obsmarkers: | |||
stripobsidx = [i for i, m in enumerate(repo.obsstore) | ||||
if m in obsmarkers] | ||||
|
r18040 | # For a set s, max(parents(s) - s) is the same as max(heads(::s - s)), but | ||
# is much faster | ||||
newbmtarget = repo.revs('max(parents(%ld) - (%ld))', tostrip, tostrip) | ||||
|
r17264 | if newbmtarget: | ||
|
r22818 | newbmtarget = repo[newbmtarget.first()].node() | ||
|
r17264 | else: | ||
newbmtarget = '.' | ||||
|
r4702 | |||
|
r13362 | bm = repo._bookmarks | ||
updatebm = [] | ||||
for m in bm: | ||||
rev = repo[bm[m]].rev() | ||||
if rev in tostrip: | ||||
updatebm.append(m) | ||||
|
r4702 | # create a changegroup for all the branches we need to keep | ||
|
r11197 | backupfile = None | ||
|
r20979 | vfs = repo.vfs | ||
|
r24252 | node = nodelist[-1] | ||
|
r22057 | if backup: | ||
|
r37034 | backupfile = backupbundle(repo, stripbases, cl.heads(), node, topic) | ||
|
r20979 | repo.ui.status(_("saved backup bundle to %s\n") % | ||
vfs.join(backupfile)) | ||||
repo.ui.log("backupbundle", "saved backup bundle to %s\n", | ||||
vfs.join(backupfile)) | ||||
|
r29954 | tmpbundlefile = None | ||
|
r29951 | if saveheads: | ||
|
r29954 | # do not compress temporary bundle if we remove it from disk later | ||
r32628 | # | |||
# We do not include obsolescence, it might re-introduce prune markers | ||||
# we are trying to strip. This is harmless since the stripped markers | ||||
# are already backed up and we did not touched the markers for the | ||||
# saved changesets. | ||||
|
r37034 | tmpbundlefile = backupbundle(repo, savebases, saveheads, node, 'temp', | ||
compress=False, obsolescence=False) | ||||
|
r4702 | |||
|
r27873 | try: | ||
with repo.transaction("strip") as tr: | ||||
offset = len(tr.entries) | ||||
|
r8073 | |||
|
r27873 | tr.startgroup() | ||
cl.strip(striprev, tr) | ||||
|
r33691 | stripmanifest(repo, striprev, tr, files) | ||
|
r32196 | |||
|
r27873 | for fn in files: | ||
repo.file(fn).strip(striprev, tr) | ||||
tr.endgroup() | ||||
|
r8073 | |||
|
r11197 | for i in xrange(offset, len(tr.entries)): | ||
file, troffset, ignore = tr.entries[i] | ||||
|
r30001 | with repo.svfs(file, 'a', checkambig=True) as fp: | ||
fp.truncate(troffset) | ||||
|
r20885 | if troffset == 0: | ||
repo.store.markremoved(file) | ||||
|
r11197 | |||
r32629 | deleteobsmarkers(repo.obsstore, stripobsidx) | |||
del repo.obsstore | ||||
|
r35796 | repo.invalidatevolatilesets() | ||
|
r35725 | repo._phasecache.filterunknown(repo) | ||
r32629 | ||||
|
r29954 | if tmpbundlefile: | ||
|
r11202 | ui.note(_("adding branch\n")) | ||
|
r29954 | f = vfs.open(tmpbundlefile, "rb") | ||
gen = exchange.readbundle(ui, f, tmpbundlefile, vfs) | ||||
|
r11202 | if not repo.ui.verbose: | ||
# silence internal shuffling chatter | ||||
repo.ui.pushbuffer() | ||||
|
r32929 | tmpbundleurl = 'bundle:' + vfs.join(tmpbundlefile) | ||
|
r33042 | txnname = 'strip' | ||
if not isinstance(gen, bundle2.unbundle20): | ||||
txnname = "strip\n%s" % util.hidepassword(tmpbundleurl) | ||||
with repo.transaction(txnname) as tr: | ||||
|
r33043 | bundle2.applybundle(repo, gen, tr, source='strip', | ||
|
r33307 | url=tmpbundleurl) | ||
|
r11202 | if not repo.ui.verbose: | ||
repo.ui.popbuffer() | ||||
|
r11197 | f.close() | ||
|
r31626 | |||
|
r32925 | with repo.transaction('repair') as tr: | ||
|
r33490 | bmchanges = [(m, repo[newbmtarget].node()) for m in updatebm] | ||
bm.applychanges(repo, tr, bmchanges) | ||||
|
r27157 | |||
|
r16237 | # remove undo files | ||
|
r20975 | for undovfs, undofile in repo.undofiles(): | ||
|
r16237 | try: | ||
|
r20975 | undovfs.unlink(undofile) | ||
|
r25660 | except OSError as e: | ||
|
r16237 | if e.errno != errno.ENOENT: | ||
|
r20975 | ui.warn(_('error removing %s: %s\n') % | ||
|
r37102 | (undovfs.join(undofile), | ||
stringutil.forcebytestr(e))) | ||||
|
r16237 | |||
|
r16705 | except: # re-raises | ||
|
r11197 | if backupfile: | ||
|
r29954 | ui.warn(_("strip failed, backup bundle stored in '%s'\n") | ||
|
r20979 | % vfs.join(backupfile)) | ||
|
r29954 | if tmpbundlefile: | ||
|
r29953 | ui.warn(_("strip failed, unrecovered changes stored in '%s'\n") | ||
|
r29954 | % vfs.join(tmpbundlefile)) | ||
|
r29953 | ui.warn(_("(fix the problem, then recover the changesets with " | ||
|
r29954 | "\"hg unbundle '%s'\")\n") % vfs.join(tmpbundlefile)) | ||
|
r8073 | raise | ||
|
r22057 | else: | ||
|
r29954 | if tmpbundlefile: | ||
# Remove temporary bundle only if there were no exceptions | ||||
vfs.unlink(tmpbundlefile) | ||||
|
r4702 | |||
|
r18395 | repo.destroyed() | ||
|
r30274 | # return the backup file path (or None if 'backup' was False) so | ||
# extensions can use it | ||||
return backupfile | ||||
|
r25652 | |||
|
r33087 | def safestriproots(ui, repo, nodes): | ||
"""return list of roots of nodes where descendants are covered by nodes""" | ||||
torev = repo.unfiltered().changelog.rev | ||||
revs = set(torev(n) for n in nodes) | ||||
# tostrip = wanted - unsafe = wanted - ancestors(orphaned) | ||||
# orphaned = affected - wanted | ||||
# affected = descendants(roots(wanted)) | ||||
# wanted = revs | ||||
tostrip = set(repo.revs('%ld-(::((roots(%ld)::)-%ld))', revs, revs, revs)) | ||||
notstrip = revs - tostrip | ||||
if notstrip: | ||||
nodestr = ', '.join(sorted(short(repo[n].node()) for n in notstrip)) | ||||
ui.warn(_('warning: orphaned descendants detected, ' | ||||
'not stripping %s\n') % nodestr) | ||||
return [c.node() for c in repo.set('roots(%ld)', tostrip)] | ||||
class stripcallback(object): | ||||
"""used as a transaction postclose callback""" | ||||
def __init__(self, ui, repo, backup, topic): | ||||
self.ui = ui | ||||
self.repo = repo | ||||
self.backup = backup | ||||
self.topic = topic or 'backup' | ||||
self.nodelist = [] | ||||
def addnodes(self, nodes): | ||||
self.nodelist.extend(nodes) | ||||
def __call__(self, tr): | ||||
roots = safestriproots(self.ui, self.repo, self.nodelist) | ||||
if roots: | ||||
|
r33108 | strip(self.ui, self.repo, roots, self.backup, self.topic) | ||
|
r33087 | |||
def delayedstrip(ui, repo, nodelist, topic=None): | ||||
"""like strip, but works inside transaction and won't strip irreverent revs | ||||
nodelist must explicitly contain all descendants. Otherwise a warning will | ||||
be printed that some nodes are not stripped. | ||||
Always do a backup. The last non-None "topic" will be used as the backup | ||||
topic name. The default backup topic name is "backup". | ||||
""" | ||||
tr = repo.currenttransaction() | ||||
if not tr: | ||||
nodes = safestriproots(ui, repo, nodelist) | ||||
return strip(ui, repo, nodes, True, topic) | ||||
# transaction postclose callbacks are called in alphabet order. | ||||
# use '\xff' as prefix so we are likely to be called last. | ||||
callback = tr.getpostclose('\xffstrip') | ||||
if callback is None: | ||||
callback = stripcallback(ui, repo, True, topic) | ||||
tr.addpostclose('\xffstrip', callback) | ||||
if topic: | ||||
callback.topic = topic | ||||
callback.addnodes(nodelist) | ||||
|
r33691 | def stripmanifest(repo, striprev, tr, files): | ||
revlog = repo.manifestlog._revlog | ||||
revlog.strip(striprev, tr) | ||||
striptrees(repo, tr, striprev, files) | ||||
|
r32196 | def striptrees(repo, tr, striprev, files): | ||
if 'treemanifest' in repo.requirements: # safe but unnecessary | ||||
# otherwise | ||||
|
r32296 | for unencoded, encoded, size in repo.store.datafiles(): | ||
if (unencoded.startswith('meta/') and | ||||
unencoded.endswith('00manifest.i')): | ||||
dir = unencoded[5:-12] | ||||
repo.manifestlog._revlog.dirlog(dir).strip(striprev, tr) | ||||
|
r32196 | |||
|
r25652 | def rebuildfncache(ui, repo): | ||
"""Rebuilds the fncache file from repo history. | ||||
Missing entries will be added. Extra entries will be removed. | ||||
""" | ||||
repo = repo.unfiltered() | ||||
if 'fncache' not in repo.requirements: | ||||
ui.warn(_('(not rebuilding fncache because repository does not ' | ||||
|
r25874 | 'support fncache)\n')) | ||
|
r25652 | return | ||
|
r27860 | with repo.lock(): | ||
|
r25652 | fnc = repo.store.fncache | ||
# Trigger load of fncache. | ||||
if 'irrelevant' in fnc: | ||||
pass | ||||
oldentries = set(fnc.entries) | ||||
newentries = set() | ||||
seenfiles = set() | ||||
|
r38413 | progress = ui.makeprogress(_('rebuilding'), unit=_('changesets'), | ||
total=len(repo)) | ||||
|
r25652 | for rev in repo: | ||
|
r38413 | progress.update(rev) | ||
|
r25652 | |||
ctx = repo[rev] | ||||
for f in ctx.files(): | ||||
# This is to minimize I/O. | ||||
if f in seenfiles: | ||||
continue | ||||
seenfiles.add(f) | ||||
i = 'data/%s.i' % f | ||||
d = 'data/%s.d' % f | ||||
if repo.store._exists(i): | ||||
newentries.add(i) | ||||
if repo.store._exists(d): | ||||
newentries.add(d) | ||||
|
r38413 | progress.complete() | ||
|
r25652 | |||
|
r28031 | if 'treemanifest' in repo.requirements: # safe but unnecessary otherwise | ||
|
r28007 | for dir in util.dirs(seenfiles): | ||
i = 'meta/%s/00manifest.i' % dir | ||||
d = 'meta/%s/00manifest.d' % dir | ||||
if repo.store._exists(i): | ||||
newentries.add(i) | ||||
if repo.store._exists(d): | ||||
newentries.add(d) | ||||
|
r25652 | addcount = len(newentries - oldentries) | ||
removecount = len(oldentries - newentries) | ||||
for p in sorted(oldentries - newentries): | ||||
ui.write(_('removing %s\n') % p) | ||||
for p in sorted(newentries - oldentries): | ||||
ui.write(_('adding %s\n') % p) | ||||
if addcount or removecount: | ||||
ui.write(_('%d items added, %d removed from fncache\n') % | ||||
(addcount, removecount)) | ||||
fnc.entries = newentries | ||||
fnc._dirty = True | ||||
|
r27871 | with repo.transaction('fncache') as tr: | ||
|
r25652 | fnc.write(tr) | ||
else: | ||||
ui.write(_('fncache already up to date\n')) | ||||
|
r28868 | def deleteobsmarkers(obsstore, indices): | ||
"""Delete some obsmarkers from obsstore and return how many were deleted | ||||
'indices' is a list of ints which are the indices | ||||
of the markers to be deleted. | ||||
Every invocation of this function completely rewrites the obsstore file, | ||||
skipping the markers we want to be removed. The new temporary file is | ||||
created, remaining markers are written there and on .close() this file | ||||
gets atomically renamed to obsstore, thus guaranteeing consistency.""" | ||||
if not indices: | ||||
# we don't want to rewrite the obsstore with the same content | ||||
return | ||||
left = [] | ||||
current = obsstore._all | ||||
n = 0 | ||||
for i, m in enumerate(current): | ||||
if i in indices: | ||||
n += 1 | ||||
continue | ||||
left.append(m) | ||||
newobsstorefile = obsstore.svfs('obsstore', 'w', atomictemp=True) | ||||
for bytes in obsolete.encodemarkers(left, True, obsstore._version): | ||||
newobsstorefile.write(bytes) | ||||
newobsstorefile.close() | ||||
return n | ||||