This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4225

repository: formalize interfaces for revision deltas and requests
ClosedPublic

Authored by indygreg on Aug 9 2018, 7:12 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGb518d495a560: repository: formalize interfaces for revision deltas and requests
Summary

Now that we've sufficiently abstracted how revision deltas are
produced in changegroup code, we can now start the process of
formalizing that as part of the interfaces defined in the
repository module.

This commit essentially converts the revisiondelta and
revisiondeltarequest classes into well-defined interfaces. This
is not strictly necessary. But I want all types formalized by the
storage interface to have interfaces. This makes it much easier
to test for interface conformance and for implementing new
storage backends.

Because the interface is documented, comments and docstrings from
changegroup.py have been dropped.

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.

Revision Contents
Changeset List

Diff 10510

mercurial/changegroup.py

phases, phases,
pycompat, pycompat,
repository, repository,
revlog, revlog,
util, util,
) )
from .utils import ( from .utils import (
interfaceutil,
stringutil, stringutil,
) )
_CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s") _CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
_CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s") _CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH") _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
LFS_REQUIREMENT = 'lfs' LFS_REQUIREMENT = 'lfs'
def read(self, n): def read(self, n):
if self._h: if self._h:
d, self._h = self._h[:n], self._h[n:] d, self._h = self._h[:n], self._h[n:]
if len(d) < n: if len(d) < n:
d += readexactly(self._fh, n - len(d)) d += readexactly(self._fh, n - len(d))
return d return d
return readexactly(self._fh, n) return readexactly(self._fh, n)
@interfaceutil.implementer(repository.irevisiondeltarequest)
@attr.s(slots=True, frozen=True) @attr.s(slots=True, frozen=True)
class revisiondeltarequest(object): class revisiondeltarequest(object):
"""Describes a request to construct a revision delta.
Instances are converted into ``revisiondelta`` later.
"""
# Revision whose delta will be generated.
node = attr.ib() node = attr.ib()
# Linknode value.
linknode = attr.ib() linknode = attr.ib()
# Parent revisions to record in ``revisiondelta`` instance.
p1node = attr.ib() p1node = attr.ib()
p2node = attr.ib() p2node = attr.ib()
# Base revision that delta should be generated against. If nullid,
# the full revision data should be populated. If None, the delta
# may be generated against any base revision that is an ancestor of
# this revision. If any other value, the delta should be produced
# against that revision.
basenode = attr.ib() basenode = attr.ib()
# Whether this should be marked as an ellipsis revision.
ellipsis = attr.ib(default=False) ellipsis = attr.ib(default=False)
@interfaceutil.implementer(repository.irevisiondelta)
@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.
Captured data is sufficient to serialize the delta into multiple
formats.
``revision`` and ``delta`` are mutually exclusive.
"""
# 20 byte node of this revision.
node = attr.ib() node = attr.ib()
# 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.
basenode = attr.ib() basenode = attr.ib()
# 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.
flags = attr.ib() flags = attr.ib()
# Size of base revision this delta is against. May be None if
# basenode is nullid.
baserevisionsize = attr.ib() baserevisionsize = attr.ib()
# Raw fulltext revision data.
revision = attr.ib() revision = attr.ib()
# Delta between the basenode and node.
delta = attr.ib() 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 # The captured revision delta may be encoded as a delta against
# a base revision or as a full revision. The changegroup format # a base revision or as a full revision. The changegroup format
# requires that everything on the wire be deltas. So for full # requires that everything on the wire be deltas. So for full

mercurial/repository.py

def requirecap(self, name, purpose): def requirecap(self, name, purpose):
if self.capable(name): if self.capable(name):
return return
raise error.CapabilityError( raise error.CapabilityError(
_('cannot %s; remote repository does not support the %r ' _('cannot %s; remote repository does not support the %r '
'capability') % (purpose, name)) 'capability') % (purpose, name))
class irevisiondelta(interfaceutil.Interface):
"""Represents a delta between one revision and another.
Instances convey enough information to allow a revision to be exchanged
with another repository.
Instances represent the fulltext revision data or a delta against
another revision. Therefore the ``revision`` and ``delta`` attributes
are mutually exclusive.
Typically used for changegroup generation.
"""
node = interfaceutil.Attribute(
"""20 byte node of this revision.""")
p1node = interfaceutil.Attribute(
"""20 byte node of 1st parent of this revision.""")
p2node = interfaceutil.Attribute(
"""20 byte node of 2nd parent of this revision.""")
linknode = interfaceutil.Attribute(
"""20 byte node of the changelog revision this node is linked to.""")
flags = interfaceutil.Attribute(
"""2 bytes of integer flags that apply to this revision.""")
basenode = interfaceutil.Attribute(
"""20 byte node of the revision this data is a delta against.
``nullid`` indicates that the revision is a full revision and not
a delta.
""")
baserevisionsize = interfaceutil.Attribute(
"""Size of base revision this delta is against.
May be ``None`` if ``basenode`` is ``nullid``.
""")
revision = interfaceutil.Attribute(
"""Raw fulltext of revision data for this node.""")
delta = interfaceutil.Attribute(
"""Delta between ``basenode`` and ``node``.
Stored in the bdiff delta format.
""")
class irevisiondeltarequest(interfaceutil.Interface):
"""Represents a request to generate an ``irevisiondelta``."""
node = interfaceutil.Attribute(
"""20 byte node of revision being requested.""")
p1node = interfaceutil.Attribute(
"""20 byte node of 1st parent of revision.""")
p2node = interfaceutil.Attribute(
"""20 byte node of 2nd parent of revision.""")
linknode = interfaceutil.Attribute(
"""20 byte node to store in ``linknode`` attribute.""")
basenode = interfaceutil.Attribute(
"""Base revision that delta should be generated against.
If ``nullid``, the derived ``irevisiondelta`` should have its
``revision`` field populated and no delta should be generated.
If ``None``, the delta may be generated against any revision that
is an ancestor of this revision. Or a full revision may be used.
If any other value, the delta should be produced against that
revision.
""")
ellipsis = interfaceutil.Attribute(
"""Boolean on whether the ellipsis flag should be set.""")
class ifilerevisionssequence(interfaceutil.Interface): class ifilerevisionssequence(interfaceutil.Interface):
"""Contains index data for all revisions of a file. """Contains index data for all revisions of a file.
Types implementing this behave like lists of tuples. The index Types implementing this behave like lists of tuples. The index
in the list corresponds to the revision number. The values contain in the list corresponds to the revision number. The values contain
index metadata. index metadata.
The *null* revision (revision number -1) is always the last item The *null* revision (revision number -1) is always the last item

tests/test-check-interfaces.py

from mercurial.thirdparty.zope import ( from mercurial.thirdparty.zope import (
interface as zi, interface as zi,
) )
from mercurial.thirdparty.zope.interface import ( from mercurial.thirdparty.zope.interface import (
verify as ziverify, verify as ziverify,
) )
from mercurial import ( from mercurial import (
changegroup,
bundlerepo, bundlerepo,
filelog, filelog,
httppeer, httppeer,
localrepo, localrepo,
manifest, manifest,
pycompat, pycompat,
repository, repository,
sshpeer, sshpeer,
# Conforms to imanifestrevisionwritable. # Conforms to imanifestrevisionwritable.
checkzobject(mctx.new()) checkzobject(mctx.new())
checkzobject(mctx.copy()) checkzobject(mctx.copy())
# Conforms to imanifestdict. # Conforms to imanifestdict.
checkzobject(mctx.read()) checkzobject(mctx.read())
ziverify.verifyClass(repository.irevisiondelta,
changegroup.revisiondelta)
ziverify.verifyClass(repository.irevisiondeltarequest,
changegroup.revisiondeltarequest)
rd = changegroup.revisiondelta(
node=b'',
p1node=b'',
p2node=b'',
basenode=b'',
linknode=b'',
flags=b'',
baserevisionsize=None,
revision=b'',
delta=None)
checkzobject(rd)
rdr = changegroup.revisiondeltarequest(
node=b'',
linknode=b'',
p1node=b'',
p2node=b'',
basenode=b'')
checkzobject(rdr)
main() main()