This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8365

manifest: introduce new exception to signal unavailability of fastdelta()
ClosedPublic

Authored by durin42 on Apr 2 2020, 1:16 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG948fac24bc39: manifest: introduce new exception to signal unavailability of fastdelta()
Summary

I've spent some time reflecting on this, and I think this is the best
we can do in this API contract for now. This opens the door to adding
treemanifest's implementation to the list of implementers of
imanifestdict.

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

durin42 created this revision.Apr 2 2020, 1:16 PM
pulkit accepted this revision.Apr 3 2020, 5:20 AM
This revision is now accepted and ready to land.Apr 3 2020, 5:20 AM
pulkit added inline comments.Apr 3 2020, 5:21 AM
mercurial/manifest.py
1632

this will lead us to running this and next heapq.merge call on treemanifest, but I am not sure how costly that will be.

Revision Contents
Changeset List

Diff 20982

mercurial/interfaces/repository.py

"""Obtain a delta between this manifest and another given changes. """Obtain a delta between this manifest and another given changes.
``base`` in the raw data representation for another manifest. ``base`` in the raw data representation for another manifest.
``changes`` is an iterable of ``(path, to_delete)``. ``changes`` is an iterable of ``(path, to_delete)``.
Returns a 2-tuple containing ``bytearray(self.text())`` and the Returns a 2-tuple containing ``bytearray(self.text())`` and the
delta between ``base`` and this manifest. delta between ``base`` and this manifest.
If this manifest implementation can't support ``fastdelta()``,
raise ``mercurial.manifest.FastdeltaUnavailable``.
""" """
class imanifestrevisionbase(interfaceutil.Interface): class imanifestrevisionbase(interfaceutil.Interface):
"""Base interface representing a single revision of a manifest. """Base interface representing a single revision of a manifest.
Should not be used as a primary interface: should always be inherited Should not be used as a primary interface: should always be inherited
as part of a larger interface. as part of a larger interface.

mercurial/manifest.py

m = subm._matches_inner(match) m = subm._matches_inner(match)
if not m._isempty(): if not m._isempty():
ret._dirs[dir] = m ret._dirs[dir] = m
if not ret._isempty(): if not ret._isempty():
ret._dirty = True ret._dirty = True
return ret return ret
def fastdelta(self, base, changes):
raise FastdeltaUnavailable()
def diff(self, m2, match=None, clean=False): def diff(self, m2, match=None, clean=False):
'''Finds changes between the current manifest and m2. '''Finds changes between the current manifest and m2.
Args: Args:
m2: the manifest to which this manifest should be compared. m2: the manifest to which this manifest should be compared.
clean: if true, include files unchanged between these manifests clean: if true, include files unchanged between these manifests
with a None value in the returned dictionary. with a None value in the returned dictionary.
self._read = False self._read = False
# and upper bound of what we expect from compression # and upper bound of what we expect from compression
# (real live value seems to be "3") # (real live value seems to be "3")
MAXCOMPRESSION = 3 MAXCOMPRESSION = 3
class FastdeltaUnavailable(Exception):
"""Exception raised when fastdelta isn't usable on a manifest."""
@interfaceutil.implementer(repository.imanifeststorage) @interfaceutil.implementer(repository.imanifeststorage)
class manifestrevlog(object): class manifestrevlog(object):
'''A revlog that stores manifest texts. This is responsible for caching the '''A revlog that stores manifest texts. This is responsible for caching the
full-text manifest contents. full-text manifest contents.
''' '''
def __init__( def __init__(
self, self,
link, link,
p1, p1,
p2, p2,
added, added,
removed, removed,
readtree=None, readtree=None,
match=None, match=None,
): ):
if p1 in self.fulltextcache and util.safehasattr(m, b'fastdelta'): try:
if p1 not in self.fulltextcache:
raise FastdeltaUnavailable()
# If our first parent is in the manifest cache, we can # If our first parent is in the manifest cache, we can
# compute a delta here using properties we know about the # compute a delta here using properties we know about the
# manifest up-front, which may save time later for the # manifest up-front, which may save time later for the
# revlog layer. # revlog layer.
_checkforbidden(added) _checkforbidden(added)
pulkitUnsubmitted
Not Done

this will lead us to running this and next heapq.merge call on treemanifest, but I am not sure how costly that will be.

pulkit: this will lead us to running this and next `heapq.merge` call on treemanifest, but I am not…
# combine the changed lists into one sorted iterator # combine the changed lists into one sorted iterator
work = heapq.merge( work = heapq.merge(
[(x, False) for x in sorted(added)], [(x, False) for x in sorted(added)],
[(x, True) for x in sorted(removed)], [(x, True) for x in sorted(removed)],
) )
arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work) arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
cachedelta = self._revlog.rev(p1), deltatext cachedelta = self._revlog.rev(p1), deltatext
text = util.buffer(arraytext) text = util.buffer(arraytext)
n = self._revlog.addrevision( n = self._revlog.addrevision(
text, transaction, link, p1, p2, cachedelta text, transaction, link, p1, p2, cachedelta
) )
else: except FastdeltaUnavailable:
# The first parent manifest isn't already loaded, so we'll # The first parent manifest isn't already loaded or the
# just encode a fulltext of the manifest and pass that # manifest implementation doesn't support fastdelta, so
# through to the revlog layer, and let it handle the delta # we'll just encode a fulltext of the manifest and pass
# process. # that through to the revlog layer, and let it handle the
# delta process.
if self._treeondisk: if self._treeondisk:
assert readtree, b"readtree must be set for treemanifest writes" assert readtree, b"readtree must be set for treemanifest writes"
assert match, b"match must be specified for treemanifest writes" assert match, b"match must be specified for treemanifest writes"
m1 = readtree(self.tree, p1) m1 = readtree(self.tree, p1)
m2 = readtree(self.tree, p2) m2 = readtree(self.tree, p2)
n = self._addtree( n = self._addtree(
m, transaction, link, m1, m2, readtree, match=match m, transaction, link, m1, m2, readtree, match=match
) )