This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4641

localrepo: pass root manifest into manifestlog.__init__
ClosedPublic

Authored by indygreg on Sep 18 2018, 6:40 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5ccd791344f3: localrepo: pass root manifest into manifestlog.__init__
Summary

Today, localrepository has a method that can be overloaded which
returns an instance of the root manifest storage object. When a
manifestlog is created, it calls this private method and stores
the root manifest object on it.

This "hook" on localrepository isn't part of the documented interface.
It isn't compatible with our desire to make repo storage determined
before the repo object is constructed.

This commit changes manifestlog.init to accept the root
storage object instead of calling into the repo to construct it.
By doing things this way, the repo instance is responsible for
constructing the manifest storage object directly.

This does mean that other derived repo types need to overload
manifestlog(). But they should have been doing this already,
as manifestlog() is typically decorated in a storage-specific way.
e.g. localrepository.manifestlog() is decorated as
@storecache('00manifest.i'). And this assumes that a 00manifest.i
file exists in the store vfs. This condition may not hold for
repository types using non-revlog storage. So it is important
for special repo types to override manifestlog() to remove this
file association.

The code changed in perf is wrong because it isn't compatible with
older Mercurial versions. But I'm pretty sure the code was broken
on older versions before this commit. It only affects hg perftags.
I don't care enough to fix that at this time.

.. api::

``manifest.manifestlog.__init__()`` now receives the root manifest
storage instance instead of calling into a private method on
the repo object to obtain it.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Sep 18 2018, 6:40 PM
yuja added a subscriber: yuja.Sep 23 2018, 5:30 AM

Queued, thanks.

diff --git a/mercurial/unionrepo.py b/mercurial/unionrepo.py

  • a/mercurial/unionrepo.py

+++ b/mercurial/unionrepo.py
@@ -208,6 +208,12 @@

def changelog(self):
    return unionchangelog(self.svfs, self.repo2.svfs)

+ @localrepo.unfilteredpropertycache
+ def manifestlog(self):
+ rootstore = unionmanifest(self.svfs, self.repo2.svfs,
+ self.unfiltered()._clrev)
+ return manifest.manifestlog(self.svfs, self, rootstore)

Perhaps unionrepository._constructmanifest() can be removed.

Closed by commit rHG5ccd791344f3: localrepo: pass root manifest into manifestlog.__init__ (authored by indygreg). · Explain WhySep 23 2018, 5:38 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11267

contrib/perf.py

def perftags(ui, repo, **opts): def perftags(ui, repo, **opts):
import mercurial.changelog import mercurial.changelog
import mercurial.manifest import mercurial.manifest
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
svfs = getsvfs(repo) svfs = getsvfs(repo)
repocleartagscache = repocleartagscachefunc(repo) repocleartagscache = repocleartagscachefunc(repo)
def t(): def t():
repo.changelog = mercurial.changelog.changelog(svfs) repo.changelog = mercurial.changelog.changelog(svfs)
repo.manifestlog = mercurial.manifest.manifestlog(svfs, repo) rootmanifest = mercurial.manifest.manifestrevlog(svfs)
repo.manifestlog = mercurial.manifest.manifestlog(svfs, repo,
rootmanifest)
repocleartagscache() repocleartagscache()
return len(repo.tags()) return len(repo.tags())
timer(t) timer(t)
fm.end() fm.end()
@command(b'perfancestors', formatteropts) @command(b'perfancestors', formatteropts)
def perfancestors(ui, repo, **opts): def perfancestors(ui, repo, **opts):
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)

mercurial/bundlerepo.py

@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def changelog(self): def changelog(self):
# consume the header if it exists # consume the header if it exists
self._cgunpacker.changelogheader() self._cgunpacker.changelogheader()
c = bundlechangelog(self.svfs, self._cgunpacker) c = bundlechangelog(self.svfs, self._cgunpacker)
self.manstart = self._cgunpacker.tell() self.manstart = self._cgunpacker.tell()
return c return c
def _constructmanifest(self): @localrepo.unfilteredpropertycache
def manifestlog(self):
self._cgunpacker.seek(self.manstart) self._cgunpacker.seek(self.manstart)
# consume the header if it exists # consume the header if it exists
self._cgunpacker.manifestheader() self._cgunpacker.manifestheader()
linkmapper = self.unfiltered().changelog.rev linkmapper = self.unfiltered().changelog.rev
m = bundlemanifest(self.svfs, self._cgunpacker, linkmapper) rootstore = bundlemanifest(self.svfs, self._cgunpacker, linkmapper)
self.filestart = self._cgunpacker.tell() self.filestart = self._cgunpacker.tell()
return m
return manifest.manifestlog(self.svfs, self, rootstore)
def _consumemanifest(self): def _consumemanifest(self):
"""Consumes the manifest portion of the bundle, setting filestart so the """Consumes the manifest portion of the bundle, setting filestart so the
file portion can be read.""" file portion can be read."""
self._cgunpacker.seek(self.manstart) self._cgunpacker.seek(self.manstart)
self._cgunpacker.manifestheader() self._cgunpacker.manifestheader()
for delta in self._cgunpacker.deltaiter(): for delta in self._cgunpacker.deltaiter():
pass pass

mercurial/localrepo.py

def obsstore(self): def obsstore(self):
return obsolete.makestore(self.ui, self) return obsolete.makestore(self.ui, self)
@storecache('00changelog.i') @storecache('00changelog.i')
def changelog(self): def changelog(self):
return changelog.changelog(self.svfs, return changelog.changelog(self.svfs,
trypending=txnutil.mayhavepending(self.root)) trypending=txnutil.mayhavepending(self.root))
def _constructmanifest(self):
# This is a temporary function while we migrate from manifest to
# manifestlog. It allows bundlerepo and unionrepo to intercept the
# manifest creation.
return manifest.manifestrevlog(self.svfs)
@storecache('00manifest.i') @storecache('00manifest.i')
def manifestlog(self): def manifestlog(self):
return manifest.manifestlog(self.svfs, self) rootstore = manifest.manifestrevlog(self.svfs)
return manifest.manifestlog(self.svfs, self, rootstore)
@repofilecache('dirstate') @repofilecache('dirstate')
def dirstate(self): def dirstate(self):
return self._makedirstate() return self._makedirstate()
def _makedirstate(self): def _makedirstate(self):
"""Extension point for wrapping the dirstate per-repo.""" """Extension point for wrapping the dirstate per-repo."""
sparsematchfn = lambda: sparse.matcher(self) sparsematchfn = lambda: sparse.matcher(self)

mercurial/manifest.py

class manifestlog(object): class manifestlog(object):
"""A collection class representing the collection of manifest snapshots """A collection class representing the collection of manifest snapshots
referenced by commits in the repository. referenced by commits in the repository.
In this situation, 'manifest' refers to the abstract concept of a snapshot In this situation, 'manifest' refers to the abstract concept of a snapshot
of the list of files in the given commit. Consumers of the output of this of the list of files in the given commit. Consumers of the output of this
class do not care about the implementation details of the actual manifests class do not care about the implementation details of the actual manifests
they receive (i.e. tree or flat or lazily loaded, etc).""" they receive (i.e. tree or flat or lazily loaded, etc)."""
def __init__(self, opener, repo): def __init__(self, opener, repo, rootstore):
usetreemanifest = False usetreemanifest = False
cachesize = 4 cachesize = 4
opts = getattr(opener, 'options', None) opts = getattr(opener, 'options', None)
if opts is not None: if opts is not None:
usetreemanifest = opts.get('treemanifest', usetreemanifest) usetreemanifest = opts.get('treemanifest', usetreemanifest)
cachesize = opts.get('manifestcachesize', cachesize) cachesize = opts.get('manifestcachesize', cachesize)
self._treemanifests = usetreemanifest self._treemanifests = usetreemanifest
self._rootstore = repo._constructmanifest() self._rootstore = rootstore
self._rootstore._setupmanifestcachehooks(repo) self._rootstore._setupmanifestcachehooks(repo)
self._narrowmatch = repo.narrowmatch() self._narrowmatch = repo.narrowmatch()
# A cache of the manifestctx or treemanifestctx for each directory # A cache of the manifestctx or treemanifestctx for each directory
self._dirmancache = {} self._dirmancache = {}
self._dirmancache[''] = util.lrucachedict(cachesize) self._dirmancache[''] = util.lrucachedict(cachesize)
self._cachesize = cachesize self._cachesize = cachesize

mercurial/statichttprepo.py

# setup store # setup store
self.store = localrepo.makestore(requirements, self.path, vfsclass) self.store = localrepo.makestore(requirements, self.path, vfsclass)
self.spath = self.store.path self.spath = self.store.path
self.svfs = self.store.opener self.svfs = self.store.opener
self.sjoin = self.store.join self.sjoin = self.store.join
self._filecache = {} self._filecache = {}
self.requirements = requirements self.requirements = requirements
self.manifestlog = manifest.manifestlog(self.svfs, self) rootmanifest = manifest.manifestrevlog(self.svfs)
self.manifestlog = manifest.manifestlog(self.svfs, self, rootmanifest)
self.changelog = changelog.changelog(self.svfs) self.changelog = changelog.changelog(self.svfs)
self._tags = None self._tags = None
self.nodetagscache = None self.nodetagscache = None
self._branchcaches = {} self._branchcaches = {}
self._revbranchcache = None self._revbranchcache = None
self.encodepats = None self.encodepats = None
self.decodepats = None self.decodepats = None
self._transref = None self._transref = None

mercurial/unionrepo.py

self._url = url self._url = url
self.ui.setconfig('phases', 'publish', False, 'unionrepo') self.ui.setconfig('phases', 'publish', False, 'unionrepo')
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def changelog(self): def changelog(self):
return unionchangelog(self.svfs, self.repo2.svfs) return unionchangelog(self.svfs, self.repo2.svfs)
@localrepo.unfilteredpropertycache
def manifestlog(self):
rootstore = unionmanifest(self.svfs, self.repo2.svfs,
self.unfiltered()._clrev)
return manifest.manifestlog(self.svfs, self, rootstore)
def _clrev(self, rev2): def _clrev(self, rev2):
"""map from repo2 changelog rev to temporary rev in self.changelog""" """map from repo2 changelog rev to temporary rev in self.changelog"""
node = self.repo2.changelog.node(rev2) node = self.repo2.changelog.node(rev2)
return self.changelog.rev(node) return self.changelog.rev(node)
def _constructmanifest(self): def _constructmanifest(self):
return unionmanifest(self.svfs, self.repo2.svfs, return unionmanifest(self.svfs, self.repo2.svfs,
self.unfiltered()._clrev) self.unfiltered()._clrev)

tests/test-check-interfaces.py

ziverify.verifyClass(repository.imanifestlog, manifest.manifestlog) ziverify.verifyClass(repository.imanifestlog, manifest.manifestlog)
ziverify.verifyClass(repository.imanifeststorage, manifest.manifestrevlog) ziverify.verifyClass(repository.imanifeststorage, manifest.manifestrevlog)
vfs = vfsmod.vfs(b'.') vfs = vfsmod.vfs(b'.')
fl = filelog.filelog(vfs, b'dummy.i') fl = filelog.filelog(vfs, b'dummy.i')
checkzobject(fl, allowextra=True) checkzobject(fl, allowextra=True)
# Conforms to imanifestlog. # Conforms to imanifestlog.
ml = manifest.manifestlog(vfs, repo) ml = manifest.manifestlog(vfs, repo, manifest.manifestrevlog(repo.svfs))
checkzobject(ml) checkzobject(ml)
checkzobject(repo.manifestlog) checkzobject(repo.manifestlog)
# Conforms to imanifestrevision. # Conforms to imanifestrevision.
mctx = ml[repo[0].manifestnode()] mctx = ml[repo[0].manifestnode()]
checkzobject(mctx) checkzobject(mctx)
# Conforms to imanifestrevisionwritable. # Conforms to imanifestrevisionwritable.