This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4079

changegroup: pass function to build delta header into constructor
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGbd64b8b8f0dd: changegroup: pass function to build delta header into constructor
Summary

Previously, the delta header struct format was defined on each
class and each class had a separate function for building the
delta header.

We replace both of these with an argument to init containing
a callable that can format a delta header given a revisiondelta
instance.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (51 lines)

Diff 9841

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):
deltaheader = _CHANGEGROUPV1_DELTA_HEADER def __init__(self, repo, filematcher, version, builddeltaheader,
bundlecaps=None):
def __init__(self, repo, filematcher, version, 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.
builddeltaheader is a callable that constructs the header for a group
delta.
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
# 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':
fn = self._revisiondeltanarrow fn = self._revisiondeltanarrow
else: else:
fn = self._revisiondeltanormal fn = self._revisiondeltanormal
delta = fn(store, rev, prev, linknode) delta = fn(store, rev, prev, linknode)
if not delta: if not delta:
return return
meta = self.builddeltaheader(delta.node, delta.p1node, delta.p2node, meta = self._builddeltaheader(delta)
delta.basenode, delta.linknode,
delta.flags)
l = len(meta) + sum(len(x) for x in delta.deltachunks) l = len(meta) + sum(len(x) for x in delta.deltachunks)
yield chunkheader(l) yield chunkheader(l)
yield meta yield meta
for x in delta.deltachunks: for x in delta.deltachunks:
yield x yield x
def _revisiondeltanormal(self, store, rev, prev, linknode): def _revisiondeltanormal(self, store, rev, prev, linknode):
p1node=p1n, p1node=p1n,
p2node=p2n, p2node=p2n,
basenode=nullid, basenode=nullid,
linknode=linknode, linknode=linknode,
flags=flags, flags=flags,
deltachunks=(diffheader, data), deltachunks=(diffheader, data),
) )
def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
# do nothing with basenode, it is implicitly the previous one in HG10
# do nothing with flags, it is implicitly 0 for cg1 and cg2
return self.deltaheader.pack(node, p1n, p2n, linknode)
class cg2packer(cg1packer): class cg2packer(cg1packer):
deltaheader = _CHANGEGROUPV2_DELTA_HEADER def __init__(self, repo, filematcher, version, builddeltaheader,
bundlecaps=None):
def __init__(self, repo, filematcher, version, bundlecaps=None):
super(cg2packer, self).__init__(repo, filematcher, version, super(cg2packer, self).__init__(repo, filematcher, version,
builddeltaheader,
bundlecaps=bundlecaps) bundlecaps=bundlecaps)
if self._reorder is None: if self._reorder is None:
# Since generaldelta is directly supported by cg2, reordering # Since generaldelta is directly supported by cg2, reordering
# generally doesn't help, so we disable it by default (treating # generally doesn't help, so we disable it by default (treating
# bundle.reorder=auto just like bundle.reorder=False). # bundle.reorder=auto just like bundle.reorder=False).
self._reorder = False self._reorder = False
# Pick prev when we can't be sure remote has the base revision. # Pick prev when we can't be sure remote has the base revision.
return prev return prev
else: else:
base = dp base = dp
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 builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
# Do nothing with flags, it is implicitly 0 in cg1 and cg2
return self.deltaheader.pack(node, p1n, p2n, basenode, linknode)
class cg3packer(cg2packer): class cg3packer(cg2packer):
deltaheader = _CHANGEGROUPV3_DELTA_HEADER
def _packmanifests(self, dir, mfnodes, lookuplinknode): def _packmanifests(self, dir, mfnodes, lookuplinknode):
if dir: if dir:
yield self.fileheader(dir) yield self.fileheader(dir)
dirlog = self._repo.manifestlog._revlog.dirlog(dir) dirlog = self._repo.manifestlog._revlog.dirlog(dir)
for chunk in self.group(mfnodes, dirlog, lookuplinknode, for chunk in self.group(mfnodes, dirlog, lookuplinknode,
units=_('manifests')): units=_('manifests')):
yield chunk yield chunk
def _manifestsdone(self): def _manifestsdone(self):
return self.close() return self.close()
def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
return self.deltaheader.pack(node, p1n, p2n, basenode, linknode, flags)
def _makecg1packer(repo, filematcher, bundlecaps): def _makecg1packer(repo, filematcher, bundlecaps):
return cg1packer(repo, filematcher, b'01', bundlecaps=bundlecaps) builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.linknode)
return cg1packer(repo, filematcher, b'01', builddeltaheader,
bundlecaps=bundlecaps)
def _makecg2packer(repo, filematcher, bundlecaps): def _makecg2packer(repo, filematcher, bundlecaps):
return cg2packer(repo, filematcher, b'02', bundlecaps=bundlecaps) builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.basenode, d.linknode)
return cg2packer(repo, filematcher, b'02', builddeltaheader,
bundlecaps=bundlecaps)
def _makecg3packer(repo, filematcher, bundlecaps): def _makecg3packer(repo, filematcher, bundlecaps):
return cg3packer(repo, filematcher, b'03', bundlecaps=bundlecaps) builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)
return cg3packer(repo, filematcher, b'03', builddeltaheader,
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),
} }