( )⚙ D6157 branchcache: have a hasnode function to validate nodes

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6157

branchcache: have a hasnode function to validate nodes
ClosedPublic

Authored by pulkit on Mar 19 2019, 9:40 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGb5511845f9d5: branchcache: have a hasnode function to validate nodes
Summary

Upcoming patches will delay node validation until it's required. So we need to a
way in branchcache class to check whether a node exists or node.

Other options were making repo or changelog an attribute of branchcache object.
But the branchcache depends on filters so I decided to pass a function object.

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

pulkit created this revision.Mar 19 2019, 9:40 AM
Closed by commit rHGb5511845f9d5: branchcache: have a hasnode function to validate nodes (authored by pulkit). · Explain WhyMar 23 2019, 11:42 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 14589

mercurial/branchmap.py

included that hashes the hashes of all filtered revisions. included that hashes the hashes of all filtered revisions.
The open/closed state is represented by a single letter 'o' or 'c'. The open/closed state is represented by a single letter 'o' or 'c'.
This field can be used to avoid changelog reads when determining if a This field can be used to avoid changelog reads when determining if a
branch head closes a branch or not. branch head closes a branch or not.
""" """
def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev, def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev,
filteredhash=None, closednodes=None): filteredhash=None, closednodes=None, hasnode=None):
""" hasnode is a function which can be used to verify whether changelog
has a given node or not. If it's not provided, we assume that every node
we have exists in changelog """
self.tipnode = tipnode self.tipnode = tipnode
self.tiprev = tiprev self.tiprev = tiprev
self.filteredhash = filteredhash self.filteredhash = filteredhash
# closednodes is a set of nodes that close their branch. If the branch # closednodes is a set of nodes that close their branch. If the branch
# cache has been updated, it may contain nodes that are no longer # cache has been updated, it may contain nodes that are no longer
# heads. # heads.
if closednodes is None: if closednodes is None:
self._closednodes = set() self._closednodes = set()
else: else:
self._closednodes = closednodes self._closednodes = closednodes
self._entries = dict(entries) self._entries = dict(entries)
# whether closed nodes are verified or not # whether closed nodes are verified or not
self._closedverified = False self._closedverified = False
# branches for which nodes are verified # branches for which nodes are verified
self._verifiedbranches = set() self._verifiedbranches = set()
self._hasnode = hasnode
if self._hasnode is None:
self._hasnode = lambda x: True
def __iter__(self): def __iter__(self):
return iter(self._entries) return iter(self._entries)
def __setitem__(self, key, value): def __setitem__(self, key, value):
self._entries[key] = value self._entries[key] = value
def __getitem__(self, key): def __getitem__(self, key):
f = None f = None
try: try:
f = repo.cachevfs(cls._filename(repo)) f = repo.cachevfs(cls._filename(repo))
lineiter = iter(f) lineiter = iter(f)
cachekey = next(lineiter).rstrip('\n').split(" ", 2) cachekey = next(lineiter).rstrip('\n').split(" ", 2)
last, lrev = cachekey[:2] last, lrev = cachekey[:2]
last, lrev = bin(last), int(lrev) last, lrev = bin(last), int(lrev)
filteredhash = None filteredhash = None
hasnode = repo.changelog.hasnode
if len(cachekey) > 2: if len(cachekey) > 2:
filteredhash = bin(cachekey[2]) filteredhash = bin(cachekey[2])
bcache = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash) bcache = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash,
hasnode=hasnode)
if not bcache.validfor(repo): if not bcache.validfor(repo):
# invalidate the cache # invalidate the cache
raise ValueError(r'tip differs') raise ValueError(r'tip differs')
bcache.load(repo, lineiter) bcache.load(repo, lineiter)
except (IOError, OSError): except (IOError, OSError):
return None return None
except Exception as inst: except Exception as inst: