This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4574

localrepo: move store() from store module
ClosedPublic

Authored by indygreg on Sep 13 2018, 12:29 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGf44187605315: localrepo: move store() from store module
Summary

I want logic related to requirements handling to be in the localrepo
module so it is all in one place.

I would have loved to inline this logic. Unfortunately, statichttprepo
also calls it. I didn't want to inline it twice. We could potentially
refactor statichttppeer. But meh.

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 13 2018, 12:29 PM
Closed by commit rHGf44187605315: localrepo: move store() from store module (authored by indygreg). · Explain WhySep 18 2018, 6:00 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11171

mercurial/localrepo.py

cachepath = sharedvfs.join(b'cache') cachepath = sharedvfs.join(b'cache')
else: else:
storebasepath = hgvfs.base storebasepath = hgvfs.base
cachepath = hgvfs.join(b'cache') cachepath = hgvfs.join(b'cache')
# The store has changed over time and the exact layout is dictated by # The store has changed over time and the exact layout is dictated by
# requirements. The store interface abstracts differences across all # requirements. The store interface abstracts differences across all
# of them. # of them.
store = storemod.store(requirements, storebasepath, store = makestore(requirements, storebasepath,
lambda base: vfsmod.vfs(base, cacheaudited=True)) lambda base: vfsmod.vfs(base, cacheaudited=True))
hgvfs.createmode = store.createmode hgvfs.createmode = store.createmode
# The cache vfs is used to manage cache files. # The cache vfs is used to manage cache files.
cachevfs = vfsmod.vfs(cachepath, cacheaudited=True) cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
cachevfs.createmode = store.createmode cachevfs.createmode = store.createmode
return localrepository( return localrepository(
``error.RepoError`` should be raised on failure. ``error.RepoError`` should be raised on failure.
""" """
if b'exp-sparse' in requirements and not sparse.enabled: if b'exp-sparse' in requirements and not sparse.enabled:
raise error.RepoError(_(b'repository is using sparse feature but ' raise error.RepoError(_(b'repository is using sparse feature but '
b'sparse is not enabled; enable the ' b'sparse is not enabled; enable the '
b'"sparse" extensions to access')) b'"sparse" extensions to access'))
def makestore(requirements, path, vfstype):
"""Construct a storage object for a repository."""
if b'store' in requirements:
if b'fncache' in requirements:
return storemod.fncachestore(path, vfstype,
b'dotencode' in requirements)
return storemod.encodedstore(path, vfstype)
return storemod.basicstore(path, vfstype)
@interfaceutil.implementer(repository.completelocalrepository) @interfaceutil.implementer(repository.completelocalrepository)
class localrepository(object): class localrepository(object):
# obsolete experimental requirements: # obsolete experimental requirements:
# - manifestv2: An experimental new manifest format that allowed # - manifestv2: An experimental new manifest format that allowed
# for stem compression of long paths. Experiment ended up not # for stem compression of long paths. Experiment ended up not
# being successful (repository sizes went up due to worse delta # being successful (repository sizes went up due to worse delta
# chains), and the code was deleted in 4.6. # chains), and the code was deleted in 4.6.

mercurial/statichttprepo.py

from .i18n import _ from .i18n import _
from . import ( from . import (
changelog, changelog,
error, error,
localrepo, localrepo,
manifest, manifest,
namespaces, namespaces,
pathutil, pathutil,
store,
url, url,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
raise error.RepoError(msg) raise error.RepoError(msg)
supportedrequirements = localrepo.gathersupportedrequirements(ui) supportedrequirements = localrepo.gathersupportedrequirements(ui)
localrepo.ensurerequirementsrecognized(requirements, localrepo.ensurerequirementsrecognized(requirements,
supportedrequirements) supportedrequirements)
localrepo.ensurerequirementscompatible(ui, requirements) localrepo.ensurerequirementscompatible(ui, requirements)
# setup store # setup store
self.store = store.store(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) self.manifestlog = manifest.manifestlog(self.svfs, self)
self.changelog = changelog.changelog(self.svfs) self.changelog = changelog.changelog(self.svfs)

mercurial/store.py

return True return True
# now check for directories (prefix match) # now check for directories (prefix match)
if not path.endswith('/'): if not path.endswith('/'):
path += '/' path += '/'
for e in self.fncache: for e in self.fncache:
if e.startswith(path) and self._exists(e): if e.startswith(path) and self._exists(e):
return True return True
return False return False
def store(requirements, path, vfstype):
if 'store' in requirements:
if 'fncache' in requirements:
return fncachestore(path, vfstype, 'dotencode' in requirements)
return encodedstore(path, vfstype)
return basicstore(path, vfstype)

tests/test-fncache.t

In repositories that have accumulated a large number of files over time, the In repositories that have accumulated a large number of files over time, the
fncache file is going to be large. If we possibly can avoid loading it, so much the better. fncache file is going to be large. If we possibly can avoid loading it, so much the better.
The cache should not loaded when committing changes to existing files, or when unbundling The cache should not loaded when committing changes to existing files, or when unbundling
changesets that only contain changes to existing files: changesets that only contain changes to existing files:
$ cat > fncacheloadwarn.py << EOF $ cat > fncacheloadwarn.py << EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import extensions, store > from mercurial import extensions, localrepo
> >
> def extsetup(ui): > def extsetup(ui):
> def wrapstore(orig, requirements, *args): > def wrapstore(orig, requirements, *args):
> store = orig(requirements, *args) > store = orig(requirements, *args)
> if 'store' in requirements and 'fncache' in requirements: > if 'store' in requirements and 'fncache' in requirements:
> instrumentfncachestore(store, ui) > instrumentfncachestore(store, ui)
> return store > return store
> extensions.wrapfunction(store, 'store', wrapstore) > extensions.wrapfunction(localrepo, 'makestore', wrapstore)
> >
> def instrumentfncachestore(fncachestore, ui): > def instrumentfncachestore(fncachestore, ui):
> class instrumentedfncache(type(fncachestore.fncache)): > class instrumentedfncache(type(fncachestore.fncache)):
> def _load(self): > def _load(self):
> ui.warn('fncache load triggered!\n') > ui.warn('fncache load triggered!\n')
> super(instrumentedfncache, self)._load() > super(instrumentedfncache, self)._load()
> fncachestore.fncache.__class__ = instrumentedfncache > fncachestore.fncache.__class__ = instrumentedfncache
> EOF > EOF