manifest.py
2055 lines
| 67.6 KiB
| text/x-python
|
PythonLexer
/ mercurial / manifest.py
|
r1089 | # manifest.py - manifest revision class for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r1089 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r1089 | |||
|
r27502 | from __future__ import absolute_import | ||
import heapq | ||||
|
r32536 | import itertools | ||
|
r27502 | import struct | ||
|
r38803 | import weakref | ||
|
r27502 | |||
from .i18n import _ | ||||
|
r31530 | from .node import ( | ||
bin, | ||||
hex, | ||||
|
r39352 | nullid, | ||
nullrev, | ||||
|
r31530 | ) | ||
|
r27502 | from . import ( | ||
error, | ||||
mdiff, | ||||
|
r32372 | policy, | ||
|
r38353 | pycompat, | ||
|
r38549 | repository, | ||
|
r27502 | revlog, | ||
util, | ||||
) | ||||
|
r38549 | from .utils import ( | ||
interfaceutil, | ||||
) | ||||
|
r1089 | |||
|
r32372 | parsers = policy.importmod(r'parsers') | ||
|
r24322 | propertycache = util.propertycache | ||
|
r24225 | |||
|
r36391 | def _parse(data): | ||
|
r24524 | # This method does a little bit of excessive-looking | ||
# precondition checking. This is so that the behavior of this | ||||
# class exactly matches its C counterpart to try and help | ||||
# prevent surprise breakage for anyone that develops against | ||||
# the pure version. | ||||
|
r32535 | if data and data[-1:] != '\n': | ||
|
r24524 | raise ValueError('Manifest did not end in a newline.') | ||
prev = None | ||||
for l in data.splitlines(): | ||||
if prev is not None and prev > l: | ||||
raise ValueError('Manifest lines not in sorted order.') | ||||
prev = l | ||||
f, n = l.split('\0') | ||||
if len(n) > 40: | ||||
|
r31366 | yield f, bin(n[:40]), n[40:] | ||
|
r24524 | else: | ||
|
r31366 | yield f, bin(n), '' | ||
|
r24524 | |||
|
r36391 | def _text(it): | ||
|
r24525 | files = [] | ||
lines = [] | ||||
for f, n, fl in it: | ||||
files.append(f) | ||||
# if this is changed to support newlines in filenames, | ||||
# be sure to check the templates/ dir again (especially *-raw.tmpl) | ||||
|
r39352 | lines.append("%s\0%s%s\n" % (f, hex(n), fl)) | ||
|
r24525 | |||
_checkforbidden(files) | ||||
return ''.join(lines) | ||||
|
r30042 | class lazymanifestiter(object): | ||
def __init__(self, lm): | ||||
self.pos = 0 | ||||
self.lm = lm | ||||
|
r24225 | |||
|
r30042 | def __iter__(self): | ||
return self | ||||
|
r24223 | |||
|
r30042 | def next(self): | ||
try: | ||||
data, pos = self.lm._get(self.pos) | ||||
except IndexError: | ||||
raise StopIteration | ||||
if pos == -1: | ||||
self.pos += 1 | ||||
return data[0] | ||||
self.pos += 1 | ||||
zeropos = data.find('\x00', pos) | ||||
return data[pos:zeropos] | ||||
|
r24224 | |||
|
r31364 | __next__ = next | ||
|
r30042 | class lazymanifestiterentries(object): | ||
def __init__(self, lm): | ||||
self.lm = lm | ||||
self.pos = 0 | ||||
|
r24225 | |||
def __iter__(self): | ||||
|
r30042 | return self | ||
def next(self): | ||||
try: | ||||
data, pos = self.lm._get(self.pos) | ||||
except IndexError: | ||||
raise StopIteration | ||||
if pos == -1: | ||||
self.pos += 1 | ||||
return data | ||||
zeropos = data.find('\x00', pos) | ||||
hashval = unhexlify(data, self.lm.extrainfo[self.pos], | ||||
zeropos + 1, 40) | ||||
flags = self.lm._getflags(data, self.pos, zeropos) | ||||
self.pos += 1 | ||||
return (data[pos:zeropos], hashval, flags) | ||||
|
r31364 | __next__ = next | ||
|
r30042 | def unhexlify(data, extra, pos, length): | ||
|
r31365 | s = bin(data[pos:pos + length]) | ||
|
r30042 | if extra: | ||
s += chr(extra & 0xff) | ||||
return s | ||||
def _cmp(a, b): | ||||
return (a > b) - (a < b) | ||||
class _lazymanifest(object): | ||||
def __init__(self, data, positions=None, extrainfo=None, extradata=None): | ||||
if positions is None: | ||||
self.positions = self.findlines(data) | ||||
self.extrainfo = [0] * len(self.positions) | ||||
self.data = data | ||||
self.extradata = [] | ||||
else: | ||||
self.positions = positions[:] | ||||
self.extrainfo = extrainfo[:] | ||||
self.extradata = extradata[:] | ||||
self.data = data | ||||
def findlines(self, data): | ||||
if not data: | ||||
return [] | ||||
pos = data.find("\n") | ||||
|
r31352 | if pos == -1 or data[-1:] != '\n': | ||
|
r30042 | raise ValueError("Manifest did not end in a newline.") | ||
positions = [0] | ||||
prev = data[:data.find('\x00')] | ||||
while pos < len(data) - 1 and pos != -1: | ||||
positions.append(pos + 1) | ||||
nexts = data[pos + 1:data.find('\x00', pos + 1)] | ||||
if nexts < prev: | ||||
raise ValueError("Manifest lines not in sorted order.") | ||||
prev = nexts | ||||
pos = data.find("\n", pos + 1) | ||||
return positions | ||||
def _get(self, index): | ||||
# get the position encoded in pos: | ||||
# positive number is an index in 'data' | ||||
# negative number is in extrapieces | ||||
pos = self.positions[index] | ||||
if pos >= 0: | ||||
return self.data, pos | ||||
return self.extradata[-pos - 1], -1 | ||||
def _getkey(self, pos): | ||||
if pos >= 0: | ||||
return self.data[pos:self.data.find('\x00', pos + 1)] | ||||
return self.extradata[-pos - 1][0] | ||||
def bsearch(self, key): | ||||
first = 0 | ||||
last = len(self.positions) - 1 | ||||
while first <= last: | ||||
midpoint = (first + last)//2 | ||||
nextpos = self.positions[midpoint] | ||||
candidate = self._getkey(nextpos) | ||||
r = _cmp(key, candidate) | ||||
if r == 0: | ||||
return midpoint | ||||
else: | ||||
if r < 0: | ||||
last = midpoint - 1 | ||||
else: | ||||
first = midpoint + 1 | ||||
return -1 | ||||
|
r24225 | |||
|
r30042 | def bsearch2(self, key): | ||
# same as the above, but will always return the position | ||||
# done for performance reasons | ||||
first = 0 | ||||
last = len(self.positions) - 1 | ||||
while first <= last: | ||||
midpoint = (first + last)//2 | ||||
nextpos = self.positions[midpoint] | ||||
candidate = self._getkey(nextpos) | ||||
r = _cmp(key, candidate) | ||||
if r == 0: | ||||
return (midpoint, True) | ||||
else: | ||||
if r < 0: | ||||
last = midpoint - 1 | ||||
else: | ||||
first = midpoint + 1 | ||||
return (first, False) | ||||
def __contains__(self, key): | ||||
return self.bsearch(key) != -1 | ||||
def _getflags(self, data, needle, pos): | ||||
start = pos + 41 | ||||
end = data.find("\n", start) | ||||
if end == -1: | ||||
end = len(data) - 1 | ||||
if start == end: | ||||
return '' | ||||
return self.data[start:end] | ||||
|
r24297 | |||
|
r30042 | def __getitem__(self, key): | ||
|
r31367 | if not isinstance(key, bytes): | ||
raise TypeError("getitem: manifest keys must be a bytes.") | ||||
|
r30042 | needle = self.bsearch(key) | ||
if needle == -1: | ||||
raise KeyError | ||||
data, pos = self._get(needle) | ||||
if pos == -1: | ||||
return (data[1], data[2]) | ||||
zeropos = data.find('\x00', pos) | ||||
assert 0 <= needle <= len(self.positions) | ||||
assert len(self.extrainfo) == len(self.positions) | ||||
hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, 40) | ||||
flags = self._getflags(data, needle, zeropos) | ||||
return (hashval, flags) | ||||
def __delitem__(self, key): | ||||
needle, found = self.bsearch2(key) | ||||
if not found: | ||||
raise KeyError | ||||
cur = self.positions[needle] | ||||
self.positions = self.positions[:needle] + self.positions[needle + 1:] | ||||
self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1:] | ||||
if cur >= 0: | ||||
self.data = self.data[:cur] + '\x00' + self.data[cur + 1:] | ||||
def __setitem__(self, key, value): | ||||
|
r31531 | if not isinstance(key, bytes): | ||
raise TypeError("setitem: manifest keys must be a byte string.") | ||||
|
r30042 | if not isinstance(value, tuple) or len(value) != 2: | ||
raise TypeError("Manifest values must be a tuple of (node, flags).") | ||||
hashval = value[0] | ||||
|
r31531 | if not isinstance(hashval, bytes) or not 20 <= len(hashval) <= 22: | ||
raise TypeError("node must be a 20-byte byte string") | ||||
|
r30042 | flags = value[1] | ||
if len(hashval) == 22: | ||||
hashval = hashval[:-1] | ||||
|
r31531 | if not isinstance(flags, bytes) or len(flags) > 1: | ||
|
r30042 | raise TypeError("flags must a 0 or 1 byte string, got %r", flags) | ||
needle, found = self.bsearch2(key) | ||||
if found: | ||||
# put the item | ||||
pos = self.positions[needle] | ||||
if pos < 0: | ||||
self.extradata[-pos - 1] = (key, hashval, value[1]) | ||||
else: | ||||
# just don't bother | ||||
self.extradata.append((key, hashval, value[1])) | ||||
self.positions[needle] = -len(self.extradata) | ||||
else: | ||||
# not found, put it in with extra positions | ||||
self.extradata.append((key, hashval, value[1])) | ||||
self.positions = (self.positions[:needle] + [-len(self.extradata)] | ||||
+ self.positions[needle:]) | ||||
self.extrainfo = (self.extrainfo[:needle] + [0] + | ||||
self.extrainfo[needle:]) | ||||
|
r24298 | |||
|
r2831 | def copy(self): | ||
|
r30042 | # XXX call _compact like in C? | ||
return _lazymanifest(self.data, self.positions, self.extrainfo, | ||||
self.extradata) | ||||
def _compact(self): | ||||
# hopefully not called TOO often | ||||
if len(self.extradata) == 0: | ||||
return | ||||
l = [] | ||||
i = 0 | ||||
offset = 0 | ||||
self.extrainfo = [0] * len(self.positions) | ||||
while i < len(self.positions): | ||||
if self.positions[i] >= 0: | ||||
cur = self.positions[i] | ||||
last_cut = cur | ||||
while True: | ||||
self.positions[i] = offset | ||||
i += 1 | ||||
if i == len(self.positions) or self.positions[i] < 0: | ||||
break | ||||
offset += self.positions[i] - cur | ||||
cur = self.positions[i] | ||||
end_cut = self.data.find('\n', cur) | ||||
if end_cut != -1: | ||||
end_cut += 1 | ||||
offset += end_cut - cur | ||||
l.append(self.data[last_cut:end_cut]) | ||||
else: | ||||
while i < len(self.positions) and self.positions[i] < 0: | ||||
cur = self.positions[i] | ||||
t = self.extradata[-cur - 1] | ||||
l.append(self._pack(t)) | ||||
self.positions[i] = offset | ||||
if len(t[1]) > 20: | ||||
self.extrainfo[i] = ord(t[1][21]) | ||||
offset += len(l[-1]) | ||||
i += 1 | ||||
self.data = ''.join(l) | ||||
self.extradata = [] | ||||
def _pack(self, d): | ||||
|
r31530 | return d[0] + '\x00' + hex(d[1][:20]) + d[2] + '\n' | ||
|
r30042 | |||
def text(self): | ||||
self._compact() | ||||
return self.data | ||||
|
r24225 | |||
def diff(self, m2, clean=False): | ||||
'''Finds changes between the current manifest and m2.''' | ||||
|
r30042 | # XXX think whether efficiency matters here | ||
|
r24225 | diff = {} | ||
|
r30042 | for fn, e1, flags in self.iterentries(): | ||
|
r24225 | if fn not in m2: | ||
|
r30042 | diff[fn] = (e1, flags), (None, '') | ||
|
r24225 | else: | ||
e2 = m2[fn] | ||||
|
r30042 | if (e1, flags) != e2: | ||
diff[fn] = (e1, flags), e2 | ||||
|
r24225 | elif clean: | ||
diff[fn] = None | ||||
|
r30042 | for fn, e2, flags in m2.iterentries(): | ||
|
r24225 | if fn not in self: | ||
|
r30042 | diff[fn] = (None, ''), (e2, flags) | ||
|
r24225 | |||
return diff | ||||
|
r30042 | def iterentries(self): | ||
return lazymanifestiterentries(self) | ||||
def iterkeys(self): | ||||
return lazymanifestiter(self) | ||||
def __iter__(self): | ||||
return lazymanifestiter(self) | ||||
def __len__(self): | ||||
return len(self.positions) | ||||
|
r24225 | def filtercopy(self, filterfn): | ||
|
r30042 | # XXX should be optimized | ||
|
r24225 | c = _lazymanifest('') | ||
|
r24298 | for f, n, fl in self.iterentries(): | ||
|
r24225 | if filterfn(f): | ||
c[f] = n, fl | ||||
return c | ||||
|
r24226 | try: | ||
_lazymanifest = parsers.lazymanifest | ||||
except AttributeError: | ||||
pass | ||||
|
r38549 | @interfaceutil.implementer(repository.imanifestdict) | ||
|
r24225 | class manifestdict(object): | ||
def __init__(self, data=''): | ||||
|
r36391 | self._lm = _lazymanifest(data) | ||
|
r24225 | |||
def __getitem__(self, key): | ||||
return self._lm[key][0] | ||||
|
r24277 | def find(self, key): | ||
return self._lm[key] | ||||
|
r24225 | def __len__(self): | ||
return len(self._lm) | ||||
|
r30331 | def __nonzero__(self): | ||
# nonzero is covered by the __len__ function, but implementing it here | ||||
# makes it easier for extensions to override. | ||||
return len(self._lm) != 0 | ||||
|
r31476 | __bool__ = __nonzero__ | ||
|
r24225 | def __setitem__(self, key, node): | ||
self._lm[key] = node, self.flags(key, '') | ||||
def __contains__(self, key): | ||||
|
r34347 | if key is None: | ||
return False | ||||
|
r24225 | return key in self._lm | ||
def __delitem__(self, key): | ||||
del self._lm[key] | ||||
|
r24295 | def __iter__(self): | ||
|
r24298 | return self._lm.__iter__() | ||
|
r24225 | |||
def iterkeys(self): | ||||
|
r24295 | return self._lm.iterkeys() | ||
def keys(self): | ||||
return list(self.iterkeys()) | ||||
|
r24225 | |||
|
r31255 | def filesnotin(self, m2, match=None): | ||
|
r24184 | '''Set of files in this manifest that are not in the other''' | ||
|
r31255 | if match: | ||
m1 = self.matches(match) | ||||
m2 = m2.matches(match) | ||||
return m1.filesnotin(m2) | ||||
|
r29056 | diff = self.diff(m2) | ||
files = set(filepath | ||||
for filepath, hashflags in diff.iteritems() | ||||
if hashflags[1][0] is None) | ||||
|
r24184 | return files | ||
|
r24322 | @propertycache | ||
def _dirs(self): | ||||
|
r24635 | return util.dirs(self) | ||
|
r24322 | |||
def dirs(self): | ||||
return self._dirs | ||||
|
r24324 | def hasdir(self, dir): | ||
return dir in self._dirs | ||||
|
r24685 | def _filesfastpath(self, match): | ||
'''Checks whether we can correctly and quickly iterate over matcher | ||||
files instead of over manifest files.''' | ||||
files = match.files() | ||||
return (len(files) < 100 and (match.isexact() or | ||||
|
r25276 | (match.prefix() and all(fn in self for fn in files)))) | ||
|
r24685 | |||
|
r24646 | def walk(self, match): | ||
'''Generates matching file names. | ||||
Equivalent to manifest.matches(match).iterkeys(), but without creating | ||||
an entirely new manifest. | ||||
It also reports nonexistent files by marking them bad with match.bad(). | ||||
''' | ||||
|
r24683 | if match.always(): | ||
for f in iter(self): | ||||
yield f | ||||
return | ||||
|
r24646 | fset = set(match.files()) | ||
# avoid the entire walk if we're only looking for specific files | ||||
|
r24685 | if self._filesfastpath(match): | ||
|
r24667 | for fn in sorted(fset): | ||
yield fn | ||||
|
r24682 | return | ||
|
r24646 | |||
for fn in self: | ||||
if fn in fset: | ||||
# specified pattern is the exact name | ||||
fset.remove(fn) | ||||
if match(fn): | ||||
yield fn | ||||
# for dirstate.walk, files=['.'] means "walk the whole tree". | ||||
# follow that here, too | ||||
fset.discard('.') | ||||
for fn in sorted(fset): | ||||
if not self.hasdir(fn): | ||||
match.bad(fn, None) | ||||
|
r23305 | def matches(self, match): | ||
'''generate a new manifest filtered by the match argument''' | ||||
if match.always(): | ||||
return self.copy() | ||||
|
r24685 | if self._filesfastpath(match): | ||
|
r24666 | m = manifestdict() | ||
lm = self._lm | ||||
for fn in match.files(): | ||||
if fn in lm: | ||||
m._lm[fn] = lm[fn] | ||||
return m | ||||
|
r23305 | |||
|
r24700 | m = manifestdict() | ||
|
r24664 | m._lm = self._lm.filtercopy(match) | ||
return m | ||||
|
r23305 | |||
|
r31255 | def diff(self, m2, match=None, clean=False): | ||
|
r23756 | '''Finds changes between the current manifest and m2. | ||
Args: | ||||
m2: the manifest to which this manifest should be compared. | ||||
clean: if true, include files unchanged between these manifests | ||||
with a None value in the returned dictionary. | ||||
The result is returned as a dict with filename as key and | ||||
values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the | ||||
nodeid in the current/other manifest and fl1/fl2 is the flag | ||||
in the current/other manifest. Where the file does not exist, | ||||
the nodeid will be None and the flags will be the empty | ||||
string. | ||||
''' | ||||
|
r31255 | if match: | ||
m1 = self.matches(match) | ||||
m2 = m2.matches(match) | ||||
return m1.diff(m2, clean=clean) | ||||
|
r24225 | return self._lm.diff(m2._lm, clean) | ||
def setflag(self, key, flag): | ||||
self._lm[key] = self[key], flag | ||||
def get(self, key, default=None): | ||||
try: | ||||
return self._lm[key][0] | ||||
except KeyError: | ||||
return default | ||||
|
r22965 | |||
|
r24225 | def flags(self, key, default=''): | ||
try: | ||||
return self._lm[key][1] | ||||
except KeyError: | ||||
return default | ||||
|
r22965 | |||
|
r24225 | def copy(self): | ||
|
r24700 | c = manifestdict() | ||
|
r24225 | c._lm = self._lm.copy() | ||
return c | ||||
|
r32550 | def items(self): | ||
|
r24298 | return (x[:2] for x in self._lm.iterentries()) | ||
|
r2831 | |||
|
r38679 | def iteritems(self): | ||
return (x[:2] for x in self._lm.iterentries()) | ||||
|
r32550 | |||
|
r28203 | def iterentries(self): | ||
return self._lm.iterentries() | ||||
|
r36391 | def text(self): | ||
# most likely uses native version | ||||
return self._lm.text() | ||||
|
r22408 | |||
|
r22931 | def fastdelta(self, base, changes): | ||
|
r31787 | """Given a base manifest text as a bytearray and a list of changes | ||
|
r22931 | relative to that text, compute a delta that can be used by revlog. | ||
""" | ||||
delta = [] | ||||
dstart = None | ||||
dend = None | ||||
dline = [""] | ||||
start = 0 | ||||
# zero copy representation of base as a buffer | ||||
addbuf = util.buffer(base) | ||||
|
r26871 | changes = list(changes) | ||
if len(changes) < 1000: | ||||
# start with a readonly loop that finds the offset of | ||||
# each line and creates the deltas | ||||
for f, todelete in changes: | ||||
# bs will either be the index of the item or the insert point | ||||
start, end = _msearch(addbuf, f, start) | ||||
if not todelete: | ||||
h, fl = self._lm[f] | ||||
|
r39352 | l = "%s\0%s%s\n" % (f, hex(h), fl) | ||
|
r26871 | else: | ||
if start == end: | ||||
# item we want to delete was not found, error out | ||||
raise AssertionError( | ||||
_("failed to remove %s from manifest") % f) | ||||
l = "" | ||||
if dstart is not None and dstart <= start and dend >= start: | ||||
if dend < end: | ||||
dend = end | ||||
if l: | ||||
dline.append(l) | ||||
else: | ||||
if dstart is not None: | ||||
delta.append([dstart, dend, "".join(dline)]) | ||||
dstart = start | ||||
|
r22931 | dend = end | ||
|
r26871 | dline = [l] | ||
|
r22931 | |||
|
r26871 | if dstart is not None: | ||
delta.append([dstart, dend, "".join(dline)]) | ||||
# apply the delta to the base, and get a delta for addrevision | ||||
deltatext, arraytext = _addlistdelta(base, delta) | ||||
else: | ||||
# For large changes, it's much cheaper to just build the text and | ||||
# diff it. | ||||
|
r31346 | arraytext = bytearray(self.text()) | ||
deltatext = mdiff.textdiff( | ||||
util.buffer(base), util.buffer(arraytext)) | ||||
|
r26871 | |||
|
r22931 | return arraytext, deltatext | ||
|
r22930 | def _msearch(m, s, lo=0, hi=None): | ||
'''return a tuple (start, end) that says where to find s within m. | ||||
If the string is found m[start:end] are the line containing | ||||
that string. If start == end the string was not found and | ||||
they indicate the proper sorted insertion point. | ||||
|
r31650 | m should be a buffer, a memoryview or a byte string. | ||
s is a byte string''' | ||||
|
r22930 | def advance(i, c): | ||
|
r31650 | while i < lenm and m[i:i + 1] != c: | ||
|
r22930 | i += 1 | ||
return i | ||||
if not s: | ||||
return (lo, lo) | ||||
lenm = len(m) | ||||
if not hi: | ||||
hi = lenm | ||||
while lo < hi: | ||||
mid = (lo + hi) // 2 | ||||
start = mid | ||||
|
r31650 | while start > 0 and m[start - 1:start] != '\n': | ||
|
r22930 | start -= 1 | ||
end = advance(start, '\0') | ||||
|
r31650 | if bytes(m[start:end]) < s: | ||
|
r22930 | # we know that after the null there are 40 bytes of sha1 | ||
# this translates to the bisect lo = mid + 1 | ||||
lo = advance(end + 40, '\n') + 1 | ||||
else: | ||||
# this translates to the bisect hi = mid | ||||
hi = start | ||||
end = advance(lo, '\0') | ||||
found = m[lo:end] | ||||
if s == found: | ||||
# we know that after the null there are 40 bytes of sha1 | ||||
end = advance(end + 40, '\n') | ||||
return (lo, end + 1) | ||||
else: | ||||
return (lo, lo) | ||||
|
r22415 | def _checkforbidden(l): | ||
|
r22408 | """Check filenames for illegal characters.""" | ||
for f in l: | ||||
if '\n' in f or '\r' in f: | ||||
|
r39813 | raise error.StorageError( | ||
|
r38353 | _("'\\n' and '\\r' disallowed in filenames: %r") | ||
% pycompat.bytestr(f)) | ||||
|
r22408 | |||
|
r22409 | # apply the changes collected during the bisect loop to our addlist | ||
# return a delta suitable for addrevision | ||||
|
r22415 | def _addlistdelta(addlist, x): | ||
|
r22409 | # for large addlist arrays, building a new array is cheaper | ||
# than repeatedly modifying the existing one | ||||
currentposition = 0 | ||||
|
r31346 | newaddlist = bytearray() | ||
|
r22409 | |||
for start, end, content in x: | ||||
newaddlist += addlist[currentposition:start] | ||||
if content: | ||||
|
r31346 | newaddlist += bytearray(content) | ||
|
r22409 | |||
currentposition = end | ||||
newaddlist += addlist[currentposition:] | ||||
deltatext = "".join(struct.pack(">lll", start, end, len(content)) | ||||
+ content for start, end, content in x) | ||||
return deltatext, newaddlist | ||||
|
r24401 | def _splittopdir(f): | ||
if '/' in f: | ||||
dir, subpath = f.split('/', 1) | ||||
return dir + '/', subpath | ||||
else: | ||||
return '', f | ||||
|
r26402 | _noop = lambda s: None | ||
|
r25222 | |||
|
r24401 | class treemanifest(object): | ||
|
r24403 | def __init__(self, dir='', text=''): | ||
self._dir = dir | ||||
|
r39352 | self._node = nullid | ||
|
r26402 | self._loadfunc = _noop | ||
self._copyfunc = _noop | ||||
|
r25220 | self._dirty = False | ||
|
r24401 | self._dirs = {} | ||
|
r39551 | self._lazydirs = {} | ||
|
r24401 | # Using _lazymanifest here is a little slower than plain old dicts | ||
self._files = {} | ||||
self._flags = {} | ||||
|
r25220 | if text: | ||
def readsubtree(subdir, subm): | ||||
raise AssertionError('treemanifest constructor only accepts ' | ||||
'flat manifests') | ||||
self.parse(text, readsubtree) | ||||
self._dirty = True # Mark flat manifest dirty after parsing | ||||
|
r24401 | |||
|
r24403 | def _subpath(self, path): | ||
return self._dir + path | ||||
|
r39551 | def _loadalllazy(self): | ||
|
r40075 | selfdirs = self._dirs | ||
for d, (path, node, readsubtree, docopy) in self._lazydirs.iteritems(): | ||||
if docopy: | ||||
selfdirs[d] = readsubtree(path, node).copy() | ||||
else: | ||||
selfdirs[d] = readsubtree(path, node) | ||||
|
r39551 | self._lazydirs = {} | ||
def _loadlazy(self, d): | ||||
|
r40017 | v = self._lazydirs.get(d) | ||
if v: | ||||
|
r40075 | path, node, readsubtree, docopy = v | ||
if docopy: | ||||
self._dirs[d] = readsubtree(path, node).copy() | ||||
else: | ||||
self._dirs[d] = readsubtree(path, node) | ||||
|
r40017 | del self._lazydirs[d] | ||
|
r39551 | |||
|
r39557 | def _loadchildrensetlazy(self, visit): | ||
if not visit: | ||||
return None | ||||
if visit == 'all' or visit == 'this': | ||||
self._loadalllazy() | ||||
return None | ||||
|
r40018 | loadlazy = self._loadlazy | ||
|
r39557 | for k in visit: | ||
|
r40018 | loadlazy(k + '/') | ||
|
r39557 | return visit | ||
|
r40074 | def _loaddifflazy(self, t1, t2): | ||
"""load items in t1 and t2 if they're needed for diffing. | ||||
The criteria currently is: | ||||
- if it's not present in _lazydirs in either t1 or t2, load it in the | ||||
other (it may already be loaded or it may not exist, doesn't matter) | ||||
- if it's present in _lazydirs in both, compare the nodeid; if it | ||||
differs, load it in both | ||||
""" | ||||
toloadlazy = [] | ||||
for d, v1 in t1._lazydirs.iteritems(): | ||||
v2 = t2._lazydirs.get(d) | ||||
if not v2 or v2[1] != v1[1]: | ||||
toloadlazy.append(d) | ||||
for d, v1 in t2._lazydirs.iteritems(): | ||||
if d not in t1._lazydirs: | ||||
toloadlazy.append(d) | ||||
for d in toloadlazy: | ||||
t1._loadlazy(d) | ||||
t2._loadlazy(d) | ||||
|
r24401 | def __len__(self): | ||
|
r25222 | self._load() | ||
|
r24401 | size = len(self._files) | ||
|
r39551 | self._loadalllazy() | ||
|
r24401 | for m in self._dirs.values(): | ||
size += m.__len__() | ||||
return size | ||||
|
r36192 | def __nonzero__(self): | ||
# Faster than "__len() != 0" since it avoids loading sub-manifests | ||||
return not self._isempty() | ||||
__bool__ = __nonzero__ | ||||
|
r24551 | def _isempty(self): | ||
|
r25222 | self._load() # for consistency; already loaded by all callers | ||
|
r39552 | # See if we can skip loading everything. | ||
if self._files or (self._dirs and | ||||
any(not m._isempty() for m in self._dirs.values())): | ||||
return False | ||||
|
r39551 | self._loadalllazy() | ||
|
r39552 | return (not self._dirs or | ||
all(m._isempty() for m in self._dirs.values())) | ||||
|
r24551 | |||
|
r26400 | def __repr__(self): | ||
return ('<treemanifest dir=%s, node=%s, loaded=%s, dirty=%s at 0x%x>' % | ||||
|
r39352 | (self._dir, hex(self._node), | ||
|
r26402 | bool(self._loadfunc is _noop), | ||
|
r26400 | self._dirty, id(self))) | ||
|
r25091 | |||
def dir(self): | ||||
'''The directory that this tree manifest represents, including a | ||||
trailing '/'. Empty string for the repo root directory.''' | ||||
return self._dir | ||||
def node(self): | ||||
'''This node of this instance. nullid for unsaved instances. Should | ||||
be updated when the instance is read or written from a revlog. | ||||
''' | ||||
|
r25220 | assert not self._dirty | ||
|
r25091 | return self._node | ||
def setnode(self, node): | ||||
self._node = node | ||||
|
r25220 | self._dirty = False | ||
|
r24403 | |||
|
r28206 | def iterentries(self): | ||
self._load() | ||||
|
r39551 | self._loadalllazy() | ||
|
r32536 | for p, n in sorted(itertools.chain(self._dirs.items(), | ||
self._files.items())): | ||||
|
r28206 | if p in self._files: | ||
yield self._subpath(p), n, self._flags.get(p, '') | ||||
else: | ||||
for x in n.iterentries(): | ||||
yield x | ||||
|
r32550 | def items(self): | ||
|
r25222 | self._load() | ||
|
r39551 | self._loadalllazy() | ||
|
r32536 | for p, n in sorted(itertools.chain(self._dirs.items(), | ||
self._files.items())): | ||||
|
r24401 | if p in self._files: | ||
|
r24403 | yield self._subpath(p), n | ||
|
r24401 | else: | ||
|
r24403 | for f, sn in n.iteritems(): | ||
yield f, sn | ||||
|
r24401 | |||
|
r32550 | iteritems = items | ||
|
r24401 | def iterkeys(self): | ||
|
r25222 | self._load() | ||
|
r39551 | self._loadalllazy() | ||
|
r32536 | for p in sorted(itertools.chain(self._dirs, self._files)): | ||
|
r24401 | if p in self._files: | ||
|
r24403 | yield self._subpath(p) | ||
|
r24401 | else: | ||
|
r35604 | for f in self._dirs[p]: | ||
|
r24403 | yield f | ||
|
r24401 | |||
def keys(self): | ||||
return list(self.iterkeys()) | ||||
def __iter__(self): | ||||
return self.iterkeys() | ||||
def __contains__(self, f): | ||||
if f is None: | ||||
return False | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | if dir not in self._dirs: | ||
return False | ||||
|
r39551 | |||
|
r24401 | return self._dirs[dir].__contains__(subpath) | ||
else: | ||||
return f in self._files | ||||
def get(self, f, default=None): | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | if dir not in self._dirs: | ||
return default | ||||
return self._dirs[dir].get(subpath, default) | ||||
else: | ||||
return self._files.get(f, default) | ||||
def __getitem__(self, f): | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | return self._dirs[dir].__getitem__(subpath) | ||
else: | ||||
return self._files[f] | ||||
def flags(self, f): | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | if dir not in self._dirs: | ||
return '' | ||||
return self._dirs[dir].flags(subpath) | ||||
else: | ||||
|
r39551 | if f in self._lazydirs or f in self._dirs: | ||
|
r24401 | return '' | ||
return self._flags.get(f, '') | ||||
def find(self, f): | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | return self._dirs[dir].find(subpath) | ||
else: | ||||
return self._files[f], self._flags.get(f, '') | ||||
def __delitem__(self, f): | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r39551 | |||
|
r24401 | self._dirs[dir].__delitem__(subpath) | ||
# If the directory is now empty, remove it | ||||
|
r24551 | if self._dirs[dir]._isempty(): | ||
|
r24401 | del self._dirs[dir] | ||
else: | ||||
del self._files[f] | ||||
if f in self._flags: | ||||
del self._flags[f] | ||||
|
r25220 | self._dirty = True | ||
|
r24401 | |||
def __setitem__(self, f, n): | ||||
assert n is not None | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r24401 | if dir not in self._dirs: | ||
|
r24403 | self._dirs[dir] = treemanifest(self._subpath(dir)) | ||
|
r24401 | self._dirs[dir].__setitem__(subpath, n) | ||
else: | ||||
|
r24467 | self._files[f] = n[:21] # to match manifestdict's behavior | ||
|
r25220 | self._dirty = True | ||
|
r24401 | |||
|
r26402 | def _load(self): | ||
if self._loadfunc is not _noop: | ||||
lf, self._loadfunc = self._loadfunc, _noop | ||||
lf(self) | ||||
elif self._copyfunc is not _noop: | ||||
cf, self._copyfunc = self._copyfunc, _noop | ||||
cf(self) | ||||
|
r24401 | def setflag(self, f, flags): | ||
"""Set the flags (symlink, executable) for path f.""" | ||||
|
r25222 | self._load() | ||
|
r24401 | dir, subpath = _splittopdir(f) | ||
if dir: | ||||
|
r40019 | self._loadlazy(dir) | ||
|
r24401 | if dir not in self._dirs: | ||
|
r24403 | self._dirs[dir] = treemanifest(self._subpath(dir)) | ||
|
r24401 | self._dirs[dir].setflag(subpath, flags) | ||
else: | ||||
self._flags[f] = flags | ||||
|
r25220 | self._dirty = True | ||
|
r24401 | |||
def copy(self): | ||||
|
r24403 | copy = treemanifest(self._dir) | ||
|
r25091 | copy._node = self._node | ||
|
r25220 | copy._dirty = self._dirty | ||
|
r26402 | if self._copyfunc is _noop: | ||
def _copyfunc(s): | ||||
self._load() | ||||
|
r40076 | s._lazydirs = {d: (p, n, r, True) for | ||
d, (p, n, r, c) in self._lazydirs.iteritems()} | ||||
|
r39551 | sdirs = s._dirs | ||
for d, v in self._dirs.iteritems(): | ||||
sdirs[d] = v.copy() | ||||
|
r26402 | s._files = dict.copy(self._files) | ||
s._flags = dict.copy(self._flags) | ||||
if self._loadfunc is _noop: | ||||
_copyfunc(copy) | ||||
else: | ||||
copy._copyfunc = _copyfunc | ||||
else: | ||||
copy._copyfunc = self._copyfunc | ||||
|
r24401 | return copy | ||
|
r31255 | def filesnotin(self, m2, match=None): | ||
|
r24401 | '''Set of files in this manifest that are not in the other''' | ||
|
r39553 | if match and not match.always(): | ||
|
r31255 | m1 = self.matches(match) | ||
m2 = m2.matches(match) | ||||
return m1.filesnotin(m2) | ||||
|
r24405 | files = set() | ||
def _filesnotin(t1, t2): | ||||
|
r25220 | if t1._node == t2._node and not t1._dirty and not t2._dirty: | ||
return | ||||
|
r25222 | t1._load() | ||
t2._load() | ||||
|
r40074 | self._loaddifflazy(t1, t2) | ||
|
r24405 | for d, m1 in t1._dirs.iteritems(): | ||
if d in t2._dirs: | ||||
m2 = t2._dirs[d] | ||||
_filesnotin(m1, m2) | ||||
else: | ||||
files.update(m1.iterkeys()) | ||||
|
r36314 | for fn in t1._files: | ||
|
r24405 | if fn not in t2._files: | ||
files.add(t1._subpath(fn)) | ||||
_filesnotin(self, m2) | ||||
|
r24401 | return files | ||
@propertycache | ||||
def _alldirs(self): | ||||
|
r24635 | return util.dirs(self) | ||
|
r24401 | |||
def dirs(self): | ||||
return self._alldirs | ||||
def hasdir(self, dir): | ||||
|
r25222 | self._load() | ||
|
r24406 | topdir, subdir = _splittopdir(dir) | ||
if topdir: | ||||
|
r40019 | self._loadlazy(topdir) | ||
|
r24406 | if topdir in self._dirs: | ||
return self._dirs[topdir].hasdir(subdir) | ||||
return False | ||||
|
r39551 | dirslash = dir + '/' | ||
return dirslash in self._dirs or dirslash in self._lazydirs | ||||
|
r24401 | |||
|
r24646 | def walk(self, match): | ||
'''Generates matching file names. | ||||
Equivalent to manifest.matches(match).iterkeys(), but without creating | ||||
an entirely new manifest. | ||||
It also reports nonexistent files by marking them bad with match.bad(). | ||||
''' | ||||
|
r24683 | if match.always(): | ||
for f in iter(self): | ||||
yield f | ||||
return | ||||
|
r24646 | fset = set(match.files()) | ||
|
r24647 | for fn in self._walk(match): | ||
|
r24646 | if fn in fset: | ||
# specified pattern is the exact name | ||||
fset.remove(fn) | ||||
|
r24647 | yield fn | ||
|
r24646 | |||
# for dirstate.walk, files=['.'] means "walk the whole tree". | ||||
# follow that here, too | ||||
fset.discard('.') | ||||
for fn in sorted(fset): | ||||
if not self.hasdir(fn): | ||||
match.bad(fn, None) | ||||
|
r25188 | def _walk(self, match): | ||
'''Recursively generates matching file names for walk().''' | ||||
|
r39558 | visit = match.visitchildrenset(self._dir[:-1] or '.') | ||
if not visit: | ||||
|
r25188 | return | ||
|
r24647 | |||
# yield this dir's files and walk its submanifests | ||||
|
r25222 | self._load() | ||
|
r39558 | visit = self._loadchildrensetlazy(visit) | ||
|
r36315 | for p in sorted(list(self._dirs) + list(self._files)): | ||
|
r24647 | if p in self._files: | ||
fullp = self._subpath(p) | ||||
if match(fullp): | ||||
yield fullp | ||||
else: | ||||
|
r39558 | if not visit or p[:-1] in visit: | ||
for f in self._dirs[p]._walk(match): | ||||
yield f | ||||
|
r24647 | |||
|
r24401 | def matches(self, match): | ||
'''generate a new manifest filtered by the match argument''' | ||||
if match.always(): | ||||
return self.copy() | ||||
|
r24552 | return self._matches(match) | ||
|
r25188 | def _matches(self, match): | ||
|
r24552 | '''recursively generate a new manifest filtered by the match argument. | ||
|
r25188 | ''' | ||
|
r27343 | |||
|
r39557 | visit = match.visitchildrenset(self._dir[:-1] or '.') | ||
|
r27343 | if visit == 'all': | ||
return self.copy() | ||||
|
r24552 | ret = treemanifest(self._dir) | ||
|
r27343 | if not visit: | ||
|
r25188 | return ret | ||
|
r24552 | |||
|
r25222 | self._load() | ||
|
r24552 | for fn in self._files: | ||
|
r39557 | # While visitchildrenset *usually* lists only subdirs, this is | ||
# actually up to the matcher and may have some files in the set(). | ||||
# If visit == 'this', we should obviously look at the files in this | ||||
# directory; if visit is a set, and fn is in it, we should inspect | ||||
# fn (but no need to inspect things not in the set). | ||||
if visit != 'this' and fn not in visit: | ||||
continue | ||||
|
r24552 | fullp = self._subpath(fn) | ||
|
r39557 | # visitchildrenset isn't perfect, we still need to call the regular | ||
# matcher code to further filter results. | ||||
|
r24552 | if not match(fullp): | ||
continue | ||||
ret._files[fn] = self._files[fn] | ||||
if fn in self._flags: | ||||
ret._flags[fn] = self._flags[fn] | ||||
|
r39557 | visit = self._loadchildrensetlazy(visit) | ||
|
r24552 | for dir, subm in self._dirs.iteritems(): | ||
|
r39557 | if visit and dir[:-1] not in visit: | ||
continue | ||||
|
r25188 | m = subm._matches(match) | ||
|
r24552 | if not m._isempty(): | ||
ret._dirs[dir] = m | ||||
|
r25220 | if not ret._isempty(): | ||
ret._dirty = True | ||||
|
r24552 | return ret | ||
|
r24401 | |||
|
r31255 | def diff(self, m2, match=None, clean=False): | ||
|
r24401 | '''Finds changes between the current manifest and m2. | ||
Args: | ||||
m2: the manifest to which this manifest should be compared. | ||||
clean: if true, include files unchanged between these manifests | ||||
with a None value in the returned dictionary. | ||||
The result is returned as a dict with filename as key and | ||||
values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the | ||||
nodeid in the current/other manifest and fl1/fl2 is the flag | ||||
in the current/other manifest. Where the file does not exist, | ||||
the nodeid will be None and the flags will be the empty | ||||
string. | ||||
''' | ||||
|
r39553 | if match and not match.always(): | ||
|
r31255 | m1 = self.matches(match) | ||
m2 = m2.matches(match) | ||||
return m1.diff(m2, clean=clean) | ||||
|
r24404 | result = {} | ||
emptytree = treemanifest() | ||||
|
r41188 | |||
def _iterativediff(t1, t2, stack): | ||||
"""compares two tree manifests and append new tree-manifests which | ||||
needs to be compared to stack""" | ||||
|
r25220 | if t1._node == t2._node and not t1._dirty and not t2._dirty: | ||
return | ||||
|
r25222 | t1._load() | ||
t2._load() | ||||
|
r40074 | self._loaddifflazy(t1, t2) | ||
|
r40020 | |||
|
r24404 | for d, m1 in t1._dirs.iteritems(): | ||
m2 = t2._dirs.get(d, emptytree) | ||||
|
r41188 | stack.append((m1, m2)) | ||
|
r24404 | |||
for d, m2 in t2._dirs.iteritems(): | ||||
if d not in t1._dirs: | ||||
|
r41188 | stack.append((emptytree, m2)) | ||
|
r24401 | |||
|
r24404 | for fn, n1 in t1._files.iteritems(): | ||
fl1 = t1._flags.get(fn, '') | ||||
n2 = t2._files.get(fn, None) | ||||
fl2 = t2._flags.get(fn, '') | ||||
if n1 != n2 or fl1 != fl2: | ||||
result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) | ||||
elif clean: | ||||
result[t1._subpath(fn)] = None | ||||
|
r24401 | |||
|
r24404 | for fn, n2 in t2._files.iteritems(): | ||
if fn not in t1._files: | ||||
fl2 = t2._flags.get(fn, '') | ||||
result[t2._subpath(fn)] = ((None, ''), (n2, fl2)) | ||||
|
r24401 | |||
|
r41188 | stackls = [] | ||
_iterativediff(self, m2, stackls) | ||||
while stackls: | ||||
t1, t2 = stackls.pop() | ||||
# stackls is populated in the function call | ||||
_iterativediff(t1, t2, stackls) | ||||
|
r24404 | return result | ||
|
r24401 | |||
|
r25221 | def unmodifiedsince(self, m2): | ||
return not self._dirty and not m2._dirty and self._node == m2._node | ||||
|
r25091 | def parse(self, text, readsubtree): | ||
|
r39551 | selflazy = self._lazydirs | ||
subpath = self._subpath | ||||
|
r24781 | for f, n, fl in _parse(text): | ||
|
r27271 | if fl == 't': | ||
|
r25091 | f = f + '/' | ||
|
r40075 | # False below means "doesn't need to be copied" and can use the | ||
# cached value from readsubtree directly. | ||||
selflazy[f] = (subpath(f), n, readsubtree, False) | ||||
|
r25220 | elif '/' in f: | ||
# This is a flat manifest, so use __setitem__ and setflag rather | ||||
# than assigning directly to _files and _flags, so we can | ||||
# assign a path in a subdirectory, and to mark dirty (compared | ||||
# to nullid). | ||||
|
r25091 | self[f] = n | ||
if fl: | ||||
self.setflag(f, fl) | ||||
|
r25220 | else: | ||
# Assigning to _files and _flags avoids marking as dirty, | ||||
# and should be a little faster. | ||||
self._files[f] = n | ||||
if fl: | ||||
self._flags[f] = fl | ||||
|
r24781 | |||
|
r36391 | def text(self): | ||
|
r24401 | """Get the full data of this manifest as a bytestring.""" | ||
|
r25222 | self._load() | ||
|
r36391 | return _text(self.iterentries()) | ||
|
r24401 | |||
|
r36391 | def dirtext(self): | ||
|
r25091 | """Get the full data of this directory as a bytestring. Make sure that | ||
any submanifests have been written first, so their nodeids are correct. | ||||
""" | ||||
|
r25222 | self._load() | ||
|
r25091 | flags = self.flags | ||
|
r40075 | lazydirs = [(d[:-1], v[1], 't') for d, v in self._lazydirs.iteritems()] | ||
|
r27271 | dirs = [(d[:-1], self._dirs[d]._node, 't') for d in self._dirs] | ||
|
r25091 | files = [(f, self._files[f], flags(f)) for f in self._files] | ||
|
r39551 | return _text(sorted(dirs + files + lazydirs)) | ||
|
r25091 | |||
|
r25222 | def read(self, gettext, readsubtree): | ||
|
r26402 | def _load_for_read(s): | ||
s.parse(gettext(), readsubtree) | ||||
s._dirty = False | ||||
self._loadfunc = _load_for_read | ||||
|
r25222 | |||
|
r39704 | def writesubtrees(self, m1, m2, writesubtree, match): | ||
|
r25222 | self._load() # for consistency; should never have any effect here | ||
|
r29888 | m1._load() | ||
m2._load() | ||||
|
r25091 | emptytree = treemanifest() | ||
|
r39554 | def getnode(m, d): | ||
ld = m._lazydirs.get(d) | ||||
if ld: | ||||
return ld[1] | ||||
return m._dirs.get(d, emptytree)._node | ||||
|
r39704 | # let's skip investigating things that `match` says we do not need. | ||
visit = match.visitchildrenset(self._dir[:-1] or '.') | ||||
|
r40076 | visit = self._loadchildrensetlazy(visit) | ||
|
r39704 | if visit == 'this' or visit == 'all': | ||
visit = None | ||||
|
r25091 | for d, subm in self._dirs.iteritems(): | ||
|
r39704 | if visit and d[:-1] not in visit: | ||
continue | ||||
|
r39554 | subp1 = getnode(m1, d) | ||
subp2 = getnode(m2, d) | ||||
|
r39352 | if subp1 == nullid: | ||
|
r25091 | subp1, subp2 = subp2, subp1 | ||
|
r39704 | writesubtree(subm, subp1, subp2, match) | ||
|
r25091 | |||
|
r31876 | def walksubtrees(self, matcher=None): | ||
"""Returns an iterator of the subtrees of this manifest, including this | ||||
manifest itself. | ||||
If `matcher` is provided, it only returns subtrees that match. | ||||
""" | ||||
if matcher and not matcher.visitdir(self._dir[:-1] or '.'): | ||||
return | ||||
if not matcher or matcher(self._dir[:-1]): | ||||
yield self | ||||
self._load() | ||||
|
r39551 | # OPT: use visitchildrenset to avoid loading everything. | ||
self._loadalllazy() | ||||
|
r31876 | for d, subm in self._dirs.iteritems(): | ||
for subtree in subm.walksubtrees(matcher=matcher): | ||||
yield subtree | ||||
|
r38803 | class manifestfulltextcache(util.lrucachedict): | ||
"""File-backed LRU cache for the manifest cache | ||||
File consists of entries, up to EOF: | ||||
- 20 bytes node, 4 bytes length, <length> manifest data | ||||
These are written in reverse cache order (oldest to newest). | ||||
""" | ||||
r42128 | ||||
_file = 'manifestfulltextcache' | ||||
|
r38803 | def __init__(self, max): | ||
super(manifestfulltextcache, self).__init__(max) | ||||
self._dirty = False | ||||
self._read = False | ||||
self._opener = None | ||||
def read(self): | ||||
if self._read or self._opener is None: | ||||
return | ||||
try: | ||||
r42128 | with self._opener(self._file) as fp: | |||
|
r38803 | set = super(manifestfulltextcache, self).__setitem__ | ||
# ignore trailing data, this is a cache, corruption is skipped | ||||
while True: | ||||
node = fp.read(20) | ||||
if len(node) < 20: | ||||
break | ||||
try: | ||||
size = struct.unpack('>L', fp.read(4))[0] | ||||
except struct.error: | ||||
break | ||||
value = bytearray(fp.read(size)) | ||||
if len(value) != size: | ||||
break | ||||
set(node, value) | ||||
except IOError: | ||||
# the file is allowed to be missing | ||||
pass | ||||
self._read = True | ||||
self._dirty = False | ||||
def write(self): | ||||
if not self._dirty or self._opener is None: | ||||
return | ||||
# rotate backwards to the first used node | ||||
r42128 | with self._opener(self._file, 'w', atomictemp=True, checkambig=True | |||
|
r38803 | ) as fp: | ||
node = self._head.prev | ||||
while True: | ||||
if node.key in self._cache: | ||||
fp.write(node.key) | ||||
fp.write(struct.pack('>L', len(node.value))) | ||||
fp.write(node.value) | ||||
if node is self._head: | ||||
break | ||||
node = node.prev | ||||
def __len__(self): | ||||
if not self._read: | ||||
self.read() | ||||
return super(manifestfulltextcache, self).__len__() | ||||
def __contains__(self, k): | ||||
if not self._read: | ||||
self.read() | ||||
return super(manifestfulltextcache, self).__contains__(k) | ||||
def __iter__(self): | ||||
if not self._read: | ||||
self.read() | ||||
return super(manifestfulltextcache, self).__iter__() | ||||
def __getitem__(self, k): | ||||
if not self._read: | ||||
self.read() | ||||
# the cache lru order can change on read | ||||
setdirty = self._cache.get(k) is not self._head | ||||
value = super(manifestfulltextcache, self).__getitem__(k) | ||||
if setdirty: | ||||
self._dirty = True | ||||
return value | ||||
def __setitem__(self, k, v): | ||||
if not self._read: | ||||
self.read() | ||||
super(manifestfulltextcache, self).__setitem__(k, v) | ||||
self._dirty = True | ||||
def __delitem__(self, k): | ||||
if not self._read: | ||||
self.read() | ||||
super(manifestfulltextcache, self).__delitem__(k) | ||||
self._dirty = True | ||||
def get(self, k, default=None): | ||||
if not self._read: | ||||
self.read() | ||||
return super(manifestfulltextcache, self).get(k, default=default) | ||||
def clear(self, clear_persisted_data=False): | ||||
super(manifestfulltextcache, self).clear() | ||||
if clear_persisted_data: | ||||
self._dirty = True | ||||
self.write() | ||||
self._read = False | ||||
|
r39350 | @interfaceutil.implementer(repository.imanifeststorage) | ||
class manifestrevlog(object): | ||||
|
r29824 | '''A revlog that stores manifest texts. This is responsible for caching the | ||
full-text manifest contents. | ||||
''' | ||||
|
r39279 | def __init__(self, opener, tree='', dirlogcache=None, indexfile=None, | ||
|
r32252 | treemanifest=False): | ||
|
r31151 | """Constructs a new manifest revlog | ||
`indexfile` - used by extensions to have two manifests at once, like | ||||
when transitioning between flatmanifeset and treemanifests. | ||||
|
r32252 | |||
`treemanifest` - used to indicate this is a tree manifest revlog. Opener | ||||
options can also be used to make this a tree manifest revlog. The opener | ||||
option takes precedence, so if it is set to True, we ignore whatever | ||||
value is passed in to the constructor. | ||||
|
r31151 | """ | ||
|
r29824 | # During normal operations, we expect to deal with not more than four | ||
# revs at a time (such as during commit --amend). When rebasing large | ||||
# stacks of commits, the number can go up, hence the config knob below. | ||||
cachesize = 4 | ||||
|
r32252 | optiontreemanifest = False | ||
|
r29824 | opts = getattr(opener, 'options', None) | ||
if opts is not None: | ||||
cachesize = opts.get('manifestcachesize', cachesize) | ||||
|
r32252 | optiontreemanifest = opts.get('treemanifest', False) | ||
|
r29940 | |||
|
r32252 | self._treeondisk = optiontreemanifest or treemanifest | ||
|
r29940 | |||
|
r38803 | self._fulltextcache = manifestfulltextcache(cachesize) | ||
|
r29824 | |||
|
r39279 | if tree: | ||
|
r29940 | assert self._treeondisk, 'opts is %r' % opts | ||
|
r31151 | |||
if indexfile is None: | ||||
indexfile = '00manifest.i' | ||||
|
r39279 | if tree: | ||
indexfile = "meta/" + tree + indexfile | ||||
|
r31151 | |||
|
r39351 | self.tree = tree | ||
|
r29941 | # The dirlogcache is kept on the root manifest log | ||
|
r39279 | if tree: | ||
|
r29941 | self._dirlogcache = dirlogcache | ||
else: | ||||
self._dirlogcache = {'': self} | ||||
|
r29940 | |||
|
r39350 | self._revlog = revlog.revlog(opener, indexfile, | ||
# only root indexfile is cached | ||||
checkambig=not bool(tree), | ||||
mmaplargeindex=True) | ||||
self.index = self._revlog.index | ||||
self.version = self._revlog.version | ||||
self._generaldelta = self._revlog._generaldelta | ||||
|
r29940 | |||
|
r38803 | def _setupmanifestcachehooks(self, repo): | ||
"""Persist the manifestfulltextcache on lock release""" | ||||
r42130 | if not util.safehasattr(repo, '_wlockref'): | |||
|
r38803 | return | ||
self._fulltextcache._opener = repo.cachevfs | ||||
r42130 | if repo._currentlock(repo._wlockref) is None: | |||
r42127 | return | |||
|
r38803 | reporef = weakref.ref(repo) | ||
manifestrevlogref = weakref.ref(self) | ||||
def persistmanifestcache(): | ||||
repo = reporef() | ||||
self = manifestrevlogref() | ||||
if repo is None or self is None: | ||||
return | ||||
|
r39356 | if repo.manifestlog.getstorage(b'') is not self: | ||
|
r38803 | # there's a different manifest in play now, abort | ||
return | ||||
self._fulltextcache.write() | ||||
r42127 | repo._afterlock(persistmanifestcache) | |||
|
r38803 | |||
|
r29824 | @property | ||
def fulltextcache(self): | ||||
return self._fulltextcache | ||||
|
r38803 | def clearcaches(self, clear_persisted_data=False): | ||
|
r39350 | self._revlog.clearcaches() | ||
|
r38803 | self._fulltextcache.clear(clear_persisted_data=clear_persisted_data) | ||
|
r39351 | self._dirlogcache = {self.tree: self} | ||
|
r29941 | |||
|
r36112 | def dirlog(self, d): | ||
if d: | ||||
|
r29941 | assert self._treeondisk | ||
|
r36112 | if d not in self._dirlogcache: | ||
mfrevlog = manifestrevlog(self.opener, d, | ||||
|
r32252 | self._dirlogcache, | ||
treemanifest=self._treeondisk) | ||||
|
r36112 | self._dirlogcache[d] = mfrevlog | ||
return self._dirlogcache[d] | ||||
|
r29824 | |||
|
r39704 | def add(self, m, transaction, link, p1, p2, added, removed, readtree=None, | ||
match=None): | ||||
|
r36391 | if p1 in self.fulltextcache and util.safehasattr(m, 'fastdelta'): | ||
|
r29961 | # If our first parent is in the manifest cache, we can | ||
# compute a delta here using properties we know about the | ||||
# manifest up-front, which may save time later for the | ||||
# revlog layer. | ||||
_checkforbidden(added) | ||||
# combine the changed lists into one sorted iterator | ||||
work = heapq.merge([(x, False) for x in added], | ||||
[(x, True) for x in removed]) | ||||
arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work) | ||||
|
r39350 | cachedelta = self._revlog.rev(p1), deltatext | ||
|
r29961 | text = util.buffer(arraytext) | ||
|
r39350 | n = self._revlog.addrevision(text, transaction, link, p1, p2, | ||
cachedelta) | ||||
|
r29961 | else: | ||
# The first parent manifest isn't already loaded, so we'll | ||||
# just encode a fulltext of the manifest and pass that | ||||
# through to the revlog layer, and let it handle the delta | ||||
# process. | ||||
if self._treeondisk: | ||||
|
r30368 | assert readtree, "readtree must be set for treemanifest writes" | ||
|
r39704 | assert match, "match must be specified for treemanifest writes" | ||
|
r39351 | m1 = readtree(self.tree, p1) | ||
m2 = readtree(self.tree, p2) | ||||
|
r39704 | n = self._addtree(m, transaction, link, m1, m2, readtree, | ||
match=match) | ||||
|
r29961 | arraytext = None | ||
else: | ||||
|
r36391 | text = m.text() | ||
|
r39350 | n = self._revlog.addrevision(text, transaction, link, p1, p2) | ||
|
r31346 | arraytext = bytearray(text) | ||
|
r29961 | |||
|
r30209 | if arraytext is not None: | ||
self.fulltextcache[n] = arraytext | ||||
|
r29961 | |||
return n | ||||
|
r39704 | def _addtree(self, m, transaction, link, m1, m2, readtree, match): | ||
|
r29961 | # If the manifest is unchanged compared to one parent, | ||
# don't write a new revision | ||||
|
r39351 | if self.tree != '' and (m.unmodifiedsince(m1) or m.unmodifiedsince( | ||
|
r39279 | m2)): | ||
|
r29961 | return m.node() | ||
|
r39704 | def writesubtree(subm, subp1, subp2, match): | ||
|
r29961 | sublog = self.dirlog(subm.dir()) | ||
|
r30368 | sublog.add(subm, transaction, link, subp1, subp2, None, None, | ||
|
r39704 | readtree=readtree, match=match) | ||
m.writesubtrees(m1, m2, writesubtree, match) | ||||
|
r36391 | text = m.dirtext() | ||
|
r31294 | n = None | ||
|
r39351 | if self.tree != '': | ||
|
r31294 | # Double-check whether contents are unchanged to one parent | ||
|
r36391 | if text == m1.dirtext(): | ||
|
r31294 | n = m1.node() | ||
|
r36391 | elif text == m2.dirtext(): | ||
|
r31294 | n = m2.node() | ||
if not n: | ||||
|
r39350 | n = self._revlog.addrevision(text, transaction, link, m1.node(), | ||
m2.node()) | ||||
|
r31294 | |||
|
r29961 | # Save nodeid so parent manifest can calculate its nodeid | ||
m.setnode(n) | ||||
return n | ||||
|
r39350 | def __len__(self): | ||
return len(self._revlog) | ||||
def __iter__(self): | ||||
return self._revlog.__iter__() | ||||
def rev(self, node): | ||||
return self._revlog.rev(node) | ||||
def node(self, rev): | ||||
return self._revlog.node(rev) | ||||
def lookup(self, value): | ||||
return self._revlog.lookup(value) | ||||
def parentrevs(self, rev): | ||||
return self._revlog.parentrevs(rev) | ||||
def parents(self, node): | ||||
return self._revlog.parents(node) | ||||
def linkrev(self, rev): | ||||
return self._revlog.linkrev(rev) | ||||
def checksize(self): | ||||
return self._revlog.checksize() | ||||
def revision(self, node, _df=None, raw=False): | ||||
return self._revlog.revision(node, _df=_df, raw=raw) | ||||
def revdiff(self, rev1, rev2): | ||||
return self._revlog.revdiff(rev1, rev2) | ||||
def cmp(self, node, text): | ||||
return self._revlog.cmp(node, text) | ||||
def deltaparent(self, rev): | ||||
return self._revlog.deltaparent(rev) | ||||
|
r39898 | def emitrevisions(self, nodes, nodesorder=None, | ||
revisiondata=False, assumehaveparentrevisions=False, | ||||
|
r40457 | deltamode=repository.CG_DELTAMODE_STD): | ||
|
r39898 | return self._revlog.emitrevisions( | ||
nodes, nodesorder=nodesorder, revisiondata=revisiondata, | ||||
assumehaveparentrevisions=assumehaveparentrevisions, | ||||
|
r40457 | deltamode=deltamode) | ||
|
r39898 | |||
|
r39350 | def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): | ||
return self._revlog.addgroup(deltas, linkmapper, transaction, | ||||
addrevisioncb=addrevisioncb) | ||||
|
r39894 | def rawsize(self, rev): | ||
return self._revlog.rawsize(rev) | ||||
|
r39350 | def getstrippoint(self, minlink): | ||
return self._revlog.getstrippoint(minlink) | ||||
def strip(self, minlink, transaction): | ||||
return self._revlog.strip(minlink, transaction) | ||||
def files(self): | ||||
return self._revlog.files() | ||||
def clone(self, tr, destrevlog, **kwargs): | ||||
if not isinstance(destrevlog, manifestrevlog): | ||||
raise error.ProgrammingError('expected manifestrevlog to clone()') | ||||
return self._revlog.clone(tr, destrevlog._revlog, **kwargs) | ||||
|
r39905 | def storageinfo(self, exclusivefiles=False, sharedfiles=False, | ||
revisionscount=False, trackedsize=False, | ||||
storedsize=False): | ||||
return self._revlog.storageinfo( | ||||
exclusivefiles=exclusivefiles, sharedfiles=sharedfiles, | ||||
revisionscount=revisionscount, trackedsize=trackedsize, | ||||
storedsize=storedsize) | ||||
|
r39350 | @property | ||
def indexfile(self): | ||||
return self._revlog.indexfile | ||||
@indexfile.setter | ||||
def indexfile(self, value): | ||||
self._revlog.indexfile = value | ||||
@property | ||||
def opener(self): | ||||
return self._revlog.opener | ||||
@opener.setter | ||||
def opener(self, value): | ||||
self._revlog.opener = value | ||||
|
r38549 | @interfaceutil.implementer(repository.imanifestlog) | ||
|
r29825 | class manifestlog(object): | ||
"""A collection class representing the collection of manifest snapshots | ||||
referenced by commits in the repository. | ||||
In this situation, 'manifest' refers to the abstract concept of a snapshot | ||||
of the list of files in the given commit. Consumers of the output of this | ||||
class do not care about the implementation details of the actual manifests | ||||
they receive (i.e. tree or flat or lazily loaded, etc).""" | ||||
|
r41067 | def __init__(self, opener, repo, rootstore, narrowmatch): | ||
|
r29959 | usetreemanifest = False | ||
|
r30372 | cachesize = 4 | ||
|
r29959 | |||
opts = getattr(opener, 'options', None) | ||||
if opts is not None: | ||||
usetreemanifest = opts.get('treemanifest', usetreemanifest) | ||||
|
r30372 | cachesize = opts.get('manifestcachesize', cachesize) | ||
|
r39281 | |||
self._treemanifests = usetreemanifest | ||||
|
r29959 | |||
|
r39799 | self._rootstore = rootstore | ||
|
r39357 | self._rootstore._setupmanifestcachehooks(repo) | ||
|
r41067 | self._narrowmatch = narrowmatch | ||
|
r30219 | |||
|
r30292 | # A cache of the manifestctx or treemanifestctx for each directory | ||
self._dirmancache = {} | ||||
|
r30372 | self._dirmancache[''] = util.lrucachedict(cachesize) | ||
|
r30292 | |||
|
r38529 | self._cachesize = cachesize | ||
|
r29826 | |||
|
r29825 | def __getitem__(self, node): | ||
|
r30290 | """Retrieves the manifest instance for the given node. Throws a | ||
LookupError if not found. | ||||
|
r29825 | """ | ||
|
r30291 | return self.get('', node) | ||
|
r29825 | |||
|
r39271 | def get(self, tree, node, verify=True): | ||
|
r30291 | """Retrieves the manifest instance for the given node. Throws a | ||
LookupError if not found. | ||||
|
r30403 | |||
`verify` - if True an exception will be thrown if the node is not in | ||||
the revlog | ||||
|
r30291 | """ | ||
|
r39271 | if node in self._dirmancache.get(tree, ()): | ||
return self._dirmancache[tree][node] | ||||
|
r30292 | |||
|
r37392 | if not self._narrowmatch.always(): | ||
|
r39271 | if not self._narrowmatch.visitdir(tree[:-1] or '.'): | ||
return excludeddirmanifestctx(tree, node) | ||||
if tree: | ||||
|
r39357 | if self._rootstore._treeondisk: | ||
|
r30403 | if verify: | ||
|
r39282 | # Side-effect is LookupError is raised if node doesn't | ||
# exist. | ||||
self.getstorage(tree).rev(node) | ||||
|
r39271 | m = treemanifestctx(self, tree, node) | ||
|
r30291 | else: | ||
raise error.Abort( | ||||
_("cannot ask for manifest directory '%s' in a flat " | ||||
|
r39271 | "manifest") % tree) | ||
|
r29907 | else: | ||
|
r30403 | if verify: | ||
|
r39282 | # Side-effect is LookupError is raised if node doesn't exist. | ||
|
r39357 | self._rootstore.rev(node) | ||
|
r39282 | |||
|
r39281 | if self._treemanifests: | ||
|
r31153 | m = treemanifestctx(self, '', node) | ||
|
r30291 | else: | ||
|
r31153 | m = manifestctx(self, node) | ||
|
r30292 | |||
|
r39352 | if node != nullid: | ||
|
r39271 | mancache = self._dirmancache.get(tree) | ||
|
r30292 | if not mancache: | ||
|
r38529 | mancache = util.lrucachedict(self._cachesize) | ||
|
r39271 | self._dirmancache[tree] = mancache | ||
|
r30292 | mancache[node] = m | ||
|
r29825 | return m | ||
|
r39280 | def getstorage(self, tree): | ||
|
r39357 | return self._rootstore.dirlog(tree) | ||
|
r39280 | |||
|
r38803 | def clearcaches(self, clear_persisted_data=False): | ||
|
r30370 | self._dirmancache.clear() | ||
|
r39357 | self._rootstore.clearcaches(clear_persisted_data=clear_persisted_data) | ||
|
r30370 | |||
|
r38573 | def rev(self, node): | ||
|
r39357 | return self._rootstore.rev(node) | ||
|
r38573 | |||
|
r38549 | @interfaceutil.implementer(repository.imanifestrevisionwritable) | ||
|
r30342 | class memmanifestctx(object): | ||
|
r31153 | def __init__(self, manifestlog): | ||
self._manifestlog = manifestlog | ||||
|
r30342 | self._manifestdict = manifestdict() | ||
|
r39353 | def _storage(self): | ||
|
r39356 | return self._manifestlog.getstorage(b'') | ||
|
r30345 | |||
|
r30342 | def new(self): | ||
|
r31153 | return memmanifestctx(self._manifestlog) | ||
|
r30342 | |||
|
r30343 | def copy(self): | ||
|
r31153 | memmf = memmanifestctx(self._manifestlog) | ||
|
r30343 | memmf._manifestdict = self.read().copy() | ||
return memmf | ||||
|
r30342 | def read(self): | ||
return self._manifestdict | ||||
|
r39704 | def write(self, transaction, link, p1, p2, added, removed, match=None): | ||
|
r39353 | return self._storage().add(self._manifestdict, transaction, link, | ||
|
r39704 | p1, p2, added, removed, match=match) | ||
|
r30345 | |||
|
r38549 | @interfaceutil.implementer(repository.imanifestrevisionstored) | ||
|
r29926 | class manifestctx(object): | ||
|
r29825 | """A class representing a single revision of a manifest, including its | ||
contents, its parent revs, and its linkrev. | ||||
""" | ||||
|
r31153 | def __init__(self, manifestlog, node): | ||
self._manifestlog = manifestlog | ||||
|
r29926 | self._data = None | ||
|
r29825 | |||
self._node = node | ||||
|
r29907 | |||
# TODO: We eventually want p1, p2, and linkrev exposed on this class, | ||||
# but let's add it later when something needs it and we can load it | ||||
# lazily. | ||||
|
r39353 | #self.p1, self.p2 = store.parents(node) | ||
#rev = store.rev(node) | ||||
#self.linkrev = store.linkrev(rev) | ||||
|
r29825 | |||
|
r39353 | def _storage(self): | ||
|
r39356 | return self._manifestlog.getstorage(b'') | ||
|
r30341 | |||
|
r29825 | def node(self): | ||
return self._node | ||||
|
r30342 | def new(self): | ||
|
r31153 | return memmanifestctx(self._manifestlog) | ||
|
r30342 | |||
|
r30343 | def copy(self): | ||
|
r31153 | memmf = memmanifestctx(self._manifestlog) | ||
|
r30343 | memmf._manifestdict = self.read().copy() | ||
return memmf | ||||
|
r30565 | @propertycache | ||
def parents(self): | ||||
|
r39353 | return self._storage().parents(self._node) | ||
|
r30565 | |||
|
r29926 | def read(self): | ||
|
r31097 | if self._data is None: | ||
|
r39352 | if self._node == nullid: | ||
|
r29926 | self._data = manifestdict() | ||
else: | ||||
|
r39353 | store = self._storage() | ||
|
r39358 | if self._node in store.fulltextcache: | ||
text = pycompat.bytestr(store.fulltextcache[self._node]) | ||||
|
r38803 | else: | ||
|
r39353 | text = store.revision(self._node) | ||
|
r38803 | arraytext = bytearray(text) | ||
|
r39358 | store.fulltextcache[self._node] = arraytext | ||
|
r29926 | self._data = manifestdict(text) | ||
return self._data | ||||
|
r30293 | def readfast(self, shallow=False): | ||
|
r30294 | '''Calls either readdelta or read, based on which would be less work. | ||
readdelta is called if the delta is against the p1, and therefore can be | ||||
read quickly. | ||||
If `shallow` is True, nothing changes since this is a flat manifest. | ||||
''' | ||||
|
r39353 | store = self._storage() | ||
r = store.rev(self._node) | ||||
deltaparent = store.deltaparent(r) | ||||
if deltaparent != nullrev and deltaparent in store.parentrevs(r): | ||||
|
r29939 | return self.readdelta() | ||
return self.read() | ||||
|
r30293 | def readdelta(self, shallow=False): | ||
|
r30295 | '''Returns a manifest containing just the entries that are present | ||
in this manifest, but not in its p1 manifest. This is efficient to read | ||||
if the revlog delta is already p1. | ||||
Changing the value of `shallow` has no effect on flat manifests. | ||||
''' | ||||
|
r39353 | store = self._storage() | ||
r = store.rev(self._node) | ||||
d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) | ||||
|
r29938 | return manifestdict(d) | ||
|
r30340 | def find(self, key): | ||
return self.read().find(key) | ||||
|
r38549 | @interfaceutil.implementer(repository.imanifestrevisionwritable) | ||
|
r30342 | class memtreemanifestctx(object): | ||
|
r31153 | def __init__(self, manifestlog, dir=''): | ||
self._manifestlog = manifestlog | ||||
|
r30342 | self._dir = dir | ||
self._treemanifest = treemanifest() | ||||
|
r39353 | def _storage(self): | ||
|
r39356 | return self._manifestlog.getstorage(b'') | ||
|
r30345 | |||
|
r30342 | def new(self, dir=''): | ||
|
r31153 | return memtreemanifestctx(self._manifestlog, dir=dir) | ||
|
r30342 | |||
|
r30343 | def copy(self): | ||
|
r31153 | memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) | ||
|
r30343 | memmf._treemanifest = self._treemanifest.copy() | ||
return memmf | ||||
|
r30342 | def read(self): | ||
return self._treemanifest | ||||
|
r39704 | def write(self, transaction, link, p1, p2, added, removed, match=None): | ||
|
r30368 | def readtree(dir, node): | ||
|
r31153 | return self._manifestlog.get(dir, node).read() | ||
|
r39353 | return self._storage().add(self._treemanifest, transaction, link, | ||
|
r39704 | p1, p2, added, removed, readtree=readtree, | ||
match=match) | ||||
|
r30345 | |||
|
r38549 | @interfaceutil.implementer(repository.imanifestrevisionstored) | ||
|
r29926 | class treemanifestctx(object): | ||
|
r31153 | def __init__(self, manifestlog, dir, node): | ||
self._manifestlog = manifestlog | ||||
|
r29907 | self._dir = dir | ||
|
r29926 | self._data = None | ||
|
r29907 | |||
self._node = node | ||||
# TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that | ||||
# we can instantiate treemanifestctx objects for directories we don't | ||||
# have on disk. | ||||
|
r39353 | #self.p1, self.p2 = store.parents(node) | ||
#rev = store.rev(node) | ||||
#self.linkrev = store.linkrev(rev) | ||||
|
r29907 | |||
|
r39353 | def _storage(self): | ||
|
r37391 | narrowmatch = self._manifestlog._narrowmatch | ||
if not narrowmatch.always(): | ||||
if not narrowmatch.visitdir(self._dir[:-1] or '.'): | ||||
return excludedmanifestrevlog(self._dir) | ||||
|
r39280 | return self._manifestlog.getstorage(self._dir) | ||
|
r30221 | |||
|
r29926 | def read(self): | ||
|
r31097 | if self._data is None: | ||
|
r39353 | store = self._storage() | ||
|
r39352 | if self._node == nullid: | ||
|
r29926 | self._data = treemanifest() | ||
|
r39353 | # TODO accessing non-public API | ||
elif store._treeondisk: | ||||
|
r29926 | m = treemanifest(dir=self._dir) | ||
def gettext(): | ||||
|
r39353 | return store.revision(self._node) | ||
|
r29926 | def readsubtree(dir, subm): | ||
|
r30404 | # Set verify to False since we need to be able to create | ||
# subtrees for trees that don't exist on disk. | ||||
|
r31153 | return self._manifestlog.get(dir, subm, verify=False).read() | ||
|
r29926 | m.read(gettext, readsubtree) | ||
m.setnode(self._node) | ||||
self._data = m | ||||
else: | ||||
|
r39353 | if self._node in store.fulltextcache: | ||
text = pycompat.bytestr(store.fulltextcache[self._node]) | ||||
|
r38803 | else: | ||
|
r39353 | text = store.revision(self._node) | ||
|
r38803 | arraytext = bytearray(text) | ||
|
r39353 | store.fulltextcache[self._node] = arraytext | ||
|
r29926 | self._data = treemanifest(dir=self._dir, text=text) | ||
return self._data | ||||
|
r29907 | |||
def node(self): | ||||
return self._node | ||||
|
r30342 | def new(self, dir=''): | ||
|
r31153 | return memtreemanifestctx(self._manifestlog, dir=dir) | ||
|
r30342 | |||
|
r30343 | def copy(self): | ||
|
r31153 | memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) | ||
|
r30343 | memmf._treemanifest = self.read().copy() | ||
return memmf | ||||
|
r30565 | @propertycache | ||
def parents(self): | ||||
|
r39353 | return self._storage().parents(self._node) | ||
|
r30565 | |||
|
r30293 | def readdelta(self, shallow=False): | ||
|
r30295 | '''Returns a manifest containing just the entries that are present | ||
in this manifest, but not in its p1 manifest. This is efficient to read | ||||
if the revlog delta is already p1. | ||||
If `shallow` is True, this will read the delta for this directory, | ||||
without recursively reading subdirectory manifests. Instead, any | ||||
subdirectory entry will be reported as it appears in the manifest, i.e. | ||||
the subdirectory will be reported among files and distinguished only by | ||||
its 't' flag. | ||||
''' | ||||
|
r39353 | store = self._storage() | ||
|
r36391 | if shallow: | ||
|
r39353 | r = store.rev(self._node) | ||
d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) | ||||
|
r30293 | return manifestdict(d) | ||
else: | ||||
# Need to perform a slow delta | ||||
|
r39353 | r0 = store.deltaparent(store.rev(self._node)) | ||
m0 = self._manifestlog.get(self._dir, store.node(r0)).read() | ||||
|
r30293 | m1 = self.read() | ||
md = treemanifest(dir=self._dir) | ||||
for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).iteritems(): | ||||
if n1: | ||||
md[f] = n1 | ||||
if fl1: | ||||
md.setflag(f, fl1) | ||||
return md | ||||
|
r29938 | |||
|
r30293 | def readfast(self, shallow=False): | ||
|
r30294 | '''Calls either readdelta or read, based on which would be less work. | ||
readdelta is called if the delta is against the p1, and therefore can be | ||||
read quickly. | ||||
If `shallow` is True, it only returns the entries from this manifest, | ||||
and not any submanifests. | ||||
''' | ||||
|
r39353 | store = self._storage() | ||
r = store.rev(self._node) | ||||
deltaparent = store.deltaparent(r) | ||||
|
r39352 | if (deltaparent != nullrev and | ||
|
r39353 | deltaparent in store.parentrevs(r)): | ||
|
r30293 | return self.readdelta(shallow=shallow) | ||
if shallow: | ||||
|
r39353 | return manifestdict(store.revision(self._node)) | ||
|
r30293 | else: | ||
return self.read() | ||||
|
r29939 | |||
|
r30340 | def find(self, key): | ||
return self.read().find(key) | ||||
|
r37390 | |||
class excludeddir(treemanifest): | ||||
"""Stand-in for a directory that is excluded from the repository. | ||||
With narrowing active on a repository that uses treemanifests, | ||||
some of the directory revlogs will be excluded from the resulting | ||||
clone. This is a huge storage win for clients, but means we need | ||||
some sort of pseudo-manifest to surface to internals so we can | ||||
detect a merge conflict outside the narrowspec. That's what this | ||||
class is: it stands in for a directory whose node is known, but | ||||
whose contents are unknown. | ||||
""" | ||||
def __init__(self, dir, node): | ||||
super(excludeddir, self).__init__(dir) | ||||
self._node = node | ||||
# Add an empty file, which will be included by iterators and such, | ||||
# appearing as the directory itself (i.e. something like "dir/") | ||||
self._files[''] = node | ||||
self._flags[''] = 't' | ||||
# Manifests outside the narrowspec should never be modified, so avoid | ||||
# copying. This makes a noticeable difference when there are very many | ||||
# directories outside the narrowspec. Also, it makes sense for the copy to | ||||
# be of the same type as the original, which would not happen with the | ||||
# super type's copy(). | ||||
def copy(self): | ||||
return self | ||||
class excludeddirmanifestctx(treemanifestctx): | ||||
"""context wrapper for excludeddir - see that docstring for rationale""" | ||||
def __init__(self, dir, node): | ||||
self._dir = dir | ||||
self._node = node | ||||
def read(self): | ||||
return excludeddir(self._dir, self._node) | ||||
def write(self, *args): | ||||
raise error.ProgrammingError( | ||||
'attempt to write manifest from excluded dir %s' % self._dir) | ||||
class excludedmanifestrevlog(manifestrevlog): | ||||
"""Stand-in for excluded treemanifest revlogs. | ||||
When narrowing is active on a treemanifest repository, we'll have | ||||
references to directories we can't see due to the revlog being | ||||
skipped. This class exists to conform to the manifestrevlog | ||||
interface for those directories and proactively prevent writes to | ||||
outside the narrowspec. | ||||
""" | ||||
def __init__(self, dir): | ||||
self._dir = dir | ||||
def __len__(self): | ||||
raise error.ProgrammingError( | ||||
'attempt to get length of excluded dir %s' % self._dir) | ||||
def rev(self, node): | ||||
raise error.ProgrammingError( | ||||
'attempt to get rev from excluded dir %s' % self._dir) | ||||
def linkrev(self, node): | ||||
raise error.ProgrammingError( | ||||
'attempt to get linkrev from excluded dir %s' % self._dir) | ||||
def node(self, rev): | ||||
raise error.ProgrammingError( | ||||
'attempt to get node from excluded dir %s' % self._dir) | ||||
def add(self, *args, **kwargs): | ||||
# We should never write entries in dirlogs outside the narrow clone. | ||||
# However, the method still gets called from writesubtree() in | ||||
# _addtree(), so we need to handle it. We should possibly make that | ||||
# avoid calling add() with a clean manifest (_dirty is always False | ||||
# in excludeddir instances). | ||||
pass | ||||