obsolete: add readonly flag to obstore constructor

Previously, obstore read the obsolete._enabled flag to determine whether to
allow writes to the obstore. Since obsolete._enabled will be moving into a repo
specific config, we can't read it globally, and therefore must pass the
information into the constructor.

mercurial/localrepo.py

@@ -1,1790 +1,1791 b''
 # localrepo.py - read/write repository class for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from node import hex, nullid, short
 from i18n import _
 import urllib
 import peer, changegroup, subrepo, pushkey, obsolete, repoview
 import changelog, dirstate, filelog, manifest, context, bookmarks, phases
 import lock as lockmod
 import transaction, store, encoding, exchange, bundle2
 import scmutil, util, extensions, hook, error, revset
 import match as matchmod
 import merge as mergemod
 import tags as tagsmod
 from lock import release
 import weakref, errno, os, time, inspect
 import branchmap, pathutil
 propertycache = util.propertycache
 filecache = scmutil.filecache
 
 class repofilecache(filecache):
     """All filecache usage on repo are done for logic that should be unfiltered
     """
 
     def __get__(self, repo, type=None):
         return super(repofilecache, self).__get__(repo.unfiltered(), type)
     def __set__(self, repo, value):
         return super(repofilecache, self).__set__(repo.unfiltered(), value)
     def __delete__(self, repo):
         return super(repofilecache, self).__delete__(repo.unfiltered())
 
 class storecache(repofilecache):
     """filecache for files in the store"""
     def join(self, obj, fname):
         return obj.sjoin(fname)
 
 class unfilteredpropertycache(propertycache):
     """propertycache that apply to unfiltered repo only"""
 
     def __get__(self, repo, type=None):
         unfi = repo.unfiltered()
         if unfi is repo:
             return super(unfilteredpropertycache, self).__get__(unfi)
         return getattr(unfi, self.name)
 
 class filteredpropertycache(propertycache):
     """propertycache that must take filtering in account"""
 
     def cachevalue(self, obj, value):
         object.__setattr__(obj, self.name, value)
 
 
 def hasunfilteredcache(repo, name):
     """check if a repo has an unfilteredpropertycache value for <name>"""
     return name in vars(repo.unfiltered())
 
 def unfilteredmethod(orig):
     """decorate method that always need to be run on unfiltered version"""
     def wrapper(repo, *args, **kwargs):
         return orig(repo.unfiltered(), *args, **kwargs)
     return wrapper
 
 moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
                   'unbundle'))
 legacycaps = moderncaps.union(set(['changegroupsubset']))
 
 class localpeer(peer.peerrepository):
     '''peer for a local repo; reflects only the most recent API'''
 
     def __init__(self, repo, caps=moderncaps):
         peer.peerrepository.__init__(self)
         self._repo = repo.filtered('served')
         self.ui = repo.ui
         self._caps = repo._restrictcapabilities(caps)
         self.requirements = repo.requirements
         self.supportedformats = repo.supportedformats
 
     def close(self):
         self._repo.close()
 
     def _capabilities(self):
         return self._caps
 
     def local(self):
         return self._repo
 
     def canpush(self):
         return True
 
     def url(self):
         return self._repo.url()
 
     def lookup(self, key):
         return self._repo.lookup(key)
 
     def branchmap(self):
         return self._repo.branchmap()
 
     def heads(self):
         return self._repo.heads()
 
     def known(self, nodes):
         return self._repo.known(nodes)
 
     def getbundle(self, source, heads=None, common=None, bundlecaps=None,
                   format='HG10', **kwargs):
         cg = exchange.getbundle(self._repo, source, heads=heads,
                                 common=common, bundlecaps=bundlecaps, **kwargs)
         if bundlecaps is not None and 'HG2X' in bundlecaps:
             # When requesting a bundle2, getbundle returns a stream to make the
             # wire level function happier. We need to build a proper object
             # from it in local peer.
             cg = bundle2.unbundle20(self.ui, cg)
         return cg
 
     # TODO We might want to move the next two calls into legacypeer and add
     # unbundle instead.
 
     def unbundle(self, cg, heads, url):
         """apply a bundle on a repo
 
         This function handles the repo locking itself."""
         try:
             cg = exchange.readbundle(self.ui, cg, None)
             ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
             if util.safehasattr(ret, 'getchunks'):
                 # This is a bundle20 object, turn it into an unbundler.
                 # This little dance should be dropped eventually when the API
                 # is finally improved.
                 stream = util.chunkbuffer(ret.getchunks())
                 ret = bundle2.unbundle20(self.ui, stream)
             return ret
         except error.PushRaced, exc:
             raise error.ResponseError(_('push failed:'), str(exc))
 
     def lock(self):
         return self._repo.lock()
 
     def addchangegroup(self, cg, source, url):
         return changegroup.addchangegroup(self._repo, cg, source, url)
 
     def pushkey(self, namespace, key, old, new):
         return self._repo.pushkey(namespace, key, old, new)
 
     def listkeys(self, namespace):
         return self._repo.listkeys(namespace)
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         '''used to test argument passing over the wire'''
         return "%s %s %s %s %s" % (one, two, three, four, five)
 
 class locallegacypeer(localpeer):
     '''peer extension which implements legacy methods too; used for tests with
     restricted capabilities'''
 
     def __init__(self, repo):
         localpeer.__init__(self, repo, caps=legacycaps)
 
     def branches(self, nodes):
         return self._repo.branches(nodes)
 
     def between(self, pairs):
         return self._repo.between(pairs)
 
     def changegroup(self, basenodes, source):
         return changegroup.changegroup(self._repo, basenodes, source)
 
     def changegroupsubset(self, bases, heads, source):
         return changegroup.changegroupsubset(self._repo, bases, heads, source)
 
 class localrepository(object):
 
     supportedformats = set(('revlogv1', 'generaldelta'))
     _basesupported = supportedformats | set(('store', 'fncache', 'shared',
                                              'dotencode'))
     openerreqs = set(('revlogv1', 'generaldelta'))
     requirements = ['revlogv1']
     filtername = None
 
     # a list of (ui, featureset) functions.
     # only functions defined in module of enabled extensions are invoked
     featuresetupfuncs = set()
 
     def _baserequirements(self, create):
         return self.requirements[:]
 
     def __init__(self, baseui, path=None, create=False):
         self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
         self.wopener = self.wvfs
         self.root = self.wvfs.base
         self.path = self.wvfs.join(".hg")
         self.origroot = path
         self.auditor = pathutil.pathauditor(self.root, self._checknested)
         self.vfs = scmutil.vfs(self.path)
         self.opener = self.vfs
         self.baseui = baseui
         self.ui = baseui.copy()
         self.ui.copy = baseui.copy # prevent copying repo configuration
         # A list of callback to shape the phase if no data were found.
         # Callback are in the form: func(repo, roots) --> processed root.
         # This list it to be filled by extension during repo setup
         self._phasedefaults = []
         try:
             self.ui.readconfig(self.join("hgrc"), self.root)
             extensions.loadall(self.ui)
         except IOError:
             pass
 
         if self.featuresetupfuncs:
             self.supported = set(self._basesupported) # use private copy
             extmods = set(m.__name__ for n, m
                           in extensions.extensions(self.ui))
             for setupfunc in self.featuresetupfuncs:
                 if setupfunc.__module__ in extmods:
                     setupfunc(self.ui, self.supported)
         else:
             self.supported = self._basesupported
 
         if not self.vfs.isdir():
             if create:
                 if not self.wvfs.exists():
                     self.wvfs.makedirs()
                 self.vfs.makedir(notindexed=True)
                 requirements = self._baserequirements(create)
                 if self.ui.configbool('format', 'usestore', True):
                     self.vfs.mkdir("store")
                     requirements.append("store")
                     if self.ui.configbool('format', 'usefncache', True):
                         requirements.append("fncache")
                         if self.ui.configbool('format', 'dotencode', True):
                             requirements.append('dotencode')
                     # create an invalid changelog
                     self.vfs.append(
                         "00changelog.i",
                         '\0\0\0\2' # represents revlogv2
                         ' dummy changelog to prevent using the old repo layout'
                     )
                 if self.ui.configbool('format', 'generaldelta', False):
                     requirements.append("generaldelta")
                 requirements = set(requirements)
             else:
                 raise error.RepoError(_("repository %s not found") % path)
         elif create:
             raise error.RepoError(_("repository %s already exists") % path)
         else:
             try:
                 requirements = scmutil.readrequires(self.vfs, self.supported)
             except IOError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
                 requirements = set()
 
         self.sharedpath = self.path
         try:
             vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
                               realpath=True)
             s = vfs.base
             if not vfs.exists():
                 raise error.RepoError(
                     _('.hg/sharedpath points to nonexistent directory %s') % s)
             self.sharedpath = s
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
 
         self.store = store.store(requirements, self.sharedpath, scmutil.vfs)
         self.spath = self.store.path
         self.svfs = self.store.vfs
         self.sopener = self.svfs
         self.sjoin = self.store.join
         self.vfs.createmode = self.store.createmode
         self._applyrequirements(requirements)
         if create:
             self._writerequirements()
 
 
         self._branchcaches = {}
         self.filterpats = {}
         self._datafilters = {}
         self._transref = self._lockref = self._wlockref = None
 
         # A cache for various files under .hg/ that tracks file changes,
         # (used by the filecache decorator)
         #
         # Maps a property name to its util.filecacheentry
         self._filecache = {}
 
         # hold sets of revision to be filtered
         # should be cleared when something might have changed the filter value:
         # - new changesets,
         # - phase change,
         # - new obsolescence marker,
         # - working directory parent change,
         # - bookmark changes
         self.filteredrevcache = {}
 
     def close(self):
         pass
 
     def _restrictcapabilities(self, caps):
         # bundle2 is not ready for prime time, drop it unless explicitly
         # required by the tests (or some brave tester)
         if self.ui.configbool('experimental', 'bundle2-exp', False):
             caps = set(caps)
             capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))
             caps.add('bundle2-exp=' + urllib.quote(capsblob))
         return caps
 
     def _applyrequirements(self, requirements):
         self.requirements = requirements
         self.sopener.options = dict((r, 1) for r in requirements
                                            if r in self.openerreqs)
         chunkcachesize = self.ui.configint('format', 'chunkcachesize')
         if chunkcachesize is not None:
             self.sopener.options['chunkcachesize'] = chunkcachesize
 
     def _writerequirements(self):
         reqfile = self.opener("requires", "w")
         for r in sorted(self.requirements):
             reqfile.write("%s\n" % r)
         reqfile.close()
 
     def _checknested(self, path):
         """Determine if path is a legal nested repository."""
         if not path.startswith(self.root):
             return False
         subpath = path[len(self.root) + 1:]
         normsubpath = util.pconvert(subpath)
 
         # XXX: Checking against the current working copy is wrong in
         # the sense that it can reject things like
         #
         #   $ hg cat -r 10 sub/x.txt
         #
         # if sub/ is no longer a subrepository in the working copy
         # parent revision.
         #
         # However, it can of course also allow things that would have
         # been rejected before, such as the above cat command if sub/
         # is a subrepository now, but was a normal directory before.
         # The old path auditor would have rejected by mistake since it
         # panics when it sees sub/.hg/.
         #
         # All in all, checking against the working copy seems sensible
         # since we want to prevent access to nested repositories on
         # the filesystem *now*.
         ctx = self[None]
         parts = util.splitpath(subpath)
         while parts:
             prefix = '/'.join(parts)
             if prefix in ctx.substate:
                 if prefix == normsubpath:
                     return True
                 else:
                     sub = ctx.sub(prefix)
                     return sub.checknested(subpath[len(prefix) + 1:])
             else:
                 parts.pop()
         return False
 
     def peer(self):
         return localpeer(self) # not cached to avoid reference cycle
 
     def unfiltered(self):
         """Return unfiltered version of the repository
 
         Intended to be overwritten by filtered repo."""
         return self
 
     def filtered(self, name):
         """Return a filtered version of a repository"""
         # build a new class with the mixin and the current class
         # (possibly subclass of the repo)
         class proxycls(repoview.repoview, self.unfiltered().__class__):
             pass
         return proxycls(self, name)
 
     @repofilecache('bookmarks')
     def _bookmarks(self):
         return bookmarks.bmstore(self)
 
     @repofilecache('bookmarks.current')
     def _bookmarkcurrent(self):
         return bookmarks.readcurrent(self)
 
     def bookmarkheads(self, bookmark):
         name = bookmark.split('@', 1)[0]
         heads = []
         for mark, n in self._bookmarks.iteritems():
             if mark.split('@', 1)[0] == name:
                 heads.append(n)
         return heads
 
     @storecache('phaseroots')
     def _phasecache(self):
         return phases.phasecache(self, self._phasedefaults)
 
     @storecache('obsstore')
     def obsstore(self):
         # read default format for new obsstore.
         defaultformat = self.ui.configint('format', 'obsstore-version', None)
         # rely on obsstore class default when possible.
         kwargs = {}
         if defaultformat is not None:
             kwargs['defaultformat'] = defaultformat
-        store = obsolete.obsstore(self.sopener, **kwargs)
+        store = obsolete.obsstore(self.sopener, readonly=not obsolete._enabled,
+                                  **kwargs)
         if store and not obsolete._enabled:
             # message is rare enough to not be translated
             msg = 'obsolete feature not enabled but %i markers found!\n'
             self.ui.warn(msg % len(list(store)))
         return store
 
     @storecache('00changelog.i')
     def changelog(self):
         c = changelog.changelog(self.sopener)
         if 'HG_PENDING' in os.environ:
             p = os.environ['HG_PENDING']
             if p.startswith(self.root):
                 c.readpending('00changelog.i.a')
         return c
 
     @storecache('00manifest.i')
     def manifest(self):
         return manifest.manifest(self.sopener)
 
     @repofilecache('dirstate')
     def dirstate(self):
         warned = [0]
         def validate(node):
             try:
                 self.changelog.rev(node)
                 return node
             except error.LookupError:
                 if not warned[0]:
                     warned[0] = True
                     self.ui.warn(_("warning: ignoring unknown"
                                    " working parent %s!\n") % short(node))
                 return nullid
 
         return dirstate.dirstate(self.opener, self.ui, self.root, validate)
 
     def __getitem__(self, changeid):
         if changeid is None:
             return context.workingctx(self)
         return context.changectx(self, changeid)
 
     def __contains__(self, changeid):
         try:
             return bool(self.lookup(changeid))
         except error.RepoLookupError:
             return False
 
     def __nonzero__(self):
         return True
 
     def __len__(self):
         return len(self.changelog)
 
     def __iter__(self):
         return iter(self.changelog)
 
     def revs(self, expr, *args):
         '''Return a list of revisions matching the given revset'''
         expr = revset.formatspec(expr, *args)
         m = revset.match(None, expr)
         return m(self, revset.spanset(self))
 
     def set(self, expr, *args):
         '''
         Yield a context for each matching revision, after doing arg
         replacement via revset.formatspec
         '''
         for r in self.revs(expr, *args):
             yield self[r]
 
     def url(self):
         return 'file:' + self.root
 
     def hook(self, name, throw=False, **args):
         """Call a hook, passing this repo instance.
 
         This a convenience method to aid invoking hooks. Extensions likely
         won't call this unless they have registered a custom hook or are
         replacing code that is expected to call a hook.
         """
         return hook.hook(self.ui, self, name, throw, **args)
 
     @unfilteredmethod
     def _tag(self, names, node, message, local, user, date, extra={},
              editor=False):
         if isinstance(names, str):
             names = (names,)
 
         branches = self.branchmap()
         for name in names:
             self.hook('pretag', throw=True, node=hex(node), tag=name,
                       local=local)
             if name in branches:
                 self.ui.warn(_("warning: tag %s conflicts with existing"
                 " branch name\n") % name)
 
         def writetags(fp, names, munge, prevtags):
             fp.seek(0, 2)
             if prevtags and prevtags[-1] != '\n':
                 fp.write('\n')
             for name in names:
                 m = munge and munge(name) or name
                 if (self._tagscache.tagtypes and
                     name in self._tagscache.tagtypes):
                     old = self.tags().get(name, nullid)
                     fp.write('%s %s\n' % (hex(old), m))
                 fp.write('%s %s\n' % (hex(node), m))
             fp.close()
 
         prevtags = ''
         if local:
             try:
                 fp = self.opener('localtags', 'r+')
             except IOError:
                 fp = self.opener('localtags', 'a')
             else:
                 prevtags = fp.read()
 
             # local tags are stored in the current charset
             writetags(fp, names, None, prevtags)
             for name in names:
                 self.hook('tag', node=hex(node), tag=name, local=local)
             return
 
         try:
             fp = self.wfile('.hgtags', 'rb+')
         except IOError, e:
             if e.errno != errno.ENOENT:
                 raise
             fp = self.wfile('.hgtags', 'ab')
         else:
             prevtags = fp.read()
 
         # committed tags are stored in UTF-8
         writetags(fp, names, encoding.fromlocal, prevtags)
 
         fp.close()
 
         self.invalidatecaches()
 
         if '.hgtags' not in self.dirstate:
             self[None].add(['.hgtags'])
 
         m = matchmod.exact(self.root, '', ['.hgtags'])
         tagnode = self.commit(message, user, date, extra=extra, match=m,
                               editor=editor)
 
         for name in names:
             self.hook('tag', node=hex(node), tag=name, local=local)
 
         return tagnode
 
     def tag(self, names, node, message, local, user, date, editor=False):
         '''tag a revision with one or more symbolic names.
 
         names is a list of strings or, when adding a single tag, names may be a
         string.
 
         if local is True, the tags are stored in a per-repository file.
         otherwise, they are stored in the .hgtags file, and a new
         changeset is committed with the change.
 
         keyword arguments:
 
         local: whether to store tags in non-version-controlled file
         (default False)
 
         message: commit message to use if committing
 
         user: name of user to use if committing
 
         date: date tuple to use if committing'''
 
         if not local:
             m = matchmod.exact(self.root, '', ['.hgtags'])
             if util.any(self.status(match=m, unknown=True, ignored=True)):
                 raise util.Abort(_('working copy of .hgtags is changed'),
                                  hint=_('please commit .hgtags manually'))
 
         self.tags() # instantiate the cache
         self._tag(names, node, message, local, user, date, editor=editor)
 
     @filteredpropertycache
     def _tagscache(self):
         '''Returns a tagscache object that contains various tags related
         caches.'''
 
         # This simplifies its cache management by having one decorated
         # function (this one) and the rest simply fetch things from it.
         class tagscache(object):
             def __init__(self):
                 # These two define the set of tags for this repository. tags
                 # maps tag name to node; tagtypes maps tag name to 'global' or
                 # 'local'. (Global tags are defined by .hgtags across all
                 # heads, and local tags are defined in .hg/localtags.)
                 # They constitute the in-memory cache of tags.
                 self.tags = self.tagtypes = None
 
                 self.nodetagscache = self.tagslist = None
 
         cache = tagscache()
         cache.tags, cache.tagtypes = self._findtags()
 
         return cache
 
     def tags(self):
         '''return a mapping of tag to node'''
         t = {}
         if self.changelog.filteredrevs:
             tags, tt = self._findtags()
         else:
             tags = self._tagscache.tags
         for k, v in tags.iteritems():
             try:
                 # ignore tags to unknown nodes
                 self.changelog.rev(v)
                 t[k] = v
             except (error.LookupError, ValueError):
                 pass
         return t
 
     def _findtags(self):
         '''Do the hard work of finding tags.  Return a pair of dicts
         (tags, tagtypes) where tags maps tag name to node, and tagtypes
         maps tag name to a string like \'global\' or \'local\'.
         Subclasses or extensions are free to add their own tags, but
         should be aware that the returned dicts will be retained for the
         duration of the localrepo object.'''
 
         # XXX what tagtype should subclasses/extensions use?  Currently
         # mq and bookmarks add tags, but do not set the tagtype at all.
         # Should each extension invent its own tag type?  Should there
         # be one tagtype for all such "virtual" tags?  Or is the status
         # quo fine?
 
         alltags = {}                    # map tag name to (node, hist)
         tagtypes = {}
 
         tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
         tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
 
         # Build the return dicts.  Have to re-encode tag names because
         # the tags module always uses UTF-8 (in order not to lose info
         # writing to the cache), but the rest of Mercurial wants them in
         # local encoding.
         tags = {}
         for (name, (node, hist)) in alltags.iteritems():
             if node != nullid:
                 tags[encoding.tolocal(name)] = node
         tags['tip'] = self.changelog.tip()
         tagtypes = dict([(encoding.tolocal(name), value)
                          for (name, value) in tagtypes.iteritems()])
         return (tags, tagtypes)
 
     def tagtype(self, tagname):
         '''
         return the type of the given tag. result can be:
 
         'local'  : a local tag
         'global' : a global tag
         None     : tag does not exist
         '''
 
         return self._tagscache.tagtypes.get(tagname)
 
     def tagslist(self):
         '''return a list of tags ordered by revision'''
         if not self._tagscache.tagslist:
             l = []
             for t, n in self.tags().iteritems():
                 l.append((self.changelog.rev(n), t, n))
             self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
 
         return self._tagscache.tagslist
 
     def nodetags(self, node):
         '''return the tags associated with a node'''
         if not self._tagscache.nodetagscache:
             nodetagscache = {}
             for t, n in self._tagscache.tags.iteritems():
                 nodetagscache.setdefault(n, []).append(t)
             for tags in nodetagscache.itervalues():
                 tags.sort()
             self._tagscache.nodetagscache = nodetagscache
         return self._tagscache.nodetagscache.get(node, [])
 
     def nodebookmarks(self, node):
         marks = []
         for bookmark, n in self._bookmarks.iteritems():
             if n == node:
                 marks.append(bookmark)
         return sorted(marks)
 
     def branchmap(self):
         '''returns a dictionary {branch: [branchheads]} with branchheads
         ordered by increasing revision number'''
         branchmap.updatecache(self)
         return self._branchcaches[self.filtername]
 
     def branchtip(self, branch):
         '''return the tip node for a given branch'''
         try:
             return self.branchmap().branchtip(branch)
         except KeyError:
             raise error.RepoLookupError(_("unknown branch '%s'") % branch)
 
     def lookup(self, key):
         return self[key].node()
 
     def lookupbranch(self, key, remote=None):
         repo = remote or self
         if key in repo.branchmap():
             return key
 
         repo = (remote and remote.local()) and remote or self
         return repo[key].branch()
 
     def known(self, nodes):
         nm = self.changelog.nodemap
         pc = self._phasecache
         result = []
         for n in nodes:
             r = nm.get(n)
             resp = not (r is None or pc.phase(self, r) >= phases.secret)
             result.append(resp)
         return result
 
     def local(self):
         return self
 
     def cancopy(self):
         # so statichttprepo's override of local() works
         if not self.local():
             return False
         if not self.ui.configbool('phases', 'publish', True):
             return True
         # if publishing we can't copy if there is filtered content
         return not self.filtered('visible').changelog.filteredrevs
 
     def join(self, f, *insidef):
         return os.path.join(self.path, f, *insidef)
 
     def wjoin(self, f, *insidef):
         return os.path.join(self.root, f, *insidef)
 
     def file(self, f):
         if f[0] == '/':
             f = f[1:]
         return filelog.filelog(self.sopener, f)
 
     def changectx(self, changeid):
         return self[changeid]
 
     def parents(self, changeid=None):
         '''get list of changectxs for parents of changeid'''
         return self[changeid].parents()
 
     def setparents(self, p1, p2=nullid):
         self.dirstate.beginparentchange()
         copies = self.dirstate.setparents(p1, p2)
         pctx = self[p1]
         if copies:
             # Adjust copy records, the dirstate cannot do it, it
             # requires access to parents manifests. Preserve them
             # only for entries added to first parent.
             for f in copies:
                 if f not in pctx and copies[f] in pctx:
                     self.dirstate.copy(copies[f], f)
         if p2 == nullid:
             for f, s in sorted(self.dirstate.copies().items()):
                 if f not in pctx and s not in pctx:
                     self.dirstate.copy(None, f)
         self.dirstate.endparentchange()
 
     def filectx(self, path, changeid=None, fileid=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         return context.filectx(self, path, changeid, fileid)
 
     def getcwd(self):
         return self.dirstate.getcwd()
 
     def pathto(self, f, cwd=None):
         return self.dirstate.pathto(f, cwd)
 
     def wfile(self, f, mode='r'):
         return self.wopener(f, mode)
 
     def _link(self, f):
         return self.wvfs.islink(f)
 
     def _loadfilter(self, filter):
         if filter not in self.filterpats:
             l = []
             for pat, cmd in self.ui.configitems(filter):
                 if cmd == '!':
                     continue
                 mf = matchmod.match(self.root, '', [pat])
                 fn = None
                 params = cmd
                 for name, filterfn in self._datafilters.iteritems():
                     if cmd.startswith(name):
                         fn = filterfn
                         params = cmd[len(name):].lstrip()
                         break
                 if not fn:
                     fn = lambda s, c, **kwargs: util.filter(s, c)
                 # Wrap old filters not supporting keyword arguments
                 if not inspect.getargspec(fn)[2]:
                     oldfn = fn
                     fn = lambda s, c, **kwargs: oldfn(s, c)
                 l.append((mf, fn, params))
             self.filterpats[filter] = l
         return self.filterpats[filter]
 
     def _filter(self, filterpats, filename, data):
         for mf, fn, cmd in filterpats:
             if mf(filename):
                 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
                 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
                 break
 
         return data
 
     @unfilteredpropertycache
     def _encodefilterpats(self):
         return self._loadfilter('encode')
 
     @unfilteredpropertycache
     def _decodefilterpats(self):
         return self._loadfilter('decode')
 
     def adddatafilter(self, name, filter):
         self._datafilters[name] = filter
 
     def wread(self, filename):
         if self._link(filename):
             data = self.wvfs.readlink(filename)
         else:
             data = self.wopener.read(filename)
         return self._filter(self._encodefilterpats, filename, data)
 
     def wwrite(self, filename, data, flags):
         data = self._filter(self._decodefilterpats, filename, data)
         if 'l' in flags:
             self.wopener.symlink(data, filename)
         else:
             self.wopener.write(filename, data)
             if 'x' in flags:
                 self.wvfs.setflags(filename, False, True)
 
     def wwritedata(self, filename, data):
         return self._filter(self._decodefilterpats, filename, data)
 
     def transaction(self, desc, report=None):
         tr = self._transref and self._transref() or None
         if tr and tr.running():
             return tr.nest()
 
         # abort here if the journal already exists
         if self.svfs.exists("journal"):
             raise error.RepoError(
                 _("abandoned transaction found"),
                 hint=_("run 'hg recover' to clean up transaction"))
 
         def onclose():
             self.store.write(self._transref())
 
         self._writejournal(desc)
         renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
         rp = report and report or self.ui.warn
         tr = transaction.transaction(rp, self.sopener,
                                      "journal",
                                      aftertrans(renames),
                                      self.store.createmode,
                                      onclose)
         self._transref = weakref.ref(tr)
         return tr
 
     def _journalfiles(self):
         return ((self.svfs, 'journal'),
                 (self.vfs, 'journal.dirstate'),
                 (self.vfs, 'journal.branch'),
                 (self.vfs, 'journal.desc'),
                 (self.vfs, 'journal.bookmarks'),
                 (self.svfs, 'journal.phaseroots'))
 
     def undofiles(self):
         return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
 
     def _writejournal(self, desc):
         self.opener.write("journal.dirstate",
                           self.opener.tryread("dirstate"))
         self.opener.write("journal.branch",
                           encoding.fromlocal(self.dirstate.branch()))
         self.opener.write("journal.desc",
                           "%d\n%s\n" % (len(self), desc))
         self.opener.write("journal.bookmarks",
                           self.opener.tryread("bookmarks"))
         self.sopener.write("journal.phaseroots",
                            self.sopener.tryread("phaseroots"))
 
     def recover(self):
         lock = self.lock()
         try:
             if self.svfs.exists("journal"):
                 self.ui.status(_("rolling back interrupted transaction\n"))
                 transaction.rollback(self.sopener, "journal",
                                      self.ui.warn)
                 self.invalidate()
                 return True
             else:
                 self.ui.warn(_("no interrupted transaction available\n"))
                 return False
         finally:
             lock.release()
 
     def rollback(self, dryrun=False, force=False):
         wlock = lock = None
         try:
             wlock = self.wlock()
             lock = self.lock()
             if self.svfs.exists("undo"):
                 return self._rollback(dryrun, force)
             else:
                 self.ui.warn(_("no rollback information available\n"))
                 return 1
         finally:
             release(lock, wlock)
 
     @unfilteredmethod # Until we get smarter cache management
     def _rollback(self, dryrun, force):
         ui = self.ui
         try:
             args = self.opener.read('undo.desc').splitlines()
             (oldlen, desc, detail) = (int(args[0]), args[1], None)
             if len(args) >= 3:
                 detail = args[2]
             oldtip = oldlen - 1
 
             if detail and ui.verbose:
                 msg = (_('repository tip rolled back to revision %s'
                          ' (undo %s: %s)\n')
                        % (oldtip, desc, detail))
             else:
                 msg = (_('repository tip rolled back to revision %s'
                          ' (undo %s)\n')
                        % (oldtip, desc))
         except IOError:
             msg = _('rolling back unknown transaction\n')
             desc = None
 
         if not force and self['.'] != self['tip'] and desc == 'commit':
             raise util.Abort(
                 _('rollback of last commit while not checked out '
                   'may lose data'), hint=_('use -f to force'))
 
         ui.status(msg)
         if dryrun:
             return 0
 
         parents = self.dirstate.parents()
         self.destroying()
         transaction.rollback(self.sopener, 'undo', ui.warn)
         if self.vfs.exists('undo.bookmarks'):
             self.vfs.rename('undo.bookmarks', 'bookmarks')
         if self.svfs.exists('undo.phaseroots'):
             self.svfs.rename('undo.phaseroots', 'phaseroots')
         self.invalidate()
 
         parentgone = (parents[0] not in self.changelog.nodemap or
                       parents[1] not in self.changelog.nodemap)
         if parentgone:
             self.vfs.rename('undo.dirstate', 'dirstate')
             try:
                 branch = self.opener.read('undo.branch')
                 self.dirstate.setbranch(encoding.tolocal(branch))
             except IOError:
                 ui.warn(_('named branch could not be reset: '
                           'current branch is still \'%s\'\n')
                         % self.dirstate.branch())
 
             self.dirstate.invalidate()
             parents = tuple([p.rev() for p in self.parents()])
             if len(parents) > 1:
                 ui.status(_('working directory now based on '
                             'revisions %d and %d\n') % parents)
             else:
                 ui.status(_('working directory now based on '
                             'revision %d\n') % parents)
         # TODO: if we know which new heads may result from this rollback, pass
         # them to destroy(), which will prevent the branchhead cache from being
         # invalidated.
         self.destroyed()
         return 0
 
     def invalidatecaches(self):
 
         if '_tagscache' in vars(self):
             # can't use delattr on proxy
             del self.__dict__['_tagscache']
 
         self.unfiltered()._branchcaches.clear()
         self.invalidatevolatilesets()
 
     def invalidatevolatilesets(self):
         self.filteredrevcache.clear()
         obsolete.clearobscaches(self)
 
     def invalidatedirstate(self):
         '''Invalidates the dirstate, causing the next call to dirstate
         to check if it was modified since the last time it was read,
         rereading it if it has.
 
         This is different to dirstate.invalidate() that it doesn't always
         rereads the dirstate. Use dirstate.invalidate() if you want to
         explicitly read the dirstate again (i.e. restoring it to a previous
         known good state).'''
         if hasunfilteredcache(self, 'dirstate'):
             for k in self.dirstate._filecache:
                 try:
                     delattr(self.dirstate, k)
                 except AttributeError:
                     pass
             delattr(self.unfiltered(), 'dirstate')
 
     def invalidate(self):
         unfiltered = self.unfiltered() # all file caches are stored unfiltered
         for k in self._filecache:
             # dirstate is invalidated separately in invalidatedirstate()
             if k == 'dirstate':
                 continue
 
             try:
                 delattr(unfiltered, k)
             except AttributeError:
                 pass
         self.invalidatecaches()
         self.store.invalidatecaches()
 
     def invalidateall(self):
         '''Fully invalidates both store and non-store parts, causing the
         subsequent operation to reread any outside changes.'''
         # extension should hook this to invalidate its caches
         self.invalidate()
         self.invalidatedirstate()
 
     def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc):
         try:
             l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc)
         except error.LockHeld, inst:
             if not wait:
                 raise
             self.ui.warn(_("waiting for lock on %s held by %r\n") %
                          (desc, inst.locker))
             # default to 600 seconds timeout
             l = lockmod.lock(vfs, lockname,
                              int(self.ui.config("ui", "timeout", "600")),
                              releasefn, desc=desc)
             self.ui.warn(_("got lock after %s seconds\n") % l.delay)
         if acquirefn:
             acquirefn()
         return l
 
     def _afterlock(self, callback):
         """add a callback to the current repository lock.
 
         The callback will be executed on lock release."""
         l = self._lockref and self._lockref()
         if l:
             l.postrelease.append(callback)
         else:
             callback()
 
     def lock(self, wait=True):
         '''Lock the repository store (.hg/store) and return a weak reference
         to the lock. Use this before modifying the store (e.g. committing or
         stripping). If you are opening a transaction, get a lock as well.)'''
         l = self._lockref and self._lockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         def unlock():
             for k, ce in self._filecache.items():
                 if k == 'dirstate' or k not in self.__dict__:
                     continue
                 ce.refresh()
 
         l = self._lock(self.svfs, "lock", wait, unlock,
                        self.invalidate, _('repository %s') % self.origroot)
         self._lockref = weakref.ref(l)
         return l
 
     def wlock(self, wait=True):
         '''Lock the non-store parts of the repository (everything under
         .hg except .hg/store) and return a weak reference to the lock.
         Use this before modifying files in .hg.'''
         l = self._wlockref and self._wlockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         def unlock():
             if self.dirstate.pendingparentchange():
                 self.dirstate.invalidate()
             else:
                 self.dirstate.write()
 
             self._filecache['dirstate'].refresh()
 
         l = self._lock(self.vfs, "wlock", wait, unlock,
                        self.invalidatedirstate, _('working directory of %s') %
                        self.origroot)
         self._wlockref = weakref.ref(l)
         return l
 
     def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
         """
         commit an individual file as part of a larger transaction
         """
 
         fname = fctx.path()
         text = fctx.data()
         flog = self.file(fname)
         fparent1 = manifest1.get(fname, nullid)
         fparent2 = manifest2.get(fname, nullid)
 
         meta = {}
         copy = fctx.renamed()
         if copy and copy[0] != fname:
             # Mark the new revision of this file as a copy of another
             # file.  This copy data will effectively act as a parent
             # of this new revision.  If this is a merge, the first
             # parent will be the nullid (meaning "look up the copy data")
             # and the second one will be the other parent.  For example:
             #
             # 0 --- 1 --- 3   rev1 changes file foo
             #   \       /     rev2 renames foo to bar and changes it
             #    \- 2 -/      rev3 should have bar with all changes and
             #                      should record that bar descends from
             #                      bar in rev2 and foo in rev1
             #
             # this allows this merge to succeed:
             #
             # 0 --- 1 --- 3   rev4 reverts the content change from rev2
             #   \       /     merging rev3 and rev4 should use bar@rev2
             #    \- 2 --- 4        as the merge base
             #
 
             cfname = copy[0]
             crev = manifest1.get(cfname)
             newfparent = fparent2
 
             if manifest2: # branch merge
                 if fparent2 == nullid or crev is None: # copied on remote side
                     if cfname in manifest2:
                         crev = manifest2[cfname]
                         newfparent = fparent1
 
             # find source in nearest ancestor if we've lost track
             if not crev:
                 self.ui.debug(" %s: searching for copy revision for %s\n" %
                               (fname, cfname))
                 for ancestor in self[None].ancestors():
                     if cfname in ancestor:
                         crev = ancestor[cfname].filenode()
                         break
 
             if crev:
                 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
                 meta["copy"] = cfname
                 meta["copyrev"] = hex(crev)
                 fparent1, fparent2 = nullid, newfparent
             else:
                 self.ui.warn(_("warning: can't find ancestor for '%s' "
                                "copied from '%s'!\n") % (fname, cfname))
 
         elif fparent1 == nullid:
             fparent1, fparent2 = fparent2, nullid
         elif fparent2 != nullid:
             # is one parent an ancestor of the other?
             fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
             if fparent1 in fparentancestors:
                 fparent1, fparent2 = fparent2, nullid
             elif fparent2 in fparentancestors:
                 fparent2 = nullid
 
         # is the file changed?
         if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
             changelist.append(fname)
             return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
         # are just the flags changed during merge?
         elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
             changelist.append(fname)
 
         return fparent1
 
     @unfilteredmethod
     def commit(self, text="", user=None, date=None, match=None, force=False,
                editor=False, extra={}):
         """Add a new revision to current repository.
 
         Revision information is gathered from the working directory,
         match can be used to filter the committed files. If editor is
         supplied, it is called to get a commit message.
         """
 
         def fail(f, msg):
             raise util.Abort('%s: %s' % (f, msg))
 
         if not match:
             match = matchmod.always(self.root, '')
 
         if not force:
             vdirs = []
             match.explicitdir = vdirs.append
             match.bad = fail
 
         wlock = self.wlock()
         try:
             wctx = self[None]
             merge = len(wctx.parents()) > 1
 
             if (not force and merge and match and
                 (match.files() or match.anypats())):
                 raise util.Abort(_('cannot partially commit a merge '
                                    '(do not specify files or patterns)'))
 
             status = self.status(match=match, clean=force)
             if force:
                 status.modified.extend(status.clean) # mq may commit clean files
 
             # check subrepos
             subs = []
             commitsubs = set()
             newstate = wctx.substate.copy()
             # only manage subrepos and .hgsubstate if .hgsub is present
             if '.hgsub' in wctx:
                 # we'll decide whether to track this ourselves, thanks
                 for c in status.modified, status.added, status.removed:
                     if '.hgsubstate' in c:
                         c.remove('.hgsubstate')
 
                 # compare current state to last committed state
                 # build new substate based on last committed state
                 oldstate = wctx.p1().substate
                 for s in sorted(newstate.keys()):
                     if not match(s):
                         # ignore working copy, use old state if present
                         if s in oldstate:
                             newstate[s] = oldstate[s]
                             continue
                         if not force:
                             raise util.Abort(
                                 _("commit with new subrepo %s excluded") % s)
                     if wctx.sub(s).dirty(True):
                         if not self.ui.configbool('ui', 'commitsubrepos'):
                             raise util.Abort(
                                 _("uncommitted changes in subrepo %s") % s,
                                 hint=_("use --subrepos for recursive commit"))
                         subs.append(s)
                         commitsubs.add(s)
                     else:
                         bs = wctx.sub(s).basestate()
                         newstate[s] = (newstate[s][0], bs, newstate[s][2])
                         if oldstate.get(s, (None, None, None))[1] != bs:
                             subs.append(s)
 
                 # check for removed subrepos
                 for p in wctx.parents():
                     r = [s for s in p.substate if s not in newstate]
                     subs += [s for s in r if match(s)]
                 if subs:
                     if (not match('.hgsub') and
                         '.hgsub' in (wctx.modified() + wctx.added())):
                         raise util.Abort(
                             _("can't commit subrepos without .hgsub"))
                     status.modified.insert(0, '.hgsubstate')
 
             elif '.hgsub' in status.removed:
                 # clean up .hgsubstate when .hgsub is removed
                 if ('.hgsubstate' in wctx and
                     '.hgsubstate' not in (status.modified + status.added +
                                           status.removed)):
                     status.removed.insert(0, '.hgsubstate')
 
             # make sure all explicit patterns are matched
             if not force and match.files():
                 matched = set(status.modified + status.added + status.removed)
 
                 for f in match.files():
                     f = self.dirstate.normalize(f)
                     if f == '.' or f in matched or f in wctx.substate:
                         continue
                     if f in status.deleted:
                         fail(f, _('file not found!'))
                     if f in vdirs: # visited directory
                         d = f + '/'
                         for mf in matched:
                             if mf.startswith(d):
                                 break
                         else:
                             fail(f, _("no match under directory!"))
                     elif f not in self.dirstate:
                         fail(f, _("file not tracked!"))
 
             cctx = context.workingctx(self, text, user, date, extra, status)
 
             if (not force and not extra.get("close") and not merge
                 and not cctx.files()
                 and wctx.branch() == wctx.p1().branch()):
                 return None
 
             if merge and cctx.deleted():
                 raise util.Abort(_("cannot commit merge with missing files"))
 
             ms = mergemod.mergestate(self)
             for f in status.modified:
                 if f in ms and ms[f] == 'u':
                     raise util.Abort(_("unresolved merge conflicts "
                                        "(see hg help resolve)"))
 
             if editor:
                 cctx._text = editor(self, cctx, subs)
             edited = (text != cctx._text)
 
             # Save commit message in case this transaction gets rolled back
             # (e.g. by a pretxncommit hook).  Leave the content alone on
             # the assumption that the user will use the same editor again.
             msgfn = self.savecommitmessage(cctx._text)
 
             # commit subs and write new state
             if subs:
                 for s in sorted(commitsubs):
                     sub = wctx.sub(s)
                     self.ui.status(_('committing subrepository %s\n') %
                         subrepo.subrelpath(sub))
                     sr = sub.commit(cctx._text, user, date)
                     newstate[s] = (newstate[s][0], sr)
                 subrepo.writestate(self, newstate)
 
             p1, p2 = self.dirstate.parents()
             hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
             try:
                 self.hook("precommit", throw=True, parent1=hookp1,
                           parent2=hookp2)
                 ret = self.commitctx(cctx, True)
             except: # re-raises
                 if edited:
                     self.ui.write(
                         _('note: commit message saved in %s\n') % msgfn)
                 raise
 
             # update bookmarks, dirstate and mergestate
             bookmarks.update(self, [p1, p2], ret)
             cctx.markcommitted(ret)
             ms.reset()
         finally:
             wlock.release()
 
         def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
             self.hook("commit", node=node, parent1=parent1, parent2=parent2)
         self._afterlock(commithook)
         return ret
 
     @unfilteredmethod
     def commitctx(self, ctx, error=False):
         """Add a new revision to current repository.
         Revision information is passed via the context argument.
         """
 
         tr = None
         p1, p2 = ctx.p1(), ctx.p2()
         user = ctx.user()
 
         lock = self.lock()
         try:
             tr = self.transaction("commit")
             trp = weakref.proxy(tr)
 
             if ctx.files():
                 m1 = p1.manifest()
                 m2 = p2.manifest()
                 m = m1.copy()
 
                 # check in files
                 added = []
                 changed = []
                 removed = list(ctx.removed())
                 linkrev = len(self)
                 for f in sorted(ctx.modified() + ctx.added()):
                     self.ui.note(f + "\n")
                     try:
                         fctx = ctx[f]
                         if fctx is None:
                             removed.append(f)
                         else:
                             added.append(f)
                             m[f] = self._filecommit(fctx, m1, m2, linkrev,
                                                     trp, changed)
                             m.setflag(f, fctx.flags())
                     except OSError, inst:
                         self.ui.warn(_("trouble committing %s!\n") % f)
                         raise
                     except IOError, inst:
                         errcode = getattr(inst, 'errno', errno.ENOENT)
                         if error or errcode and errcode != errno.ENOENT:
                             self.ui.warn(_("trouble committing %s!\n") % f)
                         raise
 
                 # update manifest
                 removed = [f for f in sorted(removed) if f in m1 or f in m2]
                 drop = [f for f in removed if f in m]
                 for f in drop:
                     del m[f]
                 mn = self.manifest.add(m, trp, linkrev,
                                        p1.manifestnode(), p2.manifestnode(),
                                        added, drop)
                 files = changed + removed
             else:
                 mn = p1.manifestnode()
                 files = []
 
             # update changelog
             self.changelog.delayupdate()
             n = self.changelog.add(mn, files, ctx.description(),
                                    trp, p1.node(), p2.node(),
                                    user, ctx.date(), ctx.extra().copy())
             p = lambda: self.changelog.writepending() and self.root or ""
             xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
             self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                       parent2=xp2, pending=p)
             self.changelog.finalize(trp)
             # set the new commit is proper phase
             targetphase = subrepo.newcommitphase(self.ui, ctx)
             if targetphase:
                 # retract boundary do not alter parent changeset.
                 # if a parent have higher the resulting phase will
                 # be compliant anyway
                 #
                 # if minimal phase was 0 we don't need to retract anything
                 phases.retractboundary(self, tr, targetphase, [n])
             tr.close()
             branchmap.updatecache(self.filtered('served'))
             return n
         finally:
             if tr:
                 tr.release()
             lock.release()
 
     @unfilteredmethod
     def destroying(self):
         '''Inform the repository that nodes are about to be destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done before destroying history.
 
         This is mostly useful for saving state that is in memory and waiting
         to be flushed when the current lock is released. Because a call to
         destroyed is imminent, the repo will be invalidated causing those
         changes to stay in memory (waiting for the next unlock), or vanish
         completely.
         '''
         # When using the same lock to commit and strip, the phasecache is left
         # dirty after committing. Then when we strip, the repo is invalidated,
         # causing those changes to disappear.
         if '_phasecache' in vars(self):
             self._phasecache.write()
 
     @unfilteredmethod
     def destroyed(self):
         '''Inform the repository that nodes have been destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done after destroying history.
         '''
         # When one tries to:
         # 1) destroy nodes thus calling this method (e.g. strip)
         # 2) use phasecache somewhere (e.g. commit)
         #
         # then 2) will fail because the phasecache contains nodes that were
         # removed. We can either remove phasecache from the filecache,
         # causing it to reload next time it is accessed, or simply filter
         # the removed nodes now and write the updated cache.
         self._phasecache.filterunknown(self)
         self._phasecache.write()
 
         # update the 'served' branch cache to help read only server process
         # Thanks to branchcache collaboration this is done from the nearest
         # filtered subset and it is expected to be fast.
         branchmap.updatecache(self.filtered('served'))
 
         # Ensure the persistent tag cache is updated.  Doing it now
         # means that the tag cache only has to worry about destroyed
         # heads immediately after a strip/rollback.  That in turn
         # guarantees that "cachetip == currenttip" (comparing both rev
         # and node) always means no nodes have been added or destroyed.
 
         # XXX this is suboptimal when qrefresh'ing: we strip the current
         # head, refresh the tag cache, then immediately add a new head.
         # But I think doing it this way is necessary for the "instant
         # tag cache retrieval" case to work.
         self.invalidate()
 
     def walk(self, match, node=None):
         '''
         walk recursively through the directory tree or a given
         changeset, finding all files matched by the match
         function
         '''
         return self[node].walk(match)
 
     def status(self, node1='.', node2=None, match=None,
                ignored=False, clean=False, unknown=False,
                listsubrepos=False):
         '''a convenience method that calls node1.status(node2)'''
         return self[node1].status(node2, match, ignored, clean, unknown,
                                   listsubrepos)
 
     def heads(self, start=None):
         heads = self.changelog.heads(start)
         # sort the output in rev descending order
         return sorted(heads, key=self.changelog.rev, reverse=True)
 
     def branchheads(self, branch=None, start=None, closed=False):
         '''return a (possibly filtered) list of heads for the given branch
 
         Heads are returned in topological order, from newest to oldest.
         If branch is None, use the dirstate branch.
         If start is not None, return only heads reachable from start.
         If closed is True, return heads that are marked as closed as well.
         '''
         if branch is None:
             branch = self[None].branch()
         branches = self.branchmap()
         if branch not in branches:
             return []
         # the cache returns heads ordered lowest to highest
         bheads = list(reversed(branches.branchheads(branch, closed=closed)))
         if start is not None:
             # filter out the heads that cannot be reached from startrev
             fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
             bheads = [h for h in bheads if h in fbheads]
         return bheads
 
     def branches(self, nodes):
         if not nodes:
             nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while True:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom and n != nullid:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n)
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def checkpush(self, pushop):
         """Extensions can override this function if additional checks have
         to be performed before pushing, or call it if they override push
         command.
         """
         pass
 
     @unfilteredpropertycache
     def prepushoutgoinghooks(self):
         """Return util.hooks consists of "(repo, remote, outgoing)"
         functions, which are called before pushing changesets.
         """
         return util.hooks()
 
     def stream_in(self, remote, requirements):
         lock = self.lock()
         try:
             # Save remote branchmap. We will use it later
             # to speed up branchcache creation
             rbranchmap = None
             if remote.capable("branchmap"):
                 rbranchmap = remote.branchmap()
 
             fp = remote.stream_out()
             l = fp.readline()
             try:
                 resp = int(l)
             except ValueError:
                 raise error.ResponseError(
                     _('unexpected response from remote server:'), l)
             if resp == 1:
                 raise util.Abort(_('operation forbidden by server'))
             elif resp == 2:
                 raise util.Abort(_('locking the remote repository failed'))
             elif resp != 0:
                 raise util.Abort(_('the server sent an unknown error code'))
             self.ui.status(_('streaming all changes\n'))
             l = fp.readline()
             try:
                 total_files, total_bytes = map(int, l.split(' ', 1))
             except (ValueError, TypeError):
                 raise error.ResponseError(
                     _('unexpected response from remote server:'), l)
             self.ui.status(_('%d files to transfer, %s of data\n') %
                            (total_files, util.bytecount(total_bytes)))
             handled_bytes = 0
             self.ui.progress(_('clone'), 0, total=total_bytes)
             start = time.time()
 
             tr = self.transaction(_('clone'))
             try:
                 for i in xrange(total_files):
                     # XXX doesn't support '\n' or '\r' in filenames
                     l = fp.readline()
                     try:
                         name, size = l.split('\0', 1)
                         size = int(size)
                     except (ValueError, TypeError):
                         raise error.ResponseError(
                             _('unexpected response from remote server:'), l)
                     if self.ui.debugflag:
                         self.ui.debug('adding %s (%s)\n' %
                                       (name, util.bytecount(size)))
                     # for backwards compat, name was partially encoded
                     ofp = self.sopener(store.decodedir(name), 'w')
                     for chunk in util.filechunkiter(fp, limit=size):
                         handled_bytes += len(chunk)
                         self.ui.progress(_('clone'), handled_bytes,
                                          total=total_bytes)
                         ofp.write(chunk)
                     ofp.close()
                 tr.close()
             finally:
                 tr.release()
 
             # Writing straight to files circumvented the inmemory caches
             self.invalidate()
 
             elapsed = time.time() - start
             if elapsed <= 0:
                 elapsed = 0.001
             self.ui.progress(_('clone'), None)
             self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
                            (util.bytecount(total_bytes), elapsed,
                             util.bytecount(total_bytes / elapsed)))
 
             # new requirements = old non-format requirements +
             #                    new format-related
             # requirements from the streamed-in repository
             requirements.update(set(self.requirements) - self.supportedformats)
             self._applyrequirements(requirements)
             self._writerequirements()
 
             if rbranchmap:
                 rbheads = []
                 for bheads in rbranchmap.itervalues():
                     rbheads.extend(bheads)
 
                 if rbheads:
                     rtiprev = max((int(self.changelog.rev(node))
                             for node in rbheads))
                     cache = branchmap.branchcache(rbranchmap,
                                                   self[rtiprev].node(),
                                                   rtiprev)
                     # Try to stick it as low as possible
                     # filter above served are unlikely to be fetch from a clone
                     for candidate in ('base', 'immutable', 'served'):
                         rview = self.filtered(candidate)
                         if cache.validfor(rview):
                             self._branchcaches[candidate] = cache
                             cache.write(rview)
                             break
             self.invalidate()
             return len(self.heads()) + 1
         finally:
             lock.release()
 
     def clone(self, remote, heads=[], stream=False):
         '''clone remote repository.
 
         keyword arguments:
         heads: list of revs to clone (forces use of pull)
         stream: use streaming clone if possible'''
 
         # now, all clients that can request uncompressed clones can
         # read repo formats supported by all servers that can serve
         # them.
 
         # if revlog format changes, client will have to check version
         # and format flags on "stream" capability, and use
         # uncompressed only if compatible.
 
         if not stream:
             # if the server explicitly prefers to stream (for fast LANs)
             stream = remote.capable('stream-preferred')
 
         if stream and not heads:
             # 'stream' means remote revlog format is revlogv1 only
             if remote.capable('stream'):
                 return self.stream_in(remote, set(('revlogv1',)))
             # otherwise, 'streamreqs' contains the remote revlog format
             streamreqs = remote.capable('streamreqs')
             if streamreqs:
                 streamreqs = set(streamreqs.split(','))
                 # if we support it, stream in and adjust our requirements
                 if not streamreqs - self.supportedformats:
                     return self.stream_in(remote, streamreqs)
 
         quiet = self.ui.backupconfig('ui', 'quietbookmarkmove')
         try:
             self.ui.setconfig('ui', 'quietbookmarkmove', True, 'clone')
             ret = exchange.pull(self, remote, heads).cgresult
         finally:
             self.ui.restoreconfig(quiet)
         return ret
 
     def pushkey(self, namespace, key, old, new):
         self.hook('prepushkey', throw=True, namespace=namespace, key=key,
                   old=old, new=new)
         self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
         ret = pushkey.push(self, namespace, key, old, new)
         self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
                   ret=ret)
         return ret
 
     def listkeys(self, namespace):
         self.hook('prelistkeys', throw=True, namespace=namespace)
         self.ui.debug('listing keys for "%s"\n' % namespace)
         values = pushkey.list(self, namespace)
         self.hook('listkeys', namespace=namespace, values=values)
         return values
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         '''used to test argument passing over the wire'''
         return "%s %s %s %s %s" % (one, two, three, four, five)
 
     def savecommitmessage(self, text):
         fp = self.opener('last-message.txt', 'wb')
         try:
             fp.write(text)
         finally:
             fp.close()
         return self.pathto(fp.name[len(self.root) + 1:])
 
 # used to avoid circular references so destructors work
 def aftertrans(files):
     renamefiles = [tuple(t) for t in files]
     def a():
         for vfs, src, dest in renamefiles:
             try:
                 vfs.rename(src, dest)
             except OSError: # journal file does not yet exist
                 pass
     return a
 
 def undoname(fn):
     base, name = os.path.split(fn)
     assert name.startswith('journal')
     return os.path.join(base, name.replace('journal', 'undo', 1))
 
 def instance(ui, path, create):
     return localrepository(ui, util.urllocalpath(path), create)
 
 def islocal(path):
     return True

mercurial/obsolete.py

@@ -1,1161 +1,1163 b''
 # obsolete.py - obsolete markers handling
 #
 # Copyright 2012 Pierre-Yves David <[e-mail]>
 #                Logilab SA        <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """Obsolete marker handling
 
 An obsolete marker maps an old changeset to a list of new
 changesets. If the list of new changesets is empty, the old changeset
 is said to be "killed". Otherwise, the old changeset is being
 "replaced" by the new changesets.
 
 Obsolete markers can be used to record and distribute changeset graph
 transformations performed by history rewrite operations, and help
 building new tools to reconcile conflicting rewrite actions. To
 facilitate conflict resolution, markers include various annotations
 besides old and news changeset identifiers, such as creation date or
 author name.
 
 The old obsoleted changeset is called a "precursor" and possible
 replacements are called "successors". Markers that used changeset X as
 a precursor are called "successor markers of X" because they hold
 information about the successors of X. Markers that use changeset Y as
 a successors are call "precursor markers of Y" because they hold
 information about the precursors of Y.
 
 Examples:
 
 - When changeset A is replaced by changeset A', one marker is stored:
 
     (A, (A',))
 
 - When changesets A and B are folded into a new changeset C, two markers are
   stored:
 
     (A, (C,)) and (B, (C,))
 
 - When changeset A is simply "pruned" from the graph, a marker is created:
 
     (A, ())
 
 - When changeset A is split into B and C, a single marker are used:
 
     (A, (C, C))
 
   We use a single marker to distinguish the "split" case from the "divergence"
   case. If two independent operations rewrite the same changeset A in to A' and
   A'', we have an error case: divergent rewriting. We can detect it because
   two markers will be created independently:
 
   (A, (B,)) and (A, (C,))
 
 Format
 ------
 
 Markers are stored in an append-only file stored in
 '.hg/store/obsstore'.
 
 The file starts with a version header:
 
 - 1 unsigned byte: version number, starting at zero.
 
 The header is followed by the markers. Marker format depend of the version. See
 comment associated with each format for details.
 
 """
 import struct
 import util, base85, node
 import phases
 from i18n import _
 
 _pack = struct.pack
 _unpack = struct.unpack
 
 _SEEK_END = 2 # os.SEEK_END was introduced in Python 2.5
 
 # the obsolete feature is not mature enough to be enabled by default.
 # you have to rely on third party extension extension to enable this.
 _enabled = False
 
 ### obsolescence marker flag
 
 ## bumpedfix flag
 #
 # When a changeset A' succeed to a changeset A which became public, we call A'
 # "bumped" because it's a successors of a public changesets
 #
 # o    A' (bumped)
 # |`:
 # | o  A
 # |/
 # o    Z
 #
 # The way to solve this situation is to create a new changeset Ad as children
 # of A. This changeset have the same content than A'. So the diff from A to A'
 # is the same than the diff from A to Ad. Ad is marked as a successors of A'
 #
 # o   Ad
 # |`:
 # | x A'
 # |'|
 # o | A
 # |/
 # o Z
 #
 # But by transitivity Ad is also a successors of A. To avoid having Ad marked
 # as bumped too, we add the `bumpedfix` flag to the marker. <A', (Ad,)>.
 # This flag mean that the successors express the changes between the public and
 # bumped version and fix the situation, breaking the transitivity of
 # "bumped" here.
 bumpedfix = 1
 usingsha256 = 2
 
 ## Parsing and writing of version "0"
 #
 # The header is followed by the markers. Each marker is made of:
 #
 # - 1 uint8 : number of new changesets "N", can be zero.
 #
 # - 1 uint32: metadata size "M" in bytes.
 #
 # - 1 byte: a bit field. It is reserved for flags used in common
 #   obsolete marker operations, to avoid repeated decoding of metadata
 #   entries.
 #
 # - 20 bytes: obsoleted changeset identifier.
 #
 # - N*20 bytes: new changesets identifiers.
 #
 # - M bytes: metadata as a sequence of nul-terminated strings. Each
 #   string contains a key and a value, separated by a colon ':', without
 #   additional encoding. Keys cannot contain '\0' or ':' and values
 #   cannot contain '\0'.
 _fm0version = 0
 _fm0fixed   = '>BIB20s'
 _fm0node = '20s'
 _fm0fsize = struct.calcsize(_fm0fixed)
 _fm0fnodesize = struct.calcsize(_fm0node)
 
 def _fm0readmarkers(data, off=0):
     # Loop on markers
     l = len(data)
     while off + _fm0fsize <= l:
         # read fixed part
         cur = data[off:off + _fm0fsize]
         off += _fm0fsize
         numsuc, mdsize, flags, pre = _unpack(_fm0fixed, cur)
         # read replacement
         sucs = ()
         if numsuc:
             s = (_fm0fnodesize * numsuc)
             cur = data[off:off + s]
             sucs = _unpack(_fm0node * numsuc, cur)
             off += s
         # read metadata
         # (metadata will be decoded on demand)
         metadata = data[off:off + mdsize]
         if len(metadata) != mdsize:
             raise util.Abort(_('parsing obsolete marker: metadata is too '
                                'short, %d bytes expected, got %d')
                              % (mdsize, len(metadata)))
         off += mdsize
         metadata = _fm0decodemeta(metadata)
         try:
             when, offset = metadata.pop('date', '0 0').split(' ')
             date = float(when), int(offset)
         except ValueError:
             date = (0., 0)
         parents = None
         if 'p2' in metadata:
             parents = (metadata.pop('p1', None), metadata.pop('p2', None))
         elif 'p1' in metadata:
             parents = (metadata.pop('p1', None),)
         elif 'p0' in metadata:
             parents = ()
         if parents is not None:
             try:
                 parents = tuple(node.bin(p) for p in parents)
                 # if parent content is not a nodeid, drop the data
                 for p in parents:
                     if len(p) != 20:
                         parents = None
                         break
             except TypeError:
                 # if content cannot be translated to nodeid drop the data.
                 parents = None
 
         metadata = tuple(sorted(metadata.iteritems()))
 
         yield (pre, sucs, flags, metadata, date, parents)
 
 def _fm0encodeonemarker(marker):
     pre, sucs, flags, metadata, date, parents = marker
     if flags & usingsha256:
         raise util.Abort(_('cannot handle sha256 with old obsstore format'))
     metadata = dict(metadata)
     metadata['date'] = '%d %i' % date
     if parents is not None:
         if not parents:
             # mark that we explicitly recorded no parents
             metadata['p0'] = ''
         for i, p in enumerate(parents):
             metadata['p%i' % (i + 1)] = node.hex(p)
     metadata = _fm0encodemeta(metadata)
     numsuc = len(sucs)
     format = _fm0fixed + (_fm0node * numsuc)
     data = [numsuc, len(metadata), flags, pre]
     data.extend(sucs)
     return _pack(format, *data) + metadata
 
 def _fm0encodemeta(meta):
     """Return encoded metadata string to string mapping.
 
     Assume no ':' in key and no '\0' in both key and value."""
     for key, value in meta.iteritems():
         if ':' in key or '\0' in key:
             raise ValueError("':' and '\0' are forbidden in metadata key'")
         if '\0' in value:
             raise ValueError("':' is forbidden in metadata value'")
     return '\0'.join(['%s:%s' % (k, meta[k]) for k in sorted(meta)])
 
 def _fm0decodemeta(data):
     """Return string to string dictionary from encoded version."""
     d = {}
     for l in data.split('\0'):
         if l:
             key, value = l.split(':')
             d[key] = value
     return d
 
 ## Parsing and writing of version "1"
 #
 # The header is followed by the markers. Each marker is made of:
 #
 # - uint32: total size of the marker (including this field)
 #
 # - float64: date in seconds since epoch
 #
 # - int16: timezone offset in minutes
 #
 # - uint16: a bit field. It is reserved for flags used in common
 #   obsolete marker operations, to avoid repeated decoding of metadata
 #   entries.
 #
 # - uint8: number of successors "N", can be zero.
 #
 # - uint8: number of parents "P", can be zero.
 #
 #     0: parents data stored but no parent,
 #     1: one parent stored,
 #     2: two parents stored,
 #     3: no parent data stored
 #
 # - uint8: number of metadata entries M
 #
 # - 20 or 32 bytes: precursor changeset identifier.
 #
 # - N*(20 or 32) bytes: successors changesets identifiers.
 #
 # - P*(20 or 32) bytes: parents of the precursors changesets.
 #
 # - M*(uint8, uint8): size of all metadata entries (key and value)
 #
 # - remaining bytes: the metadata, each (key, value) pair after the other.
 _fm1version = 1
 _fm1fixed = '>IdhHBBB20s'
 _fm1nodesha1 = '20s'
 _fm1nodesha256 = '32s'
 _fm1fsize = struct.calcsize(_fm1fixed)
 _fm1parentnone = 3
 _fm1parentshift = 14
 _fm1parentmask = (_fm1parentnone << _fm1parentshift)
 _fm1metapair = 'BB'
 _fm1metapairsize = struct.calcsize('BB')
 
 def _fm1readmarkers(data, off=0):
     # Loop on markers
     l = len(data)
     while off + _fm1fsize <= l:
         # read fixed part
         cur = data[off:off + _fm1fsize]
         off += _fm1fsize
         fixeddata = _unpack(_fm1fixed, cur)
         ttsize, seconds, tz, flags, numsuc, numpar, nummeta, prec = fixeddata
         # extract the number of parents information
         if numpar == _fm1parentnone:
             numpar = None
         # build the date tuple (upgrade tz minutes to seconds)
         date = (seconds, tz * 60)
         _fm1node = _fm1nodesha1
         if flags & usingsha256:
             _fm1node = _fm1nodesha256
         fnodesize = struct.calcsize(_fm1node)
         # read replacement
         sucs = ()
         if numsuc:
             s = (fnodesize * numsuc)
             cur = data[off:off + s]
             sucs = _unpack(_fm1node * numsuc, cur)
             off += s
         # read parents
         if numpar is None:
             parents = None
         elif numpar == 0:
             parents = ()
         elif numpar:  # neither None nor zero
             s = (fnodesize * numpar)
             cur = data[off:off + s]
             parents = _unpack(_fm1node * numpar, cur)
             off += s
         # read metadata
         metaformat = '>' + (_fm1metapair * nummeta)
         s = _fm1metapairsize * nummeta
         metapairsize = _unpack(metaformat, data[off:off + s])
         off += s
         metadata = []
         for idx in xrange(0, len(metapairsize), 2):
             sk = metapairsize[idx]
             sv = metapairsize[idx + 1]
             key = data[off:off + sk]
             value = data[off + sk:off + sk + sv]
             assert len(key) == sk
             assert len(value) == sv
             metadata.append((key, value))
             off += sk + sv
         metadata = tuple(metadata)
 
         yield (prec, sucs, flags, metadata, date, parents)
 
 def _fm1encodeonemarker(marker):
     pre, sucs, flags, metadata, date, parents = marker
     # determine node size
     _fm1node = _fm1nodesha1
     if flags & usingsha256:
         _fm1node = _fm1nodesha256
     numsuc = len(sucs)
     numextranodes = numsuc
     if parents is None:
         numpar = _fm1parentnone
     else:
         numpar = len(parents)
         numextranodes += numpar
     formatnodes = _fm1node * numextranodes
     formatmeta = _fm1metapair * len(metadata)
     format = _fm1fixed + formatnodes + formatmeta
     # tz is stored in minutes so we divide by 60
     tz = date[1]//60
     data = [None, date[0], tz, flags, numsuc, numpar, len(metadata), pre]
     data.extend(sucs)
     if parents is not None:
         data.extend(parents)
     totalsize = struct.calcsize(format)
     for key, value in metadata:
         lk = len(key)
         lv = len(value)
         data.append(lk)
         data.append(lv)
         totalsize += lk + lv
     data[0] = totalsize
     data = [_pack(format, *data)]
     for key, value in metadata:
         data.append(key)
         data.append(value)
     return ''.join(data)
 
 # mapping to read/write various marker formats
 # <version> -> (decoder, encoder)
 formats = {_fm0version: (_fm0readmarkers, _fm0encodeonemarker),
            _fm1version: (_fm1readmarkers, _fm1encodeonemarker)}
 
 def _readmarkers(data):
     """Read and enumerate markers from raw data"""
     off = 0
     diskversion = _unpack('>B', data[off:off + 1])[0]
     off += 1
     if diskversion not in formats:
         raise util.Abort(_('parsing obsolete marker: unknown version %r')
                          % diskversion)
     return diskversion, formats[diskversion][0](data, off)
 
 def encodemarkers(markers, addheader=False, version=_fm0version):
     # Kept separate from flushmarkers(), it will be reused for
     # markers exchange.
     encodeone = formats[version][1]
     if addheader:
         yield _pack('>B', version)
     for marker in markers:
         yield encodeone(marker)
 
 
 class marker(object):
     """Wrap obsolete marker raw data"""
 
     def __init__(self, repo, data):
         # the repo argument will be used to create changectx in later version
         self._repo = repo
         self._data = data
         self._decodedmeta = None
 
     def __hash__(self):
         return hash(self._data)
 
     def __eq__(self, other):
         if type(other) != type(self):
             return False
         return self._data == other._data
 
     def precnode(self):
         """Precursor changeset node identifier"""
         return self._data[0]
 
     def succnodes(self):
         """List of successor changesets node identifiers"""
         return self._data[1]
 
     def parentnodes(self):
         """Parents of the precursors (None if not recorded)"""
         return self._data[5]
 
     def metadata(self):
         """Decoded metadata dictionary"""
         return dict(self._data[3])
 
     def date(self):
         """Creation date as (unixtime, offset)"""
         return self._data[4]
 
     def flags(self):
         """The flags field of the marker"""
         return self._data[2]
 
 class obsstore(object):
     """Store obsolete markers
 
     Markers can be accessed with two mappings:
     - precursors[x] -> set(markers on precursors edges of x)
     - successors[x] -> set(markers on successors edges of x)
     - children[x]   -> set(markers on precursors edges of children(x)
     """
 
     fields = ('prec', 'succs', 'flag', 'meta', 'date', 'parents')
     # prec:    nodeid, precursor changesets
     # succs:   tuple of nodeid, successor changesets (0-N length)
     # flag:    integer, flag field carrying modifier for the markers (see doc)
     # meta:    binary blob, encoded metadata dictionary
     # date:    (float, int) tuple, date of marker creation
     # parents: (tuple of nodeid) or None, parents of precursors
     #          None is used when no data has been recorded
 
-    def __init__(self, sopener, defaultformat=_fm1version):
+    def __init__(self, sopener, defaultformat=_fm1version, readonly=False):
         # caches for various obsolescence related cache
         self.caches = {}
         self._all = []
         self.precursors = {}
         self.successors = {}
         self.children = {}
         self.sopener = sopener
         data = sopener.tryread('obsstore')
         self._version = defaultformat
+        self._readonly = readonly
         if data:
             self._version, markers = _readmarkers(data)
             self._load(markers)
 
     def __iter__(self):
         return iter(self._all)
 
     def __len__(self):
         return len(self._all)
 
     def __nonzero__(self):
         return bool(self._all)
 
     def create(self, transaction, prec, succs=(), flag=0, parents=None,
                date=None, metadata=None):
         """obsolete: add a new obsolete marker
 
         * ensuring it is hashable
         * check mandatory metadata
         * encode metadata
 
         If you are a human writing code creating marker you want to use the
         `createmarkers` function in this module instead.
 
         return True if a new marker have been added, False if the markers
         already existed (no op).
         """
         if metadata is None:
             metadata = {}
         if date is None:
             if 'date' in metadata:
                 # as a courtesy for out-of-tree extensions
                 date = util.parsedate(metadata.pop('date'))
             else:
                 date = util.makedate()
         if len(prec) != 20:
             raise ValueError(prec)
         for succ in succs:
             if len(succ) != 20:
                 raise ValueError(succ)
         if prec in succs:
             raise ValueError(_('in-marker cycle with %s') % node.hex(prec))
 
         metadata = tuple(sorted(metadata.iteritems()))
 
         marker = (str(prec), tuple(succs), int(flag), metadata, date, parents)
         return bool(self.add(transaction, [marker]))
 
     def add(self, transaction, markers):
         """Add new markers to the store
 
         Take care of filtering duplicate.
         Return the number of new marker."""
-        if not _enabled:
-            raise util.Abort('obsolete feature is not enabled on this repo')
+        if self._readonly:
+            raise util.Abort('creating obsolete markers is not enabled on this '
+                             'repo')
         known = set(self._all)
         new = []
         for m in markers:
             if m not in known:
                 known.add(m)
                 new.append(m)
         if new:
             f = self.sopener('obsstore', 'ab')
             try:
                 # Whether the file's current position is at the begin or at
                 # the end after opening a file for appending is implementation
                 # defined. So we must seek to the end before calling tell(),
                 # or we may get a zero offset for non-zero sized files on
                 # some platforms (issue3543).
                 f.seek(0, _SEEK_END)
                 offset = f.tell()
                 transaction.add('obsstore', offset)
                 # offset == 0: new file - add the version header
                 for bytes in encodemarkers(new, offset == 0, self._version):
                     f.write(bytes)
             finally:
                 # XXX: f.close() == filecache invalidation == obsstore rebuilt.
                 # call 'filecacheentry.refresh()'  here
                 f.close()
             self._load(new)
             # new marker *may* have changed several set. invalidate the cache.
             self.caches.clear()
         # records the number of new markers for the transaction hooks
         previous = int(transaction.hookargs.get('new_obsmarkers', '0'))
         transaction.hookargs['new_obsmarkers'] = str(previous + len(new))
         return len(new)
 
     def mergemarkers(self, transaction, data):
         """merge a binary stream of markers inside the obsstore
 
         Returns the number of new markers added."""
         version, markers = _readmarkers(data)
         return self.add(transaction, markers)
 
     def _load(self, markers):
         for mark in markers:
             self._all.append(mark)
             pre, sucs = mark[:2]
             self.successors.setdefault(pre, set()).add(mark)
             for suc in sucs:
                 self.precursors.setdefault(suc, set()).add(mark)
             parents = mark[5]
             if parents is not None:
                 for p in parents:
                     self.children.setdefault(p, set()).add(mark)
         if node.nullid in self.precursors:
             raise util.Abort(_('bad obsolescence marker detected: '
                                'invalid successors nullid'))
     def relevantmarkers(self, nodes):
         """return a set of all obsolescence markers relevant to a set of nodes.
 
         "relevant" to a set of nodes mean:
 
         - marker that use this changeset as successor
         - prune marker of direct children on this changeset
         - recursive application of the two rules on precursors of these markers
 
         It is a set so you cannot rely on order."""
 
         pendingnodes = set(nodes)
         seenmarkers = set()
         seennodes = set(pendingnodes)
         precursorsmarkers = self.precursors
         children = self.children
         while pendingnodes:
             direct = set()
             for current in pendingnodes:
                 direct.update(precursorsmarkers.get(current, ()))
                 pruned = [m for m in children.get(current, ()) if not m[1]]
                 direct.update(pruned)
             direct -= seenmarkers
             pendingnodes = set([m[0] for m in direct])
             seenmarkers |= direct
             pendingnodes -= seennodes
             seennodes |= pendingnodes
         return seenmarkers
 
 def commonversion(versions):
     """Return the newest version listed in both versions and our local formats.
 
     Returns None if no common version exists.
     """
     versions.sort(reverse=True)
     # search for highest version known on both side
     for v in versions:
         if v in formats:
             return v
     return None
 
 # arbitrary picked to fit into 8K limit from HTTP server
 # you have to take in account:
 # - the version header
 # - the base85 encoding
 _maxpayload = 5300
 
 def _pushkeyescape(markers):
     """encode markers into a dict suitable for pushkey exchange
 
     - binary data is base85 encoded
     - split in chunks smaller than 5300 bytes"""
     keys = {}
     parts = []
     currentlen = _maxpayload * 2  # ensure we create a new part
     for marker in markers:
         nextdata = _fm0encodeonemarker(marker)
         if (len(nextdata) + currentlen > _maxpayload):
             currentpart = []
             currentlen = 0
             parts.append(currentpart)
         currentpart.append(nextdata)
         currentlen += len(nextdata)
     for idx, part in enumerate(reversed(parts)):
         data = ''.join([_pack('>B', _fm0version)] + part)
         keys['dump%i' % idx] = base85.b85encode(data)
     return keys
 
 def listmarkers(repo):
     """List markers over pushkey"""
     if not repo.obsstore:
         return {}
     return _pushkeyescape(repo.obsstore)
 
 def pushmarker(repo, key, old, new):
     """Push markers over pushkey"""
     if not key.startswith('dump'):
         repo.ui.warn(_('unknown key: %r') % key)
         return 0
     if old:
         repo.ui.warn(_('unexpected old value for %r') % key)
         return 0
     data = base85.b85decode(new)
     lock = repo.lock()
     try:
         tr = repo.transaction('pushkey: obsolete markers')
         try:
             repo.obsstore.mergemarkers(tr, data)
             tr.close()
             return 1
         finally:
             tr.release()
     finally:
         lock.release()
 
 def getmarkers(repo, nodes=None):
     """returns markers known in a repository
 
     If <nodes> is specified, only markers "relevant" to those nodes are are
     returned"""
     if nodes is None:
         rawmarkers = repo.obsstore
     else:
         rawmarkers = repo.obsstore.relevantmarkers(nodes)
 
     for markerdata in rawmarkers:
         yield marker(repo, markerdata)
 
 def relevantmarkers(repo, node):
     """all obsolete markers relevant to some revision"""
     for markerdata in repo.obsstore.relevantmarkers(node):
         yield marker(repo, markerdata)
 
 
 def precursormarkers(ctx):
     """obsolete marker marking this changeset as a successors"""
     for data in ctx._repo.obsstore.precursors.get(ctx.node(), ()):
         yield marker(ctx._repo, data)
 
 def successormarkers(ctx):
     """obsolete marker making this changeset obsolete"""
     for data in ctx._repo.obsstore.successors.get(ctx.node(), ()):
         yield marker(ctx._repo, data)
 
 def allsuccessors(obsstore, nodes, ignoreflags=0):
     """Yield node for every successor of <nodes>.
 
     Some successors may be unknown locally.
 
     This is a linear yield unsuited to detecting split changesets. It includes
     initial nodes too."""
     remaining = set(nodes)
     seen = set(remaining)
     while remaining:
         current = remaining.pop()
         yield current
         for mark in obsstore.successors.get(current, ()):
             # ignore marker flagged with specified flag
             if mark[2] & ignoreflags:
                 continue
             for suc in mark[1]:
                 if suc not in seen:
                     seen.add(suc)
                     remaining.add(suc)
 
 def allprecursors(obsstore, nodes, ignoreflags=0):
     """Yield node for every precursors of <nodes>.
 
     Some precursors may be unknown locally.
 
     This is a linear yield unsuited to detecting folded changesets. It includes
     initial nodes too."""
 
     remaining = set(nodes)
     seen = set(remaining)
     while remaining:
         current = remaining.pop()
         yield current
         for mark in obsstore.precursors.get(current, ()):
             # ignore marker flagged with specified flag
             if mark[2] & ignoreflags:
                 continue
             suc = mark[0]
             if suc not in seen:
                 seen.add(suc)
                 remaining.add(suc)
 
 def foreground(repo, nodes):
     """return all nodes in the "foreground" of other node
 
     The foreground of a revision is anything reachable using parent -> children
     or precursor -> successor relation. It is very similar to "descendant" but
     augmented with obsolescence information.
 
     Beware that possible obsolescence cycle may result if complex situation.
     """
     repo = repo.unfiltered()
     foreground = set(repo.set('%ln::', nodes))
     if repo.obsstore:
         # We only need this complicated logic if there is obsolescence
         # XXX will probably deserve an optimised revset.
         nm = repo.changelog.nodemap
         plen = -1
         # compute the whole set of successors or descendants
         while len(foreground) != plen:
             plen = len(foreground)
             succs = set(c.node() for c in foreground)
             mutable = [c.node() for c in foreground if c.mutable()]
             succs.update(allsuccessors(repo.obsstore, mutable))
             known = (n for n in succs if n in nm)
             foreground = set(repo.set('%ln::', known))
     return set(c.node() for c in foreground)
 
 
 def successorssets(repo, initialnode, cache=None):
     """Return all set of successors of initial nodes
 
     The successors set of a changeset A are a group of revisions that succeed
     A. It succeeds A as a consistent whole, each revision being only a partial
     replacement. The successors set contains non-obsolete changesets only.
 
     This function returns the full list of successor sets which is why it
     returns a list of tuples and not just a single tuple. Each tuple is a valid
     successors set. Not that (A,) may be a valid successors set for changeset A
     (see below).
 
     In most cases, a changeset A will have a single element (e.g. the changeset
     A is replaced by A') in its successors set. Though, it is also common for a
     changeset A to have no elements in its successor set (e.g. the changeset
     has been pruned). Therefore, the returned list of successors sets will be
     [(A',)] or [], respectively.
 
     When a changeset A is split into A' and B', however, it will result in a
     successors set containing more than a single element, i.e. [(A',B')].
     Divergent changesets will result in multiple successors sets, i.e. [(A',),
     (A'')].
 
     If a changeset A is not obsolete, then it will conceptually have no
     successors set. To distinguish this from a pruned changeset, the successor
     set will only contain itself, i.e. [(A,)].
 
     Finally, successors unknown locally are considered to be pruned (obsoleted
     without any successors).
 
     The optional `cache` parameter is a dictionary that may contain precomputed
     successors sets. It is meant to reuse the computation of a previous call to
     `successorssets` when multiple calls are made at the same time. The cache
     dictionary is updated in place. The caller is responsible for its live
     spawn. Code that makes multiple calls to `successorssets` *must* use this
     cache mechanism or suffer terrible performances.
 
     """
 
     succmarkers = repo.obsstore.successors
 
     # Stack of nodes we search successors sets for
     toproceed = [initialnode]
     # set version of above list for fast loop detection
     # element added to "toproceed" must be added here
     stackedset = set(toproceed)
     if cache is None:
         cache = {}
 
     # This while loop is the flattened version of a recursive search for
     # successors sets
     #
     # def successorssets(x):
     #    successors = directsuccessors(x)
     #    ss = [[]]
     #    for succ in directsuccessors(x):
     #        # product as in itertools cartesian product
     #        ss = product(ss, successorssets(succ))
     #    return ss
     #
     # But we can not use plain recursive calls here:
     # - that would blow the python call stack
     # - obsolescence markers may have cycles, we need to handle them.
     #
     # The `toproceed` list act as our call stack. Every node we search
     # successors set for are stacked there.
     #
     # The `stackedset` is set version of this stack used to check if a node is
     # already stacked. This check is used to detect cycles and prevent infinite
     # loop.
     #
     # successors set of all nodes are stored in the `cache` dictionary.
     #
     # After this while loop ends we use the cache to return the successors sets
     # for the node requested by the caller.
     while toproceed:
         # Every iteration tries to compute the successors sets of the topmost
         # node of the stack: CURRENT.
         #
         # There are four possible outcomes:
         #
         # 1) We already know the successors sets of CURRENT:
         #    -> mission accomplished, pop it from the stack.
         # 2) Node is not obsolete:
         #    -> the node is its own successors sets. Add it to the cache.
         # 3) We do not know successors set of direct successors of CURRENT:
         #    -> We add those successors to the stack.
         # 4) We know successors sets of all direct successors of CURRENT:
         #    -> We can compute CURRENT successors set and add it to the
         #       cache.
         #
         current = toproceed[-1]
         if current in cache:
             # case (1): We already know the successors sets
             stackedset.remove(toproceed.pop())
         elif current not in succmarkers:
             # case (2): The node is not obsolete.
             if current in repo:
                 # We have a valid last successors.
                 cache[current] = [(current,)]
             else:
                 # Final obsolete version is unknown locally.
                 # Do not count that as a valid successors
                 cache[current] = []
         else:
             # cases (3) and (4)
             #
             # We proceed in two phases. Phase 1 aims to distinguish case (3)
             # from case (4):
             #
             #     For each direct successors of CURRENT, we check whether its
             #     successors sets are known. If they are not, we stack the
             #     unknown node and proceed to the next iteration of the while
             #     loop. (case 3)
             #
             #     During this step, we may detect obsolescence cycles: a node
             #     with unknown successors sets but already in the call stack.
             #     In such a situation, we arbitrary set the successors sets of
             #     the node to nothing (node pruned) to break the cycle.
             #
             #     If no break was encountered we proceed to phase 2.
             #
             # Phase 2 computes successors sets of CURRENT (case 4); see details
             # in phase 2 itself.
             #
             # Note the two levels of iteration in each phase.
             # - The first one handles obsolescence markers using CURRENT as
             #   precursor (successors markers of CURRENT).
             #
             #   Having multiple entry here means divergence.
             #
             # - The second one handles successors defined in each marker.
             #
             #   Having none means pruned node, multiple successors means split,
             #   single successors are standard replacement.
             #
             for mark in sorted(succmarkers[current]):
                 for suc in mark[1]:
                     if suc not in cache:
                         if suc in stackedset:
                             # cycle breaking
                             cache[suc] = []
                         else:
                             # case (3) If we have not computed successors sets
                             # of one of those successors we add it to the
                             # `toproceed` stack and stop all work for this
                             # iteration.
                             toproceed.append(suc)
                             stackedset.add(suc)
                             break
                 else:
                     continue
                 break
             else:
                 # case (4): we know all successors sets of all direct
                 # successors
                 #
                 # Successors set contributed by each marker depends on the
                 # successors sets of all its "successors" node.
                 #
                 # Each different marker is a divergence in the obsolescence
                 # history. It contributes successors sets distinct from other
                 # markers.
                 #
                 # Within a marker, a successor may have divergent successors
                 # sets. In such a case, the marker will contribute multiple
                 # divergent successors sets. If multiple successors have
                 # divergent successors sets, a Cartesian product is used.
                 #
                 # At the end we post-process successors sets to remove
                 # duplicated entry and successors set that are strict subset of
                 # another one.
                 succssets = []
                 for mark in sorted(succmarkers[current]):
                     # successors sets contributed by this marker
                     markss = [[]]
                     for suc in mark[1]:
                         # cardinal product with previous successors
                         productresult = []
                         for prefix in markss:
                             for suffix in cache[suc]:
                                 newss = list(prefix)
                                 for part in suffix:
                                     # do not duplicated entry in successors set
                                     # first entry wins.
                                     if part not in newss:
                                         newss.append(part)
                                 productresult.append(newss)
                         markss = productresult
                     succssets.extend(markss)
                 # remove duplicated and subset
                 seen = []
                 final = []
                 candidate = sorted(((set(s), s) for s in succssets if s),
                                    key=lambda x: len(x[1]), reverse=True)
                 for setversion, listversion in candidate:
                     for seenset in seen:
                         if setversion.issubset(seenset):
                             break
                     else:
                         final.append(listversion)
                         seen.append(setversion)
                 final.reverse() # put small successors set first
                 cache[current] = final
     return cache[initialnode]
 
 def _knownrevs(repo, nodes):
     """yield revision numbers of known nodes passed in parameters
 
     Unknown revisions are silently ignored."""
     torev = repo.changelog.nodemap.get
     for n in nodes:
         rev = torev(n)
         if rev is not None:
             yield rev
 
 # mapping of 'set-name' -> <function to compute this set>
 cachefuncs = {}
 def cachefor(name):
     """Decorator to register a function as computing the cache for a set"""
     def decorator(func):
         assert name not in cachefuncs
         cachefuncs[name] = func
         return func
     return decorator
 
 def getrevs(repo, name):
     """Return the set of revision that belong to the <name> set
 
     Such access may compute the set and cache it for future use"""
     repo = repo.unfiltered()
     if not repo.obsstore:
         return frozenset()
     if name not in repo.obsstore.caches:
         repo.obsstore.caches[name] = cachefuncs[name](repo)
     return repo.obsstore.caches[name]
 
 # To be simple we need to invalidate obsolescence cache when:
 #
 # - new changeset is added:
 # - public phase is changed
 # - obsolescence marker are added
 # - strip is used a repo
 def clearobscaches(repo):
     """Remove all obsolescence related cache from a repo
 
     This remove all cache in obsstore is the obsstore already exist on the
     repo.
 
     (We could be smarter here given the exact event that trigger the cache
     clearing)"""
     # only clear cache is there is obsstore data in this repo
     if 'obsstore' in repo._filecache:
         repo.obsstore.caches.clear()
 
 @cachefor('obsolete')
 def _computeobsoleteset(repo):
     """the set of obsolete revisions"""
     obs = set()
     getrev = repo.changelog.nodemap.get
     getphase = repo._phasecache.phase
     for n in repo.obsstore.successors:
         rev = getrev(n)
         if rev is not None and getphase(repo, rev):
             obs.add(rev)
     return obs
 
 @cachefor('unstable')
 def _computeunstableset(repo):
     """the set of non obsolete revisions with obsolete parents"""
     # revset is not efficient enough here
     # we do (obsolete()::) - obsolete() by hand
     obs = getrevs(repo, 'obsolete')
     if not obs:
         return set()
     cl = repo.changelog
     return set(r for r in cl.descendants(obs) if r not in obs)
 
 @cachefor('suspended')
 def _computesuspendedset(repo):
     """the set of obsolete parents with non obsolete descendants"""
     suspended = repo.changelog.ancestors(getrevs(repo, 'unstable'))
     return set(r for r in getrevs(repo, 'obsolete') if r in suspended)
 
 @cachefor('extinct')
 def _computeextinctset(repo):
     """the set of obsolete parents without non obsolete descendants"""
     return getrevs(repo, 'obsolete') - getrevs(repo, 'suspended')
 
 
 @cachefor('bumped')
 def _computebumpedset(repo):
     """the set of revs trying to obsolete public revisions"""
     bumped = set()
     # util function (avoid attribute lookup in the loop)
     phase = repo._phasecache.phase # would be faster to grab the full list
     public = phases.public
     cl = repo.changelog
     torev = cl.nodemap.get
     obs = getrevs(repo, 'obsolete')
     for rev in repo:
         # We only evaluate mutable, non-obsolete revision
         if (public < phase(repo, rev)) and (rev not in obs):
             node = cl.node(rev)
             # (future) A cache of precursors may worth if split is very common
             for pnode in allprecursors(repo.obsstore, [node],
                                        ignoreflags=bumpedfix):
                 prev = torev(pnode) # unfiltered! but so is phasecache
                 if (prev is not None) and (phase(repo, prev) <= public):
                     # we have a public precursors
                     bumped.add(rev)
                     break # Next draft!
     return bumped
 
 @cachefor('divergent')
 def _computedivergentset(repo):
     """the set of rev that compete to be the final successors of some revision.
     """
     divergent = set()
     obsstore = repo.obsstore
     newermap = {}
     for ctx in repo.set('(not public()) - obsolete()'):
         mark = obsstore.precursors.get(ctx.node(), ())
         toprocess = set(mark)
         while toprocess:
             prec = toprocess.pop()[0]
             if prec not in newermap:
                 successorssets(repo, prec, newermap)
             newer = [n for n in newermap[prec] if n]
             if len(newer) > 1:
                 divergent.add(ctx.rev())
                 break
             toprocess.update(obsstore.precursors.get(prec, ()))
     return divergent
 
 
 def createmarkers(repo, relations, flag=0, date=None, metadata=None):
     """Add obsolete markers between changesets in a repo
 
     <relations> must be an iterable of (<old>, (<new>, ...)[,{metadata}])
     tuple. `old` and `news` are changectx. metadata is an optional dictionary
     containing metadata for this marker only. It is merged with the global
     metadata specified through the `metadata` argument of this function,
 
     Trying to obsolete a public changeset will raise an exception.
 
     Current user and date are used except if specified otherwise in the
     metadata attribute.
 
     This function operates within a transaction of its own, but does
     not take any lock on the repo.
     """
     # prepare metadata
     if metadata is None:
         metadata = {}
     if 'user' not in metadata:
         metadata['user'] = repo.ui.username()
     tr = repo.transaction('add-obsolescence-marker')
     try:
         for rel in relations:
             prec = rel[0]
             sucs = rel[1]
             localmetadata = metadata.copy()
             if 2 < len(rel):
                 localmetadata.update(rel[2])
 
             if not prec.mutable():
                 raise util.Abort("cannot obsolete immutable changeset: %s"
                                  % prec)
             nprec = prec.node()
             nsucs = tuple(s.node() for s in sucs)
             npare = None
             if not nsucs:
                 npare = tuple(p.node() for p in prec.parents())
             if nprec in nsucs:
                 raise util.Abort("changeset %s cannot obsolete itself" % prec)
             repo.obsstore.create(tr, nprec, nsucs, flag, parents=npare,
                                  date=date, metadata=localmetadata)
             repo.filteredrevcache.clear()
         tr.close()
     finally:
         tr.release()
 
 def isenabled(repo, option):
     """Returns True if the given repository has the given obsolete option
     enabled.
     """
     result = set(repo.ui.configlist('experimental', 'evolution'))
     if 'all' in result:
         return True
 
     # For migration purposes, temporarily return true if the config hasn't been
     # set but _enabled is true.
     if len(result) == 0 and _enabled:
         return True
 
     return option in result

tests/test-obsolete.t

@@ -1,754 +1,754 b''
   $ cat >> $HGRCPATH << EOF
   > [phases]
   > # public changeset are not obsolete
   > publish=false
   > [ui]
   > logtemplate="{rev}:{node|short} ({phase}) [{tags} {bookmarks}] {desc|firstline}\n"
   > EOF
   $ mkcommit() {
   >    echo "$1" > "$1"
   >    hg add "$1"
   >    hg ci -m "add $1"
   > }
   $ getid() {
   >    hg id --debug --hidden -ir "desc('$1')"
   > }
 
   $ cat > debugkeys.py <<EOF
   > def reposetup(ui, repo):
   >     class debugkeysrepo(repo.__class__):
   >         def listkeys(self, namespace):
   >             ui.write('listkeys %s\n' % (namespace,))
   >             return super(debugkeysrepo, self).listkeys(namespace)
   > 
   >     if repo.local():
   >         repo.__class__ = debugkeysrepo
   > EOF
 
   $ hg init tmpa
   $ cd tmpa
   $ mkcommit kill_me
 
 Checking that the feature is properly disabled
 
   $ hg debugobsolete -d '0 0' `getid kill_me` -u babar
-  abort: obsolete feature is not enabled on this repo
+  abort: creating obsolete markers is not enabled on this repo
   [255]
 
 Enabling it
 
   $ cat > ../obs.py << EOF
   > import mercurial.obsolete
   > mercurial.obsolete._enabled = True
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=${TESTTMP}/obs.py" >> $HGRCPATH
 
 Killing a single changeset without replacement
 
   $ hg debugobsolete 0
   abort: changeset references must be full hexadecimal node identifiers
   [255]
   $ hg debugobsolete '00'
   abort: changeset references must be full hexadecimal node identifiers
   [255]
   $ hg debugobsolete -d '0 0' `getid kill_me` -u babar
   $ hg debugobsolete
   97b7c2d76b1845ed3eb988cd612611e72406cef0 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'babar'}
 
 (test that mercurial is not confused)
 
   $ hg up null --quiet # having 0 as parent prevents it to be hidden
   $ hg tip
   -1:000000000000 (public) [tip ] 
   $ hg up --hidden tip --quiet
 
 Killing a single changeset with itself should fail
 (simple local safeguard)
 
   $ hg debugobsolete `getid kill_me` `getid kill_me`
   abort: bad obsmarker input: in-marker cycle with 97b7c2d76b1845ed3eb988cd612611e72406cef0
   [255]
 
   $ cd ..
 
 Killing a single changeset with replacement
 (and testing the format option)
 
   $ hg init tmpb
   $ cd tmpb
   $ mkcommit a
   $ mkcommit b
   $ mkcommit original_c
   $ hg up "desc('b')"
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_c
   created new head
   $ hg log -r 'hidden()' --template '{rev}:{node|short} {desc}\n' --hidden
   $ hg debugobsolete --config format.obsstore-version=0 --flag 12 `getid original_c`  `getid new_c` -d '56 120'
   $ hg log -r 'hidden()' --template '{rev}:{node|short} {desc}\n' --hidden
   2:245bde4270cd add original_c
   $ hg debugrevlog -cd
   # rev p1rev p2rev start   end deltastart base   p1   p2 rawsize totalsize compression heads chainlen
       0    -1    -1     0    59          0    0    0    0      58        58           0     1        0
       1     0    -1    59   118         59   59    0    0      58       116           0     1        0
       2     1    -1   118   204         59   59   59    0      76       192           0     1        1
       3     1    -1   204   271        204  204   59    0      66       258           0     2        0
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
 
 (check for version number of the obsstore)
 
   $ dd bs=1 count=1 if=.hg/store/obsstore 2>/dev/null
   \x00 (no-eol) (esc)
 
 do it again (it read the obsstore before adding new changeset)
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_2_c
   created new head
   $ hg debugobsolete -d '1337 0' `getid new_c` `getid new_2_c`
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
 
 Register two markers with a missing node
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_3_c
   created new head
   $ hg debugobsolete -d '1338 0' `getid new_2_c` 1337133713371337133713371337133713371337
   $ hg debugobsolete -d '1339 0' 1337133713371337133713371337133713371337 `getid new_3_c`
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
 
 Refuse pathological nullid successors
   $ hg debugobsolete -d '9001 0' 1337133713371337133713371337133713371337 0000000000000000000000000000000000000000
   transaction abort!
   rollback completed
   abort: bad obsolescence marker detected: invalid successors nullid
   [255]
 
 Check that graphlog detect that a changeset is obsolete:
 
   $ hg log -G
   @  5:5601fb93a350 (draft) [tip ] add new_3_c
   |
   o  1:7c3bad9141dc (draft) [ ] add b
   |
   o  0:1f0dee641bb7 (draft) [ ] add a
   
 
 check that heads does not report them
 
   $ hg heads
   5:5601fb93a350 (draft) [tip ] add new_3_c
   $ hg heads --hidden
   5:5601fb93a350 (draft) [tip ] add new_3_c
   4:ca819180edb9 (draft) [ ] add new_2_c
   3:cdbce2fbb163 (draft) [ ] add new_c
   2:245bde4270cd (draft) [ ] add original_c
 
 
 check that summary does not report them
 
   $ hg init ../sink
   $ echo '[paths]' >> .hg/hgrc
   $ echo 'default=../sink' >> .hg/hgrc
   $ hg summary --remote
   parent: 5:5601fb93a350 tip
    add new_3_c
   branch: default
   commit: (clean)
   update: (current)
   remote: 3 outgoing
 
   $ hg summary --remote --hidden
   parent: 5:5601fb93a350 tip
    add new_3_c
   branch: default
   commit: (clean)
   update: 3 new changesets, 4 branch heads (merge)
   remote: 3 outgoing
 
 check that various commands work well with filtering
 
   $ hg tip
   5:5601fb93a350 (draft) [tip ] add new_3_c
   $ hg log -r 6
   abort: unknown revision '6'!
   [255]
   $ hg log -r 4
   abort: unknown revision '4'!
   [255]
 
 Check that public changeset are not accounted as obsolete:
 
   $ hg --hidden phase --public 2
   $ hg log -G
   @  5:5601fb93a350 (draft) [tip ] add new_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 And that bumped changeset are detected
 --------------------------------------
 
 If we didn't filtered obsolete changesets out, 3 and 4 would show up too. Also
 note that the bumped changeset (5:5601fb93a350) is not a direct successor of
 the public changeset
 
   $ hg log --hidden -r 'bumped()'
   5:5601fb93a350 (draft) [tip ] add new_3_c
 
 And that we can't push bumped changeset
 
   $ hg push ../tmpa -r 0 --force #(make repo related)
   pushing to ../tmpa
   searching for changes
   warning: repository is unrelated
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   $ hg push ../tmpa
   pushing to ../tmpa
   searching for changes
   abort: push includes bumped changeset: 5601fb93a350!
   [255]
 
 Fixing "bumped" situation
 We need to create a clone of 5 and add a special marker with a flag
 
   $ hg up '5^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg revert -ar 5
   adding new_3_c
   $ hg ci -m 'add n3w_3_c'
   created new head
   $ hg debugobsolete -d '1338 0' --flags 1 `getid new_3_c` `getid n3w_3_c`
   $ hg log -r 'bumped()'
   $ hg log -G
   @  6:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 
 
   $ cd ..
 
 Exchange Test
 ============================
 
 Destination repo does not have any data
 ---------------------------------------
 
 Simple incoming test
 
   $ hg init tmpc
   $ cd tmpc
   $ hg incoming ../tmpb
   comparing with ../tmpb
   0:1f0dee641bb7 (public) [ ] add a
   1:7c3bad9141dc (public) [ ] add b
   2:245bde4270cd (public) [ ] add original_c
   6:6f9641995072 (draft) [tip ] add n3w_3_c
 
 Try to pull markers
 (extinct changeset are excluded but marker are pushed)
 
   $ hg pull ../tmpb
   pulling from ../tmpb
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
 
 Rollback//Transaction support
 
   $ hg debugobsolete -d '1340 0' aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 0 (Thu Jan 01 00:22:20 1970 +0000) {'user': 'test'}
   $ hg rollback -n
   repository tip rolled back to revision 3 (undo debugobsolete)
   $ hg rollback
   repository tip rolled back to revision 3 (undo debugobsolete)
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
 
   $ cd ..
 
 Try to push markers
 
   $ hg init tmpd
   $ hg -R tmpb push tmpd
   pushing to tmpd
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   $ hg -R tmpd debugobsolete | sort
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
 
 Check obsolete keys are exchanged only if source has an obsolete store
 
   $ hg init empty
   $ hg --config extensions.debugkeys=debugkeys.py -R empty push tmpd
   pushing to tmpd
   listkeys phases
   listkeys bookmarks
   no changes found
   listkeys phases
   [1]
 
 clone support
 (markers are copied and extinct changesets are included to allow hardlinks)
 
   $ hg clone tmpb clone-dest
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R clone-dest log -G --hidden
   @  6:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | x  5:5601fb93a350 (draft) [ ] add new_3_c
   |/
   | x  4:ca819180edb9 (draft) [ ] add new_2_c
   |/
   | x  3:cdbce2fbb163 (draft) [ ] add new_c
   |/
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg -R clone-dest debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
 
 
 Destination repo have existing data
 ---------------------------------------
 
 On pull
 
   $ hg init tmpe
   $ cd tmpe
   $ hg debugobsolete -d '1339 0' 1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00
   $ hg pull ../tmpb
   pulling from ../tmpb
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg debugobsolete
   1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
 
 
 On push
 
   $ hg push ../tmpc
   pushing to ../tmpc
   searching for changes
   no changes found
   [1]
   $ hg -R ../tmpc debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
 
 detect outgoing obsolete and unstable
 ---------------------------------------
 
 
   $ hg log -G
   o  3:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg up 'desc("n3w_3_c")'
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkcommit original_d
   $ mkcommit original_e
   $ hg debugobsolete --record-parents `getid original_d` -d '0 0'
   $ hg debugobsolete | grep `getid original_d`
   94b33453f93bdb8d457ef9b770851a618bf413e1 0 {6f96419950729f3671185b847352890f074f7557} (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   $ hg log -r 'obsolete()'
   4:94b33453f93b (draft) [ ] add original_d
   $ hg log -G -r '::unstable()'
   @  5:cda648ca50f5 (draft) [tip ] add original_e
   |
   x  4:94b33453f93b (draft) [ ] add original_d
   |
   o  3:6f9641995072 (draft) [ ] add n3w_3_c
   |
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 refuse to push obsolete changeset
 
   $ hg push ../tmpc/ -r 'desc("original_d")'
   pushing to ../tmpc/
   searching for changes
   abort: push includes obsolete changeset: 94b33453f93b!
   [255]
 
 refuse to push unstable changeset
 
   $ hg push ../tmpc/
   pushing to ../tmpc/
   searching for changes
   abort: push includes unstable changeset: cda648ca50f5!
   [255]
 
 Test that extinct changeset are properly detected
 
   $ hg log -r 'extinct()'
 
 Don't try to push extinct changeset
 
   $ hg init ../tmpf
   $ hg out  ../tmpf
   comparing with ../tmpf
   searching for changes
   0:1f0dee641bb7 (public) [ ] add a
   1:7c3bad9141dc (public) [ ] add b
   2:245bde4270cd (public) [ ] add original_c
   3:6f9641995072 (draft) [ ] add n3w_3_c
   4:94b33453f93b (draft) [ ] add original_d
   5:cda648ca50f5 (draft) [tip ] add original_e
   $ hg push ../tmpf -f # -f because be push unstable too
   pushing to ../tmpf
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 6 changes to 6 files (+1 heads)
 
 no warning displayed
 
   $ hg push ../tmpf
   pushing to ../tmpf
   searching for changes
   no changes found
   [1]
 
 Do not warn about new head when the new head is a successors of a remote one
 
   $ hg log -G
   @  5:cda648ca50f5 (draft) [tip ] add original_e
   |
   x  4:94b33453f93b (draft) [ ] add original_d
   |
   o  3:6f9641995072 (draft) [ ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg up -q 'desc(n3w_3_c)'
   $ mkcommit obsolete_e
   created new head
   $ hg debugobsolete `getid 'original_e'` `getid 'obsolete_e'`
   $ hg outgoing ../tmpf # parasite hg outgoing testin
   comparing with ../tmpf
   searching for changes
   6:3de5eca88c00 (draft) [tip ] add obsolete_e
   $ hg push ../tmpf
   pushing to ../tmpf
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
 test relevance computation
 ---------------------------------------
 
 Checking simple case of "marker relevance".
 
 
 Reminder of the repo situation
 
   $ hg log --hidden --graph
   @  6:3de5eca88c00 (draft) [tip ] add obsolete_e
   |
   | x  5:cda648ca50f5 (draft) [ ] add original_e
   | |
   | x  4:94b33453f93b (draft) [ ] add original_d
   |/
   o  3:6f9641995072 (draft) [ ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 List of all markers
 
   $ hg debugobsolete
   1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   94b33453f93bdb8d457ef9b770851a618bf413e1 0 {6f96419950729f3671185b847352890f074f7557} (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   cda648ca50f50482b7055c0b0c4c117bba6733d9 3de5eca88c00aa039da7399a220f4a5221faa585 0 (*) {'user': 'test'} (glob)
 
 List of changesets with no chain
 
   $ hg debugobsolete --hidden --rev ::2
 
 List of changesets that are included on marker chain
 
   $ hg debugobsolete --hidden --rev 6
   cda648ca50f50482b7055c0b0c4c117bba6733d9 3de5eca88c00aa039da7399a220f4a5221faa585 0 (*) {'user': 'test'} (glob)
 
 List of changesets with a longer chain, (including a pruned children)
 
   $ hg debugobsolete --hidden --rev 3
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   94b33453f93bdb8d457ef9b770851a618bf413e1 0 {6f96419950729f3671185b847352890f074f7557} (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
 
 List of both
 
   $ hg debugobsolete --hidden --rev 3::6
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   1339133913391339133913391339133913391339 ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:19 1970 +0000) {'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C (Wed Dec 31 23:58:56 1969 -0002) {'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   94b33453f93bdb8d457ef9b770851a618bf413e1 0 {6f96419950729f3671185b847352890f074f7557} (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 (Thu Jan 01 00:22:18 1970 +0000) {'user': 'test'}
   cda648ca50f50482b7055c0b0c4c117bba6733d9 3de5eca88c00aa039da7399a220f4a5221faa585 0 (*) {'user': 'test'} (glob)
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 (Thu Jan 01 00:22:17 1970 +0000) {'user': 'test'}
 
 #if serve
 
 check hgweb does not explode
 ====================================
 
   $ hg unbundle $TESTDIR/bundles/hgweb+obs.hg
   adding changesets
   adding manifests
   adding file changes
   added 62 changesets with 63 changes to 9 files (+60 heads)
   (run 'hg heads .' to see heads, 'hg merge' to merge)
   $ for node in `hg log -r 'desc(babar_)' --template '{node}\n'`;
   > do
   >    hg debugobsolete $node
   > done
   $ hg up tip
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg serve -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 check changelog view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'shortlog/'
   200 Script output follows
 
 check graph view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'graph'
   200 Script output follows
 
 check filelog view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'log/'`hg id --debug --id`/'babar'
   200 Script output follows
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/68'
   200 Script output follows
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/67'
   404 Not Found
   [1]
 
 check that web.view config option:
 
   $ "$TESTDIR/killdaemons.py" hg.pid
   $ cat >> .hg/hgrc << EOF
   > [web]
   > view=all
   > EOF
   $ wait
   $ hg serve -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/67'
   200 Script output follows
   $ "$TESTDIR/killdaemons.py" hg.pid
 
 Checking _enable=False warning if obsolete marker exists
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=!" >> $HGRCPATH
   $ hg log -r tip
   obsolete feature not enabled but 68 markers found!
   68:c15e9edfca13 (draft) [tip ] add celestine
 
 reenable for later test
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=${TESTTMP}/obs.py" >> $HGRCPATH
 
 #endif
 
 Test incoming/outcoming with changesets obsoleted remotely, known locally
 ===============================================================================
 
 This test issue 3805
 
   $ hg init repo-issue3805
   $ cd repo-issue3805
   $ echo "foo" > foo
   $ hg ci -Am "A"
   adding foo
   $ hg clone . ../other-issue3805
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "bar" >> foo
   $ hg ci --amend
   $ cd ../other-issue3805
   $ hg log -G
   @  0:193e9254ce7e (draft) [tip ] A
   
   $ hg log -G -R ../repo-issue3805
   @  2:3816541e5485 (draft) [tip ] A
   
   $ hg incoming
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   2:3816541e5485 (draft) [tip ] A
   $ hg incoming --bundle ../issue3805.hg
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   2:3816541e5485 (draft) [tip ] A
   $ hg outgoing
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   no changes found
   [1]
 
 #if serve
 
   $ hg serve -R ../repo-issue3805 -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg incoming http://localhost:$HGPORT
   comparing with http://localhost:$HGPORT/
   searching for changes
   1:3816541e5485 (public) [tip ] A
   $ hg outgoing http://localhost:$HGPORT
   comparing with http://localhost:$HGPORT/
   searching for changes
   no changes found
   [1]
 
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 
 #endif
 
 This test issue 3814
 
 (nothing to push but locally hidden changeset)
 
   $ cd ..
   $ hg init repo-issue3814
   $ cd repo-issue3805
   $ hg push -r 3816541e5485 ../repo-issue3814
   pushing to ../repo-issue3814
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   $ hg out ../repo-issue3814
   comparing with ../repo-issue3814
   searching for changes
   no changes found
   [1]
 
 Test that a local tag blocks a changeset from being hidden
 
   $ hg tag -l visible -r 0 --hidden
   $ hg log -G
   @  2:3816541e5485 (draft) [tip ] A
   
   x  0:193e9254ce7e (draft) [visible ] A
   
 Test that removing a local tag does not cause some commands to fail
 
   $ hg tag -l -r tip tiptag
   $ hg tags
   tiptag                             2:3816541e5485
   tip                                2:3816541e5485
   visible                            0:193e9254ce7e
   $ hg --config extensions.strip= strip -r tip --no-backup
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg tags
   visible                            0:193e9254ce7e
   tip                                0:193e9254ce7e