# obsolete.py - introduce the obsolete concept in mercurial.
#
# Copyright 2011 Pierre-Yves David <pierre-yves.david@ens-lyon.org>
# Logilab SA <contact@logilab.fr>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
"""Introduce the Obsolete concept to mercurial
General concept
===============
This extension introduces the *obsolete* concept. It adds a new *obsolete*
relation between two changesets. A relation ``<changeset B> obsolete <changeset
A>`` is set to denote that ``<changeset B>`` is new version of ``<changeset
A>``.
The *obsolete* relation act as a **perpendicular history** to the standard
changeset history. Standard changeset history versions files. The *obsolete*
relation versions changesets.
:obsolete: a changeset that has been replaced by another one.
:unstable: a changeset that is not obsolete but has an obsolete ancestor.
:suspended: an obsolete changeset with unstable descendant.
:extinct: an obsolete changeset without unstable descendant.
(subject to garbage collection)
Another name for unstable could be out of sync.
Usage and Feature
=================
New commands
------------
Note that rebased changesets are now marked obsolete instead of being stripped.
"""
import os, sys
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from mercurial.i18n import _
import json
import struct
from mercurial import util, base85
_pack = struct.pack
_unpack = struct.unpack
from mercurial import util
from mercurial import context
from mercurial import revset
from mercurial import scmutil
from mercurial import extensions
from mercurial import pushkey
from mercurial import discovery
from mercurial import error
from mercurial import commands
from mercurial import changelog
from mercurial import phases
from mercurial.node import hex, bin, short, nullid
from mercurial.lock import release
from mercurial import localrepo
from mercurial import cmdutil
from mercurial import templatekw
from mercurial import obsolete
obsolete._enabled = True
try:
from mercurial.localrepo import storecache
storecache('babar') # to trigger import
except (TypeError, ImportError):
def storecache(*args):
return scmutil.filecache(*args, instore=True)
### Patch changectx
#############################
def unstable(ctx):
"""is the changeset unstable (have obsolete ancestor)"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._unstableset
context.changectx.unstable = unstable
def extinct(ctx):
"""is the changeset extinct by other"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._extinctset
context.changectx.extinct = extinct
def latecomer(ctx):
"""is the changeset latecomer (Try to succeed to public change)"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._latecomerset
context.changectx.latecomer = latecomer
def conflicting(ctx):
"""is the changeset conflicting (Try to succeed to public change)"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._conflictingset
context.changectx.conflicting = conflicting
### revset
#############################
def revsethidden(repo, subset, x):
"""``hidden()``
Changeset is hidden.
"""
args = revset.getargs(x, 0, 0, 'hidden takes no argument')
return [r for r in subset if r in repo.hiddenrevs]
def revsetobsolete(repo, subset, x):
"""``obsolete()``
Changeset is obsolete.
"""
args = revset.getargs(x, 0, 0, 'obsolete takes no argument')
return [r for r in subset if r in repo._obsoleteset and repo._phasecache.phase(repo, r) > 0]
# XXX Backward compatibility, to be removed once stabilized
if '_phasecache' not in vars(localrepo.localrepository): # new api
def revsetobsolete(repo, subset, x):
"""``obsolete()``
Changeset is obsolete.
"""
args = revset.getargs(x, 0, 0, 'obsolete takes no argument')
return [r for r in subset if r in repo._obsoleteset and repo._phaserev[r] > 0]
def revsetunstable(repo, subset, x):
"""``unstable()``
Unstable changesets are non-obsolete with obsolete ancestors.
"""
args = revset.getargs(x, 0, 0, 'unstable takes no arguments')
return [r for r in subset if r in repo._unstableset]
def revsetsuspended(repo, subset, x):
"""``suspended()``
Obsolete changesets with non-obsolete descendants.
"""
args = revset.getargs(x, 0, 0, 'suspended takes no arguments')
return [r for r in subset if r in repo._suspendedset]
def revsetextinct(repo, subset, x):
"""``extinct()``
Obsolete changesets with obsolete descendants only.
"""
args = revset.getargs(x, 0, 0, 'extinct takes no arguments')
return [r for r in subset if r in repo._extinctset]
def revsetlatecomer(repo, subset, x):
"""``latecomer()``
Changesets marked as successors of public changesets.
"""
args = revset.getargs(x, 0, 0, 'latecomer takes no arguments')
return [r for r in subset if r in repo._latecomerset]
def revsetconflicting(repo, subset, x):
"""``conflicting()``
Changesets marked as successors of a same changeset.
"""
args = revset.getargs(x, 0, 0, 'conflicting takes no arguments')
return [r for r in subset if r in repo._conflictingset]
def _precursors(repo, s):
"""Precursor of a changeset"""
cs = set()
nm = repo.changelog.nodemap
markerbysubj = repo.obsstore.successors
for r in s:
for p in markerbysubj.get(repo[r].node(), ()):
pr = nm.get(p[0])
if pr is not None:
cs.add(pr)
return cs
def revsetprecursors(repo, subset, x):
"""``precursors(set)``
Immediate precursors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _precursors(repo, s)
return [r for r in subset if r in cs]
def _allprecursors(repo, s): # XXX we need a better naming
"""transitive precursors of a subset"""
toproceed = [repo[r].node() for r in s]
seen = set()
allsubjects = repo.obsstore.successors
while toproceed:
nc = toproceed.pop()
for mark in allsubjects.get(nc, ()):
np = mark[0]
if np not in seen:
seen.add(np)
toproceed.append(np)
nm = repo.changelog.nodemap
cs = set()
for p in seen:
pr = nm.get(p)
if pr is not None:
cs.add(pr)
return cs
def revsetallprecursors(repo, subset, x):
"""``allprecursors(set)``
Transitive precursors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _allprecursors(repo, s)
return [r for r in subset if r in cs]
def _successors(repo, s):
"""Successors of a changeset"""
cs = set()
nm = repo.changelog.nodemap
markerbyobj = repo.obsstore.precursors
for r in s:
for p in markerbyobj.get(repo[r].node(), ()):
for sub in p[1]:
sr = nm.get(sub)
if sr is not None:
cs.add(sr)
return cs
def revsetsuccessors(repo, subset, x):
"""``successors(set)``
Immediate successors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _successors(repo, s)
return [r for r in subset if r in cs]
def _allsuccessors(repo, s): # XXX we need a better naming
"""transitive successors of a subset"""
toproceed = [repo[r].node() for r in s]
seen = set()
allobjects = repo.obsstore.precursors
while toproceed:
nc = toproceed.pop()
for mark in allobjects.get(nc, ()):
for sub in mark[1]:
if sub not in seen:
seen.add(sub)
toproceed.append(sub)
nm = repo.changelog.nodemap
cs = set()
for s in seen:
sr = nm.get(s)
if sr is not None:
cs.add(sr)
return cs
def revsetallsuccessors(repo, subset, x):
"""``allsuccessors(set)``
Transitive successors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _allsuccessors(repo, s)
return [r for r in subset if r in cs]
### template keywords
#####################
def obsoletekw(repo, ctx, templ, **args):
""":obsolete: String. The obsolescence level of the node, could be
``stable``, ``unstable``, ``suspended`` or ``extinct``.
"""
rev = ctx.rev()
if rev in repo._extinctset:
return 'extinct'
if rev in repo._suspendedset:
return 'suspended'
if rev in repo._unstableset:
return 'unstable'
return 'stable'
### Other Extension compat
############################
def buildstate(orig, repo, dest, rebaseset, *ags, **kws):
"""wrapper for rebase 's buildstate that exclude obsolete changeset"""
rebaseset = repo.revs('%ld - extinct()', rebaseset)
return orig(repo, dest, rebaseset, *ags, **kws)
def defineparents(orig, repo, rev, target, state, *args, **kwargs):
rebasestate = getattr(repo, '_rebasestate', None)
if rebasestate is not None:
repo._rebasestate = dict(state)
repo._rebasetarget = target
return orig(repo, rev, target, state, *args, **kwargs)
def concludenode(orig, repo, rev, p1, *args, **kwargs):
"""wrapper for rebase 's concludenode that set obsolete relation"""
newrev = orig(repo, rev, p1, *args, **kwargs)
rebasestate = getattr(repo, '_rebasestate', None)
if rebasestate is not None:
if newrev is not None:
nrev = repo[newrev].rev()
else:
nrev = p1
repo._rebasestate[rev] = nrev
return newrev
def cmdrebase(orig, ui, repo, *args, **kwargs):
reallykeep = kwargs.get('keep', False)
kwargs = dict(kwargs)
kwargs['keep'] = True
# We want to mark rebased revision as obsolete and set their
# replacements if any. Doing it in concludenode() prevents
# aborting the rebase, and is not called with all relevant
# revisions in --collapse case. Instead, we try to track the
# rebase state structure by sampling/updating it in
# defineparents() and concludenode(). The obsolete markers are
# added from this state after a successful call.
repo._rebasestate = {}
repo._rebasetarget = None
try:
res = orig(ui, repo, *args, **kwargs)
if not reallykeep:
# Filter nullmerge or unrebased entries
repo._rebasestate = dict(p for p in repo._rebasestate.iteritems()
if p[1] >= 0)
if not res and not kwargs.get('abort') and repo._rebasestate:
# Rebased revisions are assumed to be descendants of
# targetrev. If a source revision is mapped to targetrev
# or to another rebased revision, it must have been
# removed.
targetrev = repo[repo._rebasetarget].rev()
newrevs = set([targetrev])
replacements = {}
for rev, newrev in sorted(repo._rebasestate.items()):
oldnode = repo[rev].node()
if newrev not in newrevs:
newnode = repo[newrev].node()
newrevs.add(newrev)
else:
newnode = nullid
replacements[oldnode] = newnode
if kwargs.get('collapse'):
newnodes = set(n for n in replacements.values() if n != nullid)
if newnodes:
# Collapsing into more than one revision?
assert len(newnodes) == 1, newnodes
newnode = newnodes.pop()
else:
newnode = nullid
repo.addcollapsedobsolete(replacements, newnode)
else:
for oldnode, newnode in replacements.iteritems():
repo.addobsolete(newnode, oldnode)
return res
finally:
delattr(repo, '_rebasestate')
delattr(repo, '_rebasetarget')
def extsetup(ui):
revset.symbols["hidden"] = revsethidden
revset.symbols["obsolete"] = revsetobsolete
revset.symbols["unstable"] = revsetunstable
revset.symbols["suspended"] = revsetsuspended
revset.symbols["extinct"] = revsetextinct
revset.symbols["latecomer"] = revsetlatecomer
revset.symbols["conflicting"] = revsetconflicting
revset.symbols["obsparents"] = revsetprecursors # DEPR
revset.symbols["precursors"] = revsetprecursors
revset.symbols["obsancestors"] = revsetallprecursors # DEPR
revset.symbols["allprecursors"] = revsetallprecursors # bad name
revset.symbols["successors"] = revsetsuccessors
revset.symbols["allsuccessors"] = revsetallsuccessors # bad name
templatekw.keywords['obsolete'] = obsoletekw
# warning about more obsolete
for cmd in ['commit', 'push', 'pull', 'graft', 'phase', 'unbundle']:
entry = extensions.wrapcommand(commands.table, cmd, warnobserrors)
try:
rebase = extensions.find('rebase')
if rebase:
entry = extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)
extensions.wrapfunction(rebase, 'buildstate', buildstate)
extensions.wrapfunction(rebase, 'defineparents', defineparents)
extensions.wrapfunction(rebase, 'concludenode', concludenode)
extensions.wrapcommand(rebase.cmdtable, "rebase", cmdrebase)
except KeyError:
pass # rebase not found
### Discovery wrapping
#############################
def wrapcheckheads(orig, repo, remote, outgoing, *args, **kwargs):
"""wrap mercurial.discovery.checkheads
* prevent unstability to be pushed
* patch remote to ignore obsolete heads on remote
"""
# do not push instability
for h in outgoing.missingheads:
# Checking heads is enough, obsolete descendants are either
# obsolete or unstable.
ctx = repo[h]
if ctx.latecomer():
raise util.Abort(_("push includes a latecomer changeset: %s!")
% ctx)
if ctx.conflicting():
raise util.Abort(_("push includes a conflicting changeset: %s!")
% ctx)
return orig(repo, remote, outgoing, *args, **kwargs)
def wrapclearcache(orig, repo, *args, **kwargs):
try:
return orig(repo, *args, **kwargs)
finally:
repo._clearobsoletecache()
### New commands
#############################
cmdtable = {}
command = cmdutil.command(cmdtable)
@command('debugconvertobsolete', [], '')
def cmddebugconvertobsolete(ui, repo):
"""import markers from an .hg/obsolete-relations file"""
cnt = 0
err = 0
l = repo.lock()
some = False
try:
unlink = []
tr = repo.transaction('convert-obsolete')
try:
repo._importoldobsolete = True
store = repo.obsstore
### very first format
try:
f = repo.opener('obsolete-relations')
try:
some = True
for line in f:
subhex, objhex = line.split()
suc = bin(subhex)
prec = bin(objhex)
sucs = (suc==nullid) and [] or [suc]
meta = {
'date': '%i %i' % util.makedate(),
'user': ui.username(),
}
try:
store.create(tr, prec, sucs, 0, meta)
cnt += 1
except ValueError:
repo.ui.write_err("invalid old marker line: %s"
% (line))
err += 1
finally:
f.close()
unlink.append(repo.join('obsolete-relations'))
except IOError:
pass
### second (json) format
data = repo.sopener.tryread('obsoletemarkers')
if data:
some = True
for oldmark in json.loads(data):
del oldmark['id'] # dropped for now
del oldmark['reason'] # unused until then
oldobject = str(oldmark.pop('object'))
oldsubjects = [str(s) for s in oldmark.pop('subjects', [])]
LOOKUP_ERRORS = (error.RepoLookupError, error.LookupError)
if len(oldobject) != 40:
try:
oldobject = repo[oldobject].node()
except LOOKUP_ERRORS:
pass
if any(len(s) != 40 for s in oldsubjects):
try:
oldsubjects = [repo[s].node() for s in oldsubjects]
except LOOKUP_ERRORS:
pass
oldmark['date'] = '%i %i' % tuple(oldmark['date'])
meta = dict((k.encode('utf-8'), v.encode('utf-8'))
for k, v in oldmark.iteritems())
try:
succs = [bin(n) for n in oldsubjects]
succs = [n for n in succs if n != nullid]
store.create(tr, bin(oldobject), succs,
0, meta)
cnt += 1
except ValueError:
repo.ui.write_err("invalid marker %s -> %s\n"
% (oldobject, oldsubjects))
err += 1
unlink.append(repo.sjoin('obsoletemarkers'))
tr.close()
for path in unlink:
util.unlink(path)
finally:
tr.release()
finally:
del repo._importoldobsolete
l.release()
if not some:
ui.warn('nothing to do\n')
ui.status('%i obsolete marker converted\n' % cnt)
if err:
ui.write_err('%i conversion failed. check you graph!\n' % err)
@command('debugsuccessors', [], '')
def cmddebugsuccessors(ui, repo):
"""dump obsolete changesets and their successors
Each line matches an existing marker, the first identifier is the
obsolete changeset identifier, followed by it successors.
"""
lock = repo.lock()
try:
allsuccessors = repo.obsstore.precursors
for old in sorted(allsuccessors):
successors = [sorted(m[1]) for m in allsuccessors[old]]
for i, group in enumerate(sorted(successors)):
ui.write('%s' % short(old))
for new in group:
ui.write(' %s' % short(new))
ui.write('\n')
finally:
lock.release()
### Altering existing command
#############################
def wrapmayobsoletewc(origfn, ui, repo, *args, **opts):
res = origfn(ui, repo, *args, **opts)
if repo['.'].obsolete():
ui.warn(_('Working directory parent is obsolete\n'))
return res
def warnobserrors(orig, ui, repo, *args, **kwargs):
"""display warning is the command resulted in more instable changeset"""
priorunstables = len(repo.revs('unstable()'))
priorlatecomers = len(repo.revs('latecomer()'))
priorconflictings = len(repo.revs('conflicting()'))
#print orig, priorunstables
#print len(repo.revs('secret() - obsolete()'))
try:
return orig(ui, repo, *args, **kwargs)
finally:
newunstables = len(repo.revs('unstable()')) - priorunstables
newlatecomers = len(repo.revs('latecomer()')) - priorlatecomers
newconflictings = len(repo.revs('conflicting()')) - priorconflictings
#print orig, newunstables
#print len(repo.revs('secret() - obsolete()'))
if newunstables > 0:
ui.warn(_('%i new unstables changesets\n') % newunstables)
if newlatecomers > 0:
ui.warn(_('%i new latecomers changesets\n') % newlatecomers)
if newconflictings > 0:
ui.warn(_('%i new conflictings changesets\n') % newconflictings)
def wrapcmdutilamend(orig, ui, repo, commitfunc, old, *args, **kwargs):
oldnode = old.node()
new = orig(ui, repo, commitfunc, old, *args, **kwargs)
if new != oldnode:
lock = repo.lock()
try:
tr = repo.transaction('post-amend-obst')
try:
meta = {
'date': '%i %i' % util.makedate(),
'user': ui.username(),
}
repo.obsstore.create(tr, oldnode, [new], 0, meta)
tr.close()
repo._clearobsoletecache()
finally:
tr.release()
finally:
lock.release()
return new
def uisetup(ui):
extensions.wrapcommand(commands.table, "update", wrapmayobsoletewc)
extensions.wrapcommand(commands.table, "pull", wrapmayobsoletewc)
if util.safehasattr(cmdutil, 'amend'):
extensions.wrapfunction(cmdutil, 'amend', wrapcmdutilamend)
extensions.wrapfunction(discovery, 'checkheads', wrapcheckheads)
extensions.wrapfunction(phases, 'advanceboundary', wrapclearcache)
### serialisation
#############################
def _obsserialise(obssubrels, flike):
"""serialise an obsolete relation mapping in a plain text one
this is for subject -> [objects] mapping
format is::
<subject-full-hex> <object-full-hex>\n"""
for sub, objs in obssubrels.iteritems():
for obj in objs:
if sub is None:
sub = nullid
flike.write('%s %s\n' % (hex(sub), hex(obj)))
def _obsdeserialise(flike):
"""read a file like object serialised with _obsserialise
this desierialize into a {subject -> objects} mapping"""
rels = {}
for line in flike:
subhex, objhex = line.split()
subnode = bin(subhex)
if subnode == nullid:
subnode = None
rels.setdefault( subnode, set()).add(bin(objhex))
return rels
### diagnostique tools
#############################
def unstables(repo):
"""Return all unstable changeset"""
return scmutil.revrange(repo, ['obsolete():: and (not obsolete())'])
def newerversion(repo, obs):
"""Return the newer version of an obsolete changeset"""
toproceed = set([(obs,)])
# XXX known optimization available
newer = set()
objectrels = repo.obsstore.precursors
while toproceed:
current = toproceed.pop()
assert len(current) <= 1, 'splitting not handled yet. %r' % current
current = [n for n in current if n != nullid]
if current:
n, = current
if n in objectrels:
markers = objectrels[n]
for mark in markers:
toproceed.add(tuple(mark[1]))
else:
newer.add(tuple(current))
else:
newer.add(())
return sorted(newer)
### repo subclassing
#############################
def reposetup(ui, repo):
if not repo.local():
return
if not util.safehasattr(repo.opener, 'tryread'):
raise util.Abort('Obsolete extension requires Mercurial 2.2 (or later)')
opush = repo.push
o_updatebranchcache = repo.updatebranchcache
# /!\ api change in Hg 2.2 (97efd26eb9576f39590812ea9) /!\
if util.safehasattr(repo, '_journalfiles'): # Hg 2.2
o_journalfiles = repo._journalfiles
o_writejournal = repo._writejournal
o_hook = repo.hook
class obsoletingrepo(repo.__class__):
# workaround
def hook(self, name, throw=False, **args):
if 'pushkey' in name:
args.pop('new')
args.pop('old')
return o_hook(name, throw=False, **args)
### Public method
def obsoletedby(self, node):
"""return the set of node that make <node> obsolete (obj)"""
others = set()
for marker in self.obsstore.precursors.get(node, []):
others.update(marker[1])
return others
def obsolete(self, node):
"""return the set of node that <node> make obsolete (sub)"""
return set(marker[0] for marker in self.obsstore.successors.get(node, []))
@util.propertycache
def _obsoleteset(self):
"""the set of obsolete revision"""
obs = set()
nm = self.changelog.nodemap
for prec in self.obsstore.precursors:
rev = nm.get(prec)
if rev is not None:
obs.add(rev)
return obs
@util.propertycache
def _unstableset(self):
"""the set of non obsolete revision with obsolete parent"""
return set(self.revs('(obsolete()::) - obsolete()'))
@util.propertycache
def _suspendedset(self):
"""the set of obsolete parent with non obsolete descendant"""
return set(self.revs('obsolete() and obsolete()::unstable()'))
@util.propertycache
def _extinctset(self):
"""the set of obsolete parent without non obsolete descendant"""
return set(self.revs('obsolete() - obsolete()::unstable()'))
@util.propertycache
def _latecomerset(self):
"""the set of rev trying to obsolete public revision"""
query = 'allsuccessors(public()) - obsolete() - public()'
return set(self.revs(query))
@util.propertycache
def _conflictingset(self):
"""the set of rev trying to obsolete public revision"""
conflicting = set()
obsstore = self.obsstore
newermap = {}
for ctx in self.set('(not public()) - obsolete()'):
prec = obsstore.successors.get(ctx.node(), ())
toprocess = set(prec)
while toprocess:
prec = toprocess.pop()[0]
if prec not in newermap:
newermap[prec] = newerversion(self, prec)
newer = [n for n in newermap[prec] if n] # filter kill
if len(newer) > 1:
conflicting.add(ctx.rev())
break
toprocess.update(obsstore.successors.get(prec, ()))
return conflicting
def _clearobsoletecache(self):
if '_obsoleteset' in vars(self):
del self._obsoleteset
self._clearunstablecache()
def updatebranchcache(self):
o_updatebranchcache()
self._clearunstablecache()
def _clearunstablecache(self):
if '_unstableset' in vars(self):
del self._unstableset
if '_suspendedset' in vars(self):
del self._suspendedset
if '_extinctset' in vars(self):
del self._extinctset
if '_latecomerset' in vars(self):
del self._latecomerset
if '_conflictingset' in vars(self):
del self._conflictingset
def addobsolete(self, sub, obj):
"""Add a relation marking that node <sub> is a new version of <obj>"""
assert sub != obj
if not repo[obj].phase():
if sub is None:
self.ui.warn(
_("trying to kill immutable changeset %(obj)s\n")
% {'obj': short(obj)})
if sub is not None:
self.ui.warn(
_("%(sub)s try to obsolete immutable changeset %(obj)s\n")
% {'sub': short(sub), 'obj': short(obj)})
lock = self.lock()
try:
tr = self.transaction('add-obsolete')
try:
meta = {
'date': '%i %i' % util.makedate(),
'user': ui.username(),
}
subs = (sub == nullid) and [] or [sub]
mid = self.obsstore.create(tr, obj, subs, 0, meta)
tr.close()
self._clearobsoletecache()
return mid
finally:
tr.release()
finally:
lock.release()
def addcollapsedobsolete(self, oldnodes, newnode):
"""Mark oldnodes as collapsed into newnode."""
# Assume oldnodes are all descendants of a single rev
rootrevs = self.revs('roots(%ln)', oldnodes)
assert len(rootrevs) == 1, rootrevs
#rootnode = self[rootrevs[0]].node()
for n in oldnodes:
self.addobsolete(newnode, n)
### pull // push support
def push(self, remote, *args, **opts):
"""wrapper around pull that pull obsolete relation"""
try:
result = opush(remote, *args, **opts)
except util.Abort, ex:
hint = _("use 'hg stabilize' to get a stable history "
"or --force to ignore warnings")
if (len(ex.args) >= 1
and ex.args[0].startswith('push includes ')
and ex.hint is None):
ex.hint = hint
raise
return result
repo.__class__ = obsoletingrepo
for arg in sys.argv:
if 'debugc' in arg:
break
else:
data = repo.opener.tryread('obsolete-relations')
if not data:
data = repo.sopener.tryread('obsoletemarkers')
if data:
raise util.Abort('old format of obsolete marker detected!\n'
'run `hg debugconvertobsolete` once.')