This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4799

storageutil: extract functionality for resolving strip revisions
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGfa3dc85a747e: storageutil: extract functionality for resolving strip revisions
Summary

I found myself having to copy this method as part of implementing a new
storage backend. With a little tweaking, we can extract it to a
standalone function so it can be reused easily.

We'll likely want to implement a better method for removing revisions
on the storage interface someday. But until then, let's use what we
have.

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

PathPackages
Mmercurial/revlog.py (36 lines)
Mmercurial/utils/storageutil.py (52 lines)

Diff 11613

mercurial/revlog.py

return newlen >= addlen and delta[hlen:hlen + addlen] == add return newlen >= addlen and delta[hlen:hlen + addlen] == add
def getstrippoint(self, minlink): def getstrippoint(self, minlink):
"""find the minimum rev that must be stripped to strip the linkrev """find the minimum rev that must be stripped to strip the linkrev
Returns a tuple containing the minimum rev and a set of all revs that Returns a tuple containing the minimum rev and a set of all revs that
have linkrevs that will be broken by this strip. have linkrevs that will be broken by this strip.
""" """
brokenrevs = set() return storageutil.resolvestripinfo(minlink, len(self) - 1,
strippoint = len(self) self.headrevs(),
self.linkrev, self.parentrevs)
heads = {}
futurelargelinkrevs = set()
for head in self.headrevs():
headlinkrev = self.linkrev(head)
heads[head] = headlinkrev
if headlinkrev >= minlink:
futurelargelinkrevs.add(headlinkrev)
# This algorithm involves walking down the rev graph, starting at the
# heads. Since the revs are topologically sorted according to linkrev,
# once all head linkrevs are below the minlink, we know there are
# no more revs that could have a linkrev greater than minlink.
# So we can stop walking.
while futurelargelinkrevs:
strippoint -= 1
linkrev = heads.pop(strippoint)
if linkrev < minlink:
brokenrevs.add(strippoint)
else:
futurelargelinkrevs.remove(linkrev)
for p in self.parentrevs(strippoint):
if p != nullrev:
plinkrev = self.linkrev(p)
heads[p] = plinkrev
if plinkrev >= minlink:
futurelargelinkrevs.add(plinkrev)
return strippoint, brokenrevs
def strip(self, minlink, transaction): def strip(self, minlink, transaction):
"""truncate the revlog on the first revision with a linkrev >= minlink """truncate the revlog on the first revision with a linkrev >= minlink
This function is called when we're stripping revision minlink and This function is called when we're stripping revision minlink and
its descendants from the repository. its descendants from the repository.
We have to remove all revisions with linkrev >= minlink, because We have to remove all revisions with linkrev >= minlink, because

mercurial/utils/storageutil.py

# storageutil.py - Storage functionality agnostic of backend implementation. # storageutil.py - Storage functionality agnostic of backend implementation.
# #
# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import hashlib import hashlib
import re import re
from ..i18n import _ from ..i18n import _
from ..node import ( from ..node import (
bin, bin,
nullid, nullid,
nullrev,
) )
from .. import ( from .. import (
error, error,
pycompat, pycompat,
) )
_nullhash = hashlib.sha1(nullid) _nullhash = hashlib.sha1(nullid)
try: try:
return store.node(rev) return store.node(rev)
except (IndexError, TypeError): except (IndexError, TypeError):
pass pass
except (ValueError, OverflowError): except (ValueError, OverflowError):
pass pass
raise error.LookupError(fileid, identifier, _('no match found')) raise error.LookupError(fileid, identifier, _('no match found'))
def resolvestripinfo(minlinkrev, tiprev, headrevs, linkrevfn, parentrevsfn):
"""Resolve information needed to strip revisions.
Finds the minimum revision number that must be stripped in order to
strip ``minlinkrev``.
Returns a 2-tuple of the minimum revision number to do that and a set
of all revision numbers that have linkrevs that would be broken
by that strip.
``tiprev`` is the current tip-most revision. It is ``len(store) - 1``.
``headrevs`` is an iterable of head revisions.
``linkrevfn`` is a callable that receives a revision and returns a linked
revision.
``parentrevsfn`` is a callable that receives a revision number and returns
an iterable of its parent revision numbers.
"""
brokenrevs = set()
strippoint = tiprev + 1
heads = {}
futurelargelinkrevs = set()
for head in headrevs:
headlinkrev = linkrevfn(head)
heads[head] = headlinkrev
if headlinkrev >= minlinkrev:
futurelargelinkrevs.add(headlinkrev)
# This algorithm involves walking down the rev graph, starting at the
# heads. Since the revs are topologically sorted according to linkrev,
# once all head linkrevs are below the minlink, we know there are
# no more revs that could have a linkrev greater than minlink.
# So we can stop walking.
while futurelargelinkrevs:
strippoint -= 1
linkrev = heads.pop(strippoint)
if linkrev < minlinkrev:
brokenrevs.add(strippoint)
else:
futurelargelinkrevs.remove(linkrev)
for p in parentrevsfn(strippoint):
if p != nullrev:
plinkrev = linkrevfn(p)
heads[p] = plinkrev
if plinkrev >= minlinkrev:
futurelargelinkrevs.add(plinkrev)
return strippoint, brokenrevs