mercurial-scm/hg-stable: mercurial/revlog.py annotate

annotate mercurial/revlog.py @ 2295:9c15f85e61b1

fix a typo in an error message

author	Benoit Boissinot <benoit.boissinot@ens-lyon.org>
date	Tue, 16 May 2006 11:07:56 +0200
parents	854954fd410a
children	16276b1c0658

rev	line source
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	2 revlog.py - storage back-end for mercurial
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	3
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	4 This provides efficient delta storage with O(1) retrieve and append
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	5 and O(changes) merge between branches
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	6
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	7 Copyright 2005 Matt Mackall <mpm@selenic.com>
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	8
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	9 This software may be used and distributed according to the terms
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	10 of the GNU General Public License, incorporated herein by reference.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	11 """
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	12
1089 142b5d5ec9cc Break apart hg.py mpm@selenic.com parents: 1083 diff changeset	13 from node import *
1400 cf9a1233738a i18n first part: make '_' available for files who need it Benoit Boissinot <benoit.boissinot@ens-lyon.org parents: 1393 diff changeset	14 from i18n import gettext as _
1322 b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	15 from demandload import demandload
1981 736b6c96bbbc make incoming work via ssh (issue139); move chunk code into separate module. Thomas Arendsen Hein <thomas@intevation.de> parents: 1941 diff changeset	16 demandload(globals(), "binascii changegroup errno heapq mdiff os")
2176 9b42304d9896 fix file handling bugs on windows. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2089 diff changeset	17 demandload(globals(), "sha struct util zlib")
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	18
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	19 # revlog version strings
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	20 REVLOGV0 = 0
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	21 REVLOGNG = 1
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	22
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	23 # revlog flags
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	24 REVLOGNGINLINEDATA = (1 << 16)
2222 c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	25 REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	26
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	27 REVLOG_DEFAULT_FORMAT = REVLOGNG
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	28 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT \| REVLOG_DEFAULT_FLAGS
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	29
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	30 def flagstr(flag):
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	31 if flag == "inline":
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	32 return REVLOGNGINLINEDATA
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	33 raise RevlogError(_("unknown revlog flag %s" % flag))
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	34
1091 d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	35 def hash(text, p1, p2):
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	36 """generate a hash from the given text and its parent hashes
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	37
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	38 This hash combines both the current file contents and its history
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	39 in a manner that makes it easy to distinguish nodes with the same
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	40 content in the revision graph.
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	41 """
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	42 l = [p1, p2]
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	43 l.sort()
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	44 s = sha.new(l[0])
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	45 s.update(l[1])
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	46 s.update(text)
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	47 return s.digest()
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	48
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	49 def compress(text):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	50 """ generate a possibly-compressed representation of text """
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	51 if not text: return ("", text)
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	52 if len(text) < 44:
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	53 if text[0] == '\0': return ("", text)
3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	54 return ('u', text)
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	55 bin = zlib.compress(text)
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	56 if len(bin) > len(text):
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	57 if text[0] == '\0': return ("", text)
3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	58 return ('u', text)
3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	59 return ("", bin)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	60
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	61 def decompress(bin):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	62 """ decompress the given input """
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	63 if not bin: return bin
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	64 t = bin[0]
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	65 if t == '\0': return bin
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	66 if t == 'x': return zlib.decompress(bin)
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	67 if t == 'u': return bin[1:]
1853 5ac811b720de Fix some problems when working on broken repositories: Thomas Arendsen Hein <thomas@intevation.de> parents: 1784 diff changeset	68 raise RevlogError(_("unknown compression type %r") % t)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	69
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	70 indexformatv0 = ">4l20s20s20s"
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	71 v0shaoffset = 56
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	72 # index ng:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	73 # 6 bytes offset
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	74 # 2 bytes flags
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	75 # 4 bytes compressed length
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	76 # 4 bytes uncompressed length
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	77 # 4 bytes: base rev
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	78 # 4 bytes link rev
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	79 # 4 bytes parent 1 rev
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	80 # 4 bytes parent 2 rev
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	81 # 32 bytes: nodeid
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	82 indexformatng = ">Qiiiiii20s12x"
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	83 ngshaoffset = 32
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	84 versionformat = ">i"
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	85
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1551 diff changeset	86 class lazyparser(object):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	87 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	88 this class avoids the need to parse the entirety of large indices
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	89 """
2250 45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	90
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	91 # lazyparser is not safe to use on windows if win32 extensions not
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	92 # available. it keeps file handle open, which make it not possible
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	93 # to break hardlinks on local cloned repos.
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	94 safe_to_use = os.name != 'nt' or (not util.is_win_9x() and
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	95 hasattr(util, 'win32api'))
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	96
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	97 def __init__(self, dataf, size, indexformat, shaoffset):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	98 self.dataf = dataf
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	99 self.format = indexformat
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	100 self.s = struct.calcsize(indexformat)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	101 self.indexformat = indexformat
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	102 self.datasize = size
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	103 self.l = size/self.s
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	104 self.index = [None] * self.l
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	105 self.map = {nullid: -1}
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	106 self.allmap = 0
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	107 self.all = 0
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	108 self.mapfind_count = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	109 self.shaoffset = shaoffset
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	110
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	111 def loadmap(self):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	112 """
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	113 during a commit, we need to make sure the rev being added is
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	114 not a duplicate. This requires loading the entire index,
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	115 which is fairly slow. loadmap can load up just the node map,
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	116 which takes much less time.
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	117 """
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	118 if self.allmap: return
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	119 start = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	120 end = self.datasize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	121 self.allmap = 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	122 cur = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	123 count = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	124 blocksize = self.s * 256
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	125 self.dataf.seek(0)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	126 while cur < end:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	127 data = self.dataf.read(blocksize)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	128 off = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	129 for x in xrange(256):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	130 n = data[off + self.shaoffset:off + self.shaoffset + 20]
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	131 self.map[n] = count
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	132 count += 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	133 if count >= self.l:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	134 break
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	135 off += self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	136 cur += blocksize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	137
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	138 def loadblock(self, blockstart, blocksize, data=None):
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	139 if self.all: return
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	140 if data is None:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	141 self.dataf.seek(blockstart)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	142 data = self.dataf.read(blocksize)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	143 lend = len(data) / self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	144 i = blockstart / self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	145 off = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	146 for x in xrange(lend):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	147 if self.index[i + x] == None:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	148 b = data[off : off + self.s]
2080 1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	149 self.index[i + x] = b
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	150 n = b[self.shaoffset:self.shaoffset + 20]
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	151 self.map[n] = i + x
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	152 off += self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	153
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	154 def findnode(self, node):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	155 """search backwards through the index file for a specific node"""
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	156 if self.allmap: return None
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	157
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	158 # hg log will cause many many searches for the manifest
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	159 # nodes. After we get called a few times, just load the whole
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	160 # thing.
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	161 if self.mapfind_count > 8:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	162 self.loadmap()
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	163 if node in self.map:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	164 return node
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	165 return None
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	166 self.mapfind_count += 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	167 last = self.l - 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	168 while self.index[last] != None:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	169 if last == 0:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	170 self.all = 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	171 self.allmap = 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	172 return None
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	173 last -= 1
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	174 end = (last + 1) * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	175 blocksize = self.s * 256
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	176 while end >= 0:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	177 start = max(end - blocksize, 0)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	178 self.dataf.seek(start)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	179 data = self.dataf.read(end - start)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	180 findend = end - start
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	181 while True:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	182 # we're searching backwards, so weh have to make sure
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	183 # we don't find a changeset where this node is a parent
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	184 off = data.rfind(node, 0, findend)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	185 findend = off
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	186 if off >= 0:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	187 i = off / self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	188 off = i * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	189 n = data[off + self.shaoffset:off + self.shaoffset + 20]
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	190 if n == node:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	191 self.map[n] = i + start / self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	192 return node
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	193 else:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	194 break
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	195 end -= blocksize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	196 return None
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	197
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	198 def loadindex(self, i=None, end=None):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	199 if self.all: return
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	200 all = False
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	201 if i == None:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	202 blockstart = 0
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	203 blocksize = (512 / self.s) * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	204 end = self.datasize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	205 all = True
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	206 else:
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	207 if end:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	208 blockstart = i * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	209 end = end * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	210 blocksize = end - blockstart
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	211 else:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	212 blockstart = (i & ~(32)) * self.s
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	213 blocksize = self.s * 64
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	214 end = blockstart + blocksize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	215 while blockstart < end:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	216 self.loadblock(blockstart, blocksize)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	217 blockstart += blocksize
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	218 if all: self.all = True
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	219
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1551 diff changeset	220 class lazyindex(object):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	221 """a lazy version of the index array"""
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	222 def __init__(self, parser):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	223 self.p = parser
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	224 def __len__(self):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	225 return len(self.p.index)
115 39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	226 def load(self, pos):
1403 bc3e66edb04c lazyindex fix, make load handle negative indexes properly. Eric Hopper <hopper@omnifarious.org> parents: 1402 diff changeset	227 if pos < 0:
bc3e66edb04c lazyindex fix, make load handle negative indexes properly. Eric Hopper <hopper@omnifarious.org> parents: 1402 diff changeset	228 pos += len(self.p.index)
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	229 self.p.loadindex(pos)
115 39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	230 return self.p.index[pos]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	231 def __getitem__(self, pos):
2080 1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	232 ret = self.p.index[pos] or self.load(pos)
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	233 if isinstance(ret, str):
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	234 ret = struct.unpack(self.p.indexformat, ret)
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	235 return ret
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	236 def __setitem__(self, pos, item):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	237 self.p.index[pos] = item
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	238 def __delitem__(self, pos):
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	239 del self.p.index[pos]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	240 def append(self, e):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	241 self.p.index.append(e)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	242
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1551 diff changeset	243 class lazymap(object):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	244 """a lazy version of the node map"""
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	245 def __init__(self, parser):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	246 self.p = parser
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	247 def load(self, key):
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	248 n = self.p.findnode(key)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	249 if n == None:
1214 34706a835d4a Smarter handling of revlog key errors mpm@selenic.com parents: 1201 diff changeset	250 raise KeyError(key)
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	251 def __contains__(self, key):
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	252 if key in self.p.map:
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	253 return True
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	254 self.p.loadmap()
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	255 return key in self.p.map
97 7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	256 def __iter__(self):
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	257 yield nullid
97 7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	258 for i in xrange(self.p.l):
2080 1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	259 ret = self.p.index[i]
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	260 if not ret:
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	261 self.p.loadindex(i)
2080 1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	262 ret = self.p.index[i]
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	263 if isinstance(ret, str):
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	264 ret = struct.unpack(self.p.indexformat, ret)
1cbb14c048cb Reduce index memory usage by storing the bare string instead of tuples mason@suse.com parents: 2079 diff changeset	265 yield ret[-1]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	266 def __getitem__(self, key):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	267 try:
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	268 return self.p.map[key]
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	269 except KeyError:
86 1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	270 try:
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	271 self.load(key)
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	272 return self.p.map[key]
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	273 except KeyError:
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	274 raise KeyError("node " + hex(key))
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	275 def __setitem__(self, key, val):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	276 self.p.map[key] = val
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	277 def __delitem__(self, key):
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	278 del self.p.map[key]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	279
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	280 class RevlogError(Exception): pass
7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	281
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1551 diff changeset	282 class revlog(object):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	283 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	284 the underlying revision storage object
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	285
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	286 A revlog consists of two parts, an index and the revision data.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	287
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	288 The index is a file with a fixed record size containing
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	289 information on each revision, includings its nodeid (hash), the
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	290 nodeids of its parents, the position and offset of its data within
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	291 the data file, and the revision it's based on. Finally, each entry
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	292 contains a linkrev entry that can serve as a pointer to external
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	293 data.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	294
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	295 The revision data itself is a linear collection of data chunks.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	296 Each chunk represents a revision and is usually represented as a
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	297 delta against the previous chunk. To bound lookup time, runs of
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	298 deltas are limited to about 2 times the length of the original
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	299 version data. This makes retrieval of a version proportional to
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	300 its size, or O(1) relative to the number of revisions.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	301
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	302 Both pieces of the revlog are written to in an append-only
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	303 fashion, which means we never need to rewrite a file to insert or
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	304 remove data, and can use some simple techniques to avoid the need
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	305 for locking while reading.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	306 """
2222 c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	307 def __init__(self, opener, indexfile, datafile,
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	308 defversion=REVLOG_DEFAULT_VERSION):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	309 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	310 create a revlog object
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	311
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	312 opener is a function that abstracts the file opening operation
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	313 and can be used to implement COW semantics or the like.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	314 """
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	315 self.indexfile = indexfile
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	316 self.datafile = datafile
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	317 self.opener = opener
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	318
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	319 self.indexstat = None
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	320 self.cache = None
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	321 self.chunkcache = None
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	322 self.defversion = defversion
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	323 self.load()
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	324
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	325 def load(self):
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	326 v = self.defversion
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	327 try:
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	328 f = self.opener(self.indexfile)
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	329 i = f.read(4)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	330 f.seek(0)
1322 b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	331 except IOError, inst:
b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	332 if inst.errno != errno.ENOENT:
b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	333 raise
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	334 i = ""
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	335 else:
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	336 try:
2176 9b42304d9896 fix file handling bugs on windows. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2089 diff changeset	337 st = util.fstat(f)
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	338 except AttributeError, inst:
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	339 st = None
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	340 else:
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	341 oldst = self.indexstat
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	342 if (oldst and st.st_dev == oldst.st_dev
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	343 and st.st_ino == oldst.st_ino
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	344 and st.st_mtime == oldst.st_mtime
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	345 and st.st_ctime == oldst.st_ctime):
2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	346 return
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	347 self.indexstat = st
2138 f5046cab9e2e Fix revlog-ng interaction with old-http. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2089 diff changeset	348 if len(i) > 0:
f5046cab9e2e Fix revlog-ng interaction with old-http. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2089 diff changeset	349 v = struct.unpack(versionformat, i)[0]
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	350 flags = v & ~0xFFFF
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	351 fmt = v & 0xFFFF
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	352 if fmt == REVLOGV0:
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	353 if flags:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	354 raise RevlogError(_("index %s invalid flags %x for format v0" %
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	355 (self.indexfile, flags)))
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	356 elif fmt == REVLOGNG:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	357 if flags & ~REVLOGNGINLINEDATA:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	358 raise RevlogError(_("index %s invalid flags %x for revlogng" %
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	359 (self.indexfile, flags)))
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	360 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	361 raise RevlogError(_("index %s invalid format %d" %
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	362 (self.indexfile, fmt)))
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	363 self.version = v
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	364 if v == REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	365 self.indexformat = indexformatv0
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	366 shaoffset = v0shaoffset
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	367 else:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	368 self.indexformat = indexformatng
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	369 shaoffset = ngshaoffset
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	370
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	371 if i:
2250 45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	372 if (lazyparser.safe_to_use and not self.inlinedata() and
45aef5ddcdbe windows: revlog.lazyparser not always safe to use. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2222 diff changeset	373 st and st.st_size > 10000):
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	374 # big index, let's parse it on demand
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	375 parser = lazyparser(f, st.st_size, self.indexformat, shaoffset)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	376 self.index = lazyindex(parser)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	377 self.nodemap = lazymap(parser)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	378 else:
2255 3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	379 self.parseindex(f, st)
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	380 if self.version != REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	381 e = list(self.index[0])
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	382 type = self.ngtype(e[0])
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	383 e[0] = self.offset_type(0, type)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	384 self.index[0] = e
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	385 else:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	386 self.nodemap = { nullid: -1}
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	387 self.index = []
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	388
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	389
2255 3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	390 def parseindex(self, fp, st):
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	391 s = struct.calcsize(self.indexformat)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	392 self.index = []
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	393 self.nodemap = {nullid: -1}
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	394 inline = self.inlinedata()
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	395 n = 0
2255 3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	396 leftover = None
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	397 while True:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	398 if st:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	399 data = fp.read(65536)
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	400 else:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	401 # hack for httprangereader, it doesn't do partial reads well
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	402 data = fp.read()
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	403 if not data:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	404 break
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	405 if n == 0 and self.inlinedata():
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	406 # cache the first chunk
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	407 self.chunkcache = (0, data)
2289 854954fd410a Fix revlog.parseindex Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2255 diff changeset	408 if leftover:
854954fd410a Fix revlog.parseindex Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2255 diff changeset	409 data = leftover + data
854954fd410a Fix revlog.parseindex Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2255 diff changeset	410 leftover = None
2255 3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	411 off = 0
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	412 l = len(data)
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	413 while off < l:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	414 if l - off < s:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	415 leftover = data[off:]
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	416 break
2289 854954fd410a Fix revlog.parseindex Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2255 diff changeset	417 cur = data[off:off + s]
854954fd410a Fix revlog.parseindex Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2255 diff changeset	418 off += s
2255 3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	419 e = struct.unpack(self.indexformat, cur)
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	420 self.index.append(e)
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	421 self.nodemap[e[-1]] = n
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	422 n += 1
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	423 if inline:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	424 off += e[1]
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	425 if off > l:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	426 # some things don't seek well, just read it
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	427 fp.read(off - l)
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	428 if not st:
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	429 break
3f38e872f39a Reduce ram used for very large inlined index files mason@suse.com parents: 2250 diff changeset	430
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	431
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	432 def ngoffset(self, q):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	433 if q & 0xFFFF:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	434 raise RevlogError(_('%s: incompatible revision flag %x') %
2141 ed631e83fa06 Corrected error message for incompatible revision flags. Thomas Arendsen Hein <thomas@intevation.de> parents: 2138 diff changeset	435 (self.indexfile, q))
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	436 return long(q >> 16)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	437
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	438 def ngtype(self, q):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	439 return int(q & 0xFFFF)
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	440
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	441 def offset_type(self, offset, type):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	442 return long(long(offset) << 16 \| type)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	443
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	444 def loadindex(self, start, end):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	445 """load a block of indexes all at once from the lazy parser"""
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	446 if isinstance(self.index, lazyindex):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	447 self.index.p.loadindex(start, end)
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	448
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	449 def loadindexmap(self):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	450 """loads both the map and the index from the lazy parser"""
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	451 if isinstance(self.index, lazyindex):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	452 p = self.index.p
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	453 p.loadindex()
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	454 self.nodemap = p.map
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	455
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	456 def loadmap(self):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	457 """loads the map from the lazy parser"""
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	458 if isinstance(self.nodemap, lazymap):
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	459 self.nodemap.p.loadmap()
ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	460 self.nodemap = self.nodemap.p.map
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	461
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	462 def inlinedata(self): return self.version & REVLOGNGINLINEDATA
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	463 def tip(self): return self.node(len(self.index) - 1)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	464 def count(self): return len(self.index)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	465 def node(self, rev):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	466 return (rev < 0) and nullid or self.index[rev][-1]
1201 59bfbdbc38f6 revlog: raise informative exception if file is missing. Bryan O'Sullivan <bos@serpentine.com> parents: 1099 diff changeset	467 def rev(self, node):
59bfbdbc38f6 revlog: raise informative exception if file is missing. Bryan O'Sullivan <bos@serpentine.com> parents: 1099 diff changeset	468 try:
59bfbdbc38f6 revlog: raise informative exception if file is missing. Bryan O'Sullivan <bos@serpentine.com> parents: 1099 diff changeset	469 return self.nodemap[node]
59bfbdbc38f6 revlog: raise informative exception if file is missing. Bryan O'Sullivan <bos@serpentine.com> parents: 1099 diff changeset	470 except KeyError:
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	471 raise RevlogError(_('%s: no node %s') % (self.indexfile, hex(node)))
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	472 def linkrev(self, node): return self.index[self.rev(node)][-4]
2 ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	473 def parents(self, node):
ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	474 if node == nullid: return (nullid, nullid)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	475 r = self.rev(node)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	476 d = self.index[r][-3:-1]
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	477 if self.version == REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	478 return d
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	479 return [ self.node(x) for x in d ]
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	480 def start(self, rev):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	481 if rev < 0:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	482 return -1
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	483 if self.version != REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	484 return self.ngoffset(self.index[rev][0])
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	485 return self.index[rev][0]
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	486
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	487 def end(self, rev): return self.start(rev) + self.length(rev)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	488
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	489 def size(self, rev):
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	490 """return the length of the uncompressed text for a given revision"""
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	491 l = -1
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	492 if self.version != REVLOGV0:
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	493 l = self.index[rev][2]
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	494 if l >= 0:
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	495 return l
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	496
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	497 t = self.revision(self.node(rev))
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	498 return len(t)
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	499
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	500 # alternate implementation, The advantage to this code is it
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	501 # will be faster for a single revision. But, the results are not
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	502 # cached, so finding the size of every revision will be slower.
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	503 """
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	504 if self.cache and self.cache[1] == rev:
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	505 return len(self.cache[2])
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	506
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	507 base = self.base(rev)
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	508 if self.cache and self.cache[1] >= base and self.cache[1] < rev:
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	509 base = self.cache[1]
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	510 text = self.cache[2]
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	511 else:
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	512 text = self.revision(self.node(base))
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	513
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	514 l = len(text)
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	515 for x in xrange(base + 1, rev + 1):
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	516 l = mdiff.patchedsize(l, self.chunk(x))
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	517 return l
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	518 """
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	519
1941 7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	520 def length(self, rev):
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	521 if rev < 0:
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	522 return 0
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	523 else:
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	524 return self.index[rev][1]
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	525 def base(self, rev): return (rev < 0) and rev or self.index[rev][-5]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	526
1074 55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	527 def reachable(self, rev, stop=None):
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	528 reachable = {}
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	529 visit = [rev]
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	530 reachable[rev] = 1
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	531 if stop:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	532 stopn = self.rev(stop)
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	533 else:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	534 stopn = 0
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	535 while visit:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	536 n = visit.pop(0)
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	537 if n == stop:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	538 continue
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	539 if n == nullid:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	540 continue
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	541 for p in self.parents(n):
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	542 if self.rev(p) < stopn:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	543 continue
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	544 if p not in reachable:
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	545 reachable[p] = 1
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	546 visit.append(p)
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	547 return reachable
55bf5cfde69e Add revlog.reachable to find a graph of ancestors for a given rev mason@suse.com parents: 1073 diff changeset	548
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	549 def nodesbetween(self, roots=None, heads=None):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	550 """Return a tuple containing three elements. Elements 1 and 2 contain
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	551 a final list bases and heads after all the unreachable ones have been
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	552 pruned. Element 0 contains a topologically sorted list of all
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	553
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	554 nodes that satisfy these constraints:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	555 1. All nodes must be descended from a node in roots (the nodes on
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	556 roots are considered descended from themselves).
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	557 2. All nodes must also be ancestors of a node in heads (the nodes in
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	558 heads are considered to be their own ancestors).
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	559
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	560 If roots is unspecified, nullid is assumed as the only root.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	561 If heads is unspecified, it is taken to be the output of the
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	562 heads method (i.e. a list of all nodes in the repository that
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	563 have no children)."""
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	564 nonodes = ([], [], [])
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	565 if roots is not None:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	566 roots = list(roots)
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	567 if not roots:
26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	568 return nonodes
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	569 lowestrev = min([self.rev(n) for n in roots])
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	570 else:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	571 roots = [nullid] # Everybody's a descendent of nullid
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	572 lowestrev = -1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	573 if (lowestrev == -1) and (heads is None):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	574 # We want _all_ the nodes!
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	575 return ([self.node(r) for r in xrange(0, self.count())],
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	576 [nullid], list(self.heads()))
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	577 if heads is None:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	578 # All nodes are ancestors, so the latest ancestor is the last
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	579 # node.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	580 highestrev = self.count() - 1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	581 # Set ancestors to None to signal that every node is an ancestor.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	582 ancestors = None
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	583 # Set heads to an empty dictionary for later discovery of heads
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	584 heads = {}
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	585 else:
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	586 heads = list(heads)
26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	587 if not heads:
26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	588 return nonodes
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	589 ancestors = {}
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	590 # Start at the top and keep marking parents until we're done.
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	591 nodestotag = heads[:]
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	592 # Turn heads into a dictionary so we can remove 'fake' heads.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	593 # Also, later we will be using it to filter out the heads we can't
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	594 # find from roots.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	595 heads = dict.fromkeys(heads, 0)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	596 # Remember where the top was so we can use it as a limit later.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	597 highestrev = max([self.rev(n) for n in nodestotag])
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	598 while nodestotag:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	599 # grab a node to tag
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	600 n = nodestotag.pop()
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	601 # Never tag nullid
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	602 if n == nullid:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	603 continue
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	604 # A node's revision number represents its place in a
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	605 # topologically sorted list of nodes.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	606 r = self.rev(n)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	607 if r >= lowestrev:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	608 if n not in ancestors:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	609 # If we are possibly a descendent of one of the roots
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	610 # and we haven't already been marked as an ancestor
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	611 ancestors[n] = 1 # Mark as ancestor
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	612 # Add non-nullid parents to list of nodes to tag.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	613 nodestotag.extend([p for p in self.parents(n) if
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	614 p != nullid])
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	615 elif n in heads: # We've seen it before, is it a fake head?
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	616 # So it is, real heads should not be the ancestors of
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	617 # any other heads.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	618 heads.pop(n)
1459 106fdec8e1fb Fix small bug in nodesbetween if heads is [nullid]. Eric Hopper <hopper@omnifarious.org> parents: 1458 diff changeset	619 if not ancestors:
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	620 return nonodes
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	621 # Now that we have our set of ancestors, we want to remove any
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	622 # roots that are not ancestors.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	623
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	624 # If one of the roots was nullid, everything is included anyway.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	625 if lowestrev > -1:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	626 # But, since we weren't, let's recompute the lowest rev to not
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	627 # include roots that aren't ancestors.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	628
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	629 # Filter out roots that aren't ancestors of heads
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	630 roots = [n for n in roots if n in ancestors]
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	631 # Recompute the lowest revision
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	632 if roots:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	633 lowestrev = min([self.rev(n) for n in roots])
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	634 else:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	635 # No more roots? Return empty list
1463 26e73acc0cdf Fix to handle case of empty list for roots or heads in nodesbetween. Eric Hopper <hopper@omnifarious.org> parents: 1459 diff changeset	636 return nonodes
1457 518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	637 else:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	638 # We are descending from nullid, and don't need to care about
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	639 # any other roots.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	640 lowestrev = -1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	641 roots = [nullid]
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	642 # Transform our roots list into a 'set' (i.e. a dictionary where the
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	643 # values don't matter.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	644 descendents = dict.fromkeys(roots, 1)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	645 # Also, keep the original roots so we can filter out roots that aren't
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	646 # 'real' roots (i.e. are descended from other roots).
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	647 roots = descendents.copy()
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	648 # Our topologically sorted list of output nodes.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	649 orderedout = []
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	650 # Don't start at nullid since we don't want nullid in our output list,
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	651 # and if nullid shows up in descedents, empty parents will look like
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	652 # they're descendents.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	653 for r in xrange(max(lowestrev, 0), highestrev + 1):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	654 n = self.node(r)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	655 isdescendent = False
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	656 if lowestrev == -1: # Everybody is a descendent of nullid
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	657 isdescendent = True
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	658 elif n in descendents:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	659 # n is already a descendent
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	660 isdescendent = True
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	661 # This check only needs to be done here because all the roots
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	662 # will start being marked is descendents before the loop.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	663 if n in roots:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	664 # If n was a root, check if it's a 'real' root.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	665 p = tuple(self.parents(n))
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	666 # If any of its parents are descendents, it's not a root.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	667 if (p[0] in descendents) or (p[1] in descendents):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	668 roots.pop(n)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	669 else:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	670 p = tuple(self.parents(n))
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	671 # A node is a descendent if either of its parents are
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	672 # descendents. (We seeded the dependents list with the roots
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	673 # up there, remember?)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	674 if (p[0] in descendents) or (p[1] in descendents):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	675 descendents[n] = 1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	676 isdescendent = True
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	677 if isdescendent and ((ancestors is None) or (n in ancestors)):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	678 # Only include nodes that are both descendents and ancestors.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	679 orderedout.append(n)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	680 if (ancestors is not None) and (n in heads):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	681 # We're trying to figure out which heads are reachable
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	682 # from roots.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	683 # Mark this head as having been reached
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	684 heads[n] = 1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	685 elif ancestors is None:
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	686 # Otherwise, we're trying to discover the heads.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	687 # Assume this is a head because if it isn't, the next step
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	688 # will eventually remove it.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	689 heads[n] = 1
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	690 # But, obviously its parents aren't.
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	691 for p in self.parents(n):
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	692 heads.pop(p, None)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	693 heads = [n for n in heads.iterkeys() if heads[n] != 0]
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	694 roots = roots.keys()
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	695 assert orderedout
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	696 assert roots
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	697 assert heads
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	698 return (orderedout, roots, heads)
518da3c3b6ce This implements the nodesbetween method, and it removes the newer method Eric Hopper <hopper@omnifarious.org> parents: 1351 diff changeset	699
1551 e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	700 def heads(self, start=None):
1550 ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	701 """return the list of all nodes that have no children
1551 e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	702
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	703 if start is specified, only heads that are descendants of
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	704 start will be returned
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	705
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	706 """
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	707 if start is None:
e793cbc8be00 Fixes to "hg heads -r FOO": Thomas Arendsen Hein <thomas@intevation.de> parents: 1550 diff changeset	708 start = nullid
1550 ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	709 reachable = {start: 1}
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	710 heads = {start: 1}
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	711 startrev = self.rev(start)
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	712
1550 ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	713 for r in xrange(startrev + 1, self.count()):
221 2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	714 n = self.node(r)
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	715 for pn in self.parents(n):
1550 ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	716 if pn in reachable:
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	717 reachable[n] = 1
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	718 heads[n] = 1
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	719 if pn in heads:
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	720 del heads[pn]
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1535 diff changeset	721 return heads.keys()
370 c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	722
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	723 def children(self, node):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	724 """find the children of a given node"""
370 c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	725 c = []
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	726 p = self.rev(node)
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	727 for r in range(p + 1, self.count()):
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	728 n = self.node(r)
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	729 for pn in self.parents(n):
854 473c030d34a6 Fixed revlog.children. Tristan Wibberley <tristan@wibberley.org> parents: 655 diff changeset	730 if pn == node:
473c030d34a6 Fixed revlog.children. Tristan Wibberley <tristan@wibberley.org> parents: 655 diff changeset	731 c.append(n)
370 c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	732 continue
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	733 elif pn == nullid:
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	734 continue
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	735 return c
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	736
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	737 def lookup(self, id):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	738 """locate a node based on revision number or subset of hex nodeid"""
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	739 try:
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	740 rev = int(id)
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	741 if str(rev) != id: raise ValueError
e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	742 if rev < 0: rev = self.count() + rev
476 0a338d506268 Really _call_ method revlog.count in revlog.lookup() Thomas Arendsen Hein <thomas@intevation.de> parents: 469 diff changeset	743 if rev < 0 or rev >= self.count(): raise ValueError
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	744 return self.node(rev)
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	745 except (ValueError, OverflowError):
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	746 c = []
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	747 for n in self.nodemap:
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	748 if hex(n).startswith(id):
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	749 c.append(n)
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	750 if len(c) > 1: raise RevlogError(_("Ambiguous identifier"))
9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	751 if len(c) < 1: raise RevlogError(_("No match found"))
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	752 return c[0]
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	753
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	754 return None
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	755
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	756 def diff(self, a, b):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	757 """return a delta between two revisions"""
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	758 return mdiff.textdiff(a, b)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	759
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	760 def patches(self, t, pl):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	761 """apply a list of patches to a string"""
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	762 return mdiff.patches(t, pl)
ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	763
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	764 def chunk(self, rev, df=None, cachelen=4096):
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	765 start, length = self.start(rev), self.length(rev)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	766 inline = self.inlinedata()
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	767 if inline:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	768 start += (rev + 1) * struct.calcsize(self.indexformat)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	769 end = start + length
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	770 def loadcache(df):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	771 cache_length = max(cachelen, length) # 4k
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	772 if not df:
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	773 if inline:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	774 df = self.opener(self.indexfile)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	775 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	776 df = self.opener(self.datafile)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	777 df.seek(start)
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	778 self.chunkcache = (start, df.read(cache_length))
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	779
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	780 if not self.chunkcache:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	781 loadcache(df)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	782
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	783 cache_start = self.chunkcache[0]
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	784 cache_end = cache_start + len(self.chunkcache[1])
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	785 if start >= cache_start and end <= cache_end:
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	786 # it is cached
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	787 offset = start - cache_start
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	788 else:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	789 loadcache(df)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	790 offset = 0
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	791
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	792 #def checkchunk():
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	793 # df = self.opener(self.datafile)
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	794 # df.seek(start)
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	795 # return df.read(length)
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	796 #assert s == checkchunk()
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	797 return decompress(self.chunkcache[1][offset:offset + length])
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	798
119 c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	799 def delta(self, node):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	800 """return or calculate a delta between a node and its predecessor"""
119 c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	801 r = self.rev(node)
1941 7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	802 return self.revdiff(r - 1, r)
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	803
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	804 def revdiff(self, rev1, rev2):
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	805 """return or calculate a delta between two revisions"""
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	806 b1 = self.base(rev1)
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	807 b2 = self.base(rev2)
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	808 if b1 == b2 and rev1 + 1 == rev2:
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	809 return self.chunk(rev2)
119 c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	810 else:
1941 7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	811 return self.diff(self.revision(self.node(rev1)),
7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	812 self.revision(self.node(rev2)))
119 c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	813
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	814 def revision(self, node):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	815 """return an uncompressed revision of a given"""
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	816 if node == nullid: return ""
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	817 if self.cache and self.cache[0] == node: return self.cache[2]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	818
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	819 # look up what we need to read
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	820 text = None
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	821 rev = self.rev(node)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	822 base = self.base(rev)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	823
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	824 if self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	825 # we probably have the whole chunk cached
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	826 df = None
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	827 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	828 df = self.opener(self.datafile)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	829
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	830 # do we have useful data cached?
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	831 if self.cache and self.cache[1] >= base and self.cache[1] < rev:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	832 base = self.cache[1]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	833 text = self.cache[2]
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	834 self.loadindex(base, rev + 1)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	835 else:
2079 ee96ca273f32 New lazy index code for revlogs. mason@suse.com parents: 2078 diff changeset	836 self.loadindex(base, rev + 1)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	837 text = self.chunk(base, df=df)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	838
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	839 bins = []
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	840 for r in xrange(base + 1, rev + 1):
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	841 bins.append(self.chunk(r, df=df))
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	842
1941 7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	843 text = self.patches(text, bins)
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	844
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	845 p1, p2 = self.parents(node)
26 9cf83bf9ad38 Simplify integrity checking mpm@selenic.com parents: 14 diff changeset	846 if node != hash(text, p1, p2):
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	847 raise RevlogError(_("integrity check failed on %s:%d")
98 3dde7c87e36d Add paranoia to diff code mpm@selenic.com parents: 97 diff changeset	848 % (self.datafile, rev))
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	849
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	850 self.cache = (node, rev, text)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	851 return text
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	852
2075 343aeefb553b Make the appendfile class inline-data index friendly mason@suse.com parents: 2073 diff changeset	853 def checkinlinesize(self, tr, fp=None):
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	854 if not self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	855 return
2075 343aeefb553b Make the appendfile class inline-data index friendly mason@suse.com parents: 2073 diff changeset	856 if not fp:
343aeefb553b Make the appendfile class inline-data index friendly mason@suse.com parents: 2073 diff changeset	857 fp = self.opener(self.indexfile, 'r')
2082 856f0ba200bc Additional appendfile fixes for interleaved data/index files mason@suse.com parents: 2081 diff changeset	858 fp.seek(0, 2)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	859 size = fp.tell()
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	860 if size < 131072:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	861 return
2084 d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	862 trinfo = tr.find(self.indexfile)
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	863 if trinfo == None:
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	864 raise RevlogError(_("%s not found in the transaction" %
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	865 self.indexfile))
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	866
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	867 trindex = trinfo[2]
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	868 dataoff = self.start(trindex)
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	869
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	870 tr.add(self.datafile, dataoff)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	871 df = self.opener(self.datafile, 'w')
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	872 calc = struct.calcsize(self.indexformat)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	873 for r in xrange(self.count()):
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	874 start = self.start(r) + (r + 1) * calc
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	875 length = self.length(r)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	876 fp.seek(start)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	877 d = fp.read(length)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	878 df.write(d)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	879 fp.close()
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	880 df.close()
2076 d007df6daf8e Create an atomic opener that does not automatically rename on close mason@suse.com parents: 2075 diff changeset	881 fp = self.opener(self.indexfile, 'w', atomictemp=True)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	882 self.version &= ~(REVLOGNGINLINEDATA)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	883 if self.count():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	884 x = self.index[0]
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	885 e = struct.pack(self.indexformat, *x)[4:]
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	886 l = struct.pack(versionformat, self.version)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	887 fp.write(l)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	888 fp.write(e)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	889
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	890 for i in xrange(1, self.count()):
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	891 x = self.index[i]
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	892 e = struct.pack(self.indexformat, *x)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	893 fp.write(e)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	894
2076 d007df6daf8e Create an atomic opener that does not automatically rename on close mason@suse.com parents: 2075 diff changeset	895 # if we don't call rename, the temp file will never replace the
d007df6daf8e Create an atomic opener that does not automatically rename on close mason@suse.com parents: 2075 diff changeset	896 # real index
d007df6daf8e Create an atomic opener that does not automatically rename on close mason@suse.com parents: 2075 diff changeset	897 fp.rename()
2084 d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	898
d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	899 tr.replace(self.indexfile, trindex * calc)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	900 self.chunkcache = None
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	901
644 6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	902 def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	903 """add a revision to the log
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	904
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	905 text - the revision data to add
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	906 transaction - the transaction object used for rollback
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	907 link - the linkrev data to add
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	908 p1, p2 - the parent nodeids of the revision
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	909 d - an optional precomputed delta
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	910 """
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	911 if text is None: text = ""
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	912 if p1 is None: p1 = self.tip()
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	913 if p2 is None: p2 = nullid
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	914
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	915 node = hash(text, p1, p2)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	916
301 5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	917 if node in self.nodemap:
5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	918 return node
5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	919
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	920 n = self.count()
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	921 t = n - 1
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	922
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	923 if n:
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	924 base = self.base(t)
b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	925 start = self.start(base)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	926 end = self.end(t)
644 6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	927 if not d:
6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	928 prev = self.revision(self.tip())
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	929 d = self.diff(prev, str(text))
98 3dde7c87e36d Add paranoia to diff code mpm@selenic.com parents: 97 diff changeset	930 data = compress(d)
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	931 l = len(data[1]) + len(data[0])
3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	932 dist = end - start + l
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	933
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	934 # full versions are inserted when the needed deltas
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	935 # become comparable to the uncompressed text
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	936 if not n or dist > len(text) * 2:
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	937 data = compress(text)
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	938 l = len(data[1]) + len(data[0])
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	939 base = n
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	940 else:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	941 base = self.base(t)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	942
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	943 offset = 0
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	944 if t >= 0:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	945 offset = self.end(t)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	946
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	947 if self.version == REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	948 e = (offset, l, base, link, p1, p2, node)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	949 else:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	950 e = (self.offset_type(offset, 0), l, len(text),
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	951 base, link, self.rev(p1), self.rev(p2), node)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	952
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	953 self.index.append(e)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	954 self.nodemap[node] = n
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	955 entry = struct.pack(self.indexformat, *e)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	956
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	957 if not self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	958 transaction.add(self.datafile, offset)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	959 transaction.add(self.indexfile, n * len(entry))
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	960 f = self.opener(self.datafile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	961 if data[0]:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	962 f.write(data[0])
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	963 f.write(data[1])
2089 cb99c711c59f make appendfile simpler so it does not break with revlogng on windows. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2084 diff changeset	964 f.close()
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	965 f = self.opener(self.indexfile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	966 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	967 f = self.opener(self.indexfile, "a+")
2077 4d0700ae0991 Fix inlined revlogs to seek to eof after opening "a+" mason@suse.com parents: 2076 diff changeset	968 f.seek(0, 2)
2084 d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	969 transaction.add(self.indexfile, f.tell(), self.count() - 1)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	970
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	971 if len(self.index) == 1 and self.version != REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	972 l = struct.pack(versionformat, self.version)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	973 f.write(l)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	974 entry = entry[4:]
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	975
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	976 f.write(entry)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	977
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	978 if self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	979 f.write(data[0])
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	980 f.write(data[1])
2075 343aeefb553b Make the appendfile class inline-data index friendly mason@suse.com parents: 2073 diff changeset	981 self.checkinlinesize(transaction, f)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	982
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	983 self.cache = (node, n, text)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	984 return node
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	985
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	986 def ancestor(self, a, b):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	987 """calculate the least common ancestor of nodes a and b"""
2081 416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	988
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	989 # start with some short cuts for the linear cases
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	990 if a == b:
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	991 return a
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	992 ra = self.rev(a)
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	993 rb = self.rev(b)
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	994 if ra < rb:
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	995 last = b
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	996 first = a
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	997 else:
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	998 last = a
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	999 first = b
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1000
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1001 # reachable won't include stop in the list, so we have to use a parent
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1002 reachable = self.reachable(last, stop=self.parents(first)[0])
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1003 if first in reachable:
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1004 return first
416d8b2a75b8 Speedup revlog.ancestors for the linear case Chris Mason <mason@suse.com> parents: 2080 diff changeset	1005
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1006 # calculate the distance of every node from root
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1007 dist = {nullid: 0}
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1008 for i in xrange(self.count()):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1009 n = self.node(i)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1010 p1, p2 = self.parents(n)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1011 dist[n] = max(dist[p1], dist[p2]) + 1
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	1012
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1013 # traverse ancestors in order of decreasing distance from root
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1014 def ancestors(node):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1015 # we store negative distances because heap returns smallest member
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1016 h = [(-dist[node], node)]
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1017 seen = {}
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1018 while h:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1019 d, n = heapq.heappop(h)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1020 if n not in seen:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1021 seen[n] = 1
1351 0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1022 yield (-d, n)
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1023 for p in self.parents(n):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1024 heapq.heappush(h, (-dist[p], p))
45 f2b2d5daec30 Fix recursion depth trouble with ancestor algorithm mpm@selenic.com parents: 41 diff changeset	1025
1351 0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1026 def generations(node):
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1027 sg, s = None, {}
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1028 for g,n in ancestors(node):
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1029 if g != sg:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1030 if sg:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1031 yield sg, s
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1032 sg, s = g, {n:1}
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1033 else:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1034 s[n] = 1
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1035 yield sg, s
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1036
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1037 x = generations(a)
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1038 y = generations(b)
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1039 gx = x.next()
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1040 gy = y.next()
45 f2b2d5daec30 Fix recursion depth trouble with ancestor algorithm mpm@selenic.com parents: 41 diff changeset	1041
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1042 # increment each ancestor list until it is closer to root than
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1043 # the other, or they match
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	1044 while 1:
1351 0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1045 #print "ancestor gen %s %s" % (gx[0], gy[0])
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1046 if gx[0] == gy[0]:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1047 # find the intersection
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1048 i = [ n for n in gx[1] if n in gy[1] ]
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1049 if i:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1050 return i[0]
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1051 else:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1052 #print "next"
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1053 gy = y.next()
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1054 gx = x.next()
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1055 elif gx[0] < gy[0]:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1056 #print "next y"
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1057 gy = y.next()
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1058 else:
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1059 #print "next x"
0e2be889ccd7 Repair ancestor logic, fix up test cases Matt Mackall <mpm@selenic.com> parents: 1325 diff changeset	1060 gx = x.next()
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	1061
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	1062 def group(self, nodelist, lookup, infocollect=None):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1063 """calculate a delta group
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1064
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1065 Given a list of changeset revs, return a set of deltas and
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1066 metadata corresponding to nodes. the first delta is
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1067 parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1068 have this parent as it has all history before these
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1069 changesets. parent is parent[0]
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1070 """
1458 1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup Eric Hopper <hopper@omnifarious.org> parents: 1457 diff changeset	1071 revs = [self.rev(n) for n in nodelist]
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1072
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1073 # if we don't have any revisions touched by these changesets, bail
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1074 if not revs:
1981 736b6c96bbbc make incoming work via ssh (issue139); move chunk code into separate module. Thomas Arendsen Hein <thomas@intevation.de> parents: 1941 diff changeset	1075 yield changegroup.closechunk()
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1076 return
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1077
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1078 # add the parent of the first rev
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1079 p = self.parents(self.node(revs[0]))[0]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1080 revs.insert(0, self.rev(p))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1081
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1082 # build deltas
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	1083 for d in xrange(0, len(revs) - 1):
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1084 a, b = revs[d], revs[d + 1]
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	1085 nb = self.node(b)
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1086
1458 1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup Eric Hopper <hopper@omnifarious.org> parents: 1457 diff changeset	1087 if infocollect is not None:
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	1088 infocollect(nb)
1458 1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup Eric Hopper <hopper@omnifarious.org> parents: 1457 diff changeset	1089
1941 7518823709a2 revlog.py: factorization and fixes for rev < 0 (nullid) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1853 diff changeset	1090 d = self.revdiff(a, b)
1598 14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	1091 p = self.parents(nb)
14d1f1868bf6 cleanup of revlog.group when repository is local Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1559 diff changeset	1092 meta = nb + p[0] + p[1] + lookup(nb)
1981 736b6c96bbbc make incoming work via ssh (issue139); move chunk code into separate module. Thomas Arendsen Hein <thomas@intevation.de> parents: 1941 diff changeset	1093 yield changegroup.genchunk("%s%s" % (meta, d))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1094
1981 736b6c96bbbc make incoming work via ssh (issue139); move chunk code into separate module. Thomas Arendsen Hein <thomas@intevation.de> parents: 1941 diff changeset	1095 yield changegroup.closechunk()
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1096
1062 6d5a62a549fa pep-0008 cleanup benoit.boissinot@ens-lyon.fr parents: 902 diff changeset	1097 def addgroup(self, revs, linkmapper, transaction, unique=0):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1098 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1099 add a delta group
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1100
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1101 given a set of deltas, add them to the revision log. the
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1102 first delta is against its parent, which should be in our
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1103 log, the rest are against the previous delta.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1104 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1105
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	1106 #track the base of the current delta log
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1107 r = self.count()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1108 t = r - 1
2002 4aab906517c6 Calling revlog.addgroup with an empty changegroup now raises RevlogError. Thomas Arendsen Hein <thomas@intevation.de> parents: 1981 diff changeset	1109 node = None
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	1110
655 b3bba126b04a Fix out of range regression Matt Mackall <mpm@selenic.com> parents: 653 diff changeset	1111 base = prev = -1
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	1112 start = end = textlen = 0
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1113 if r:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1114 end = self.end(t)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1115
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1116 ifh = self.opener(self.indexfile, "a+")
2077 4d0700ae0991 Fix inlined revlogs to seek to eof after opening "a+" mason@suse.com parents: 2076 diff changeset	1117 ifh.seek(0, 2)
2084 d66278012853 Chris Mason <mason@suse.com> parents: 2082 diff changeset	1118 transaction.add(self.indexfile, ifh.tell(), self.count())
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1119 if self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1120 dfh = None
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1121 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1122 transaction.add(self.datafile, end)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1123 dfh = self.opener(self.datafile, "a")
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1124
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1125 # loop through our set of deltas
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1126 chain = None
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1127 for chunk in revs:
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1128 node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80])
94 7daef883134f Refactor merge code mpm@selenic.com parents: 86 diff changeset	1129 link = linkmapper(cs)
77 bed15e766511 Fix bug in lazymap code mpm@selenic.com parents: 76 diff changeset	1130 if node in self.nodemap:
224 ccbcc4d76f81 fix bad assumption about uniqueness of file versions mpm@selenic.com parents: 221 diff changeset	1131 # this can happen if two branches make the same change
1218 cde6818e082a Add preliminary support for the bundle and unbundle commands mpm@selenic.com parents: 1214 diff changeset	1132 # if unique:
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	1133 # raise RevlogError(_("already have %s") % hex(node[:4]))
653 94cdd02792b5 Fix corruption resulting from skipping parts of a revision group Matt Mackall <mpm@selenic.com> parents: 651 diff changeset	1134 chain = node
224 ccbcc4d76f81 fix bad assumption about uniqueness of file versions mpm@selenic.com parents: 221 diff changeset	1135 continue
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1136 delta = chunk[80:]
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1137
1509 46a07392cf28 Add safety check for addgroup Matt Mackall <mpm@selenic.com> parents: 1494 diff changeset	1138 for p in (p1, p2):
46a07392cf28 Add safety check for addgroup Matt Mackall <mpm@selenic.com> parents: 1494 diff changeset	1139 if not p in self.nodemap:
2295 9c15f85e61b1 fix a typo in an error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 2289 diff changeset	1140 raise RevlogError(_("unknown parent %s") % short(p))
1509 46a07392cf28 Add safety check for addgroup Matt Mackall <mpm@selenic.com> parents: 1494 diff changeset	1141
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1142 if not chain:
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1143 # retrieve the parent revision of the delta chain
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1144 chain = p1
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	1145 if not chain in self.nodemap:
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	1146 raise RevlogError(_("unknown base %s") % short(chain[:4]))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1147
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1148 # full versions are inserted when the needed deltas become
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1149 # comparable to the uncompressed text or when the previous
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1150 # version is not the one we have a delta against. We use
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1151 # the size of the previous full rev as a proxy for the
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1152 # current size.
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1153
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1154 if chain == prev:
1533 3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	1155 tempd = compress(delta)
3d11f81c9145 Reduce string duplication in compression code mason@suse.com parents: 1509 diff changeset	1156 cdelta = tempd[0] + tempd[1]
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	1157 textlen = mdiff.patchedsize(textlen, delta)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1158
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	1159 if chain != prev or (end - start + len(cdelta)) > textlen * 2:
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1160 # flush our writes here so we can read it in revision
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1161 if dfh:
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1162 dfh.flush()
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1163 ifh.flush()
65 d40cc5aacc31 Fix up a bunch of bugs in the new merge code mpm@selenic.com parents: 64 diff changeset	1164 text = self.revision(chain)
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	1165 text = self.patches(text, [delta])
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1166 chk = self.addrevision(text, transaction, link, p1, p2)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1167 if chk != node:
1402 9d2c2e6b32b5 i18n part2: use '_' for all strings who are part of the user interface Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1400 diff changeset	1168 raise RevlogError(_("consistency error adding group"))
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	1169 textlen = len(text)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1170 else:
2142 8a1e2a9c7013 Replaced 0 with REVLOGV0 where this meaning is used. Thomas Arendsen Hein <thomas@intevation.de> parents: 2141 diff changeset	1171 if self.version == REVLOGV0:
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1172 e = (end, len(cdelta), base, link, p1, p2, node)
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1173 else:
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	1174 e = (self.offset_type(end, 0), len(cdelta), textlen, base,
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1175 link, self.rev(p1), self.rev(p2), node)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1176 self.index.append(e)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1177 self.nodemap[node] = r
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1178 if self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1179 ifh.write(struct.pack(self.indexformat, *e))
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1180 ifh.write(cdelta)
2075 343aeefb553b Make the appendfile class inline-data index friendly mason@suse.com parents: 2073 diff changeset	1181 self.checkinlinesize(transaction, ifh)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1182 if not self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1183 dfh = self.opener(self.datafile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1184 ifh = self.opener(self.indexfile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1185 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1186 if not dfh:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1187 # addrevision switched from inline to conventional
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1188 # reopen the index
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1189 dfh = self.opener(self.datafile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1190 ifh = self.opener(self.indexfile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1191 dfh.write(cdelta)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1192 ifh.write(struct.pack(self.indexformat, *e))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1193
65 d40cc5aacc31 Fix up a bunch of bugs in the new merge code mpm@selenic.com parents: 64 diff changeset	1194 t, r, chain, prev = r, r + 1, node, node
1749 d457fec76ab0 fix warnings from pychecker (unused variables and shadowing) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1711 diff changeset	1195 base = self.base(t)
d457fec76ab0 fix warnings from pychecker (unused variables and shadowing) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1711 diff changeset	1196 start = self.start(base)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1197 end = self.end(t)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1198
2002 4aab906517c6 Calling revlog.addgroup with an empty changegroup now raises RevlogError. Thomas Arendsen Hein <thomas@intevation.de> parents: 1981 diff changeset	1199 if node is None:
4aab906517c6 Calling revlog.addgroup with an empty changegroup now raises RevlogError. Thomas Arendsen Hein <thomas@intevation.de> parents: 1981 diff changeset	1200 raise RevlogError(_("group to be added is empty"))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	1201 return node
1493 1a216cb4ee64 verify: add check for mismatch of index and data length Matt Mackall <mpm@selenic.com> parents: 1469 diff changeset	1202
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1203 def strip(self, rev, minlink):
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1204 if self.count() == 0 or rev >= self.count():
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1205 return
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1206
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1207 if isinstance(self.index, lazyindex):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1208 self.loadindexmap()
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1209
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1210 # When stripping away a revision, we need to make sure it
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1211 # does not actually belong to an older changeset.
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1212 # The minlink parameter defines the oldest revision
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1213 # we're allowed to strip away.
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1214 while minlink > self.index[rev][-4]:
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1215 rev += 1
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1216 if rev >= self.count():
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1217 return
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1218
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1219 # first truncate the files on disk
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1220 end = self.start(rev)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1221 if not self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1222 df = self.opener(self.datafile, "a")
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1223 df.truncate(end)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1224 end = rev * struct.calcsize(self.indexformat)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1225 else:
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1226 end += rev * struct.calcsize(self.indexformat)
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1227
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1228 indexf = self.opener(self.indexfile, "a")
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1229 indexf.truncate(end)
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1230
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1231 # then reset internal state in memory to forget those revisions
7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1232 self.cache = None
1711 8959700c2b19 revlog.strip should clear the chunkcache mason@suse.com parents: 1667 diff changeset	1233 self.chunkcache = None
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1234 for x in xrange(rev, self.count()):
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1235 del self.nodemap[self.node(x)]
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1236
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1237 del self.index[rev:]
1535 7ae0ce7a3dc4 Add revlog.strip to truncate away revisions. mason@suse.com parents: 1533 diff changeset	1238
1493 1a216cb4ee64 verify: add check for mismatch of index and data length Matt Mackall <mpm@selenic.com> parents: 1469 diff changeset	1239 def checksize(self):
1a216cb4ee64 verify: add check for mismatch of index and data length Matt Mackall <mpm@selenic.com> parents: 1469 diff changeset	1240 expected = 0
1a216cb4ee64 verify: add check for mismatch of index and data length Matt Mackall <mpm@selenic.com> parents: 1469 diff changeset	1241 if self.count():
1a216cb4ee64 verify: add check for mismatch of index and data length Matt Mackall <mpm@selenic.com> parents: 1469 diff changeset	1242 expected = self.end(self.count() - 1)
1667 daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1243
1494 249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1244 try:
249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1245 f = self.opener(self.datafile)
249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1246 f.seek(0, 2)
249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1247 actual = f.tell()
1667 daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1248 dd = actual - expected
1494 249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1249 except IOError, inst:
1667 daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1250 if inst.errno != errno.ENOENT:
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1251 raise
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1252 dd = 0
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1253
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1254 try:
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1255 f = self.opener(self.indexfile)
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1256 f.seek(0, 2)
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1257 actual = f.tell()
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	1258 s = struct.calcsize(self.indexformat)
1667 daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1259 i = actual / s
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1260 di = actual - (i * s)
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1261 if self.inlinedata():
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1262 databytes = 0
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1263 for r in xrange(self.count()):
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1264 databytes += self.length(r)
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1265 dd = 0
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	1266 di = actual - self.count() * s - databytes
1667 daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1267 except IOError, inst:
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1268 if inst.errno != errno.ENOENT:
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1269 raise
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1270 di = 0
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1271
daff3ef0de8d verify: notice extra data in indices Matt Mackall <mpm@selenic.com> parents: 1660 diff changeset	1272 return (dd, di)
1494 249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1273
249ca10d37f4 Handle empty logs in repo.checksize Matt Mackall <mpm@selenic.com> parents: 1493 diff changeset	1274

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revlog.py @ 2295:9c15f85e61b1