Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/revlog.py @ 2255:3f38e872f39a
Reduce ram used for very large inlined index files
During a clone, an inline index is not converted to a split index
file until the very end. When the conversion happens, the index
can be very large, and the inline index loading functions always load
the entire index file into ram.
This changes the revlog code to read the index in smaller chunks.
| author | mason@suse.com |
|---|---|
| date | Wed, 10 May 2006 15:26:56 -0700 |
| parents | 45aef5ddcdbe |
| children | 854954fd410a |
| rev | line source |
|---|---|
| 1083 | 1 """ |
| 2 revlog.py - storage back-end for mercurial | |
| 3 | |
| 4 This provides efficient delta storage with O(1) retrieve and append | |
| 5 and O(changes) merge between branches | |
| 6 | |
| 7 Copyright 2005 Matt Mackall <mpm@selenic.com> | |
| 8 | |
| 9 This software may be used and distributed according to the terms | |
| 10 of the GNU General Public License, incorporated herein by reference. | |
| 11 """ | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
12 |
| 1089 | 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 | 19 # revlog version strings |
| 20 REVLOGV0 = 0 | |
| 21 REVLOGNG = 1 | |
| 22 | |
| 2073 | 23 # revlog flags |
| 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 | 29 |
| 30 def flagstr(flag): | |
| 31 if flag == "inline": | |
| 32 return REVLOGNGINLINEDATA | |
| 33 raise RevlogError(_("unknown revlog flag %s" % flag)) | |
| 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 | 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 | 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 | 55 bin = zlib.compress(text) |
| 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 | 62 """ decompress the given input """ |
| 112 | 63 if not bin: return bin |
| 64 t = bin[0] | |
| 65 if t == '\0': return bin | |
| 66 if t == 'x': return zlib.decompress(bin) | |
| 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 | 70 indexformatv0 = ">4l20s20s20s" |
| 2079 | 71 v0shaoffset = 56 |
| 2072 | 72 # index ng: |
| 73 # 6 bytes offset | |
| 74 # 2 bytes flags | |
| 75 # 4 bytes compressed length | |
| 76 # 4 bytes uncompressed length | |
| 77 # 4 bytes: base rev | |
| 78 # 4 bytes link rev | |
| 79 # 4 bytes parent 1 rev | |
| 80 # 4 bytes parent 2 rev | |
| 81 # 32 bytes: nodeid | |
| 82 indexformatng = ">Qiiiiii20s12x" | |
| 2079 | 83 ngshaoffset = 32 |
| 2072 | 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 | 87 """ |
| 88 this class avoids the need to parse the entirety of large indices | |
| 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 | 97 def __init__(self, dataf, size, indexformat, shaoffset): |
| 98 self.dataf = dataf | |
| 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 | 101 self.indexformat = indexformat |
| 2079 | 102 self.datasize = size |
| 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 | 106 self.allmap = 0 |
| 323 | 107 self.all = 0 |
| 2079 | 108 self.mapfind_count = 0 |
| 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 | 111 def loadmap(self): |
| 112 """ | |
| 113 during a commit, we need to make sure the rev being added is | |
| 114 not a duplicate. This requires loading the entire index, | |
| 115 which is fairly slow. loadmap can load up just the node map, | |
| 116 which takes much less time. | |
| 117 """ | |
| 118 if self.allmap: return | |
| 119 start = 0 | |
| 120 end = self.datasize | |
| 121 self.allmap = 1 | |
| 122 cur = 0 | |
| 123 count = 0 | |
| 124 blocksize = self.s * 256 | |
| 125 self.dataf.seek(0) | |
| 126 while cur < end: | |
| 127 data = self.dataf.read(blocksize) | |
| 128 off = 0 | |
| 129 for x in xrange(256): | |
| 130 n = data[off + self.shaoffset:off + self.shaoffset + 20] | |
| 131 self.map[n] = count | |
| 132 count += 1 | |
| 133 if count >= self.l: | |
| 134 break | |
| 135 off += self.s | |
| 136 cur += blocksize | |
| 137 | |
| 138 def loadblock(self, blockstart, blocksize, data=None): | |
| 323 | 139 if self.all: return |
| 2079 | 140 if data is None: |
| 141 self.dataf.seek(blockstart) | |
| 142 data = self.dataf.read(blocksize) | |
| 143 lend = len(data) / self.s | |
| 144 i = blockstart / self.s | |
| 145 off = 0 | |
| 146 for x in xrange(lend): | |
| 147 if self.index[i + x] == None: | |
| 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 | 152 off += self.s |
| 153 | |
| 154 def findnode(self, node): | |
| 155 """search backwards through the index file for a specific node""" | |
| 156 if self.allmap: return None | |
| 157 | |
| 158 # hg log will cause many many searches for the manifest | |
| 159 # nodes. After we get called a few times, just load the whole | |
| 160 # thing. | |
| 161 if self.mapfind_count > 8: | |
| 162 self.loadmap() | |
| 163 if node in self.map: | |
| 164 return node | |
| 165 return None | |
| 166 self.mapfind_count += 1 | |
| 167 last = self.l - 1 | |
| 168 while self.index[last] != None: | |
| 169 if last == 0: | |
| 170 self.all = 1 | |
| 171 self.allmap = 1 | |
| 172 return None | |
| 173 last -= 1 | |
| 174 end = (last + 1) * self.s | |
| 175 blocksize = self.s * 256 | |
| 176 while end >= 0: | |
| 177 start = max(end - blocksize, 0) | |
| 178 self.dataf.seek(start) | |
| 179 data = self.dataf.read(end - start) | |
| 180 findend = end - start | |
| 181 while True: | |
| 182 # we're searching backwards, so weh have to make sure | |
| 183 # we don't find a changeset where this node is a parent | |
| 184 off = data.rfind(node, 0, findend) | |
| 185 findend = off | |
| 186 if off >= 0: | |
| 187 i = off / self.s | |
| 188 off = i * self.s | |
| 189 n = data[off + self.shaoffset:off + self.shaoffset + 20] | |
| 190 if n == node: | |
| 191 self.map[n] = i + start / self.s | |
| 192 return node | |
| 193 else: | |
| 194 break | |
| 195 end -= blocksize | |
| 196 return None | |
| 197 | |
| 198 def loadindex(self, i=None, end=None): | |
| 199 if self.all: return | |
| 200 all = False | |
| 201 if i == None: | |
| 202 blockstart = 0 | |
| 203 blocksize = (512 / self.s) * self.s | |
| 204 end = self.datasize | |
| 205 all = True | |
| 323 | 206 else: |
| 2079 | 207 if end: |
| 208 blockstart = i * self.s | |
| 209 end = end * self.s | |
| 210 blocksize = end - blockstart | |
| 211 else: | |
| 212 blockstart = (i & ~(32)) * self.s | |
| 213 blocksize = self.s * 64 | |
| 214 end = blockstart + blocksize | |
| 215 while blockstart < end: | |
| 216 self.loadblock(blockstart, blocksize) | |
| 217 blockstart += blocksize | |
| 218 if all: self.all = True | |
| 515 | 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 | 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 | 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 | 229 self.p.loadindex(pos) |
| 115 | 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 | 236 def __setitem__(self, pos, item): |
| 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 | 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 | 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 | 248 n = self.p.findnode(key) |
| 249 if n == None: | |
| 1214 | 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 | 252 if key in self.p.map: |
| 253 return True | |
| 254 self.p.loadmap() | |
| 323 | 255 return key in self.p.map |
| 97 | 256 def __iter__(self): |
| 469 | 257 yield nullid |
| 97 | 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 | 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 | 283 """ |
| 284 the underlying revision storage object | |
| 285 | |
| 286 A revlog consists of two parts, an index and the revision data. | |
| 287 | |
| 288 The index is a file with a fixed record size containing | |
| 289 information on each revision, includings its nodeid (hash), the | |
| 290 nodeids of its parents, the position and offset of its data within | |
| 291 the data file, and the revision it's based on. Finally, each entry | |
| 292 contains a linkrev entry that can serve as a pointer to external | |
| 293 data. | |
| 294 | |
| 295 The revision data itself is a linear collection of data chunks. | |
| 296 Each chunk represents a revision and is usually represented as a | |
| 297 delta against the previous chunk. To bound lookup time, runs of | |
| 298 deltas are limited to about 2 times the length of the original | |
| 299 version data. This makes retrieval of a version proportional to | |
| 300 its size, or O(1) relative to the number of revisions. | |
| 301 | |
| 302 Both pieces of the revlog are written to in an append-only | |
| 303 fashion, which means we never need to rewrite a file to insert or | |
| 304 remove data, and can use some simple techniques to avoid the need | |
| 305 for locking while reading. | |
| 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 | 309 """ |
| 310 create a revlog object | |
| 311 | |
| 312 opener is a function that abstracts the file opening operation | |
| 313 and can be used to implement COW semantics or the like. | |
| 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 | 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 | 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 | 329 i = f.read(4) |
| 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 | 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 | 350 flags = v & ~0xFFFF |
| 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 | 353 if flags: |
| 354 raise RevlogError(_("index %s invalid flags %x for format v0" % | |
| 355 (self.indexfile, flags))) | |
| 356 elif fmt == REVLOGNG: | |
| 357 if flags & ~REVLOGNGINLINEDATA: | |
| 358 raise RevlogError(_("index %s invalid flags %x for revlogng" % | |
| 359 (self.indexfile, flags))) | |
| 360 else: | |
| 361 raise RevlogError(_("index %s invalid format %d" % | |
| 362 (self.indexfile, fmt))) | |
| 2072 | 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 | 365 self.indexformat = indexformatv0 |
| 2079 | 366 shaoffset = v0shaoffset |
| 2072 | 367 else: |
| 368 self.indexformat = indexformatng | |
| 2079 | 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 | 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 | 374 # big index, let's parse it on demand |
| 2079 | 375 parser = lazyparser(f, st.st_size, self.indexformat, shaoffset) |
| 2072 | 376 self.index = lazyindex(parser) |
| 377 self.nodemap = lazymap(parser) | |
| 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 | 381 e = list(self.index[0]) |
| 382 type = self.ngtype(e[0]) | |
| 383 e[0] = self.offset_type(0, type) | |
| 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 | 386 self.nodemap = { nullid: -1} |
| 387 self.index = [] | |
| 388 | |
| 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 | 391 s = struct.calcsize(self.indexformat) |
| 392 self.index = [] | |
| 393 self.nodemap = {nullid: -1} | |
| 2073 | 394 inline = self.inlinedata() |
| 2072 | 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) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
408 off = 0 |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
409 l = len(data) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
410 while off < l: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
411 if l - off < s: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
412 leftover = data[off:] |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
413 break |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
414 if leftover: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
415 cur = leftover + data[off:off + s - len(leftover)] |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
416 off += s - len(leftover) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
417 leftover = None |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
418 else: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
419 cur = data[off:off + s] |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
420 off += s |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
421 e = struct.unpack(self.indexformat, cur) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
422 self.index.append(e) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
423 self.nodemap[e[-1]] = n |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
424 n += 1 |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
425 if inline: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
426 off += e[1] |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
427 if off > l: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
428 # 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
|
429 fp.read(off - l) |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
430 if not st: |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
431 break |
|
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
432 |
|
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
433 |
| 2072 | 434 def ngoffset(self, q): |
| 435 if q & 0xFFFF: | |
| 436 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
|
437 (self.indexfile, q)) |
| 2072 | 438 return long(q >> 16) |
| 439 | |
| 440 def ngtype(self, q): | |
| 441 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
|
442 |
| 2072 | 443 def offset_type(self, offset, type): |
| 444 return long(long(offset) << 16 | type) | |
| 445 | |
| 2079 | 446 def loadindex(self, start, end): |
| 447 """load a block of indexes all at once from the lazy parser""" | |
| 448 if isinstance(self.index, lazyindex): | |
| 449 self.index.p.loadindex(start, end) | |
| 450 | |
| 2072 | 451 def loadindexmap(self): |
| 452 """loads both the map and the index from the lazy parser""" | |
| 453 if isinstance(self.index, lazyindex): | |
| 454 p = self.index.p | |
| 2079 | 455 p.loadindex() |
| 456 self.nodemap = p.map | |
| 457 | |
| 458 def loadmap(self): | |
| 459 """loads the map from the lazy parser""" | |
| 460 if isinstance(self.nodemap, lazymap): | |
| 461 self.nodemap.p.loadmap() | |
| 462 self.nodemap = self.nodemap.p.map | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
463 |
| 2073 | 464 def inlinedata(self): return self.version & REVLOGNGINLINEDATA |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
465 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
|
466 def count(self): return len(self.index) |
| 2072 | 467 def node(self, rev): |
| 468 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
|
469 def rev(self, node): |
|
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
470 try: |
|
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
471 return self.nodemap[node] |
|
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
472 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
|
473 raise RevlogError(_('%s: no node %s') % (self.indexfile, hex(node))) |
| 2072 | 474 def linkrev(self, node): return self.index[self.rev(node)][-4] |
| 2 | 475 def parents(self, node): |
| 476 if node == nullid: return (nullid, nullid) | |
| 2072 | 477 r = self.rev(node) |
| 478 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
|
479 if self.version == REVLOGV0: |
| 2072 | 480 return d |
| 481 return [ self.node(x) for x in d ] | |
| 482 def start(self, rev): | |
| 483 if rev < 0: | |
| 484 return -1 | |
|
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
485 if self.version != REVLOGV0: |
| 2072 | 486 return self.ngoffset(self.index[rev][0]) |
| 487 return self.index[rev][0] | |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
488 |
| 2072 | 489 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
|
490 |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
491 def size(self, rev): |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
492 """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
|
493 l = -1 |
|
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
494 if self.version != REVLOGV0: |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
495 l = self.index[rev][2] |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
496 if l >= 0: |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
497 return l |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
498 |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
499 t = self.revision(self.node(rev)) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
500 return len(t) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
501 |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
502 # 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
|
503 # 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
|
504 # 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
|
505 """ |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
506 if self.cache and self.cache[1] == rev: |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
507 return len(self.cache[2]) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
508 |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
509 base = self.base(rev) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
510 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
|
511 base = self.cache[1] |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
512 text = self.cache[2] |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
513 else: |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
514 text = self.revision(self.node(base)) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
515 |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
516 l = len(text) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
517 for x in xrange(base + 1, rev + 1): |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
518 l = mdiff.patchedsize(l, self.chunk(x)) |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
519 return l |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
520 """ |
|
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
521 |
|
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
522 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
|
523 if rev < 0: |
|
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
524 return 0 |
|
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
525 else: |
|
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
526 return self.index[rev][1] |
| 2072 | 527 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
|
528 |
|
1074
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
529 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
|
530 reachable = {} |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
531 visit = [rev] |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
532 reachable[rev] = 1 |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
533 if stop: |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
534 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
|
535 else: |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
536 stopn = 0 |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
537 while visit: |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
538 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
|
539 if n == stop: |
|
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 if n == nullid: |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
542 continue |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
543 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
|
544 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
|
545 continue |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
546 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
|
547 reachable[p] = 1 |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
548 visit.append(p) |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
549 return reachable |
|
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
550 |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
551 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
|
552 """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
|
553 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
|
554 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
|
555 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
556 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
|
557 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
|
558 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
|
559 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
|
560 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
|
561 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
562 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
|
563 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
|
564 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
|
565 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
|
566 nonodes = ([], [], []) |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
567 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
|
568 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
|
569 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
|
570 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
571 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
|
572 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
573 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
|
574 lowestrev = -1 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
575 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
|
576 # 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
|
577 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
|
578 [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
|
579 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
|
580 # 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
|
581 # node. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
582 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
|
583 # 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
|
584 ancestors = None |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
585 # 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
|
586 heads = {} |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
587 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
|
588 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
|
589 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
|
590 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
591 ancestors = {} |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
592 # 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
|
593 nodestotag = heads[:] |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
594 # 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
|
595 # 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
|
596 # find from roots. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
597 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
|
598 # 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
|
599 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
|
600 while nodestotag: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
601 # 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
|
602 n = nodestotag.pop() |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
603 # Never tag nullid |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
604 if n == nullid: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
605 continue |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
606 # 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
|
607 # 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
|
608 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
|
609 if r >= lowestrev: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
610 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
|
611 # 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
|
612 # 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
|
613 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
|
614 # 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
|
615 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
|
616 p != nullid]) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
617 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
|
618 # 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
|
619 # any other heads. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
620 heads.pop(n) |
|
1459
106fdec8e1fb
Fix small bug in nodesbetween if heads is [nullid].
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
621 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
|
622 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
623 # 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
|
624 # 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
|
625 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
626 # 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
|
627 if lowestrev > -1: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
628 # 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
|
629 # 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
|
630 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
631 # 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
|
632 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
|
633 # 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
|
634 if roots: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
635 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
|
636 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
637 # 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
|
638 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
639 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
640 # 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
|
641 # any other roots. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
642 lowestrev = -1 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
643 roots = [nullid] |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
644 # 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
|
645 # 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
|
646 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
|
647 # 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
|
648 # '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
|
649 roots = descendents.copy() |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
650 # 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
|
651 orderedout = [] |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
652 # 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
|
653 # 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
|
654 # they're descendents. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
655 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
|
656 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
|
657 isdescendent = False |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
658 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
|
659 isdescendent = True |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
660 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
|
661 # 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
|
662 isdescendent = True |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
663 # 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
|
664 # 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
|
665 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
|
666 # 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
|
667 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
|
668 # 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
|
669 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
|
670 roots.pop(n) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
671 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
672 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
|
673 # 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
|
674 # 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
|
675 # up there, remember?) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
676 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
|
677 descendents[n] = 1 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
678 isdescendent = True |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
679 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
|
680 # 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
|
681 orderedout.append(n) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
682 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
|
683 # 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
|
684 # from roots. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
685 # 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
|
686 heads[n] = 1 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
687 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
|
688 # 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
|
689 # 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
|
690 # 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
|
691 heads[n] = 1 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
692 # 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
|
693 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
|
694 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
|
695 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
|
696 roots = roots.keys() |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
697 assert orderedout |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
698 assert roots |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
699 assert heads |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
700 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
|
701 |
|
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
702 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
|
703 """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
|
704 |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
705 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
|
706 start will be returned |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
707 |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
708 """ |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
709 if start is None: |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
710 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
|
711 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
|
712 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
|
713 startrev = self.rev(start) |
| 1083 | 714 |
|
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
|
715 for r in xrange(startrev + 1, self.count()): |
| 221 | 716 n = self.node(r) |
| 717 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
|
718 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
|
719 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
|
720 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
|
721 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
|
722 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
|
723 return heads.keys() |
| 370 | 724 |
| 725 def children(self, node): | |
| 1083 | 726 """find the children of a given node""" |
| 370 | 727 c = [] |
| 728 p = self.rev(node) | |
| 729 for r in range(p + 1, self.count()): | |
| 730 n = self.node(r) | |
| 731 for pn in self.parents(n): | |
|
854
473c030d34a6
Fixed revlog.children.
Tristan Wibberley <tristan@wibberley.org>
parents:
655
diff
changeset
|
732 if pn == node: |
|
473c030d34a6
Fixed revlog.children.
Tristan Wibberley <tristan@wibberley.org>
parents:
655
diff
changeset
|
733 c.append(n) |
| 370 | 734 continue |
| 735 elif pn == nullid: | |
| 736 continue | |
| 737 return c | |
| 515 | 738 |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
739 def lookup(self, id): |
| 1083 | 740 """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
|
741 try: |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
742 rev = int(id) |
| 469 | 743 if str(rev) != id: raise ValueError |
| 744 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
|
745 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
|
746 return self.node(rev) |
| 469 | 747 except (ValueError, OverflowError): |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
748 c = [] |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
749 for n in self.nodemap: |
| 469 | 750 if hex(n).startswith(id): |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
751 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
|
752 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
|
753 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
|
754 return c[0] |
| 515 | 755 |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
756 return None |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
757 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
758 def diff(self, a, b): |
| 1083 | 759 """return a delta between two revisions""" |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
760 return mdiff.textdiff(a, b) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
761 |
| 73 | 762 def patches(self, t, pl): |
| 1083 | 763 """apply a list of patches to a string""" |
| 73 | 764 return mdiff.patches(t, pl) |
| 765 | |
| 2072 | 766 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
|
767 start, length = self.start(rev), self.length(rev) |
| 2073 | 768 inline = self.inlinedata() |
| 769 if inline: | |
| 770 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
|
771 end = start + length |
| 2072 | 772 def loadcache(df): |
| 773 cache_length = max(cachelen, length) # 4k | |
| 774 if not df: | |
| 2073 | 775 if inline: |
| 776 df = self.opener(self.indexfile) | |
| 777 else: | |
| 778 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
|
779 df.seek(start) |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
780 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
|
781 |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
782 if not self.chunkcache: |
| 2072 | 783 loadcache(df) |
|
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
784 |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
785 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
|
786 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
|
787 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
|
788 # it is cached |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
789 offset = start - cache_start |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
790 else: |
| 2072 | 791 loadcache(df) |
|
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
792 offset = 0 |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
793 |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
794 #def checkchunk(): |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
795 # 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
|
796 # df.seek(start) |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
797 # return df.read(length) |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
798 #assert s == checkchunk() |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
799 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
|
800 |
|
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
801 def delta(self, node): |
| 1083 | 802 """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
|
803 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
|
804 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
|
805 |
|
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
806 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
|
807 """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
|
808 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
|
809 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
|
810 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
|
811 return self.chunk(rev2) |
|
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
812 else: |
|
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
813 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
|
814 self.revision(self.node(rev2))) |
|
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
815 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
816 def revision(self, node): |
| 1083 | 817 """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
|
818 if node == nullid: return "" |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
819 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
|
820 |
| 1083 | 821 # look up what we need to read |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
822 text = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
823 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
|
824 base = self.base(rev) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
825 |
| 2073 | 826 if self.inlinedata(): |
| 827 # we probably have the whole chunk cached | |
| 828 df = None | |
| 829 else: | |
| 830 df = self.opener(self.datafile) | |
| 2072 | 831 |
| 1083 | 832 # do we have useful data cached? |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
833 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
|
834 base = self.cache[1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
835 text = self.cache[2] |
| 2079 | 836 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
|
837 else: |
| 2079 | 838 self.loadindex(base, rev + 1) |
| 2072 | 839 text = self.chunk(base, df=df) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
840 |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
841 bins = [] |
| 64 | 842 for r in xrange(base + 1, rev + 1): |
| 2072 | 843 bins.append(self.chunk(r, df=df)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
844 |
|
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
845 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
|
846 |
|
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
847 p1, p2 = self.parents(node) |
| 26 | 848 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
|
849 raise RevlogError(_("integrity check failed on %s:%d") |
| 98 | 850 % (self.datafile, rev)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
851 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
852 self.cache = (node, rev, text) |
| 515 | 853 return text |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
854 |
|
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
855 def checkinlinesize(self, tr, fp=None): |
| 2073 | 856 if not self.inlinedata(): |
| 857 return | |
|
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
858 if not fp: |
|
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
859 fp = self.opener(self.indexfile, 'r') |
|
2082
856f0ba200bc
Additional appendfile fixes for interleaved data/index files
mason@suse.com
parents:
2081
diff
changeset
|
860 fp.seek(0, 2) |
| 2073 | 861 size = fp.tell() |
| 862 if size < 131072: | |
| 863 return | |
| 2084 | 864 trinfo = tr.find(self.indexfile) |
| 865 if trinfo == None: | |
| 866 raise RevlogError(_("%s not found in the transaction" % | |
| 867 self.indexfile)) | |
| 868 | |
| 869 trindex = trinfo[2] | |
| 870 dataoff = self.start(trindex) | |
| 871 | |
| 872 tr.add(self.datafile, dataoff) | |
| 2073 | 873 df = self.opener(self.datafile, 'w') |
| 874 calc = struct.calcsize(self.indexformat) | |
| 875 for r in xrange(self.count()): | |
| 876 start = self.start(r) + (r + 1) * calc | |
| 877 length = self.length(r) | |
| 878 fp.seek(start) | |
| 879 d = fp.read(length) | |
| 880 df.write(d) | |
| 881 fp.close() | |
| 882 df.close() | |
|
2076
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
883 fp = self.opener(self.indexfile, 'w', atomictemp=True) |
| 2073 | 884 self.version &= ~(REVLOGNGINLINEDATA) |
| 885 if self.count(): | |
| 886 x = self.index[0] | |
| 887 e = struct.pack(self.indexformat, *x)[4:] | |
| 888 l = struct.pack(versionformat, self.version) | |
| 889 fp.write(l) | |
| 890 fp.write(e) | |
| 891 | |
| 892 for i in xrange(1, self.count()): | |
| 893 x = self.index[i] | |
| 894 e = struct.pack(self.indexformat, *x) | |
| 895 fp.write(e) | |
| 896 | |
|
2076
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
897 # 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
|
898 # real index |
|
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
899 fp.rename() |
| 2084 | 900 |
| 901 tr.replace(self.indexfile, trindex * calc) | |
| 2073 | 902 self.chunkcache = None |
| 903 | |
| 644 | 904 def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): |
| 1083 | 905 """add a revision to the log |
| 906 | |
| 907 text - the revision data to add | |
| 908 transaction - the transaction object used for rollback | |
| 909 link - the linkrev data to add | |
| 910 p1, p2 - the parent nodeids of the revision | |
| 911 d - an optional precomputed delta | |
| 912 """ | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
913 if text is None: text = "" |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
914 if p1 is None: p1 = self.tip() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
915 if p2 is None: p2 = nullid |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
916 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
917 node = hash(text, p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
918 |
| 301 | 919 if node in self.nodemap: |
| 920 return node | |
| 921 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
922 n = self.count() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
923 t = n - 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
924 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
925 if n: |
| 64 | 926 base = self.base(t) |
| 927 start = self.start(base) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
928 end = self.end(t) |
| 644 | 929 if not d: |
| 930 prev = self.revision(self.tip()) | |
|
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
931 d = self.diff(prev, str(text)) |
| 98 | 932 data = compress(d) |
|
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
933 l = len(data[1]) + len(data[0]) |
|
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
934 dist = end - start + l |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
935 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
936 # full versions are inserted when the needed deltas |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
937 # become comparable to the uncompressed text |
| 64 | 938 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
|
939 data = compress(text) |
|
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
940 l = len(data[1]) + len(data[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
941 base = n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
942 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
943 base = self.base(t) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
944 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
945 offset = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
946 if t >= 0: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
947 offset = self.end(t) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
948 |
|
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
949 if self.version == REVLOGV0: |
| 2072 | 950 e = (offset, l, base, link, p1, p2, node) |
| 951 else: | |
| 952 e = (self.offset_type(offset, 0), l, len(text), | |
| 953 base, link, self.rev(p1), self.rev(p2), node) | |
| 515 | 954 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
955 self.index.append(e) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
956 self.nodemap[node] = n |
| 2072 | 957 entry = struct.pack(self.indexformat, *e) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
958 |
| 2073 | 959 if not self.inlinedata(): |
| 960 transaction.add(self.datafile, offset) | |
| 961 transaction.add(self.indexfile, n * len(entry)) | |
| 962 f = self.opener(self.datafile, "a") | |
| 963 if data[0]: | |
| 964 f.write(data[0]) | |
| 965 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
|
966 f.close() |
| 2073 | 967 f = self.opener(self.indexfile, "a") |
| 968 else: | |
| 969 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
|
970 f.seek(0, 2) |
| 2084 | 971 transaction.add(self.indexfile, f.tell(), self.count() - 1) |
| 2072 | 972 |
|
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
973 if len(self.index) == 1 and self.version != REVLOGV0: |
| 2072 | 974 l = struct.pack(versionformat, self.version) |
| 975 f.write(l) | |
| 976 entry = entry[4:] | |
| 977 | |
| 978 f.write(entry) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
979 |
| 2073 | 980 if self.inlinedata(): |
| 981 f.write(data[0]) | |
| 982 f.write(data[1]) | |
|
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
983 self.checkinlinesize(transaction, f) |
| 2073 | 984 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
985 self.cache = (node, n, text) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
986 return node |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
987 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
988 def ancestor(self, a, b): |
| 1083 | 989 """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
|
990 |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
991 # 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
|
992 if a == b: |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
993 return a |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
994 ra = self.rev(a) |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
995 rb = self.rev(b) |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
996 if ra < rb: |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
997 last = b |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
998 first = a |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
999 else: |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1000 last = a |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1001 first = b |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1002 |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1003 # 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
|
1004 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
|
1005 if first in reachable: |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1006 return first |
|
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1007 |
| 147 | 1008 # calculate the distance of every node from root |
| 1009 dist = {nullid: 0} | |
| 1010 for i in xrange(self.count()): | |
| 1011 n = self.node(i) | |
| 1012 p1, p2 = self.parents(n) | |
| 1013 dist[n] = max(dist[p1], dist[p2]) + 1 | |
| 515 | 1014 |
| 147 | 1015 # traverse ancestors in order of decreasing distance from root |
| 1016 def ancestors(node): | |
| 1017 # we store negative distances because heap returns smallest member | |
| 1018 h = [(-dist[node], node)] | |
| 1019 seen = {} | |
| 1020 while h: | |
| 1021 d, n = heapq.heappop(h) | |
| 1022 if n not in seen: | |
| 1023 seen[n] = 1 | |
|
1351
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1024 yield (-d, n) |
| 147 | 1025 for p in self.parents(n): |
| 1026 heapq.heappush(h, (-dist[p], p)) | |
|
45
f2b2d5daec30
Fix recursion depth trouble with ancestor algorithm
mpm@selenic.com
parents:
41
diff
changeset
|
1027 |
|
1351
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1028 def generations(node): |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1029 sg, s = None, {} |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1030 for g,n in ancestors(node): |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1031 if g != sg: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1032 if sg: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1033 yield sg, s |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1034 sg, s = g, {n:1} |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1035 else: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1036 s[n] = 1 |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1037 yield sg, s |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1038 |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1039 x = generations(a) |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1040 y = generations(b) |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1041 gx = x.next() |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1042 gy = y.next() |
|
45
f2b2d5daec30
Fix recursion depth trouble with ancestor algorithm
mpm@selenic.com
parents:
41
diff
changeset
|
1043 |
| 147 | 1044 # increment each ancestor list until it is closer to root than |
| 1045 # the other, or they match | |
| 1046 while 1: | |
|
1351
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1047 #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
|
1048 if gx[0] == gy[0]: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1049 # find the intersection |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1050 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
|
1051 if i: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1052 return i[0] |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1053 else: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1054 #print "next" |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1055 gy = y.next() |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1056 gx = x.next() |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1057 elif gx[0] < gy[0]: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1058 #print "next y" |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1059 gy = y.next() |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1060 else: |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1061 #print "next x" |
|
0e2be889ccd7
Repair ancestor logic, fix up test cases
Matt Mackall <mpm@selenic.com>
parents:
1325
diff
changeset
|
1062 gx = x.next() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1063 |
|
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1064 def group(self, nodelist, lookup, infocollect=None): |
| 1083 | 1065 """calculate a delta group |
| 46 | 1066 |
| 1083 | 1067 Given a list of changeset revs, return a set of deltas and |
| 1068 metadata corresponding to nodes. the first delta is | |
| 1069 parent(nodes[0]) -> nodes[0] the receiver is guaranteed to | |
| 1070 have this parent as it has all history before these | |
| 1071 changesets. parent is parent[0] | |
| 1072 """ | |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1073 revs = [self.rev(n) for n in nodelist] |
| 46 | 1074 |
| 1075 # if we don't have any revisions touched by these changesets, bail | |
| 192 | 1076 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
|
1077 yield changegroup.closechunk() |
| 192 | 1078 return |
| 46 | 1079 |
| 1080 # add the parent of the first rev | |
| 1081 p = self.parents(self.node(revs[0]))[0] | |
| 1082 revs.insert(0, self.rev(p)) | |
| 1083 | |
| 1084 # build deltas | |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
1085 for d in xrange(0, len(revs) - 1): |
| 46 | 1086 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
|
1087 nb = self.node(b) |
| 192 | 1088 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1089 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
|
1090 infocollect(nb) |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1091 |
|
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
1092 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
|
1093 p = self.parents(nb) |
|
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1094 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
|
1095 yield changegroup.genchunk("%s%s" % (meta, d)) |
| 46 | 1096 |
|
1981
736b6c96bbbc
make incoming work via ssh (issue139); move chunk code into separate module.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1941
diff
changeset
|
1097 yield changegroup.closechunk() |
| 192 | 1098 |
| 1062 | 1099 def addgroup(self, revs, linkmapper, transaction, unique=0): |
| 1083 | 1100 """ |
| 1101 add a delta group | |
| 46 | 1102 |
| 1083 | 1103 given a set of deltas, add them to the revision log. the |
| 1104 first delta is against its parent, which should be in our | |
| 1105 log, the rest are against the previous delta. | |
| 1106 """ | |
| 1107 | |
| 1108 #track the base of the current delta log | |
| 46 | 1109 r = self.count() |
| 1110 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
|
1111 node = None |
| 515 | 1112 |
| 655 | 1113 base = prev = -1 |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1114 start = end = textlen = 0 |
| 46 | 1115 if r: |
| 1116 end = self.end(t) | |
| 1117 | |
| 2072 | 1118 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
|
1119 ifh.seek(0, 2) |
| 2084 | 1120 transaction.add(self.indexfile, ifh.tell(), self.count()) |
| 2073 | 1121 if self.inlinedata(): |
| 1122 dfh = None | |
| 1123 else: | |
| 1124 transaction.add(self.datafile, end) | |
| 1125 dfh = self.opener(self.datafile, "a") | |
| 46 | 1126 |
| 1127 # loop through our set of deltas | |
| 192 | 1128 chain = None |
| 1129 for chunk in revs: | |
| 1130 node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80]) | |
| 94 | 1131 link = linkmapper(cs) |
| 77 | 1132 if node in self.nodemap: |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
1133 # 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
|
1134 # 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
|
1135 # 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
|
1136 chain = node |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
1137 continue |
| 192 | 1138 delta = chunk[80:] |
| 1139 | |
|
1509
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1140 for p in (p1, p2): |
|
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1141 if not p in self.nodemap: |
|
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1142 raise RevlogError(_("unknown parent %s") % short(p1)) |
|
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1143 |
| 192 | 1144 if not chain: |
| 1145 # retrieve the parent revision of the delta chain | |
| 1146 chain = p1 | |
| 1147 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
|
1148 raise RevlogError(_("unknown base %s") % short(chain[:4])) |
| 46 | 1149 |
| 1150 # full versions are inserted when the needed deltas become | |
| 1151 # comparable to the uncompressed text or when the previous | |
| 1152 # version is not the one we have a delta against. We use | |
| 1153 # the size of the previous full rev as a proxy for the | |
| 1154 # current size. | |
| 1155 | |
| 1156 if chain == prev: | |
|
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1157 tempd = compress(delta) |
|
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1158 cdelta = tempd[0] + tempd[1] |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1159 textlen = mdiff.patchedsize(textlen, delta) |
| 46 | 1160 |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1161 if chain != prev or (end - start + len(cdelta)) > textlen * 2: |
| 46 | 1162 # flush our writes here so we can read it in revision |
| 2072 | 1163 if dfh: |
| 1164 dfh.flush() | |
| 46 | 1165 ifh.flush() |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1166 text = self.revision(chain) |
| 73 | 1167 text = self.patches(text, [delta]) |
| 46 | 1168 chk = self.addrevision(text, transaction, link, p1, p2) |
| 1169 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
|
1170 raise RevlogError(_("consistency error adding group")) |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1171 textlen = len(text) |
| 46 | 1172 else: |
|
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
1173 if self.version == REVLOGV0: |
| 2072 | 1174 e = (end, len(cdelta), base, link, p1, p2, node) |
| 1175 else: | |
|
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1176 e = (self.offset_type(end, 0), len(cdelta), textlen, base, |
| 2072 | 1177 link, self.rev(p1), self.rev(p2), node) |
| 46 | 1178 self.index.append(e) |
| 1179 self.nodemap[node] = r | |
| 2073 | 1180 if self.inlinedata(): |
| 1181 ifh.write(struct.pack(self.indexformat, *e)) | |
| 1182 ifh.write(cdelta) | |
|
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
1183 self.checkinlinesize(transaction, ifh) |
| 2073 | 1184 if not self.inlinedata(): |
| 1185 dfh = self.opener(self.datafile, "a") | |
| 1186 ifh = self.opener(self.indexfile, "a") | |
| 1187 else: | |
| 1188 if not dfh: | |
| 1189 # addrevision switched from inline to conventional | |
| 1190 # reopen the index | |
| 1191 dfh = self.opener(self.datafile, "a") | |
| 1192 ifh = self.opener(self.indexfile, "a") | |
| 1193 dfh.write(cdelta) | |
| 1194 ifh.write(struct.pack(self.indexformat, *e)) | |
| 46 | 1195 |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1196 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
|
1197 base = self.base(t) |
|
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1711
diff
changeset
|
1198 start = self.start(base) |
| 46 | 1199 end = self.end(t) |
| 1200 | |
|
2002
4aab906517c6
Calling revlog.addgroup with an empty changegroup now raises RevlogError.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1981
diff
changeset
|
1201 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
|
1202 raise RevlogError(_("group to be added is empty")) |
| 46 | 1203 return node |
|
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1204 |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1205 def strip(self, rev, minlink): |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1206 if self.count() == 0 or rev >= self.count(): |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1207 return |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1208 |
| 2072 | 1209 if isinstance(self.index, lazyindex): |
| 1210 self.loadindexmap() | |
| 1211 | |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1212 # 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
|
1213 # does not actually belong to an older changeset. |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1214 # The minlink parameter defines the oldest revision |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1215 # we're allowed to strip away. |
| 2072 | 1216 while minlink > self.index[rev][-4]: |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1217 rev += 1 |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1218 if rev >= self.count(): |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1219 return |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1220 |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1221 # first truncate the files on disk |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1222 end = self.start(rev) |
| 2073 | 1223 if not self.inlinedata(): |
| 1224 df = self.opener(self.datafile, "a") | |
| 1225 df.truncate(end) | |
| 1226 end = rev * struct.calcsize(self.indexformat) | |
| 1227 else: | |
| 1228 end += rev * struct.calcsize(self.indexformat) | |
| 2072 | 1229 |
| 1230 indexf = self.opener(self.indexfile, "a") | |
| 1231 indexf.truncate(end) | |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1232 |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1233 # 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
|
1234 self.cache = None |
| 1711 | 1235 self.chunkcache = None |
| 2072 | 1236 for x in xrange(rev, self.count()): |
| 1237 del self.nodemap[self.node(x)] | |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1238 |
| 2072 | 1239 del self.index[rev:] |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1240 |
|
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1241 def checksize(self): |
|
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1242 expected = 0 |
|
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1243 if self.count(): |
|
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1244 expected = self.end(self.count() - 1) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1245 |
|
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1246 try: |
|
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1247 f = self.opener(self.datafile) |
|
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1248 f.seek(0, 2) |
|
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1249 actual = f.tell() |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1250 dd = actual - expected |
|
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1251 except IOError, inst: |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1252 if inst.errno != errno.ENOENT: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1253 raise |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1254 dd = 0 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1255 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1256 try: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1257 f = self.opener(self.indexfile) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1258 f.seek(0, 2) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1259 actual = f.tell() |
| 2072 | 1260 s = struct.calcsize(self.indexformat) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1261 i = actual / s |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1262 di = actual - (i * s) |
| 2073 | 1263 if self.inlinedata(): |
| 1264 databytes = 0 | |
| 1265 for r in xrange(self.count()): | |
| 1266 databytes += self.length(r) | |
| 1267 dd = 0 | |
| 1268 di = actual - self.count() * s - databytes | |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1269 except IOError, inst: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1270 if inst.errno != errno.ENOENT: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1271 raise |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1272 di = 0 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1273 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1274 return (dd, di) |
|
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1275 |
|
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1276 |