This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4804

storageutil: make all callables optional
ClosedPublic

Authored by indygreg on Sep 28 2018, 8:18 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG631c6f5058b9: storageutil: make all callables optional
Summary

Not all storage backends may implement these callables. That's part
of the reason these methods aren't exposed on the storage interface.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Sep 28 2018, 8:18 PM
Closed by commit rHG631c6f5058b9: storageutil: make all callables optional (authored by indygreg). · Explain WhyOct 3 2018, 11:05 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/utils/storageutil.py (55 lines)

Diff 11487

mercurial/utils/storageutil.py

from ..i18n import _ from ..i18n import _
from ..node import ( from ..node import (
bin, bin,
nullid, nullid,
nullrev, nullrev,
) )
from .. import ( from .. import (
error, error,
mdiff,
pycompat, pycompat,
) )
_nullhash = hashlib.sha1(nullid) _nullhash = hashlib.sha1(nullid)
def hashrevisionsha1(text, p1, p2): def hashrevisionsha1(text, p1, p2):
"""Compute the SHA-1 for revision data and its parents. """Compute the SHA-1 for revision data and its parents.
if p != nullrev: if p != nullrev:
plinkrev = linkrevfn(p) plinkrev = linkrevfn(p)
heads[p] = plinkrev heads[p] = plinkrev
if plinkrev >= minlinkrev: if plinkrev >= minlinkrev:
futurelargelinkrevs.add(plinkrev) futurelargelinkrevs.add(plinkrev)
return strippoint, brokenrevs return strippoint, brokenrevs
def emitrevisions(store, revs, resultcls, deltaparentfn, candeltafn, def emitrevisions(store, revs, resultcls, deltaparentfn=None, candeltafn=None,
rawsizefn, revdifffn, flagsfn, sendfulltext=False, rawsizefn=None, revdifffn=None, flagsfn=None,
sendfulltext=False,
revisiondata=False, assumehaveparentrevisions=False, revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
"""Generic implementation of ifiledata.emitrevisions(). """Generic implementation of ifiledata.emitrevisions().
Emitting revision data is subtly complex. This function attempts to Emitting revision data is subtly complex. This function attempts to
encapsulate all the logic for doing so in a backend-agnostic way. encapsulate all the logic for doing so in a backend-agnostic way.
``store`` ``store``
Object conforming to ``ifilestorage`` interface. Object conforming to ``ifilestorage`` interface.
``revs`` ``revs``
List of integer revision numbers whose data to emit. List of integer revision numbers whose data to emit.
``resultcls`` ``resultcls``
A type implementing the ``irevisiondelta`` interface that will be A type implementing the ``irevisiondelta`` interface that will be
constructed and returned. constructed and returned.
``deltaparentfn`` ``deltaparentfn`` (optional)
Callable receiving a revision number and returning the revision number Callable receiving a revision number and returning the revision number
of a revision that the internal delta is stored against. This delta of a revision that the internal delta is stored against. This delta
will be preferred over computing a new arbitrary delta. will be preferred over computing a new arbitrary delta.
``candeltafn`` If not defined, a delta will always be computed from raw revision
data.
``candeltafn`` (optional)
Callable receiving a pair of revision numbers that returns a bool Callable receiving a pair of revision numbers that returns a bool
indicating whether a delta between them can be produced. indicating whether a delta between them can be produced.
``rawsizefn`` If not defined, it is assumed that any two revisions can delta with
each other.
``rawsizefn`` (optional)
Callable receiving a revision number and returning the length of the Callable receiving a revision number and returning the length of the
``store.revision(rev, raw=True)``. ``store.revision(rev, raw=True)``.
``revdifffn`` If not defined, ``len(store.revision(rev, raw=True))`` will be called.
``revdifffn`` (optional)
Callable receiving a pair of revision numbers that returns a delta Callable receiving a pair of revision numbers that returns a delta
between them. between them.
``flagsfn`` If not defined, a delta will be computed by invoking mdiff code
on ``store.revision()`` results.
Defining this function allows a precomputed or stored delta to be
used without having to compute on.
``flagsfn`` (optional)
Callable receiving a revision number and returns the integer flags Callable receiving a revision number and returns the integer flags
value for it. value for it. If not defined, flags value will be 0.
``sendfulltext`` ``sendfulltext``
Whether to send fulltext revisions instead of deltas, if allowed. Whether to send fulltext revisions instead of deltas, if allowed.
``revisiondata`` ``revisiondata``
``assumehaveparentrevisions`` ``assumehaveparentrevisions``
``deltaprevious`` ``deltaprevious``
See ``ifiledata.emitrevisions()`` interface documentation. See ``ifiledata.emitrevisions()`` interface documentation.
# Set of revs available to delta against. # Set of revs available to delta against.
available = set() available = set()
for rev in revs: for rev in revs:
if rev == nullrev: if rev == nullrev:
continue continue
node = fnode(rev) node = fnode(rev)
deltaparentrev = deltaparentfn(rev)
p1rev, p2rev = store.parentrevs(rev) p1rev, p2rev = store.parentrevs(rev)
if deltaparentfn:
deltaparentrev = deltaparentfn(rev)
else:
deltaparentrev = nullrev
# Forced delta against previous mode. # Forced delta against previous mode.
if deltaprevious: if deltaprevious:
baserev = prevrev baserev = prevrev
# We're instructed to send fulltext. Honor that. # We're instructed to send fulltext. Honor that.
elif sendfulltext: elif sendfulltext:
baserev = nullrev baserev = nullrev
# There is definitely room to improve this logic. # There is definitely room to improve this logic.
elif prevrev is not None: elif prevrev is not None:
baserev = prevrev baserev = prevrev
else: else:
baserev = nullrev baserev = nullrev
# But we can't actually use our chosen delta base for whatever # But we can't actually use our chosen delta base for whatever
# reason. Reset to fulltext. # reason. Reset to fulltext.
if baserev != nullrev and not candeltafn(baserev, rev): if baserev != nullrev and (candeltafn and not candeltafn(baserev, rev)):
baserev = nullrev baserev = nullrev
revision = None revision = None
delta = None delta = None
baserevisionsize = None baserevisionsize = None
if revisiondata: if revisiondata:
if store.iscensored(baserev) or store.iscensored(rev): if store.iscensored(baserev) or store.iscensored(rev):
try: try:
revision = store.revision(node, raw=True) revision = store.revision(node, raw=True)
except error.CensoredNodeError as e: except error.CensoredNodeError as e:
revision = e.tombstone revision = e.tombstone
if baserev != nullrev: if baserev != nullrev:
if rawsizefn:
baserevisionsize = rawsizefn(baserev) baserevisionsize = rawsizefn(baserev)
else:
baserevisionsize = len(store.revision(baserev,
raw=True))
elif baserev == nullrev and not deltaprevious: elif baserev == nullrev and not deltaprevious:
revision = store.revision(node, raw=True) revision = store.revision(node, raw=True)
available.add(rev) available.add(rev)
else: else:
if revdifffn:
delta = revdifffn(baserev, rev) delta = revdifffn(baserev, rev)
else:
delta = mdiff.textdiff(store.revision(baserev, raw=True),
store.revision(rev, raw=True))
available.add(rev) available.add(rev)
yield resultcls( yield resultcls(
node=node, node=node,
p1node=fnode(p1rev), p1node=fnode(p1rev),
p2node=fnode(p2rev), p2node=fnode(p2rev),
basenode=fnode(baserev), basenode=fnode(baserev),
flags=flagsfn(rev), flags=flagsfn(rev) if flagsfn else 0,
baserevisionsize=baserevisionsize, baserevisionsize=baserevisionsize,
revision=revision, revision=revision,
delta=delta) delta=delta)
prevrev = rev prevrev = rev