This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8917

requirements: introduce new requirements related module
ClosedPublic

Authored by pulkit on Aug 9 2020, 5:25 AM.

Details

Reviewers
durin42
martinvonz
indygreg
Group Reviewers
hg-reviewers
Commits
rHG77b8588dd84e: requirements: introduce new requirements related module
Summary

It was not clear where all requirements should and related APIs should be, this
patch introduces a requirements module which will have all exitsing requirements
and related APIs.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

pulkit created this revision.Aug 9 2020, 5:25 AM
indygreg accepted this revision.Aug 10 2020, 8:58 PM
This revision is now accepted and ready to land.Aug 10 2020, 8:58 PM
pulkit added a commit: rHG77b8588dd84e: requirements: introduce new requirements related module.Aug 10 2020, 9:14 PM
Closed by commit rHG77b8588dd84e: requirements: introduce new requirements related module (authored by pulkit). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22372

hgext/narrow/__init__.py

# __init__.py - narrowhg extension # __init__.py - narrowhg extension
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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.
'''create clones which fetch history data for subset of files (EXPERIMENTAL)''' '''create clones which fetch history data for subset of files (EXPERIMENTAL)'''
from __future__ import absolute_import from __future__ import absolute_import
from mercurial import ( from mercurial import (
localrepo, localrepo,
registrar, registrar,
requirements,
) )
from mercurial.interfaces import repository
from . import ( from . import (
narrowbundle2, narrowbundle2,
narrowcommands, narrowcommands,
narrowrepo, narrowrepo,
narrowtemplates, narrowtemplates,
narrowwirepeer, narrowwirepeer,
) )
alias=[(b'narrow', b'serveellipses')], alias=[(b'narrow', b'serveellipses')],
) )
# Export the commands table for Mercurial to see. # Export the commands table for Mercurial to see.
cmdtable = narrowcommands.table cmdtable = narrowcommands.table
def featuresetup(ui, features): def featuresetup(ui, features):
features.add(repository.NARROW_REQUIREMENT) features.add(requirements.NARROW_REQUIREMENT)
def uisetup(ui): def uisetup(ui):
"""Wraps user-facing mercurial commands with narrow-aware versions.""" """Wraps user-facing mercurial commands with narrow-aware versions."""
localrepo.featuresetupfuncs.add(featuresetup) localrepo.featuresetupfuncs.add(featuresetup)
narrowbundle2.setup() narrowbundle2.setup()
narrowcommands.setup() narrowcommands.setup()
narrowwirepeer.uisetup() narrowwirepeer.uisetup()
def reposetup(ui, repo): def reposetup(ui, repo):
"""Wraps local repositories with narrow repo support.""" """Wraps local repositories with narrow repo support."""
if not repo.local(): if not repo.local():
return return
repo.ui.setconfig(b'experimental', b'narrow', True, b'narrow-ext') repo.ui.setconfig(b'experimental', b'narrow', True, b'narrow-ext')
if repository.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:
narrowrepo.wraprepo(repo) narrowrepo.wraprepo(repo)
narrowwirepeer.reposetup(repo) narrowwirepeer.reposetup(repo)
templatekeyword = narrowtemplates.templatekeyword templatekeyword = narrowtemplates.templatekeyword
revsetpredicate = narrowtemplates.revsetpredicate revsetpredicate = narrowtemplates.revsetpredicate

hgext/narrow/narrowbundle2.py

from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
error, error,
exchange, exchange,
localrepo, localrepo,
narrowspec, narrowspec,
repair, repair,
requirements,
scmutil, scmutil,
util, util,
wireprototypes, wireprototypes,
) )
from mercurial.interfaces import repository
from mercurial.utils import stringutil from mercurial.utils import stringutil
_NARROWACL_SECTION = b'narrowacl' _NARROWACL_SECTION = b'narrowacl'
_CHANGESPECPART = b'narrow:changespec' _CHANGESPECPART = b'narrow:changespec'
_RESSPECS = b'narrow:responsespec' _RESSPECS = b'narrow:responsespec'
_SPECPART = b'narrow:spec' _SPECPART = b'narrow:spec'
_SPECPART_INCLUDE = b'include' _SPECPART_INCLUDE = b'include'
_SPECPART_EXCLUDE = b'exclude' _SPECPART_EXCLUDE = b'exclude'
shallow=depth is not None, shallow=depth is not None,
ellipsisroots=ellipsisroots, ellipsisroots=ellipsisroots,
fullnodes=relevant_nodes, fullnodes=relevant_nodes,
) )
cgdata = packer.generate(common, visitnodes, False, b'narrow_widen') cgdata = packer.generate(common, visitnodes, False, b'narrow_widen')
part = bundler.newpart(b'changegroup', data=cgdata) part = bundler.newpart(b'changegroup', data=cgdata)
part.addparam(b'version', version) part.addparam(b'version', version)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
def generate_ellipses_bundle2_for_widening( def generate_ellipses_bundle2_for_widening(
bundler, repo, oldmatch, newmatch, version, common, known, bundler, repo, oldmatch, newmatch, version, common, known,
): ):
common = set(common or [nullid]) common = set(common or [nullid])
# Steps: # Steps:
shallow=False, shallow=False,
ellipsisroots=newellipsis, ellipsisroots=newellipsis,
fullnodes=newfull, fullnodes=newfull,
) )
cgdata = packer.generate(common, newvisit, False, b'narrow_widen') cgdata = packer.generate(common, newvisit, False, b'narrow_widen')
part = bundler.newpart(b'changegroup', data=cgdata) part = bundler.newpart(b'changegroup', data=cgdata)
part.addparam(b'version', version) part.addparam(b'version', version)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
@bundle2.parthandler(_SPECPART, (_SPECPART_INCLUDE, _SPECPART_EXCLUDE)) @bundle2.parthandler(_SPECPART, (_SPECPART_INCLUDE, _SPECPART_EXCLUDE))
def _handlechangespec_2(op, inpart): def _handlechangespec_2(op, inpart):
# XXX: This bundle2 handling is buggy and should be removed after hg5.2 is # XXX: This bundle2 handling is buggy and should be removed after hg5.2 is
# released. New servers will send a mandatory bundle2 part named # released. New servers will send a mandatory bundle2 part named
# 'Narrowspec' and will send specs as data instead of params. # 'Narrowspec' and will send specs as data instead of params.
# Refer to issue5952 and 6019 # Refer to issue5952 and 6019
includepats = set(inpart.params.get(_SPECPART_INCLUDE, b'').splitlines()) includepats = set(inpart.params.get(_SPECPART_INCLUDE, b'').splitlines())
excludepats = set(inpart.params.get(_SPECPART_EXCLUDE, b'').splitlines()) excludepats = set(inpart.params.get(_SPECPART_EXCLUDE, b'').splitlines())
narrowspec.validatepatterns(includepats) narrowspec.validatepatterns(includepats)
narrowspec.validatepatterns(excludepats) narrowspec.validatepatterns(excludepats)
if not repository.NARROW_REQUIREMENT in op.repo.requirements: if not requirements.NARROW_REQUIREMENT in op.repo.requirements:
op.repo.requirements.add(repository.NARROW_REQUIREMENT) op.repo.requirements.add(requirements.NARROW_REQUIREMENT)
scmutil.writereporequirements(op.repo) scmutil.writereporequirements(op.repo)
op.repo.setnarrowpats(includepats, excludepats) op.repo.setnarrowpats(includepats, excludepats)
narrowspec.copytoworkingcopy(op.repo) narrowspec.copytoworkingcopy(op.repo)
@bundle2.parthandler(_RESSPECS) @bundle2.parthandler(_RESSPECS)
def _handlenarrowspecs(op, inpart): def _handlenarrowspecs(op, inpart):
data = inpart.read() data = inpart.read()
inc, exc = data.split(b'\0') inc, exc = data.split(b'\0')
includepats = set(inc.splitlines()) includepats = set(inc.splitlines())
excludepats = set(exc.splitlines()) excludepats = set(exc.splitlines())
narrowspec.validatepatterns(includepats) narrowspec.validatepatterns(includepats)
narrowspec.validatepatterns(excludepats) narrowspec.validatepatterns(excludepats)
if repository.NARROW_REQUIREMENT not in op.repo.requirements: if requirements.NARROW_REQUIREMENT not in op.repo.requirements:
op.repo.requirements.add(repository.NARROW_REQUIREMENT) op.repo.requirements.add(requirements.NARROW_REQUIREMENT)
scmutil.writereporequirements(op.repo) scmutil.writereporequirements(op.repo)
op.repo.setnarrowpats(includepats, excludepats) op.repo.setnarrowpats(includepats, excludepats)
narrowspec.copytoworkingcopy(op.repo) narrowspec.copytoworkingcopy(op.repo)
@bundle2.parthandler(_CHANGESPECPART) @bundle2.parthandler(_CHANGESPECPART)
def _handlechangespec(op, inpart): def _handlechangespec(op, inpart):
repo = op.repo repo = op.repo

hgext/narrow/narrowcommands.py

hg, hg,
narrowspec, narrowspec,
node, node,
pathutil, pathutil,
pycompat, pycompat,
registrar, registrar,
repair, repair,
repoview, repoview,
requirements,
sparse, sparse,
util, util,
wireprototypes, wireprototypes,
) )
from mercurial.interfaces import repository
table = {} table = {}
command = registrar.command(table) command = registrar.command(table)
def setup(): def setup():
"""Wraps user-facing mercurial commands with narrow-aware versions.""" """Wraps user-facing mercurial commands with narrow-aware versions."""
with wrappedextraprepare: with wrappedextraprepare:
return orig(ui, repo, *args, **pycompat.strkwargs(opts)) return orig(ui, repo, *args, **pycompat.strkwargs(opts))
def pullnarrowcmd(orig, ui, repo, *args, **opts): def pullnarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps pull command to allow modifying narrow spec.""" """Wraps pull command to allow modifying narrow spec."""
wrappedextraprepare = util.nullcontextmanager() wrappedextraprepare = util.nullcontextmanager()
if repository.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:
def pullbundle2extraprepare_widen(orig, pullop, kwargs): def pullbundle2extraprepare_widen(orig, pullop, kwargs):
orig(pullop, kwargs) orig(pullop, kwargs)
if opts.get('depth'): if opts.get('depth'):
kwargs[b'depth'] = opts['depth'] kwargs[b'depth'] = opts['depth']
wrappedextraprepare = extensions.wrappedfunction( wrappedextraprepare = extensions.wrappedfunction(
exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen
) )
with wrappedextraprepare: with wrappedextraprepare:
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def archivenarrowcmd(orig, ui, repo, *args, **opts): def archivenarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps archive command to narrow the default includes.""" """Wraps archive command to narrow the default includes."""
if repository.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:
repo_includes, repo_excludes = repo.narrowpats repo_includes, repo_excludes = repo.narrowpats
includes = set(opts.get('include', [])) includes = set(opts.get('include', []))
excludes = set(opts.get('exclude', [])) excludes = set(opts.get('exclude', []))
includes, excludes, unused_invalid = narrowspec.restrictpatterns( includes, excludes, unused_invalid = narrowspec.restrictpatterns(
includes, excludes, repo_includes, repo_excludes includes, excludes, repo_includes, repo_excludes
) )
if includes: if includes:
opts['include'] = includes opts['include'] = includes
if excludes: if excludes:
opts['exclude'] = excludes opts['exclude'] = excludes
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def pullbundle2extraprepare(orig, pullop, kwargs): def pullbundle2extraprepare(orig, pullop, kwargs):
repo = pullop.repo repo = pullop.repo
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return orig(pullop, kwargs) return orig(pullop, kwargs)
if wireprototypes.NARROWCAP not in pullop.remote.capabilities(): if wireprototypes.NARROWCAP not in pullop.remote.capabilities():
raise error.Abort(_(b"server does not support narrow clones")) raise error.Abort(_(b"server does not support narrow clones"))
orig(pullop, kwargs) orig(pullop, kwargs)
kwargs[b'narrow'] = True kwargs[b'narrow'] = True
include, exclude = repo.narrowpats include, exclude = repo.narrowpats
kwargs[b'oldincludepats'] = include kwargs[b'oldincludepats'] = include
the remote) will be added to the set of explicitly specified includes to the remote) will be added to the set of explicitly specified includes to
remove. remove.
--import-rules accepts a path to a file containing rules, allowing you to --import-rules accepts a path to a file containing rules, allowing you to
add --addinclude, --addexclude rules in bulk. Like the other include and add --addinclude, --addexclude rules in bulk. Like the other include and
exclude switches, the changes are applied immediately. exclude switches, the changes are applied immediately.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
raise error.Abort( raise error.Abort(
_( _(
b'the tracked command is only supported on ' b'the tracked command is only supported on '
b'repositories cloned with --narrow' b'repositories cloned with --narrow'
) )
) )
# Before supporting, decide whether it "hg tracked --clear" should mean # Before supporting, decide whether it "hg tracked --clear" should mean

hgext/remotefilelog/remotefilelogserver.py

from mercurial import ( from mercurial import (
changegroup, changegroup,
changelog, changelog,
context, context,
error, error,
extensions, extensions,
match, match,
pycompat, pycompat,
requirements,
store, store,
streamclone, streamclone,
util, util,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1server, wireprotov1server,
) )
from mercurial.interfaces import repository
from . import ( from . import (
constants, constants,
shallowutil, shallowutil,
) )
_sshv1server = wireprotoserver.sshv1protocolhandler _sshv1server = wireprotoserver.sshv1protocolhandler
if not fp.endswith(b'.i') and not fp.endswith( if not fp.endswith(b'.i') and not fp.endswith(
b'.d' b'.d'
): ):
n = util.pconvert(fp[striplen:]) n = util.pconvert(fp[striplen:])
yield (store.decodedir(n), n, st.st_size) yield (store.decodedir(n), n, st.st_size)
if kind == stat.S_IFDIR: if kind == stat.S_IFDIR:
visit.append(fp) visit.append(fp)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
for (u, e, s) in repo.store.datafiles(): for (u, e, s) in repo.store.datafiles():
if u.startswith(b'meta/') and ( if u.startswith(b'meta/') and (
u.endswith(b'.i') or u.endswith(b'.d') u.endswith(b'.i') or u.endswith(b'.d')
): ):
yield (u, e, s) yield (u, e, s)
# Return .d and .i files that do not match the shallow pattern # Return .d and .i files that do not match the shallow pattern
match = state.match match = state.match

hgext/sqlitestore.py

dagop, dagop,
encoding, encoding,
error, error,
extensions, extensions,
localrepo, localrepo,
mdiff, mdiff,
pycompat, pycompat,
registrar, registrar,
requirements,
util, util,
verify, verify,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from mercurial.utils import ( from mercurial.utils import (
supported.add(REQUIREMENT) supported.add(REQUIREMENT)
if zstd: if zstd:
supported.add(REQUIREMENT_ZSTD) supported.add(REQUIREMENT_ZSTD)
supported.add(REQUIREMENT_ZLIB) supported.add(REQUIREMENT_ZLIB)
supported.add(REQUIREMENT_NONE) supported.add(REQUIREMENT_NONE)
supported.add(REQUIREMENT_SHALLOW_FILES) supported.add(REQUIREMENT_SHALLOW_FILES)
supported.add(repository.NARROW_REQUIREMENT) supported.add(requirements.NARROW_REQUIREMENT)
def newreporequirements(orig, ui, createopts): def newreporequirements(orig, ui, createopts):
if createopts[b'backend'] != b'sqlite': if createopts[b'backend'] != b'sqlite':
return orig(ui, createopts) return orig(ui, createopts)
# This restriction can be lifted once we have more confidence. # This restriction can be lifted once we have more confidence.
if b'sharedrepo' in createopts: if b'sharedrepo' in createopts:

mercurial/bundle2.py

changegroup, changegroup,
encoding, encoding,
error, error,
node as nodemod, node as nodemod,
obsolete, obsolete,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
requirements,
scmutil, scmutil,
streamclone, streamclone,
tags, tags,
url, url,
util, util,
) )
from .interfaces import repository
from .utils import stringutil from .utils import stringutil
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
_pack = struct.pack _pack = struct.pack
_unpack = struct.unpack _unpack = struct.unpack
cg = changegroup.getunbundler(unpackerversion, inpart, None) cg = changegroup.getunbundler(unpackerversion, inpart, None)
# the source and url passed here are overwritten by the one contained in # the source and url passed here are overwritten by the one contained in
# the transaction.hookargs argument. So 'bundle2' is a placeholder # the transaction.hookargs argument. So 'bundle2' is a placeholder
nbchangesets = None nbchangesets = None
if b'nbchanges' in inpart.params: if b'nbchanges' in inpart.params:
nbchangesets = int(inpart.params.get(b'nbchanges')) nbchangesets = int(inpart.params.get(b'nbchanges'))
if ( if (
b'treemanifest' in inpart.params b'treemanifest' in inpart.params
and repository.TREEMANIFEST_REQUIREMENT not in op.repo.requirements and requirements.TREEMANIFEST_REQUIREMENT not in op.repo.requirements
): ):
if len(op.repo.changelog) != 0: if len(op.repo.changelog) != 0:
raise error.Abort( raise error.Abort(
_( _(
b"bundle contains tree manifests, but local repo is " b"bundle contains tree manifests, but local repo is "
b"non-empty and does not use tree manifests" b"non-empty and does not use tree manifests"
) )
) )
op.repo.requirements.add(repository.TREEMANIFEST_REQUIREMENT) op.repo.requirements.add(requirements.TREEMANIFEST_REQUIREMENT)
op.repo.svfs.options = localrepo.resolvestorevfsoptions( op.repo.svfs.options = localrepo.resolvestorevfsoptions(
op.repo.ui, op.repo.requirements, op.repo.features op.repo.ui, op.repo.requirements, op.repo.features
) )
scmutil.writereporequirements(op.repo) scmutil.writereporequirements(op.repo)
bundlesidedata = bool(b'exp-sidedata' in inpart.params) bundlesidedata = bool(b'exp-sidedata' in inpart.params)
reposidedata = bool(b'exp-sidedata-flag' in op.repo.requirements) reposidedata = bool(b'exp-sidedata-flag' in op.repo.requirements)
if reposidedata and not bundlesidedata: if reposidedata and not bundlesidedata:
list(commonnodes), list(commonnodes),
False, False,
b'narrow_widen', b'narrow_widen',
changelog=False, changelog=False,
) )
part = bundler.newpart(b'changegroup', data=cgdata) part = bundler.newpart(b'changegroup', data=cgdata)
part.addparam(b'version', cgversion) part.addparam(b'version', cgversion)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
if b'exp-sidedata-flag' in repo.requirements: if b'exp-sidedata-flag' in repo.requirements:
part.addparam(b'exp-sidedata', b'1') part.addparam(b'exp-sidedata', b'1')
return bundler return bundler

mercurial/changegroup.py

from .pycompat import open from .pycompat import open
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
mdiff, mdiff,
phases, phases,
pycompat, pycompat,
requirements,
util, util,
) )
from .interfaces import repository from .interfaces import repository
_CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s") _CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s")
_CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s") _CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s")
_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH") _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH")
# never reordered. To handle this case, we simply take the slowpath, # never reordered. To handle this case, we simply take the slowpath,
# which already has the 'clrevorder' logic. This was also fixed in # which already has the 'clrevorder' logic. This was also fixed in
# cc0ff93d0c0c. # cc0ff93d0c0c.
# Treemanifests don't work correctly with fastpathlinkrev # Treemanifests don't work correctly with fastpathlinkrev
# either, because we don't discover which directory nodes to # either, because we don't discover which directory nodes to
# send along with files. This could probably be fixed. # send along with files. This could probably be fixed.
fastpathlinkrev = fastpathlinkrev and ( fastpathlinkrev = fastpathlinkrev and (
repository.TREEMANIFEST_REQUIREMENT not in repo.requirements requirements.TREEMANIFEST_REQUIREMENT not in repo.requirements
) )
fnodes = {} # needed file nodes fnodes = {} # needed file nodes
size = 0 size = 0
it = self.generatemanifests( it = self.generatemanifests(
commonrevs, commonrevs,
clrevorder, clrevorder,
def allsupportedversions(repo): def allsupportedversions(repo):
versions = set(_packermap.keys()) versions = set(_packermap.keys())
needv03 = False needv03 = False
if ( if (
repo.ui.configbool(b'experimental', b'changegroup3') repo.ui.configbool(b'experimental', b'changegroup3')
or repo.ui.configbool(b'experimental', b'treemanifest') or repo.ui.configbool(b'experimental', b'treemanifest')
or repository.TREEMANIFEST_REQUIREMENT in repo.requirements or requirements.TREEMANIFEST_REQUIREMENT in repo.requirements
): ):
# we keep version 03 because we need to to exchange treemanifest data # we keep version 03 because we need to to exchange treemanifest data
# #
# we also keep vresion 01 and 02, because it is possible for repo to # we also keep vresion 01 and 02, because it is possible for repo to
# contains both normal and tree manifest at the same time. so using # contains both normal and tree manifest at the same time. so using
# older version to pull data is viable # older version to pull data is viable
# #
# (or even to push subset of history) # (or even to push subset of history)
# Changegroup versions that can be applied to the repo # Changegroup versions that can be applied to the repo
def supportedincomingversions(repo): def supportedincomingversions(repo):
return allsupportedversions(repo) return allsupportedversions(repo)
# Changegroup versions that can be created from the repo # Changegroup versions that can be created from the repo
def supportedoutgoingversions(repo): def supportedoutgoingversions(repo):
versions = allsupportedversions(repo) versions = allsupportedversions(repo)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
# Versions 01 and 02 support only flat manifests and it's just too # Versions 01 and 02 support only flat manifests and it's just too
# expensive to convert between the flat manifest and tree manifest on # expensive to convert between the flat manifest and tree manifest on
# the fly. Since tree manifests are hashed differently, all of history # the fly. Since tree manifests are hashed differently, all of history
# would have to be converted. Instead, we simply don't even pretend to # would have to be converted. Instead, we simply don't even pretend to
# support versions 01 and 02. # support versions 01 and 02.
versions.discard(b'01') versions.discard(b'01')
versions.discard(b'02') versions.discard(b'02')
if repository.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:
# Versions 01 and 02 don't support revlog flags, and we need to # Versions 01 and 02 don't support revlog flags, and we need to
# support that for stripping and unbundling to work. # support that for stripping and unbundling to work.
versions.discard(b'01') versions.discard(b'01')
versions.discard(b'02') versions.discard(b'02')
if LFS_REQUIREMENT in repo.requirements: if LFS_REQUIREMENT in repo.requirements:
# Versions 01 and 02 don't support revlog flags, and we need to # Versions 01 and 02 don't support revlog flags, and we need to
# mark LFS entries with REVIDX_EXTSTORED. # mark LFS entries with REVIDX_EXTSTORED.
versions.discard(b'01') versions.discard(b'01')

mercurial/cmdutil.py

mergestate as mergestatemod, mergestate as mergestatemod,
mergeutil, mergeutil,
obsolete, obsolete,
patch, patch,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
repair, repair,
requirements,
revlog, revlog,
rewriteutil, rewriteutil,
scmutil, scmutil,
smartset, smartset,
state as statemod, state as statemod,
subrepoutil, subrepoutil,
templatekw, templatekw,
templater, templater,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .interfaces import repository
from .utils import ( from .utils import (
dateutil, dateutil,
stringutil, stringutil,
) )
if pycompat.TYPE_CHECKING: if pycompat.TYPE_CHECKING:
from typing import ( from typing import (
Any, Any,
if msg: if msg:
raise error.Abort(msg) raise error.Abort(msg)
r = None r = None
if repo: if repo:
if cl: if cl:
r = repo.unfiltered().changelog r = repo.unfiltered().changelog
elif dir: elif dir:
if repository.TREEMANIFEST_REQUIREMENT not in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT not in repo.requirements:
raise error.Abort( raise error.Abort(
_( _(
b"--dir can only be used on repos with " b"--dir can only be used on repos with "
b"treemanifest enabled" b"treemanifest enabled"
) )
) )
if not dir.endswith(b'/'): if not dir.endswith(b'/'):
dir = dir + b'/' dir = dir + b'/'

mercurial/exchange.py

lock as lockmod, lock as lockmod,
logexchange, logexchange,
narrowspec, narrowspec,
obsolete, obsolete,
obsutil, obsutil,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
requirements,
scmutil, scmutil,
sslutil, sslutil,
streamclone, streamclone,
url as urlmod, url as urlmod,
util, util,
wireprototypes, wireprototypes,
) )
from .interfaces import repository
from .utils import ( from .utils import (
hashutil, hashutil,
stringutil, stringutil,
) )
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
raise error.Abort(_(b'no common changegroup version')) raise error.Abort(_(b'no common changegroup version'))
version = max(cgversions) version = max(cgversions)
cgstream = changegroup.makestream( cgstream = changegroup.makestream(
pushop.repo, pushop.outgoing, version, b'push' pushop.repo, pushop.outgoing, version, b'push'
) )
cgpart = bundler.newpart(b'changegroup', data=cgstream) cgpart = bundler.newpart(b'changegroup', data=cgstream)
if cgversions: if cgversions:
cgpart.addparam(b'version', version) cgpart.addparam(b'version', version)
if repository.TREEMANIFEST_REQUIREMENT in pushop.repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in pushop.repo.requirements:
cgpart.addparam(b'treemanifest', b'1') cgpart.addparam(b'treemanifest', b'1')
if b'exp-sidedata-flag' in pushop.repo.requirements: if b'exp-sidedata-flag' in pushop.repo.requirements:
cgpart.addparam(b'exp-sidedata', b'1') cgpart.addparam(b'exp-sidedata', b'1')
def handlereply(op): def handlereply(op):
"""extract addchangegroup returns from server reply""" """extract addchangegroup returns from server reply"""
cgreplies = op.records.getreplies(cgpart.id) cgreplies = op.records.getreplies(cgpart.id)
assert len(cgreplies[b'changegroup']) == 1 assert len(cgreplies[b'changegroup']) == 1
"""Returns heads((h1 + h2) - null)""" """Returns heads((h1 + h2) - null)"""
res = unfi.set(b'heads((%ln + %ln - null))', h1, h2) res = unfi.set(b'heads((%ln + %ln - null))', h1, h2)
return {ctx.node() for ctx in res} return {ctx.node() for ctx in res}
while True: while True:
old_heads = unficl.heads() old_heads = unficl.heads()
clstart = len(unficl) clstart = len(unficl)
_pullbundle2(pullop) _pullbundle2(pullop)
if repository.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:
# XXX narrow clones filter the heads on the server side during # XXX narrow clones filter the heads on the server side during
# XXX getbundle and result in partial replies as well. # XXX getbundle and result in partial replies as well.
# XXX Disable pull bundles in this case as band aid to avoid # XXX Disable pull bundles in this case as band aid to avoid
# XXX extra round trips. # XXX extra round trips.
break break
if clstart == len(unficl): if clstart == len(unficl):
break break
if all(unficl.hasnode(n) for n in pullop.rheads): if all(unficl.hasnode(n) for n in pullop.rheads):
) )
part = bundler.newpart(b'changegroup', data=cgstream) part = bundler.newpart(b'changegroup', data=cgstream)
if cgversions: if cgversions:
part.addparam(b'version', version) part.addparam(b'version', version)
part.addparam(b'nbchanges', b'%d' % len(outgoing.missing), mandatory=False) part.addparam(b'nbchanges', b'%d' % len(outgoing.missing), mandatory=False)
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
if b'exp-sidedata-flag' in repo.requirements: if b'exp-sidedata-flag' in repo.requirements:
part.addparam(b'exp-sidedata', b'1') part.addparam(b'exp-sidedata', b'1')
if ( if (
kwargs.get('narrow', False) kwargs.get('narrow', False)
and kwargs.get('narrow_acl', False) and kwargs.get('narrow_acl', False)

mercurial/hg.py

logcmdutil, logcmdutil,
logexchange, logexchange,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
narrowspec, narrowspec,
node, node,
phases, phases,
pycompat, pycompat,
requirements,
scmutil, scmutil,
sshpeer, sshpeer,
statichttprepo, statichttprepo,
ui as uimod, ui as uimod,
unionrepo, unionrepo,
url, url,
util, util,
verify as verifymod, verify as verifymod,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import hashutil from .utils import hashutil
from .interfaces import repository as repositorymod
release = lock.release release = lock.release
# shared features # shared features
sharedbookmarks = b'bookmarks' sharedbookmarks = b'bookmarks'
def _local(path): def _local(path):
Extensions can wrap this function and write additional entries to Extensions can wrap this function and write additional entries to
destrepo/.hg/shared to indicate additional pieces of data to be shared. destrepo/.hg/shared to indicate additional pieces of data to be shared.
""" """
default = defaultpath or sourcerepo.ui.config(b'paths', b'default') default = defaultpath or sourcerepo.ui.config(b'paths', b'default')
if default: if default:
template = b'[paths]\ndefault = %s\n' template = b'[paths]\ndefault = %s\n'
destrepo.vfs.write(b'hgrc', util.tonativeeol(template % default)) destrepo.vfs.write(b'hgrc', util.tonativeeol(template % default))
if repositorymod.NARROW_REQUIREMENT in sourcerepo.requirements: if requirements.NARROW_REQUIREMENT in sourcerepo.requirements:
with destrepo.wlock(): with destrepo.wlock():
narrowspec.copytoworkingcopy(destrepo) narrowspec.copytoworkingcopy(destrepo)
def _postshareupdate(repo, update, checkout=None): def _postshareupdate(repo, update, checkout=None):
"""Maybe perform a working directory update after a shared repo is created. """Maybe perform a working directory update after a shared repo is created.
``update`` can be a boolean or a revision to update to. ``update`` can be a boolean or a revision to update to.

mercurial/interfaces/repository.py

# repository.py - Interfaces and base classes for repositories and peers. # repository.py - Interfaces and base classes for repositories and peers.
# #
# Copyright 2017 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2017 Gregory Szorc <gregory.szorc@gmail.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
from ..i18n import _ from ..i18n import _
from .. import error from .. import error
from . import util as interfaceutil from . import util as interfaceutil
# When narrowing is finalized and no longer subject to format changes,
# we should move this to just "narrow" or similar.
NARROW_REQUIREMENT = b'narrowhg-experimental'
# Enables sparse working directory usage
SPARSE_REQUIREMENT = b'exp-sparse'
# Enables the internal phase which is used to hide changesets instead
# of stripping them
INTERNAL_PHASE_REQUIREMENT = b'internal-phase'
# Stores manifest in Tree structure
TREEMANIFEST_REQUIREMENT = b'treemanifest'
# Local repository feature string. # Local repository feature string.
# Revlogs are being used for file storage. # Revlogs are being used for file storage.
REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage' REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage'
# The storage part of the repository is shared from an external source. # The storage part of the repository is shared from an external source.
REPO_FEATURE_SHARED_STORAGE = b'sharedstore' REPO_FEATURE_SHARED_STORAGE = b'sharedstore'
# LFS supported for backing file storage. # LFS supported for backing file storage.
REPO_FEATURE_LFS = b'lfs' REPO_FEATURE_LFS = b'lfs'

mercurial/localrepo.py

narrowspec, narrowspec,
obsolete, obsolete,
pathutil, pathutil,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
rcutil, rcutil,
repoview, repoview,
requirements as requirementsmod,
revset, revset,
revsetlang, revsetlang,
scmutil, scmutil,
sparse, sparse,
store as storemod, store as storemod,
subrepoutil, subrepoutil,
tags as tagsmod, tags as tagsmod,
transaction, transaction,
repository opening to ensure that the set of requirements needed repository opening to ensure that the set of requirements needed
to open a repository is sane and compatible with config options. to open a repository is sane and compatible with config options.
Extensions can monkeypatch this function to perform additional Extensions can monkeypatch this function to perform additional
checking. checking.
``error.RepoError`` should be raised on failure. ``error.RepoError`` should be raised on failure.
""" """
if repository.SPARSE_REQUIREMENT in requirements and not sparse.enabled: if (
requirementsmod.SPARSE_REQUIREMENT in requirements
and not sparse.enabled
):
raise error.RepoError( raise error.RepoError(
_( _(
b'repository is using sparse feature but ' b'repository is using sparse feature but '
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 resolvestorevfsoptions(ui, requirements, features): 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 repository.TREEMANIFEST_REQUIREMENT in requirements: if requirementsmod.TREEMANIFEST_REQUIREMENT 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
msg = _(b'invalid value for `storage.revlog.zlib.level` config: %d') msg = _(b'invalid value for `storage.revlog.zlib.level` config: %d')
raise error.Abort(msg % options[b'zlib.level']) raise error.Abort(msg % options[b'zlib.level'])
options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level') options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level')
if options[b'zstd.level'] is not None: if options[b'zstd.level'] is not None:
if not (0 <= options[b'zstd.level'] <= 22): if not (0 <= options[b'zstd.level'] <= 22):
msg = _(b'invalid value for `storage.revlog.zstd.level` config: %d') msg = _(b'invalid value for `storage.revlog.zstd.level` config: %d')
raise error.Abort(msg % options[b'zstd.level']) raise error.Abort(msg % options[b'zstd.level'])
if repository.NARROW_REQUIREMENT in requirements: if requirementsmod.NARROW_REQUIREMENT in requirements:
options[b'enableellipsis'] = True options[b'enableellipsis'] = True
if ui.configbool(b'experimental', b'rust.index'): if ui.configbool(b'experimental', b'rust.index'):
options[b'rust.index'] = True options[b'rust.index'] = True
if NODEMAP_REQUIREMENT in requirements: if NODEMAP_REQUIREMENT in requirements:
options[b'persistent-nodemap'] = True options[b'persistent-nodemap'] = True
if ui.configbool(b'storage', b'revlog.nodemap.mmap'): if ui.configbool(b'storage', b'revlog.nodemap.mmap'):
options[b'persistent-nodemap.mmap'] = True options[b'persistent-nodemap.mmap'] = True
return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch) return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
def makefilestorage(requirements, features, **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) features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
features.add(repository.REPO_FEATURE_STREAM_CLONE) features.add(repository.REPO_FEATURE_STREAM_CLONE)
if repository.NARROW_REQUIREMENT in requirements: if requirementsmod.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. We capture the # derive the final type for a local repository instance. We capture the
# 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 = {
b'revlogv1', b'revlogv1',
b'generaldelta', b'generaldelta',
repository.TREEMANIFEST_REQUIREMENT, requirementsmod.TREEMANIFEST_REQUIREMENT,
COPIESSDC_REQUIREMENT, COPIESSDC_REQUIREMENT,
REVLOGV2_REQUIREMENT, REVLOGV2_REQUIREMENT,
SIDEDATA_REQUIREMENT, SIDEDATA_REQUIREMENT,
SPARSEREVLOG_REQUIREMENT, SPARSEREVLOG_REQUIREMENT,
NODEMAP_REQUIREMENT, NODEMAP_REQUIREMENT,
bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT, bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT,
} }
_basesupported = supportedformats | { _basesupported = supportedformats | {
b'store', b'store',
b'fncache', b'fncache',
b'shared', b'shared',
b'relshared', b'relshared',
b'dotencode', b'dotencode',
repository.SPARSE_REQUIREMENT, requirementsmod.SPARSE_REQUIREMENT,
repository.INTERNAL_PHASE_REQUIREMENT, requirementsmod.INTERNAL_PHASE_REQUIREMENT,
} }
# list of prefix for file which can be written without 'wlock' # list of prefix for file which can be written without 'wlock'
# Extensions should extend this list when needed # Extensions should extend this list when needed
_wlockfreeprefix = { _wlockfreeprefix = {
# We migh consider requiring 'wlock' for the next # We migh consider requiring 'wlock' for the next
# two, but pretty much all the existing code assume # two, but pretty much all the existing code assume
# wlock is not needed so we keep them excluded for # wlock is not needed so we keep them excluded for
"""matcher patterns for this repository's narrowspec """matcher patterns for this repository's narrowspec
A tuple of (includes, excludes). A tuple of (includes, excludes).
""" """
return narrowspec.load(self) return narrowspec.load(self)
@storecache(narrowspec.FILENAME) @storecache(narrowspec.FILENAME)
def _storenarrowmatch(self): def _storenarrowmatch(self):
if repository.NARROW_REQUIREMENT not in self.requirements: if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
return matchmod.always() return matchmod.always()
include, exclude = self.narrowpats include, exclude = self.narrowpats
return narrowspec.match(self.root, include=include, exclude=exclude) return narrowspec.match(self.root, include=include, exclude=exclude)
@storecache(narrowspec.FILENAME) @storecache(narrowspec.FILENAME)
def _narrowmatch(self): def _narrowmatch(self):
if repository.NARROW_REQUIREMENT not in self.requirements: if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
return matchmod.always() return matchmod.always()
narrowspec.checkworkingcopynarrowspec(self) narrowspec.checkworkingcopynarrowspec(self)
include, exclude = self.narrowpats include, exclude = self.narrowpats
return narrowspec.match(self.root, include=include, exclude=exclude) return narrowspec.match(self.root, include=include, exclude=exclude)
def narrowmatch(self, match=None, includeexact=False): def narrowmatch(self, match=None, includeexact=False):
"""matcher corresponding the the repo's narrowspec """matcher corresponding the the repo's narrowspec
# 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(SIDEDATA_REQUIREMENT) requirements.add(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(SIDEDATA_REQUIREMENT) requirements.add(SIDEDATA_REQUIREMENT)
requirements.add(COPIESSDC_REQUIREMENT) requirements.add(COPIESSDC_REQUIREMENT)
if ui.configbool(b'experimental', b'treemanifest'): if ui.configbool(b'experimental', b'treemanifest'):
requirements.add(repository.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(b'revlogv1') requirements.remove(b'revlogv1')
# generaldelta is implied by revlogv2. # generaldelta is implied by revlogv2.
requirements.discard(b'generaldelta') requirements.discard(b'generaldelta')
requirements.add(REVLOGV2_REQUIREMENT) requirements.add(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(repository.INTERNAL_PHASE_REQUIREMENT) requirements.add(requirementsmod.INTERNAL_PHASE_REQUIREMENT)
if createopts.get(b'narrowfiles'): if createopts.get(b'narrowfiles'):
requirements.add(repository.NARROW_REQUIREMENT) requirements.add(requirementsmod.NARROW_REQUIREMENT)
if createopts.get(b'lfs'): if createopts.get(b'lfs'):
requirements.add(b'lfs') requirements.add(b'lfs')
if ui.configbool(b'format', b'bookmarks-in-store'): if ui.configbool(b'format', b'bookmarks-in-store'):
requirements.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT) requirements.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
if ui.configbool(b'format', b'use-persistent-nodemap'): if ui.configbool(b'format', b'use-persistent-nodemap'):

mercurial/narrowspec.py

# narrowspec.py - methods for working with a narrow view of a repository # narrowspec.py - methods for working with a narrow view of a repository
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .interfaces import repository
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
merge, merge,
mergestate as mergestatemod, mergestate as mergestatemod,
requirements,
scmutil, scmutil,
sparse, sparse,
util, util,
) )
# The file in .hg/store/ that indicates which paths exit in the store # The file in .hg/store/ that indicates which paths exit in the store
FILENAME = b'narrowspec' FILENAME = b'narrowspec'
# The file in .hg/ that indicates which paths exit in the dirstate # The file in .hg/ that indicates which paths exit in the dirstate
def copytoworkingcopy(repo): def copytoworkingcopy(repo):
spec = repo.svfs.read(FILENAME) spec = repo.svfs.read(FILENAME)
repo.vfs.write(DIRSTATE_FILENAME, spec) repo.vfs.write(DIRSTATE_FILENAME, spec)
def savebackup(repo, backupname): def savebackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return return
svfs = repo.svfs svfs = repo.svfs
svfs.tryunlink(backupname) svfs.tryunlink(backupname)
util.copyfile(svfs.join(FILENAME), svfs.join(backupname), hardlink=True) util.copyfile(svfs.join(FILENAME), svfs.join(backupname), hardlink=True)
def restorebackup(repo, backupname): def restorebackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return return
util.rename(repo.svfs.join(backupname), repo.svfs.join(FILENAME)) util.rename(repo.svfs.join(backupname), repo.svfs.join(FILENAME))
def savewcbackup(repo, backupname): def savewcbackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return return
vfs = repo.vfs vfs = repo.vfs
vfs.tryunlink(backupname) vfs.tryunlink(backupname)
# It may not exist in old repos # It may not exist in old repos
if vfs.exists(DIRSTATE_FILENAME): if vfs.exists(DIRSTATE_FILENAME):
util.copyfile( util.copyfile(
vfs.join(DIRSTATE_FILENAME), vfs.join(backupname), hardlink=True vfs.join(DIRSTATE_FILENAME), vfs.join(backupname), hardlink=True
) )
def restorewcbackup(repo, backupname): def restorewcbackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return return
# It may not exist in old repos # It may not exist in old repos
if repo.vfs.exists(backupname): if repo.vfs.exists(backupname):
util.rename(repo.vfs.join(backupname), repo.vfs.join(DIRSTATE_FILENAME)) util.rename(repo.vfs.join(backupname), repo.vfs.join(DIRSTATE_FILENAME))
def clearwcbackup(repo, backupname): def clearwcbackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements: if requirements.NARROW_REQUIREMENT not in repo.requirements:
return return
repo.vfs.tryunlink(backupname) repo.vfs.tryunlink(backupname)
def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes): def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
r""" Restricts the patterns according to repo settings, r""" Restricts the patterns according to repo settings,
results in a logical AND operation results in a logical AND operation

mercurial/phases.py

) )
from .pycompat import ( from .pycompat import (
getattr, getattr,
setattr, setattr,
) )
from . import ( from . import (
error, error,
pycompat, pycompat,
requirements,
smartset, smartset,
txnutil, txnutil,
util, util,
) )
from .interfaces import repository
_fphasesentry = struct.Struct(b'>i20s') _fphasesentry = struct.Struct(b'>i20s')
# record phase index # record phase index
public, draft, secret = range(3) public, draft, secret = range(3)
archived = 32 # non-continuous for compatibility archived = 32 # non-continuous for compatibility
internal = 96 # non-continuous for compatibility internal = 96 # non-continuous for compatibility
allphases = (public, draft, secret, archived, internal) allphases = (public, draft, secret, archived, internal)
# record phase property # record phase property
mutablephases = (draft, secret, archived, internal) mutablephases = (draft, secret, archived, internal)
remotehiddenphases = (secret, archived, internal) remotehiddenphases = (secret, archived, internal)
localhiddenphases = (internal, archived) localhiddenphases = (internal, archived)
def supportinternal(repo): def supportinternal(repo):
"""True if the internal phase can be used on a repository""" """True if the internal phase can be used on a repository"""
return repository.INTERNAL_PHASE_REQUIREMENT in repo.requirements return requirements.INTERNAL_PHASE_REQUIREMENT in repo.requirements
def _readroots(repo, phasedefaults=None): def _readroots(repo, phasedefaults=None):
"""Read phase roots from disk """Read phase roots from disk
phasedefaults is a list of fn(repo, roots) callable, which are phasedefaults is a list of fn(repo, roots) callable, which are
executed if the phase roots file does not exist. When phases are executed if the phase roots file does not exist. When phases are
being initialized on an existing repository, this could be used to being initialized on an existing repository, this could be used to

mercurial/repair.py

discovery, discovery,
error, error,
exchange, exchange,
obsolete, obsolete,
obsutil, obsutil,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
requirements,
util, util,
) )
from .interfaces import repository
from .utils import ( from .utils import (
hashutil, hashutil,
stringutil, stringutil,
) )
def backupbundle( def backupbundle(
repo, bases, heads, node, suffix, compress=True, obsolescence=True repo, bases, heads, node, suffix, compress=True, obsolescence=True
def stripmanifest(repo, striprev, tr, files): def stripmanifest(repo, striprev, tr, files):
for revlog in manifestrevlogs(repo): for revlog in manifestrevlogs(repo):
revlog.strip(striprev, tr) revlog.strip(striprev, tr)
def manifestrevlogs(repo): def manifestrevlogs(repo):
yield repo.manifestlog.getstorage(b'') yield repo.manifestlog.getstorage(b'')
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
# This logic is safe if treemanifest isn't enabled, but also # This logic is safe if treemanifest isn't enabled, but also
# pointless, so we skip it if treemanifest isn't enabled. # pointless, so we skip it if treemanifest isn't enabled.
for unencoded, encoded, size in repo.store.datafiles(): for unencoded, encoded, size in repo.store.datafiles():
if unencoded.startswith(b'meta/') and unencoded.endswith( if unencoded.startswith(b'meta/') and unencoded.endswith(
b'00manifest.i' b'00manifest.i'
): ):
dir = unencoded[5:-12] dir = unencoded[5:-12]
yield repo.manifestlog.getstorage(dir) yield repo.manifestlog.getstorage(dir)
if repo.store._exists(i): if repo.store._exists(i):
newentries.add(i) newentries.add(i)
if repo.store._exists(d): if repo.store._exists(d):
newentries.add(d) newentries.add(d)
progress.complete() progress.complete()
if repository.TREEMANIFEST_REQUIREMENT in repo.requirements: if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
# This logic is safe if treemanifest isn't enabled, but also # This logic is safe if treemanifest isn't enabled, but also
# pointless, so we skip it if treemanifest isn't enabled. # pointless, so we skip it if treemanifest isn't enabled.
for dir in pathutil.dirs(seenfiles): for dir in pathutil.dirs(seenfiles):
i = b'meta/%s/00manifest.i' % dir i = b'meta/%s/00manifest.i' % dir
d = b'meta/%s/00manifest.d' % dir d = b'meta/%s/00manifest.d' % dir
if repo.store._exists(i): if repo.store._exists(i):
newentries.add(i) newentries.add(i)

mercurial/requirements.py

  • This file was added.
# requirements.py - objects and functions related to repository requirements
#
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
# When narrowing is finalized and no longer subject to format changes,
# we should move this to just "narrow" or similar.
NARROW_REQUIREMENT = b'narrowhg-experimental'
# Enables sparse working directory usage
SPARSE_REQUIREMENT = b'exp-sparse'
# Enables the internal phase which is used to hide changesets instead
# of stripping them
INTERNAL_PHASE_REQUIREMENT = b'internal-phase'
# Stores manifest in Tree structure
TREEMANIFEST_REQUIREMENT = b'treemanifest'

mercurial/sparse.py

) )
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
pathutil, pathutil,
pycompat, pycompat,
requirements,
scmutil, scmutil,
util, util,
) )
from .interfaces import repository
from .utils import hashutil from .utils import hashutil
# Whether sparse features are enabled. This variable is intended to be # Whether sparse features are enabled. This variable is intended to be
# temporary to facilitate porting sparse to core. It should eventually be # temporary to facilitate porting sparse to core. It should eventually be
# a per-repo option, possibly a repo requirement. # a per-repo option, possibly a repo requirement.
enabled = False enabled = False
# TODO remove this try..except once the matcher integrates better # TODO remove this try..except once the matcher integrates better
# with dirstate. We currently have to write the updated config # with dirstate. We currently have to write the updated config
# because that will invalidate the matcher cache and force a # because that will invalidate the matcher cache and force a
# re-read. We ideally want to update the cached matcher on the # re-read. We ideally want to update the cached matcher on the
# repo instance then flush the new config to disk once wdir is # repo instance then flush the new config to disk once wdir is
# updated. But this requires massive rework to matcher() and its # updated. But this requires massive rework to matcher() and its
# consumers. # consumers.
if repository.SPARSE_REQUIREMENT in oldrequires and removing: if requirements.SPARSE_REQUIREMENT in oldrequires and removing:
repo.requirements.discard(repository.SPARSE_REQUIREMENT) repo.requirements.discard(requirements.SPARSE_REQUIREMENT)
scmutil.writereporequirements(repo) scmutil.writereporequirements(repo)
elif repository.SPARSE_REQUIREMENT not in oldrequires: elif requirements.SPARSE_REQUIREMENT not in oldrequires:
repo.requirements.add(repository.SPARSE_REQUIREMENT) repo.requirements.add(requirements.SPARSE_REQUIREMENT)
scmutil.writereporequirements(repo) scmutil.writereporequirements(repo)
try: try:
writeconfig(repo, includes, excludes, profiles) writeconfig(repo, includes, excludes, profiles)
return refreshwdir(repo, oldstatus, oldmatch, force=force) return refreshwdir(repo, oldstatus, oldmatch, force=force)
except Exception: except Exception:
if repo.requirements != oldrequires: if repo.requirements != oldrequires:
repo.requirements.clear() repo.requirements.clear()

mercurial/upgrade.py

changelog, changelog,
error, error,
filelog, filelog,
hg, hg,
localrepo, localrepo,
manifest, manifest,
metadata, metadata,
pycompat, pycompat,
requirements,
revlog, revlog,
scmutil, scmutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .interfaces import repository
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', b'generaldelta',
localrepo.SPARSEREVLOG_REQUIREMENT, localrepo.SPARSEREVLOG_REQUIREMENT,
} }
"""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.
""" """
return { return {
# The upgrade code does not yet support these experimental features. # The upgrade code does not yet support these experimental features.
# This is an artificial limitation. # This is an artificial limitation.
repository.TREEMANIFEST_REQUIREMENT, requirements.TREEMANIFEST_REQUIREMENT,
# This was a precursor to generaldelta and was never enabled by default. # This was a precursor to generaldelta and was never enabled by default.
# It should (hopefully) not exist in the wild. # It should (hopefully) not exist in the wild.
b'parentdelta', b'parentdelta',
# Upgrade should operate on the actual store, not the shared link. # Upgrade should operate on the actual store, not the shared link.
b'shared', b'shared',
} }

tests/pullext.py

# pullext.py - Simple extension to test pulling # pullext.py - Simple extension to test pulling
# #
# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.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
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
commands, commands,
error, error,
extensions, extensions,
localrepo, localrepo,
requirements,
) )
from mercurial.interfaces import repository
def clonecommand(orig, ui, repo, *args, **kwargs): def clonecommand(orig, ui, repo, *args, **kwargs):
if kwargs.get('include') or kwargs.get('exclude'): if kwargs.get('include') or kwargs.get('exclude'):
kwargs['narrow'] = True kwargs['narrow'] = True
if kwargs.get('depth'): if kwargs.get('depth'):
try: try:
kwargs['depth'] = int(kwargs['depth']) kwargs['depth'] = int(kwargs['depth'])
except ValueError: except ValueError:
raise error.Abort(_('--depth must be an integer')) raise error.Abort(_('--depth must be an integer'))
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
def featuresetup(ui, features): def featuresetup(ui, features):
features.add(repository.NARROW_REQUIREMENT) features.add(requirements.NARROW_REQUIREMENT)
def extsetup(ui): def extsetup(ui):
entry = extensions.wrapcommand(commands.table, b'clone', clonecommand) entry = extensions.wrapcommand(commands.table, b'clone', clonecommand)
hasinclude = any(x[1] == b'include' for x in entry[1]) hasinclude = any(x[1] == b'include' for x in entry[1])
hasdepth = any(x[1] == b'depth' for x in entry[1]) hasdepth = any(x[1] == b'depth' for x in entry[1])