This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4213

changegroup: differentiate between fulltext and diff based deltas
ClosedPublic

Authored by indygreg on Aug 9 2018, 4:52 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG39b8277e2115: changegroup: differentiate between fulltext and diff based deltas
Summary

Previously, revisiondelta encoded a delta and an optional prefix
containing a delta header. The underlying code could populate
the delta with either a real delta or a fulltext revision.

Following the theme of wanting to defer serialization of revision
data to the changegroup format as long as possible, it seems
prudent for the revision delta instance to capture what type of
data is being represented. This could possibly allow us to
encode revision data differently in the future. But for the
short term, it makes the behavior of a revisiondelta more
explicit.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Aug 9 2018, 4:52 PM
Closed by commit rHG39b8277e2115: changegroup: differentiate between fulltext and diff based deltas (authored by indygreg). · Explain WhyAug 9 2018, 10:24 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (69 lines)

Diff 10207

mercurial/changegroup.py

return readexactly(self._fh, n) return readexactly(self._fh, n)
@attr.s(slots=True, frozen=True) @attr.s(slots=True, frozen=True)
class revisiondelta(object): class revisiondelta(object):
"""Describes a delta entry in a changegroup. """Describes a delta entry in a changegroup.
Captured data is sufficient to serialize the delta into multiple Captured data is sufficient to serialize the delta into multiple
formats. formats.
``revision`` and ``delta`` are mutually exclusive.
""" """
# 20 byte node of this revision. # 20 byte node of this revision.
node = attr.ib() node = attr.ib()
# 20 byte nodes of parent revisions. # 20 byte nodes of parent revisions.
p1node = attr.ib() p1node = attr.ib()
p2node = attr.ib() p2node = attr.ib()
# 20 byte node of node this delta is against. # 20 byte node of node this delta is against.
basenode = attr.ib() basenode = attr.ib()
# 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. # Size of base revision this delta is against. May be None if
deltachunks = attr.ib() # basenode is nullid.
baserevisionsize = attr.ib()
# Raw fulltext revision data.
revision = attr.ib()
# Delta between the basenode and node.
delta = attr.ib()
def _revisiondeltatochunks(delta, headerfn): def _revisiondeltatochunks(delta, headerfn):
"""Serialize a revisiondelta to changegroup chunks.""" """Serialize a revisiondelta to changegroup chunks."""
# The captured revision delta may be encoded as a delta against
# a base revision or as a full revision. The changegroup format
# requires that everything on the wire be deltas. So for full
# revisions, we need to invent a header that says to rewrite
# data.
if delta.delta is not None:
prefix, data = b'', delta.delta
elif delta.basenode == nullid:
data = delta.revision
prefix = mdiff.trivialdiffheader(len(data))
else:
data = delta.revision
prefix = mdiff.replacediffheader(delta.baserevisionsize,
len(data))
meta = headerfn(delta) meta = headerfn(delta)
l = len(meta) + sum(len(x) for x in delta.deltachunks)
yield chunkheader(l) yield chunkheader(len(meta) + len(prefix) + len(data))
yield meta yield meta
for x in delta.deltachunks: if prefix:
yield x yield prefix
yield data
def _sortnodesnormal(store, nodes, reorder): def _sortnodesnormal(store, nodes, reorder):
"""Sort nodes for changegroup generation and turn into revnums.""" """Sort nodes for changegroup generation and turn into revnums."""
# for generaldelta revlogs, we linearize the revs; this will both be # for generaldelta revlogs, we linearize the revs; this will both be
# much quicker and generate a much smaller bundle # much quicker and generate a much smaller bundle
if (store._generaldelta and reorder is None) or reorder: if (store._generaldelta and reorder is None) or reorder:
dag = dagutil.revlogdag(store) dag = dagutil.revlogdag(store)
return dag.linearize(set(store.rev(n) for n in nodes)) return dag.linearize(set(store.rev(n) for n in nodes))
return [store.rev(n) for n in sorted(nodes, key=key)] return [store.rev(n) for n in sorted(nodes, key=key)]
def _revisiondeltanormal(store, rev, prev, linknode, deltaparentfn): def _revisiondeltanormal(store, rev, prev, linknode, deltaparentfn):
"""Construct a revision delta for non-ellipses changegroup generation.""" """Construct a revision delta for non-ellipses changegroup generation."""
node = store.node(rev) node = store.node(rev)
p1, p2 = store.parentrevs(rev) p1, p2 = store.parentrevs(rev)
base = deltaparentfn(store, rev, p1, p2, prev) base = deltaparentfn(store, rev, p1, p2, prev)
prefix = '' revision = None
delta = None
baserevisionsize = None
if store.iscensored(base) or store.iscensored(rev): if store.iscensored(base) or store.iscensored(rev):
try: try:
delta = store.revision(node, raw=True) revision = store.revision(node, raw=True)
except error.CensoredNodeError as e: except error.CensoredNodeError as e:
delta = e.tombstone revision = e.tombstone
if base == nullrev:
prefix = mdiff.trivialdiffheader(len(delta)) if base != nullrev:
else: baserevisionsize = store.rawsize(base)
baselen = store.rawsize(base)
prefix = mdiff.replacediffheader(baselen, len(delta))
elif base == nullrev: elif base == nullrev:
delta = store.revision(node, raw=True) revision = store.revision(node, raw=True)
prefix = mdiff.trivialdiffheader(len(delta))
else: else:
delta = store.revdiff(base, rev) delta = store.revdiff(base, rev)
p1n, p2n = store.parents(node) p1n, p2n = store.parents(node)
return revisiondelta( return revisiondelta(
node=node, node=node,
p1node=p1n, p1node=p1n,
p2node=p2n, p2node=p2n,
basenode=store.node(base), basenode=store.node(base),
linknode=linknode, linknode=linknode,
flags=store.flags(rev), flags=store.flags(rev),
deltachunks=(prefix, delta), baserevisionsize=baserevisionsize,
revision=revision,
delta=delta,
) )
def _revisiondeltanarrow(cl, store, ischangelog, rev, linkrev, def _revisiondeltanarrow(cl, store, ischangelog, rev, linkrev,
linknode, clrevtolocalrev, fullclnodes, linknode, clrevtolocalrev, fullclnodes,
precomputedellipsis): precomputedellipsis):
linkparents = precomputedellipsis[linkrev] linkparents = precomputedellipsis[linkrev]
def local(clrev): def local(clrev):
"""Turn a changelog revnum into a local revnum. """Turn a changelog revnum into a local revnum.
p1, p2 = sorted(local(p) for p in linkparents) p1, p2 = sorted(local(p) for p in linkparents)
n = store.node(rev) n = store.node(rev)
p1n, p2n = store.node(p1), store.node(p2) p1n, p2n = store.node(p1), store.node(p2)
flags = store.flags(rev) flags = store.flags(rev)
flags |= revlog.REVIDX_ELLIPSIS flags |= revlog.REVIDX_ELLIPSIS
# TODO: try and actually send deltas for ellipsis data blocks # TODO: try and actually send deltas for ellipsis data blocks
data = store.revision(n)
diffheader = mdiff.trivialdiffheader(len(data))
return revisiondelta( return revisiondelta(
node=n, node=n,
p1node=p1n, p1node=p1n,
p2node=p2n, p2node=p2n,
basenode=nullid, basenode=nullid,
linknode=linknode, linknode=linknode,
flags=flags, flags=flags,
deltachunks=(diffheader, data), baserevisionsize=None,
revision=store.revision(n),
delta=None,
) )
def deltagroup(repo, revs, store, ischangelog, lookup, deltaparentfn, def deltagroup(repo, revs, store, ischangelog, lookup, deltaparentfn,
units=None, units=None,
ellipses=False, clrevtolocalrev=None, fullclnodes=None, ellipses=False, clrevtolocalrev=None, fullclnodes=None,
precomputedellipsis=None): precomputedellipsis=None):
"""Calculate deltas for a set of revisions. """Calculate deltas for a set of revisions.