This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4791

localrepo: define storage backend in creation options (API)
ClosedPublic

Authored by indygreg on Sep 28 2018, 8:18 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGdbcb466d0065: localrepo: define storage backend in creation options (API)
Summary

We add an experimental config option to define the storage backend
for new repositories. By default, it uses "revlogv1," which maps to
the current and only modern supported repository format.

We add a "backend" creation option to control which backend to
use. It defaults to using the value from the config option.

newreporequirements() will now barf if it sees a "backend" value
that isn't "revlogv1." This forces extensions to monkeypatch the
function to handle requirements derivation for custom backends.

In order for this to "just work," we factored out obtaining the
default creation options into its own function and made callers
of newreporequirements() responsible for passing in valid data.
Without this, direct callers of newreporequirements() wouldn't
get the proper results.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Sep 28 2018, 8:18 PM
Closed by commit rHGdbcb466d0065: localrepo: define storage backend in creation options (API) (authored by indygreg). · Explain WhyOct 3 2018, 11:04 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/configitems.py (3 lines)
Mmercurial/localrepo.py (31 lines)
Mmercurial/upgrade.py (6 lines)

Diff 11474

mercurial/configitems.py

default=0.1, default=0.1,
) )
coreconfigitem('progress', 'width', coreconfigitem('progress', 'width',
default=dynamicdefault, default=dynamicdefault,
) )
coreconfigitem('push', 'pushvars.server', coreconfigitem('push', 'pushvars.server',
default=False, default=False,
) )
coreconfigitem('storage', 'new-repo-backend',
default='revlogv1',
)
coreconfigitem('storage', 'revlog.optimize-delta-parent-choice', coreconfigitem('storage', 'revlog.optimize-delta-parent-choice',
default=True, default=True,
alias=[('format', 'aggressivemergedeltas')], alias=[('format', 'aggressivemergedeltas')],
) )
coreconfigitem('server', 'bookmarks-pushkey-compat', coreconfigitem('server', 'bookmarks-pushkey-compat',
default=True, default=True,
) )
coreconfigitem('server', 'bundle1', coreconfigitem('server', 'bundle1',

mercurial/localrepo.py

if create: if create:
createrepository(ui, localpath, createopts=createopts) createrepository(ui, localpath, createopts=createopts)
return makelocalrepository(ui, localpath, intents=intents) return makelocalrepository(ui, localpath, intents=intents)
def islocal(path): def islocal(path):
return True return True
def newreporequirements(ui, createopts=None): def defaultcreateopts(ui, createopts=None):
"""Populate the default creation options for a repository.
A dictionary of explicitly requested creation options can be passed
in. Missing keys will be populated.
"""
createopts = dict(createopts or {})
if 'backend' not in createopts:
# experimental config: storage.new-repo-backend
createopts['backend'] = ui.config('storage', 'new-repo-backend')
return createopts
def newreporequirements(ui, createopts):
"""Determine the set of requirements for a new local repository. """Determine the set of requirements for a new local repository.
Extensions can wrap this function to specify custom requirements for Extensions can wrap this function to specify custom requirements for
new repositories. new repositories.
""" """
createopts = createopts or {}
# If the repo is being created from a shared repository, we copy # If the repo is being created from a shared repository, we copy
# its requirements. # its requirements.
if 'sharedrepo' in createopts: if 'sharedrepo' in createopts:
requirements = set(createopts['sharedrepo'].requirements) requirements = set(createopts['sharedrepo'].requirements)
if createopts.get('sharedrelative'): if createopts.get('sharedrelative'):
requirements.add('relshared') requirements.add('relshared')
else: else:
requirements.add('shared') requirements.add('shared')
return requirements return requirements
if 'backend' not in createopts:
raise error.ProgrammingError('backend key not present in createopts; '
'was defaultcreateopts() called?')
if createopts['backend'] != 'revlogv1':
raise error.Abort(_('unable to determine repository requirements for '
'storage backend: %s') % createopts['backend'])
requirements = {'revlogv1'} requirements = {'revlogv1'}
if ui.configbool('format', 'usestore'): if ui.configbool('format', 'usestore'):
requirements.add('store') requirements.add('store')
if ui.configbool('format', 'usefncache'): if ui.configbool('format', 'usefncache'):
requirements.add('fncache') requirements.add('fncache')
if ui.configbool('format', 'dotencode'): if ui.configbool('format', 'dotencode'):
requirements.add('dotencode') requirements.add('dotencode')
returned dict contains any items, repository creation will not returned dict contains any items, repository creation will not
be allowed, as it means there was a request to create a repository be allowed, as it means there was a request to create a repository
with options not recognized by loaded code. with options not recognized by loaded code.
Extensions can wrap this function to filter out creation options Extensions can wrap this function to filter out creation options
they know how to handle. they know how to handle.
""" """
known = { known = {
'backend',
'narrowfiles', 'narrowfiles',
'sharedrepo', 'sharedrepo',
'sharedrelative', 'sharedrelative',
'shareditems', 'shareditems',
} }
return {k: v for k, v in createopts.items() if k not in known} return {k: v for k, v in createopts.items() if k not in known}
def createrepository(ui, path, createopts=None): def createrepository(ui, path, createopts=None):
"""Create a new repository in a vfs. """Create a new repository in a vfs.
``path`` path to the new repo's working directory. ``path`` path to the new repo's working directory.
``createopts`` options for the new repository. ``createopts`` options for the new repository.
The following keys for ``createopts`` are recognized: The following keys for ``createopts`` are recognized:
backend
The storage backend to use.
narrowfiles narrowfiles
Set up repository to support narrow file storage. Set up repository to support narrow file storage.
sharedrepo sharedrepo
Repository object from which storage should be shared. Repository object from which storage should be shared.
sharedrelative sharedrelative
Boolean indicating if the path to the shared repo should be Boolean indicating if the path to the shared repo should be
stored as relative. By default, the pointer to the "parent" repo stored as relative. By default, the pointer to the "parent" repo
is stored as an absolute path. is stored as an absolute path.
shareditems shareditems
Set of items to share to the new repository (in addition to storage). Set of items to share to the new repository (in addition to storage).
""" """
createopts = createopts or {} createopts = defaultcreateopts(ui, createopts=createopts)
unknownopts = filterknowncreateopts(ui, createopts) unknownopts = filterknowncreateopts(ui, createopts)
if not isinstance(unknownopts, dict): if not isinstance(unknownopts, dict):
raise error.ProgrammingError('filterknowncreateopts() did not return ' raise error.ProgrammingError('filterknowncreateopts() did not return '
'a dict') 'a dict')
if unknownopts: if unknownopts:

mercurial/upgrade.py

subclass to factor the code. subclass to factor the code.
""" """
# the requirement that control this format variant # the requirement that control this format variant
_requirement = None _requirement = None
@staticmethod @staticmethod
def _newreporequirements(ui): def _newreporequirements(ui):
return localrepo.newreporequirements(ui) return localrepo.newreporequirements(
ui, localrepo.defaultcreateopts(ui))
@classmethod @classmethod
def fromrepo(cls, repo): def fromrepo(cls, repo):
assert cls._requirement is not None assert cls._requirement is not None
return cls._requirement in repo.requirements return cls._requirement in repo.requirements
@classmethod @classmethod
def fromconfig(cls, repo): def fromconfig(cls, repo):
blockedreqs = blocksourcerequirements(repo) & repo.requirements blockedreqs = blocksourcerequirements(repo) & repo.requirements
if blockedreqs: if blockedreqs:
raise error.Abort(_('cannot upgrade repository; unsupported source ' raise error.Abort(_('cannot upgrade repository; unsupported source '
'requirement: %s') % 'requirement: %s') %
_(', ').join(sorted(blockedreqs))) _(', ').join(sorted(blockedreqs)))
# FUTURE there is potentially a need to control the wanted requirements via # FUTURE there is potentially a need to control the wanted requirements via
# command arguments or via an extension hook point. # command arguments or via an extension hook point.
newreqs = localrepo.newreporequirements(repo.ui) newreqs = localrepo.newreporequirements(
repo.ui, localrepo.defaultcreateopts(repo.ui))
newreqs.update(preservedrequirements(repo)) newreqs.update(preservedrequirements(repo))
noremovereqs = (repo.requirements - newreqs - noremovereqs = (repo.requirements - newreqs -
supportremovedrequirements(repo)) supportremovedrequirements(repo))
if noremovereqs: if noremovereqs:
raise error.Abort(_('cannot upgrade repository; requirement would be ' raise error.Abort(_('cannot upgrade repository; requirement would be '
'removed: %s') % _(', ').join(sorted(noremovereqs))) 'removed: %s') % _(', ').join(sorted(noremovereqs)))