( )⚙ D10106 requirements: also add a generaldelta constant

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10106

requirements: also add a generaldelta constant
ClosedPublic

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

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGf4c325bf80fc: requirements: also add a generaldelta 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:00 AM
This revision is now accepted and ready to land.Mar 4 2021, 4:00 AM
Alphare added a commit: rHGf4c325bf80fc: requirements: also add a generaldelta constant.Mar 4 2021, 7:38 AM
Closed by commit rHGf4c325bf80fc: requirements: also add a generaldelta constant (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26062

mercurial/bundlecaches.py

# bundlecaches.py - utility to deal with pre-computed bundle for servers # bundlecaches.py - utility to deal with pre-computed bundle for servers
# #
# 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 .i18n import _ from .i18n import _
from .thirdparty import attr from .thirdparty import attr
from . import ( from . import (
error, error,
requirements as requirementsmod,
sslutil, sslutil,
util, util,
) )
from .utils import stringutil from .utils import stringutil
urlreq = util.urlreq urlreq = util.urlreq
CB_MANIFEST_FILE = b'clonebundles.manifest' CB_MANIFEST_FILE = b'clonebundles.manifest'
assert not strict assert not strict
spec, params = parseparams(spec) spec, params = parseparams(spec)
if spec in util.compengines.supportedbundlenames: if spec in util.compengines.supportedbundlenames:
compression = spec compression = spec
version = b'v1' version = b'v1'
# Generaldelta repos require v2. # Generaldelta repos require v2.
if b'generaldelta' in repo.requirements: if requirementsmod.GENERALDELTA_REQUIREMENT in repo.requirements:
version = b'v2' version = b'v2'
# Modern compression engines require v2. # Modern compression engines require v2.
if compression not in _bundlespecv1compengines: if compression not in _bundlespecv1compengines:
version = b'v2' version = b'v2'
elif spec in _bundlespeccgversions: elif spec in _bundlespeccgversions:
if spec == b'packed1': if spec == b'packed1':
compression = b'none' compression = b'none'
else: else:

mercurial/changegroup.py

return max(supportedoutgoingversions(repo)) return max(supportedoutgoingversions(repo))
def safeversion(repo): def safeversion(repo):
# Finds the smallest version that it's safe to assume clients of the repo # Finds the smallest version that it's safe to assume clients of the repo
# will support. For example, all hg versions that support generaldelta also # will support. For example, all hg versions that support generaldelta also
# support changegroup 02. # support changegroup 02.
versions = supportedoutgoingversions(repo) versions = supportedoutgoingversions(repo)
if b'generaldelta' in repo.requirements: if requirements.GENERALDELTA_REQUIREMENT in repo.requirements:
versions.discard(b'01') versions.discard(b'01')
assert versions assert versions
return min(versions) return min(versions)
def getbundler( def getbundler(
version, version,
repo, repo,

mercurial/localrepo.py

options = {} options = {}
options[b'flagprocessors'] = {} options[b'flagprocessors'] = {}
if requirementsmod.REVLOGV1_REQUIREMENT in requirements: if requirementsmod.REVLOGV1_REQUIREMENT in requirements:
options[b'revlogv1'] = True options[b'revlogv1'] = True
if requirementsmod.REVLOGV2_REQUIREMENT in requirements: if requirementsmod.REVLOGV2_REQUIREMENT in requirements:
options[b'revlogv2'] = True options[b'revlogv2'] = True
if b'generaldelta' in requirements: if requirementsmod.GENERALDELTA_REQUIREMENT in requirements:
options[b'generaldelta'] = True options[b'generaldelta'] = True
# experimental config: format.chunkcachesize # experimental config: format.chunkcachesize
chunkcachesize = ui.configint(b'format', b'chunkcachesize') chunkcachesize = ui.configint(b'format', b'chunkcachesize')
if chunkcachesize is not None: if chunkcachesize is not None:
options[b'chunkcachesize'] = chunkcachesize options[b'chunkcachesize'] = chunkcachesize
deltabothparents = ui.configbool( deltabothparents = ui.configbool(
# 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.
supportedformats = { supportedformats = {
requirementsmod.REVLOGV1_REQUIREMENT, requirementsmod.REVLOGV1_REQUIREMENT,
b'generaldelta', requirementsmod.GENERALDELTA_REQUIREMENT,
requirementsmod.TREEMANIFEST_REQUIREMENT, requirementsmod.TREEMANIFEST_REQUIREMENT,
requirementsmod.COPIESSDC_REQUIREMENT, requirementsmod.COPIESSDC_REQUIREMENT,
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,
# zlib is the historical default and doesn't need an explicit requirement. # zlib is the historical default and doesn't need an explicit requirement.
if compengine == b'zstd': if compengine == b'zstd':
requirements.add(b'revlog-compression-zstd') requirements.add(b'revlog-compression-zstd')
elif compengine != b'zlib': elif compengine != b'zlib':
requirements.add(b'exp-compression-%s' % compengine) requirements.add(b'exp-compression-%s' % compengine)
if scmutil.gdinitconfig(ui): if scmutil.gdinitconfig(ui):
requirements.add(b'generaldelta') requirements.add(requirementsmod.GENERALDELTA_REQUIREMENT)
if ui.configbool(b'format', b'sparse-revlog'): if ui.configbool(b'format', b'sparse-revlog'):
requirements.add(requirementsmod.SPARSEREVLOG_REQUIREMENT) requirements.add(requirementsmod.SPARSEREVLOG_REQUIREMENT)
# experimental config: format.exp-use-side-data # experimental config: format.exp-use-side-data
if ui.configbool(b'format', b'exp-use-side-data'): if ui.configbool(b'format', b'exp-use-side-data'):
requirements.add(requirementsmod.SIDEDATA_REQUIREMENT) requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
# experimental config: format.exp-use-copies-side-data-changeset # experimental config: format.exp-use-copies-side-data-changeset
if ui.configbool(b'format', b'exp-use-copies-side-data-changeset'): if ui.configbool(b'format', b'exp-use-copies-side-data-changeset'):
requirements.add(requirementsmod.SIDEDATA_REQUIREMENT) requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
requirements.add(requirementsmod.COPIESSDC_REQUIREMENT) requirements.add(requirementsmod.COPIESSDC_REQUIREMENT)
if ui.configbool(b'experimental', b'treemanifest'): if ui.configbool(b'experimental', b'treemanifest'):
requirements.add(requirementsmod.TREEMANIFEST_REQUIREMENT) requirements.add(requirementsmod.TREEMANIFEST_REQUIREMENT)
revlogv2 = ui.config(b'experimental', b'revlogv2') revlogv2 = ui.config(b'experimental', b'revlogv2')
if revlogv2 == b'enable-unstable-format-and-corrupt-my-data': if revlogv2 == b'enable-unstable-format-and-corrupt-my-data':
requirements.remove(requirementsmod.REVLOGV1_REQUIREMENT) requirements.remove(requirementsmod.REVLOGV1_REQUIREMENT)
# generaldelta is implied by revlogv2. # generaldelta is implied by revlogv2.
requirements.discard(b'generaldelta') requirements.discard(requirementsmod.GENERALDELTA_REQUIREMENT)
requirements.add(requirementsmod.REVLOGV2_REQUIREMENT) requirements.add(requirementsmod.REVLOGV2_REQUIREMENT)
# experimental config: format.internal-phase # experimental config: format.internal-phase
if ui.configbool(b'format', b'internal-phase'): if ui.configbool(b'format', b'internal-phase'):
requirements.add(requirementsmod.INTERNAL_PHASE_REQUIREMENT) requirements.add(requirementsmod.INTERNAL_PHASE_REQUIREMENT)
if createopts.get(b'narrowfiles'): if createopts.get(b'narrowfiles'):
requirements.add(requirementsmod.NARROW_REQUIREMENT) requirements.add(requirementsmod.NARROW_REQUIREMENT)

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'
# 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'
# Enables the internal phase which is used to hide changesets instead # Enables the internal phase which is used to hide changesets instead

mercurial/upgrade_utils/actions.py

revlog, revlog,
util, util,
) )
from ..utils import compression from ..utils import compression
# list of requirements that request a clone of all revlog if added/removed # list of requirements that request a clone of all revlog if added/removed
RECLONES_REQUIREMENTS = { RECLONES_REQUIREMENTS = {
b'generaldelta', requirements.GENERALDELTA_REQUIREMENT,
requirements.SPARSEREVLOG_REQUIREMENT, requirements.SPARSEREVLOG_REQUIREMENT,
} }
def preservedrequirements(repo): def preservedrequirements(repo):
return set() return set()
b'beginning with a space or period' b'beginning with a space or period'
) )
@registerformatvariant @registerformatvariant
class generaldelta(requirementformatvariant): class generaldelta(requirementformatvariant):
name = b'generaldelta' name = b'generaldelta'
_requirement = b'generaldelta' _requirement = requirements.GENERALDELTA_REQUIREMENT
default = True default = True
description = _( description = _(
b'deltas within internal storage are unable to ' b'deltas within internal storage are unable to '
b'choose optimal revisions; repository is larger and ' b'choose optimal revisions; repository is larger and '
b'slower than it could be; interaction with other ' b'slower than it could be; interaction with other '
b'repositories may require extra network and CPU ' b'repositories may require extra network and CPU '
If the result of the upgrade would create requirements not in this set, If the result of the upgrade would create requirements not in this set,
the upgrade is disallowed. the upgrade is disallowed.
Extensions should monkeypatch this to add their custom requirements. Extensions should monkeypatch this to add their custom requirements.
""" """
supported = { supported = {
b'dotencode', b'dotencode',
b'fncache', b'fncache',
b'generaldelta', requirements.GENERALDELTA_REQUIREMENT,
requirements.REVLOGV1_REQUIREMENT, requirements.REVLOGV1_REQUIREMENT,
b'store', b'store',
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,
} }
We use a list of allowed requirement additions instead of a list of known We use a list of allowed requirement additions instead of a list of known
bad additions because the whitelist approach is safer and will prevent bad additions because the whitelist approach is safer and will prevent
future, unknown requirements from accidentally being added. future, unknown requirements from accidentally being added.
""" """
supported = { supported = {
b'dotencode', b'dotencode',
b'fncache', b'fncache',
b'generaldelta', requirements.GENERALDELTA_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]

mercurial/wireprotov1server.py

Priority is: Priority is:
1. server.bundle1gd.<action> (if generaldelta active) 1. server.bundle1gd.<action> (if generaldelta active)
2. server.bundle1.<action> 2. server.bundle1.<action>
3. server.bundle1gd (if generaldelta active) 3. server.bundle1gd (if generaldelta active)
4. server.bundle1 4. server.bundle1
""" """
ui = repo.ui ui = repo.ui
gd = b'generaldelta' in repo.requirements gd = requirementsmod.GENERALDELTA_REQUIREMENT in repo.requirements
if gd: if gd:
v = ui.configbool(b'server', b'bundle1gd.%s' % action) v = ui.configbool(b'server', b'bundle1gd.%s' % action)
if v is not None: if v is not None:
return v return v
v = ui.configbool(b'server', b'bundle1.%s' % action) v = ui.configbool(b'server', b'bundle1.%s' % action)
if v is not None: if v is not None: