annotate mercurial/revlog.py @ 4979:06abdaf78788

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