Mercurial > hg
annotate mercurial/revlog.py @ 30933:69a3c6c8bf95
dispatch: move detection of profiling earlier during startup
author | Bryan O'Sullivan <bryano@fb.com> |
---|---|
date | Mon, 13 Feb 2017 20:44:20 -0800 |
parents | 08b34c3a6f74 |
children | ef6888172437 |
rev | line source |
---|---|
8226
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
1 # revlog.py - storage back-end for mercurial |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
2 # |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
4 # |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 |
8227
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
8 """Storage back-end for Mercurial. |
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
9 |
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
10 This provides efficient delta storage with O(1) retrieve and append |
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
11 and O(changes) merge between branches. |
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
12 """ |
0a9542703300
turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents:
8226
diff
changeset
|
13 |
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
14 from __future__ import absolute_import |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
15 |
25113
0ca8410ea345
util: drop alias for collections.deque
Martin von Zweigbergk <martinvonz@google.com>
parents:
24454
diff
changeset
|
16 import collections |
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
17 import errno |
29339
a9e010cd66e1
revlog: use hashlib.sha1 directly instead of through util
Augie Fackler <raf@durin42.com>
parents:
27650
diff
changeset
|
18 import hashlib |
27430
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
19 import os |
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
20 import struct |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
21 import zlib |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
22 |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
23 # import stuff from node for others to import from revlog |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
24 from .node import ( |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
25 bin, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
26 hex, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
27 nullid, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
28 nullrev, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
29 ) |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
30 from .i18n import _ |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
31 from . import ( |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
32 ancestor, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
33 error, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
34 mdiff, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
35 parsers, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
36 templatefilters, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
37 util, |
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
38 ) |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
39 |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
40 _pack = struct.pack |
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
41 _unpack = struct.unpack |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
42 # Aliased for performance. |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
43 _zlibdecompress = zlib.decompress |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
44 |
11746
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
45 # revlog header flags |
2072 | 46 REVLOGV0 = 0 |
47 REVLOGNG = 1 | |
2073 | 48 REVLOGNGINLINEDATA = (1 << 16) |
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
49 REVLOGGENERALDELTA = (1 << 17) |
2222
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
50 REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA |
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
51 REVLOG_DEFAULT_FORMAT = REVLOGNG |
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
52 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS |
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
53 REVLOGNG_FLAGS = REVLOGNGINLINEDATA | REVLOGGENERALDELTA |
11746
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
54 |
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
55 # revlog index flags |
23855
4f23081c901e
revlog: define censored flag for revlogng index
Mike Edgar <adgar@google.com>
parents:
23338
diff
changeset
|
56 REVIDX_ISCENSORED = (1 << 15) # revision has censor metadata, must be verified |
30829
08b34c3a6f74
revlog: give EXTSTORED flag value to narrowhg
Martin von Zweigbergk <martinvonz@google.com>
parents:
30818
diff
changeset
|
57 REVIDX_ELLIPSIS = (1 << 14) # revision hash does not match data (narrowhg) |
08b34c3a6f74
revlog: give EXTSTORED flag value to narrowhg
Martin von Zweigbergk <martinvonz@google.com>
parents:
30818
diff
changeset
|
58 REVIDX_EXTSTORED = (1 << 13) # revision data is stored externally |
23855
4f23081c901e
revlog: define censored flag for revlogng index
Mike Edgar <adgar@google.com>
parents:
23338
diff
changeset
|
59 REVIDX_DEFAULT_FLAGS = 0 |
30745 | 60 # stable order in which flags need to be processed and their processors applied |
61 REVIDX_FLAGS_ORDER = [ | |
62 REVIDX_ISCENSORED, | |
30829
08b34c3a6f74
revlog: give EXTSTORED flag value to narrowhg
Martin von Zweigbergk <martinvonz@google.com>
parents:
30818
diff
changeset
|
63 REVIDX_ELLIPSIS, |
30746
9cb0bb0f29f0
revlog: REVIDX_EXTSTORED flag
Remi Chaintron <remi@fb.com>
parents:
30745
diff
changeset
|
64 REVIDX_EXTSTORED, |
30745 | 65 ] |
66 REVIDX_KNOWN_FLAGS = util.bitsfrom(REVIDX_FLAGS_ORDER) | |
2073 | 67 |
10916
9c84395a338e
add documentation for revlog._prereadsize
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10914
diff
changeset
|
68 # max size of revlog with inline data |
9c84395a338e
add documentation for revlog._prereadsize
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10914
diff
changeset
|
69 _maxinline = 131072 |
13253 | 70 _chunksize = 1048576 |
10913
f2ecc5733c89
revlog: factor out _maxinline global.
Greg Ward <greg-hg@gerg.ca>
parents:
10404
diff
changeset
|
71 |
7633 | 72 RevlogError = error.RevlogError |
73 LookupError = error.LookupError | |
22934
8a096d4d0862
revlog: support importing censored file revision tombstones
Mike Edgar <adgar@google.com>
parents:
22785
diff
changeset
|
74 CensoredNodeError = error.CensoredNodeError |
30745 | 75 ProgrammingError = error.ProgrammingError |
76 | |
77 # Store flag processors (cf. 'addflagprocessor()' to register) | |
78 _flagprocessors = { | |
79 REVIDX_ISCENSORED: None, | |
80 } | |
81 | |
82 def addflagprocessor(flag, processor): | |
83 """Register a flag processor on a revision data flag. | |
84 | |
85 Invariant: | |
86 - Flags need to be defined in REVIDX_KNOWN_FLAGS and REVIDX_FLAGS_ORDER. | |
87 - Only one flag processor can be registered on a specific flag. | |
88 - flagprocessors must be 3-tuples of functions (read, write, raw) with the | |
89 following signatures: | |
90 - (read) f(self, text) -> newtext, bool | |
91 - (write) f(self, text) -> newtext, bool | |
92 - (raw) f(self, text) -> bool | |
93 The boolean returned by these transforms is used to determine whether | |
94 'newtext' can be used for hash integrity checking. | |
95 | |
96 Note: The 'raw' transform is used for changegroup generation and in some | |
97 debug commands. In this case the transform only indicates whether the | |
98 contents can be used for hash integrity checks. | |
99 """ | |
100 if not flag & REVIDX_KNOWN_FLAGS: | |
101 msg = _("cannot register processor on unknown flag '%#x'.") % (flag) | |
102 raise ProgrammingError(msg) | |
103 if flag not in REVIDX_FLAGS_ORDER: | |
104 msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % (flag) | |
105 raise ProgrammingError(msg) | |
106 if flag in _flagprocessors: | |
107 msg = _("cannot register multiple processors on flag '%#x'.") % (flag) | |
108 raise error.Abort(msg) | |
109 _flagprocessors[flag] = processor | |
6703
bacfee67c1a9
LookupError should have same __str__ as RevlogError
Alexander Solovyov <piranha@piranha.org.ua>
parents:
6700
diff
changeset
|
110 |
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
111 def getoffset(q): |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
112 return int(q >> 16) |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
113 |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
114 def gettype(q): |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
115 return int(q & 0xFFFF) |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
116 |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
117 def offset_type(offset, type): |
30543
03fae9048fa1
revlog: ensure that flags do not overflow 2 bytes
Cotizo Sima <cotizo@fb.com>
parents:
30391
diff
changeset
|
118 if (type & ~REVIDX_KNOWN_FLAGS) != 0: |
03fae9048fa1
revlog: ensure that flags do not overflow 2 bytes
Cotizo Sima <cotizo@fb.com>
parents:
30391
diff
changeset
|
119 raise ValueError('unknown revlog index flags') |
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
120 return long(long(offset) << 16 | type) |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
121 |
29339
a9e010cd66e1
revlog: use hashlib.sha1 directly instead of through util
Augie Fackler <raf@durin42.com>
parents:
27650
diff
changeset
|
122 _nullhash = hashlib.sha1(nullid) |
7883
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
123 |
1091
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
124 def hash(text, p1, p2): |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
125 """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
|
126 |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
127 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
|
128 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
|
129 content in the revision graph. |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
130 """ |
7883
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
131 # As of now, if one of the parent node is null, p2 is null |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
132 if p2 == nullid: |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
133 # deep copy of a hash is faster than creating one |
22784
0f4e655136ef
revlog: mark nullhash as module-private
Augie Fackler <raf@durin42.com>
parents:
22389
diff
changeset
|
134 s = _nullhash.copy() |
7883
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
135 s.update(p1) |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
136 else: |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
137 # none of the parent nodes are nullid |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
138 l = [p1, p2] |
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
139 l.sort() |
29339
a9e010cd66e1
revlog: use hashlib.sha1 directly instead of through util
Augie Fackler <raf@durin42.com>
parents:
27650
diff
changeset
|
140 s = hashlib.sha1(l[0]) |
7883
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
141 s.update(l[1]) |
1091
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
142 s.update(text) |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
143 return s.digest() |
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
144 |
18585
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
145 # index v0: |
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
146 # 4 bytes: offset |
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
147 # 4 bytes: compressed length |
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
148 # 4 bytes: base rev |
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
149 # 4 bytes: link rev |
25891
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
150 # 20 bytes: parent 1 nodeid |
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
151 # 20 bytes: parent 2 nodeid |
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
152 # 20 bytes: nodeid |
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
153 indexformatv0 = ">4l20s20s20s" |
4918
e017d3a82e1d
revlog: raise offset/type helpers to global scope
Matt Mackall <mpm@selenic.com>
parents:
4746
diff
changeset
|
154 |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
155 class revlogoldio(object): |
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
156 def __init__(self): |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
157 self.size = struct.calcsize(indexformatv0) |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
158 |
13264
8439526fb407
revlog/parseindex: no need to pass the file around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13259
diff
changeset
|
159 def parseindex(self, data, inline): |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
160 s = self.size |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
161 index = [] |
27637
b502138f5faa
cleanup: remove superfluous space after space after equals (python)
timeless <timeless@mozdev.org>
parents:
27475
diff
changeset
|
162 nodemap = {nullid: nullrev} |
4973
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
163 n = off = 0 |
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
164 l = len(data) |
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
165 while off + s <= l: |
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
166 cur = data[off:off + s] |
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
167 off += s |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
168 e = _unpack(indexformatv0, cur) |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
169 # transform to revlogv1 format |
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
170 e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3], |
5544
686899a7de5b
revlog: make revlogv0 loading more robust against corruption
Matt Mackall <mpm@selenic.com>
parents:
5453
diff
changeset
|
171 nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6]) |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
172 index.append(e2) |
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
173 nodemap[e[6]] = n |
4973
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
174 n += 1 |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
175 |
13265
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
176 # add the magic null revision at -1 |
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
177 index.append((0, 0, 0, -1, -1, -1, -1, nullid)) |
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
178 |
4983
4dbcfc6e359e
revlog: pull chunkcache back into revlog
Matt Mackall <mpm@selenic.com>
parents:
4982
diff
changeset
|
179 return index, nodemap, None |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
180 |
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
181 def packentry(self, entry, node, version, rev): |
10395
ea52a2d4f42c
revlog: don't silently discard revlog flags on revlogv0
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10329
diff
changeset
|
182 if gettype(entry[0]): |
ea52a2d4f42c
revlog: don't silently discard revlog flags on revlogv0
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10329
diff
changeset
|
183 raise RevlogError(_("index entry flags need RevlogNG")) |
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
184 e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4], |
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
185 node(entry[5]), node(entry[6]), entry[7]) |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
186 return _pack(indexformatv0, *e2) |
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
187 |
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
188 # index ng: |
11323
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
189 # 6 bytes: offset |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
190 # 2 bytes: flags |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
191 # 4 bytes: compressed length |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
192 # 4 bytes: uncompressed length |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
193 # 4 bytes: base rev |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
194 # 4 bytes: link rev |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
195 # 4 bytes: parent 1 rev |
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
196 # 4 bytes: parent 2 rev |
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
197 # 32 bytes: nodeid |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
198 indexformatng = ">Qiiiiii20s12x" |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
199 versionformat = ">I" |
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
200 |
25410
eee88912db0a
revlog: raise an exception earlier if an entry is too large (issue4675)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
25361
diff
changeset
|
201 # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte |
eee88912db0a
revlog: raise an exception earlier if an entry is too large (issue4675)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
25361
diff
changeset
|
202 # signed integer) |
eee88912db0a
revlog: raise an exception earlier if an entry is too large (issue4675)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
25361
diff
changeset
|
203 _maxentrysize = 0x7fffffff |
eee88912db0a
revlog: raise an exception earlier if an entry is too large (issue4675)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
25361
diff
changeset
|
204 |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
205 class revlogio(object): |
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
206 def __init__(self): |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
207 self.size = struct.calcsize(indexformatng) |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
208 |
13264
8439526fb407
revlog/parseindex: no need to pass the file around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13259
diff
changeset
|
209 def parseindex(self, data, inline): |
7109
528b7fc1216c
use the new parseindex implementation C in parsers
Bernhard Leiner <bleiner@gmail.com>
parents:
7089
diff
changeset
|
210 # call the C implementation to parse the index data |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
13253
diff
changeset
|
211 index, cache = parsers.parse_index2(data, inline) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
212 return index, getattr(index, 'nodemap', None), cache |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
213 |
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
214 def packentry(self, entry, node, version, rev): |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
215 p = _pack(indexformatng, *entry) |
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
216 if rev == 0: |
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
217 p = _pack(versionformat, version) + p[4:] |
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
218 return p |
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
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 revlog(object): |
1083 | 221 """ |
222 the underlying revision storage object | |
223 | |
224 A revlog consists of two parts, an index and the revision data. | |
225 | |
226 The index is a file with a fixed record size containing | |
6912 | 227 information on each revision, including its nodeid (hash), the |
1083 | 228 nodeids of its parents, the position and offset of its data within |
229 the data file, and the revision it's based on. Finally, each entry | |
230 contains a linkrev entry that can serve as a pointer to external | |
231 data. | |
232 | |
233 The revision data itself is a linear collection of data chunks. | |
234 Each chunk represents a revision and is usually represented as a | |
235 delta against the previous chunk. To bound lookup time, runs of | |
236 deltas are limited to about 2 times the length of the original | |
237 version data. This makes retrieval of a version proportional to | |
238 its size, or O(1) relative to the number of revisions. | |
239 | |
240 Both pieces of the revlog are written to in an append-only | |
241 fashion, which means we never need to rewrite a file to insert or | |
242 remove data, and can use some simple techniques to avoid the need | |
243 for locking while reading. | |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
244 |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
245 If checkambig, indexfile is opened with checkambig=True at |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
246 writing, to avoid file stat ambiguity. |
1083 | 247 """ |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
248 def __init__(self, opener, indexfile, checkambig=False): |
1083 | 249 """ |
250 create a revlog object | |
251 | |
252 opener is a function that abstracts the file opening operation | |
253 and can be used to implement COW semantics or the like. | |
254 """ | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
255 self.indexfile = indexfile |
4257
1b5c38e9d7aa
revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents:
4224
diff
changeset
|
256 self.datafile = indexfile[:-2] + ".d" |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
257 self.opener = opener |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
258 # When True, indexfile is opened with checkambig=True at writing, to |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
259 # avoid file stat ambiguity. |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
260 self._checkambig = checkambig |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
261 # 3-tuple of (node, rev, text) for a raw revision. |
4984 | 262 self._cache = None |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
263 # Maps rev to chain base rev. |
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
264 self._chainbasecache = util.lrucachedict(100) |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
265 # 2-tuple of (offset, data) of raw data from the revlog at an offset. |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
266 self._chunkcache = (0, '') |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
267 # How much data to read and cache into the raw revlog data cache. |
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
268 self._chunkcachesize = 65536 |
23255
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
269 self._maxchainlen = None |
26118
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
270 self._aggressivemergedeltas = False |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
271 self.index = [] |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
272 # Mapping of partial identifiers to full nodes. |
13258
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
273 self._pcache = {} |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
274 # Mapping of revision integer to full node. |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
275 self._nodecache = {nullid: nullrev} |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
276 self._nodepos = None |
30818
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
277 self._compengine = 'zlib' |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
278 |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
279 v = REVLOG_DEFAULT_VERSION |
14960
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
280 opts = getattr(opener, 'options', None) |
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
281 if opts is not None: |
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
282 if 'revlogv1' in opts: |
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
283 if 'generaldelta' in opts: |
14333
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14325
diff
changeset
|
284 v |= REVLOGGENERALDELTA |
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14325
diff
changeset
|
285 else: |
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14325
diff
changeset
|
286 v = 0 |
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
287 if 'chunkcachesize' in opts: |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
288 self._chunkcachesize = opts['chunkcachesize'] |
23255
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
289 if 'maxchainlen' in opts: |
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
290 self._maxchainlen = opts['maxchainlen'] |
26118
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
291 if 'aggressivemergedeltas' in opts: |
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
292 self._aggressivemergedeltas = opts['aggressivemergedeltas'] |
26907
dfab6edb98e3
format: introduce 'format.usegeneraldelta`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26705
diff
changeset
|
293 self._lazydeltabase = bool(opts.get('lazydeltabase', False)) |
30818
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
294 if 'compengine' in opts: |
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
295 self._compengine = opts['compengine'] |
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
296 |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
297 if self._chunkcachesize <= 0: |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
298 raise RevlogError(_('revlog chunk cache size %r is not greater ' |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
299 'than 0') % self._chunkcachesize) |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
300 elif self._chunkcachesize & (self._chunkcachesize - 1): |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
301 raise RevlogError(_('revlog chunk cache size %r is not a power ' |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
302 'of 2') % self._chunkcachesize) |
11928
b69899dbad40
revlog: parentdelta flags for revlog index
Pradeepkumar Gayam <in3xes@gmail.com>
parents:
11759
diff
changeset
|
303 |
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
304 indexdata = '' |
14334
85c82ebc96a3
changelog: don't use generaldelta
Sune Foldager <cryo@cyanite.org>
parents:
14333
diff
changeset
|
305 self._initempty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
306 try: |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
307 f = self.opener(self.indexfile) |
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
308 indexdata = f.read() |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
309 f.close() |
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
310 if len(indexdata) > 0: |
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
311 v = struct.unpack(versionformat, indexdata[:4])[0] |
14334
85c82ebc96a3
changelog: don't use generaldelta
Sune Foldager <cryo@cyanite.org>
parents:
14333
diff
changeset
|
312 self._initempty = False |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25459
diff
changeset
|
313 except IOError as inst: |
1322
b3d44e9b3092
Make revlog constructor more discerning in its treatment of errors.
Bryan O'Sullivan <bos@serpentine.com>
parents:
1232
diff
changeset
|
314 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
|
315 raise |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
316 |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
317 self.version = v |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
318 self._inline = v & REVLOGNGINLINEDATA |
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
319 self._generaldelta = v & REVLOGGENERALDELTA |
2073 | 320 flags = v & ~0xFFFF |
321 fmt = v & 0xFFFF | |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
322 if fmt == REVLOGV0 and flags: |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
323 raise RevlogError(_("index %s unknown flags %#04x for format v0") |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
324 % (self.indexfile, flags >> 16)) |
11746
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
325 elif fmt == REVLOGNG and flags & ~REVLOGNG_FLAGS: |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
326 raise RevlogError(_("index %s unknown flags %#04x for revlogng") |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
327 % (self.indexfile, flags >> 16)) |
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
328 elif fmt > REVLOGNG: |
3743
3a099154b110
Make revlog error slightly less scary
Matt Mackall <mpm@selenic.com>
parents:
3683
diff
changeset
|
329 raise RevlogError(_("index %s unknown format %d") |
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
330 % (self.indexfile, fmt)) |
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
331 |
30210
5e4f16874a9f
revlog: make 'storedeltachains' a "public" attribute
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30154
diff
changeset
|
332 self.storedeltachains = True |
30154
5e72129d75ed
revlog: add instance variable controlling delta chain use
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30012
diff
changeset
|
333 |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
334 self._io = revlogio() |
4971
3e6dae278c99
revlog: regroup parsing code
Matt Mackall <mpm@selenic.com>
parents:
4920
diff
changeset
|
335 if self.version == REVLOGV0: |
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
336 self._io = revlogoldio() |
13265
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
337 try: |
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
338 d = self._io.parseindex(indexdata, self._inline) |
13265
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
339 except (ValueError, IndexError): |
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
340 raise RevlogError(_("index %s is corrupted") % (self.indexfile)) |
13268
fff12b3d953a
revlog: explicit test and explicit variable names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13267
diff
changeset
|
341 self.index, nodemap, self._chunkcache = d |
fff12b3d953a
revlog: explicit test and explicit variable names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13267
diff
changeset
|
342 if nodemap is not None: |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
343 self.nodemap = self._nodecache = nodemap |
13265
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
344 if not self._chunkcache: |
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
345 self._chunkclear() |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
346 # revnum -> (chain-length, sum-delta-length) |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
347 self._chaininfocache = {} |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
348 # revlog header -> revlog compressor |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
349 self._decompressors = {} |
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
350 |
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
351 @util.propertycache |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
352 def _compressor(self): |
30818
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
353 return util.compengines[self._compengine].revlogcompressor() |
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
354 |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
355 def tip(self): |
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
356 return self.node(len(self.index) - 2) |
24030
828dc8db5515
revlog: add __contains__ for fast membership test
Yuya Nishihara <yuya@tcha.org>
parents:
23857
diff
changeset
|
357 def __contains__(self, rev): |
828dc8db5515
revlog: add __contains__ for fast membership test
Yuya Nishihara <yuya@tcha.org>
parents:
23857
diff
changeset
|
358 return 0 <= rev < len(self) |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
359 def __len__(self): |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
360 return len(self.index) - 1 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
361 def __iter__(self): |
17951
6f79c32c0bdf
commit: increase perf by avoiding unnecessary filteredrevs check
Durham Goode <durham@fb.com>
parents:
17674
diff
changeset
|
362 return iter(xrange(len(self))) |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
363 def revs(self, start=0, stop=None): |
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
364 """iterate over all rev in this revlog (from start to stop)""" |
17975
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
365 step = 1 |
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
366 if stop is not None: |
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
367 if start > stop: |
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
368 step = -1 |
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
369 stop += step |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
370 else: |
17975
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
371 stop = len(self) |
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
372 return xrange(start, stop, step) |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
373 |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
374 @util.propertycache |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
375 def nodemap(self): |
14064
e4bfb9c337f3
remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents:
13831
diff
changeset
|
376 self.rev(self.node(0)) |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
377 return self._nodecache |
13259
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
378 |
16374
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
379 def hasnode(self, node): |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
380 try: |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
381 self.rev(node) |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
382 return True |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
383 except KeyError: |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
384 return False |
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
385 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
386 def clearcaches(self): |
27465
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
387 self._cache = None |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
388 self._chainbasecache.clear() |
27465
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
389 self._chunkcache = (0, '') |
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
390 self._pcache = {} |
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
391 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
392 try: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
393 self._nodecache.clearcaches() |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
394 except AttributeError: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
395 self._nodecache = {nullid: nullrev} |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
396 self._nodepos = None |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
397 |
13259
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
398 def rev(self, node): |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
399 try: |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
400 return self._nodecache[node] |
22282
4092d12ba18a
repoview: fix 0L with pack/unpack for 2.4
Matt Mackall <mpm@selenic.com>
parents:
21752
diff
changeset
|
401 except TypeError: |
4092d12ba18a
repoview: fix 0L with pack/unpack for 2.4
Matt Mackall <mpm@selenic.com>
parents:
21752
diff
changeset
|
402 raise |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
403 except RevlogError: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
404 # parsers.c radix tree lookup failed |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
405 raise LookupError(node, self.indexfile, _('no node')) |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
406 except KeyError: |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
407 # pure python cache lookup failed |
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
408 n = self._nodecache |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
409 i = self.index |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
410 p = self._nodepos |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
411 if p is None: |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
412 p = len(i) - 2 |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
413 for r in xrange(p, -1, -1): |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
414 v = i[r][7] |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
415 n[v] = r |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
416 if v == node: |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
417 self._nodepos = r - 1 |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
418 return r |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
419 raise LookupError(node, self.indexfile, _('no node')) |
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
420 |
30287
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
421 # Accessors for index entries. |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
422 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
423 # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
424 # are flags. |
2072 | 425 def start(self, rev): |
5006
c2febf5420e9
revlog: minor chunk speed-up
Matt Mackall <mpm@selenic.com>
parents:
5005
diff
changeset
|
426 return int(self.index[rev][0] >> 16) |
30287
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
427 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
428 def flags(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
429 return self.index[rev][0] & 0xFFFF |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
430 |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
431 def length(self, rev): |
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
432 return self.index[rev][1] |
30287
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
433 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
434 def rawsize(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
435 """return the length of the uncompressed text for a given revision""" |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
436 l = self.index[rev][2] |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
437 if l >= 0: |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
438 return l |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
439 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
440 t = self.revision(self.node(rev)) |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
441 return len(t) |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
442 size = rawsize |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
443 |
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
444 def chainbase(self, rev): |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
445 base = self._chainbasecache.get(rev) |
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
446 if base is not None: |
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
447 return base |
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
448 |
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
449 index = self.index |
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
450 base = index[rev][3] |
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
451 while base != rev: |
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
452 rev = base |
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
453 base = index[rev][3] |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
454 |
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
455 self._chainbasecache[rev] = base |
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
456 return base |
30287
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
457 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
458 def linkrev(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
459 return self.index[rev][4] |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
460 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
461 def parentrevs(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
462 return self.index[rev][5:7] |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
463 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
464 def node(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
465 return self.index[rev][7] |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
466 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
467 # Derived from index values. |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
468 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
469 def end(self, rev): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
470 return self.start(rev) + self.length(rev) |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
471 |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
472 def parents(self, node): |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
473 i = self.index |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
474 d = i[self.rev(node)] |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
475 return i[d[5]][7], i[d[6]][7] # map revisions to nodes inline |
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
476 |
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
477 def chainlen(self, rev): |
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
478 return self._chaininfo(rev)[0] |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
479 |
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
480 def _chaininfo(self, rev): |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
481 chaininfocache = self._chaininfocache |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
482 if rev in chaininfocache: |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
483 return chaininfocache[rev] |
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
484 index = self.index |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
485 generaldelta = self._generaldelta |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
486 iterrev = rev |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
487 e = index[iterrev] |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
488 clen = 0 |
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
489 compresseddeltalen = 0 |
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
490 while iterrev != e[3]: |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
491 clen += 1 |
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
492 compresseddeltalen += e[1] |
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
493 if generaldelta: |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
494 iterrev = e[3] |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
495 else: |
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
496 iterrev -= 1 |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
497 if iterrev in chaininfocache: |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
498 t = chaininfocache[iterrev] |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
499 clen += t[0] |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
500 compresseddeltalen += t[1] |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
501 break |
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
502 e = index[iterrev] |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
503 else: |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
504 # Add text length of base since decompressing that also takes |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
505 # work. For cache hits the length is already included. |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
506 compresseddeltalen += e[1] |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
507 r = (clen, compresseddeltalen) |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
508 chaininfocache[rev] = r |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
509 return r |
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
510 |
27468
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
511 def _deltachain(self, rev, stoprev=None): |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
512 """Obtain the delta chain for a revision. |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
513 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
514 ``stoprev`` specifies a revision to stop at. If not specified, we |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
515 stop at the base of the chain. |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
516 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
517 Returns a 2-tuple of (chain, stopped) where ``chain`` is a list of |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
518 revs in ascending order and ``stopped`` is a bool indicating whether |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
519 ``stoprev`` was hit. |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
520 """ |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
521 chain = [] |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
522 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
523 # Alias to prevent attribute lookup in tight loop. |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
524 index = self.index |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
525 generaldelta = self._generaldelta |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
526 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
527 iterrev = rev |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
528 e = index[iterrev] |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
529 while iterrev != e[3] and iterrev != stoprev: |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
530 chain.append(iterrev) |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
531 if generaldelta: |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
532 iterrev = e[3] |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
533 else: |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
534 iterrev -= 1 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
535 e = index[iterrev] |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
536 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
537 if iterrev == stoprev: |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
538 stopped = True |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
539 else: |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
540 chain.append(iterrev) |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
541 stopped = False |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
542 |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
543 chain.reverse() |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
544 return chain, stopped |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
545 |
18081
f88c60e740a1
revlog.ancestors: add support for including revs
Siddharth Agarwal <sid0@fb.com>
parents:
17975
diff
changeset
|
546 def ancestors(self, revs, stoprev=0, inclusive=False): |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
547 """Generate the ancestors of 'revs' in reverse topological order. |
16868
eb88ed4269c5
revlog: add optional stoprev arg to revlog.ancestors()
Joshua Redstone <joshua.redstone@fb.com>
parents:
16867
diff
changeset
|
548 Does not generate revs lower than stoprev. |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
549 |
18090
9abc55ef85b5
revlog: move ancestor generation out to a new class
Siddharth Agarwal <sid0@fb.com>
parents:
18083
diff
changeset
|
550 See the documentation for ancestor.lazyancestors for more details.""" |
18081
f88c60e740a1
revlog.ancestors: add support for including revs
Siddharth Agarwal <sid0@fb.com>
parents:
17975
diff
changeset
|
551 |
23328
3a7d9c0c57a5
ancestor.lazyancestors: take parentrevs function rather than changelog
Siddharth Agarwal <sid0@fb.com>
parents:
23306
diff
changeset
|
552 return ancestor.lazyancestors(self.parentrevs, revs, stoprev=stoprev, |
18090
9abc55ef85b5
revlog: move ancestor generation out to a new class
Siddharth Agarwal <sid0@fb.com>
parents:
18083
diff
changeset
|
553 inclusive=inclusive) |
6872
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
554 |
16867
1093ad1e8903
revlog: descendants(*revs) becomes descendants(revs) (API)
Bryan O'Sullivan <bryano@fb.com>
parents:
16866
diff
changeset
|
555 def descendants(self, revs): |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
556 """Generate the descendants of 'revs' in revision order. |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
557 |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
558 Yield a sequence of revision numbers starting with a child of |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
559 some rev in revs, i.e., each revision is *not* considered a |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
560 descendant of itself. Results are ordered by revision number (a |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
561 topological sort).""" |
12950
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
562 first = min(revs) |
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
563 if first == nullrev: |
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
564 for i in self: |
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
565 yield i |
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
566 return |
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
567 |
8150
bbc24c0753a0
util: use built-in set and frozenset
Martin Geisler <mg@lazybytes.net>
parents:
8073
diff
changeset
|
568 seen = set(revs) |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
569 for i in self.revs(start=first + 1): |
6872
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
570 for x in self.parentrevs(i): |
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
571 if x != nullrev and x in seen: |
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
572 seen.add(i) |
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
573 yield i |
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
574 break |
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
575 |
13741
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
576 def findcommonmissing(self, common=None, heads=None): |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
577 """Return a tuple of the ancestors of common and the ancestors of heads |
15835
fa15869bf95c
revlog: improve docstring for findcommonmissing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15827
diff
changeset
|
578 that are not ancestors of common. In revset terminology, we return the |
fa15869bf95c
revlog: improve docstring for findcommonmissing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15827
diff
changeset
|
579 tuple: |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
580 |
15835
fa15869bf95c
revlog: improve docstring for findcommonmissing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15827
diff
changeset
|
581 ::common, (::heads) - (::common) |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
582 |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
583 The list is sorted by revision number, meaning it is |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
584 topologically sorted. |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
585 |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
586 'heads' and 'common' are both lists of node IDs. If heads is |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
587 not supplied, uses all of the revlog's heads. If common is not |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
588 supplied, uses nullid.""" |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
589 if common is None: |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
590 common = [nullid] |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
591 if heads is None: |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
592 heads = self.heads() |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
593 |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
594 common = [self.rev(n) for n in common] |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
595 heads = [self.rev(n) for n in heads] |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
596 |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
597 # we want the ancestors, but inclusive |
20073
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
598 class lazyset(object): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
599 def __init__(self, lazyvalues): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
600 self.addedvalues = set() |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
601 self.lazyvalues = lazyvalues |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
602 |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
603 def __contains__(self, value): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
604 return value in self.addedvalues or value in self.lazyvalues |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
605 |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
606 def __iter__(self): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
607 added = self.addedvalues |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
608 for r in added: |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
609 yield r |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
610 for r in self.lazyvalues: |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
611 if not r in added: |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
612 yield r |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
613 |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
614 def add(self, value): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
615 self.addedvalues.add(value) |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
616 |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
617 def update(self, values): |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
618 self.addedvalues.update(values) |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
619 |
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
620 has = lazyset(self.ancestors(common)) |
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
621 has.add(nullrev) |
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
622 has.update(common) |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
623 |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
624 # take all ancestors from heads that aren't in has |
8453
d1ca637b0773
revlog.missing(): use sets instead of a dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8391
diff
changeset
|
625 missing = set() |
25113
0ca8410ea345
util: drop alias for collections.deque
Martin von Zweigbergk <martinvonz@google.com>
parents:
24454
diff
changeset
|
626 visit = collections.deque(r for r in heads if r not in has) |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
627 while visit: |
16803
107a3270a24a
cleanup: use the deque type where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
628 r = visit.popleft() |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
629 if r in missing: |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
630 continue |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
631 else: |
8453
d1ca637b0773
revlog.missing(): use sets instead of a dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8391
diff
changeset
|
632 missing.add(r) |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
633 for p in self.parentrevs(r): |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
634 if p not in has: |
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
635 visit.append(p) |
8453
d1ca637b0773
revlog.missing(): use sets instead of a dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8391
diff
changeset
|
636 missing = list(missing) |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
637 missing.sort() |
30391
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
638 return has, [self.node(miss) for miss in missing] |
13741
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
639 |
23337
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
640 def incrementalmissingrevs(self, common=None): |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
641 """Return an object that can be used to incrementally compute the |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
642 revision numbers of the ancestors of arbitrary sets that are not |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
643 ancestors of common. This is an ancestor.incrementalmissingancestors |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
644 object. |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
645 |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
646 'common' is a list of revision numbers. If common is not supplied, uses |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
647 nullrev. |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
648 """ |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
649 if common is None: |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
650 common = [nullrev] |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
651 |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
652 return ancestor.incrementalmissingancestors(self.parentrevs, common) |
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
653 |
17972
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
654 def findmissingrevs(self, common=None, heads=None): |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
655 """Return the revision numbers of the ancestors of heads that |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
656 are not ancestors of common. |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
657 |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
658 More specifically, return a list of revision numbers corresponding to |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
659 nodes N such that every N satisfies the following constraints: |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
660 |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
661 1. N is an ancestor of some node in 'heads' |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
662 2. N is not an ancestor of any node in 'common' |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
663 |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
664 The list is sorted by revision number, meaning it is |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
665 topologically sorted. |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
666 |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
667 'heads' and 'common' are both lists of revision numbers. If heads is |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
668 not supplied, uses all of the revlog's heads. If common is not |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
669 supplied, uses nullid.""" |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
670 if common is None: |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
671 common = [nullrev] |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
672 if heads is None: |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
673 heads = self.headrevs() |
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
674 |
23338
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
675 inc = self.incrementalmissingrevs(common=common) |
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
676 return inc.missingancestors(heads) |
17972
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
677 |
13741
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
678 def findmissing(self, common=None, heads=None): |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
679 """Return the ancestors of heads that are not ancestors of common. |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
680 |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
681 More specifically, return a list of nodes N such that every N |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
682 satisfies the following constraints: |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
683 |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
684 1. N is an ancestor of some node in 'heads' |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
685 2. N is not an ancestor of any node in 'common' |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
686 |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
687 The list is sorted by revision number, meaning it is |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
688 topologically sorted. |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
689 |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
690 'heads' and 'common' are both lists of node IDs. If heads is |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
691 not supplied, uses all of the revlog's heads. If common is not |
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
692 supplied, uses nullid.""" |
17971
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
693 if common is None: |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
694 common = [nullid] |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
695 if heads is None: |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
696 heads = self.heads() |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
697 |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
698 common = [self.rev(n) for n in common] |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
699 heads = [self.rev(n) for n in heads] |
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
700 |
23338
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
701 inc = self.incrementalmissingrevs(common=common) |
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
702 return [self.node(r) for r in inc.missingancestors(heads)] |
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
703 |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
704 def nodesbetween(self, roots=None, heads=None): |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
705 """Return a topological path from 'roots' to 'heads'. |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
706 |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
707 Return a tuple (nodes, outroots, outheads) where 'nodes' is a |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
708 topologically sorted list of all nodes N that satisfy both of |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
709 these constraints: |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
710 |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
711 1. N is a descendant of some node in 'roots' |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
712 2. N is an ancestor of some node in 'heads' |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
713 |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
714 Every node is considered to be both a descendant and an ancestor |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
715 of itself, so every reachable node in 'roots' and 'heads' will be |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
716 included in 'nodes'. |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
717 |
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
718 'outroots' is the list of reachable nodes in 'roots', i.e., the |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
719 subset of 'roots' that is returned in 'nodes'. Likewise, |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
720 'outheads' is the subset of 'heads' that is also in 'nodes'. |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
721 |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
722 'roots' and 'heads' are both lists of node IDs. If 'roots' is |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
723 unspecified, uses nullid as the only root. If 'heads' is |
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
724 unspecified, uses list of all of the revlog's heads.""" |
1463
26e73acc0cdf
Fix to handle case of empty list for roots or heads in nodesbetween.
Eric Hopper <hopper@omnifarious.org>
parents:
1459
diff
changeset
|
725 nonodes = ([], [], []) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
726 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
|
727 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
|
728 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
|
729 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
730 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
|
731 else: |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
732 roots = [nullid] # Everybody's a descendant of nullid |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3508
diff
changeset
|
733 lowestrev = nullrev |
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3508
diff
changeset
|
734 if (lowestrev == nullrev) and (heads is None): |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
735 # We want _all_ the nodes! |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
736 return ([self.node(r) for r in self], [nullid], list(self.heads())) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
737 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
|
738 # 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
|
739 # node. |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
740 highestrev = len(self) - 1 |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
741 # 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
|
742 ancestors = None |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
743 # 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
|
744 heads = {} |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
745 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
|
746 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
|
747 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
|
748 return nonodes |
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
749 ancestors = set() |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
750 # 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
|
751 # 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
|
752 # find from roots. |
14219
c33427080671
revlog: use real Booleans instead of 0/1 in nodesbetween
Martin Geisler <mg@aragost.com>
parents:
14208
diff
changeset
|
753 heads = dict.fromkeys(heads, False) |
3360
ef8307585b41
nodesbetween: fix a bug with duplicate heads
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3335
diff
changeset
|
754 # Start at the top and keep marking parents until we're done. |
8163
62d7287fe6b0
rebase, revlog: use set(x) instead of set(x.keys())
Martin Geisler <mg@lazybytes.net>
parents:
8153
diff
changeset
|
755 nodestotag = set(heads) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
756 # 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
|
757 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
|
758 while nodestotag: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
759 # 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
|
760 n = nodestotag.pop() |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
761 # Never tag nullid |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
762 if n == nullid: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
763 continue |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
764 # 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
|
765 # 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
|
766 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
|
767 if r >= lowestrev: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
768 if n not in ancestors: |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
769 # If we are possibly a descendant of one of the roots |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
770 # and we haven't already been marked as an ancestor |
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
771 ancestors.add(n) # Mark as ancestor |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
772 # Add non-nullid parents to list of nodes to tag. |
8153
616f20e1004a
revlog: let nodestotag be a set instead of a list
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
773 nodestotag.update([p for p in self.parents(n) if |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
774 p != nullid]) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
775 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
|
776 # 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
|
777 # any other heads. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
778 heads.pop(n) |
1459
106fdec8e1fb
Fix small bug in nodesbetween if heads is [nullid].
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
779 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
|
780 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
781 # 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
|
782 # 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
|
783 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
784 # If one of the roots was nullid, everything is included anyway. |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3508
diff
changeset
|
785 if lowestrev > nullrev: |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
786 # 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
|
787 # 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
|
788 |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
789 # Filter out roots that aren't ancestors of heads |
30391
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
790 roots = [root for root in roots if root in ancestors] |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
791 # 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
|
792 if roots: |
30391
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
793 lowestrev = min([self.rev(root) for root in roots]) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
794 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
795 # 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
|
796 return nonodes |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
797 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
798 # 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
|
799 # any other roots. |
3578
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3508
diff
changeset
|
800 lowestrev = nullrev |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
801 roots = [nullid] |
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
802 # Transform our roots list into a set. |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
803 descendants = set(roots) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
804 # 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
|
805 # 'real' roots (i.e. are descended from other roots). |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
806 roots = descendants.copy() |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
807 # 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
|
808 orderedout = [] |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
809 # Don't start at nullid since we don't want nullid in our output list, |
17483 | 810 # and if nullid shows up in descendants, empty parents will look like |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
811 # they're descendants. |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
812 for r in self.revs(start=max(lowestrev, 0), stop=highestrev + 1): |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
813 n = self.node(r) |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
814 isdescendant = False |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
815 if lowestrev == nullrev: # Everybody is a descendant of nullid |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
816 isdescendant = True |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
817 elif n in descendants: |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
818 # n is already a descendant |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
819 isdescendant = True |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
820 # This check only needs to be done here because all the roots |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
821 # will start being marked is descendants before the loop. |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
822 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
|
823 # 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
|
824 p = tuple(self.parents(n)) |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
825 # If any of its parents are descendants, it's not a root. |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
826 if (p[0] in descendants) or (p[1] in descendants): |
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
827 roots.remove(n) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
828 else: |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
829 p = tuple(self.parents(n)) |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
830 # A node is a descendant if either of its parents are |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
831 # descendants. (We seeded the dependents list with the roots |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
832 # up there, remember?) |
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
833 if (p[0] in descendants) or (p[1] in descendants): |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
834 descendants.add(n) |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
835 isdescendant = True |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
836 if isdescendant and ((ancestors is None) or (n in ancestors)): |
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
837 # Only include nodes that are both descendants and ancestors. |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
838 orderedout.append(n) |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
839 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
|
840 # 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
|
841 # from roots. |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
842 # Mark this head as having been reached |
14219
c33427080671
revlog: use real Booleans instead of 0/1 in nodesbetween
Martin Geisler <mg@aragost.com>
parents:
14208
diff
changeset
|
843 heads[n] = True |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
844 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
|
845 # 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
|
846 # 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
|
847 # will eventually remove it. |
14219
c33427080671
revlog: use real Booleans instead of 0/1 in nodesbetween
Martin Geisler <mg@aragost.com>
parents:
14208
diff
changeset
|
848 heads[n] = True |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
849 # 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
|
850 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
|
851 heads.pop(p, None) |
30391
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
852 heads = [head for head, flag in heads.iteritems() if flag] |
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
853 roots = list(roots) |
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
854 assert orderedout |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
855 assert roots |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
856 assert heads |
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
857 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
|
858 |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
859 def headrevs(self): |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
860 try: |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
861 return self.index.headrevs() |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
862 except AttributeError: |
17674
e69274f8d444
clfilter: split `revlog.headrevs` C call from python code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17673
diff
changeset
|
863 return self._headrevs() |
e69274f8d444
clfilter: split `revlog.headrevs` C call from python code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17673
diff
changeset
|
864 |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24255
diff
changeset
|
865 def computephases(self, roots): |
25361
1635579f9baf
phases: fix bug where native phase computation wasn't called
Laurent Charignon <lcharignon@fb.com>
parents:
25113
diff
changeset
|
866 return self.index.computephasesmapsets(roots) |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24255
diff
changeset
|
867 |
17674
e69274f8d444
clfilter: split `revlog.headrevs` C call from python code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17673
diff
changeset
|
868 def _headrevs(self): |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
869 count = len(self) |
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
870 if not count: |
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
871 return [nullrev] |
17673
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
872 # we won't iter over filtered rev so nobody is a head at start |
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
873 ishead = [0] * (count + 1) |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
874 index = self.index |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
875 for r in self: |
17673
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
876 ishead[r] = 1 # I may be an head |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
877 e = index[r] |
17673
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
878 ishead[e[5]] = ishead[e[6]] = 0 # my parent are not |
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
879 return [r for r, val in enumerate(ishead) if val] |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
880 |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
881 def heads(self, start=None, stop=None): |
1550
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1535
diff
changeset
|
882 """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
|
883 |
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
884 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
|
885 start will be returned |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
886 if stop is specified, it will consider all the revs from stop |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
887 as if they had no children |
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
888 """ |
4991
9c8c42bcf17a
revlog: implement a fast path for heads
Matt Mackall <mpm@selenic.com>
parents:
4990
diff
changeset
|
889 if start is None and stop is None: |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
890 if not len(self): |
4991
9c8c42bcf17a
revlog: implement a fast path for heads
Matt Mackall <mpm@selenic.com>
parents:
4990
diff
changeset
|
891 return [nullid] |
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
892 return [self.node(r) for r in self.headrevs()] |
4991
9c8c42bcf17a
revlog: implement a fast path for heads
Matt Mackall <mpm@selenic.com>
parents:
4990
diff
changeset
|
893 |
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
894 if start is None: |
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
895 start = nullid |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
896 if stop is None: |
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
897 stop = [] |
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
898 stoprevs = set([self.rev(n) for n in stop]) |
1550
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1535
diff
changeset
|
899 startrev = self.rev(start) |
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
900 reachable = set((startrev,)) |
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
901 heads = set((startrev,)) |
1083 | 902 |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
903 parentrevs = self.parentrevs |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
904 for r in self.revs(start=startrev + 1): |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
905 for p in parentrevs(r): |
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
906 if p in reachable: |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
907 if r not in stoprevs: |
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
908 reachable.add(r) |
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
909 heads.add(r) |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
910 if p in heads and p not in stoprevs: |
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
911 heads.remove(p) |
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
912 |
2490
6ff82ec1f4b8
Change revlog.heads to walk the revision graph using revision numbers
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2489
diff
changeset
|
913 return [self.node(r) for r in heads] |
370 | 914 |
915 def children(self, node): | |
1083 | 916 """find the children of a given node""" |
370 | 917 c = [] |
918 p = self.rev(node) | |
17672
474047947b8f
clfilter: make the revlog class responsible of all its iteration
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17537
diff
changeset
|
919 for r in self.revs(start=p + 1): |
4746
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
920 prevs = [pr for pr in self.parentrevs(r) if pr != nullrev] |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
921 if prevs: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
922 for pr in prevs: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
923 if pr == p: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
924 c.append(self.node(r)) |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
925 elif p == nullrev: |
62c56d8f368b
Fix revlog.children so the real children of the null revision can be calculated.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4635
diff
changeset
|
926 c.append(self.node(r)) |
370 | 927 return c |
515 | 928 |
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
929 def descendant(self, start, end): |
12949
6878eaa5a40d
revlog: if start is nullrev, end is always a descendant
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12890
diff
changeset
|
930 if start == nullrev: |
6878eaa5a40d
revlog: if start is nullrev, end is always a descendant
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12890
diff
changeset
|
931 return True |
16867
1093ad1e8903
revlog: descendants(*revs) becomes descendants(revs) (API)
Bryan O'Sullivan <bryano@fb.com>
parents:
16866
diff
changeset
|
932 for i in self.descendants([start]): |
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
933 if i == end: |
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
934 return True |
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
935 elif i > end: |
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
936 break |
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
937 return False |
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
938 |
21104
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
939 def commonancestorsheads(self, a, b): |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
940 """calculate all the heads of the common ancestors of nodes a and b""" |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
941 a, b = self.rev(a), self.rev(b) |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
942 try: |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
943 ancs = self.index.commonancestorsheads(a, b) |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
944 except (AttributeError, OverflowError): # C implementation failed |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
945 ancs = ancestor.commonancestorsheads(self.parentrevs, a, b) |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
946 return map(self.node, ancs) |
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
947 |
22381
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
948 def isancestor(self, a, b): |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
949 """return True if node a is an ancestor of node b |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
950 |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
951 The implementation of this is trivial but the use of |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
952 commonancestorsheads is not.""" |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
953 return a in self.commonancestorsheads(a, b) |
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
954 |
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
955 def ancestor(self, a, b): |
22389
94f77624dbb5
comments: describe ancestor consistently - avoid 'least common ancestor'
Mads Kiilerich <madski@unity3d.com>
parents:
22381
diff
changeset
|
956 """calculate the "best" common ancestor of nodes a and b""" |
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
957 |
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
958 a, b = self.rev(a), self.rev(b) |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18987
diff
changeset
|
959 try: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18987
diff
changeset
|
960 ancs = self.index.ancestors(a, b) |
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
961 except (AttributeError, OverflowError): |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18987
diff
changeset
|
962 ancs = ancestor.ancestors(self.parentrevs, a, b) |
18987
3605d4e7e618
revlog: choose a consistent ancestor when there's a tie
Bryan O'Sullivan <bryano@fb.com>
parents:
18986
diff
changeset
|
963 if ancs: |
3605d4e7e618
revlog: choose a consistent ancestor when there's a tie
Bryan O'Sullivan <bryano@fb.com>
parents:
18986
diff
changeset
|
964 # choose a consistent winner when there's a tie |
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
965 return min(map(self.node, ancs)) |
18987
3605d4e7e618
revlog: choose a consistent ancestor when there's a tie
Bryan O'Sullivan <bryano@fb.com>
parents:
18986
diff
changeset
|
966 return nullid |
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
967 |
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
968 def _match(self, id): |
16762
93f8b9565257
revlog: don't handle long for revision matching
Matt Mackall <mpm@selenic.com>
parents:
16686
diff
changeset
|
969 if isinstance(id, int): |
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
970 # rev |
2641
156fb1feab62
lookup should allow -1 to represent nullid (if passed an int as arg)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2600
diff
changeset
|
971 return self.node(id) |
3438 | 972 if len(id) == 20: |
973 # possibly a binary node | |
974 # odds of a binary node being all hex in ASCII are 1 in 10**25 | |
975 try: | |
976 node = id | |
7874
d812029cda85
cleanup: drop variables for unused return values
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7873
diff
changeset
|
977 self.rev(node) # quick search the index |
3438 | 978 return node |
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
979 except LookupError: |
3438 | 980 pass # may be partial hex id |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
981 try: |
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
982 # str(rev) |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
983 rev = int(id) |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
984 if str(rev) != id: |
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
985 raise ValueError |
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
986 if rev < 0: |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
987 rev = len(self) + rev |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
988 if rev < 0 or rev >= len(self): |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
989 raise ValueError |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
990 return self.node(rev) |
469 | 991 except (ValueError, OverflowError): |
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
992 pass |
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
993 if len(id) == 40: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
994 try: |
3438 | 995 # a full hex nodeid? |
996 node = bin(id) | |
7874
d812029cda85
cleanup: drop variables for unused return values
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7873
diff
changeset
|
997 self.rev(node) |
3157
4fe41a9e4591
optimize revlog.lookup when passed hex(node)[:...]
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3156
diff
changeset
|
998 return node |
7062
efc579fdaf69
provide nicer feedback when an unknown node id is passed to a command
Sune Foldager <cryo@cyanite.org>
parents:
6912
diff
changeset
|
999 except (TypeError, LookupError): |
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1000 pass |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1001 |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1002 def _partialmatch(self, id): |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1003 try: |
30391
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
1004 partial = self.index.partialmatch(id) |
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
1005 if partial and self.hasnode(partial): |
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30289
diff
changeset
|
1006 return partial |
19471
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1007 return None |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1008 except RevlogError: |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1009 # parsers.c radix tree lookup gave multiple matches |
29396
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1010 # fast path: for unfiltered changelog, radix tree is accurate |
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1011 if not getattr(self, 'filteredrevs', None): |
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1012 raise LookupError(id, self.indexfile, |
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1013 _('ambiguous identifier')) |
19471
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1014 # fall through to slow path that filters hidden revisions |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1015 except (AttributeError, ValueError): |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1016 # we are pure python, or key was too short to search radix tree |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1017 pass |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1018 |
13258
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1019 if id in self._pcache: |
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1020 return self._pcache[id] |
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1021 |
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1022 if len(id) < 40: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1023 try: |
3438 | 1024 # hex(node)[:...] |
9029
0001e49f1c11
compat: use // for integer division
Alejandro Santos <alejolp@alejolp.com>
parents:
8658
diff
changeset
|
1025 l = len(id) // 2 # grab an even number of digits |
13259
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
1026 prefix = bin(id[:l * 2]) |
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
1027 nl = [e[7] for e in self.index if e[7].startswith(prefix)] |
19471
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1028 nl = [n for n in nl if hex(n).startswith(id) and |
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1029 self.hasnode(n)] |
7365
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1030 if len(nl) > 0: |
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1031 if len(nl) == 1: |
13258
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1032 self._pcache[id] = nl[0] |
7365
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1033 return nl[0] |
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1034 raise LookupError(id, self.indexfile, |
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1035 _('ambiguous identifier')) |
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1036 return None |
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1037 except TypeError: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1038 pass |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1039 |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1040 def lookup(self, id): |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1041 """locate a node based on: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1042 - revision number or str(revision number) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1043 - nodeid or subset of hex nodeid |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1044 """ |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1045 n = self._match(id) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1046 if n is not None: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1047 return n |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1048 n = self._partialmatch(id) |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1049 if n: |
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1050 return n |
515 | 1051 |
6228
c0c4c7b1e8d3
revlog: report node and file when lookup fails
Matt Mackall <mpm@selenic.com>
parents:
6212
diff
changeset
|
1052 raise LookupError(id, self.indexfile, _('no match found')) |
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
1053 |
2890
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1054 def cmp(self, node, text): |
11539
a463e3c50212
cmp: document the fact that we return True if content is different
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11323
diff
changeset
|
1055 """compare text with a given file revision |
a463e3c50212
cmp: document the fact that we return True if content is different
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11323
diff
changeset
|
1056 |
a463e3c50212
cmp: document the fact that we return True if content is different
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11323
diff
changeset
|
1057 returns True if text is different than what is stored. |
a463e3c50212
cmp: document the fact that we return True if content is different
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11323
diff
changeset
|
1058 """ |
2890
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1059 p1, p2 = self.parents(node) |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1060 return hash(text, p1, p2) != node |
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1061 |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1062 def _addchunk(self, offset, data): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1063 """Add a segment to the revlog cache. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1064 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1065 Accepts an absolute offset and the data that is at that location. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1066 """ |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1067 o, d = self._chunkcache |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1068 # try to add to existing cache |
13253 | 1069 if o + len(d) == offset and len(d) + len(data) < _chunksize: |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1070 self._chunkcache = o, d + data |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1071 else: |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1072 self._chunkcache = offset, data |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1073 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1074 def _loadchunk(self, offset, length, df=None): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1075 """Load a segment of raw data from the revlog. |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1076 |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1077 Accepts an absolute offset, length to read, and an optional existing |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1078 file handle to read from. |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1079 |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1080 If an existing file handle is passed, it will be seeked and the |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1081 original seek position will NOT be restored. |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1082 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1083 Returns a str or buffer of raw byte data. |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1084 """ |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1085 if df is not None: |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1086 closehandle = False |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1087 else: |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1088 if self._inline: |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1089 df = self.opener(self.indexfile) |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1090 else: |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1091 df = self.opener(self.datafile) |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1092 closehandle = True |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1093 |
20179
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1094 # Cache data both forward and backward around the requested |
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1095 # data, in a fixed size window. This helps speed up operations |
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1096 # involving reading the revlog backwards. |
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
1097 cachesize = self._chunkcachesize |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
1098 realoffset = offset & ~(cachesize - 1) |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
1099 reallength = (((offset + length + cachesize) & ~(cachesize - 1)) |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
1100 - realoffset) |
20179
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1101 df.seek(realoffset) |
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1102 d = df.read(reallength) |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1103 if closehandle: |
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1104 df.close() |
20179
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1105 self._addchunk(realoffset, d) |
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1106 if offset != realoffset or reallength != length: |
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1107 return util.buffer(d, offset - realoffset, length) |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1108 return d |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1109 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1110 def _getchunk(self, offset, length, df=None): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1111 """Obtain a segment of raw data from the revlog. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1112 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1113 Accepts an absolute offset, length of bytes to obtain, and an |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1114 optional file handle to the already-opened revlog. If the file |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1115 handle is used, it's original seek position will not be preserved. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1116 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1117 Requests for data may be returned from a cache. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1118 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1119 Returns a str or a buffer instance of raw byte data. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1120 """ |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1121 o, d = self._chunkcache |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1122 l = len(d) |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1123 |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1124 # is it in the cache? |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1125 cachestart = offset - o |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1126 cacheend = cachestart + length |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1127 if cachestart >= 0 and cacheend <= l: |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1128 if cachestart == 0 and cacheend == l: |
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1129 return d # avoid a copy |
16423
a150923b49ba
revlog: avoid an expensive string copy
Bryan O'Sullivan <bryano@fb.com>
parents:
16418
diff
changeset
|
1130 return util.buffer(d, cachestart, cacheend - cachestart) |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1131 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1132 return self._loadchunk(offset, length, df=df) |
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1133 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1134 def _chunkraw(self, startrev, endrev, df=None): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1135 """Obtain a segment of raw data corresponding to a range of revisions. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1136 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1137 Accepts the start and end revisions and an optional already-open |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1138 file handle to be used for reading. If the file handle is read, its |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1139 seek position will not be preserved. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1140 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1141 Requests for data may be satisfied by a cache. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1142 |
27649
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1143 Returns a 2-tuple of (offset, data) for the requested range of |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1144 revisions. Offset is the integer offset from the beginning of the |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1145 revlog and data is a str or buffer of the raw byte data. |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1146 |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1147 Callers will need to call ``self.start(rev)`` and ``self.length(rev)`` |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1148 to determine where each revision's data begins and ends. |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1149 """ |
30288
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1150 # Inlined self.start(startrev) & self.end(endrev) for perf reasons |
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1151 # (functions are expensive). |
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1152 index = self.index |
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1153 istart = index[startrev] |
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1154 start = int(istart[0] >> 16) |
30289
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30288
diff
changeset
|
1155 if startrev == endrev: |
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30288
diff
changeset
|
1156 end = start + istart[1] |
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30288
diff
changeset
|
1157 else: |
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30288
diff
changeset
|
1158 iend = index[endrev] |
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30288
diff
changeset
|
1159 end = int(iend[0] >> 16) + iend[1] |
30288
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30287
diff
changeset
|
1160 |
8318
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1161 if self._inline: |
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1162 start += (startrev + 1) * self._io.size |
19714
0e07c0b5fb1c
revlog.revision: fix cache preload for inline revlogs
Siddharth Agarwal <sid0@fb.com>
parents:
19713
diff
changeset
|
1163 end += (endrev + 1) * self._io.size |
0e07c0b5fb1c
revlog.revision: fix cache preload for inline revlogs
Siddharth Agarwal <sid0@fb.com>
parents:
19713
diff
changeset
|
1164 length = end - start |
27649
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1165 |
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1166 return start, self._getchunk(start, length, df=df) |
8318
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1167 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1168 def _chunk(self, rev, df=None): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1169 """Obtain a single decompressed chunk for a revision. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1170 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1171 Accepts an integer revision and an optional already-open file handle |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1172 to be used for reading. If used, the seek position of the file will not |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1173 be preserved. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1174 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1175 Returns a str holding uncompressed data for the requested revision. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1176 """ |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1177 return self.decompress(self._chunkraw(rev, rev, df=df)[1]) |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1178 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1179 def _chunks(self, revs, df=None): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1180 """Obtain decompressed chunks for the specified revisions. |
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1181 |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1182 Accepts an iterable of numeric revisions that are assumed to be in |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1183 ascending order. Also accepts an optional already-open file handle |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1184 to be used for reading. If used, the seek position of the file will |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1185 not be preserved. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1186 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1187 This function is similar to calling ``self._chunk()`` multiple times, |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1188 but is faster. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1189 |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1190 Returns a list with decompressed data for each requested revision. |
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1191 """ |
19716
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1192 if not revs: |
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1193 return [] |
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1194 start = self.start |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1195 length = self.length |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1196 inline = self._inline |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1197 iosize = self._io.size |
19715
1aab406be57c
revlog._chunks: inline getchunk
Siddharth Agarwal <sid0@fb.com>
parents:
19714
diff
changeset
|
1198 buffer = util.buffer |
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1199 |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1200 l = [] |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1201 ladd = l.append |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1202 |
20957
469d949a7cb8
revlog: deal with chunk ranges over 2G on Windows (issue4215)
Matt Mackall <mpm@selenic.com>
parents:
20217
diff
changeset
|
1203 try: |
27650
e7222d326ea2
revlog: remove unnecessary cache validation in _chunks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27649
diff
changeset
|
1204 offset, data = self._chunkraw(revs[0], revs[-1], df=df) |
20957
469d949a7cb8
revlog: deal with chunk ranges over 2G on Windows (issue4215)
Matt Mackall <mpm@selenic.com>
parents:
20217
diff
changeset
|
1205 except OverflowError: |
469d949a7cb8
revlog: deal with chunk ranges over 2G on Windows (issue4215)
Matt Mackall <mpm@selenic.com>
parents:
20217
diff
changeset
|
1206 # issue4215 - we can't cache a run of chunks greater than |
469d949a7cb8
revlog: deal with chunk ranges over 2G on Windows (issue4215)
Matt Mackall <mpm@selenic.com>
parents:
20217
diff
changeset
|
1207 # 2G on Windows |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1208 return [self._chunk(rev, df=df) for rev in revs] |
19715
1aab406be57c
revlog._chunks: inline getchunk
Siddharth Agarwal <sid0@fb.com>
parents:
19714
diff
changeset
|
1209 |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1210 decomp = self.decompress |
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1211 for rev in revs: |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1212 chunkstart = start(rev) |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1213 if inline: |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1214 chunkstart += (rev + 1) * iosize |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1215 chunklength = length(rev) |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1216 ladd(decomp(buffer(data, chunkstart - offset, chunklength))) |
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1217 |
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1218 return l |
14075
bc101902a68d
revlog: introduce _chunkbase to allow filelog to override
Sune Foldager <cryo@cyanite.org>
parents:
14064
diff
changeset
|
1219 |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1220 def _chunkclear(self): |
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1221 """Clear the raw chunk cache.""" |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1222 self._chunkcache = (0, '') |
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1223 |
11929
1839a7518b0d
revlog: deltachain() returns chain of revs need to construct a revision
Pradeepkumar Gayam <in3xes@gmail.com>
parents:
11928
diff
changeset
|
1224 def deltaparent(self, rev): |
14195
0013d3eeb826
revlog: remove support for parentdelta
Sune Foldager <cryo@cyanite.org>
parents:
14164
diff
changeset
|
1225 """return deltaparent of the given revision""" |
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1226 base = self.index[rev][3] |
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1227 if base == rev: |
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1228 return nullrev |
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1229 elif self._generaldelta: |
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1230 return base |
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1231 else: |
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1232 return rev - 1 |
11929
1839a7518b0d
revlog: deltachain() returns chain of revs need to construct a revision
Pradeepkumar Gayam <in3xes@gmail.com>
parents:
11928
diff
changeset
|
1233 |
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
1234 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
|
1235 """return or calculate a delta between two revisions""" |
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1236 if rev1 != nullrev and self.deltaparent(rev2) == rev1: |
16423
a150923b49ba
revlog: avoid an expensive string copy
Bryan O'Sullivan <bryano@fb.com>
parents:
16418
diff
changeset
|
1237 return str(self._chunk(rev2)) |
5005
72082bfced9a
revlog: minor revdiff reorganization
Matt Mackall <mpm@selenic.com>
parents:
5004
diff
changeset
|
1238 |
16424
ff63d71ac8ab
revlog: drop some unneeded rev.node calls in revdiff
Matt Mackall <mpm@selenic.com>
parents:
16423
diff
changeset
|
1239 return mdiff.textdiff(self.revision(rev1), |
ff63d71ac8ab
revlog: drop some unneeded rev.node calls in revdiff
Matt Mackall <mpm@selenic.com>
parents:
16423
diff
changeset
|
1240 self.revision(rev2)) |
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
1241 |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1242 def revision(self, nodeorrev, _df=None, raw=False): |
16435
df347129305d
revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents:
16424
diff
changeset
|
1243 """return an uncompressed revision of a given node or revision |
df347129305d
revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents:
16424
diff
changeset
|
1244 number. |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1245 |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1246 _df - an existing file handle to read from. (internal-only) |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1247 raw - an optional argument specifying if the revision data is to be |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1248 treated as raw data when applying flag transforms. 'raw' should be set |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1249 to True when generating changegroups or in debug commands. |
16435
df347129305d
revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents:
16424
diff
changeset
|
1250 """ |
16375
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1251 if isinstance(nodeorrev, int): |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1252 rev = nodeorrev |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1253 node = self.node(rev) |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1254 else: |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1255 node = nodeorrev |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1256 rev = None |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1257 |
11996
3195cf01dfb9
revlog.revision(): don't use nullrev as the default value for the cache
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
11995
diff
changeset
|
1258 cachedrev = None |
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1259 if node == nullid: |
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1260 return "" |
26242
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1261 if self._cache: |
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1262 if self._cache[0] == node: |
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1263 return self._cache[2] |
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1264 cachedrev = self._cache[1] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1265 |
1083 | 1266 # look up what we need to read |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1267 text = None |
16375
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1268 if rev is None: |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1269 rev = self.rev(node) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1270 |
27468
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
1271 chain, stopped = self._deltachain(rev, stoprev=cachedrev) |
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
1272 if stopped: |
26242
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1273 text = self._cache[2] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1274 |
11754
6ccd130eab0e
revlog: drop cache after use to save memory footprint
Matt Mackall <mpm@selenic.com>
parents:
11539
diff
changeset
|
1275 # drop cache to save memory |
6ccd130eab0e
revlog: drop cache after use to save memory footprint
Matt Mackall <mpm@selenic.com>
parents:
11539
diff
changeset
|
1276 self._cache = None |
6ccd130eab0e
revlog: drop cache after use to save memory footprint
Matt Mackall <mpm@selenic.com>
parents:
11539
diff
changeset
|
1277 |
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1278 bins = self._chunks(chain, df=_df) |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1279 if text is None: |
19716
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1280 text = str(bins[0]) |
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1281 bins = bins[1:] |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1282 |
4989
1aaed3d69772
revlog: eliminate diff and patches functions
Matt Mackall <mpm@selenic.com>
parents:
4988
diff
changeset
|
1283 text = mdiff.patches(text, bins) |
30745 | 1284 |
1285 text, validatehash = self._processflags(text, self.flags(rev), 'read', | |
1286 raw=raw) | |
1287 if validatehash: | |
1288 self.checkhash(text, node, rev=rev) | |
1289 | |
13239
12ed25f39d0b
revlog: break hash checking into subfunction
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
1290 self._cache = (node, rev, text) |
12ed25f39d0b
revlog: break hash checking into subfunction
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
1291 return text |
12ed25f39d0b
revlog: break hash checking into subfunction
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
1292 |
22785
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1293 def hash(self, text, p1, p2): |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1294 """Compute a node hash. |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1295 |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1296 Available as a function so that subclasses can replace the hash |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1297 as needed. |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1298 """ |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1299 return hash(text, p1, p2) |
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1300 |
30745 | 1301 def _processflags(self, text, flags, operation, raw=False): |
1302 """Inspect revision data flags and applies transforms defined by | |
1303 registered flag processors. | |
1304 | |
1305 ``text`` - the revision data to process | |
1306 ``flags`` - the revision flags | |
1307 ``operation`` - the operation being performed (read or write) | |
1308 ``raw`` - an optional argument describing if the raw transform should be | |
1309 applied. | |
1310 | |
1311 This method processes the flags in the order (or reverse order if | |
1312 ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the | |
1313 flag processors registered for present flags. The order of flags defined | |
1314 in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity. | |
1315 | |
1316 Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the | |
1317 processed text and ``validatehash`` is a bool indicating whether the | |
1318 returned text should be checked for hash integrity. | |
1319 | |
1320 Note: If the ``raw`` argument is set, it has precedence over the | |
1321 operation and will only update the value of ``validatehash``. | |
1322 """ | |
1323 if not operation in ('read', 'write'): | |
1324 raise ProgrammingError(_("invalid '%s' operation ") % (operation)) | |
1325 # Check all flags are known. | |
1326 if flags & ~REVIDX_KNOWN_FLAGS: | |
1327 raise RevlogError(_("incompatible revision flag '%#x'") % | |
1328 (flags & ~REVIDX_KNOWN_FLAGS)) | |
1329 validatehash = True | |
1330 # Depending on the operation (read or write), the order might be | |
1331 # reversed due to non-commutative transforms. | |
1332 orderedflags = REVIDX_FLAGS_ORDER | |
1333 if operation == 'write': | |
1334 orderedflags = reversed(orderedflags) | |
1335 | |
1336 for flag in orderedflags: | |
1337 # If a flagprocessor has been registered for a known flag, apply the | |
1338 # related operation transform and update result tuple. | |
1339 if flag & flags: | |
1340 vhash = True | |
1341 | |
1342 if flag not in _flagprocessors: | |
1343 message = _("missing processor for flag '%#x'") % (flag) | |
1344 raise RevlogError(message) | |
1345 | |
1346 processor = _flagprocessors[flag] | |
1347 if processor is not None: | |
1348 readtransform, writetransform, rawtransform = processor | |
1349 | |
1350 if raw: | |
1351 vhash = rawtransform(self, text) | |
1352 elif operation == 'read': | |
1353 text, vhash = readtransform(self, text) | |
1354 else: # write operation | |
1355 text, vhash = writetransform(self, text) | |
1356 validatehash = validatehash and vhash | |
1357 | |
1358 return text, validatehash | |
1359 | |
30584
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1360 def checkhash(self, text, node, p1=None, p2=None, rev=None): |
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1361 """Check node hash integrity. |
19624
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1362 |
30584
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1363 Available as a function so that subclasses can extend hash mismatch |
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1364 behaviors as needed. |
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1365 """ |
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1366 if p1 is None and p2 is None: |
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30543
diff
changeset
|
1367 p1, p2 = self.parents(node) |
22785
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1368 if node != self.hash(text, p1, p2): |
19624
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1369 revornode = rev |
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1370 if revornode is None: |
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1371 revornode = templatefilters.short(hex(node)) |
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1372 raise RevlogError(_("integrity check failed on %s:%s") |
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1373 % (self.indexfile, revornode)) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1374 |
2075
343aeefb553b
Make the appendfile class inline-data index friendly
mason@suse.com
parents:
2073
diff
changeset
|
1375 def checkinlinesize(self, tr, fp=None): |
26376
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1376 """Check if the revlog is too big for inline and convert if so. |
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1377 |
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1378 This should be called after revisions are added to the revlog. If the |
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1379 revlog has grown too large to be an inline revlog, it will convert it |
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1380 to use multiple index and data files. |
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1381 """ |
10913
f2ecc5733c89
revlog: factor out _maxinline global.
Greg Ward <greg-hg@gerg.ca>
parents:
10404
diff
changeset
|
1382 if not self._inline or (self.start(-2) + self.length(-2)) < _maxinline: |
2073 | 1383 return |
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1384 |
2084 | 1385 trinfo = tr.find(self.indexfile) |
8527
f9a80054dd3c
use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents:
8464
diff
changeset
|
1386 if trinfo is None: |
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
1387 raise RevlogError(_("%s not found in the transaction") |
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
1388 % self.indexfile) |
2084 | 1389 |
1390 trindex = trinfo[2] | |
24454
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1391 if trindex is not None: |
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1392 dataoff = self.start(trindex) |
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1393 else: |
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1394 # revlog was stripped at start of transaction, use all leftover data |
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1395 trindex = len(self) - 1 |
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1396 dataoff = self.end(-2) |
2084 | 1397 |
1398 tr.add(self.datafile, dataoff) | |
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1399 |
8317
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1400 if fp: |
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1401 fp.flush() |
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1402 fp.close() |
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1403 |
2073 | 1404 df = self.opener(self.datafile, 'w') |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1405 try: |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1406 for r in self: |
27649
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1407 df.write(self._chunkraw(r, r)[1]) |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1408 finally: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1409 df.close() |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1410 |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1411 fp = self.opener(self.indexfile, 'w', atomictemp=True, |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1412 checkambig=self._checkambig) |
2073 | 1413 self.version &= ~(REVLOGNGINLINEDATA) |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1414 self._inline = False |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1415 for i in self: |
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
1416 e = self._io.packentry(self.index[i], self.node, self.version, i) |
2073 | 1417 fp.write(e) |
1418 | |
15057
774da7121fc9
atomictempfile: make close() consistent with other file-like objects.
Greg Ward <greg@gerg.ca>
parents:
14960
diff
changeset
|
1419 # if we don't call close, the temp file will never replace the |
2076
d007df6daf8e
Create an atomic opener that does not automatically rename on close
mason@suse.com
parents:
2075
diff
changeset
|
1420 # real index |
15057
774da7121fc9
atomictempfile: make close() consistent with other file-like objects.
Greg Ward <greg@gerg.ca>
parents:
14960
diff
changeset
|
1421 fp.close() |
2084 | 1422 |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1423 tr.replace(self.indexfile, trindex * self._io.size) |
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1424 self._chunkclear() |
2073 | 1425 |
19625
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1426 def addrevision(self, text, transaction, link, p1, p2, cachedelta=None, |
30744
e12c0fa1f65b
revlog: pass revlog flags to addrevision
Remi Chaintron <remi@fb.com>
parents:
30743
diff
changeset
|
1427 node=None, flags=REVIDX_DEFAULT_FLAGS): |
1083 | 1428 """add a revision to the log |
1429 | |
1430 text - the revision data to add | |
1431 transaction - the transaction object used for rollback | |
1432 link - the linkrev data to add | |
1433 p1, p2 - the parent nodeids of the revision | |
12012
bade7a9c5c07
revlog: fix docstring
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12011
diff
changeset
|
1434 cachedelta - an optional precomputed delta |
19625
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1435 node - nodeid of revision; typically node is not specified, and it is |
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1436 computed by default as hash(text, p1, p2), however subclasses might |
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1437 use different hashing method (and override checkhash() in such case) |
30744
e12c0fa1f65b
revlog: pass revlog flags to addrevision
Remi Chaintron <remi@fb.com>
parents:
30743
diff
changeset
|
1438 flags - the known flags to set on the revision |
1083 | 1439 """ |
19326
7014526d67a8
revlog: add exception when linkrev == nullrev
Durham Goode <durham@fb.com>
parents:
19200
diff
changeset
|
1440 if link == nullrev: |
7014526d67a8
revlog: add exception when linkrev == nullrev
Durham Goode <durham@fb.com>
parents:
19200
diff
changeset
|
1441 raise RevlogError(_("attempted to add linkrev -1 to %s") |
7014526d67a8
revlog: add exception when linkrev == nullrev
Durham Goode <durham@fb.com>
parents:
19200
diff
changeset
|
1442 % self.indexfile) |
25459
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1443 |
30745 | 1444 if flags: |
1445 node = node or self.hash(text, p1, p2) | |
1446 | |
1447 newtext, validatehash = self._processflags(text, flags, 'write') | |
1448 | |
1449 # If the flag processor modifies the revision data, ignore any provided | |
1450 # cachedelta. | |
1451 if newtext != text: | |
1452 cachedelta = None | |
1453 text = newtext | |
1454 | |
25459
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1455 if len(text) > _maxentrysize: |
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1456 raise RevlogError( |
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1457 _("%s: size of %d bytes exceeds maximum revlog storage of 2GiB") |
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1458 % (self.indexfile, len(text))) |
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1459 |
22785
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1460 node = node or self.hash(text, p1, p2) |
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
1461 if node in self.nodemap: |
12023
44c22dc193a4
revlog.addrevision(): move computation of nodeid in addrevision()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12012
diff
changeset
|
1462 return node |
44c22dc193a4
revlog.addrevision(): move computation of nodeid in addrevision()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12012
diff
changeset
|
1463 |
30745 | 1464 if validatehash: |
1465 self.checkhash(text, node, p1=p1, p2=p2) | |
1466 | |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1467 dfh = None |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1468 if not self._inline: |
26378
e749707f0afb
revlog: always open revlogs for reading and appending
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26377
diff
changeset
|
1469 dfh = self.opener(self.datafile, "a+") |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1470 ifh = self.opener(self.indexfile, "a+", checkambig=self._checkambig) |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1471 try: |
12023
44c22dc193a4
revlog.addrevision(): move computation of nodeid in addrevision()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12012
diff
changeset
|
1472 return self._addrevision(node, text, transaction, link, p1, p2, |
30744
e12c0fa1f65b
revlog: pass revlog flags to addrevision
Remi Chaintron <remi@fb.com>
parents:
30743
diff
changeset
|
1473 flags, cachedelta, ifh, dfh) |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1474 finally: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1475 if dfh: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1476 dfh.close() |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1477 ifh.close() |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1478 |
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1479 def compress(self, data): |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1480 """Generate a possibly-compressed representation of data.""" |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1481 if not data: |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1482 return '', data |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1483 |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1484 compressed = self._compressor.compress(data) |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1485 |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1486 if compressed: |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1487 # The revlog compressor added the header in the returned data. |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1488 return '', compressed |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1489 |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1490 if data[0] == '\0': |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1491 return '', data |
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1492 return 'u', data |
17128
1028a1c9077a
revlog: make compress a method
Bryan O'Sullivan <bryano@fb.com>
parents:
17009
diff
changeset
|
1493 |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1494 def decompress(self, data): |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1495 """Decompress a revlog chunk. |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1496 |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1497 The chunk is expected to begin with a header identifying the |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1498 format type so it can be routed to an appropriate decompressor. |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1499 """ |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1500 if not data: |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1501 return data |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1502 |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1503 # Revlogs are read much more frequently than they are written and many |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1504 # chunks only take microseconds to decompress, so performance is |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1505 # important here. |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1506 # |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1507 # We can make a few assumptions about revlogs: |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1508 # |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1509 # 1) the majority of chunks will be compressed (as opposed to inline |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1510 # raw data). |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1511 # 2) decompressing *any* data will likely by at least 10x slower than |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1512 # returning raw inline data. |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1513 # 3) we want to prioritize common and officially supported compression |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1514 # engines |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1515 # |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1516 # It follows that we want to optimize for "decompress compressed data |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1517 # when encoded with common and officially supported compression engines" |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1518 # case over "raw data" and "data encoded by less common or non-official |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1519 # compression engines." That is why we have the inline lookup first |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1520 # followed by the compengines lookup. |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1521 # |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1522 # According to `hg perfrevlogchunks`, this is ~0.5% faster for zlib |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1523 # compressed chunks. And this matters for changelog and manifest reads. |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1524 t = data[0] |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1525 |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1526 if t == 'x': |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1527 try: |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1528 return _zlibdecompress(data) |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1529 except zlib.error as e: |
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1530 raise RevlogError(_('revlog decompress error: %s') % str(e)) |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1531 # '\0' is more common than 'u' so it goes first. |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1532 elif t == '\0': |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1533 return data |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1534 elif t == 'u': |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1535 return util.buffer(data, 1) |
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1536 |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1537 try: |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1538 compressor = self._decompressors[t] |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1539 except KeyError: |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1540 try: |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1541 engine = util.compengines.forrevlogheader(t) |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1542 compressor = engine.revlogcompressor() |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1543 self._decompressors[t] = compressor |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1544 except KeyError: |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1545 raise RevlogError(_('unknown compression type %r') % t) |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1546 |
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
1547 return compressor.decompress(data) |
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
1548 |
26115
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1549 def _isgooddelta(self, d, textlen): |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1550 """Returns True if the given delta is good. Good means that it is within |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1551 the disk span, disk size, and chain length bounds that we know to be |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1552 performant.""" |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1553 if d is None: |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1554 return False |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1555 |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1556 # - 'dist' is the distance from the base revision -- bounding it limits |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1557 # the amount of I/O we need to do. |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1558 # - 'compresseddeltalen' is the sum of the total size of deltas we need |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1559 # to apply -- bounding it limits the amount of CPU we consume. |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1560 dist, l, data, base, chainbase, chainlen, compresseddeltalen = d |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1561 if (dist > textlen * 4 or l > textlen or |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1562 compresseddeltalen > textlen * 2 or |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1563 (self._maxchainlen and chainlen > self._maxchainlen)): |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1564 return False |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1565 |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1566 return True |
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
1567 |
23856
062c3ad86651
revlog: add flags argument to _addrevision, update callers use default flags
Mike Edgar <adgar@google.com>
parents:
23855
diff
changeset
|
1568 def _addrevision(self, node, text, transaction, link, p1, p2, flags, |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1569 cachedelta, ifh, dfh, alwayscache=False, raw=False): |
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
1570 """internal function to add revisions to the log |
12623
8f97b50a8d10
revlog._addrevision(): allow text argument to be None, build it lazily
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12336
diff
changeset
|
1571 |
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
1572 see addrevision for argument descriptions. |
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
1573 invariants: |
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
1574 - text is optional (can be None); if not set, cachedelta must be set. |
17424
e7cfe3587ea4
fix trivial spelling errors
Mads Kiilerich <mads@kiilerich.com>
parents:
17150
diff
changeset
|
1575 if both are set, they must correspond to each other. |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1576 - raw is optional; if set to True, it indicates the revision data is to |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1577 be treated by _processflags() as raw. It is usually set by changegroup |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1578 generation and debug commands. |
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
1579 """ |
12886
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1580 btext = [text] |
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1581 def buildtext(): |
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1582 if btext[0] is not None: |
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1583 return btext[0] |
24122
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1584 baserev = cachedelta[0] |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1585 delta = cachedelta[1] |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1586 # special case deltas which replace entire base; no need to decode |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1587 # base revision. this neatly avoids censored bases, which throw when |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1588 # they're decoded. |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1589 hlen = struct.calcsize(">lll") |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1590 if delta[:hlen] == mdiff.replacediffheader(self.rawsize(baserev), |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1591 len(delta) - hlen): |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1592 btext[0] = delta[hlen:] |
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1593 else: |
26379
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1594 if self._inline: |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1595 fh = ifh |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1596 else: |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1597 fh = dfh |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1598 basetext = self.revision(self.node(baserev), _df=fh, raw=raw) |
24122
da14b8eba806
revlog: special case expanding full-replacement deltas received by exchange
Mike Edgar <adgar@google.com>
parents:
24120
diff
changeset
|
1599 btext[0] = mdiff.patch(basetext, delta) |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1600 |
22934
8a096d4d0862
revlog: support importing censored file revision tombstones
Mike Edgar <adgar@google.com>
parents:
22785
diff
changeset
|
1601 try: |
30745 | 1602 res = self._processflags(btext[0], flags, 'read', raw=raw) |
1603 btext[0], validatehash = res | |
1604 if validatehash: | |
1605 self.checkhash(btext[0], node, p1=p1, p2=p2) | |
23857
8a3c132f93d2
revlog: verify censored flag when hashing added revision fulltext
Mike Edgar <adgar@google.com>
parents:
23856
diff
changeset
|
1606 if flags & REVIDX_ISCENSORED: |
8a3c132f93d2
revlog: verify censored flag when hashing added revision fulltext
Mike Edgar <adgar@google.com>
parents:
23856
diff
changeset
|
1607 raise RevlogError(_('node %s is not censored') % node) |
22934
8a096d4d0862
revlog: support importing censored file revision tombstones
Mike Edgar <adgar@google.com>
parents:
22785
diff
changeset
|
1608 except CensoredNodeError: |
23857
8a3c132f93d2
revlog: verify censored flag when hashing added revision fulltext
Mike Edgar <adgar@google.com>
parents:
23856
diff
changeset
|
1609 # must pass the censored index flag to add censored revisions |
8a3c132f93d2
revlog: verify censored flag when hashing added revision fulltext
Mike Edgar <adgar@google.com>
parents:
23856
diff
changeset
|
1610 if not flags & REVIDX_ISCENSORED: |
8a3c132f93d2
revlog: verify censored flag when hashing added revision fulltext
Mike Edgar <adgar@google.com>
parents:
23856
diff
changeset
|
1611 raise |
12886
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1612 return btext[0] |
12623
8f97b50a8d10
revlog._addrevision(): allow text argument to be None, build it lazily
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12336
diff
changeset
|
1613 |
12888
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1614 def builddelta(rev): |
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1615 # can we use the cached delta? |
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1616 if cachedelta and cachedelta[0] == rev: |
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1617 delta = cachedelta[1] |
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1618 else: |
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1619 t = buildtext() |
24123
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1620 if self.iscensored(rev): |
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1621 # deltas based on a censored revision must replace the |
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1622 # full content in one patch, so delta works everywhere |
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1623 header = mdiff.replacediffheader(self.rawsize(rev), len(t)) |
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1624 delta = header + t |
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1625 else: |
26379
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1626 if self._inline: |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1627 fh = ifh |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1628 else: |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1629 fh = dfh |
39d643252b9f
revlog: use existing file handle when reading during _addrevision
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26378
diff
changeset
|
1630 ptext = self.revision(self.node(rev), _df=fh) |
24123
eb2d41c6ec37
revlog: _addrevision creates full-replace deltas based on censored revisions
Mike Edgar <adgar@google.com>
parents:
24122
diff
changeset
|
1631 delta = mdiff.textdiff(ptext, t) |
30011
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1632 header, data = self.compress(delta) |
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1633 deltalen = len(header) + len(data) |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
1634 chainbase = self.chainbase(rev) |
30011
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1635 dist = deltalen + offset - self.start(chainbase) |
14270
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14253
diff
changeset
|
1636 if self._generaldelta: |
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14253
diff
changeset
|
1637 base = rev |
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14253
diff
changeset
|
1638 else: |
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14253
diff
changeset
|
1639 base = chainbase |
23287
426d7f901789
revlog: bound based on the length of the compressed deltas
Siddharth Agarwal <sid0@fb.com>
parents:
23286
diff
changeset
|
1640 chainlen, compresseddeltalen = self._chaininfo(rev) |
426d7f901789
revlog: bound based on the length of the compressed deltas
Siddharth Agarwal <sid0@fb.com>
parents:
23286
diff
changeset
|
1641 chainlen += 1 |
30011
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1642 compresseddeltalen += deltalen |
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1643 return (dist, deltalen, (header, data), base, |
d81fe5af92b8
revlog: make code in builddelta() slightly easier to read
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29997
diff
changeset
|
1644 chainbase, chainlen, compresseddeltalen) |
12888
ad01fe38afe6
revlog: extract delta building to a subfunction
Matt Mackall <mpm@selenic.com>
parents:
12887
diff
changeset
|
1645 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1646 curr = len(self) |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1647 prev = curr - 1 |
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1648 offset = self.end(prev) |
27178
5ebc4a192550
addrevision: rename 'd' to 'delta'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27070
diff
changeset
|
1649 delta = None |
12889
5482c6b826f4
revlog: precalculate p1 and p2 revisions
Matt Mackall <mpm@selenic.com>
parents:
12888
diff
changeset
|
1650 p1r, p2r = self.rev(p1), self.rev(p2) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1651 |
26116
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1652 # full versions are inserted when the needed deltas |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1653 # become comparable to the uncompressed text |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1654 if text is None: |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1655 textlen = mdiff.patchedsize(self.rawsize(cachedelta[0]), |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1656 cachedelta[1]) |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1657 else: |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1658 textlen = len(text) |
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
1659 |
11963
7c3aa579d98a
parendelta: fix computation of base rev (fixes issue2337)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
11962
diff
changeset
|
1660 # should we try to build a delta? |
30210
5e4f16874a9f
revlog: make 'storedeltachains' a "public" attribute
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30154
diff
changeset
|
1661 if prev != nullrev and self.storedeltachains: |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1662 tested = set() |
30012
60a66c79125f
revlog: document high frequency of code execution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30011
diff
changeset
|
1663 # This condition is true most of the time when processing |
60a66c79125f
revlog: document high frequency of code execution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30011
diff
changeset
|
1664 # changegroup data into a generaldelta repo. The only time it |
60a66c79125f
revlog: document high frequency of code execution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30011
diff
changeset
|
1665 # isn't true is if this is the first revision in a delta chain |
60a66c79125f
revlog: document high frequency of code execution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30011
diff
changeset
|
1666 # or if ``format.generaldelta=true`` disabled ``lazydeltabase``. |
26907
dfab6edb98e3
format: introduce 'format.usegeneraldelta`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26705
diff
changeset
|
1667 if cachedelta and self._generaldelta and self._lazydeltabase: |
dfab6edb98e3
format: introduce 'format.usegeneraldelta`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26705
diff
changeset
|
1668 # Assume what we received from the server is a good choice |
dfab6edb98e3
format: introduce 'format.usegeneraldelta`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26705
diff
changeset
|
1669 # build delta will reuse the cache |
27180
8e7db961535a
addrevision: only use the incoming base if it is a good delta (issue4975)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27179
diff
changeset
|
1670 candidatedelta = builddelta(cachedelta[0]) |
27249
0e5aab543d85
revlog: clarify which revision is added to 'tested' when using cached delta
Martin von Zweigbergk <martinvonz@google.com>
parents:
27248
diff
changeset
|
1671 tested.add(cachedelta[0]) |
27180
8e7db961535a
addrevision: only use the incoming base if it is a good delta (issue4975)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27179
diff
changeset
|
1672 if self._isgooddelta(candidatedelta, textlen): |
8e7db961535a
addrevision: only use the incoming base if it is a good delta (issue4975)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27179
diff
changeset
|
1673 delta = candidatedelta |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1674 if delta is None and self._generaldelta: |
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1675 # exclude already lazy tested base if any |
27251
d9bfe6289acf
revlog: don't consider nullrev when choosing delta base
Martin von Zweigbergk <martinvonz@google.com>
parents:
27250
diff
changeset
|
1676 parents = [p for p in (p1r, p2r) |
d9bfe6289acf
revlog: don't consider nullrev when choosing delta base
Martin von Zweigbergk <martinvonz@google.com>
parents:
27250
diff
changeset
|
1677 if p != nullrev and p not in tested] |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1678 if parents and not self._aggressivemergedeltas: |
26118
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
1679 # Pick whichever parent is closer to us (to minimize the |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1680 # chance of having to build a fulltext). |
27189
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1681 parents = [max(parents)] |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1682 tested.update(parents) |
27189
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1683 pdeltas = [] |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1684 for p in parents: |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1685 pd = builddelta(p) |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1686 if self._isgooddelta(pd, textlen): |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1687 pdeltas.append(pd) |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1688 if pdeltas: |
7b6cb7c15109
addrevision: rework generaldelta computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27180
diff
changeset
|
1689 delta = min(pdeltas, key=lambda x: x[1]) |
27191
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1690 if delta is None and prev not in tested: |
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1691 # other approach failed try against prev to hopefully save us a |
20a9226bdc8a
addrevision: use general delta when the incoming base delta is bad
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27189
diff
changeset
|
1692 # fulltext. |
27250
bff71fe05768
revlog: make calls to _isgooddelta() consistent
Martin von Zweigbergk <martinvonz@google.com>
parents:
27249
diff
changeset
|
1693 candidatedelta = builddelta(prev) |
bff71fe05768
revlog: make calls to _isgooddelta() consistent
Martin von Zweigbergk <martinvonz@google.com>
parents:
27249
diff
changeset
|
1694 if self._isgooddelta(candidatedelta, textlen): |
bff71fe05768
revlog: make calls to _isgooddelta() consistent
Martin von Zweigbergk <martinvonz@google.com>
parents:
27249
diff
changeset
|
1695 delta = candidatedelta |
27179
b481bf14992d
addrevision: handle code path not producing delta
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27178
diff
changeset
|
1696 if delta is not None: |
27178
5ebc4a192550
addrevision: rename 'd' to 'delta'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
27070
diff
changeset
|
1697 dist, l, data, base, chainbase, chainlen, compresseddeltalen = delta |
27250
bff71fe05768
revlog: make calls to _isgooddelta() consistent
Martin von Zweigbergk <martinvonz@google.com>
parents:
27249
diff
changeset
|
1698 else: |
12886
c25945a148c1
revlog: fix buildtext local scope
Matt Mackall <mpm@selenic.com>
parents:
12624
diff
changeset
|
1699 text = buildtext() |
17128
1028a1c9077a
revlog: make compress a method
Bryan O'Sullivan <bryano@fb.com>
parents:
17009
diff
changeset
|
1700 data = self.compress(text) |
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
1701 l = len(data[1]) + len(data[0]) |
14296
62e25c63fb3a
revlog: fix bug in chainbase cache
Sune Foldager <cryo@cyanite.org>
parents:
14292
diff
changeset
|
1702 base = chainbase = curr |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1703 |
12623
8f97b50a8d10
revlog._addrevision(): allow text argument to be None, build it lazily
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12336
diff
changeset
|
1704 e = (offset_type(offset, flags), l, textlen, |
12889
5482c6b826f4
revlog: precalculate p1 and p2 revisions
Matt Mackall <mpm@selenic.com>
parents:
12888
diff
changeset
|
1705 base, link, p1r, p2r, node) |
4979
06abdaf78788
revlog: add a magic null revision to our index
Matt Mackall <mpm@selenic.com>
parents:
4978
diff
changeset
|
1706 self.index.insert(-1, e) |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1707 self.nodemap[node] = curr |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
1708 |
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
1709 entry = self._io.packentry(e, self.node, self.version, curr) |
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1710 self._writeentry(transaction, ifh, dfh, entry, data, link, offset) |
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1711 |
26243
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1712 if alwayscache and text is None: |
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1713 text = buildtext() |
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1714 |
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1715 if type(text) == str: # only accept immutable objects |
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1716 self._cache = (node, curr, text) |
29830
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29829
diff
changeset
|
1717 self._chainbasecache[curr] = chainbase |
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1718 return node |
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1719 |
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1720 def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset): |
27430
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1721 # Files opened in a+ mode have inconsistent behavior on various |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1722 # platforms. Windows requires that a file positioning call be made |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1723 # when the file handle transitions between reads and writes. See |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1724 # 3686fa2b8eee and the mixedfilemodewrapper in windows.py. On other |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1725 # platforms, Python or the platform itself can be buggy. Some versions |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1726 # of Solaris have been observed to not append at the end of the file |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1727 # if the file was seeked to before the end. See issue4943 for more. |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1728 # |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1729 # We work around this issue by inserting a seek() before writing. |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1730 # Note: This is likely not necessary on Python 3. |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1731 ifh.seek(0, os.SEEK_END) |
27441
e47841c8343d
revlog: fix bad indentation (replace tab by space)
Martin von Zweigbergk <martinvonz@google.com>
parents:
27430
diff
changeset
|
1732 if dfh: |
27430
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1733 dfh.seek(0, os.SEEK_END) |
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
1734 |
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
1735 curr = len(self) - 1 |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1736 if not self._inline: |
2073 | 1737 transaction.add(self.datafile, offset) |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1738 transaction.add(self.indexfile, curr * len(entry)) |
2073 | 1739 if data[0]: |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1740 dfh.write(data[0]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1741 dfh.write(data[1]) |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1742 ifh.write(entry) |
2073 | 1743 else: |
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
1744 offset += curr * self._io.size |
5324
8409a2e3a78d
revlog: fix inlined revision transaction extra data (issue 749)
Patrick Mezard <pmezard@gmail.com>
parents:
5007
diff
changeset
|
1745 transaction.add(self.indexfile, offset, curr) |
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1746 ifh.write(entry) |
3390
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1747 ifh.write(data[0]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1748 ifh.write(data[1]) |
a74addddd092
make revlog.addgroup pass its file handles to addrevision
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3360
diff
changeset
|
1749 self.checkinlinesize(transaction, ifh) |
2073 | 1750 |
26705
2f5c45fe3a3b
revlog: rename bundle to cg to reflect its nature as a cg?unpacker
Augie Fackler <augie@google.com>
parents:
26380
diff
changeset
|
1751 def addgroup(self, cg, linkmapper, transaction, addrevisioncb=None): |
1083 | 1752 """ |
1753 add a delta group | |
46 | 1754 |
1083 | 1755 given a set of deltas, add them to the revision log. the |
1756 first delta is against its parent, which should be in our | |
1757 log, the rest are against the previous delta. | |
25822
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1758 |
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1759 If ``addrevisioncb`` is defined, it will be called with arguments of |
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1760 this revlog and the node that was added. |
1083 | 1761 """ |
1762 | |
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1763 # track the base of the current delta log |
15890
e234eda20984
revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15835
diff
changeset
|
1764 content = [] |
2002
4aab906517c6
Calling revlog.addgroup with an empty changegroup now raises RevlogError.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1981
diff
changeset
|
1765 node = None |
515 | 1766 |
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1767 r = len(self) |
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1768 end = 0 |
46 | 1769 if r: |
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1770 end = self.end(r - 1) |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1771 ifh = self.opener(self.indexfile, "a+", checkambig=self._checkambig) |
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
1772 isize = r * self._io.size |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1773 if self._inline: |
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
1774 transaction.add(self.indexfile, end + isize, r) |
2073 | 1775 dfh = None |
1776 else: | |
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
1777 transaction.add(self.indexfile, isize, r) |
2073 | 1778 transaction.add(self.datafile, end) |
26378
e749707f0afb
revlog: always open revlogs for reading and appending
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26377
diff
changeset
|
1779 dfh = self.opener(self.datafile, "a+") |
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1780 def flush(): |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1781 if dfh: |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1782 dfh.flush() |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1783 ifh.flush() |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1784 try: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1785 # loop through our set of deltas |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1786 chain = None |
29732
0806fa2a39d8
revlog: use `iter(callable, sentinel)` instead of while True
Augie Fackler <augie@google.com>
parents:
29396
diff
changeset
|
1787 for chunkdata in iter(lambda: cg.deltachunk(chain), {}): |
12336
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
1788 node = chunkdata['node'] |
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
1789 p1 = chunkdata['p1'] |
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
1790 p2 = chunkdata['p2'] |
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
1791 cs = chunkdata['cs'] |
14141
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1792 deltabase = chunkdata['deltabase'] |
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1793 delta = chunkdata['delta'] |
27433
12f727a5b434
changegroup: add flags field to cg3 delta header
Mike Edgar <adgar@google.com>
parents:
27431
diff
changeset
|
1794 flags = chunkdata['flags'] or REVIDX_DEFAULT_FLAGS |
12336
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
1795 |
15890
e234eda20984
revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15835
diff
changeset
|
1796 content.append(node) |
e234eda20984
revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15835
diff
changeset
|
1797 |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1798 link = linkmapper(cs) |
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
1799 if node in self.nodemap: |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1800 # this can happen if two branches make the same change |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1801 chain = node |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1802 continue |
192 | 1803 |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1804 for p in (p1, p2): |
16686
67964cda8701
cleanup: "not x in y" -> "x not in y"
Brodie Rao <brodie@sf.io>
parents:
16665
diff
changeset
|
1805 if p not in self.nodemap: |
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
1806 raise LookupError(p, self.indexfile, |
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
1807 _('unknown parent')) |
46 | 1808 |
14141
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1809 if deltabase not in self.nodemap: |
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1810 raise LookupError(deltabase, self.indexfile, |
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1811 _('unknown delta base')) |
46 | 1812 |
14141
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
1813 baserev = self.rev(deltabase) |
24120
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1814 |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1815 if baserev != nullrev and self.iscensored(baserev): |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1816 # if base is censored, delta must be full replacement in a |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1817 # single patch operation |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1818 hlen = struct.calcsize(">lll") |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1819 oldlen = self.rawsize(baserev) |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1820 newlen = len(delta) - hlen |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1821 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen): |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1822 raise error.CensoredBaseError(self.indexfile, |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1823 self.node(baserev)) |
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
1824 |
27433
12f727a5b434
changegroup: add flags field to cg3 delta header
Mike Edgar <adgar@google.com>
parents:
27431
diff
changeset
|
1825 if not flags and self._peek_iscensored(baserev, delta, flush): |
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1826 flags |= REVIDX_ISCENSORED |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1827 |
26243
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1828 # We assume consumers of addrevisioncb will want to retrieve |
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1829 # the added revision, which will require a call to |
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1830 # revision(). revision() will fast path if there is a cache |
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1831 # hit. So, we tell _addrevision() to always cache in this case. |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1832 # We're only using addgroup() in the context of changegroup |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1833 # generation so the revision data can always be handled as raw |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1834 # by the flagprocessor. |
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1835 chain = self._addrevision(node, None, transaction, link, |
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1836 p1, p2, flags, (baserev, delta), |
26243
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
1837 ifh, dfh, |
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1838 alwayscache=bool(addrevisioncb), |
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30584
diff
changeset
|
1839 raw=True) |
25822
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1840 |
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1841 if addrevisioncb: |
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1842 addrevisioncb(self, chain) |
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
1843 |
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1844 if not dfh and not self._inline: |
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1845 # addrevision switched from inline to conventional |
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
1846 # reopen the index |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
1847 ifh.close() |
26378
e749707f0afb
revlog: always open revlogs for reading and appending
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26377
diff
changeset
|
1848 dfh = self.opener(self.datafile, "a+") |
29997
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1849 ifh = self.opener(self.indexfile, "a+", |
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29830
diff
changeset
|
1850 checkambig=self._checkambig) |
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1851 finally: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1852 if dfh: |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1853 dfh.close() |
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1854 ifh.close() |
46 | 1855 |
15890
e234eda20984
revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15835
diff
changeset
|
1856 return content |
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1857 |
24118
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
1858 def iscensored(self, rev): |
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
1859 """Check if a file revision is censored.""" |
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
1860 return False |
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
1861 |
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1862 def _peek_iscensored(self, baserev, delta, flush): |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1863 """Quickly check if a delta produces a censored revision.""" |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1864 return False |
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
1865 |
20074
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1866 def getstrippoint(self, minlink): |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1867 """find the minimum rev that must be stripped to strip the linkrev |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1868 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1869 Returns a tuple containing the minimum rev and a set of all revs that |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1870 have linkrevs that will be broken by this strip. |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1871 """ |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1872 brokenrevs = set() |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1873 strippoint = len(self) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1874 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1875 heads = {} |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1876 futurelargelinkrevs = set() |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1877 for head in self.headrevs(): |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1878 headlinkrev = self.linkrev(head) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1879 heads[head] = headlinkrev |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1880 if headlinkrev >= minlink: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1881 futurelargelinkrevs.add(headlinkrev) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1882 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1883 # This algorithm involves walking down the rev graph, starting at the |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1884 # heads. Since the revs are topologically sorted according to linkrev, |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1885 # once all head linkrevs are below the minlink, we know there are |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1886 # no more revs that could have a linkrev greater than minlink. |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1887 # So we can stop walking. |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1888 while futurelargelinkrevs: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1889 strippoint -= 1 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1890 linkrev = heads.pop(strippoint) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1891 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1892 if linkrev < minlink: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1893 brokenrevs.add(strippoint) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1894 else: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1895 futurelargelinkrevs.remove(linkrev) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1896 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1897 for p in self.parentrevs(strippoint): |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1898 if p != nullrev: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1899 plinkrev = self.linkrev(p) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1900 heads[p] = plinkrev |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1901 if plinkrev >= minlink: |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1902 futurelargelinkrevs.add(plinkrev) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1903 |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1904 return strippoint, brokenrevs |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1905 |
8073
e8a28556a0a8
strip: make repair.strip transactional to avoid repository corruption
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
8017
diff
changeset
|
1906 def strip(self, minlink, transaction): |
5910
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1907 """truncate the revlog on the first revision with a linkrev >= minlink |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1908 |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1909 This function is called when we're stripping revision minlink and |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1910 its descendants from the repository. |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1911 |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1912 We have to remove all revisions with linkrev >= minlink, because |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1913 the equivalent changelog revisions will be renumbered after the |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1914 strip. |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1915 |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1916 So we truncate the revlog on the first of these revisions, and |
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1917 trust that the caller has saved the revisions that shouldn't be |
15827
1dacf7672556
revlog: clarify strip docstring "readd" -> "re-add"
Steven Brown <StevenGBrown@gmail.com>
parents:
15407
diff
changeset
|
1918 removed and that it'll re-add them after this truncation. |
5910
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
1919 """ |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1920 if len(self) == 0: |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1921 return |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1922 |
20074
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1923 rev, _ = self.getstrippoint(minlink) |
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
1924 if rev == len(self): |
5909
f45f7390c1c5
strip: calculate list of extra nodes to save and pass it to changegroupsubset
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5659
diff
changeset
|
1925 return |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1926 |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1927 # first truncate the files on disk |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1928 end = self.start(rev) |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1929 if not self._inline: |
8073
e8a28556a0a8
strip: make repair.strip transactional to avoid repository corruption
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
8017
diff
changeset
|
1930 transaction.add(self.datafile, end) |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
1931 end = rev * self._io.size |
2073 | 1932 else: |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
1933 end += rev * self._io.size |
2072 | 1934 |
8073
e8a28556a0a8
strip: make repair.strip transactional to avoid repository corruption
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
8017
diff
changeset
|
1935 transaction.add(self.indexfile, end) |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1936 |
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1937 # then reset internal state in memory to forget those revisions |
4984 | 1938 self._cache = None |
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
1939 self._chaininfocache = {} |
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1940 self._chunkclear() |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1941 for x in xrange(rev, len(self)): |
2072 | 1942 del self.nodemap[self.node(x)] |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1943 |
4979
06abdaf78788
revlog: add a magic null revision to our index
Matt Mackall <mpm@selenic.com>
parents:
4978
diff
changeset
|
1944 del self.index[rev:-1] |
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
1945 |
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1946 def checksize(self): |
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
1947 expected = 0 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1948 if len(self): |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1949 expected = max(0, self.end(len(self) - 1)) |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1950 |
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1951 try: |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1952 f = self.opener(self.datafile) |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1953 f.seek(0, 2) |
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1954 actual = f.tell() |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
1955 f.close() |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1956 dd = actual - expected |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25459
diff
changeset
|
1957 except IOError as inst: |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1958 if inst.errno != errno.ENOENT: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1959 raise |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1960 dd = 0 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1961 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1962 try: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1963 f = self.opener(self.indexfile) |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1964 f.seek(0, 2) |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1965 actual = f.tell() |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
1966 f.close() |
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
1967 s = self._io.size |
9029
0001e49f1c11
compat: use // for integer division
Alejandro Santos <alejolp@alejolp.com>
parents:
8658
diff
changeset
|
1968 i = max(0, actual // s) |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1969 di = actual - (i * s) |
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1970 if self._inline: |
2073 | 1971 databytes = 0 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1972 for r in self: |
5312
fb070713ff36
revlog: more robust for damaged indexes
Matt Mackall <mpm@selenic.com>
parents:
5007
diff
changeset
|
1973 databytes += max(0, self.length(r)) |
2073 | 1974 dd = 0 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1975 di = actual - len(self) * s - databytes |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25459
diff
changeset
|
1976 except IOError as inst: |
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1977 if inst.errno != errno.ENOENT: |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1978 raise |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1979 di = 0 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1980 |
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
1981 return (dd, di) |
6891
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
1982 |
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
1983 def files(self): |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
1984 res = [self.indexfile] |
6891
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
1985 if not self._inline: |
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
1986 res.append(self.datafile) |
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
1987 return res |
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1988 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1989 DELTAREUSEALWAYS = 'always' |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1990 DELTAREUSESAMEREVS = 'samerevs' |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1991 DELTAREUSENEVER = 'never' |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1992 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1993 DELTAREUSEALL = set(['always', 'samerevs', 'never']) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1994 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1995 def clone(self, tr, destrevlog, addrevisioncb=None, |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1996 deltareuse=DELTAREUSESAMEREVS, aggressivemergedeltas=None): |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1997 """Copy this revlog to another, possibly with format changes. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1998 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
1999 The destination revlog will contain the same revisions and nodes. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2000 However, it may not be bit-for-bit identical due to e.g. delta encoding |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2001 differences. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2002 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2003 The ``deltareuse`` argument control how deltas from the existing revlog |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2004 are preserved in the destination revlog. The argument can have the |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2005 following values: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2006 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2007 DELTAREUSEALWAYS |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2008 Deltas will always be reused (if possible), even if the destination |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2009 revlog would not select the same revisions for the delta. This is the |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2010 fastest mode of operation. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2011 DELTAREUSESAMEREVS |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2012 Deltas will be reused if the destination revlog would pick the same |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2013 revisions for the delta. This mode strikes a balance between speed |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2014 and optimization. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2015 DELTAREUSENEVER |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2016 Deltas will never be reused. This is the slowest mode of execution. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2017 This mode can be used to recompute deltas (e.g. if the diff/delta |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2018 algorithm changes). |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2019 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2020 Delta computation can be slow, so the choice of delta reuse policy can |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2021 significantly affect run time. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2022 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2023 The default policy (``DELTAREUSESAMEREVS``) strikes a balance between |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2024 two extremes. Deltas will be reused if they are appropriate. But if the |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2025 delta could choose a better revision, it will do so. This means if you |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2026 are converting a non-generaldelta revlog to a generaldelta revlog, |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2027 deltas will be recomputed if the delta's parent isn't a parent of the |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2028 revision. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2029 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2030 In addition to the delta policy, the ``aggressivemergedeltas`` argument |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2031 controls whether to compute deltas against both parents for merges. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2032 By default, the current default is used. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2033 """ |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2034 if deltareuse not in self.DELTAREUSEALL: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2035 raise ValueError(_('value for deltareuse invalid: %s') % deltareuse) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2036 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2037 if len(destrevlog): |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2038 raise ValueError(_('destination revlog is not empty')) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2039 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2040 if getattr(self, 'filteredrevs', None): |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2041 raise ValueError(_('source revlog has filtered revisions')) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2042 if getattr(destrevlog, 'filteredrevs', None): |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2043 raise ValueError(_('destination revlog has filtered revisions')) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2044 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2045 # lazydeltabase controls whether to reuse a cached delta, if possible. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2046 oldlazydeltabase = destrevlog._lazydeltabase |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2047 oldamd = destrevlog._aggressivemergedeltas |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2048 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2049 try: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2050 if deltareuse == self.DELTAREUSEALWAYS: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2051 destrevlog._lazydeltabase = True |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2052 elif deltareuse == self.DELTAREUSESAMEREVS: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2053 destrevlog._lazydeltabase = False |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2054 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2055 destrevlog._aggressivemergedeltas = aggressivemergedeltas or oldamd |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2056 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2057 populatecachedelta = deltareuse in (self.DELTAREUSEALWAYS, |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2058 self.DELTAREUSESAMEREVS) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2059 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2060 index = self.index |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2061 for rev in self: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2062 entry = index[rev] |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2063 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2064 # Some classes override linkrev to take filtered revs into |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2065 # account. Use raw entry from index. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2066 flags = entry[0] & 0xffff |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2067 linkrev = entry[4] |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2068 p1 = index[entry[5]][7] |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2069 p2 = index[entry[6]][7] |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2070 node = entry[7] |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2071 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2072 # (Possibly) reuse the delta from the revlog if allowed and |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2073 # the revlog chunk is a delta. |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2074 cachedelta = None |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2075 text = None |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2076 if populatecachedelta: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2077 dp = self.deltaparent(rev) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2078 if dp != nullrev: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2079 cachedelta = (dp, str(self._chunk(rev))) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2080 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2081 if not cachedelta: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2082 text = self.revision(rev) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2083 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2084 ifh = destrevlog.opener(destrevlog.indexfile, 'a+', |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2085 checkambig=False) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2086 dfh = None |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2087 if not destrevlog._inline: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2088 dfh = destrevlog.opener(destrevlog.datafile, 'a+') |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2089 try: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2090 destrevlog._addrevision(node, text, tr, linkrev, p1, p2, |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2091 flags, cachedelta, ifh, dfh) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2092 finally: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2093 if dfh: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2094 dfh.close() |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2095 ifh.close() |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2096 |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2097 if addrevisioncb: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2098 addrevisioncb(self, rev, node) |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2099 finally: |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2100 destrevlog._lazydeltabase = oldlazydeltabase |
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2101 destrevlog._aggressivemergedeltas = oldamd |