This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10108

requirements: also add a store constant
ClosedPublic

Authored by Alphare on Mar 4 2021, 3:32 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGab58098bebed: requirements: also add a store constant
Summary

Continue the cleanup to the remaining requirements

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

Alphare created this revision.Mar 4 2021, 3:32 AM
pulkit accepted this revision.Mar 4 2021, 4:02 AM
This revision is now accepted and ready to land.Mar 4 2021, 4:02 AM
Alphare updated this revision to Diff 26082.Mar 4 2021, 10:11 AM
Alphare added a commit: rHGab58098bebed: requirements: also add a store constant.Mar 5 2021, 4:34 AM
Closed by commit rHGab58098bebed: requirements: also add a store constant (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26103

mercurial/localrepo.py

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): def makestore(requirements, path, vfstype):
"""Construct a storage object for a repository.""" """Construct a storage object for a repository."""
if b'store' in requirements: if requirementsmod.STORE_REQUIREMENT in requirements:
if b'fncache' in requirements: if b'fncache' in requirements:
dotencode = requirementsmod.DOTENCODE_REQUIREMENT in requirements dotencode = requirementsmod.DOTENCODE_REQUIREMENT in requirements
return storemod.fncachestore(path, vfstype, dotencode) return storemod.fncachestore(path, vfstype, dotencode)
return storemod.encodedstore(path, vfstype) return storemod.encodedstore(path, vfstype)
return storemod.basicstore(path, vfstype) return storemod.basicstore(path, vfstype)
requirementsmod.REVLOGV2_REQUIREMENT, requirementsmod.REVLOGV2_REQUIREMENT,
requirementsmod.SIDEDATA_REQUIREMENT, requirementsmod.SIDEDATA_REQUIREMENT,
requirementsmod.SPARSEREVLOG_REQUIREMENT, requirementsmod.SPARSEREVLOG_REQUIREMENT,
requirementsmod.NODEMAP_REQUIREMENT, requirementsmod.NODEMAP_REQUIREMENT,
bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT, bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT,
requirementsmod.SHARESAFE_REQUIREMENT, requirementsmod.SHARESAFE_REQUIREMENT,
} }
_basesupported = supportedformats | { _basesupported = supportedformats | {
b'store', requirementsmod.STORE_REQUIREMENT,
b'fncache', b'fncache',
requirementsmod.SHARED_REQUIREMENT, requirementsmod.SHARED_REQUIREMENT,
requirementsmod.RELATIVE_SHARED_REQUIREMENT, requirementsmod.RELATIVE_SHARED_REQUIREMENT,
requirementsmod.DOTENCODE_REQUIREMENT, requirementsmod.DOTENCODE_REQUIREMENT,
requirementsmod.SPARSE_REQUIREMENT, requirementsmod.SPARSE_REQUIREMENT,
requirementsmod.INTERNAL_PHASE_REQUIREMENT, requirementsmod.INTERNAL_PHASE_REQUIREMENT,
} }
b'unable to determine repository requirements for ' b'unable to determine repository requirements for '
b'storage backend: %s' b'storage backend: %s'
) )
% createopts[b'backend'] % createopts[b'backend']
) )
requirements = {requirementsmod.REVLOGV1_REQUIREMENT} requirements = {requirementsmod.REVLOGV1_REQUIREMENT}
if ui.configbool(b'format', b'usestore'): if ui.configbool(b'format', b'usestore'):
requirements.add(b'store') requirements.add(requirementsmod.STORE_REQUIREMENT)
if ui.configbool(b'format', b'usefncache'): if ui.configbool(b'format', b'usefncache'):
requirements.add(b'fncache') requirements.add(b'fncache')
if ui.configbool(b'format', b'dotencode'): if ui.configbool(b'format', b'dotencode'):
requirements.add(requirementsmod.DOTENCODE_REQUIREMENT) requirements.add(requirementsmod.DOTENCODE_REQUIREMENT)
compengines = ui.configlist(b'format', b'revlog-compression') compengines = ui.configlist(b'format', b'revlog-compression')
for compengine in compengines: for compengine in compengines:
if compengine in util.compengines: if compengine in util.compengines:
def checkrequirementscompat(ui, requirements): def checkrequirementscompat(ui, requirements):
"""Checks compatibility of repository requirements enabled and disabled. """Checks compatibility of repository requirements enabled and disabled.
Returns a set of requirements which needs to be dropped because dependend Returns a set of requirements which needs to be dropped because dependend
requirements are not enabled. Also warns users about it""" requirements are not enabled. Also warns users about it"""
dropped = set() dropped = set()
if b'store' not in requirements: if requirementsmod.STORE_REQUIREMENT not in requirements:
if bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT in requirements: if bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT in requirements:
ui.warn( ui.warn(
_( _(
b'ignoring enabled \'format.bookmarks-in-store\' config ' b'ignoring enabled \'format.bookmarks-in-store\' config '
b'beacuse it is incompatible with disabled ' b'beacuse it is incompatible with disabled '
b'\'format.usestore\' config\n' b'\'format.usestore\' config\n'
) )
) )
if not wdirvfs.exists(): if not wdirvfs.exists():
wdirvfs.makedirs() wdirvfs.makedirs()
hgvfs.makedir(notindexed=True) hgvfs.makedir(notindexed=True)
if b'sharedrepo' not in createopts: if b'sharedrepo' not in createopts:
hgvfs.mkdir(b'cache') hgvfs.mkdir(b'cache')
hgvfs.mkdir(b'wcache') hgvfs.mkdir(b'wcache')
if b'store' in requirements and b'sharedrepo' not in createopts: has_store = requirementsmod.STORE_REQUIREMENT in requirements
if has_store and b'sharedrepo' not in createopts:
hgvfs.mkdir(b'store') hgvfs.mkdir(b'store')
# We create an invalid changelog outside the store so very old # We create an invalid changelog outside the store so very old
# Mercurial versions (which didn't know about the requirements # Mercurial versions (which didn't know about the requirements
# file) encounter an error on reading the changelog. This # file) encounter an error on reading the changelog. This
# effectively locks out old clients and prevents them from # effectively locks out old clients and prevents them from
# mucking with a repo in an unknown format. # mucking with a repo in an unknown format.
# #

mercurial/requirements.py

# requirements.py - objects and functions related to repository requirements # requirements.py - objects and functions related to repository requirements
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
GENERALDELTA_REQUIREMENT = b'generaldelta' GENERALDELTA_REQUIREMENT = b'generaldelta'
DOTENCODE_REQUIREMENT = b'dotencode' DOTENCODE_REQUIREMENT = b'dotencode'
STORE_REQUIREMENT = b'store'
# 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 = b'narrowhg-experimental' NARROW_REQUIREMENT = b'narrowhg-experimental'
# Enables sparse working directory usage # Enables sparse working directory usage
SPARSE_REQUIREMENT = b'exp-sparse' SPARSE_REQUIREMENT = b'exp-sparse'

mercurial/upgrade_utils/actions.py

An upgrade will not be allowed if the repository doesn't have the An upgrade will not be allowed if the repository doesn't have the
requirements returned by this function. requirements returned by this function.
""" """
return { return {
# Introduced in Mercurial 0.9.2. # Introduced in Mercurial 0.9.2.
requirements.REVLOGV1_REQUIREMENT, requirements.REVLOGV1_REQUIREMENT,
# Introduced in Mercurial 0.9.2. # Introduced in Mercurial 0.9.2.
b'store', requirements.STORE_REQUIREMENT,
} }
def blocksourcerequirements(repo): def blocksourcerequirements(repo):
"""Obtain requirements that will prevent an upgrade from occurring. """Obtain requirements that will prevent an upgrade from occurring.
An upgrade cannot be performed if the source repository contains a An upgrade cannot be performed if the source repository contains a
requirements in the returned set. requirements in the returned set.
Extensions should monkeypatch this to add their custom requirements. Extensions should monkeypatch this to add their custom requirements.
""" """
supported = { supported = {
requirements.DOTENCODE_REQUIREMENT, requirements.DOTENCODE_REQUIREMENT,
b'fncache', b'fncache',
requirements.GENERALDELTA_REQUIREMENT, requirements.GENERALDELTA_REQUIREMENT,
requirements.REVLOGV1_REQUIREMENT, requirements.REVLOGV1_REQUIREMENT,
b'store', requirements.STORE_REQUIREMENT,
requirements.SPARSEREVLOG_REQUIREMENT, requirements.SPARSEREVLOG_REQUIREMENT,
requirements.SIDEDATA_REQUIREMENT, requirements.SIDEDATA_REQUIREMENT,
requirements.COPIESSDC_REQUIREMENT, requirements.COPIESSDC_REQUIREMENT,
requirements.NODEMAP_REQUIREMENT, requirements.NODEMAP_REQUIREMENT,
requirements.SHARESAFE_REQUIREMENT, requirements.SHARESAFE_REQUIREMENT,
} }
for name in compression.compengines: for name in compression.compengines:
engine = compression.compengines[name] engine = compression.compengines[name]