This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4573

localrepo: resolve store and cachevfs in makelocalrepository()
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG98ca9078807a: localrepo: resolve store and cachevfs in makelocalrepository()
Summary

This is mostly a code move and refactor.

One change is that we now explicitly look for requirements indicating
a share is being used rather than blindly try to read from
.hg/sharedpath. Requirements *should* be all that is necessary to
dictate high-level behavior and I'm not sure why the previous code
was doing what it was.

The previous code has been in place since 87d1fd40f57e (authored in
2009). And the commit immediately after that (971e38a9344b) introduced
`hg.share() and always wrote the shared` requirement. And as far
as I can tell, every revision of `hg.share()` since has written
either the `shared or relshared` requirement. So I'm pretty
sure we don't need to maintain BC by always looking for and honoring
the `.hg/sharedpath` file even if a requirement isn't present.

.. bc::

A repository will no longer use shared storage if it has a
``.hg/sharedpath`` file but no entry in ``.hg/requires`` saying it
is shared.

This change should not have any end-user impact, as all shared
repos should have a ``.hg/requires`` file indicating this.

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 rHG98ca9078807a: localrepo: resolve store and cachevfs in makelocalrepository() (authored by indygreg). · Explain WhySep 18 2018, 6:00 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/localrepo.py (83 lines)

Diff 11172

mercurial/localrepo.py

pushkey, pushkey,
pycompat, pycompat,
repository, repository,
repoview, repoview,
revset, revset,
revsetlang, revsetlang,
scmutil, scmutil,
sparse, sparse,
store, store as storemod,
subrepoutil, subrepoutil,
tags as tagsmod, tags as tagsmod,
transaction, transaction,
txnutil, txnutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import ( from .utils import (
# file when sharing repos. But if a requirement is added after the share is # file when sharing repos. But if a requirement is added after the share is
# performed, thereby introducing a new requirement for the opener, we may # performed, thereby introducing a new requirement for the opener, we may
# will not see that and could encounter a run-time error interacting with # will not see that and could encounter a run-time error interacting with
# that shared store since it has an unknown-to-us requirement. # that shared store since it has an unknown-to-us requirement.
# At this point, we know we should be capable of opening the repository. # At this point, we know we should be capable of opening the repository.
# Now get on with doing that. # Now get on with doing that.
# The "store" part of the repository holds versioned data. How it is
# accessed is determined by various requirements. The ``shared`` or
# ``relshared`` requirements indicate the store lives in the path contained
# in the ``.hg/sharedpath`` file. This is an absolute path for
# ``shared`` and relative to ``.hg/`` for ``relshared``.
if b'shared' in requirements or b'relshared' in requirements:
sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
if b'relshared' in requirements:
sharedpath = hgvfs.join(sharedpath)
sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
if not sharedvfs.exists():
raise error.RepoError(_(b'.hg/sharedpath points to nonexistent '
b'directory %s') % sharedvfs.base)
storebasepath = sharedvfs.base
cachepath = sharedvfs.join(b'cache')
else:
storebasepath = hgvfs.base
cachepath = hgvfs.join(b'cache')
# The store has changed over time and the exact layout is dictated by
# requirements. The store interface abstracts differences across all
# of them.
store = storemod.store(requirements, storebasepath,
lambda base: vfsmod.vfs(base, cacheaudited=True))
hgvfs.createmode = store.createmode
# The cache vfs is used to manage cache files.
cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
cachevfs.createmode = store.createmode
return localrepository( return localrepository(
baseui=baseui, baseui=baseui,
ui=ui, ui=ui,
origroot=path, origroot=path,
wdirvfs=wdirvfs, wdirvfs=wdirvfs,
hgvfs=hgvfs, hgvfs=hgvfs,
requirements=requirements, requirements=requirements,
supportedrequirements=supportedrequirements, supportedrequirements=supportedrequirements,
sharedpath=storebasepath,
store=store,
cachevfs=cachevfs,
intents=intents) intents=intents)
def gathersupportedrequirements(ui): def gathersupportedrequirements(ui):
"""Determine the complete set of recognized requirements.""" """Determine the complete set of recognized requirements."""
# Start with all requirements supported by this file. # Start with all requirements supported by this file.
supported = set(localrepository._basesupported) supported = set(localrepository._basesupported)
# Execute ``featuresetupfuncs`` entries if they belong to an extension # Execute ``featuresetupfuncs`` entries if they belong to an extension
'dirstate', 'dirstate',
# XXX bisect was still a bit too messy at the time # XXX bisect was still a bit too messy at the time
# this changeset was introduced. Someone should fix # this changeset was introduced. Someone should fix
# the remainig bit and drop this line # the remainig bit and drop this line
'bisect.state', 'bisect.state',
} }
def __init__(self, baseui, ui, origroot, wdirvfs, hgvfs, requirements, def __init__(self, baseui, ui, origroot, wdirvfs, hgvfs, requirements,
supportedrequirements, intents=None): supportedrequirements, sharedpath, store, cachevfs,
intents=None):
"""Create a new local repository instance. """Create a new local repository instance.
Most callers should use ``hg.repository()``, ``localrepo.instance()``, Most callers should use ``hg.repository()``, ``localrepo.instance()``,
or ``localrepo.makelocalrepository()`` for obtaining a new repository or ``localrepo.makelocalrepository()`` for obtaining a new repository
object. object.
Arguments: Arguments:
requirements requirements
``set`` of bytestrings representing repository opening requirements. ``set`` of bytestrings representing repository opening requirements.
supportedrequirements supportedrequirements
``set`` of bytestrings representing repository requirements that we ``set`` of bytestrings representing repository requirements that we
know how to open. May be a supetset of ``requirements``. know how to open. May be a supetset of ``requirements``.
sharedpath
``bytes`` Defining path to storage base directory. Points to a
``.hg/`` directory somewhere.
store
``store.basicstore`` (or derived) instance providing access to
versioned storage.
cachevfs
``vfs.vfs`` used for cache files.
intents intents
``set`` of system strings indicating what this repo will be used ``set`` of system strings indicating what this repo will be used
for. for.
""" """
self.baseui = baseui self.baseui = baseui
self.ui = ui self.ui = ui
self.origroot = origroot self.origroot = origroot
# vfs rooted at working directory. # vfs rooted at working directory.
self.wvfs = wdirvfs self.wvfs = wdirvfs
self.root = wdirvfs.base self.root = wdirvfs.base
# vfs rooted at .hg/. Used to access most non-store paths. # vfs rooted at .hg/. Used to access most non-store paths.
self.vfs = hgvfs self.vfs = hgvfs
self.path = hgvfs.base self.path = hgvfs.base
self.requirements = requirements self.requirements = requirements
self.supported = supportedrequirements self.supported = supportedrequirements
self.sharedpath = sharedpath
self.store = store
self.cachevfs = cachevfs
self.filtername = None self.filtername = None
# svfs: usually rooted at .hg/store, used to access repository history
# If this is a shared repository, this vfs may point to another
# repository's .hg/store directory.
self.svfs = None
if (self.ui.configbool('devel', 'all-warnings') or if (self.ui.configbool('devel', 'all-warnings') or
self.ui.configbool('devel', 'check-locks')): self.ui.configbool('devel', 'check-locks')):
self.vfs.audit = self._getvfsward(self.vfs.audit) self.vfs.audit = self._getvfsward(self.vfs.audit)
# A list of callback to shape the phase if no data were found. # A list of callback to shape the phase if no data were found.
# Callback are in the form: func(repo, roots) --> processed root. # Callback are in the form: func(repo, roots) --> processed root.
# This list it to be filled by extension during repo setup # This list it to be filled by extension during repo setup
self._phasedefaults = [] self._phasedefaults = []
color.setup(self.ui) color.setup(self.ui)
cachepath = self.vfs.join('cache')
self.sharedpath = self.path
try:
sharedpath = self.vfs.read("sharedpath").rstrip('\n')
if 'relshared' in self.requirements:
sharedpath = self.vfs.join(sharedpath)
vfs = vfsmod.vfs(sharedpath, realpath=True)
cachepath = vfs.join('cache')
s = vfs.base
if not vfs.exists():
raise error.RepoError(
_('.hg/sharedpath points to nonexistent directory %s') % s)
self.sharedpath = s
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
self.store = store.store(
self.requirements, self.sharedpath,
lambda base: vfsmod.vfs(base, cacheaudited=True))
self.spath = self.store.path self.spath = self.store.path
self.svfs = self.store.vfs self.svfs = self.store.vfs
self.sjoin = self.store.join self.sjoin = self.store.join
self.vfs.createmode = self.store.createmode
self.cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
self.cachevfs.createmode = self.store.createmode
if (self.ui.configbool('devel', 'all-warnings') or if (self.ui.configbool('devel', 'all-warnings') or
self.ui.configbool('devel', 'check-locks')): self.ui.configbool('devel', 'check-locks')):
if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit) self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
else: # standard vfs else: # standard vfs
self.svfs.audit = self._getsvfsward(self.svfs.audit) self.svfs.audit = self._getsvfsward(self.svfs.audit)
self._applyopenerreqs() self._applyopenerreqs()