This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4082

changegroup: control reordering via constructor argument
ClosedPublic

Authored by indygreg on Aug 3 2018, 5:04 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG6e999a2d8fe7: changegroup: control reordering via constructor argument
Summary

cg2packer.init exists just to override self._reorder. Let's
parameterize this behavior via an argument to the parent's
init.

The logic for self._reorder is kinda wonky. None is used as a
special value and the value should be None in some situations.
It is probably worth rewriting this logic to make behavior more
explicit. This will likely happen as part of future work to
control the delta generation process that I have planned.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Aug 3 2018, 5:04 PM
Closed by commit rHG6e999a2d8fe7: changegroup: control reordering via constructor argument (authored by indygreg). · Explain WhyAug 6 2018, 2:57 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (41 lines)

Diff 9844

mercurial/changegroup.py

# 20 byte node of changeset revision this delta is associated with. # 20 byte node of changeset revision this delta is associated with.
linknode = attr.ib() linknode = attr.ib()
# 2 bytes of flags to apply to revision data. # 2 bytes of flags to apply to revision data.
flags = attr.ib() flags = attr.ib()
# Iterable of chunks holding raw delta data. # Iterable of chunks holding raw delta data.
deltachunks = attr.ib() deltachunks = attr.ib()
class cg1packer(object): class cg1packer(object):
def __init__(self, repo, filematcher, version, builddeltaheader, def __init__(self, repo, filematcher, version, allowreorder,
manifestsend, sendtreemanifests, builddeltaheader, manifestsend, sendtreemanifests,
bundlecaps=None): bundlecaps=None):
"""Given a source repo, construct a bundler. """Given a source repo, construct a bundler.
filematcher is a matcher that matches on files to include in the filematcher is a matcher that matches on files to include in the
changegroup. Used to facilitate sparse changegroups. changegroup. Used to facilitate sparse changegroups.
allowreorder controls whether reordering of revisions is allowed.
This value is used when ``bundle.reorder`` is ``auto`` or isn't
set.
builddeltaheader is a callable that constructs the header for a group builddeltaheader is a callable that constructs the header for a group
delta. delta.
manifestsend is a chunk to send after manifests have been fully emitted. manifestsend is a chunk to send after manifests have been fully emitted.
sendtreemanifests indicates whether tree manifests should be emitted. sendtreemanifests indicates whether tree manifests should be emitted.
bundlecaps is optional and can be used to specify the set of bundlecaps is optional and can be used to specify the set of
capabilities which can be used to build the bundle. While bundlecaps is capabilities which can be used to build the bundle. While bundlecaps is
unused in core Mercurial, extensions rely on this feature to communicate unused in core Mercurial, extensions rely on this feature to communicate
capabilities to customize the changegroup packer. capabilities to customize the changegroup packer.
""" """
assert filematcher assert filematcher
self._filematcher = filematcher self._filematcher = filematcher
self.version = version self.version = version
self._builddeltaheader = builddeltaheader self._builddeltaheader = builddeltaheader
self._manifestsend = manifestsend self._manifestsend = manifestsend
self._sendtreemanifests = sendtreemanifests self._sendtreemanifests = sendtreemanifests
# Set of capabilities we can use to build the bundle. # Set of capabilities we can use to build the bundle.
if bundlecaps is None: if bundlecaps is None:
bundlecaps = set() bundlecaps = set()
self._bundlecaps = bundlecaps self._bundlecaps = bundlecaps
# experimental config: bundle.reorder # experimental config: bundle.reorder
reorder = repo.ui.config('bundle', 'reorder') reorder = repo.ui.config('bundle', 'reorder')
if reorder == 'auto': if reorder == 'auto':
reorder = None self._reorder = allowreorder
else: else:
reorder = stringutil.parsebool(reorder) self._reorder = stringutil.parsebool(reorder)
self._repo = repo self._repo = repo
self._reorder = reorder
if self._repo.ui.verbose and not self._repo.ui.debugflag: if self._repo.ui.verbose and not self._repo.ui.debugflag:
self._verbosenote = self._repo.ui.note self._verbosenote = self._repo.ui.note
else: else:
self._verbosenote = lambda s: None self._verbosenote = lambda s: None
def close(self): def close(self):
# Ellipses serving mode. # Ellipses serving mode.
getattr(self, 'clrev_to_localrev', {}).clear() getattr(self, 'clrev_to_localrev', {}).clear()
p2node=p2n, p2node=p2n,
basenode=nullid, basenode=nullid,
linknode=linknode, linknode=linknode,
flags=flags, flags=flags,
deltachunks=(diffheader, data), deltachunks=(diffheader, data),
) )
class cg2packer(cg1packer): class cg2packer(cg1packer):
def __init__(self, repo, filematcher, version, builddeltaheader,
manifestsend, sendtreemanifests, bundlecaps=None):
super(cg2packer, self).__init__(repo, filematcher, version,
builddeltaheader, manifestsend,
sendtreemanifests,
bundlecaps=bundlecaps)
if self._reorder is None:
# Since generaldelta is directly supported by cg2, reordering
# generally doesn't help, so we disable it by default (treating
# bundle.reorder=auto just like bundle.reorder=False).
self._reorder = False
def deltaparent(self, store, rev, p1, p2, prev): def deltaparent(self, store, rev, p1, p2, prev):
# Narrow ellipses mode. # Narrow ellipses mode.
if util.safehasattr(self, 'full_nodes'): if util.safehasattr(self, 'full_nodes'):
# TODO: send better deltas when in narrow mode. # TODO: send better deltas when in narrow mode.
# #
# changegroup.group() loops over revisions to send, # changegroup.group() loops over revisions to send,
# including revisions we'll skip. What this means is that # including revisions we'll skip. What this means is that
# `prev` will be a potentially useless delta base for all # `prev` will be a potentially useless delta base for all
if base != nullrev and not store.candelta(base, rev): if base != nullrev and not store.candelta(base, rev):
base = nullrev base = nullrev
return base return base
def _makecg1packer(repo, filematcher, bundlecaps): def _makecg1packer(repo, filematcher, bundlecaps):
builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack( builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.linknode) d.node, d.p1node, d.p2node, d.linknode)
return cg1packer(repo, filematcher, b'01', builddeltaheader, return cg1packer(repo, filematcher, b'01', allowreorder=None,
builddeltaheader=builddeltaheader,
manifestsend=b'', sendtreemanifests=False, manifestsend=b'', sendtreemanifests=False,
bundlecaps=bundlecaps) bundlecaps=bundlecaps)
def _makecg2packer(repo, filematcher, bundlecaps): def _makecg2packer(repo, filematcher, bundlecaps):
builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack( builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.basenode, d.linknode) d.node, d.p1node, d.p2node, d.basenode, d.linknode)
return cg2packer(repo, filematcher, b'02', builddeltaheader, # Since generaldelta is directly supported by cg2, reordering
# generally doesn't help, so we disable it by default (treating
# bundle.reorder=auto just like bundle.reorder=False).
return cg2packer(repo, filematcher, b'02', allowreorder=False,
builddeltaheader=builddeltaheader,
manifestsend=b'', sendtreemanifests=False, manifestsend=b'', sendtreemanifests=False,
bundlecaps=bundlecaps) bundlecaps=bundlecaps)
def _makecg3packer(repo, filematcher, bundlecaps): def _makecg3packer(repo, filematcher, bundlecaps):
builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack( builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags) d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)
return cg2packer(repo, filematcher, b'03', builddeltaheader, return cg2packer(repo, filematcher, b'03', allowreorder=False,
builddeltaheader=builddeltaheader,
manifestsend=closechunk(), sendtreemanifests=True, manifestsend=closechunk(), sendtreemanifests=True,
bundlecaps=bundlecaps) bundlecaps=bundlecaps)
_packermap = {'01': (_makecg1packer, cg1unpacker), _packermap = {'01': (_makecg1packer, cg1unpacker),
# cg2 adds support for exchanging generaldelta # cg2 adds support for exchanging generaldelta
'02': (_makecg2packer, cg2unpacker), '02': (_makecg2packer, cg2unpacker),
# cg3 adds support for exchanging revlog flags and treemanifests # cg3 adds support for exchanging revlog flags and treemanifests
'03': (_makecg3packer, cg3unpacker), '03': (_makecg3packer, cg3unpacker),