branchmap.py
600 lines
| 22.5 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 | |||
|
r25918 | from __future__ import absolute_import | ||
import struct | ||||
from .node import ( | ||||
bin, | ||||
hex, | ||||
nullid, | ||||
nullrev, | ||||
) | ||||
from . import ( | ||||
encoding, | ||||
|
r26587 | error, | ||
|
r35849 | pycompat, | ||
|
r25918 | scmutil, | ||
|
r30975 | util, | ||
|
r25918 | ) | ||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r25918 | |||
calcsize = struct.calcsize | ||||
|
r31370 | pack_into = struct.pack_into | ||
unpack_from = struct.unpack_from | ||||
|
r18117 | |||
|
r18118 | |||
|
r20032 | ### Nearest subset relation | ||
# Nearest subset of filter X is a filter Y so that: | ||||
# * Y is included in X, | ||||
# * X - Y is as small as possible. | ||||
# This create and ordering used for branchmap purpose. | ||||
# the ordering may be partial | ||||
subsettable = {None: 'visible', | ||||
|
r35511 | 'visible-hidden': 'visible', | ||
|
r20032 | 'visible': 'served', | ||
'served': 'immutable', | ||||
'immutable': 'base'} | ||||
|
r41764 | |||
class BranchMapCache(object): | ||||
|
r41867 | """mapping of filtered views of repo with their branchcache""" | ||
|
r41764 | def __init__(self): | ||
self._per_filter = {} | ||||
|
r41708 | |||
|
r41764 | def __getitem__(self, repo): | ||
self.updatecache(repo) | ||||
return self._per_filter[repo.filtername] | ||||
def updatecache(self, repo): | ||||
"""Update the cache for the given filtered view on a repository""" | ||||
# This can trigger updates for the caches for subsets of the filtered | ||||
# view, e.g. when there is no cache for this filtered view or the cache | ||||
# is stale. | ||||
|
r18121 | |||
|
r41764 | cl = repo.changelog | ||
filtername = repo.filtername | ||||
bcache = self._per_filter.get(filtername) | ||||
if bcache is None or not bcache.validfor(repo): | ||||
# cache object missing or cache object stale? Read from disk | ||||
bcache = branchcache.fromfile(repo) | ||||
|
r41708 | |||
|
r41764 | revs = [] | ||
if bcache is None: | ||||
# no (fresh) cache available anymore, perhaps we can re-use | ||||
# the cache for a subset, then extend that to add info on missing | ||||
# revisions. | ||||
subsetname = subsettable.get(filtername) | ||||
if subsetname is not None: | ||||
subset = repo.filtered(subsetname) | ||||
bcache = self[subset].copy() | ||||
extrarevs = subset.changelog.filteredrevs - cl.filteredrevs | ||||
revs.extend(r for r in extrarevs if r <= bcache.tiprev) | ||||
else: | ||||
# nothing to fall back on, start empty. | ||||
bcache = branchcache() | ||||
|
r24373 | |||
|
r41764 | revs.extend(cl.revs(start=bcache.tiprev + 1)) | ||
if revs: | ||||
bcache.update(repo, revs) | ||||
|
r18124 | |||
|
r41764 | assert bcache.validfor(repo), filtername | ||
self._per_filter[repo.filtername] = bcache | ||||
def replace(self, repo, remotebranchmap): | ||||
"""Replace the branchmap cache for a repo with a branch mapping. | ||||
This is likely only called during clone with a branch map from a | ||||
remote. | ||||
|
r26460 | |||
|
r41764 | """ | ||
cl = repo.changelog | ||||
clrev = cl.rev | ||||
clbranchinfo = cl.branchinfo | ||||
rbheads = [] | ||||
closed = [] | ||||
for bheads in remotebranchmap.itervalues(): | ||||
rbheads += bheads | ||||
for h in bheads: | ||||
r = clrev(h) | ||||
b, c = clbranchinfo(r) | ||||
if c: | ||||
closed.append(h) | ||||
|
r26460 | |||
|
r41764 | if rbheads: | ||
rtiprev = max((int(clrev(node)) for node in rbheads)) | ||||
cache = branchcache( | ||||
remotebranchmap, repo[rtiprev].node(), rtiprev, | ||||
closednodes=closed) | ||||
|
r26460 | |||
|
r41764 | # Try to stick it as low as possible | ||
# filter above served are unlikely to be fetch from a clone | ||||
for candidate in ('base', 'immutable', 'served'): | ||||
rview = repo.filtered(candidate) | ||||
if cache.validfor(rview): | ||||
self._per_filter[candidate] = cache | ||||
cache.write(rview) | ||||
return | ||||
def clear(self): | ||||
self._per_filter.clear() | ||||
|
r26460 | |||
|
r18124 | class branchcache(dict): | ||
|
r20181 | """A dict like object that hold branches heads cache. | ||
This cache is used to avoid costly computations to determine all the | ||||
branch heads of a repo. | ||||
The cache is serialized on disk in the following format: | ||||
<tip hex node> <tip rev number> [optional filtered repo hex hash] | ||||
|
r20185 | <branch head hex node> <open/closed state> <branch name> | ||
<branch head hex node> <open/closed state> <branch name> | ||||
|
r20181 | ... | ||
The first line is used to check if the cache is still valid. If the | ||||
branch cache is for a filtered repo view, an optional third hash is | ||||
included that hashes the hashes of all filtered revisions. | ||||
|
r20185 | |||
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 | ||||
branch head closes a branch or not. | ||||
|
r20181 | """ | ||
|
r41826 | |||
def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev, | ||||
filteredhash=None, closednodes=None): | ||||
super(branchcache, self).__init__(entries) | ||||
self.tipnode = tipnode | ||||
self.tiprev = tiprev | ||||
self.filteredhash = filteredhash | ||||
# 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 | ||||
# heads. | ||||
if closednodes is None: | ||||
self._closednodes = set() | ||||
else: | ||||
self._closednodes = closednodes | ||||
|
r41706 | @classmethod | ||
def fromfile(cls, repo): | ||||
f = None | ||||
try: | ||||
f = repo.cachevfs(cls._filename(repo)) | ||||
lineiter = iter(f) | ||||
cachekey = next(lineiter).rstrip('\n').split(" ", 2) | ||||
last, lrev = cachekey[:2] | ||||
last, lrev = bin(last), int(lrev) | ||||
filteredhash = None | ||||
if len(cachekey) > 2: | ||||
filteredhash = bin(cachekey[2]) | ||||
bcache = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash) | ||||
if not bcache.validfor(repo): | ||||
# invalidate the cache | ||||
raise ValueError(r'tip differs') | ||||
|
r41959 | bcache.load(repo, f) | ||
|
r41706 | except (IOError, OSError): | ||
return None | ||||
except Exception as inst: | ||||
if repo.ui.debugflag: | ||||
msg = 'invalid branchheads cache' | ||||
if repo.filtername is not None: | ||||
msg += ' (%s)' % repo.filtername | ||||
msg += ': %s\n' | ||||
repo.ui.debug(msg % pycompat.bytestr(inst)) | ||||
bcache = None | ||||
finally: | ||||
if f: | ||||
f.close() | ||||
return bcache | ||||
|
r41959 | def load(self, repo, f): | ||
""" fully loads the branchcache by reading from the file f """ | ||||
cl = repo.changelog | ||||
lineiter = iter(f) | ||||
for line in lineiter: | ||||
line = line.rstrip('\n') | ||||
if not line: | ||||
continue | ||||
node, state, label = line.split(" ", 2) | ||||
if state not in 'oc': | ||||
raise ValueError(r'invalid branch state') | ||||
label = encoding.tolocal(label.strip()) | ||||
node = bin(node) | ||||
if not cl.hasnode(node): | ||||
raise ValueError( | ||||
r'node %s does not exist' % pycompat.sysstr(hex(node))) | ||||
self.setdefault(label, []).append(node) | ||||
if state == 'c': | ||||
self._closednodes.add(node) | ||||
|
r41706 | @staticmethod | ||
def _filename(repo): | ||||
"""name of a branchcache file for a given repo or repoview""" | ||||
filename = "branch2" | ||||
if repo.filtername: | ||||
filename = '%s-%s' % (filename, repo.filtername) | ||||
return filename | ||||
|
r18124 | |||
|
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)) | ||
|
r41925 | and (self.filteredhash == | ||
|
r24723 | scmutil.filteredhash(repo, self.tiprev))) | ||
|
r18132 | except IndexError: | ||
return False | ||||
|
r20186 | def _branchtip(self, heads): | ||
|
r20245 | '''Return tuple with last open head in heads and false, | ||
otherwise return last closed head and true.''' | ||||
|
r20186 | tip = heads[-1] | ||
closed = True | ||||
for h in reversed(heads): | ||||
if h not in self._closednodes: | ||||
tip = h | ||||
closed = False | ||||
break | ||||
return tip, closed | ||||
def branchtip(self, branch): | ||||
|
r20245 | '''Return the tipmost open head on branch head, otherwise return the | ||
tipmost closed head on branch. | ||||
Raise KeyError for unknown branch.''' | ||||
|
r20186 | return self._branchtip(self[branch])[0] | ||
|
r34076 | def iteropen(self, nodes): | ||
return (n for n in nodes if n not in self._closednodes) | ||||
|
r20188 | def branchheads(self, branch, closed=False): | ||
heads = self[branch] | ||||
if not closed: | ||||
|
r34076 | heads = list(self.iteropen(heads)) | ||
|
r20188 | return heads | ||
|
r20190 | def iterbranches(self): | ||
for bn, heads in self.iteritems(): | ||||
yield (bn, heads) + self._branchtip(heads) | ||||
|
r18232 | def copy(self): | ||
"""return an deep copy of the branchcache object""" | ||||
|
r41707 | return type(self)( | ||
self, self.tipnode, self.tiprev, self.filteredhash, | ||||
self._closednodes) | ||||
|
r18132 | |||
|
r18128 | def write(self, repo): | ||
try: | ||||
|
r41706 | f = repo.cachevfs(self._filename(repo), "w", atomictemp=True) | ||
|
r31348 | cachekey = [hex(self.tipnode), '%d' % self.tiprev] | ||
|
r18184 | if self.filteredhash is not None: | ||
cachekey.append(hex(self.filteredhash)) | ||||
f.write(" ".join(cachekey) + '\n') | ||||
|
r21031 | nodecount = 0 | ||
|
r18357 | for label, nodes in sorted(self.iteritems()): | ||
|
r41827 | label = encoding.fromlocal(label) | ||
|
r18128 | for node in nodes: | ||
|
r21031 | nodecount += 1 | ||
|
r20185 | if node in self._closednodes: | ||
state = 'c' | ||||
else: | ||||
state = 'o' | ||||
|
r41827 | f.write("%s %s %s\n" % (hex(node), state, label)) | ||
|
r18128 | f.close() | ||
|
r21031 | repo.ui.log('branchcache', | ||
'wrote %s branch cache with %d labels and %d nodes\n', | ||||
repo.filtername, len(self), nodecount) | ||||
|
r26587 | except (IOError, OSError, error.Abort) as inst: | ||
|
r34369 | # Abort may be raised by read only opener, so log and continue | ||
|
r36414 | repo.ui.debug("couldn't write branch cache: %s\n" % | ||
|
r37102 | stringutil.forcebytestr(inst)) | ||
|
r18131 | |||
|
r18305 | def update(self, repo, revgen): | ||
|
r18131 | """Given a branchhead cache, self, that may have extra nodes or be | ||
|
r20263 | missing heads, and a generator of nodes that are strictly a superset of | ||
|
r18131 | heads missing, this function updates self to be correct. | ||
""" | ||||
|
r30975 | starttime = util.timer() | ||
|
r18131 | cl = repo.changelog | ||
# collect new branch entries | ||||
newbranches = {} | ||||
|
r24373 | getbranchinfo = repo.revbranchcache().branchinfo | ||
|
r18307 | for r in revgen: | ||
|
r40455 | branch, closesbranch = getbranchinfo(r) | ||
|
r20262 | newbranches.setdefault(branch, []).append(r) | ||
|
r20185 | if closesbranch: | ||
|
r20262 | self._closednodes.add(cl.node(r)) | ||
|
r22357 | |||
# fetch current topological heads to speed up filtering | ||||
topoheads = set(cl.headrevs()) | ||||
|
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) | ||||
|
r20262 | for branch, newheadrevs in newbranches.iteritems(): | ||
|
r18131 | bheads = self.setdefault(branch, []) | ||
|
r20264 | bheadset = set(cl.rev(node) for node in bheads) | ||
|
r18131 | |||
|
r20263 | # This have been tested True on all internal usage of this function. | ||
# run it again in case of doubt | ||||
# assert not (set(bheadrevs) & set(newheadrevs)) | ||||
|
r20264 | bheadset.update(newheadrevs) | ||
|
r18131 | |||
|
r22356 | # This 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. | ||||
|
r22357 | uncertain = bheadset - topoheads | ||
if uncertain: | ||||
floorrev = min(uncertain) | ||||
ancestors = set(cl.ancestors(newheadrevs, floorrev)) | ||||
bheadset -= ancestors | ||||
|
r20264 | bheadrevs = sorted(bheadset) | ||
|
r18131 | self[branch] = [cl.node(rev) for rev in bheadrevs] | ||
|
r20263 | tiprev = bheadrevs[-1] | ||
|
r18131 | 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 | ||||
|
r24723 | self.filteredhash = scmutil.filteredhash(repo, self.tiprev) | ||
|
r21031 | |||
|
r30975 | duration = util.timer() - starttime | ||
|
r21031 | repo.ui.log('branchcache', 'updated %s branch cache in %.4f seconds\n', | ||
repo.filtername, duration) | ||||
|
r23785 | |||
|
r41707 | self.write(repo) | ||
class remotebranchcache(branchcache): | ||||
"""Branchmap info for a remote connection, should not write locally""" | ||||
def write(self, repo): | ||||
pass | ||||
|
r23785 | # Revision branch info cache | ||
_rbcversion = '-v1' | ||||
|
r33535 | _rbcnames = 'rbc-names' + _rbcversion | ||
_rbcrevs = 'rbc-revs' + _rbcversion | ||||
|
r23785 | # [4 byte hash prefix][4 byte branch name number with sign bit indicating open] | ||
_rbcrecfmt = '>4sI' | ||||
_rbcrecsize = calcsize(_rbcrecfmt) | ||||
_rbcnodelen = 4 | ||||
_rbcbranchidxmask = 0x7fffffff | ||||
_rbccloseflag = 0x80000000 | ||||
class revbranchcache(object): | ||||
"""Persistent cache, mapping from revision number to branch name and close. | ||||
This is a low level cache, independent of filtering. | ||||
Branch names are stored in rbc-names in internal encoding separated by 0. | ||||
rbc-names is append-only, and each branch name is only stored once and will | ||||
thus have a unique index. | ||||
The branch info for each revision is stored in rbc-revs as constant size | ||||
records. The whole file is read into memory, but it is only 'parsed' on | ||||
demand. The file is usually append-only but will be truncated if repo | ||||
modification is detected. | ||||
The record for each revision contains the first 4 bytes of the | ||||
corresponding node hash, and the record is only used if it still matches. | ||||
Even a completely trashed rbc-revs fill thus still give the right result | ||||
while converging towards full recovery ... assuming no incorrectly matching | ||||
node hashes. | ||||
The record also contains 4 bytes where 31 bits contains the index of the | ||||
branch and the last bit indicate that it is a branch close commit. | ||||
The usage pattern for rbc-revs is thus somewhat similar to 00changelog.i | ||||
and will grow with it but be 1/8th of its size. | ||||
""" | ||||
|
r24159 | def __init__(self, repo, readonly=True): | ||
|
r23785 | assert repo.filtername is None | ||
|
r24374 | self._repo = repo | ||
|
r23785 | self._names = [] # branch names in local encoding with static index | ||
|
r31346 | self._rbcrevs = bytearray() | ||
|
r29615 | self._rbcsnameslen = 0 # length of names read at _rbcsnameslen | ||
|
r23785 | try: | ||
|
r33535 | bndata = repo.cachevfs.read(_rbcnames) | ||
|
r23785 | self._rbcsnameslen = len(bndata) # for verification before writing | ||
|
r31371 | if bndata: | ||
self._names = [encoding.tolocal(bn) | ||||
for bn in bndata.split('\0')] | ||||
|
r29423 | except (IOError, OSError): | ||
|
r24159 | if readonly: | ||
# don't try to use cache - fall back to the slow path | ||||
self.branchinfo = self._branchinfo | ||||
|
r23785 | if self._names: | ||
try: | ||||
|
r33535 | data = repo.cachevfs.read(_rbcrevs) | ||
|
r31346 | self._rbcrevs[:] = data | ||
|
r25660 | except (IOError, OSError) as inst: | ||
|
r23785 | repo.ui.debug("couldn't read revision branch cache: %s\n" % | ||
|
r37102 | stringutil.forcebytestr(inst)) | ||
|
r23785 | # remember number of good records on disk | ||
self._rbcrevslen = min(len(self._rbcrevs) // _rbcrecsize, | ||||
len(repo.changelog)) | ||||
if self._rbcrevslen == 0: | ||||
self._names = [] | ||||
|
r29615 | self._rbcnamescount = len(self._names) # number of names read at | ||
# _rbcsnameslen | ||||
|
r23785 | |||
|
r28558 | def _clear(self): | ||
self._rbcsnameslen = 0 | ||||
del self._names[:] | ||||
self._rbcnamescount = 0 | ||||
self._rbcrevslen = len(self._repo.changelog) | ||||
|
r31346 | self._rbcrevs = bytearray(self._rbcrevslen * _rbcrecsize) | ||
|
r40746 | util.clearcachedproperty(self, '_namesreverse') | ||
@util.propertycache | ||||
def _namesreverse(self): | ||||
return dict((b, r) for r, b in enumerate(self._names)) | ||||
|
r28558 | |||
|
r40455 | def branchinfo(self, rev): | ||
|
r23785 | """Return branch name and close flag for rev, using and updating | ||
persistent cache.""" | ||||
|
r40455 | changelog = self._repo.changelog | ||
|
r23785 | rbcrevidx = rev * _rbcrecsize | ||
|
r25266 | # avoid negative index, changelog.read(nullrev) is fast without cache | ||
if rev == nullrev: | ||||
return changelog.branchinfo(rev) | ||||
|
r29604 | # if requested rev isn't allocated, grow and cache the rev info | ||
|
r23785 | if len(self._rbcrevs) < rbcrevidx + _rbcrecsize: | ||
|
r40455 | return self._branchinfo(rev) | ||
|
r23785 | |||
# fast path: extract data from cache, use it if node is matching | ||||
reponode = changelog.node(rev)[:_rbcnodelen] | ||||
|
r33737 | cachenode, branchidx = unpack_from( | ||
_rbcrecfmt, util.buffer(self._rbcrevs), rbcrevidx) | ||||
|
r23785 | close = bool(branchidx & _rbccloseflag) | ||
if close: | ||||
branchidx &= _rbcbranchidxmask | ||||
|
r24376 | if cachenode == '\0\0\0\0': | ||
pass | ||||
elif cachenode == reponode: | ||||
|
r29615 | try: | ||
|
r28558 | return self._names[branchidx], close | ||
|
r29615 | except IndexError: | ||
# recover from invalid reference to unknown branch | ||||
self._repo.ui.debug("referenced branch names not found" | ||||
" - rebuilding revision branch cache from scratch\n") | ||||
self._clear() | ||||
|
r24376 | else: | ||
# rev/node map has changed, invalidate the cache from here up | ||||
|
r29615 | self._repo.ui.debug("history modification detected - truncating " | ||
|
r31497 | "revision branch cache to revision %d\n" % rev) | ||
|
r24376 | truncate = rbcrevidx + _rbcrecsize | ||
del self._rbcrevs[truncate:] | ||||
self._rbcrevslen = min(self._rbcrevslen, truncate) | ||||
|
r23785 | # fall back to slow path and make sure it will be written to disk | ||
|
r40455 | return self._branchinfo(rev) | ||
|
r23785 | |||
|
r40455 | def _branchinfo(self, rev): | ||
|
r23785 | """Retrieve branch info from changelog and update _rbcrevs""" | ||
|
r40455 | changelog = self._repo.changelog | ||
|
r23785 | b, close = changelog.branchinfo(rev) | ||
if b in self._namesreverse: | ||||
branchidx = self._namesreverse[b] | ||||
else: | ||||
branchidx = len(self._names) | ||||
self._names.append(b) | ||||
self._namesreverse[b] = branchidx | ||||
reponode = changelog.node(rev) | ||||
if close: | ||||
branchidx |= _rbccloseflag | ||||
|
r40455 | self._setcachedata(rev, reponode, branchidx) | ||
|
r24375 | return b, close | ||
|
r36980 | def setdata(self, branch, rev, node, close): | ||
"""add new data information to the cache""" | ||||
if branch in self._namesreverse: | ||||
branchidx = self._namesreverse[branch] | ||||
else: | ||||
branchidx = len(self._names) | ||||
self._names.append(branch) | ||||
self._namesreverse[branch] = branchidx | ||||
if close: | ||||
branchidx |= _rbccloseflag | ||||
self._setcachedata(rev, node, branchidx) | ||||
# If no cache data were readable (non exists, bad permission, etc) | ||||
# the cache was bypassing itself by setting: | ||||
# | ||||
# self.branchinfo = self._branchinfo | ||||
# | ||||
# Since we now have data in the cache, we need to drop this bypassing. | ||||
|
r40268 | if r'branchinfo' in vars(self): | ||
|
r36980 | del self.branchinfo | ||
|
r40455 | def _setcachedata(self, rev, node, branchidx): | ||
|
r24375 | """Writes the node's branch data to the in-memory cache data.""" | ||
|
r31454 | if rev == nullrev: | ||
return | ||||
|
r23785 | rbcrevidx = rev * _rbcrecsize | ||
|
r29604 | if len(self._rbcrevs) < rbcrevidx + _rbcrecsize: | ||
self._rbcrevs.extend('\0' * | ||||
|
r40455 | (len(self._repo.changelog) * _rbcrecsize - | ||
|
r29604 | len(self._rbcrevs))) | ||
|
r31370 | pack_into(_rbcrecfmt, self._rbcrevs, rbcrevidx, node, branchidx) | ||
|
r24376 | self._rbcrevslen = min(self._rbcrevslen, rev) | ||
|
r23785 | |||
|
r24377 | tr = self._repo.currenttransaction() | ||
if tr: | ||||
tr.addfinalize('write-revbranchcache', self.write) | ||||
def write(self, tr=None): | ||||
|
r23785 | """Save branch cache if it is dirty.""" | ||
|
r24374 | repo = self._repo | ||
|
r29744 | wlock = None | ||
|
r29745 | step = '' | ||
|
r29744 | try: | ||
|
r29743 | if self._rbcnamescount < len(self._names): | ||
|
r29745 | step = ' names' | ||
|
r29744 | wlock = repo.wlock(wait=False) | ||
|
r29746 | if self._rbcnamescount != 0: | ||
|
r33535 | f = repo.cachevfs.open(_rbcnames, 'ab') | ||
|
r29746 | if f.tell() == self._rbcsnameslen: | ||
f.write('\0') | ||||
else: | ||||
f.close() | ||||
repo.ui.debug("%s changed - rewriting it\n" % _rbcnames) | ||||
self._rbcnamescount = 0 | ||||
self._rbcrevslen = 0 | ||||
if self._rbcnamescount == 0: | ||||
# before rewriting names, make sure references are removed | ||||
|
r33535 | repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True) | ||
f = repo.cachevfs.open(_rbcnames, 'wb') | ||||
|
r29746 | f.write('\0'.join(encoding.fromlocal(b) | ||
for b in self._names[self._rbcnamescount:])) | ||||
self._rbcsnameslen = f.tell() | ||||
f.close() | ||||
|
r29743 | self._rbcnamescount = len(self._names) | ||
|
r23785 | |||
|
r29743 | start = self._rbcrevslen * _rbcrecsize | ||
if start != len(self._rbcrevs): | ||||
|
r29745 | step = '' | ||
|
r29744 | if wlock is None: | ||
wlock = repo.wlock(wait=False) | ||||
|
r29743 | revs = min(len(repo.changelog), | ||
len(self._rbcrevs) // _rbcrecsize) | ||||
|
r33535 | f = repo.cachevfs.open(_rbcrevs, 'ab') | ||
|
r29746 | if f.tell() != start: | ||
|
r33535 | repo.ui.debug("truncating cache/%s to %d\n" | ||
% (_rbcrevs, start)) | ||||
|
r29746 | f.seek(start) | ||
|
r28557 | if f.tell() != start: | ||
|
r29746 | start = 0 | ||
|
r28557 | f.seek(start) | ||
|
r29746 | f.truncate() | ||
end = revs * _rbcrecsize | ||||
f.write(self._rbcrevs[start:end]) | ||||
f.close() | ||||
|
r29743 | self._rbcrevslen = revs | ||
|
r29745 | except (IOError, OSError, error.Abort, error.LockError) as inst: | ||
repo.ui.debug("couldn't write revision branch cache%s: %s\n" | ||||
|
r37102 | % (step, stringutil.forcebytestr(inst))) | ||
|
r29744 | finally: | ||
if wlock is not None: | ||||
wlock.release() | ||||