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