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