Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/revlog.py @ 5045:f191bc3916f7
merge: do early copy to deal with issue636
Without copies/renames, merges source names are 1:1 with their
targets. Copies and renames introduce the possibility that there will
be two merges with the same input but different output. By doing the
copy to the destination name before the merge, the actual merge
becomes 1:1 again, and no source is the input to two different merges.
- add a preliminary scan to applyupdates to do copies
- for the merge action, pass the old name (for finding ancestors) and
the new name (for input to the merge) to filemerge
- eliminate the old post-merge copy
- lookup file contents from new name in filemerge
- pass new name to external merge helper
- report merge failure at new name
- add a test
author | Matt Mackall <mpm@selenic.com> |
---|---|
date | Wed, 01 Aug 2007 12:33:12 -0500 |
parents | 62c56d8f368b |
children | e017d3a82e1d |
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 | |
4635
63b9d2deed48
Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4497
diff
changeset
|
7 Copyright 2005-2007 Matt Mackall <mpm@selenic.com> |
1083 | 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 * |
3893 | 14 from i18n import _ |
3886
abaee83ce0a6
Replace demandload with new demandimport
Matt Mackall <mpm@selenic.com>
parents:
3755
diff
changeset
|
15 import binascii, changegroup, errno, ancestor, mdiff, os |
abaee83ce0a6
Replace demandload with new demandimport
Matt Mackall <mpm@selenic.com>
parents:
3755
diff
changeset
|
16 import sha, struct, util, zlib |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
17 |
2072 | 18 # revlog version strings |
19 REVLOGV0 = 0 | |
20 REVLOGNG = 1 | |
21 | |
2073 | 22 # revlog flags |
23 REVLOGNGINLINEDATA = (1 << 16) | |
2222
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
24 REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA |
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
25 |
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
26 REVLOG_DEFAULT_FORMAT = REVLOGNG |
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
27 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS |
2073 | 28 |
1091
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
29 def hash(text, p1, p2): |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
30 """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
|
31 |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
32 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
|
33 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
|
34 content in the revision graph. |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
35 """ |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
36 l = [p1, p2] |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
37 l.sort() |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
38 s = sha.new(l[0]) |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
39 s.update(l[1]) |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
40 s.update(text) |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
41 return s.digest() |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
42 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
43 def compress(text): |
1083 | 44 """ generate a possibly-compressed representation of text """ |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
45 if not text: return ("", text) |
112 | 46 if len(text) < 44: |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
47 if text[0] == '\0': return ("", text) |
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
48 return ('u', text) |
112 | 49 bin = zlib.compress(text) |
50 if len(bin) > len(text): | |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
51 if text[0] == '\0': return ("", text) |
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
52 return ('u', text) |
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
53 return ("", bin) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
54 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
55 def decompress(bin): |
1083 | 56 """ decompress the given input """ |
112 | 57 if not bin: return bin |
58 t = bin[0] | |
59 if t == '\0': return bin | |
60 if t == 'x': return zlib.decompress(bin) | |
61 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
|
62 raise RevlogError(_("unknown compression type %r") % t) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
63 |
2072 | 64 indexformatv0 = ">4l20s20s20s" |
2079 | 65 v0shaoffset = 56 |
2072 | 66 # index ng: |
67 # 6 bytes offset | |
68 # 2 bytes flags | |
69 # 4 bytes compressed length | |
70 # 4 bytes uncompressed length | |
71 # 4 bytes: base rev | |
72 # 4 bytes link rev | |
73 # 4 bytes parent 1 rev | |
74 # 4 bytes parent 2 rev | |
75 # 32 bytes: nodeid | |
76 indexformatng = ">Qiiiiii20s12x" | |
2079 | 77 ngshaoffset = 32 |
3755
05120e210c65
Use unsigned version format.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3754
diff
changeset
|
78 versionformat = ">I" |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
79 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
80 class lazyparser(object): |
1083 | 81 """ |
82 this class avoids the need to parse the entirety of large indices | |
83 """ | |
2250
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
84 |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
85 # lazyparser is not safe to use on windows if win32 extensions not |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
86 # available. it keeps file handle open, which make it not possible |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
87 # to break hardlinks on local cloned repos. |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
88 safe_to_use = os.name != 'nt' or (not util.is_win_9x() and |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
89 hasattr(util, 'win32api')) |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
90 |
2079 | 91 def __init__(self, dataf, size, indexformat, shaoffset): |
92 self.dataf = dataf | |
93 self.format = indexformat | |
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
94 self.s = struct.calcsize(indexformat) |
2072 | 95 self.indexformat = indexformat |
2079 | 96 self.datasize = size |
97 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
|
98 self.index = [None] * self.l |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
99 self.map = {nullid: nullrev} |
2079 | 100 self.allmap = 0 |
323 | 101 self.all = 0 |
2079 | 102 self.mapfind_count = 0 |
103 self.shaoffset = shaoffset | |
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
104 |
2079 | 105 def loadmap(self): |
106 """ | |
107 during a commit, we need to make sure the rev being added is | |
108 not a duplicate. This requires loading the entire index, | |
109 which is fairly slow. loadmap can load up just the node map, | |
110 which takes much less time. | |
111 """ | |
112 if self.allmap: return | |
113 end = self.datasize | |
114 self.allmap = 1 | |
115 cur = 0 | |
116 count = 0 | |
117 blocksize = self.s * 256 | |
118 self.dataf.seek(0) | |
119 while cur < end: | |
120 data = self.dataf.read(blocksize) | |
121 off = 0 | |
122 for x in xrange(256): | |
123 n = data[off + self.shaoffset:off + self.shaoffset + 20] | |
124 self.map[n] = count | |
125 count += 1 | |
126 if count >= self.l: | |
127 break | |
128 off += self.s | |
129 cur += blocksize | |
130 | |
131 def loadblock(self, blockstart, blocksize, data=None): | |
323 | 132 if self.all: return |
2079 | 133 if data is None: |
134 self.dataf.seek(blockstart) | |
3075
baa3873eb387
don't let lazyparser read more data than it can handle
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2910
diff
changeset
|
135 if blockstart + blocksize > self.datasize: |
baa3873eb387
don't let lazyparser read more data than it can handle
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2910
diff
changeset
|
136 # the revlog may have grown since we've started running, |
baa3873eb387
don't let lazyparser read more data than it can handle
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2910
diff
changeset
|
137 # but we don't have space in self.index for more entries. |
baa3873eb387
don't let lazyparser read more data than it can handle
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2910
diff
changeset
|
138 # limit blocksize so that we don't get too much data. |
3086
e7fc04dc6349
Avoid negative block sizes in lazyparser.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3075
diff
changeset
|
139 blocksize = max(self.datasize - blockstart, 0) |
2079 | 140 data = self.dataf.read(blocksize) |
141 lend = len(data) / self.s | |
142 i = blockstart / self.s | |
143 off = 0 | |
4061
40030c1b6bc6
lazyindex: handle __delitem__ in loadblock
Brendan Cully <brendan@kublai.com>
parents:
3930
diff
changeset
|
144 # lazyindex supports __delitem__ |
40030c1b6bc6
lazyindex: handle __delitem__ in loadblock
Brendan Cully <brendan@kublai.com>
parents:
3930
diff
changeset
|
145 if lend > len(self.index) - i: |
40030c1b6bc6
lazyindex: handle __delitem__ in loadblock
Brendan Cully <brendan@kublai.com>
parents:
3930
diff
changeset
|
146 lend = len(self.index) - i |
2079 | 147 for x in xrange(lend): |
148 if self.index[i + x] == None: | |
149 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
|
150 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
|
151 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
|
152 self.map[n] = i + x |
2079 | 153 off += self.s |
154 | |
155 def findnode(self, node): | |
156 """search backwards through the index file for a specific node""" | |
157 if self.allmap: return None | |
158 | |
159 # hg log will cause many many searches for the manifest | |
160 # nodes. After we get called a few times, just load the whole | |
161 # thing. | |
162 if self.mapfind_count > 8: | |
163 self.loadmap() | |
164 if node in self.map: | |
165 return node | |
166 return None | |
167 self.mapfind_count += 1 | |
168 last = self.l - 1 | |
169 while self.index[last] != None: | |
170 if last == 0: | |
171 self.all = 1 | |
172 self.allmap = 1 | |
173 return None | |
174 last -= 1 | |
175 end = (last + 1) * self.s | |
176 blocksize = self.s * 256 | |
177 while end >= 0: | |
178 start = max(end - blocksize, 0) | |
179 self.dataf.seek(start) | |
180 data = self.dataf.read(end - start) | |
181 findend = end - start | |
182 while True: | |
183 # we're searching backwards, so weh have to make sure | |
184 # we don't find a changeset where this node is a parent | |
185 off = data.rfind(node, 0, findend) | |
186 findend = off | |
187 if off >= 0: | |
188 i = off / self.s | |
189 off = i * self.s | |
190 n = data[off + self.shaoffset:off + self.shaoffset + 20] | |
191 if n == node: | |
192 self.map[n] = i + start / self.s | |
193 return node | |
194 else: | |
195 break | |
196 end -= blocksize | |
197 return None | |
198 | |
199 def loadindex(self, i=None, end=None): | |
200 if self.all: return | |
201 all = False | |
202 if i == None: | |
203 blockstart = 0 | |
204 blocksize = (512 / self.s) * self.s | |
205 end = self.datasize | |
206 all = True | |
323 | 207 else: |
2079 | 208 if end: |
209 blockstart = i * self.s | |
210 end = end * self.s | |
211 blocksize = end - blockstart | |
212 else: | |
4314
43dedce9667e
revlog.py: fix/tweak read ahead code in lazyparser
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4222
diff
changeset
|
213 blockstart = (i & ~63) * self.s |
2079 | 214 blocksize = self.s * 64 |
215 end = blockstart + blocksize | |
216 while blockstart < end: | |
217 self.loadblock(blockstart, blocksize) | |
218 blockstart += blocksize | |
219 if all: self.all = True | |
515 | 220 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
221 class lazyindex(object): |
1083 | 222 """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
|
223 def __init__(self, parser): |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
224 self.p = parser |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
225 def __len__(self): |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
226 return len(self.p.index) |
115 | 227 def load(self, pos): |
1403
bc3e66edb04c
lazyindex fix, make load handle negative indexes properly.
Eric Hopper <hopper@omnifarious.org>
parents:
1402
diff
changeset
|
228 if pos < 0: |
bc3e66edb04c
lazyindex fix, make load handle negative indexes properly.
Eric Hopper <hopper@omnifarious.org>
parents:
1402
diff
changeset
|
229 pos += len(self.p.index) |
2079 | 230 self.p.loadindex(pos) |
115 | 231 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
|
232 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
|
233 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
|
234 if isinstance(ret, str): |
1cbb14c048cb
Reduce index memory usage by storing the bare string instead of tuples
mason@suse.com
parents:
2079
diff
changeset
|
235 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
|
236 return ret |
2072 | 237 def __setitem__(self, pos, item): |
238 self.p.index[pos] = item | |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
239 def __delitem__(self, pos): |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
240 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
|
241 def append(self, e): |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
242 self.p.index.append(e) |
515 | 243 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
244 class lazymap(object): |
1083 | 245 """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
|
246 def __init__(self, parser): |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
247 self.p = parser |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
248 def load(self, key): |
2079 | 249 n = self.p.findnode(key) |
250 if n == None: | |
1214 | 251 raise KeyError(key) |
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
252 def __contains__(self, key): |
2079 | 253 if key in self.p.map: |
254 return True | |
255 self.p.loadmap() | |
323 | 256 return key in self.p.map |
97 | 257 def __iter__(self): |
469 | 258 yield nullid |
97 | 259 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
|
260 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
|
261 if not ret: |
2079 | 262 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
|
263 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
|
264 if isinstance(ret, str): |
1cbb14c048cb
Reduce index memory usage by storing the bare string instead of tuples
mason@suse.com
parents:
2079
diff
changeset
|
265 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
|
266 yield ret[-1] |
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
267 def __getitem__(self, key): |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
268 try: |
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
269 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
|
270 except KeyError: |
86
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
271 try: |
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
272 self.load(key) |
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
273 return self.p.map[key] |
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
274 except KeyError: |
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
275 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
|
276 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
|
277 self.p.map[key] = val |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
278 def __delitem__(self, key): |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
279 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
|
280 |
1073
7b35a980b982
[PATCH] raise exceptions with Exception subclasses
Bart Trojanowski <bart@jukie.net>
parents:
1062
diff
changeset
|
281 class RevlogError(Exception): pass |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
282 class LookupError(RevlogError): pass |
1073
7b35a980b982
[PATCH] raise exceptions with Exception subclasses
Bart Trojanowski <bart@jukie.net>
parents:
1062
diff
changeset
|
283 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
284 class revlog(object): |
1083 | 285 """ |
286 the underlying revision storage object | |
287 | |
288 A revlog consists of two parts, an index and the revision data. | |
289 | |
290 The index is a file with a fixed record size containing | |
291 information on each revision, includings its nodeid (hash), the | |
292 nodeids of its parents, the position and offset of its data within | |
293 the data file, and the revision it's based on. Finally, each entry | |
294 contains a linkrev entry that can serve as a pointer to external | |
295 data. | |
296 | |
297 The revision data itself is a linear collection of data chunks. | |
298 Each chunk represents a revision and is usually represented as a | |
299 delta against the previous chunk. To bound lookup time, runs of | |
300 deltas are limited to about 2 times the length of the original | |
301 version data. This makes retrieval of a version proportional to | |
302 its size, or O(1) relative to the number of revisions. | |
303 | |
304 Both pieces of the revlog are written to in an append-only | |
305 fashion, which means we never need to rewrite a file to insert or | |
306 remove data, and can use some simple techniques to avoid the need | |
307 for locking while reading. | |
308 """ | |
4267
b11a2fb59cf5
revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4266
diff
changeset
|
309 def __init__(self, opener, indexfile): |
1083 | 310 """ |
311 create a revlog object | |
312 | |
313 opener is a function that abstracts the file opening operation | |
314 and can be used to implement COW semantics or the like. | |
315 """ | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
316 self.indexfile = indexfile |
4266
1b5c38e9d7aa
revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents:
4224
diff
changeset
|
317 self.datafile = indexfile[:-2] + ".d" |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
318 self.opener = opener |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
319 |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
320 self.indexstat = None |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
321 self.cache = None |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
322 self.chunkcache = None |
4277
0ce23256e454
Fixed spacing in assignment of REVLOG_DEFAULT_VERSION
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4267
diff
changeset
|
323 self.defversion = REVLOG_DEFAULT_VERSION |
4267
b11a2fb59cf5
revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4266
diff
changeset
|
324 if hasattr(opener, "defversion"): |
b11a2fb59cf5
revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4266
diff
changeset
|
325 self.defversion = opener.defversion |
4302
d69bdc1091b8
Fixups for recent changes in revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4277
diff
changeset
|
326 if self.defversion & REVLOGNG: |
d69bdc1091b8
Fixups for recent changes in revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4277
diff
changeset
|
327 self.defversion |= REVLOGNGINLINEDATA |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
328 self.load() |
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
329 |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
330 def load(self): |
2072 | 331 v = self.defversion |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
332 try: |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
333 f = self.opener(self.indexfile) |
2079 | 334 i = f.read(4) |
335 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
|
336 except IOError, inst: |
b3d44e9b3092
Make revlog constructor more discerning in its treatment of errors.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1232
diff
changeset
|
337 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
|
338 raise |
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
339 i = "" |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
340 else: |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
341 try: |
2176
9b42304d9896
fix file handling bugs on windows.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2089
diff
changeset
|
342 st = util.fstat(f) |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
343 except AttributeError, inst: |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
344 st = None |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
345 else: |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
346 oldst = self.indexstat |
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
347 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
|
348 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
|
349 and st.st_mtime == oldst.st_mtime |
4495
769cc8ef5b72
Also check the index file size when deciding whether to reload a revlog.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4314
diff
changeset
|
350 and st.st_ctime == oldst.st_ctime |
769cc8ef5b72
Also check the index file size when deciding whether to reload a revlog.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4314
diff
changeset
|
351 and st.st_size == oldst.st_size): |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
352 return |
2072 | 353 self.indexstat = st |
2138
f5046cab9e2e
Fix revlog-ng interaction with old-http.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2089
diff
changeset
|
354 if len(i) > 0: |
f5046cab9e2e
Fix revlog-ng interaction with old-http.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2089
diff
changeset
|
355 v = struct.unpack(versionformat, i)[0] |
2073 | 356 flags = v & ~0xFFFF |
357 fmt = v & 0xFFFF | |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
358 if fmt == REVLOGV0: |
2073 | 359 if flags: |
3754
cd25a4a1a265
Improve error message for unknown revlog flags.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3744
diff
changeset
|
360 raise RevlogError(_("index %s unknown flags %#04x for format v0") |
cd25a4a1a265
Improve error message for unknown revlog flags.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3744
diff
changeset
|
361 % (self.indexfile, flags >> 16)) |
2073 | 362 elif fmt == REVLOGNG: |
363 if flags & ~REVLOGNGINLINEDATA: | |
3754
cd25a4a1a265
Improve error message for unknown revlog flags.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3744
diff
changeset
|
364 raise RevlogError(_("index %s unknown flags %#04x for revlogng") |
cd25a4a1a265
Improve error message for unknown revlog flags.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3744
diff
changeset
|
365 % (self.indexfile, flags >> 16)) |
2073 | 366 else: |
3744
3a099154b110
Make revlog error slightly less scary
Matt Mackall <mpm@selenic.com>
parents:
3683
diff
changeset
|
367 raise RevlogError(_("index %s unknown format %d") |
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
368 % (self.indexfile, fmt)) |
2072 | 369 self.version = v |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
370 if v == REVLOGV0: |
2072 | 371 self.indexformat = indexformatv0 |
2079 | 372 shaoffset = v0shaoffset |
2072 | 373 else: |
374 self.indexformat = indexformatng | |
2079 | 375 shaoffset = ngshaoffset |
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
376 |
2072 | 377 if i: |
2250
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
378 if (lazyparser.safe_to_use and not self.inlinedata() and |
45aef5ddcdbe
windows: revlog.lazyparser not always safe to use.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2222
diff
changeset
|
379 st and st.st_size > 10000): |
2072 | 380 # big index, let's parse it on demand |
2079 | 381 parser = lazyparser(f, st.st_size, self.indexformat, shaoffset) |
2072 | 382 self.index = lazyindex(parser) |
383 self.nodemap = lazymap(parser) | |
384 else: | |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
385 self.parseindex(f, st) |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
386 if self.version != REVLOGV0: |
2072 | 387 e = list(self.index[0]) |
388 type = self.ngtype(e[0]) | |
389 e[0] = self.offset_type(0, type) | |
390 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
|
391 else: |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
392 self.nodemap = {nullid: nullrev} |
2072 | 393 self.index = [] |
394 | |
395 | |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
396 def parseindex(self, fp, st): |
2072 | 397 s = struct.calcsize(self.indexformat) |
398 self.index = [] | |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
399 self.nodemap = {nullid: nullrev} |
2073 | 400 inline = self.inlinedata() |
2072 | 401 n = 0 |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
402 leftover = None |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
403 while True: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
404 if st: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
405 data = fp.read(65536) |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
406 else: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
407 # hack for httprangereader, it doesn't do partial reads well |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
408 data = fp.read() |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
409 if not data: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
410 break |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
411 if n == 0 and self.inlinedata(): |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
412 # cache the first chunk |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
413 self.chunkcache = (0, data) |
2289
854954fd410a
Fix revlog.parseindex
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2255
diff
changeset
|
414 if leftover: |
854954fd410a
Fix revlog.parseindex
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2255
diff
changeset
|
415 data = leftover + data |
854954fd410a
Fix revlog.parseindex
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2255
diff
changeset
|
416 leftover = None |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
417 off = 0 |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
418 l = len(data) |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
419 while off < l: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
420 if l - off < s: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
421 leftover = data[off:] |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
422 break |
2289
854954fd410a
Fix revlog.parseindex
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2255
diff
changeset
|
423 cur = data[off:off + s] |
854954fd410a
Fix revlog.parseindex
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2255
diff
changeset
|
424 off += s |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
425 e = struct.unpack(self.indexformat, cur) |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
426 self.index.append(e) |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
427 self.nodemap[e[-1]] = n |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
428 n += 1 |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
429 if inline: |
4222
90bb1ab53a85
revlog: attempt to gracefully handle some interleaved damage
Matt Mackall <mpm@selenic.com>
parents:
3925
diff
changeset
|
430 if e[1] < 0: |
90bb1ab53a85
revlog: attempt to gracefully handle some interleaved damage
Matt Mackall <mpm@selenic.com>
parents:
3925
diff
changeset
|
431 break |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
432 off += e[1] |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
433 if off > l: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
434 # some things don't seek well, just read it |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
435 fp.read(off - l) |
4222
90bb1ab53a85
revlog: attempt to gracefully handle some interleaved damage
Matt Mackall <mpm@selenic.com>
parents:
3925
diff
changeset
|
436 break |
2255
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
437 if not st: |
3f38e872f39a
Reduce ram used for very large inlined index files
mason@suse.com
parents:
2250
diff
changeset
|
438 break |
2600
c4325f0a9b91
clean up trailing white space.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2561
diff
changeset
|
439 |
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
440 |
2072 | 441 def ngoffset(self, q): |
442 if q & 0xFFFF: | |
443 raise RevlogError(_('%s: incompatible revision flag %x') % | |
2141
ed631e83fa06
Corrected error message for incompatible revision flags.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2138
diff
changeset
|
444 (self.indexfile, q)) |
2072 | 445 return long(q >> 16) |
446 | |
447 def ngtype(self, q): | |
448 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
|
449 |
2072 | 450 def offset_type(self, offset, type): |
451 return long(long(offset) << 16 | type) | |
452 | |
2079 | 453 def loadindex(self, start, end): |
454 """load a block of indexes all at once from the lazy parser""" | |
455 if isinstance(self.index, lazyindex): | |
456 self.index.p.loadindex(start, end) | |
457 | |
2072 | 458 def loadindexmap(self): |
459 """loads both the map and the index from the lazy parser""" | |
460 if isinstance(self.index, lazyindex): | |
461 p = self.index.p | |
2079 | 462 p.loadindex() |
463 self.nodemap = p.map | |
464 | |
465 def loadmap(self): | |
466 """loads the map from the lazy parser""" | |
467 if isinstance(self.nodemap, lazymap): | |
468 self.nodemap.p.loadmap() | |
469 self.nodemap = self.nodemap.p.map | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
470 |
2073 | 471 def inlinedata(self): return self.version & REVLOGNGINLINEDATA |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
472 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
|
473 def count(self): return len(self.index) |
2072 | 474 def node(self, rev): |
3585
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
475 return rev == nullrev 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
|
476 def rev(self, node): |
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
477 try: |
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
478 return self.nodemap[node] |
59bfbdbc38f6
revlog: raise informative exception if file is missing.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1099
diff
changeset
|
479 except KeyError: |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
480 raise LookupError(_('%s: no node %s') % (self.indexfile, hex(node))) |
2651
6414ee2eb688
correct the handling of linkrev with nullid
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2650
diff
changeset
|
481 def linkrev(self, node): |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
482 return (node == nullid) and nullrev or self.index[self.rev(node)][-4] |
2 | 483 def parents(self, node): |
484 if node == nullid: return (nullid, nullid) | |
2072 | 485 r = self.rev(node) |
486 d = self.index[r][-3:-1] | |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
487 if self.version == REVLOGV0: |
2072 | 488 return d |
3505
0aef94f45ebf
revlog.py: always return tuples from parents and parentrevs
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3499
diff
changeset
|
489 return (self.node(d[0]), self.node(d[1])) |
2489
568e58eed096
Add revlog.parentrevs function.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2354
diff
changeset
|
490 def parentrevs(self, rev): |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
491 if rev == nullrev: |
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
492 return (nullrev, nullrev) |
2489
568e58eed096
Add revlog.parentrevs function.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2354
diff
changeset
|
493 d = self.index[rev][-3:-1] |
568e58eed096
Add revlog.parentrevs function.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2354
diff
changeset
|
494 if self.version == REVLOGV0: |
3505
0aef94f45ebf
revlog.py: always return tuples from parents and parentrevs
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3499
diff
changeset
|
495 return (self.rev(d[0]), self.rev(d[1])) |
2489
568e58eed096
Add revlog.parentrevs function.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2354
diff
changeset
|
496 return d |
2072 | 497 def start(self, rev): |
3585
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
498 if rev == nullrev: |
3584
8dbbe4dadb48
revlog: return 0 as offset for nullid
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3582
diff
changeset
|
499 return 0 |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
500 if self.version != REVLOGV0: |
2072 | 501 return self.ngoffset(self.index[rev][0]) |
502 return self.index[rev][0] | |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
503 |
2072 | 504 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
|
505 |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
506 def size(self, rev): |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
507 """return the length of the uncompressed text for a given revision""" |
3582
9fb7d3a05882
revlog.size() fix handling of rev == -1
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3578
diff
changeset
|
508 if rev == nullrev: |
9fb7d3a05882
revlog.size() fix handling of rev == -1
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3578
diff
changeset
|
509 return 0 |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
510 l = -1 |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
511 if self.version != REVLOGV0: |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
512 l = self.index[rev][2] |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
513 if l >= 0: |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
514 return l |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
515 |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
516 t = self.revision(self.node(rev)) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
517 return len(t) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
518 |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
519 # 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
|
520 # 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
|
521 # 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
|
522 """ |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
523 if self.cache and self.cache[1] == rev: |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
524 return len(self.cache[2]) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
525 |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
526 base = self.base(rev) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
527 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
|
528 base = self.cache[1] |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
529 text = self.cache[2] |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
530 else: |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
531 text = self.revision(self.node(base)) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
532 |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
533 l = len(text) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
534 for x in xrange(base + 1, rev + 1): |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
535 l = mdiff.patchedsize(l, self.chunk(x)) |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
536 return l |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
537 """ |
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
538 |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
539 def length(self, rev): |
3585
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
540 if rev == nullrev: |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
541 return 0 |
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
542 else: |
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
543 return self.index[rev][1] |
3585
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
544 def base(self, rev): |
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
545 if (rev == nullrev): |
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
546 return nullrev |
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
547 else: |
cac2c17bec5a
revlog: more nullrev fixes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3584
diff
changeset
|
548 return self.index[rev][-5] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
549 |
3633
508036290b00
revlog: reachable actually takes a node
Matt Mackall <mpm@selenic.com>
parents:
3585
diff
changeset
|
550 def reachable(self, node, stop=None): |
3683 | 551 """return a hash of all nodes ancestral to a given node, including |
552 the node itself, stopping when stop is matched""" | |
1074
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
553 reachable = {} |
3633
508036290b00
revlog: reachable actually takes a node
Matt Mackall <mpm@selenic.com>
parents:
3585
diff
changeset
|
554 visit = [node] |
508036290b00
revlog: reachable actually takes a node
Matt Mackall <mpm@selenic.com>
parents:
3585
diff
changeset
|
555 reachable[node] = 1 |
1074
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
556 if stop: |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
557 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
|
558 else: |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
559 stopn = 0 |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
560 while visit: |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
561 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
|
562 if n == stop: |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
563 continue |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
564 if n == nullid: |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
565 continue |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
566 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
|
567 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
|
568 continue |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
569 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
|
570 reachable[p] = 1 |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
571 visit.append(p) |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
572 return reachable |
55bf5cfde69e
Add revlog.reachable to find a graph of ancestors for a given rev
mason@suse.com
parents:
1073
diff
changeset
|
573 |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
574 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
|
575 """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
|
576 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
|
577 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
|
578 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
579 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
|
580 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
|
581 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
|
582 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
|
583 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
|
584 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
585 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
|
586 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
|
587 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
|
588 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
|
589 nonodes = ([], [], []) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
590 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
|
591 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
|
592 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
|
593 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
594 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
|
595 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
596 roots = [nullid] # Everybody's a descendent of nullid |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
597 lowestrev = nullrev |
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
598 if (lowestrev == nullrev) and (heads is None): |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
599 # 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
|
600 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
|
601 [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
|
602 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
|
603 # 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
|
604 # node. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
605 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
|
606 # 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
|
607 ancestors = None |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
608 # 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
|
609 heads = {} |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
610 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
|
611 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
|
612 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
|
613 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
614 ancestors = {} |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
615 # 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
|
616 # 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
|
617 # find from roots. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
618 heads = dict.fromkeys(heads, 0) |
3360
ef8307585b41
nodesbetween: fix a bug with duplicate heads
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3333
diff
changeset
|
619 # Start at the top and keep marking parents until we're done. |
ef8307585b41
nodesbetween: fix a bug with duplicate heads
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3333
diff
changeset
|
620 nodestotag = heads.keys() |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
621 # 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
|
622 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
|
623 while nodestotag: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
624 # 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
|
625 n = nodestotag.pop() |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
626 # Never tag nullid |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
627 if n == nullid: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
628 continue |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
629 # 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
|
630 # 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
|
631 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
|
632 if r >= lowestrev: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
633 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
|
634 # 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
|
635 # 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
|
636 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
|
637 # 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
|
638 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
|
639 p != nullid]) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
640 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
|
641 # 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
|
642 # any other heads. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
643 heads.pop(n) |
1459
106fdec8e1fb
Fix small bug in nodesbetween if heads is [nullid].
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
644 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
|
645 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
646 # 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
|
647 # 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
|
648 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
649 # If one of the roots was nullid, everything is included anyway. |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
650 if lowestrev > nullrev: |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
651 # 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
|
652 # 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
|
653 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
654 # 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
|
655 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
|
656 # 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
|
657 if roots: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
658 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
|
659 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
660 # 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
|
661 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
662 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
663 # 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
|
664 # any other roots. |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
665 lowestrev = nullrev |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
666 roots = [nullid] |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
667 # 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
|
668 # 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
|
669 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
|
670 # 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
|
671 # '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
|
672 roots = descendents.copy() |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
673 # 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
|
674 orderedout = [] |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
675 # 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
|
676 # 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
|
677 # they're descendents. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
678 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
|
679 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
|
680 isdescendent = False |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
681 if lowestrev == nullrev: # Everybody is a descendent of nullid |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
682 isdescendent = True |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
683 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
|
684 # 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
|
685 isdescendent = True |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
686 # 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
|
687 # 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
|
688 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
|
689 # 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
|
690 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
|
691 # 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
|
692 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
|
693 roots.pop(n) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
694 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
695 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
|
696 # 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
|
697 # 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
|
698 # up there, remember?) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
699 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
|
700 descendents[n] = 1 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
701 isdescendent = True |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
702 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
|
703 # 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
|
704 orderedout.append(n) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
705 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
|
706 # 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
|
707 # from roots. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
708 # 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
|
709 heads[n] = 1 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
710 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
|
711 # 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
|
712 # 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
|
713 # 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
|
714 heads[n] = 1 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
715 # 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
|
716 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
|
717 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
|
718 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
|
719 roots = roots.keys() |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
720 assert orderedout |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
721 assert roots |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
722 assert heads |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
723 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
|
724 |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
725 def heads(self, start=None, stop=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
|
726 """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
|
727 |
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
728 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
|
729 start will be returned |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
730 if stop is specified, it will consider all the revs from stop |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
731 as if they had no children |
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
732 """ |
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
733 if start is None: |
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
734 start = nullid |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
735 if stop is None: |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
736 stop = [] |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
737 stoprevs = dict.fromkeys([self.rev(n) for n in stop]) |
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
|
738 startrev = self.rev(start) |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
739 reachable = {startrev: 1} |
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
740 heads = {startrev: 1} |
1083 | 741 |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
742 parentrevs = self.parentrevs |
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
|
743 for r in xrange(startrev + 1, self.count()): |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
744 for p in parentrevs(r): |
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
745 if p in reachable: |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
746 if r not in stoprevs: |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
747 reachable[r] = 1 |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
748 heads[r] = 1 |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
749 if p in heads and p not in stoprevs: |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
750 del heads[p] |
3925
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
751 |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
752 return [self.node(r) for r in heads] |
370 | 753 |
754 def children(self, node): | |
1083 | 755 """find the children of a given node""" |
370 | 756 c = [] |
757 p = self.rev(node) | |
758 for r in range(p + 1, self.count()): | |
4781
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
759 prevs = [pr for pr in self.parentrevs(r) if pr != nullrev] |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
760 if prevs: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
761 for pr in prevs: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
762 if pr == p: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
763 c.append(self.node(r)) |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
764 elif p == nullrev: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
765 c.append(self.node(r)) |
370 | 766 return c |
515 | 767 |
3494
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
768 def _match(self, id): |
3210
7240f9e47144
correctly find the type of 'id' in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3153
diff
changeset
|
769 if isinstance(id, (long, int)): |
3152
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
770 # rev |
2650
156fb1feab62
lookup should allow -1 to represent nullid (if passed an int as arg)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2600
diff
changeset
|
771 return self.node(id) |
3438 | 772 if len(id) == 20: |
773 # possibly a binary node | |
774 # odds of a binary node being all hex in ASCII are 1 in 10**25 | |
775 try: | |
776 node = id | |
777 r = self.rev(node) # quick search the index | |
778 return node | |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
779 except LookupError: |
3438 | 780 pass # may be partial hex id |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
781 try: |
3152
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
782 # str(rev) |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
783 rev = int(id) |
469 | 784 if str(rev) != id: raise ValueError |
785 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
|
786 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
|
787 return self.node(rev) |
469 | 788 except (ValueError, OverflowError): |
3152
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
789 pass |
3494
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
790 if len(id) == 40: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
791 try: |
3438 | 792 # a full hex nodeid? |
793 node = bin(id) | |
794 r = self.rev(node) | |
3153
4fe41a9e4591
optimize revlog.lookup when passed hex(node)[:...]
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3152
diff
changeset
|
795 return node |
3494
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
796 except TypeError: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
797 pass |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
798 |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
799 def _partialmatch(self, id): |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
800 if len(id) < 40: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
801 try: |
3438 | 802 # hex(node)[:...] |
803 bin_id = bin(id[:len(id) & ~1]) # grab an even number of digits | |
804 node = None | |
805 for n in self.nodemap: | |
806 if n.startswith(bin_id) and hex(n).startswith(id): | |
807 if node is not None: | |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
808 raise LookupError(_("Ambiguous identifier")) |
3438 | 809 node = n |
810 if node is not None: | |
811 return node | |
3494
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
812 except TypeError: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
813 pass |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
814 |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
815 def lookup(self, id): |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
816 """locate a node based on: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
817 - revision number or str(revision number) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
818 - nodeid or subset of hex nodeid |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
819 """ |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
820 |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
821 n = self._match(id) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
822 if n is not None: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
823 return n |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
824 n = self._partialmatch(id) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
825 if n: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
826 return n |
515 | 827 |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
828 raise LookupError(_("No match found")) |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
829 |
2910
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
830 def cmp(self, node, text): |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
831 """compare text with a given file revision""" |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
832 p1, p2 = self.parents(node) |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
833 return hash(text, p1, p2) != node |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
834 |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
835 def makenode(self, node, text): |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
836 """calculate a file nodeid for text, descended or possibly |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
837 unchanged from node""" |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
838 |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
839 if self.cmp(node, text): |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
840 return hash(text, node, nullid) |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
841 return node |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2858
diff
changeset
|
842 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
843 def diff(self, a, b): |
1083 | 844 """return a delta between two revisions""" |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
845 return mdiff.textdiff(a, b) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
846 |
73 | 847 def patches(self, t, pl): |
1083 | 848 """apply a list of patches to a string""" |
73 | 849 return mdiff.patches(t, pl) |
850 | |
2072 | 851 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
|
852 start, length = self.start(rev), self.length(rev) |
2073 | 853 inline = self.inlinedata() |
854 if inline: | |
855 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
|
856 end = start + length |
2072 | 857 def loadcache(df): |
858 cache_length = max(cachelen, length) # 4k | |
859 if not df: | |
2073 | 860 if inline: |
861 df = self.opener(self.indexfile) | |
862 else: | |
863 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
|
864 df.seek(start) |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
865 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
|
866 |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
867 if not self.chunkcache: |
2072 | 868 loadcache(df) |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
869 |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
870 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
|
871 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
|
872 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
|
873 # it is cached |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
874 offset = start - cache_start |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
875 else: |
2072 | 876 loadcache(df) |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
877 offset = 0 |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
878 |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
879 #def checkchunk(): |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
880 # 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
|
881 # df.seek(start) |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
882 # return df.read(length) |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
883 #assert s == checkchunk() |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
884 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
|
885 |
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
886 def delta(self, node): |
1083 | 887 """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
|
888 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
|
889 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
|
890 |
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
891 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
|
892 """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
|
893 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
|
894 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
|
895 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
|
896 return self.chunk(rev2) |
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
897 else: |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
898 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
|
899 self.revision(self.node(rev2))) |
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
900 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
901 def revision(self, node): |
1083 | 902 """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
|
903 if node == nullid: return "" |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
904 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
|
905 |
1083 | 906 # look up what we need to read |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
907 text = None |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
908 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
|
909 base = self.base(rev) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
910 |
2073 | 911 if self.inlinedata(): |
912 # we probably have the whole chunk cached | |
913 df = None | |
914 else: | |
915 df = self.opener(self.datafile) | |
2072 | 916 |
1083 | 917 # do we have useful data cached? |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
918 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
|
919 base = self.cache[1] |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
920 text = self.cache[2] |
2079 | 921 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
|
922 else: |
2079 | 923 self.loadindex(base, rev + 1) |
2072 | 924 text = self.chunk(base, df=df) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
925 |
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
926 bins = [] |
64 | 927 for r in xrange(base + 1, rev + 1): |
2072 | 928 bins.append(self.chunk(r, df=df)) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
929 |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
930 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
|
931 |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
932 p1, p2 = self.parents(node) |
26 | 933 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
|
934 raise RevlogError(_("integrity check failed on %s:%d") |
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
935 % (self.datafile, rev)) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
936 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
937 self.cache = (node, rev, text) |
515 | 938 return text |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
939 |
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
940 def checkinlinesize(self, tr, fp=None): |
2073 | 941 if not self.inlinedata(): |
942 return | |
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
943 if not fp: |
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
944 fp = self.opener(self.indexfile, 'r') |
2082
856f0ba200bc
Additional appendfile fixes for interleaved data/index files
mason@suse.com
parents:
2081
diff
changeset
|
945 fp.seek(0, 2) |
2073 | 946 size = fp.tell() |
947 if size < 131072: | |
948 return | |
2084 | 949 trinfo = tr.find(self.indexfile) |
950 if trinfo == None: | |
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
951 raise RevlogError(_("%s not found in the transaction") |
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
952 % self.indexfile) |
2084 | 953 |
954 trindex = trinfo[2] | |
955 dataoff = self.start(trindex) | |
956 | |
957 tr.add(self.datafile, dataoff) | |
2073 | 958 df = self.opener(self.datafile, 'w') |
959 calc = struct.calcsize(self.indexformat) | |
960 for r in xrange(self.count()): | |
961 start = self.start(r) + (r + 1) * calc | |
962 length = self.length(r) | |
963 fp.seek(start) | |
964 d = fp.read(length) | |
965 df.write(d) | |
966 fp.close() | |
967 df.close() | |
2076
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
968 fp = self.opener(self.indexfile, 'w', atomictemp=True) |
2073 | 969 self.version &= ~(REVLOGNGINLINEDATA) |
970 if self.count(): | |
971 x = self.index[0] | |
972 e = struct.pack(self.indexformat, *x)[4:] | |
973 l = struct.pack(versionformat, self.version) | |
974 fp.write(l) | |
975 fp.write(e) | |
976 | |
977 for i in xrange(1, self.count()): | |
978 x = self.index[i] | |
979 e = struct.pack(self.indexformat, *x) | |
980 fp.write(e) | |
981 | |
2076
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
982 # 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
|
983 # real index |
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
984 fp.rename() |
2084 | 985 |
986 tr.replace(self.indexfile, trindex * calc) | |
2073 | 987 self.chunkcache = None |
988 | |
644 | 989 def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): |
1083 | 990 """add a revision to the log |
991 | |
992 text - the revision data to add | |
993 transaction - the transaction object used for rollback | |
994 link - the linkrev data to add | |
995 p1, p2 - the parent nodeids of the revision | |
996 d - an optional precomputed delta | |
997 """ | |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
998 if not self.inlinedata(): |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
999 dfh = self.opener(self.datafile, "a") |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1000 else: |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1001 dfh = None |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1002 ifh = self.opener(self.indexfile, "a+") |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1003 return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1004 |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1005 def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh): |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1006 if text is None: text = "" |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1007 if p1 is None: p1 = self.tip() |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1008 if p2 is None: p2 = nullid |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1009 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1010 node = hash(text, p1, p2) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1011 |
301 | 1012 if node in self.nodemap: |
1013 return node | |
1014 | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1015 n = self.count() |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1016 t = n - 1 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1017 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1018 if n: |
64 | 1019 base = self.base(t) |
1020 start = self.start(base) | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1021 end = self.end(t) |
644 | 1022 if not d: |
1023 prev = self.revision(self.tip()) | |
3333
9061613c1593
Teach bdiff to support buffer objects
Brendan Cully <brendan@kublai.com>
parents:
3210
diff
changeset
|
1024 d = self.diff(prev, text) |
98 | 1025 data = compress(d) |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1026 l = len(data[1]) + len(data[0]) |
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1027 dist = end - start + l |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1028 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1029 # full versions are inserted when the needed deltas |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1030 # become comparable to the uncompressed text |
64 | 1031 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
|
1032 data = compress(text) |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1033 l = len(data[1]) + len(data[0]) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1034 base = n |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1035 else: |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1036 base = self.base(t) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1037 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1038 offset = 0 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1039 if t >= 0: |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1040 offset = self.end(t) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1041 |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
1042 if self.version == REVLOGV0: |
2072 | 1043 e = (offset, l, base, link, p1, p2, node) |
1044 else: | |
1045 e = (self.offset_type(offset, 0), l, len(text), | |
1046 base, link, self.rev(p1), self.rev(p2), node) | |
515 | 1047 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1048 self.index.append(e) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1049 self.nodemap[node] = n |
2072 | 1050 entry = struct.pack(self.indexformat, *e) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1051 |
2073 | 1052 if not self.inlinedata(): |
1053 transaction.add(self.datafile, offset) | |
1054 transaction.add(self.indexfile, n * len(entry)) | |
1055 if data[0]: | |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1056 dfh.write(data[0]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1057 dfh.write(data[1]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1058 dfh.flush() |
2073 | 1059 else: |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1060 ifh.seek(0, 2) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1061 transaction.add(self.indexfile, ifh.tell(), self.count() - 1) |
2072 | 1062 |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
1063 if len(self.index) == 1 and self.version != REVLOGV0: |
2072 | 1064 l = struct.pack(versionformat, self.version) |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1065 ifh.write(l) |
2072 | 1066 entry = entry[4:] |
1067 | |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1068 ifh.write(entry) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1069 |
2073 | 1070 if self.inlinedata(): |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1071 ifh.write(data[0]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1072 ifh.write(data[1]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1073 self.checkinlinesize(transaction, ifh) |
2073 | 1074 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1075 self.cache = (node, n, text) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1076 return node |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1077 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1078 def ancestor(self, a, b): |
1083 | 1079 """calculate the least common ancestor of nodes a and b""" |
2081
416d8b2a75b8
Speedup revlog.ancestors for the linear case
Chris Mason <mason@suse.com>
parents:
2080
diff
changeset
|
1080 |
3139
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1081 def parents(rev): |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
1082 return [p for p in self.parentrevs(rev) if p != nullrev] |
515 | 1083 |
3139
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1084 c = ancestor.ancestor(self.rev(a), self.rev(b), parents) |
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1085 if c is None: |
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1086 return nullid |
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1087 |
1fd1cdcc4200
Switch revlog.ancestor to use revisions rather than nodeids
Matt Mackall <mpm@selenic.com>
parents:
3136
diff
changeset
|
1088 return self.node(c) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1089 |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1090 def group(self, nodelist, lookup, infocollect=None): |
1083 | 1091 """calculate a delta group |
46 | 1092 |
1083 | 1093 Given a list of changeset revs, return a set of deltas and |
1094 metadata corresponding to nodes. the first delta is | |
1095 parent(nodes[0]) -> nodes[0] the receiver is guaranteed to | |
1096 have this parent as it has all history before these | |
1097 changesets. parent is parent[0] | |
1098 """ | |
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1099 revs = [self.rev(n) for n in nodelist] |
46 | 1100 |
1101 # if we don't have any revisions touched by these changesets, bail | |
192 | 1102 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
|
1103 yield changegroup.closechunk() |
192 | 1104 return |
46 | 1105 |
1106 # add the parent of the first rev | |
1107 p = self.parents(self.node(revs[0]))[0] | |
1108 revs.insert(0, self.rev(p)) | |
1109 | |
1110 # build deltas | |
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
1111 for d in xrange(0, len(revs) - 1): |
46 | 1112 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
|
1113 nb = self.node(b) |
192 | 1114 |
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1115 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
|
1116 infocollect(nb) |
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1117 |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
1118 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
|
1119 p = self.parents(nb) |
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1120 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
|
1121 yield changegroup.genchunk("%s%s" % (meta, d)) |
46 | 1122 |
1981
736b6c96bbbc
make incoming work via ssh (issue139); move chunk code into separate module.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1941
diff
changeset
|
1123 yield changegroup.closechunk() |
192 | 1124 |
1062 | 1125 def addgroup(self, revs, linkmapper, transaction, unique=0): |
1083 | 1126 """ |
1127 add a delta group | |
46 | 1128 |
1083 | 1129 given a set of deltas, add them to the revision log. the |
1130 first delta is against its parent, which should be in our | |
1131 log, the rest are against the previous delta. | |
1132 """ | |
1133 | |
1134 #track the base of the current delta log | |
46 | 1135 r = self.count() |
1136 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
|
1137 node = None |
515 | 1138 |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3505
diff
changeset
|
1139 base = prev = nullrev |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1140 start = end = textlen = 0 |
46 | 1141 if r: |
1142 end = self.end(t) | |
1143 | |
2072 | 1144 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
|
1145 ifh.seek(0, 2) |
2084 | 1146 transaction.add(self.indexfile, ifh.tell(), self.count()) |
2073 | 1147 if self.inlinedata(): |
1148 dfh = None | |
1149 else: | |
1150 transaction.add(self.datafile, end) | |
1151 dfh = self.opener(self.datafile, "a") | |
46 | 1152 |
1153 # loop through our set of deltas | |
192 | 1154 chain = None |
1155 for chunk in revs: | |
1156 node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80]) | |
94 | 1157 link = linkmapper(cs) |
77 | 1158 if node in self.nodemap: |
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
1159 # 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
|
1160 # 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
|
1161 # 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
|
1162 chain = node |
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
1163 continue |
192 | 1164 delta = chunk[80:] |
1165 | |
1509
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1166 for p in (p1, p2): |
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1167 if not p in self.nodemap: |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
1168 raise LookupError(_("unknown parent %s") % short(p)) |
1509
46a07392cf28
Add safety check for addgroup
Matt Mackall <mpm@selenic.com>
parents:
1494
diff
changeset
|
1169 |
192 | 1170 if not chain: |
1171 # retrieve the parent revision of the delta chain | |
1172 chain = p1 | |
1173 if not chain in self.nodemap: | |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
1174 raise LookupError(_("unknown base %s") % short(chain[:4])) |
46 | 1175 |
1176 # full versions are inserted when the needed deltas become | |
1177 # comparable to the uncompressed text or when the previous | |
1178 # version is not the one we have a delta against. We use | |
1179 # the size of the previous full rev as a proxy for the | |
1180 # current size. | |
1181 | |
1182 if chain == prev: | |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1183 tempd = compress(delta) |
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1184 cdelta = tempd[0] + tempd[1] |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1185 textlen = mdiff.patchedsize(textlen, delta) |
46 | 1186 |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1187 if chain != prev or (end - start + len(cdelta)) > textlen * 2: |
46 | 1188 # flush our writes here so we can read it in revision |
2072 | 1189 if dfh: |
1190 dfh.flush() | |
46 | 1191 ifh.flush() |
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1192 text = self.revision(chain) |
73 | 1193 text = self.patches(text, [delta]) |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1194 chk = self._addrevision(text, transaction, link, p1, p2, None, |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1195 ifh, dfh) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1196 if not dfh and not self.inlinedata(): |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1197 # addrevision switched from inline to conventional |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1198 # reopen the index |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1199 dfh = self.opener(self.datafile, "a") |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1200 ifh = self.opener(self.indexfile, "a") |
46 | 1201 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
|
1202 raise RevlogError(_("consistency error adding group")) |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1203 textlen = len(text) |
46 | 1204 else: |
2142
8a1e2a9c7013
Replaced 0 with REVLOGV0 where this meaning is used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2141
diff
changeset
|
1205 if self.version == REVLOGV0: |
2072 | 1206 e = (end, len(cdelta), base, link, p1, p2, node) |
1207 else: | |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
2077
diff
changeset
|
1208 e = (self.offset_type(end, 0), len(cdelta), textlen, base, |
2072 | 1209 link, self.rev(p1), self.rev(p2), node) |
46 | 1210 self.index.append(e) |
1211 self.nodemap[node] = r | |
2073 | 1212 if self.inlinedata(): |
1213 ifh.write(struct.pack(self.indexformat, *e)) | |
1214 ifh.write(cdelta) | |
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
1215 self.checkinlinesize(transaction, ifh) |
2073 | 1216 if not self.inlinedata(): |
1217 dfh = self.opener(self.datafile, "a") | |
1218 ifh = self.opener(self.indexfile, "a") | |
1219 else: | |
1220 dfh.write(cdelta) | |
1221 ifh.write(struct.pack(self.indexformat, *e)) | |
46 | 1222 |
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1223 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
|
1224 base = self.base(t) |
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1711
diff
changeset
|
1225 start = self.start(base) |
46 | 1226 end = self.end(t) |
1227 | |
1228 return node | |
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1229 |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1230 def strip(self, rev, minlink): |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1231 if self.count() == 0 or rev >= self.count(): |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1232 return |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1233 |
2072 | 1234 if isinstance(self.index, lazyindex): |
1235 self.loadindexmap() | |
1236 | |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1237 # 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
|
1238 # does not actually belong to an older changeset. |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1239 # The minlink parameter defines the oldest revision |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1240 # we're allowed to strip away. |
2072 | 1241 while minlink > self.index[rev][-4]: |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1242 rev += 1 |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1243 if rev >= self.count(): |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1244 return |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1245 |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1246 # first truncate the files on disk |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1247 end = self.start(rev) |
2073 | 1248 if not self.inlinedata(): |
1249 df = self.opener(self.datafile, "a") | |
1250 df.truncate(end) | |
1251 end = rev * struct.calcsize(self.indexformat) | |
1252 else: | |
1253 end += rev * struct.calcsize(self.indexformat) | |
2072 | 1254 |
1255 indexf = self.opener(self.indexfile, "a") | |
1256 indexf.truncate(end) | |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1257 |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1258 # 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
|
1259 self.cache = None |
1711 | 1260 self.chunkcache = None |
2072 | 1261 for x in xrange(rev, self.count()): |
1262 del self.nodemap[self.node(x)] | |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1263 |
2072 | 1264 del self.index[rev:] |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1265 |
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1266 def checksize(self): |
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1267 expected = 0 |
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1268 if self.count(): |
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1269 expected = self.end(self.count() - 1) |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1270 |
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1271 try: |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1272 f = self.opener(self.datafile) |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1273 f.seek(0, 2) |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1274 actual = f.tell() |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1275 dd = actual - expected |
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1276 except IOError, inst: |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1277 if inst.errno != errno.ENOENT: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1278 raise |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1279 dd = 0 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1280 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1281 try: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1282 f = self.opener(self.indexfile) |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1283 f.seek(0, 2) |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1284 actual = f.tell() |
2072 | 1285 s = struct.calcsize(self.indexformat) |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1286 i = actual / s |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1287 di = actual - (i * s) |
2073 | 1288 if self.inlinedata(): |
1289 databytes = 0 | |
1290 for r in xrange(self.count()): | |
1291 databytes += self.length(r) | |
1292 dd = 0 | |
1293 di = actual - self.count() * s - databytes | |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1294 except IOError, inst: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1295 if inst.errno != errno.ENOENT: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1296 raise |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1297 di = 0 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1298 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1299 return (dd, di) |
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1300 |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1301 |