Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/revlog.py @ 653:94cdd02792b5
Fix corruption resulting from skipping parts of a revision group
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Fix corruption resulting from skipping parts of a revision group
We were occassionally losing track of what revision a delta applied to
when we skipped over deltas we already had and applying the delta
against the wrong base. This could result in coredumps from mpatch,
consistency errors, or failed verify.
manifest hash: fcf20a8abfd81f08fae2398136b2ed66216b2083
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.0 (GNU/Linux)
iD8DBQFCzu5SywK+sNU5EO8RAi10AJ9cqIfQzOzbcdH36t1LR/rY+UMtHwCeM79p
Dtv+Jh0McLZr6nf4iJyhDgI=
=5o6U
-----END PGP SIGNATURE-----
| author | Matt Mackall <mpm@selenic.com> |
|---|---|
| date | Fri, 08 Jul 2005 13:21:22 -0800 |
| parents | 08b65d66f3e7 |
| children | b3bba126b04a |
| rev | line source |
|---|---|
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1 # revlog.py - storage back-end for mercurial |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
2 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
3 # This provides efficient delta storage with O(1) retrieve and append |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
4 # and O(changes) merge between branches |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
5 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
6 # Copyright 2005 Matt Mackall <mpm@selenic.com> |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
8 # This software may be used and distributed according to the terms |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
9 # of the GNU General Public License, incorporated herein by reference. |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
10 |
| 208 | 11 import zlib, struct, sha, binascii, heapq |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
12 from mercurial import mdiff |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
13 |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
14 def hex(node): return binascii.hexlify(node) |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
15 def bin(node): return binascii.unhexlify(node) |
|
373
67081329d49a
Change the size of the short hash representation
mpm@selenic.com
parents:
370
diff
changeset
|
16 def short(node): return hex(node[:6]) |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
17 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
18 def compress(text): |
| 112 | 19 if not text: return text |
| 20 if len(text) < 44: | |
| 21 if text[0] == '\0': return text | |
| 22 return 'u' + text | |
| 23 bin = zlib.compress(text) | |
| 24 if len(bin) > len(text): | |
| 25 if text[0] == '\0': return text | |
| 26 return 'u' + text | |
| 27 return bin | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
28 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
29 def decompress(bin): |
| 112 | 30 if not bin: return bin |
| 31 t = bin[0] | |
| 32 if t == '\0': return bin | |
| 33 if t == 'x': return zlib.decompress(bin) | |
| 34 if t == 'u': return bin[1:] | |
| 35 raise "unknown compression type %s" % t | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
36 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
37 def hash(text, p1, p2): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
38 l = [p1, p2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
39 l.sort() |
| 531 | 40 s = sha.new(l[0]) |
| 41 s.update(l[1]) | |
| 42 s.update(text) | |
| 43 return s.digest() | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
44 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
45 nullid = "\0" * 20 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
46 indexformat = ">4l20s20s20s" |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
47 |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
48 class lazyparser: |
| 323 | 49 def __init__(self, data, revlog): |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
50 self.data = data |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
51 self.s = struct.calcsize(indexformat) |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
52 self.l = len(data)/self.s |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
53 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
|
54 self.map = {nullid: -1} |
| 323 | 55 self.all = 0 |
| 56 self.revlog = revlog | |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
57 |
| 323 | 58 def load(self, pos=None): |
| 59 if self.all: return | |
| 60 if pos is not None: | |
| 61 block = pos / 1000 | |
| 62 i = block * 1000 | |
| 63 end = min(self.l, i + 1000) | |
| 64 else: | |
| 65 self.all = 1 | |
| 66 i = 0 | |
| 67 end = self.l | |
| 68 self.revlog.index = self.index | |
| 69 self.revlog.nodemap = self.map | |
| 515 | 70 |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
71 while i < end: |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
72 d = self.data[i * self.s: (i + 1) * self.s] |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
73 e = struct.unpack(indexformat, d) |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
74 self.index[i] = e |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
75 self.map[e[6]] = i |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
76 i += 1 |
| 515 | 77 |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
78 class lazyindex: |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
79 def __init__(self, parser): |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
80 self.p = parser |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
81 def __len__(self): |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
82 return len(self.p.index) |
| 115 | 83 def load(self, pos): |
| 84 self.p.load(pos) | |
| 85 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
|
86 def __getitem__(self, pos): |
| 115 | 87 return self.p.index[pos] or self.load(pos) |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
88 def append(self, e): |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
89 self.p.index.append(e) |
| 515 | 90 |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
91 class lazymap: |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
92 def __init__(self, parser): |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
93 self.p = parser |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
94 def load(self, key): |
| 323 | 95 if self.p.all: return |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
96 n = self.p.data.find(key) |
|
86
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
97 if n < 0: 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
|
98 pos = n / self.p.s |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
99 self.p.load(pos) |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
100 def __contains__(self, key): |
| 323 | 101 self.p.load() |
| 102 return key in self.p.map | |
| 97 | 103 def __iter__(self): |
| 469 | 104 yield nullid |
| 97 | 105 for i in xrange(self.p.l): |
| 106 try: | |
| 107 yield self.p.index[i][6] | |
| 108 except: | |
| 109 self.p.load(i) | |
| 110 yield self.p.index[i][6] | |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
111 def __getitem__(self, key): |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
112 try: |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
113 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
|
114 except KeyError: |
|
86
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
115 try: |
|
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
116 self.load(key) |
|
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
117 return self.p.map[key] |
|
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
118 except KeyError: |
|
1b945e8ba67b
Friendlier exceptions for unknown node errors
mpm@selenic.com
parents:
84
diff
changeset
|
119 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
|
120 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
|
121 self.p.map[key] = val |
|
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
122 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
123 class revlog: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
124 def __init__(self, opener, indexfile, datafile): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
125 self.indexfile = indexfile |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
126 self.datafile = datafile |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
127 self.opener = opener |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
128 self.cache = None |
|
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
129 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
130 try: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
131 i = self.opener(self.indexfile).read() |
| 73 | 132 except IOError: |
|
76
d993ebd69d28
Add lazy{parser,index,map} to speed up processing of index files
mpm@selenic.com
parents:
73
diff
changeset
|
133 i = "" |
|
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
134 |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
135 if len(i) > 10000: |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
136 # big index, let's parse it on demand |
| 323 | 137 parser = lazyparser(i, self) |
|
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
138 self.index = lazyindex(parser) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
139 self.nodemap = lazymap(parser) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
140 else: |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
141 s = struct.calcsize(indexformat) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
142 l = len(i) / s |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
143 self.index = [None] * l |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
144 m = [None] * l |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
145 |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
146 n = 0 |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
147 for f in xrange(0, len(i), s): |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
148 # offset, size, base, linkrev, p1, p2, nodeid |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
149 e = struct.unpack(indexformat, i[f:f + s]) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
150 m[n] = (e[6], n) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
151 self.index[n] = e |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
152 n += 1 |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
153 |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
154 self.nodemap = dict(m) |
|
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
155 self.nodemap[nullid] = -1 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
156 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
157 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
|
158 def count(self): return len(self.index) |
| 26 | 159 def node(self, rev): return (rev < 0) and nullid or self.index[rev][6] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
160 def rev(self, node): return self.nodemap[node] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
161 def linkrev(self, node): return self.index[self.nodemap[node]][3] |
| 2 | 162 def parents(self, node): |
| 163 if node == nullid: return (nullid, nullid) | |
| 164 return self.index[self.nodemap[node]][4:6] | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
165 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
166 def start(self, rev): return self.index[rev][0] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
167 def length(self, rev): return self.index[rev][1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
168 def end(self, rev): return self.start(rev) + self.length(rev) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
169 def base(self, rev): return self.index[rev][2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
170 |
| 221 | 171 def heads(self): |
| 172 p = {} | |
| 173 h = [] | |
| 243 | 174 for r in range(self.count() - 1, -1, -1): |
| 221 | 175 n = self.node(r) |
| 176 if n not in p: | |
| 177 h.append(n) | |
| 178 for pn in self.parents(n): | |
| 179 p[pn] = 1 | |
| 180 return h | |
| 370 | 181 |
| 182 def children(self, node): | |
| 183 c = [] | |
| 184 p = self.rev(node) | |
| 185 for r in range(p + 1, self.count()): | |
| 186 n = self.node(r) | |
| 187 for pn in self.parents(n): | |
| 188 if pn == p: | |
| 189 c.append(p) | |
| 190 continue | |
| 191 elif pn == nullid: | |
| 192 continue | |
| 193 return c | |
| 515 | 194 |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
195 def lookup(self, id): |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
196 try: |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
197 rev = int(id) |
| 469 | 198 if str(rev) != id: raise ValueError |
| 199 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
|
200 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
|
201 return self.node(rev) |
| 469 | 202 except (ValueError, OverflowError): |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
203 c = [] |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
204 for n in self.nodemap: |
| 469 | 205 if hex(n).startswith(id): |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
206 c.append(n) |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
207 if len(c) > 1: raise KeyError("Ambiguous identifier") |
| 67 | 208 if len(c) < 1: raise KeyError("No match found") |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
209 return c[0] |
| 515 | 210 |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
211 return None |
|
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
212 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
213 def diff(self, a, b): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
214 return mdiff.textdiff(a, b) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
215 |
| 73 | 216 def patches(self, t, pl): |
| 217 return mdiff.patches(t, pl) | |
| 218 | |
|
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
219 def delta(self, node): |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
220 r = self.rev(node) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
221 b = self.base(r) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
222 if r == b: |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
223 return self.diff(self.revision(self.node(r - 1)), |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
224 self.revision(node)) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
225 else: |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
226 f = self.opener(self.datafile) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
227 f.seek(self.start(r)) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
228 data = f.read(self.length(r)) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
229 return decompress(data) |
|
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
230 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
231 def revision(self, node): |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
232 if node == nullid: return "" |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
233 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
|
234 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
235 text = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
236 rev = self.rev(node) |
| 117 | 237 start, length, base, link, p1, p2, node = self.index[rev] |
| 238 end = start + length | |
| 239 if base != rev: start = self.start(base) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
240 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
241 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
|
242 base = self.cache[1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
243 start = self.start(base + 1) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
244 text = self.cache[2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
245 last = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
246 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
247 f = self.opener(self.datafile) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
248 f.seek(start) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
249 data = f.read(end - start) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
250 |
| 651 | 251 if text is None: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
252 last = self.length(base) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
253 text = decompress(data[:last]) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
254 |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
255 bins = [] |
| 64 | 256 for r in xrange(base + 1, rev + 1): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
257 s = self.length(r) |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
258 bins.append(decompress(data[last:last + s])) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
259 last = last + s |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
260 |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
261 text = mdiff.patches(text, bins) |
|
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
262 |
| 26 | 263 if node != hash(text, p1, p2): |
| 98 | 264 raise IOError("integrity check failed on %s:%d" |
| 265 % (self.datafile, rev)) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
266 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
267 self.cache = (node, rev, text) |
| 515 | 268 return text |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
269 |
| 644 | 270 def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
271 if text is None: text = "" |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
272 if p1 is None: p1 = self.tip() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
273 if p2 is None: p2 = nullid |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
274 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
275 node = hash(text, p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
276 |
| 301 | 277 if node in self.nodemap: |
| 278 return node | |
| 279 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
280 n = self.count() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
281 t = n - 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
282 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
283 if n: |
| 64 | 284 base = self.base(t) |
| 285 start = self.start(base) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
286 end = self.end(t) |
| 644 | 287 if not d: |
| 288 prev = self.revision(self.tip()) | |
| 289 d = self.diff(prev, text) | |
| 98 | 290 data = compress(d) |
| 64 | 291 dist = end - start + len(data) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
292 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
293 # full versions are inserted when the needed deltas |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
294 # become comparable to the uncompressed text |
| 64 | 295 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
|
296 data = compress(text) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
297 base = n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
298 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
299 base = self.base(t) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
300 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
301 offset = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
302 if t >= 0: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
303 offset = self.end(t) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
304 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
305 e = (offset, len(data), base, link, p1, p2, node) |
| 515 | 306 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
307 self.index.append(e) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
308 self.nodemap[node] = n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
309 entry = struct.pack(indexformat, *e) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
310 |
| 26 | 311 transaction.add(self.datafile, e[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
312 self.opener(self.datafile, "a").write(data) |
| 41 | 313 transaction.add(self.indexfile, n * len(entry)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
314 self.opener(self.indexfile, "a").write(entry) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
315 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
316 self.cache = (node, n, text) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
317 return node |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
318 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
319 def ancestor(self, a, b): |
| 147 | 320 # calculate the distance of every node from root |
| 321 dist = {nullid: 0} | |
| 322 for i in xrange(self.count()): | |
| 323 n = self.node(i) | |
| 324 p1, p2 = self.parents(n) | |
| 325 dist[n] = max(dist[p1], dist[p2]) + 1 | |
| 515 | 326 |
| 147 | 327 # traverse ancestors in order of decreasing distance from root |
| 328 def ancestors(node): | |
| 329 # we store negative distances because heap returns smallest member | |
| 330 h = [(-dist[node], node)] | |
| 331 seen = {} | |
| 332 earliest = self.count() | |
| 333 while h: | |
| 334 d, n = heapq.heappop(h) | |
| 335 if n not in seen: | |
| 336 seen[n] = 1 | |
| 381 | 337 r = self.rev(n) |
| 338 yield (-d, r, n) | |
| 147 | 339 for p in self.parents(n): |
| 340 heapq.heappush(h, (-dist[p], p)) | |
|
45
f2b2d5daec30
Fix recursion depth trouble with ancestor algorithm
mpm@selenic.com
parents:
41
diff
changeset
|
341 |
| 147 | 342 x = ancestors(a) |
| 343 y = ancestors(b) | |
| 344 lx = x.next() | |
| 345 ly = y.next() | |
|
45
f2b2d5daec30
Fix recursion depth trouble with ancestor algorithm
mpm@selenic.com
parents:
41
diff
changeset
|
346 |
| 147 | 347 # increment each ancestor list until it is closer to root than |
| 348 # the other, or they match | |
| 349 while 1: | |
| 350 if lx == ly: | |
| 381 | 351 return lx[2] |
| 147 | 352 elif lx < ly: |
| 353 ly = y.next() | |
| 354 elif lx > ly: | |
| 355 lx = x.next() | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
356 |
| 46 | 357 def group(self, linkmap): |
| 358 # given a list of changeset revs, return a set of deltas and | |
| 94 | 359 # metadata corresponding to nodes. the first delta is |
| 46 | 360 # parent(nodes[0]) -> nodes[0] the receiver is guaranteed to |
| 361 # have this parent as it has all history before these | |
| 362 # changesets. parent is parent[0] | |
| 363 | |
| 364 revs = [] | |
| 365 needed = {} | |
| 366 | |
| 367 # find file nodes/revs that match changeset revs | |
| 368 for i in xrange(0, self.count()): | |
| 369 if self.index[i][3] in linkmap: | |
| 370 revs.append(i) | |
| 371 needed[i] = 1 | |
| 372 | |
| 373 # if we don't have any revisions touched by these changesets, bail | |
| 192 | 374 if not revs: |
| 375 yield struct.pack(">l", 0) | |
| 376 return | |
| 46 | 377 |
| 378 # add the parent of the first rev | |
| 379 p = self.parents(self.node(revs[0]))[0] | |
| 380 revs.insert(0, self.rev(p)) | |
| 381 | |
| 382 # for each delta that isn't contiguous in the log, we need to | |
| 383 # reconstruct the base, reconstruct the result, and then | |
| 384 # calculate the delta. We also need to do this where we've | |
| 385 # stored a full version and not a delta | |
| 386 for i in xrange(0, len(revs) - 1): | |
| 387 a, b = revs[i], revs[i + 1] | |
| 388 if a + 1 != b or self.base(b) == b: | |
| 389 for j in xrange(self.base(a), a + 1): | |
| 390 needed[j] = 1 | |
| 391 for j in xrange(self.base(b), b + 1): | |
| 392 needed[j] = 1 | |
| 393 | |
| 394 # calculate spans to retrieve from datafile | |
| 395 needed = needed.keys() | |
| 396 needed.sort() | |
| 397 spans = [] | |
| 192 | 398 oo = -1 |
| 399 ol = 0 | |
| 46 | 400 for n in needed: |
| 401 if n < 0: continue | |
| 402 o = self.start(n) | |
| 403 l = self.length(n) | |
| 192 | 404 if oo + ol == o: # can we merge with the previous? |
| 405 nl = spans[-1][2] | |
| 406 nl.append((n, l)) | |
| 407 ol += l | |
| 408 spans[-1] = (oo, ol, nl) | |
| 46 | 409 else: |
| 192 | 410 oo = o |
| 411 ol = l | |
| 412 spans.append((oo, ol, [(n, l)])) | |
| 46 | 413 |
| 414 # read spans in, divide up chunks | |
| 415 chunks = {} | |
| 192 | 416 for span in spans: |
| 46 | 417 # we reopen the file for each span to make http happy for now |
| 418 f = self.opener(self.datafile) | |
| 419 f.seek(span[0]) | |
| 420 data = f.read(span[1]) | |
| 421 | |
| 422 # divide up the span | |
| 423 pos = 0 | |
| 424 for r, l in span[2]: | |
| 192 | 425 chunks[r] = decompress(data[pos: pos + l]) |
| 46 | 426 pos += l |
| 427 | |
| 428 # helper to reconstruct intermediate versions | |
| 429 def construct(text, base, rev): | |
| 192 | 430 bins = [chunks[r] for r in xrange(base + 1, rev + 1)] |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
431 return mdiff.patches(text, bins) |
| 46 | 432 |
| 433 # build deltas | |
| 434 deltas = [] | |
|
71
47c9a869adee
Add mdiff.patches to speed up applying thousands of patches to the manifest
mpm@selenic.com
parents:
67
diff
changeset
|
435 for d in xrange(0, len(revs) - 1): |
| 46 | 436 a, b = revs[d], revs[d + 1] |
| 437 n = self.node(b) | |
| 192 | 438 |
| 439 # do we need to construct a new delta? | |
| 46 | 440 if a + 1 != b or self.base(b) == b: |
| 441 if a >= 0: | |
| 442 base = self.base(a) | |
| 192 | 443 ta = chunks[self.base(a)] |
| 46 | 444 ta = construct(ta, base, a) |
| 445 else: | |
| 446 ta = "" | |
| 515 | 447 |
| 46 | 448 base = self.base(b) |
| 449 if a > base: | |
| 450 base = a | |
| 451 tb = ta | |
| 452 else: | |
| 192 | 453 tb = chunks[self.base(b)] |
| 46 | 454 tb = construct(tb, base, b) |
| 455 d = self.diff(ta, tb) | |
| 456 else: | |
| 192 | 457 d = chunks[b] |
| 46 | 458 |
| 459 p = self.parents(n) | |
| 460 meta = n + p[0] + p[1] + linkmap[self.linkrev(n)] | |
| 461 l = struct.pack(">l", len(meta) + len(d) + 4) | |
| 192 | 462 yield l |
| 463 yield meta | |
| 464 yield d | |
| 46 | 465 |
| 192 | 466 yield struct.pack(">l", 0) |
| 467 | |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
468 def addgroup(self, revs, linkmapper, transaction, unique = 0): |
| 46 | 469 # given a set of deltas, add them to the revision log. the |
| 470 # first delta is against its parent, which should be in our | |
| 471 # log, the rest are against the previous delta. | |
| 472 | |
| 473 # track the base of the current delta log | |
| 474 r = self.count() | |
| 475 t = r - 1 | |
| 192 | 476 node = nullid |
| 515 | 477 |
|
653
94cdd02792b5
Fix corruption resulting from skipping parts of a revision group
Matt Mackall <mpm@selenic.com>
parents:
651
diff
changeset
|
478 base = -1 |
|
94cdd02792b5
Fix corruption resulting from skipping parts of a revision group
Matt Mackall <mpm@selenic.com>
parents:
651
diff
changeset
|
479 start = end = measure = 0 |
| 46 | 480 if r: |
| 481 start = self.start(self.base(t)) | |
| 482 end = self.end(t) | |
| 483 measure = self.length(self.base(t)) | |
| 484 base = self.base(t) | |
| 485 prev = self.tip() | |
| 486 | |
| 487 transaction.add(self.datafile, end) | |
| 488 transaction.add(self.indexfile, r * struct.calcsize(indexformat)) | |
| 489 dfh = self.opener(self.datafile, "a") | |
| 490 ifh = self.opener(self.indexfile, "a") | |
| 491 | |
| 492 # loop through our set of deltas | |
| 192 | 493 chain = None |
|
653
94cdd02792b5
Fix corruption resulting from skipping parts of a revision group
Matt Mackall <mpm@selenic.com>
parents:
651
diff
changeset
|
494 prev = self.tip() |
| 192 | 495 for chunk in revs: |
| 496 node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80]) | |
| 94 | 497 link = linkmapper(cs) |
| 77 | 498 if node in self.nodemap: |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
499 # this can happen if two branches make the same change |
|
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
500 if unique: |
|
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
501 raise "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
|
502 chain = node |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
221
diff
changeset
|
503 continue |
| 192 | 504 delta = chunk[80:] |
| 505 | |
| 506 if not chain: | |
| 507 # retrieve the parent revision of the delta chain | |
| 508 chain = p1 | |
| 509 if not chain in self.nodemap: | |
| 510 raise "unknown base %s" % short(chain[:4]) | |
| 46 | 511 |
| 512 # full versions are inserted when the needed deltas become | |
| 513 # comparable to the uncompressed text or when the previous | |
| 514 # version is not the one we have a delta against. We use | |
| 515 # the size of the previous full rev as a proxy for the | |
| 516 # current size. | |
| 517 | |
| 518 if chain == prev: | |
| 519 cdelta = compress(delta) | |
| 520 | |
| 521 if chain != prev or (end - start + len(cdelta)) > measure * 2: | |
| 522 # flush our writes here so we can read it in revision | |
| 523 dfh.flush() | |
| 524 ifh.flush() | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
525 text = self.revision(chain) |
| 73 | 526 text = self.patches(text, [delta]) |
| 46 | 527 chk = self.addrevision(text, transaction, link, p1, p2) |
| 528 if chk != node: | |
| 529 raise "consistency error adding group" | |
| 530 measure = len(text) | |
| 531 else: | |
| 532 e = (end, len(cdelta), self.base(t), link, p1, p2, node) | |
| 533 self.index.append(e) | |
| 534 self.nodemap[node] = r | |
| 535 dfh.write(cdelta) | |
| 536 ifh.write(struct.pack(indexformat, *e)) | |
| 537 | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
538 t, r, chain, prev = r, r + 1, node, node |
| 46 | 539 start = self.start(self.base(t)) |
| 540 end = self.end(t) | |
| 541 | |
| 542 dfh.close() | |
| 543 ifh.close() | |
| 544 return node |