This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4709

localrepo: define "features" on repository instances (API)
ClosedPublic

Authored by indygreg on Sep 24 2018, 12:12 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd89d5bc06eaa: localrepo: define "features" on repository instances (API)
Summary

There are a handful of attributes/methods on repository instances that
describe the behavior of the repository. Furthermore, there is
an unbound set of repository descriptors that we may wish to expose.
For example, an extension may wish to add a descriptor and have
monkeypatched functions look for the presence of an attribute before
taking actions.

This commit introduces a "features" mechanism to allow repositories
to self-advertise an arbitrary set of strings that describe repository
behavior or capabilities.

We implement basic support for advertising a few features to give an
idea of what I want to use this for.

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 24 2018, 12:12 PM
Closed by commit rHGd89d5bc06eaa: localrepo: define "features" on repository instances (API) (authored by indygreg). · Explain WhySep 26 2018, 1:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11380

mercurial/bundle2.py

if ('treemanifest' in inpart.params and if ('treemanifest' in inpart.params and
'treemanifest' not in op.repo.requirements): 'treemanifest' not in op.repo.requirements):
if len(op.repo.changelog) != 0: if len(op.repo.changelog) != 0:
raise error.Abort(_( raise error.Abort(_(
"bundle contains tree manifests, but local repo is " "bundle contains tree manifests, but local repo is "
"non-empty and does not use tree manifests")) "non-empty and does not use tree manifests"))
op.repo.requirements.add('treemanifest') op.repo.requirements.add('treemanifest')
op.repo.svfs.options = localrepo.resolvestorevfsoptions( op.repo.svfs.options = localrepo.resolvestorevfsoptions(
op.repo.ui, op.repo.requirements) op.repo.ui, op.repo.requirements, op.repo.features)
op.repo._writerequirements() op.repo._writerequirements()
extrakwargs = {} extrakwargs = {}
targetphase = inpart.params.get('targetphase') targetphase = inpart.params.get('targetphase')
if targetphase is not None: if targetphase is not None:
extrakwargs[r'targetphase'] = int(targetphase) extrakwargs[r'targetphase'] = int(targetphase)
ret = _processchangegroup(op, cg, tr, 'bundle2', 'bundle2', ret = _processchangegroup(op, cg, tr, 'bundle2', 'bundle2',
expectedtotal=nbchangesets, **extrakwargs) expectedtotal=nbchangesets, **extrakwargs)
if op.reply is not None: if op.reply is not None:

mercurial/localrepo.py

# 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.
features = set()
# The "store" part of the repository holds versioned data. How it is # The "store" part of the repository holds versioned data. How it is
# accessed is determined by various requirements. The ``shared`` or # accessed is determined by various requirements. The ``shared`` or
# ``relshared`` requirements indicate the store lives in the path contained # ``relshared`` requirements indicate the store lives in the path contained
# in the ``.hg/sharedpath`` file. This is an absolute path for # in the ``.hg/sharedpath`` file. This is an absolute path for
# ``shared`` and relative to ``.hg/`` for ``relshared``. # ``shared`` and relative to ``.hg/`` for ``relshared``.
if b'shared' in requirements or b'relshared' in requirements: if b'shared' in requirements or b'relshared' in requirements:
sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n') sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
if b'relshared' in requirements: if b'relshared' in requirements:
sharedpath = hgvfs.join(sharedpath) sharedpath = hgvfs.join(sharedpath)
sharedvfs = vfsmod.vfs(sharedpath, realpath=True) sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
if not sharedvfs.exists(): if not sharedvfs.exists():
raise error.RepoError(_(b'.hg/sharedpath points to nonexistent ' raise error.RepoError(_(b'.hg/sharedpath points to nonexistent '
b'directory %s') % sharedvfs.base) b'directory %s') % sharedvfs.base)
features.add(repository.REPO_FEATURE_SHARED_STORAGE)
storebasepath = sharedvfs.base storebasepath = sharedvfs.base
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 = makestore(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
storevfs = store.vfs storevfs = store.vfs
storevfs.options = resolvestorevfsoptions(ui, requirements) storevfs.options = resolvestorevfsoptions(ui, requirements, features)
# 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
# Now resolve the type for the repository object. We do this by repeatedly # Now resolve the type for the repository object. We do this by repeatedly
# calling a factory function to produces types for specific aspects of the # calling a factory function to produces types for specific aspects of the
# repo's operation. The aggregate returned types are used as base classes # repo's operation. The aggregate returned types are used as base classes
# for a dynamically-derived type, which will represent our new repository. # for a dynamically-derived type, which will represent our new repository.
bases = [] bases = []
extrastate = {} extrastate = {}
for iface, fn in REPO_INTERFACES: for iface, fn in REPO_INTERFACES:
# We pass all potentially useful state to give extensions tons of # We pass all potentially useful state to give extensions tons of
# flexibility. # flexibility.
typ = fn(ui=ui, typ = fn(ui=ui,
intents=intents, intents=intents,
requirements=requirements, requirements=requirements,
features=features,
wdirvfs=wdirvfs, wdirvfs=wdirvfs,
hgvfs=hgvfs, hgvfs=hgvfs,
store=store, store=store,
storevfs=storevfs, storevfs=storevfs,
storeoptions=storevfs.options, storeoptions=storevfs.options,
cachevfs=cachevfs, cachevfs=cachevfs,
extensionmodulenames=extensionmodulenames, extensionmodulenames=extensionmodulenames,
extrastate=extrastate, extrastate=extrastate,
origroot=path, origroot=path,
wdirvfs=wdirvfs, wdirvfs=wdirvfs,
hgvfs=hgvfs, hgvfs=hgvfs,
requirements=requirements, requirements=requirements,
supportedrequirements=supportedrequirements, supportedrequirements=supportedrequirements,
sharedpath=storebasepath, sharedpath=storebasepath,
store=store, store=store,
cachevfs=cachevfs, cachevfs=cachevfs,
features=features,
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
if b'fncache' in requirements: if b'fncache' in requirements:
return storemod.fncachestore(path, vfstype, return storemod.fncachestore(path, vfstype,
b'dotencode' in requirements) b'dotencode' in requirements)
return storemod.encodedstore(path, vfstype) return storemod.encodedstore(path, vfstype)
return storemod.basicstore(path, vfstype) return storemod.basicstore(path, vfstype)
def resolvestorevfsoptions(ui, requirements): def resolvestorevfsoptions(ui, requirements, features):
"""Resolve the options to pass to the store vfs opener. """Resolve the options to pass to the store vfs opener.
The returned dict is used to influence behavior of the storage layer. The returned dict is used to influence behavior of the storage layer.
""" """
options = {} options = {}
if b'treemanifest' in requirements: if b'treemanifest' in requirements:
options[b'treemanifest'] = True options[b'treemanifest'] = True
# experimental config: format.manifestcachesize # experimental config: format.manifestcachesize
manifestcachesize = ui.configint(b'format', b'manifestcachesize') manifestcachesize = ui.configint(b'format', b'manifestcachesize')
if manifestcachesize is not None: if manifestcachesize is not None:
options[b'manifestcachesize'] = manifestcachesize options[b'manifestcachesize'] = manifestcachesize
# In the absence of another requirement superseding a revlog-related # In the absence of another requirement superseding a revlog-related
# requirement, we have to assume the repo is using revlog version 0. # requirement, we have to assume the repo is using revlog version 0.
# This revlog format is super old and we don't bother trying to parse # This revlog format is super old and we don't bother trying to parse
# opener options for it because those options wouldn't do anything # opener options for it because those options wouldn't do anything
# meaningful on such old repos. # meaningful on such old repos.
if b'revlogv1' in requirements or REVLOGV2_REQUIREMENT in requirements: if b'revlogv1' in requirements or REVLOGV2_REQUIREMENT in requirements:
options.update(resolverevlogstorevfsoptions(ui, requirements)) options.update(resolverevlogstorevfsoptions(ui, requirements, features))
return options return options
def resolverevlogstorevfsoptions(ui, requirements): def resolverevlogstorevfsoptions(ui, requirements, features):
"""Resolve opener options specific to revlogs.""" """Resolve opener options specific to revlogs."""
options = {} options = {}
if b'revlogv1' in requirements: if b'revlogv1' in requirements:
options[b'revlogv1'] = True options[b'revlogv1'] = True
if REVLOGV2_REQUIREMENT in requirements: if REVLOGV2_REQUIREMENT in requirements:
options[b'revlogv2'] = True options[b'revlogv2'] = True
"""File storage when using revlogs and narrow files.""" """File storage when using revlogs and narrow files."""
def file(self, path): def file(self, path):
if path[0] == b'/': if path[0] == b'/':
path = path[1:] path = path[1:]
return filelog.narrowfilelog(self.svfs, path, self.narrowmatch()) return filelog.narrowfilelog(self.svfs, path, self.narrowmatch())
def makefilestorage(requirements, **kwargs): def makefilestorage(requirements, features, **kwargs):
"""Produce a type conforming to ``ilocalrepositoryfilestorage``.""" """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
if repository.NARROW_REQUIREMENT in requirements: if repository.NARROW_REQUIREMENT in requirements:
return revlognarrowfilestorage return revlognarrowfilestorage
else: else:
return revlogfilestorage return revlogfilestorage
# List of repository interfaces and factory functions for them. Each # List of repository interfaces and factory functions for them. Each
# will be called in order during ``makelocalrepository()`` to iteratively # will be called in order during ``makelocalrepository()`` to iteratively
# derive the final type for a local repository instance. # derive the final type for a local repository instance.
# 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, sharedpath, store, cachevfs, supportedrequirements, sharedpath, store, cachevfs,
intents=None): features, 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:
store store
``store.basicstore`` (or derived) instance providing access to ``store.basicstore`` (or derived) instance providing access to
versioned storage. versioned storage.
cachevfs cachevfs
``vfs.vfs`` used for cache files. ``vfs.vfs`` used for cache files.
features
``set`` of bytestrings defining features/capabilities of this
instance.
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.sharedpath = sharedpath
self.store = store self.store = store
self.cachevfs = cachevfs self.cachevfs = cachevfs
self.features = features
self.filtername = None self.filtername = 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.

mercurial/repository.py

from .utils import ( from .utils import (
interfaceutil, interfaceutil,
) )
# When narrowing is finalized and no longer subject to format changes, # When narrowing is finalized and no longer subject to format changes,
# we should move this to just "narrow" or similar. # we should move this to just "narrow" or similar.
NARROW_REQUIREMENT = 'narrowhg-experimental' NARROW_REQUIREMENT = 'narrowhg-experimental'
# Local repository feature string.
# Revlogs are being used for file storage.
REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage'
# The storage part of the repository is shared from an external source.
REPO_FEATURE_SHARED_STORAGE = b'sharedstore'
class ipeerconnection(interfaceutil.Interface): class ipeerconnection(interfaceutil.Interface):
"""Represents a "connection" to a repository. """Represents a "connection" to a repository.
This is the base interface for representing a connection to a repository. This is the base interface for representing a connection to a repository.
It holds basic properties and methods applicable to all peer types. It holds basic properties and methods applicable to all peer types.
This is not a complete interface definition and should not be used This is not a complete interface definition and should not be used
outside of this module. outside of this module.
""") """)
supported = interfaceutil.Attribute( supported = interfaceutil.Attribute(
"""Set of requirements that this repo is capable of opening.""") """Set of requirements that this repo is capable of opening.""")
requirements = interfaceutil.Attribute( requirements = interfaceutil.Attribute(
"""Set of requirements this repo uses.""") """Set of requirements this repo uses.""")
features = interfaceutil.Attribute(
"""Set of "features" this repository supports.
A "feature" is a loosely-defined term. It can refer to a feature
in the classical sense or can describe an implementation detail
of the repository. For example, a ``readonly`` feature may denote
the repository as read-only. Or a ``revlogfilestore`` feature may
denote that the repository is using revlogs for file storage.
The intent of features is to provide a machine-queryable mechanism
for repo consumers to test for various repository characteristics.
Features are similar to ``requirements``. The main difference is that
requirements are stored on-disk and represent requirements to open the
repository. Features are more run-time capabilities of the repository
and more granular capabilities (which may be derived from requirements).
""")
filtername = interfaceutil.Attribute( filtername = interfaceutil.Attribute(
"""Name of the repoview that is active on this repo.""") """Name of the repoview that is active on this repo.""")
wvfs = interfaceutil.Attribute( wvfs = interfaceutil.Attribute(
"""VFS used to access the working directory.""") """VFS used to access the working directory.""")
vfs = interfaceutil.Attribute( vfs = interfaceutil.Attribute(
"""VFS rooted at the .hg directory. """VFS rooted at the .hg directory.

mercurial/streamclone.py

consumev1(repo, fp, filecount, bytecount) consumev1(repo, fp, filecount, bytecount)
# new requirements = old non-format requirements + # new requirements = old non-format requirements +
# new format-related remote requirements # new format-related remote requirements
# requirements from the streamed-in repository # requirements from the streamed-in repository
repo.requirements = requirements | ( repo.requirements = requirements | (
repo.requirements - repo.supportedformats) repo.requirements - repo.supportedformats)
repo.svfs.options = localrepo.resolvestorevfsoptions( repo.svfs.options = localrepo.resolvestorevfsoptions(
repo.ui, repo.requirements) repo.ui, repo.requirements, repo.features)
repo._writerequirements() repo._writerequirements()
if rbranchmap: if rbranchmap:
branchmap.replacecache(repo, rbranchmap) branchmap.replacecache(repo, rbranchmap)
repo.invalidate() repo.invalidate()
def allowservergeneration(repo): def allowservergeneration(repo):
consumev2(repo, fp, filecount, filesize) consumev2(repo, fp, filecount, filesize)
# new requirements = old non-format requirements + # new requirements = old non-format requirements +
# new format-related remote requirements # new format-related remote requirements
# requirements from the streamed-in repository # requirements from the streamed-in repository
repo.requirements = set(requirements) | ( repo.requirements = set(requirements) | (
repo.requirements - repo.supportedformats) repo.requirements - repo.supportedformats)
repo.svfs.options = localrepo.resolvestorevfsoptions( repo.svfs.options = localrepo.resolvestorevfsoptions(
repo.ui, repo.requirements) repo.ui, repo.requirements, repo.features)
repo._writerequirements() repo._writerequirements()