This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8981

scmutil: introduce function to check whether repo uses treemanifest or not
ClosedPublic

Authored by pulkit on Sep 5 2020, 3:08 AM.

Details

Reviewers
durin42
martinvonz
marmoute
Group Reviewers
hg-reviewers
Commits
rHG10284ce3d5ed: scmutil: introduce function to check whether repo uses treemanifest or not
rHG5a16798ab57f: scmutil: introduce function to check whether repo uses treemanifest or not
rHGdfe585655c3b: scmutil: introduce function to check whether repo uses treemanifest or not
Summary

In next patch, I wanted to check whether current repo uses treemanifest or not.
I looked for a function and found that at all places we manually check for the
requirement in repo requirements. I guess having a dedicated function for that
is much better.

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

pulkit created this revision.Sep 5 2020, 3:08 AM
marmoute accepted this revision.Sep 11 2020, 5:03 AM
pulkit added a commit: rHGdfe585655c3b: scmutil: introduce function to check whether repo uses treemanifest or not.Sep 24 2020, 9:27 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGdfe585655c3b: scmutil: introduce function to check whether repo uses treemanifest or not (authored by pulkit). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22827

hgext/narrow/narrowbundle2.py

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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
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.

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, scmutil,
store, store,
streamclone, streamclone,
util, util,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1server, wireprotov1server,
) )
from . import ( from . import (
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
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

mercurial/bundle2.py

unpackerversion = inpart.params.get(b'version', b'01') unpackerversion = inpart.params.get(b'version', b'01')
# We should raise an appropriate exception here # We should raise an appropriate exception here
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 and not scmutil.istreemanifest(op.repo):
b'treemanifest' in inpart.params
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(requirements.TREEMANIFEST_REQUIREMENT) op.repo.requirements.add(requirements.TREEMANIFEST_REQUIREMENT)
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
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 . import ( from . import (
error, error,
match as matchmod, match as matchmod,
mdiff, mdiff,
phases, phases,
pycompat, pycompat,
requirements, requirements,
scmutil,
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")
# of the changelog itself. The changelog never uses generaldelta and is # of the changelog itself. The changelog never uses generaldelta and is
# 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 not scmutil.istreemanifest(repo)
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,
fastpathlinkrev, fastpathlinkrev,
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements or scmutil.istreemanifest(repo)
): ):
# 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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
# 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 requirements.NARROW_REQUIREMENT in repo.requirements: if requirements.NARROW_REQUIREMENT in repo.requirements:

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,
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 requirements.TREEMANIFEST_REQUIREMENT not in repo.requirements: if not scmutil.istreemanifest(repo):
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

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 requirements.TREEMANIFEST_REQUIREMENT in pushop.repo.requirements: if scmutil.istreemanifest(pushop.repo):
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
) )
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
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/repair.py

error, error,
exchange, exchange,
obsolete, obsolete,
obsutil, obsutil,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
requirements, requirements,
scmutil,
util, util,
) )
from .utils import ( from .utils import (
hashutil, hashutil,
stringutil, stringutil,
) )
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 requirements.TREEMANIFEST_REQUIREMENT in repo.requirements: if scmutil.istreemanifest(repo):
# 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)

mercurial/scmutil.py

if r in requirementsmod.WORKING_DIR_REQUIREMENTS: if r in requirementsmod.WORKING_DIR_REQUIREMENTS:
wc.add(r) wc.add(r)
else: else:
store.add(r) store.add(r)
return wc, store return wc, store
return requirements, None return requirements, None
def istreemanifest(repo):
""" returns whether the repository is using treemanifest or not """
return requirementsmod.TREEMANIFEST_REQUIREMENT in repo.requirements
def writereporequirements(repo, requirements=None): def writereporequirements(repo, requirements=None):
""" writes requirements for the repo to .hg/requires """ """ writes requirements for the repo to .hg/requires """
if requirements: if requirements:
repo.requirements = requirements repo.requirements = requirements
wcreq, storereq = filterrequirements(repo.requirements) wcreq, storereq = filterrequirements(repo.requirements)
if wcreq is not None: if wcreq is not None:
writerequires(repo.vfs, wcreq) writerequires(repo.vfs, wcreq)
if storereq is not None: if storereq is not None: