This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7093

narrow: drop server support for widening using the getbundle command (BC)
ClosedPublic

Authored by martinvonz on Oct 14 2019, 1:56 PM.

Details

Reviewers
durin42
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe94f457998d3: narrow: drop server support for widening using the getbundle command (BC)
rHG28c93d1c3fc3: narrow: drop server support for widening using the getbundle command (BC)
rHG5300fcac910c: narrow: drop server support for widening using the getbundle command (BC)
Summary

The client still supports widening using the getbundle, which we
(Google) still depend on a for a little while more (we've started the
migration to the new narrow_widen command, but we're not done yet).

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.

Revision Contents
Changeset List

PathPackages
Mhgext/narrow/narrowbundle2.py (91 lines)

Diff 17211

hgext/narrow/narrowbundle2.py

# narrowbundle2.py - bundle2 extensions for narrow repository support # narrowbundle2.py - bundle2 extensions for narrow repository support
# #
# 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
import errno import errno
import struct import struct
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import nullid
bin,
nullid,
)
from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
error, error,
exchange, exchange,
localrepo, localrepo,
narrowspec, narrowspec,
repair, repair,
v v
for v in cgversions for v in cgversions
if v in changegroup.supportedoutgoingversions(repo) if v in changegroup.supportedoutgoingversions(repo)
] ]
if not cgversions: if not cgversions:
raise ValueError(_(b'no common changegroup version')) raise ValueError(_(b'no common changegroup version'))
version = max(cgversions) version = max(cgversions)
oldinclude = sorted(filter(bool, kwargs.get(r'oldincludepats', []))) include = sorted(filter(bool, kwargs.get(r'includepats', [])))
oldexclude = sorted(filter(bool, kwargs.get(r'oldexcludepats', []))) exclude = sorted(filter(bool, kwargs.get(r'excludepats', [])))
newinclude = sorted(filter(bool, kwargs.get(r'includepats', [])))
newexclude = sorted(filter(bool, kwargs.get(r'excludepats', [])))
known = {bin(n) for n in kwargs.get(r'known', [])}
generateellipsesbundle2( generateellipsesbundle2(
bundler, bundler,
repo, repo,
oldinclude, include,
oldexclude, exclude,
newinclude,
newexclude,
version, version,
common, common,
heads, heads,
known,
kwargs.get(r'depth', None), kwargs.get(r'depth', None),
) )
def generateellipsesbundle2( def generateellipsesbundle2(
bundler, bundler, repo, include, exclude, version, common, heads, depth,
repo,
oldinclude,
oldexclude,
newinclude,
newexclude,
version,
common,
heads,
known,
depth,
): ):
newmatch = narrowspec.match( match = narrowspec.match(repo.root, include=include, exclude=exclude)
repo.root, include=newinclude, exclude=newexclude
)
if depth is not None: if depth is not None:
depth = int(depth) depth = int(depth)
if depth < 1: if depth < 1:
raise error.Abort(_(b'depth must be positive, got %d') % depth) raise error.Abort(_(b'depth must be positive, got %d') % depth)
heads = set(heads or repo.heads()) heads = set(heads or repo.heads())
common = set(common or [nullid]) common = set(common or [nullid])
if known and (oldinclude != newinclude or oldexclude != newexclude):
# Steps:
# 1. Send kill for "$known & ::common"
#
# 2. Send changegroup for ::common
#
# 3. Proceed.
#
# In the future, we can send kills for only the specific
# nodes we know should go away or change shape, and then
# send a data stream that tells the client something like this:
#
# a) apply this changegroup
# b) apply nodes XXX, YYY, ZZZ that you already have
# c) goto a
#
# until they've built up the full new state.
# Convert to revnums and intersect with "common". The client should
# have made it a subset of "common" already, but let's be safe.
known = set(repo.revs(b"%ln & ::%ln", known, common))
# TODO: we could send only roots() of this set, and the
# list of nodes in common, and the client could work out
# what to strip, instead of us explicitly sending every
# single node.
deadrevs = known
def genkills():
for r in deadrevs:
yield _KILLNODESIGNAL
yield repo.changelog.node(r)
yield _DONESIGNAL
bundler.newpart(_CHANGESPECPART, data=genkills())
newvisit, newfull, newellipsis = exchange._computeellipsis(
repo, set(), common, known, newmatch
)
if newvisit:
packer = changegroup.getbundler(
version,
repo,
matcher=newmatch,
ellipses=True,
shallow=depth is not None,
ellipsisroots=newellipsis,
fullnodes=newfull,
)
cgdata = packer.generate(common, newvisit, False, b'narrow_widen')
part = bundler.newpart(b'changegroup', data=cgdata)
part.addparam(b'version', version)
if b'treemanifest' in repo.requirements:
part.addparam(b'treemanifest', b'1')
visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis( visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis(
repo, common, heads, set(), newmatch, depth=depth repo, common, heads, set(), match, depth=depth
) )
repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes)) repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes))
if visitnodes: if visitnodes:
packer = changegroup.getbundler( packer = changegroup.getbundler(
version, version,
repo, repo,
matcher=newmatch, matcher=match,
ellipses=True, ellipses=True,
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)