annotate mercurial/revlog.py @ 2289:854954fd410a

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