( )⚙ D4722 revlog: new API to emit revision data

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4722

revlog: new API to emit revision data
ClosedPublic

Authored by indygreg on Sep 24 2018, 1:15 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5a9ab91e0a45: revlog: new API to emit revision data
Summary

I recently refactored changegroup generation code to make it more
storage agnostic. I made significant progress. But there is still
a bit of work to be done. Specifically:

  • Changegroup code is looking at low-level storage attributes to influence sorting. Sorting should be done at the storage layer.
  • The linknode lookup and sorting code for ellipsis is very complicated.
  • Linknodes are just generally wonky because e.g. file storage doesn't know how to translate a linkrev to a changelog node.
  • We regressed performance when introducing the request-response objects.

Having thought about this problem a bit, I think I've come up with
a better interface for emitting revision deltas.

This commit defines and implements that interface. See the docstring
in repository.py for more info.

This API adds 3 notable features over the previous one.

First, it defers node ordering to the storage implementation in
the common case but allows overriding as necessary. We have a
facility for requesting an exact ordering (used in ellipsis
mode). We have another facility for storage order (used for changelog).

Second, we have an argument specifying assumptions about parents
revisions. This can be used to force a fulltext revision when we
don't know the receiver has a parent revision to delta against.

Third, we can control whether revision data is emitted. This makes
the API suitable as a generic "index data retrieval" API as well
as for producing revision deltas - possibly in the same operation!

The new API is much simpler: we no longer need a complicated "request"
object to encapsulate the delta generation request. I'm optimistic
this will restore performance loss associated with
emitrevisiondeltas().

Storage unit tests for the new API have been implemented.

Future commits will port existing consumers of emitrevisiondeltas()
to the new API then remove emitrevisiondeltas().

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

indygreg created this revision.Sep 24 2018, 1:15 PM
Closed by commit rHG5a9ab91e0a45: revlog: new API to emit revision data (authored by indygreg). · Explain WhySep 26 2018, 1:25 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11393

mercurial/filelog.py

return self._revlog.revision(node, _df=_df, raw=raw) return self._revlog.revision(node, _df=_df, raw=raw)
def revdiff(self, rev1, rev2): def revdiff(self, rev1, rev2):
return self._revlog.revdiff(rev1, rev2) return self._revlog.revdiff(rev1, rev2)
def emitrevisiondeltas(self, requests): def emitrevisiondeltas(self, requests):
return self._revlog.emitrevisiondeltas(requests) return self._revlog.emitrevisiondeltas(requests)
def emitrevisions(self, nodes, nodesorder=None,
revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False):
return self._revlog.emitrevisions(
nodes, nodesorder=nodesorder, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions,
deltaprevious=deltaprevious)
def addrevision(self, revisiondata, transaction, linkrev, p1, p2, def addrevision(self, revisiondata, transaction, linkrev, p1, p2,
node=None, flags=revlog.REVIDX_DEFAULT_FLAGS, node=None, flags=revlog.REVIDX_DEFAULT_FLAGS,
cachedelta=None): cachedelta=None):
return self._revlog.addrevision(revisiondata, transaction, linkrev, return self._revlog.addrevision(revisiondata, transaction, linkrev,
p1, p2, node=node, flags=flags, p1, p2, node=node, flags=flags,
cachedelta=cachedelta) cachedelta=cachedelta)
def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):

mercurial/manifest.py

return self._revlog.cmp(node, text) return self._revlog.cmp(node, text)
def deltaparent(self, rev): def deltaparent(self, rev):
return self._revlog.deltaparent(rev) return self._revlog.deltaparent(rev)
def emitrevisiondeltas(self, requests): def emitrevisiondeltas(self, requests):
return self._revlog.emitrevisiondeltas(requests) return self._revlog.emitrevisiondeltas(requests)
def emitrevisions(self, nodes, nodesorder=None,
revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False):
return self._revlog.emitrevisions(
nodes, nodesorder=nodesorder, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions,
deltaprevious=deltaprevious)
def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
return self._revlog.addgroup(deltas, linkmapper, transaction, return self._revlog.addgroup(deltas, linkmapper, transaction,
addrevisioncb=addrevisioncb) addrevisioncb=addrevisioncb)
def rawsize(self, rev): def rawsize(self, rev):
return self._revlog.rawsize(rev) return self._revlog.rawsize(rev)
def getstrippoint(self, minlink): def getstrippoint(self, minlink):

mercurial/repository.py

When sending deltas, implementations must take into account whether When sending deltas, implementations must take into account whether
the client has the base delta before encoding a delta against that the client has the base delta before encoding a delta against that
revision. A revision encountered previously in ``requests`` is revision. A revision encountered previously in ``requests`` is
always a suitable base revision. An example of a bad delta is a delta always a suitable base revision. An example of a bad delta is a delta
against a non-ancestor revision. Another example of a bad delta is a against a non-ancestor revision. Another example of a bad delta is a
delta against a censored revision. delta against a censored revision.
""" """
def emitrevisions(nodes,
nodesorder=None,
revisiondata=False,
assumehaveparentrevisions=False,
deltaprevious=False):
"""Produce ``irevisiondelta`` for revisions.
Given an iterable of nodes, emits objects conforming to the
``irevisiondelta`` interface that describe revisions in storage.
This method is a generator.
The input nodes may be unordered. Implementations must ensure that a
node's parents are emitted before the node itself. Transitively, this
means that a node may only be emitted once all its ancestors in
``nodes`` have also been emitted.
By default, emits "index" data (the ``node``, ``p1node``, and
``p2node`` attributes). If ``revisiondata`` is set, revision data
will also be present on the emitted objects.
With default argument values, implementations can choose to emit
either fulltext revision data or a delta. When emitting deltas,
implementations must consider whether the delta's base revision
fulltext is available to the receiver.
The base revision fulltext is guaranteed to be available if any of
the following are met:
* Its fulltext revision was emitted by this method call.
* A delta for that revision was emitted by this method call.
* ``assumehaveparentrevisions`` is True and the base revision is a
parent of the node.
``nodesorder`` can be used to control the order that revisions are
emitted. By default, revisions can be reordered as long as they are
in DAG topological order (see above). If the value is ``nodes``,
the iteration order from ``nodes`` should be used. If the value is
``storage``, then the native order from the backing storage layer
is used. (Not all storage layers will have strong ordering and behavior
of this mode is storage-dependent.) ``nodes`` ordering can force
revisions to be emitted before their ancestors, so consumers should
use it with care.
The ``linknode`` attribute on the returned ``irevisiondelta`` may not
be set and it is the caller's responsibility to resolve it, if needed.
If ``deltaprevious`` is True and revision data is requested, all
revision data should be emitted as deltas against the revision
emitted just prior. The initial revision should be a delta against
its 1st parent.
"""
class ifilemutation(interfaceutil.Interface): class ifilemutation(interfaceutil.Interface):
"""Storage interface for mutation events of a tracked file.""" """Storage interface for mutation events of a tracked file."""
def add(filedata, meta, transaction, linkrev, p1, p2): def add(filedata, meta, transaction, linkrev, p1, p2):
"""Add a new revision to the store. """Add a new revision to the store.
Takes file data, dictionary of metadata, a transaction, linkrev, Takes file data, dictionary of metadata, a transaction, linkrev,
and parent nodes. and parent nodes.
""" """
def emitrevisiondeltas(requests): def emitrevisiondeltas(requests):
"""Produce ``irevisiondelta`` from ``irevisiondeltarequest``s. """Produce ``irevisiondelta`` from ``irevisiondeltarequest``s.
See the documentation for ``ifiledata`` for more. See the documentation for ``ifiledata`` for more.
""" """
def emitrevisions(nodes,
nodesorder=None,
revisiondata=False,
assumehaveparentrevisions=False):
"""Produce ``irevisiondelta`` describing revisions.
See the documentation for ``ifiledata`` for more.
"""
def addgroup(deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(deltas, linkmapper, transaction, addrevisioncb=None):
"""Process a series of deltas for storage. """Process a series of deltas for storage.
See the documentation in ``ifilemutation`` for more. See the documentation in ``ifilemutation`` for more.
""" """
def rawsize(rev): def rawsize(rev):
"""Obtain the size of tracked data. """Obtain the size of tracked data.

mercurial/revlog.py

REVLOG_DEFAULT_FORMAT, REVLOG_DEFAULT_FORMAT,
REVLOG_DEFAULT_VERSION, REVLOG_DEFAULT_VERSION,
) )
from .thirdparty import ( from .thirdparty import (
attr, attr,
) )
from . import ( from . import (
ancestor, ancestor,
dagop,
error, error,
mdiff, mdiff,
policy, policy,
pycompat, pycompat,
repository, repository,
templatefilters, templatefilters,
util, util,
) )
p1 = attr.ib() p1 = attr.ib()
p2 = attr.ib() p2 = attr.ib()
btext = attr.ib() btext = attr.ib()
textlen = attr.ib() textlen = attr.ib()
cachedelta = attr.ib() cachedelta = attr.ib()
flags = attr.ib() flags = attr.ib()
@interfaceutil.implementer(repository.irevisiondelta) @interfaceutil.implementer(repository.irevisiondelta)
@attr.s(slots=True, frozen=True) @attr.s(slots=True)
class revlogrevisiondelta(object): class revlogrevisiondelta(object):
node = attr.ib() node = attr.ib()
p1node = attr.ib() p1node = attr.ib()
p2node = attr.ib() p2node = attr.ib()
basenode = attr.ib() basenode = attr.ib()
linknode = attr.ib()
flags = attr.ib() flags = attr.ib()
baserevisionsize = attr.ib() baserevisionsize = attr.ib()
revision = attr.ib() revision = attr.ib()
delta = attr.ib() delta = attr.ib()
linknode = attr.ib(default=None)
@interfaceutil.implementer(repository.iverifyproblem) @interfaceutil.implementer(repository.iverifyproblem)
@attr.s(frozen=True) @attr.s(frozen=True)
class revlogproblem(object): class revlogproblem(object):
warning = attr.ib(default=None) warning = attr.ib(default=None)
error = attr.ib(default=None) error = attr.ib(default=None)
# index v0: # index v0:
basenode=self.node(baserev), basenode=self.node(baserev),
flags=self.flags(rev) | extraflags, flags=self.flags(rev) | extraflags,
baserevisionsize=baserevisionsize, baserevisionsize=baserevisionsize,
revision=revision, revision=revision,
delta=delta) delta=delta)
prevrev = rev prevrev = rev
def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
assumehaveparentrevisions=False, deltaprevious=False):
if nodesorder not in ('nodes', 'storage', None):
raise error.ProgrammingError('unhandled value for nodesorder: %s' %
nodesorder)
if nodesorder is None and not self._generaldelta:
nodesorder = 'storage'
frev = self.rev
fnode = self.node
if nodesorder == 'nodes':
revs = [frev(n) for n in nodes]
elif nodesorder == 'storage':
revs = sorted(frev(n) for n in nodes)
else:
assert self._generaldelta
revs = set(frev(n) for n in nodes)
revs = dagop.linearize(revs, self.parentrevs)
prevrev = None
if deltaprevious or assumehaveparentrevisions:
prevrev = self.parentrevs(revs[0])[0]
# Set of revs available to delta against.
available = set()
for rev in revs:
if rev == nullrev:
continue
node = fnode(rev)
deltaparentrev = self.deltaparent(rev)
p1rev, p2rev = self.parentrevs(rev)
# Forced delta against previous mode.
if deltaprevious:
baserev = prevrev
# Revlog is configured to use full snapshots. Stick to that.
elif not self._storedeltachains:
baserev = nullrev
# There is a delta in storage. We try to use that because it
# amounts to effectively copying data from storage and is
# therefore the fastest.
elif deltaparentrev != nullrev:
# Base revision was already emitted in this group. We can
# always safely use the delta.
if deltaparentrev in available:
baserev = deltaparentrev
# Base revision is a parent that hasn't been emitted already.
# Use it if we can assume the receiver has the parent revision.
elif (assumehaveparentrevisions
and deltaparentrev in (p1rev, p2rev)):
baserev = deltaparentrev
# No guarantee the receiver has the delta parent. Send delta
# against last revision (if possible), which in the common case
# should be similar enough to this revision that the delta is
# reasonable.
elif prevrev is not None:
baserev = prevrev
else:
baserev = nullrev
# Storage has a fulltext revision.
# Let's use the previous revision, which is as good a guess as any.
# There is definitely room to improve this logic.
elif prevrev is not None:
baserev = prevrev
else:
baserev = nullrev
# But we can't actually use our chosen delta base for whatever
# reason. Reset to fulltext.
if baserev != nullrev and not self.candelta(baserev, rev):
baserev = nullrev
revision = None
delta = None
baserevisionsize = None
if revisiondata:
if self.iscensored(baserev) or self.iscensored(rev):
try:
revision = self.revision(node, raw=True)
except error.CensoredNodeError as e:
revision = e.tombstone
if baserev != nullrev:
baserevisionsize = self.rawsize(baserev)
elif baserev == nullrev and not deltaprevious:
revision = self.revision(node, raw=True)
available.add(rev)
else:
delta = self.revdiff(baserev, rev)
available.add(rev)
yield revlogrevisiondelta(
node=node,
p1node=fnode(p1rev),
p2node=fnode(p2rev),
basenode=fnode(baserev),
flags=self.flags(rev),
baserevisionsize=baserevisionsize,
revision=revision,
delta=delta)
prevrev = rev
DELTAREUSEALWAYS = 'always' DELTAREUSEALWAYS = 'always'
DELTAREUSESAMEREVS = 'samerevs' DELTAREUSESAMEREVS = 'samerevs'
DELTAREUSENEVER = 'never' DELTAREUSENEVER = 'never'
DELTAREUSEFULLADD = 'fulladd' DELTAREUSEFULLADD = 'fulladd'
DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'} DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'}

mercurial/testing/storage.py

self.assertEqual(delta.basenode, nullid) self.assertEqual(delta.basenode, nullid)
self.assertIsNone(delta.baserevisionsize) self.assertIsNone(delta.baserevisionsize)
self.assertEqual(delta.revision, b'') self.assertEqual(delta.revision, b'')
self.assertIsNone(delta.delta) self.assertIsNone(delta.delta)
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(gen) next(gen)
# Emitting empty list is an empty generator.
gen = f.emitrevisions([])
with self.assertRaises(StopIteration):
next(gen)
# Emitting null node yields nothing.
gen = f.emitrevisions([nullid])
with self.assertRaises(StopIteration):
next(gen)
# Requesting unknown node fails.
with self.assertRaises(error.LookupError):
list(f.emitrevisions([b'\x01' * 20]))
def testsinglerevision(self): def testsinglerevision(self):
fulltext = b'initial' fulltext = b'initial'
f = self._makefilefn() f = self._makefilefn()
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
node = f.add(fulltext, None, tr, 0, nullid, nullid) node = f.add(fulltext, None, tr, 0, nullid, nullid)
self.assertEqual(f.rawsize(0), len(fulltext)) self.assertEqual(f.rawsize(0), len(fulltext))
self.assertEqual(delta.basenode, nullid) self.assertEqual(delta.basenode, nullid)
self.assertIsNone(delta.baserevisionsize) self.assertIsNone(delta.baserevisionsize)
self.assertEqual(delta.revision, fulltext) self.assertEqual(delta.revision, fulltext)
self.assertIsNone(delta.delta) self.assertIsNone(delta.delta)
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(gen) next(gen)
# Emitting a single revision works.
gen = f.emitrevisions([node])
rev = next(gen)
self.assertEqual(rev.node, node)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertIsNone(rev.delta)
with self.assertRaises(StopIteration):
next(gen)
# Requesting revision data works.
gen = f.emitrevisions([node], revisiondata=True)
rev = next(gen)
self.assertEqual(rev.node, node)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertEqual(rev.revision, fulltext)
self.assertIsNone(rev.delta)
with self.assertRaises(StopIteration):
next(gen)
# Emitting an unknown node after a known revision results in error.
with self.assertRaises(error.LookupError):
list(f.emitrevisions([node, b'\x01' * 20]))
def testmultiplerevisions(self): def testmultiplerevisions(self):
fulltext0 = b'x' * 1024 fulltext0 = b'x' * 1024
fulltext1 = fulltext0 + b'y' fulltext1 = fulltext0 + b'y'
fulltext2 = b'y' + fulltext0 + b'z' fulltext2 = b'y' + fulltext0 + b'z'
f = self._makefilefn() f = self._makefilefn()
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
self.assertIsNone(delta.revision) self.assertIsNone(delta.revision)
self.assertEqual(delta.delta, self.assertEqual(delta.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
fulltext2) fulltext2)
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(gen) next(gen)
# Nodes should be emitted in order.
gen = f.emitrevisions([node0, node1, node2], revisiondata=True)
rev = next(gen)
self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertEqual(rev.revision, fulltext0)
self.assertIsNone(rev.delta)
rev = next(gen)
self.assertEqual(rev.node, node1)
self.assertEqual(rev.p1node, node0)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, node0)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
fulltext1)
rev = next(gen)
self.assertEqual(rev.node, node2)
self.assertEqual(rev.p1node, node1)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, node1)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
fulltext2)
with self.assertRaises(StopIteration):
next(gen)
# Request not in DAG order is reordered to be in DAG order.
gen = f.emitrevisions([node2, node1, node0], revisiondata=True)
rev = next(gen)
self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertEqual(rev.revision, fulltext0)
self.assertIsNone(rev.delta)
rev = next(gen)
self.assertEqual(rev.node, node1)
self.assertEqual(rev.p1node, node0)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, node0)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
fulltext1)
rev = next(gen)
self.assertEqual(rev.node, node2)
self.assertEqual(rev.p1node, node1)
self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode)
self.assertEqual(rev.basenode, node1)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
fulltext2)
with self.assertRaises(StopIteration):
next(gen)
# Unrecognized nodesorder value raises ProgrammingError.
with self.assertRaises(error.ProgrammingError):
list(f.emitrevisions([], nodesorder='bad'))
# nodesorder=storage is recognized. But we can't test it thoroughly
# because behavior is storage-dependent.
res = list(f.emitrevisions([node2, node1, node0],
nodesorder='storage'))
self.assertEqual(len(res), 3)
self.assertEqual({o.node for o in res}, {node0, node1, node2})
# nodesorder=nodes forces the order.
gen = f.emitrevisions([node2, node0], nodesorder='nodes',
revisiondata=True)
rev = next(gen)
self.assertEqual(rev.node, node2)
self.assertEqual(rev.p1node, node1)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertEqual(rev.revision, fulltext2)
self.assertIsNone(rev.delta)
rev = next(gen)
self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
# Delta behavior is storage dependent, so we can't easily test it.
with self.assertRaises(StopIteration):
next(gen)
# assumehaveparentrevisions=False (the default) won't send a delta for
# the first revision.
gen = f.emitrevisions({node2, node1}, revisiondata=True)
rev = next(gen)
self.assertEqual(rev.node, node1)
self.assertEqual(rev.p1node, node0)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertEqual(rev.revision, fulltext1)
self.assertIsNone(rev.delta)
rev = next(gen)
self.assertEqual(rev.node, node2)
self.assertEqual(rev.p1node, node1)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, node1)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
fulltext2)
with self.assertRaises(StopIteration):
next(gen)
# assumehaveparentrevisions=True allows delta against initial revision.
gen = f.emitrevisions([node2, node1],
revisiondata=True, assumehaveparentrevisions=True)
rev = next(gen)
self.assertEqual(rev.node, node1)
self.assertEqual(rev.p1node, node0)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, node0)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
fulltext1)
# forceprevious=True forces a delta against the previous revision.
# Special case for initial revision.
gen = f.emitrevisions([node0], revisiondata=True, deltaprevious=True)
rev = next(gen)
self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +
fulltext0)
with self.assertRaises(StopIteration):
next(gen)
gen = f.emitrevisions([node0, node2], revisiondata=True,
deltaprevious=True)
rev = next(gen)
self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, nullid)
self.assertIsNone(rev.baserevisionsize)
self.assertIsNone(rev.revision)
self.assertEqual(rev.delta,
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +
fulltext0)
rev = next(gen)
self.assertEqual(rev.node, node2)
self.assertEqual(rev.p1node, node1)
self.assertEqual(rev.p2node, nullid)
self.assertEqual(rev.basenode, node0)
with self.assertRaises(StopIteration):
next(gen)
def testrenamed(self): def testrenamed(self):
fulltext0 = b'foo' fulltext0 = b'foo'
fulltext1 = b'bar' fulltext1 = b'bar'
fulltext2 = b'baz' fulltext2 = b'baz'
meta1 = { meta1 = {
b'copy': b'source0', b'copy': b'source0',
b'copyrev': b'a' * 40, b'copyrev': b'a' * 40,