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