branchmap.py
210 lines
| 8.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / branchmap.py
|
r18116 | # branchmap.py - logic to computes, maintain and stores branchmap for local repo | ||
# | ||||
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
|
r18117 | |||
|
r18118 | from node import bin, hex, nullid, nullrev | ||
|
r18117 | import encoding | ||
|
r18234 | import util, repoview | ||
|
r18117 | |||
|
r18185 | def _filename(repo): | ||
|
r18187 | """name of a branchcache file for a given repo or repoview""" | ||
filename = "cache/branchheads" | ||||
if repo.filtername: | ||||
filename = '%s-%s' % (filename, repo.filtername) | ||||
return filename | ||||
|
r18185 | |||
|
r18118 | def read(repo): | ||
try: | ||||
|
r18185 | f = repo.opener(_filename(repo)) | ||
|
r18118 | lines = f.read().split('\n') | ||
f.close() | ||||
except (IOError, OSError): | ||||
|
r18212 | return None | ||
|
r18118 | |||
try: | ||||
|
r18184 | cachekey = lines.pop(0).split(" ", 2) | ||
last, lrev = cachekey[:2] | ||||
|
r18118 | last, lrev = bin(last), int(lrev) | ||
|
r18184 | filteredhash = None | ||
if len(cachekey) > 2: | ||||
filteredhash = bin(cachekey[2]) | ||||
partial = branchcache(tipnode=last, tiprev=lrev, | ||||
filteredhash=filteredhash) | ||||
|
r18132 | if not partial.validfor(repo): | ||
|
r18118 | # invalidate the cache | ||
|
r18166 | raise ValueError('tip differs') | ||
|
r18118 | for l in lines: | ||
if not l: | ||||
continue | ||||
node, label = l.split(" ", 1) | ||||
label = encoding.tolocal(label.strip()) | ||||
if not node in repo: | ||||
|
r18166 | raise ValueError('node %s does not exist' % node) | ||
|
r18118 | partial.setdefault(label, []).append(bin(node)) | ||
except KeyboardInterrupt: | ||||
raise | ||||
except Exception, inst: | ||||
if repo.ui.debugflag: | ||||
|
r18188 | msg = 'invalid branchheads cache' | ||
if repo.filtername is not None: | ||||
msg += ' (%s)' % repo.filtername | ||||
msg += ': %s\n' | ||||
repo.ui.warn(msg % inst) | ||||
|
r18212 | partial = None | ||
|
r18126 | return partial | ||
|
r18118 | |||
|
r18130 | |||
|
r18120 | |||
|
r18121 | def updatecache(repo): | ||
cl = repo.changelog | ||||
|
r18189 | filtername = repo.filtername | ||
partial = repo._branchcaches.get(filtername) | ||||
|
r18121 | |||
|
r18234 | revs = [] | ||
|
r18132 | if partial is None or not partial.validfor(repo): | ||
|
r18126 | partial = read(repo) | ||
|
r18212 | if partial is None: | ||
|
r18234 | subsetname = repoview.subsettable.get(filtername) | ||
if subsetname is None: | ||||
partial = branchcache() | ||||
else: | ||||
subset = repo.filtered(subsetname) | ||||
partial = subset.branchmap().copy() | ||||
extrarevs = subset.changelog.filteredrevs - cl.filteredrevs | ||||
revs.extend(r for r in extrarevs if r <= partial.tiprev) | ||||
revs.extend(cl.revs(start=partial.tiprev + 1)) | ||||
|
r18218 | if revs: | ||
|
r18305 | partial.update(repo, revs) | ||
|
r18128 | partial.write(repo) | ||
|
r18451 | assert partial.validfor(repo), filtername | ||
|
r18189 | repo._branchcaches[repo.filtername] = partial | ||
|
r18124 | |||
class branchcache(dict): | ||||
"""A dict like object that hold branches heads cache""" | ||||
|
r18168 | def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev, | ||
filteredhash=None): | ||||
|
r18125 | super(branchcache, self).__init__(entries) | ||
self.tipnode = tipnode | ||||
|
r18126 | self.tiprev = tiprev | ||
|
r18168 | self.filteredhash = filteredhash | ||
def _hashfiltered(self, repo): | ||||
"""build hash of revision filtered in the current cache | ||||
|
r18644 | Tracking tipnode and tiprev is not enough to ensure validity of the | ||
|
r18168 | cache as they do not help to distinct cache that ignored various | ||
revision bellow tiprev. | ||||
To detect such difference, we build a cache of all ignored revisions. | ||||
""" | ||||
cl = repo.changelog | ||||
if not cl.filteredrevs: | ||||
return None | ||||
key = None | ||||
revs = sorted(r for r in cl.filteredrevs if r <= self.tiprev) | ||||
if revs: | ||||
s = util.sha1() | ||||
for rev in revs: | ||||
s.update('%s;' % rev) | ||||
key = s.digest() | ||||
return key | ||||
|
r18128 | |||
|
r18132 | def validfor(self, repo): | ||
|
r18644 | """Is the cache content valid regarding a repo | ||
|
r18132 | |||
|
r18644 | - False when cached tipnode is unknown or if we detect a strip. | ||
|
r18132 | - True when cache is up to date or a subset of current repo.""" | ||
try: | ||||
|
r18168 | return ((self.tipnode == repo.changelog.node(self.tiprev)) | ||
and (self.filteredhash == self._hashfiltered(repo))) | ||||
|
r18132 | except IndexError: | ||
return False | ||||
|
r18232 | def copy(self): | ||
"""return an deep copy of the branchcache object""" | ||||
return branchcache(self, self.tipnode, self.tiprev, self.filteredhash) | ||||
|
r18132 | |||
|
r18128 | def write(self, repo): | ||
try: | ||||
|
r18185 | f = repo.opener(_filename(repo), "w", atomictemp=True) | ||
|
r18184 | cachekey = [hex(self.tipnode), str(self.tiprev)] | ||
if self.filteredhash is not None: | ||||
cachekey.append(hex(self.filteredhash)) | ||||
f.write(" ".join(cachekey) + '\n') | ||||
|
r18357 | for label, nodes in sorted(self.iteritems()): | ||
|
r18128 | for node in nodes: | ||
f.write("%s %s\n" % (hex(node), encoding.fromlocal(label))) | ||||
f.close() | ||||
|
r18214 | except (IOError, OSError, util.Abort): | ||
# Abort may be raise by read only opener | ||||
|
r18128 | pass | ||
|
r18131 | |||
|
r18305 | def update(self, repo, revgen): | ||
|
r18131 | """Given a branchhead cache, self, that may have extra nodes or be | ||
missing heads, and a generator of nodes that are at least a superset of | ||||
heads missing, this function updates self to be correct. | ||||
""" | ||||
cl = repo.changelog | ||||
# collect new branch entries | ||||
newbranches = {} | ||||
|
r18307 | getbranch = cl.branch | ||
for r in revgen: | ||||
newbranches.setdefault(getbranch(r), []).append(cl.node(r)) | ||||
|
r18131 | # if older branchheads are reachable from new ones, they aren't | ||
# really branchheads. Note checking parents is insufficient: | ||||
# 1 (branch a) -> 2 (branch b) -> 3 (branch a) | ||||
for branch, newnodes in newbranches.iteritems(): | ||||
bheads = self.setdefault(branch, []) | ||||
# Remove candidate heads that no longer are in the repo (e.g., as | ||||
# the result of a strip that just happened). Avoid using 'node in | ||||
# self' here because that dives down into branchcache code somewhat | ||||
# recursively. | ||||
bheadrevs = [cl.rev(node) for node in bheads | ||||
if cl.hasnode(node)] | ||||
newheadrevs = [cl.rev(node) for node in newnodes | ||||
if cl.hasnode(node)] | ||||
ctxisnew = bheadrevs and min(newheadrevs) > max(bheadrevs) | ||||
# Remove duplicates - nodes that are in newheadrevs and are already | ||||
# in bheadrevs. This can happen if you strip a node whose parent | ||||
# was already a head (because they're on different branches). | ||||
bheadrevs = sorted(set(bheadrevs).union(newheadrevs)) | ||||
# Starting from tip means fewer passes over reachable. If we know | ||||
# the new candidates are not ancestors of existing heads, we don't | ||||
# have to examine ancestors of existing heads | ||||
if ctxisnew: | ||||
iterrevs = sorted(newheadrevs) | ||||
else: | ||||
iterrevs = list(bheadrevs) | ||||
# This loop prunes out two kinds of heads - heads that are | ||||
# superseded by a head in newheadrevs, and newheadrevs that are not | ||||
# heads because an existing head is their descendant. | ||||
while iterrevs: | ||||
latest = iterrevs.pop() | ||||
if latest not in bheadrevs: | ||||
continue | ||||
ancestors = set(cl.ancestors([latest], | ||||
bheadrevs[0])) | ||||
if ancestors: | ||||
bheadrevs = [b for b in bheadrevs if b not in ancestors] | ||||
self[branch] = [cl.node(rev) for rev in bheadrevs] | ||||
tiprev = max(bheadrevs) | ||||
if tiprev > self.tiprev: | ||||
self.tipnode = cl.node(tiprev) | ||||
self.tiprev = tiprev | ||||
|
r19838 | if not self.validfor(repo): | ||
|
r18131 | # cache key are not valid anymore | ||
self.tipnode = nullid | ||||
self.tiprev = nullrev | ||||
for heads in self.values(): | ||||
tiprev = max(cl.rev(node) for node in heads) | ||||
if tiprev > self.tiprev: | ||||
self.tipnode = cl.node(tiprev) | ||||
self.tiprev = tiprev | ||||
|
r18168 | self.filteredhash = self._hashfiltered(repo) | ||