Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/revlog.py @ 37442:0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
filelog.parsemeta() and filelog.packmeta() are used to decode
and encode metadata for file copies and censor.
An upcoming commit will move the core logic for censoring revlogs
into revlog.py. This would create a cycle between revlog.py and
filelog.py. So we move these metadata functions to revlog.py.
.. api::
filelog.parsemeta() and filelog.packmeta() have been moved to
the revlog module.
Differential Revision: https://phab.mercurial-scm.org/D3150
| author | Gregory Szorc <gregory.szorc@gmail.com> |
|---|---|
| date | Thu, 05 Apr 2018 18:22:35 -0700 |
| parents | f0b6fbea00cf |
| children | 65250a66b55c |
| 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 |
|
36012
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
17 import contextlib |
|
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
18 import errno |
|
29339
a9e010cd66e1
revlog: use hashlib.sha1 directly instead of through util
Augie Fackler <raf@durin42.com>
parents:
27650
diff
changeset
|
19 import hashlib |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
20 import heapq |
|
27430
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
21 import os |
|
37442
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
22 import re |
|
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
23 import struct |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
24 import zlib |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
25 |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
26 # 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
|
27 from .node import ( |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
28 bin, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
29 hex, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
30 nullid, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
31 nullrev, |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
32 wdirhex, |
|
32679
7b17f9de6d3e
revlog: map rev(wdirid) to WdirUnsupported exception
Yuya Nishihara <yuya@tcha.org>
parents:
32481
diff
changeset
|
33 wdirid, |
|
32441
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
34 wdirrev, |
|
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
35 ) |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
36 from .i18n import _ |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
37 from .thirdparty import ( |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
38 attr, |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
39 ) |
|
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
40 from . import ( |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
41 ancestor, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
42 error, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
43 mdiff, |
|
32411
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32355
diff
changeset
|
44 policy, |
|
31580
a8e55d6f1d67
revlog: use pycompat.maplist to eagerly evaluate map on Python 3
Augie Fackler <augie@google.com>
parents:
31511
diff
changeset
|
45 pycompat, |
|
27361
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
46 templatefilters, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
47 util, |
|
29f50344fa83
revlog: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27251
diff
changeset
|
48 ) |
|
37087
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36768
diff
changeset
|
49 from .utils import ( |
|
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36768
diff
changeset
|
50 stringutil, |
|
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36768
diff
changeset
|
51 ) |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
52 |
|
32411
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32355
diff
changeset
|
53 parsers = policy.importmod(r'parsers') |
|
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32355
diff
changeset
|
54 |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
55 # Aliased for performance. |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
56 _zlibdecompress = zlib.decompress |
|
5007
3addf4531643
revlog: localize some fastpath functions
Matt Mackall <mpm@selenic.com>
parents:
5006
diff
changeset
|
57 |
|
11746
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
58 # revlog header flags |
| 2072 | 59 REVLOGV0 = 0 |
|
32355
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
60 REVLOGV1 = 1 |
|
32717
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
61 # Dummy value until file format is finalized. |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
62 # Reminder: change the bounds check in revlog.__init__ when this is changed. |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
63 REVLOGV2 = 0xDEAD |
|
32355
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
64 FLAG_INLINE_DATA = (1 << 16) |
|
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
65 FLAG_GENERALDELTA = (1 << 17) |
|
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
66 REVLOG_DEFAULT_FLAGS = FLAG_INLINE_DATA |
|
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
67 REVLOG_DEFAULT_FORMAT = REVLOGV1 |
|
2222
c9e264b115e6
Use revlogng and inlined data files by default
mason@suse.com
parents:
2177
diff
changeset
|
68 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS |
|
32355
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
69 REVLOGV1_FLAGS = FLAG_INLINE_DATA | FLAG_GENERALDELTA |
|
32717
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
70 REVLOGV2_FLAGS = REVLOGV1_FLAGS |
|
11746
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
71 |
|
46ac30b17978
revlog: add shallow header flag
Vishakh H <vsh426@gmail.com>
parents:
11745
diff
changeset
|
72 # revlog index flags |
|
23855
4f23081c901e
revlog: define censored flag for revlogng index
Mike Edgar <adgar@google.com>
parents:
23338
diff
changeset
|
73 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
|
74 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
|
75 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
|
76 REVIDX_DEFAULT_FLAGS = 0 |
| 30745 | 77 # stable order in which flags need to be processed and their processors applied |
| 78 REVIDX_FLAGS_ORDER = [ | |
| 79 REVIDX_ISCENSORED, | |
|
30829
08b34c3a6f74
revlog: give EXTSTORED flag value to narrowhg
Martin von Zweigbergk <martinvonz@google.com>
parents:
30818
diff
changeset
|
80 REVIDX_ELLIPSIS, |
|
30746
9cb0bb0f29f0
revlog: REVIDX_EXTSTORED flag
Remi Chaintron <remi@fb.com>
parents:
30745
diff
changeset
|
81 REVIDX_EXTSTORED, |
| 30745 | 82 ] |
| 83 REVIDX_KNOWN_FLAGS = util.bitsfrom(REVIDX_FLAGS_ORDER) | |
|
35839
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
84 # bitmark for flags that could cause rawdata content change |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
85 REVIDX_RAWTEXT_CHANGING_FLAGS = REVIDX_ISCENSORED | REVIDX_EXTSTORED |
| 2073 | 86 |
|
10916
9c84395a338e
add documentation for revlog._prereadsize
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10914
diff
changeset
|
87 # max size of revlog with inline data |
|
9c84395a338e
add documentation for revlog._prereadsize
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10914
diff
changeset
|
88 _maxinline = 131072 |
| 13253 | 89 _chunksize = 1048576 |
|
10913
f2ecc5733c89
revlog: factor out _maxinline global.
Greg Ward <greg-hg@gerg.ca>
parents:
10404
diff
changeset
|
90 |
| 7633 | 91 RevlogError = error.RevlogError |
| 92 LookupError = error.LookupError | |
|
22934
8a096d4d0862
revlog: support importing censored file revision tombstones
Mike Edgar <adgar@google.com>
parents:
22785
diff
changeset
|
93 CensoredNodeError = error.CensoredNodeError |
| 30745 | 94 ProgrammingError = error.ProgrammingError |
| 95 | |
| 96 # Store flag processors (cf. 'addflagprocessor()' to register) | |
| 97 _flagprocessors = { | |
| 98 REVIDX_ISCENSORED: None, | |
| 99 } | |
| 100 | |
|
37442
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
101 _mdre = re.compile('\1\n') |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
102 def parsemeta(text): |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
103 """return (metadatadict, metadatasize)""" |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
104 # text can be buffer, so we can't use .startswith or .index |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
105 if text[:2] != '\1\n': |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
106 return None, None |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
107 s = _mdre.search(text, 2).start() |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
108 mtext = text[2:s] |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
109 meta = {} |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
110 for l in mtext.splitlines(): |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
111 k, v = l.split(": ", 1) |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
112 meta[k] = v |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
113 return meta, (s + 2) |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
114 |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
115 def packmeta(meta, text): |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
116 keys = sorted(meta) |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
117 metatext = "".join("%s: %s\n" % (k, meta[k]) for k in keys) |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
118 return "\1\n%s\1\n%s" % (metatext, text) |
|
0596d27457c6
revlog: move parsemeta() and packmeta() from filelog (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37087
diff
changeset
|
119 |
| 30745 | 120 def addflagprocessor(flag, processor): |
| 121 """Register a flag processor on a revision data flag. | |
| 122 | |
| 123 Invariant: | |
|
35839
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
124 - Flags need to be defined in REVIDX_KNOWN_FLAGS and REVIDX_FLAGS_ORDER, |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
125 and REVIDX_RAWTEXT_CHANGING_FLAGS if they can alter rawtext. |
| 30745 | 126 - Only one flag processor can be registered on a specific flag. |
| 127 - flagprocessors must be 3-tuples of functions (read, write, raw) with the | |
| 128 following signatures: | |
|
31754
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
129 - (read) f(self, rawtext) -> text, bool |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
130 - (write) f(self, text) -> rawtext, bool |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
131 - (raw) f(self, rawtext) -> bool |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
132 "text" is presented to the user. "rawtext" is stored in revlog data, not |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
133 directly visible to the user. |
| 30745 | 134 The boolean returned by these transforms is used to determine whether |
|
31754
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
135 the returned text can be used for hash integrity checking. For example, |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
136 if "write" returns False, then "text" is used to generate hash. If |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
137 "write" returns True, that basically means "rawtext" returned by "write" |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
138 should be used to generate hash. Usually, "write" and "read" return |
|
17d0dab7b2b6
revlog: clarify flagprocessor documentation
Jun Wu <quark@fb.com>
parents:
31727
diff
changeset
|
139 different booleans. And "raw" returns a same boolean as "write". |
| 30745 | 140 |
| 141 Note: The 'raw' transform is used for changegroup generation and in some | |
| 142 debug commands. In this case the transform only indicates whether the | |
| 143 contents can be used for hash integrity checks. | |
| 144 """ | |
| 145 if not flag & REVIDX_KNOWN_FLAGS: | |
| 146 msg = _("cannot register processor on unknown flag '%#x'.") % (flag) | |
| 147 raise ProgrammingError(msg) | |
| 148 if flag not in REVIDX_FLAGS_ORDER: | |
| 149 msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % (flag) | |
| 150 raise ProgrammingError(msg) | |
| 151 if flag in _flagprocessors: | |
| 152 msg = _("cannot register multiple processors on flag '%#x'.") % (flag) | |
| 153 raise error.Abort(msg) | |
| 154 _flagprocessors[flag] = processor | |
|
6703
bacfee67c1a9
LookupError should have same __str__ as RevlogError
Alexander Solovyov <piranha@piranha.org.ua>
parents:
6700
diff
changeset
|
155 |
|
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
156 def getoffset(q): |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
157 return int(q >> 16) |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
158 |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
159 def gettype(q): |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
160 return int(q & 0xFFFF) |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
161 |
|
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
162 def offset_type(offset, type): |
|
30552
03fae9048fa1
revlog: ensure that flags do not overflow 2 bytes
Cotizo Sima <cotizo@fb.com>
parents:
30401
diff
changeset
|
163 if (type & ~REVIDX_KNOWN_FLAGS) != 0: |
|
03fae9048fa1
revlog: ensure that flags do not overflow 2 bytes
Cotizo Sima <cotizo@fb.com>
parents:
30401
diff
changeset
|
164 raise ValueError('unknown revlog index flags') |
|
31511
73aa13bc8dac
revlog: use int instead of long
Augie Fackler <augie@google.com>
parents:
31378
diff
changeset
|
165 return int(int(offset) << 16 | type) |
|
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
166 |
|
29339
a9e010cd66e1
revlog: use hashlib.sha1 directly instead of through util
Augie Fackler <raf@durin42.com>
parents:
27650
diff
changeset
|
167 _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
|
168 |
|
1091
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
169 def hash(text, p1, p2): |
|
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
170 """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
|
171 |
|
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
172 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
|
173 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
|
174 content in the revision graph. |
|
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
175 """ |
|
7883
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
176 # 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
|
177 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
|
178 # 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
|
179 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
|
180 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
|
181 else: |
|
c63c30ae9e39
revlog: faster hash computation when one of the parent node is null
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
7874
diff
changeset
|
182 # none of the parent nodes are nullid |
|
33391
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
183 if p1 < p2: |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
184 a = p1 |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
185 b = p2 |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
186 else: |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
187 a = p2 |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
188 b = p1 |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
189 s = hashlib.sha1(a) |
|
943b8c37f49d
revlog: micro-optimize the computation of hashes
Alex Gaynor <agaynor@mozilla.com>
parents:
33260
diff
changeset
|
190 s.update(b) |
|
1091
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
191 s.update(text) |
|
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
192 return s.digest() |
|
d62130f99a73
Move hash function back to revlog from node
mpm@selenic.com
parents:
1089
diff
changeset
|
193 |
|
34898
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
194 def _trimchunk(revlog, revs, startidx, endidx=None): |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
195 """returns revs[startidx:endidx] without empty trailing revs |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
196 """ |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
197 length = revlog.length |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
198 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
199 if endidx is None: |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
200 endidx = len(revs) |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
201 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
202 # Trim empty revs at the end, but never the very first revision of a chain |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
203 while endidx > 1 and endidx > startidx and length(revs[endidx - 1]) == 0: |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
204 endidx -= 1 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
205 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
206 return revs[startidx:endidx] |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
207 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
208 def _slicechunk(revlog, revs): |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
209 """slice revs to reduce the amount of unrelated data to be read from disk. |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
210 |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
211 ``revs`` is sliced into groups that should be read in one time. |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
212 Assume that revs are sorted. |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
213 """ |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
214 start = revlog.start |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
215 length = revlog.length |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
216 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
217 if len(revs) <= 1: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
218 yield revs |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
219 return |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
220 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
221 startbyte = start(revs[0]) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
222 endbyte = start(revs[-1]) + length(revs[-1]) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
223 readdata = deltachainspan = endbyte - startbyte |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
224 |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
225 chainpayload = sum(length(r) for r in revs) |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
226 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
227 if deltachainspan: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
228 density = chainpayload / float(deltachainspan) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
229 else: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
230 density = 1.0 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
231 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
232 # Store the gaps in a heap to have them sorted by decreasing size |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
233 gapsheap = [] |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
234 heapq.heapify(gapsheap) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
235 prevend = None |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
236 for i, rev in enumerate(revs): |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
237 revstart = start(rev) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
238 revlen = length(rev) |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
239 |
|
34898
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
240 # Skip empty revisions to form larger holes |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
241 if revlen == 0: |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
242 continue |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
243 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
244 if prevend is not None: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
245 gapsize = revstart - prevend |
|
34881
8c9b08a0c48c
sparse-read: skip gaps too small to be worth splitting
Paul Morelle <paul.morelle@octobus.net>
parents:
34880
diff
changeset
|
246 # only consider holes that are large enough |
|
8c9b08a0c48c
sparse-read: skip gaps too small to be worth splitting
Paul Morelle <paul.morelle@octobus.net>
parents:
34880
diff
changeset
|
247 if gapsize > revlog._srmingapsize: |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
248 heapq.heappush(gapsheap, (-gapsize, i)) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
249 |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
250 prevend = revstart + revlen |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
251 |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
252 # Collect the indices of the largest holes until the density is acceptable |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
253 indicesheap = [] |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
254 heapq.heapify(indicesheap) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
255 while gapsheap and density < revlog._srdensitythreshold: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
256 oppgapsize, gapidx = heapq.heappop(gapsheap) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
257 |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
258 heapq.heappush(indicesheap, gapidx) |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
259 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
260 # the gap sizes are stored as negatives to be sorted decreasingly |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
261 # by the heap |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
262 readdata -= (-oppgapsize) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
263 if readdata > 0: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
264 density = chainpayload / float(readdata) |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
265 else: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
266 density = 1.0 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
267 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
268 # Cut the revs at collected indices |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
269 previdx = 0 |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
270 while indicesheap: |
|
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
271 idx = heapq.heappop(indicesheap) |
|
34898
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
272 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
273 chunk = _trimchunk(revlog, revs, previdx, idx) |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
274 if chunk: |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
275 yield chunk |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
276 |
|
34880
9e18ab7f7240
sparse-read: move from a recursive-based approach to a heap-based one
Boris Feld <boris.feld@octobus.net>
parents:
34825
diff
changeset
|
277 previdx = idx |
|
34898
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
278 |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
279 chunk = _trimchunk(revlog, revs, previdx) |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
280 if chunk: |
|
1bde8e8e5de0
sparse-read: ignore trailing empty revs in each read chunk
Paul Morelle <paul.morelle@octobus.net>
parents:
34881
diff
changeset
|
281 yield chunk |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
282 |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
283 @attr.s(slots=True, frozen=True) |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
284 class _deltainfo(object): |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
285 distance = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
286 deltalen = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
287 data = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
288 base = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
289 chainbase = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
290 chainlen = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
291 compresseddeltalen = attr.ib() |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
292 |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
293 class _deltacomputer(object): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
294 def __init__(self, revlog): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
295 self.revlog = revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
296 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
297 def _getcandidaterevs(self, p1, p2, cachedelta): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
298 """ |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
299 Provides revisions that present an interest to be diffed against, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
300 grouped by level of easiness. |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
301 """ |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
302 revlog = self.revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
303 curr = len(revlog) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
304 prev = curr - 1 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
305 p1r, p2r = revlog.rev(p1), revlog.rev(p2) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
306 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
307 # should we try to build a delta? |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
308 if prev != nullrev and revlog.storedeltachains: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
309 tested = set() |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
310 # This condition is true most of the time when processing |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
311 # changegroup data into a generaldelta repo. The only time it |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
312 # isn't true is if this is the first revision in a delta chain |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
313 # or if ``format.generaldelta=true`` disabled ``lazydeltabase``. |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
314 if cachedelta and revlog._generaldelta and revlog._lazydeltabase: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
315 # Assume what we received from the server is a good choice |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
316 # build delta will reuse the cache |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
317 yield (cachedelta[0],) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
318 tested.add(cachedelta[0]) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
319 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
320 if revlog._generaldelta: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
321 # exclude already lazy tested base if any |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
322 parents = [p for p in (p1r, p2r) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
323 if p != nullrev and p not in tested] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
324 if parents and not revlog._aggressivemergedeltas: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
325 # Pick whichever parent is closer to us (to minimize the |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
326 # chance of having to build a fulltext). |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
327 parents = [max(parents)] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
328 tested.update(parents) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
329 yield parents |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
330 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
331 if prev not in tested: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
332 # other approach failed try against prev to hopefully save us a |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
333 # fulltext. |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
334 yield (prev,) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
335 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
336 def buildtext(self, revinfo, fh): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
337 """Builds a fulltext version of a revision |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
338 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
339 revinfo: _revisioninfo instance that contains all needed info |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
340 fh: file handle to either the .i or the .d revlog file, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
341 depending on whether it is inlined or not |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
342 """ |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
343 btext = revinfo.btext |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
344 if btext[0] is not None: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
345 return btext[0] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
346 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
347 revlog = self.revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
348 cachedelta = revinfo.cachedelta |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
349 flags = revinfo.flags |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
350 node = revinfo.node |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
351 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
352 baserev = cachedelta[0] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
353 delta = cachedelta[1] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
354 # special case deltas which replace entire base; no need to decode |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
355 # base revision. this neatly avoids censored bases, which throw when |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
356 # they're decoded. |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
357 hlen = struct.calcsize(">lll") |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
358 if delta[:hlen] == mdiff.replacediffheader(revlog.rawsize(baserev), |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
359 len(delta) - hlen): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
360 btext[0] = delta[hlen:] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
361 else: |
|
35841
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
362 # deltabase is rawtext before changed by flag processors, which is |
|
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
363 # equivalent to non-raw text |
|
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
364 basetext = revlog.revision(baserev, _df=fh, raw=False) |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
365 btext[0] = mdiff.patch(basetext, delta) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
366 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
367 try: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
368 res = revlog._processflags(btext[0], flags, 'read', raw=True) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
369 btext[0], validatehash = res |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
370 if validatehash: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
371 revlog.checkhash(btext[0], node, p1=revinfo.p1, p2=revinfo.p2) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
372 if flags & REVIDX_ISCENSORED: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
373 raise RevlogError(_('node %s is not censored') % node) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
374 except CensoredNodeError: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
375 # must pass the censored index flag to add censored revisions |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
376 if not flags & REVIDX_ISCENSORED: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
377 raise |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
378 return btext[0] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
379 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
380 def _builddeltadiff(self, base, revinfo, fh): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
381 revlog = self.revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
382 t = self.buildtext(revinfo, fh) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
383 if revlog.iscensored(base): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
384 # deltas based on a censored revision must replace the |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
385 # full content in one patch, so delta works everywhere |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
386 header = mdiff.replacediffheader(revlog.rawsize(base), len(t)) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
387 delta = header + t |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
388 else: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
389 ptext = revlog.revision(base, _df=fh, raw=True) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
390 delta = mdiff.textdiff(ptext, t) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
391 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
392 return delta |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
393 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
394 def _builddeltainfo(self, revinfo, base, fh): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
395 # can we use the cached delta? |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
396 if revinfo.cachedelta and revinfo.cachedelta[0] == base: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
397 delta = revinfo.cachedelta[1] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
398 else: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
399 delta = self._builddeltadiff(base, revinfo, fh) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
400 revlog = self.revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
401 header, data = revlog.compress(delta) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
402 deltalen = len(header) + len(data) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
403 chainbase = revlog.chainbase(base) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
404 offset = revlog.end(len(revlog) - 1) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
405 dist = deltalen + offset - revlog.start(chainbase) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
406 if revlog._generaldelta: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
407 deltabase = base |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
408 else: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
409 deltabase = chainbase |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
410 chainlen, compresseddeltalen = revlog._chaininfo(base) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
411 chainlen += 1 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
412 compresseddeltalen += deltalen |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
413 return _deltainfo(dist, deltalen, (header, data), deltabase, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
414 chainbase, chainlen, compresseddeltalen) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
415 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
416 def finddeltainfo(self, revinfo, fh): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
417 """Find an acceptable delta against a candidate revision |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
418 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
419 revinfo: information about the revision (instance of _revisioninfo) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
420 fh: file handle to either the .i or the .d revlog file, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
421 depending on whether it is inlined or not |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
422 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
423 Returns the first acceptable candidate revision, as ordered by |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
424 _getcandidaterevs |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
425 """ |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
426 cachedelta = revinfo.cachedelta |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
427 p1 = revinfo.p1 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
428 p2 = revinfo.p2 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
429 revlog = self.revlog |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
430 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
431 deltainfo = None |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
432 for candidaterevs in self._getcandidaterevs(p1, p2, cachedelta): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
433 nominateddeltas = [] |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
434 for candidaterev in candidaterevs: |
|
35840
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
435 # no delta for rawtext-changing revs (see "candelta" for why) |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
436 if revlog.flags(candidaterev) & REVIDX_RAWTEXT_CHANGING_FLAGS: |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
437 continue |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
438 candidatedelta = self._builddeltainfo(revinfo, candidaterev, fh) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
439 if revlog._isgooddeltainfo(candidatedelta, revinfo.textlen): |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
440 nominateddeltas.append(candidatedelta) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
441 if nominateddeltas: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
442 deltainfo = min(nominateddeltas, key=lambda x: x.deltalen) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
443 break |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
444 |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
445 return deltainfo |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
446 |
|
35641
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
447 @attr.s(slots=True, frozen=True) |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
448 class _revisioninfo(object): |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
449 """Information about a revision that allows building its fulltext |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
450 node: expected hash of the revision |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
451 p1, p2: parent revs of the revision |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
452 btext: built text cache consisting of a one-element list |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
453 cachedelta: (baserev, uncompressed_delta) or None |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
454 flags: flags associated to the revision storage |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
455 |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
456 One of btext[0] or cachedelta must be set. |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
457 """ |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
458 node = attr.ib() |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
459 p1 = attr.ib() |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
460 p2 = attr.ib() |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
461 btext = attr.ib() |
|
35737
d99b07bc69fb
revlog: refactor out _finddeltainfo from _addrevision
Paul Morelle <paul.morelle@octobus.net>
parents:
35641
diff
changeset
|
462 textlen = attr.ib() |
|
35641
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
463 cachedelta = attr.ib() |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
464 flags = attr.ib() |
|
c41bb85c09ff
revlog: group revision info into a dedicated structure
Paul Morelle <paul.morelle@octobus.net>
parents:
35640
diff
changeset
|
465 |
|
18585
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
466 # index v0: |
|
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
467 # 4 bytes: offset |
|
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
468 # 4 bytes: compressed length |
|
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
469 # 4 bytes: base rev |
|
b280f3bfc8a0
revlog: document v0 format
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18090
diff
changeset
|
470 # 4 bytes: link rev |
|
25891
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
471 # 20 bytes: parent 1 nodeid |
|
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
472 # 20 bytes: parent 2 nodeid |
|
c73fada78589
revlog: correct comment about size of v0 index format
Yuya Nishihara <yuya@tcha.org>
parents:
25822
diff
changeset
|
473 # 20 bytes: nodeid |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
474 indexformatv0 = struct.Struct(">4l20s20s20s") |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
475 indexformatv0_pack = indexformatv0.pack |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
476 indexformatv0_unpack = indexformatv0.unpack |
|
4918
e017d3a82e1d
revlog: raise offset/type helpers to global scope
Matt Mackall <mpm@selenic.com>
parents:
4746
diff
changeset
|
477 |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
478 class revlogoldio(object): |
|
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
479 def __init__(self): |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
480 self.size = indexformatv0.size |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
481 |
|
13264
8439526fb407
revlog/parseindex: no need to pass the file around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13259
diff
changeset
|
482 def parseindex(self, data, inline): |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
483 s = self.size |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
484 index = [] |
|
27637
b502138f5faa
cleanup: remove superfluous space after space after equals (python)
timeless <timeless@mozdev.org>
parents:
27475
diff
changeset
|
485 nodemap = {nullid: nullrev} |
|
4973
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
486 n = off = 0 |
|
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
487 l = len(data) |
|
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
488 while off + s <= l: |
|
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
489 cur = data[off:off + s] |
|
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
490 off += s |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
491 e = indexformatv0_unpack(cur) |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
492 # transform to revlogv1 format |
|
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
493 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
|
494 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
|
495 index.append(e2) |
|
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
496 nodemap[e[6]] = n |
|
4973
a386a6e4fe46
revlog: simplify the v0 parser
Matt Mackall <mpm@selenic.com>
parents:
4972
diff
changeset
|
497 n += 1 |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
498 |
|
13265
04b302ce2781
revlog: always add the magic nullid/nullrev entry in parseindex
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13264
diff
changeset
|
499 # 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
|
500 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
|
501 |
|
4983
4dbcfc6e359e
revlog: pull chunkcache back into revlog
Matt Mackall <mpm@selenic.com>
parents:
4982
diff
changeset
|
502 return index, nodemap, None |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
503 |
|
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
504 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
|
505 if gettype(entry[0]): |
|
32431
d47b62368f3a
revlog: remove some revlogNG terminology
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32430
diff
changeset
|
506 raise RevlogError(_('index entry flags need revlog version 1')) |
|
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
507 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
|
508 node(entry[5]), node(entry[6]), entry[7]) |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
509 return indexformatv0_pack(*e2) |
|
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
510 |
|
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
511 # index ng: |
|
11323
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
512 # 6 bytes: offset |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
513 # 2 bytes: flags |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
514 # 4 bytes: compressed length |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
515 # 4 bytes: uncompressed length |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
516 # 4 bytes: base rev |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
517 # 4 bytes: link rev |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
518 # 4 bytes: parent 1 rev |
|
d65b74106113
revlog: fix inconsistent comment formatting
Martin Geisler <mg@aragost.com>
parents:
11155
diff
changeset
|
519 # 4 bytes: parent 2 rev |
|
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
520 # 32 bytes: nodeid |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
521 indexformatng = struct.Struct(">Qiiiiii20s12x") |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
522 indexformatng_pack = indexformatng.pack |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
523 versionformat = struct.Struct(">I") |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
524 versionformat_pack = versionformat.pack |
|
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
525 versionformat_unpack = versionformat.unpack |
|
4987
8d30004ada40
revlog: some basic code reordering
Matt Mackall <mpm@selenic.com>
parents:
4986
diff
changeset
|
526 |
|
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
|
527 # 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
|
528 # 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
|
529 _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
|
530 |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
531 class revlogio(object): |
|
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
532 def __init__(self): |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
533 self.size = indexformatng.size |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
534 |
|
13264
8439526fb407
revlog/parseindex: no need to pass the file around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13259
diff
changeset
|
535 def parseindex(self, data, inline): |
|
7109
528b7fc1216c
use the new parseindex implementation C in parsers
Bernhard Leiner <bleiner@gmail.com>
parents:
7089
diff
changeset
|
536 # 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
|
537 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
|
538 return index, getattr(index, 'nodemap', None), cache |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
539 |
|
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
540 def packentry(self, entry, node, version, rev): |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
541 p = indexformatng_pack(*entry) |
|
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
542 if rev == 0: |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
543 p = versionformat_pack(version) + p[4:] |
|
4986
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
544 return p |
|
58cc017ec7e0
revlog: abstract out index entry packing
Matt Mackall <mpm@selenic.com>
parents:
4985
diff
changeset
|
545 |
|
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
546 class revlog(object): |
| 1083 | 547 """ |
| 548 the underlying revision storage object | |
| 549 | |
| 550 A revlog consists of two parts, an index and the revision data. | |
| 551 | |
| 552 The index is a file with a fixed record size containing | |
| 6912 | 553 information on each revision, including its nodeid (hash), the |
| 1083 | 554 nodeids of its parents, the position and offset of its data within |
| 555 the data file, and the revision it's based on. Finally, each entry | |
| 556 contains a linkrev entry that can serve as a pointer to external | |
| 557 data. | |
| 558 | |
| 559 The revision data itself is a linear collection of data chunks. | |
| 560 Each chunk represents a revision and is usually represented as a | |
| 561 delta against the previous chunk. To bound lookup time, runs of | |
| 562 deltas are limited to about 2 times the length of the original | |
| 563 version data. This makes retrieval of a version proportional to | |
| 564 its size, or O(1) relative to the number of revisions. | |
| 565 | |
| 566 Both pieces of the revlog are written to in an append-only | |
| 567 fashion, which means we never need to rewrite a file to insert or | |
| 568 remove data, and can use some simple techniques to avoid the need | |
| 569 for locking while reading. | |
|
30001
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29841
diff
changeset
|
570 |
|
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29841
diff
changeset
|
571 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:
29841
diff
changeset
|
572 writing, to avoid file stat ambiguity. |
|
34303
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
573 |
|
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
574 If mmaplargeindex is True, and an mmapindexthreshold is set, the |
|
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
575 index will be mmapped rather than read if it is larger than the |
|
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
576 configured threshold. |
| 1083 | 577 """ |
|
34303
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
578 def __init__(self, opener, indexfile, datafile=None, checkambig=False, |
|
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
579 mmaplargeindex=False): |
| 1083 | 580 """ |
| 581 create a revlog object | |
| 582 | |
| 583 opener is a function that abstracts the file opening operation | |
| 584 and can be used to implement COW semantics or the like. | |
| 585 """ | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
586 self.indexfile = indexfile |
|
32347
3caec778774b
changelog: make sure datafile is 00changelog.d (API)
Jun Wu <quark@fb.com>
parents:
32331
diff
changeset
|
587 self.datafile = datafile or (indexfile[:-2] + ".d") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
588 self.opener = opener |
|
30001
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29841
diff
changeset
|
589 # 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:
29841
diff
changeset
|
590 # avoid file stat ambiguity. |
|
b5e5ddf48bd2
revlog: specify checkambig at writing to avoid file stat ambiguity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29841
diff
changeset
|
591 self._checkambig = checkambig |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
592 # 3-tuple of (node, rev, text) for a raw revision. |
| 4984 | 593 self._cache = None |
|
29841
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
594 # Maps rev to chain base rev. |
|
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
595 self._chainbasecache = util.lrucachedict(100) |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
596 # 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
|
597 self._chunkcache = (0, '') |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
598 # 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
|
599 self._chunkcachesize = 65536 |
|
23255
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
600 self._maxchainlen = None |
|
26118
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
601 self._aggressivemergedeltas = False |
|
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
602 self.index = [] |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
603 # 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
|
604 self._pcache = {} |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
605 # 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
|
606 self._nodecache = {nullid: nullrev} |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
607 self._nodepos = None |
|
30818
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
608 self._compengine = 'zlib' |
|
33207
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
609 self._maxdeltachainspan = -1 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
610 self._withsparseread = False |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
611 self._srdensitythreshold = 0.25 |
|
34881
8c9b08a0c48c
sparse-read: skip gaps too small to be worth splitting
Paul Morelle <paul.morelle@octobus.net>
parents:
34880
diff
changeset
|
612 self._srmingapsize = 262144 |
|
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
613 |
|
34303
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
614 mmapindexthreshold = None |
|
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
615 v = REVLOG_DEFAULT_VERSION |
|
14960
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
616 opts = getattr(opener, 'options', None) |
|
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
617 if opts is not None: |
|
32717
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
618 if 'revlogv2' in opts: |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
619 # version 2 revlogs always use generaldelta. |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
620 v = REVLOGV2 | FLAG_GENERALDELTA | FLAG_INLINE_DATA |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
621 elif 'revlogv1' in opts: |
|
14960
497819817307
revlog: use getattr instead of hasattr
Augie Fackler <durin42@gmail.com>
parents:
14549
diff
changeset
|
622 if 'generaldelta' in opts: |
|
32355
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
623 v |= FLAG_GENERALDELTA |
|
14333
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14325
diff
changeset
|
624 else: |
|
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14325
diff
changeset
|
625 v = 0 |
|
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
626 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
|
627 self._chunkcachesize = opts['chunkcachesize'] |
|
23255
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
628 if 'maxchainlen' in opts: |
|
76effa770ff9
revlog: add config variable for limiting delta-chain length
Mateusz Kwapich <mitrandir@fb.com>
parents:
23254
diff
changeset
|
629 self._maxchainlen = opts['maxchainlen'] |
|
26118
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
630 if 'aggressivemergedeltas' in opts: |
|
049005de325e
revlog: add an aggressivemergedelta option
Durham Goode <durham@fb.com>
parents:
26117
diff
changeset
|
631 self._aggressivemergedeltas = opts['aggressivemergedeltas'] |
|
26907
dfab6edb98e3
format: introduce 'format.usegeneraldelta`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26705
diff
changeset
|
632 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
|
633 if 'compengine' in opts: |
|
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
634 self._compengine = opts['compengine'] |
|
33207
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
635 if 'maxdeltachainspan' in opts: |
|
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
636 self._maxdeltachainspan = opts['maxdeltachainspan'] |
|
34303
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
637 if mmaplargeindex and 'mmapindexthreshold' in opts: |
|
3c9691728237
revlog: add option to mmap revlog index
Mark Thomas <mbthomas@fb.com>
parents:
34298
diff
changeset
|
638 mmapindexthreshold = opts['mmapindexthreshold'] |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
639 self._withsparseread = bool(opts.get('with-sparse-read', False)) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
640 if 'sparse-read-density-threshold' in opts: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
641 self._srdensitythreshold = opts['sparse-read-density-threshold'] |
|
34881
8c9b08a0c48c
sparse-read: skip gaps too small to be worth splitting
Paul Morelle <paul.morelle@octobus.net>
parents:
34880
diff
changeset
|
642 if 'sparse-read-min-gap-size' in opts: |
|
8c9b08a0c48c
sparse-read: skip gaps too small to be worth splitting
Paul Morelle <paul.morelle@octobus.net>
parents:
34880
diff
changeset
|
643 self._srmingapsize = opts['sparse-read-min-gap-size'] |
|
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
644 |
|
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
645 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
|
646 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
|
647 '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
|
648 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
|
649 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
|
650 'of 2') % self._chunkcachesize) |
|
11928
b69899dbad40
revlog: parentdelta flags for revlog index
Pradeepkumar Gayam <in3xes@gmail.com>
parents:
11759
diff
changeset
|
651 |
|
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
652 indexdata = '' |
|
14334
85c82ebc96a3
changelog: don't use generaldelta
Sune Foldager <cryo@cyanite.org>
parents:
14333
diff
changeset
|
653 self._initempty = True |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
654 try: |
|
36008
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
655 with self._indexfp() as f: |
|
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
656 if (mmapindexthreshold is not None and |
|
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
657 self.opener.fstat(f).st_size >= mmapindexthreshold): |
|
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
658 indexdata = util.buffer(util.mmapread(f)) |
|
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
659 else: |
|
1f2b8a644dd4
revlog: use context manager for index file life time in __init__
Boris Feld <boris.feld@octobus.net>
parents:
36007
diff
changeset
|
660 indexdata = f.read() |
|
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
661 if len(indexdata) > 0: |
|
33392
ac6446611ad2
revlog: use struct.Struct instances for slight performance wins
Alex Gaynor <agaynor@mozilla.com>
parents:
33391
diff
changeset
|
662 v = versionformat_unpack(indexdata[:4])[0] |
|
14334
85c82ebc96a3
changelog: don't use generaldelta
Sune Foldager <cryo@cyanite.org>
parents:
14333
diff
changeset
|
663 self._initempty = False |
|
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25459
diff
changeset
|
664 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
|
665 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
|
666 raise |
|
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
667 |
|
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
668 self.version = v |
|
32355
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
669 self._inline = v & FLAG_INLINE_DATA |
|
67026d65a4fc
revlog: rename constants (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32347
diff
changeset
|
670 self._generaldelta = v & FLAG_GENERALDELTA |
| 2073 | 671 flags = v & ~0xFFFF |
| 672 fmt = v & 0xFFFF | |
|
32430
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
673 if fmt == REVLOGV0: |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
674 if flags: |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
675 raise RevlogError(_('unknown flags (%#04x) in version %d ' |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
676 'revlog %s') % |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
677 (flags >> 16, fmt, self.indexfile)) |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
678 elif fmt == REVLOGV1: |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
679 if flags & ~REVLOGV1_FLAGS: |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
680 raise RevlogError(_('unknown flags (%#04x) in version %d ' |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
681 'revlog %s') % |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
682 (flags >> 16, fmt, self.indexfile)) |
|
32717
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
683 elif fmt == REVLOGV2: |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
684 if flags & ~REVLOGV2_FLAGS: |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
685 raise RevlogError(_('unknown flags (%#04x) in version %d ' |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
686 'revlog %s') % |
|
19b9fc40cc51
revlog: skeleton support for version 2 revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32704
diff
changeset
|
687 (flags >> 16, fmt, self.indexfile)) |
|
32430
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
688 else: |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
689 raise RevlogError(_('unknown version (%d) in revlog %s') % |
|
36d3559c69a6
revlog: tweak wording and logic for flags validation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32411
diff
changeset
|
690 (fmt, self.indexfile)) |
|
4985
e6525e459157
revlog: simplify revlog.__init__
Matt Mackall <mpm@selenic.com>
parents:
4984
diff
changeset
|
691 |
|
30210
5e4f16874a9f
revlog: make 'storedeltachains' a "public" attribute
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30154
diff
changeset
|
692 self.storedeltachains = True |
|
30154
5e72129d75ed
revlog: add instance variable controlling delta chain use
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30014
diff
changeset
|
693 |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
694 self._io = revlogio() |
|
4971
3e6dae278c99
revlog: regroup parsing code
Matt Mackall <mpm@selenic.com>
parents:
4920
diff
changeset
|
695 if self.version == REVLOGV0: |
|
4972
8d0cf46e0dc6
revlog: add revlogio interface
Matt Mackall <mpm@selenic.com>
parents:
4971
diff
changeset
|
696 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
|
697 try: |
|
26241
eb97d49768cc
revlog: rename generic "i" variable to "indexdata"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26118
diff
changeset
|
698 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
|
699 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
|
700 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
|
701 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
|
702 if nodemap is not None: |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
703 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
|
704 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
|
705 self._chunkclear() |
|
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
706 # 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
|
707 self._chaininfocache = {} |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
708 # revlog header -> revlog compressor |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
709 self._decompressors = {} |
|
116
e484cd5ec282
Only use lazy indexing for big indices and avoid the overhead of the
mpm@selenic.com
parents:
115
diff
changeset
|
710 |
|
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
711 @util.propertycache |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
712 def _compressor(self): |
|
30818
4c0a5a256ae8
localrepo: experimental support for non-zlib revlog compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30817
diff
changeset
|
713 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
|
714 |
|
36007
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
715 def _indexfp(self, mode='r'): |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
716 """file object for the revlog's index file""" |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
717 args = {r'mode': mode} |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
718 if mode != 'r': |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
719 args[r'checkambig'] = self._checkambig |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
720 if mode == 'w': |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
721 args[r'atomictemp'] = True |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
722 return self.opener(self.indexfile, **args) |
|
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
723 |
|
36006
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
724 def _datafp(self, mode='r'): |
|
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
725 """file object for the revlog's data file""" |
|
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
726 return self.opener(self.datafile, mode=mode) |
|
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
727 |
|
36012
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
728 @contextlib.contextmanager |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
729 def _datareadfp(self, existingfp=None): |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
730 """file object suitable to read data""" |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
731 if existingfp is not None: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
732 yield existingfp |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
733 else: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
734 if self._inline: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
735 func = self._indexfp |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
736 else: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
737 func = self._datafp |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
738 with func() as fp: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
739 yield fp |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
740 |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
741 def tip(self): |
|
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
742 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
|
743 def __contains__(self, rev): |
|
828dc8db5515
revlog: add __contains__ for fast membership test
Yuya Nishihara <yuya@tcha.org>
parents:
23857
diff
changeset
|
744 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
|
745 def __len__(self): |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
746 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
|
747 def __iter__(self): |
|
17951
6f79c32c0bdf
commit: increase perf by avoiding unnecessary filteredrevs check
Durham Goode <durham@fb.com>
parents:
17674
diff
changeset
|
748 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
|
749 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
|
750 """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
|
751 step = 1 |
|
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
752 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
|
753 if start > stop: |
|
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
754 step = -1 |
|
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
755 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
|
756 else: |
|
17975
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
757 stop = len(self) |
|
c56b5b65430d
revlog: allow reverse iteration with revlog.revs
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17972
diff
changeset
|
758 return xrange(start, stop, step) |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
759 |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
760 @util.propertycache |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
761 def nodemap(self): |
|
14064
e4bfb9c337f3
remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents:
13831
diff
changeset
|
762 self.rev(self.node(0)) |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
763 return self._nodecache |
|
13259
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
764 |
|
16374
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
765 def hasnode(self, node): |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
766 try: |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
767 self.rev(node) |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
768 return True |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
769 except KeyError: |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
770 return False |
|
29c2ff719715
revlog: add hasnode helper method
Matt Mackall <mpm@selenic.com>
parents:
15890
diff
changeset
|
771 |
|
35839
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
772 def candelta(self, baserev, rev): |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
773 """whether two revisions (baserev, rev) can be delta-ed or not""" |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
774 # Disable delta if either rev requires a content-changing flag |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
775 # processor (ex. LFS). This is because such flag processor can alter |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
776 # the rawtext content that the delta will be based on, and two clients |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
777 # could have a same revlog node with different flags (i.e. different |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
778 # rawtext contents) and the delta could be incompatible. |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
779 if ((self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
780 or (self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS)): |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
781 return False |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
782 return True |
|
d031609b3cb7
changegroup: do not delta lfs revisions
Jun Wu <quark@fb.com>
parents:
35738
diff
changeset
|
783 |
|
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
784 def clearcaches(self): |
|
27465
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
785 self._cache = None |
|
29841
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
786 self._chainbasecache.clear() |
|
27465
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
787 self._chunkcache = (0, '') |
|
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
788 self._pcache = {} |
|
072a675c51f2
revlog: make clearcaches() more effective
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27449
diff
changeset
|
789 |
|
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
790 try: |
|
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
791 self._nodecache.clearcaches() |
|
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
792 except AttributeError: |
|
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
793 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
|
794 self._nodepos = None |
|
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
795 |
|
13259
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
796 def rev(self, node): |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
797 try: |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
798 return self._nodecache[node] |
|
22282
4092d12ba18a
repoview: fix 0L with pack/unpack for 2.4
Matt Mackall <mpm@selenic.com>
parents:
21752
diff
changeset
|
799 except TypeError: |
|
4092d12ba18a
repoview: fix 0L with pack/unpack for 2.4
Matt Mackall <mpm@selenic.com>
parents:
21752
diff
changeset
|
800 raise |
|
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
801 except RevlogError: |
|
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
802 # parsers.c radix tree lookup failed |
|
32679
7b17f9de6d3e
revlog: map rev(wdirid) to WdirUnsupported exception
Yuya Nishihara <yuya@tcha.org>
parents:
32481
diff
changeset
|
803 if node == wdirid: |
|
7b17f9de6d3e
revlog: map rev(wdirid) to WdirUnsupported exception
Yuya Nishihara <yuya@tcha.org>
parents:
32481
diff
changeset
|
804 raise error.WdirUnsupported |
|
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
805 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
|
806 except KeyError: |
|
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16375
diff
changeset
|
807 # pure python cache lookup failed |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
808 n = self._nodecache |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
809 i = self.index |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
810 p = self._nodepos |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
811 if p is None: |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
812 p = len(i) - 2 |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
813 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
|
814 v = i[r][7] |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
815 n[v] = r |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
816 if v == node: |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
817 self._nodepos = r - 1 |
|
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
818 return r |
|
32679
7b17f9de6d3e
revlog: map rev(wdirid) to WdirUnsupported exception
Yuya Nishihara <yuya@tcha.org>
parents:
32481
diff
changeset
|
819 if node == wdirid: |
|
7b17f9de6d3e
revlog: map rev(wdirid) to WdirUnsupported exception
Yuya Nishihara <yuya@tcha.org>
parents:
32481
diff
changeset
|
820 raise error.WdirUnsupported |
|
13275
68da048b4c88
revlog: incrementally build node cache with linear searches
Matt Mackall <mpm@selenic.com>
parents:
13268
diff
changeset
|
821 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
|
822 |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
823 # Accessors for index entries. |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
824 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
825 # 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
|
826 # are flags. |
| 2072 | 827 def start(self, rev): |
|
5006
c2febf5420e9
revlog: minor chunk speed-up
Matt Mackall <mpm@selenic.com>
parents:
5005
diff
changeset
|
828 return int(self.index[rev][0] >> 16) |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
829 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
830 def flags(self, rev): |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
831 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
|
832 |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
833 def length(self, rev): |
|
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
834 return self.index[rev][1] |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
835 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
836 def rawsize(self, rev): |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
837 """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
|
838 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
|
839 if l >= 0: |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
840 return l |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
841 |
|
31801
d22f29abeb42
revlog: use raw revision for rawsize
Jun Wu <quark@fb.com>
parents:
31761
diff
changeset
|
842 t = self.revision(rev, raw=True) |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
843 return len(t) |
|
31856
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
844 |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
845 def size(self, rev): |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
846 """length of non-raw text (processed by a "read" flag processor)""" |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
847 # fast path: if no "read" flag processor could change the content, |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
848 # size is rawsize. note: ELLIPSIS is known to not change the content. |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
849 flags = self.flags(rev) |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
850 if flags & (REVIDX_KNOWN_FLAGS ^ REVIDX_ELLIPSIS) == 0: |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
851 return self.rawsize(rev) |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
852 |
|
0ab7f469d386
revlog: make "size" diverge from "rawsize"
Jun Wu <quark@fb.com>
parents:
31804
diff
changeset
|
853 return len(self.revision(rev, raw=False)) |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
854 |
|
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
855 def chainbase(self, rev): |
|
29841
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
856 base = self._chainbasecache.get(rev) |
|
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
857 if base is not None: |
|
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
858 return base |
|
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
859 |
|
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
860 index = self.index |
|
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
861 base = index[rev][3] |
|
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
862 while base != rev: |
|
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
863 rev = base |
|
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
864 base = index[rev][3] |
|
29841
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
865 |
|
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
866 self._chainbasecache[rev] = base |
|
14252
19067884c5f5
revlog: calculate base revisions iteratively
Sune Foldager <cryo@cyanite.org>
parents:
14251
diff
changeset
|
867 return base |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
868 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
869 def linkrev(self, rev): |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
870 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
|
871 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
872 def parentrevs(self, rev): |
|
32441
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
873 try: |
|
35525
a0fab647a8f1
revlog: don't use slicing to return parents
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35354
diff
changeset
|
874 entry = self.index[rev] |
|
32441
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
875 except IndexError: |
|
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
876 if rev == wdirrev: |
|
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
877 raise error.WdirUnsupported |
|
a28c76e1cea9
revlog: raise WdirUnsupported when wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32431
diff
changeset
|
878 raise |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
879 |
|
35525
a0fab647a8f1
revlog: don't use slicing to return parents
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35354
diff
changeset
|
880 return entry[5], entry[6] |
|
a0fab647a8f1
revlog: don't use slicing to return parents
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35354
diff
changeset
|
881 |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
882 def node(self, rev): |
|
32481
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
883 try: |
|
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
884 return self.index[rev][7] |
|
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
885 except IndexError: |
|
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
886 if rev == wdirrev: |
|
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
887 raise error.WdirUnsupported |
|
34e9b8b94f66
revlog: raise error.WdirUnsupported from revlog.node() if wdirrev is passed
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32441
diff
changeset
|
888 raise |
|
30301
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
889 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
890 # Derived from index values. |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
891 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
892 def end(self, rev): |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
893 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
|
894 |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
895 def parents(self, node): |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
896 i = self.index |
|
0986f225c149
revlog: reorder index accessors to match data structure order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30210
diff
changeset
|
897 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
|
898 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
|
899 |
|
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
900 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
|
901 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
|
902 |
|
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
903 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
|
904 chaininfocache = self._chaininfocache |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
905 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
|
906 return chaininfocache[rev] |
|
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
907 index = self.index |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
908 generaldelta = self._generaldelta |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
909 iterrev = rev |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
910 e = index[iterrev] |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
911 clen = 0 |
|
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
912 compresseddeltalen = 0 |
|
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
913 while iterrev != e[3]: |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
914 clen += 1 |
|
23286
40e0067899d4
revlog: compute length of compressed deltas along with chain length
Siddharth Agarwal <sid0@fb.com>
parents:
23285
diff
changeset
|
915 compresseddeltalen += e[1] |
|
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
916 if generaldelta: |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
917 iterrev = e[3] |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
918 else: |
|
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
919 iterrev -= 1 |
|
23306
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
920 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
|
921 t = chaininfocache[iterrev] |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
922 clen += t[0] |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
923 compresseddeltalen += t[1] |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
924 break |
|
23254
d23834b871ac
debugrevlog: fix computing chain length in debugrevlog -d
Mateusz Kwapich <mitrandir@fb.com>
parents:
22934
diff
changeset
|
925 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
|
926 else: |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
927 # 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
|
928 # 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
|
929 compresseddeltalen += e[1] |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
930 r = (clen, compresseddeltalen) |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
931 chaininfocache[rev] = r |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
932 return r |
|
f7a42f8e82bd
revlog: cache chain info after calculating it for a rev (issue4452)
Siddharth Agarwal <sid0@fb.com>
parents:
23288
diff
changeset
|
933 |
|
27468
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
934 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
|
935 """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
|
936 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
937 ``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
|
938 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
|
939 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
940 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
|
941 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
|
942 ``stoprev`` was hit. |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
943 """ |
|
33173
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
944 # Try C implementation. |
|
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
945 try: |
|
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
946 return self.index.deltachain(rev, stoprev, self._generaldelta) |
|
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
947 except AttributeError: |
|
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
948 pass |
|
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32987
diff
changeset
|
949 |
|
27468
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
950 chain = [] |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
951 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
952 # 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
|
953 index = self.index |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
954 generaldelta = self._generaldelta |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
955 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
956 iterrev = rev |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
957 e = index[iterrev] |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
958 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
|
959 chain.append(iterrev) |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
960 if generaldelta: |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
961 iterrev = e[3] |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
962 else: |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
963 iterrev -= 1 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
964 e = index[iterrev] |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
965 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
966 if iterrev == stoprev: |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
967 stopped = True |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
968 else: |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
969 chain.append(iterrev) |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
970 stopped = False |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
971 |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
972 chain.reverse() |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
973 return chain, stopped |
|
93ac15f03331
revlog: refactor delta chain computation into own function
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27465
diff
changeset
|
974 |
|
18081
f88c60e740a1
revlog.ancestors: add support for including revs
Siddharth Agarwal <sid0@fb.com>
parents:
17975
diff
changeset
|
975 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
|
976 """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
|
977 Does not generate revs lower than stoprev. |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
978 |
|
18090
9abc55ef85b5
revlog: move ancestor generation out to a new class
Siddharth Agarwal <sid0@fb.com>
parents:
18083
diff
changeset
|
979 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
|
980 |
|
23328
3a7d9c0c57a5
ancestor.lazyancestors: take parentrevs function rather than changelog
Siddharth Agarwal <sid0@fb.com>
parents:
23306
diff
changeset
|
981 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
|
982 inclusive=inclusive) |
|
6872
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
983 |
|
16867
1093ad1e8903
revlog: descendants(*revs) becomes descendants(revs) (API)
Bryan O'Sullivan <bryano@fb.com>
parents:
16866
diff
changeset
|
984 def descendants(self, revs): |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
985 """Generate the descendants of 'revs' in revision order. |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
986 |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
987 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
|
988 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
|
989 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
|
990 topological sort).""" |
|
12950
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
991 first = min(revs) |
|
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
992 if first == nullrev: |
|
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
993 for i in self: |
|
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
994 yield i |
|
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
995 return |
|
2405b4a5964a
revlog: fix descendants() if nullrev is in revs
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12949
diff
changeset
|
996 |
|
8150
bbc24c0753a0
util: use built-in set and frozenset
Martin Geisler <mg@lazybytes.net>
parents:
8073
diff
changeset
|
997 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
|
998 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
|
999 for x in self.parentrevs(i): |
|
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
1000 if x != nullrev and x in seen: |
|
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
1001 seen.add(i) |
|
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
1002 yield i |
|
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
1003 break |
|
c7cc40fd74f6
Add ancestors and descendants to revlog
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6750
diff
changeset
|
1004 |
|
13741
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1005 def findcommonmissing(self, common=None, heads=None): |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1006 """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
|
1007 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
|
1008 tuple: |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1009 |
|
15835
fa15869bf95c
revlog: improve docstring for findcommonmissing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15827
diff
changeset
|
1010 ::common, (::heads) - (::common) |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1011 |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1012 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
|
1013 topologically sorted. |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1014 |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1015 '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
|
1016 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
|
1017 supplied, uses nullid.""" |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1018 if common is None: |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1019 common = [nullid] |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1020 if heads is None: |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1021 heads = self.heads() |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1022 |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1023 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
|
1024 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
|
1025 |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1026 # we want the ancestors, but inclusive |
|
20073
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1027 class lazyset(object): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1028 def __init__(self, lazyvalues): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1029 self.addedvalues = set() |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1030 self.lazyvalues = lazyvalues |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1031 |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1032 def __contains__(self, value): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1033 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
|
1034 |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1035 def __iter__(self): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1036 added = self.addedvalues |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1037 for r in added: |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1038 yield r |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1039 for r in self.lazyvalues: |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1040 if not r in added: |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1041 yield r |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1042 |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1043 def add(self, value): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1044 self.addedvalues.add(value) |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1045 |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1046 def update(self, values): |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1047 self.addedvalues.update(values) |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1048 |
|
eeba4eaf0716
revlog: return lazy set from findcommonmissing
Durham Goode <durham@fb.com>
parents:
19776
diff
changeset
|
1049 has = lazyset(self.ancestors(common)) |
|
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
1050 has.add(nullrev) |
|
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
1051 has.update(common) |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1052 |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1053 # 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
|
1054 missing = set() |
|
25113
0ca8410ea345
util: drop alias for collections.deque
Martin von Zweigbergk <martinvonz@google.com>
parents:
24454
diff
changeset
|
1055 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
|
1056 while visit: |
|
16803
107a3270a24a
cleanup: use the deque type where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
1057 r = visit.popleft() |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1058 if r in missing: |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1059 continue |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1060 else: |
|
8453
d1ca637b0773
revlog.missing(): use sets instead of a dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8391
diff
changeset
|
1061 missing.add(r) |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1062 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
|
1063 if p not in has: |
|
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1064 visit.append(p) |
|
8453
d1ca637b0773
revlog.missing(): use sets instead of a dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8391
diff
changeset
|
1065 missing = list(missing) |
|
7233
9f0e52e1df77
fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7109
diff
changeset
|
1066 missing.sort() |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1067 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
|
1068 |
|
23337
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1069 def incrementalmissingrevs(self, common=None): |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1070 """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
|
1071 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
|
1072 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
|
1073 object. |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1074 |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1075 '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
|
1076 nullrev. |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1077 """ |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1078 if common is None: |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1079 common = [nullrev] |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1080 |
|
3a8a763f4197
revlog: add a method to get missing revs incrementally
Siddharth Agarwal <sid0@fb.com>
parents:
23328
diff
changeset
|
1081 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
|
1082 |
|
17972
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1083 def findmissingrevs(self, common=None, heads=None): |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1084 """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
|
1085 are not ancestors of common. |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1086 |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1087 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
|
1088 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
|
1089 |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1090 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
|
1091 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
|
1092 |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1093 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
|
1094 topologically sorted. |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1095 |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1096 '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
|
1097 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
|
1098 supplied, uses nullid.""" |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1099 if common is None: |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1100 common = [nullrev] |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1101 if heads is None: |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1102 heads = self.headrevs() |
|
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1103 |
|
23338
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
1104 inc = self.incrementalmissingrevs(common=common) |
|
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
1105 return inc.missingancestors(heads) |
|
17972
7ef00d09ef35
revlog: add rev-specific variant of findmissing
Siddharth Agarwal <sid0@fb.com>
parents:
17971
diff
changeset
|
1106 |
|
13741
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1107 def findmissing(self, common=None, heads=None): |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1108 """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
|
1109 |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1110 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
|
1111 satisfies the following constraints: |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1112 |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1113 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
|
1114 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
|
1115 |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1116 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
|
1117 topologically sorted. |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1118 |
|
b51bf961b3cb
wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13400
diff
changeset
|
1119 '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
|
1120 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
|
1121 supplied, uses nullid.""" |
|
17971
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1122 if common is None: |
|
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1123 common = [nullid] |
|
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1124 if heads is None: |
|
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1125 heads = self.heads() |
|
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1126 |
|
e1b9a78a7aed
revlog: switch findmissing to use ancestor.missingancestors
Siddharth Agarwal <sid0@fb.com>
parents:
17951
diff
changeset
|
1127 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
|
1128 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
|
1129 |
|
23338
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
1130 inc = self.incrementalmissingrevs(common=common) |
|
d8f5b2f50f41
revlog: switch findmissing* methods to incrementalmissingrevs
Siddharth Agarwal <sid0@fb.com>
parents:
23337
diff
changeset
|
1131 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
|
1132 |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1133 def nodesbetween(self, roots=None, heads=None): |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1134 """Return a topological path from 'roots' to 'heads'. |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1135 |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1136 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
|
1137 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
|
1138 these constraints: |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1139 |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1140 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
|
1141 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
|
1142 |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1143 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
|
1144 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
|
1145 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
|
1146 |
|
10047
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1147 '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
|
1148 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
|
1149 '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
|
1150 |
|
27267b1f68b4
revlog: rewrite several method docstrings
Greg Ward <greg-hg@gerg.ca>
parents:
9679
diff
changeset
|
1151 '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
|
1152 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
|
1153 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
|
1154 nonodes = ([], [], []) |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1155 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
|
1156 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
|
1157 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
|
1158 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1159 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
|
1160 else: |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1161 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
|
1162 lowestrev = nullrev |
|
3b4e00cba57a
Define and use nullrev (revision of nullid) instead of -1.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3508
diff
changeset
|
1163 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
|
1164 # 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
|
1165 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
|
1166 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
|
1167 # 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
|
1168 # node. |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1169 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
|
1170 # 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
|
1171 ancestors = None |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1172 # 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
|
1173 heads = {} |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1174 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
|
1175 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
|
1176 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
|
1177 return nonodes |
|
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
1178 ancestors = set() |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1179 # 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
|
1180 # 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
|
1181 # find from roots. |
|
14219
c33427080671
revlog: use real Booleans instead of 0/1 in nodesbetween
Martin Geisler <mg@aragost.com>
parents:
14208
diff
changeset
|
1182 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
|
1183 # 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
|
1184 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
|
1185 # 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
|
1186 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
|
1187 while nodestotag: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1188 # 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
|
1189 n = nodestotag.pop() |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1190 # Never tag nullid |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1191 if n == nullid: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1192 continue |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1193 # 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
|
1194 # 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
|
1195 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
|
1196 if r >= lowestrev: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1197 if n not in ancestors: |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1198 # 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
|
1199 # 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
|
1200 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
|
1201 # 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
|
1202 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
|
1203 p != nullid]) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1204 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
|
1205 # 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
|
1206 # any other heads. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1207 heads.pop(n) |
|
1459
106fdec8e1fb
Fix small bug in nodesbetween if heads is [nullid].
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1208 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
|
1209 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1210 # 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
|
1211 # 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
|
1212 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1213 # 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
|
1214 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
|
1215 # 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
|
1216 # 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
|
1217 |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1218 # Filter out roots that aren't ancestors of heads |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1219 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
|
1220 # 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
|
1221 if roots: |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1222 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
|
1223 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1224 # 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
|
1225 return nonodes |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1226 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1227 # 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
|
1228 # 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
|
1229 lowestrev = nullrev |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1230 roots = [nullid] |
|
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
1231 # Transform our roots list into a set. |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1232 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
|
1233 # 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
|
1234 # '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
|
1235 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
|
1236 # 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
|
1237 orderedout = [] |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1238 # Don't start at nullid since we don't want nullid in our output list, |
| 17483 | 1239 # 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
|
1240 # 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
|
1241 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
|
1242 n = self.node(r) |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1243 isdescendant = False |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1244 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
|
1245 isdescendant = True |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1246 elif n in descendants: |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1247 # n is already a descendant |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1248 isdescendant = True |
|
1457
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1249 # 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
|
1250 # 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
|
1251 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
|
1252 # 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
|
1253 p = tuple(self.parents(n)) |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1254 # 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
|
1255 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
|
1256 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
|
1257 else: |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1258 p = tuple(self.parents(n)) |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1259 # 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
|
1260 # 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
|
1261 # up there, remember?) |
|
14549
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1262 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
|
1263 descendants.add(n) |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1264 isdescendant = True |
|
48ec0763afbb
check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents:
14523
diff
changeset
|
1265 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
|
1266 # 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
|
1267 orderedout.append(n) |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1268 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
|
1269 # 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
|
1270 # from roots. |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1271 # 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
|
1272 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
|
1273 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
|
1274 # 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
|
1275 # 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
|
1276 # 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
|
1277 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
|
1278 # 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
|
1279 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
|
1280 heads.pop(p, None) |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1281 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
|
1282 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
|
1283 assert orderedout |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1284 assert roots |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1285 assert heads |
|
518da3c3b6ce
This implements the nodesbetween method, and it removes the newer method
Eric Hopper <hopper@omnifarious.org>
parents:
1351
diff
changeset
|
1286 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
|
1287 |
|
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1288 def headrevs(self): |
|
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
1289 try: |
|
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
1290 return self.index.headrevs() |
|
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16762
diff
changeset
|
1291 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
|
1292 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
|
1293 |
|
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24255
diff
changeset
|
1294 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
|
1295 return self.index.computephasesmapsets(roots) |
|
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24255
diff
changeset
|
1296 |
|
17674
e69274f8d444
clfilter: split `revlog.headrevs` C call from python code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17673
diff
changeset
|
1297 def _headrevs(self): |
|
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1298 count = len(self) |
|
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1299 if not count: |
|
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1300 return [nullrev] |
|
17673
d686c6876ef6
clfilter: handle non contiguous iteration in `revlov.headrevs`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17672
diff
changeset
|
1301 # 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
|
1302 ishead = [0] * (count + 1) |
|
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1303 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
|
1304 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
|
1305 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
|
1306 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
|
1307 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
|
1308 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
|
1309 |
|
3923
27230c29bfec
fix calculation of new heads added during push with -r
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3755
diff
changeset
|
1310 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
|
1311 """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
|
1312 |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
1313 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
|
1314 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
|
1315 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
|
1316 as if they had no children |
|
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
1317 """ |
|
4991
9c8c42bcf17a
revlog: implement a fast path for heads
Matt Mackall <mpm@selenic.com>
parents:
4990
diff
changeset
|
1318 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
|
1319 if not len(self): |
|
4991
9c8c42bcf17a
revlog: implement a fast path for heads
Matt Mackall <mpm@selenic.com>
parents:
4990
diff
changeset
|
1320 return [nullid] |
|
14164
cb98fed52495
discovery: add new set-based discovery
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14144
diff
changeset
|
1321 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
|
1322 |
|
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
1323 if start is None: |
|
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
1324 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
|
1325 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
|
1326 stop = [] |
|
8152
08e1baf924ca
replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents:
8150
diff
changeset
|
1327 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
|
1328 startrev = self.rev(start) |
|
32331
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32326
diff
changeset
|
1329 reachable = {startrev} |
|
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32326
diff
changeset
|
1330 heads = {startrev} |
| 1083 | 1331 |
|
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
|
1332 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
|
1333 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
|
1334 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
|
1335 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
|
1336 if r not in stoprevs: |
|
8464
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
1337 reachable.add(r) |
|
7af92e70bb25
revlog: use set instead of dict
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8453
diff
changeset
|
1338 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
|
1339 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
|
1340 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
|
1341 |
|
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
|
1342 return [self.node(r) for r in heads] |
| 370 | 1343 |
| 1344 def children(self, node): | |
| 1083 | 1345 """find the children of a given node""" |
| 370 | 1346 c = [] |
| 1347 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
|
1348 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
|
1349 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
|
1350 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
|
1351 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
|
1352 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
|
1353 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
|
1354 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
|
1355 c.append(self.node(r)) |
| 370 | 1356 return c |
| 515 | 1357 |
|
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1358 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
|
1359 if start == nullrev: |
|
6878eaa5a40d
revlog: if start is nullrev, end is always a descendant
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12890
diff
changeset
|
1360 return True |
|
16867
1093ad1e8903
revlog: descendants(*revs) becomes descendants(revs) (API)
Bryan O'Sullivan <bryano@fb.com>
parents:
16866
diff
changeset
|
1361 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
|
1362 if i == end: |
|
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1363 return True |
|
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1364 elif i > end: |
|
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1365 break |
|
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1366 return False |
|
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1367 |
|
21104
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1368 def commonancestorsheads(self, a, b): |
|
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1369 """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
|
1370 a, b = self.rev(a), self.rev(b) |
|
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1371 try: |
|
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1372 ancs = self.index.commonancestorsheads(a, b) |
|
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1373 except (AttributeError, OverflowError): # C implementation failed |
|
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1374 ancs = ancestor.commonancestorsheads(self.parentrevs, a, b) |
|
31580
a8e55d6f1d67
revlog: use pycompat.maplist to eagerly evaluate map on Python 3
Augie Fackler <augie@google.com>
parents:
31511
diff
changeset
|
1375 return pycompat.maplist(self.node, ancs) |
|
21104
40ace21cb3a1
revlog: introduce commonancestorsheads method
Mads Kiilerich <madski@unity3d.com>
parents:
20965
diff
changeset
|
1376 |
|
22381
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
1377 def isancestor(self, a, b): |
|
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
1378 """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
|
1379 |
|
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
1380 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
|
1381 commonancestorsheads is not.""" |
|
392ae5cb8d62
revlog: introduce isancestor method for efficiently determining node lineage
Mads Kiilerich <madski@unity3d.com>
parents:
22282
diff
changeset
|
1382 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
|
1383 |
|
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
1384 def ancestor(self, a, b): |
|
22389
94f77624dbb5
comments: describe ancestor consistently - avoid 'least common ancestor'
Mads Kiilerich <madski@unity3d.com>
parents:
22381
diff
changeset
|
1385 """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
|
1386 |
|
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1387 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
|
1388 try: |
|
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18987
diff
changeset
|
1389 ancs = self.index.ancestors(a, b) |
|
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
1390 except (AttributeError, OverflowError): |
|
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18987
diff
changeset
|
1391 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
|
1392 if ancs: |
|
3605d4e7e618
revlog: choose a consistent ancestor when there's a tie
Bryan O'Sullivan <bryano@fb.com>
parents:
18986
diff
changeset
|
1393 # choose a consistent winner when there's a tie |
|
21107
4a6c8b6b10d3
revlog: backout 514d32de6646 - commonancestors
Mads Kiilerich <madski@unity3d.com>
parents:
21104
diff
changeset
|
1394 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
|
1395 return nullid |
|
10897
adb6a291bbdb
revlog: put graph related functions together
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10404
diff
changeset
|
1396 |
|
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1397 def _match(self, id): |
|
16762
93f8b9565257
revlog: don't handle long for revision matching
Matt Mackall <mpm@selenic.com>
parents:
16686
diff
changeset
|
1398 if isinstance(id, int): |
|
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
1399 # 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
|
1400 return self.node(id) |
| 3438 | 1401 if len(id) == 20: |
| 1402 # possibly a binary node | |
| 1403 # odds of a binary node being all hex in ASCII are 1 in 10**25 | |
| 1404 try: | |
| 1405 node = id | |
|
7874
d812029cda85
cleanup: drop variables for unused return values
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7873
diff
changeset
|
1406 self.rev(node) # quick search the index |
| 3438 | 1407 return node |
|
3930
01d98d68d697
Add revlog.LookupError exception, and use it instead of RevlogError.
Brendan Cully <brendan@kublai.com>
parents:
3928
diff
changeset
|
1408 except LookupError: |
| 3438 | 1409 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
|
1410 try: |
|
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
1411 # str(rev) |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
1412 rev = int(id) |
|
36744
981f328d6d16
py3: use b"%d" instead of str() to convert integers to bytes
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36725
diff
changeset
|
1413 if "%d" % rev != id: |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1414 raise ValueError |
|
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1415 if rev < 0: |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1416 rev = len(self) + rev |
|
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1417 if rev < 0 or rev >= len(self): |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1418 raise ValueError |
|
36
da28286bf6b7
Add smart node lookup by substring or by rev number
mpm@selenic.com
parents:
26
diff
changeset
|
1419 return self.node(rev) |
| 469 | 1420 except (ValueError, OverflowError): |
|
3156
d01e4cb2f5f2
cleanups in revlog.lookup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3139
diff
changeset
|
1421 pass |
|
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1422 if len(id) == 40: |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1423 try: |
| 3438 | 1424 # a full hex nodeid? |
| 1425 node = bin(id) | |
|
7874
d812029cda85
cleanup: drop variables for unused return values
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7873
diff
changeset
|
1426 self.rev(node) |
|
3157
4fe41a9e4591
optimize revlog.lookup when passed hex(node)[:...]
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3156
diff
changeset
|
1427 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
|
1428 except (TypeError, LookupError): |
|
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1429 pass |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1430 |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1431 def _partialmatch(self, id): |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1432 maybewdir = wdirhex.startswith(id) |
|
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1433 try: |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1434 partial = self.index.partialmatch(id) |
|
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1435 if partial and self.hasnode(partial): |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1436 if maybewdir: |
|
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1437 # single 'ff...' match in radix tree, ambiguous with wdir |
|
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1438 raise RevlogError |
|
30401
2ded17b64f09
revlog: avoid shadowing several variables using list comprehensions
Augie Fackler <augie@google.com>
parents:
30303
diff
changeset
|
1439 return partial |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1440 if maybewdir: |
|
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1441 # no 'ff...' match in radix tree, wdir identified |
|
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1442 raise error.WdirUnsupported |
|
19471
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1443 return None |
|
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1444 except RevlogError: |
|
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1445 # 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
|
1446 # 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
|
1447 if not getattr(self, 'filteredrevs', None): |
|
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1448 raise LookupError(id, self.indexfile, |
|
d0ae5b8f80dc
revlog: add a fast path for "ambiguous identifier"
Jun Wu <quark@fb.com>
parents:
29339
diff
changeset
|
1449 _('ambiguous identifier')) |
|
19471
fd1bb7c1be78
revlog: handle hidden revs in _partialmatch (issue3979)
Matt Mackall <mpm@selenic.com>
parents:
19326
diff
changeset
|
1450 # 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
|
1451 except (AttributeError, ValueError): |
|
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1452 # 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
|
1453 pass |
|
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16533
diff
changeset
|
1454 |
|
13258
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1455 if id in self._pcache: |
|
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1456 return self._pcache[id] |
|
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1457 |
|
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1458 if len(id) < 40: |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1459 try: |
| 3438 | 1460 # hex(node)[:...] |
|
9029
0001e49f1c11
compat: use // for integer division
Alejandro Santos <alejolp@alejolp.com>
parents:
8658
diff
changeset
|
1461 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
|
1462 prefix = bin(id[:l * 2]) |
|
3b616dfa4b17
revlog: do revlog node->rev mapping by scanning
Matt Mackall <mpm@selenic.com>
parents:
13258
diff
changeset
|
1463 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
|
1464 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
|
1465 self.hasnode(n)] |
|
7365
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1466 if len(nl) > 0: |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1467 if len(nl) == 1 and not maybewdir: |
|
13258
c2661863f16f
revlog: introduce a cache for partial lookups
Matt Mackall <mpm@selenic.com>
parents:
13254
diff
changeset
|
1468 self._pcache[id] = nl[0] |
|
7365
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1469 return nl[0] |
|
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1470 raise LookupError(id, self.indexfile, |
|
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1471 _('ambiguous identifier')) |
|
32704
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1472 if maybewdir: |
|
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32679
diff
changeset
|
1473 raise error.WdirUnsupported |
|
7365
ec3aafa84d44
lookup: speed up partial lookup
Matt Mackall <mpm@selenic.com>
parents:
7363
diff
changeset
|
1474 return None |
|
36275
f574cc00831a
node: make bin() be a wrapper instead of just an alias
Augie Fackler <augie@google.com>
parents:
36013
diff
changeset
|
1475 except TypeError: |
|
3453
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1476 pass |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1477 |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1478 def lookup(self, id): |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1479 """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
|
1480 - 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
|
1481 - 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
|
1482 """ |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1483 n = self._match(id) |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1484 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
|
1485 return n |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1486 n = self._partialmatch(id) |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1487 if n: |
|
dba3cadef789
Only look up tags and branches as a last resort
Matt Mackall <mpm@selenic.com>
parents:
3438
diff
changeset
|
1488 return n |
| 515 | 1489 |
|
6228
c0c4c7b1e8d3
revlog: report node and file when lookup fails
Matt Mackall <mpm@selenic.com>
parents:
6212
diff
changeset
|
1490 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
|
1491 |
|
34257
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1492 def shortest(self, hexnode, minlength=1): |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1493 """Find the shortest unambiguous prefix that matches hexnode.""" |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1494 def isvalid(test): |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1495 try: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1496 if self._partialmatch(test) is None: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1497 return False |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1498 |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1499 try: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1500 i = int(test) |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1501 # if we are a pure int, then starting with zero will not be |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1502 # confused as a rev; or, obviously, if the int is larger |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1503 # than the value of the tip rev |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1504 if test[0] == '0' or i > len(self): |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1505 return True |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1506 return False |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1507 except ValueError: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1508 return True |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1509 except error.RevlogError: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1510 return False |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1511 except error.WdirUnsupported: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1512 # single 'ff...' match |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1513 return True |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1514 |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1515 shortest = hexnode |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1516 startlength = max(6, minlength) |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1517 length = startlength |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1518 while True: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1519 test = hexnode[:length] |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1520 if isvalid(test): |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1521 shortest = test |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1522 if length == minlength or length > startlength: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1523 return shortest |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1524 length -= 1 |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1525 else: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1526 length += 1 |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1527 if len(shortest) <= length: |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1528 return shortest |
|
448725a2ef73
templater: extract shortest() logic from template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34160
diff
changeset
|
1529 |
|
2890
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1530 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
|
1531 """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
|
1532 |
|
a463e3c50212
cmp: document the fact that we return True if content is different
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11323
diff
changeset
|
1533 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
|
1534 """ |
|
2890
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1535 p1, p2 = self.parents(node) |
|
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1536 return hash(text, p1, p2) != node |
|
5df3e5cf16bc
Move cmp bits from filelog to revlog
Matt Mackall <mpm@selenic.com>
parents:
2859
diff
changeset
|
1537 |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1538 def _cachesegment(self, offset, data): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1539 """Add a segment to the revlog cache. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1540 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1541 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
|
1542 """ |
|
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1543 o, d = self._chunkcache |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1544 # try to add to existing cache |
| 13253 | 1545 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
|
1546 self._chunkcache = o, d + data |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1547 else: |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1548 self._chunkcache = offset, data |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1549 |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1550 def _readsegment(self, offset, length, df=None): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1551 """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
|
1552 |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1553 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
|
1554 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
|
1555 |
|
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1556 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
|
1557 original seek position will NOT be restored. |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1558 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1559 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
|
1560 """ |
|
20179
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1561 # 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
|
1562 # 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
|
1563 # 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
|
1564 cachesize = self._chunkcachesize |
|
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20179
diff
changeset
|
1565 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
|
1566 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
|
1567 - realoffset) |
|
36012
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
1568 with self._datareadfp(df) as df: |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
1569 df.seek(realoffset) |
|
4d66993bdcff
revlog: add a _datareadfp context manager for data access needs
Boris Feld <boris.feld@octobus.net>
parents:
36011
diff
changeset
|
1570 d = df.read(reallength) |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1571 self._cachesegment(realoffset, d) |
|
20179
5bb3826bdac4
revlog: read/cache chunks in fixed windows of 64 KB
Brodie Rao <brodie@sf.io>
parents:
20074
diff
changeset
|
1572 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
|
1573 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
|
1574 return d |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1575 |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1576 def _getsegment(self, offset, length, df=None): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1577 """Obtain a segment of raw data from the revlog. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1578 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1579 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
|
1580 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
|
1581 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
|
1582 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1583 Requests for data may be returned from a cache. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1584 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1585 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
|
1586 """ |
|
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1587 o, d = self._chunkcache |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1588 l = len(d) |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1589 |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1590 # is it in the cache? |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1591 cachestart = offset - o |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1592 cacheend = cachestart + length |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1593 if cachestart >= 0 and cacheend <= l: |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1594 if cachestart == 0 and cacheend == l: |
|
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1595 return d # avoid a copy |
|
16423
a150923b49ba
revlog: avoid an expensive string copy
Bryan O'Sullivan <bryano@fb.com>
parents:
16418
diff
changeset
|
1596 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
|
1597 |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1598 return self._readsegment(offset, length, df=df) |
|
8316
d593922cf480
revlog: clean up the chunk caching code
Matt Mackall <mpm@selenic.com>
parents:
8315
diff
changeset
|
1599 |
|
32269
75e93d95aae6
revlog: rename _chunkraw to _getsegmentforrevs()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32267
diff
changeset
|
1600 def _getsegmentforrevs(self, startrev, endrev, df=None): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1601 """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
|
1602 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1603 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
|
1604 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
|
1605 seek position will not be preserved. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1606 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1607 Requests for data may be satisfied by a cache. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1608 |
|
27649
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1609 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
|
1610 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
|
1611 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
|
1612 |
|
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1613 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
|
1614 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
|
1615 """ |
|
30302
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30301
diff
changeset
|
1616 # 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:
30301
diff
changeset
|
1617 # (functions are expensive). |
|
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30301
diff
changeset
|
1618 index = self.index |
|
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30301
diff
changeset
|
1619 istart = index[startrev] |
|
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30301
diff
changeset
|
1620 start = int(istart[0] >> 16) |
|
30303
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30302
diff
changeset
|
1621 if startrev == endrev: |
|
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30302
diff
changeset
|
1622 end = start + istart[1] |
|
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30302
diff
changeset
|
1623 else: |
|
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30302
diff
changeset
|
1624 iend = index[endrev] |
|
1f92056c4066
revlog: optimize _chunkraw when startrev==endrev
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30302
diff
changeset
|
1625 end = int(iend[0] >> 16) + iend[1] |
|
30302
ceddc3d94d74
revlog: inline start() and end() for perf reasons
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30301
diff
changeset
|
1626 |
|
8318
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1627 if self._inline: |
|
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1628 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
|
1629 end += (endrev + 1) * self._io.size |
|
0e07c0b5fb1c
revlog.revision: fix cache preload for inline revlogs
Siddharth Agarwal <sid0@fb.com>
parents:
19713
diff
changeset
|
1630 length = end - start |
|
27649
6446e9b37c8b
revlog: return offset from _chunkraw()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27637
diff
changeset
|
1631 |
|
32267
1395f843ece4
revlog: rename internal functions containing "chunk" to use "segment"
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31856
diff
changeset
|
1632 return start, self._getsegment(start, length, df=df) |
|
8318
6b8513f8274a
revlog: add cache priming for reconstructing delta chains
Matt Mackall <mpm@selenic.com>
parents:
8317
diff
changeset
|
1633 |
|
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1634 def _chunk(self, rev, df=None): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1635 """Obtain a single decompressed chunk for a revision. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1636 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1637 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
|
1638 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
|
1639 be preserved. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1640 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1641 Returns a str holding uncompressed data for the requested revision. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1642 """ |
|
32269
75e93d95aae6
revlog: rename _chunkraw to _getsegmentforrevs()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32267
diff
changeset
|
1643 return self.decompress(self._getsegmentforrevs(rev, rev, df=df)[1]) |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1644 |
|
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1645 def _chunks(self, revs, df=None): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1646 """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
|
1647 |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1648 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
|
1649 ascending order. Also accepts an optional already-open file handle |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1650 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
|
1651 not be preserved. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1652 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1653 This function is similar to calling ``self._chunk()`` multiple times, |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1654 but is faster. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1655 |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1656 Returns a list with decompressed data for each requested revision. |
|
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1657 """ |
|
19716
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1658 if not revs: |
|
e17976978ee4
revlog: move chunk cache preload from revision to _chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19715
diff
changeset
|
1659 return [] |
|
19713
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1660 start = self.start |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1661 length = self.length |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1662 inline = self._inline |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1663 iosize = self._io.size |
|
19715
1aab406be57c
revlog._chunks: inline getchunk
Siddharth Agarwal <sid0@fb.com>
parents:
19714
diff
changeset
|
1664 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
|
1665 |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1666 l = [] |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1667 ladd = l.append |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1668 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1669 if not self._withsparseread: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1670 slicedchunks = (revs,) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1671 else: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1672 slicedchunks = _slicechunk(self, revs) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1673 |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1674 for revschunk in slicedchunks: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1675 firstrev = revschunk[0] |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1676 # Skip trailing revisions with empty diff |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1677 for lastrev in revschunk[::-1]: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1678 if length(lastrev) != 0: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1679 break |
|
34823
7891d243d821
revlog: ignore empty trailing chunks when reading segments
Paul Morelle <paul.morelle@octobus.net>
parents:
34303
diff
changeset
|
1680 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1681 try: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1682 offset, data = self._getsegmentforrevs(firstrev, lastrev, df=df) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1683 except OverflowError: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1684 # issue4215 - we can't cache a run of chunks greater than |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1685 # 2G on Windows |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1686 return [self._chunk(rev, df=df) for rev in revschunk] |
|
19715
1aab406be57c
revlog._chunks: inline getchunk
Siddharth Agarwal <sid0@fb.com>
parents:
19714
diff
changeset
|
1687 |
|
34824
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1688 decomp = self.decompress |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1689 for rev in revschunk: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1690 chunkstart = start(rev) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1691 if inline: |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1692 chunkstart += (rev + 1) * iosize |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1693 chunklength = length(rev) |
|
e2ad93bcc084
revlog: introduce an experimental flag to slice chunks reads when too sparse
Paul Morelle <paul.morelle@octobus.net>
parents:
34823
diff
changeset
|
1694 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
|
1695 |
|
c2e27e57d250
revlog: add a fast method for getting a list of chunks
Siddharth Agarwal <sid0@fb.com>
parents:
19625
diff
changeset
|
1696 return l |
|
14075
bc101902a68d
revlog: introduce _chunkbase to allow filelog to override
Sune Foldager <cryo@cyanite.org>
parents:
14064
diff
changeset
|
1697 |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1698 def _chunkclear(self): |
|
27070
7860366b46c9
revlog: improve documentation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26907
diff
changeset
|
1699 """Clear the raw chunk cache.""" |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1700 self._chunkcache = (0, '') |
|
1598
14d1f1868bf6
cleanup of revlog.group when repository is local
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1701 |
|
11929
1839a7518b0d
revlog: deltachain() returns chain of revs need to construct a revision
Pradeepkumar Gayam <in3xes@gmail.com>
parents:
11928
diff
changeset
|
1702 def deltaparent(self, rev): |
|
14195
0013d3eeb826
revlog: remove support for parentdelta
Sune Foldager <cryo@cyanite.org>
parents:
14164
diff
changeset
|
1703 """return deltaparent of the given revision""" |
|
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1704 base = self.index[rev][3] |
|
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1705 if base == rev: |
|
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1706 return nullrev |
|
14253
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1707 elif self._generaldelta: |
|
c28d5200374c
revlog: support reading generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14252
diff
changeset
|
1708 return base |
|
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1709 else: |
|
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1710 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
|
1711 |
|
1941
7518823709a2
revlog.py: factorization and fixes for rev < 0 (nullid)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1853
diff
changeset
|
1712 def revdiff(self, rev1, rev2): |
|
31758
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1713 """return or calculate a delta between two revisions |
|
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1714 |
|
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1715 The delta calculated is in binary form and is intended to be written to |
|
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1716 revlog data directly. So this function needs raw revision data. |
|
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1717 """ |
|
14208
d62d597b8974
revlog: compute correct deltaparent in the deltaparent function
Sune Foldager <cryo@cyanite.org>
parents:
14196
diff
changeset
|
1718 if rev1 != nullrev and self.deltaparent(rev2) == rev1: |
|
31378
b6f5af372c0c
revlog: use bytes() instead of str() to get data from memoryview
Augie Fackler <augie@google.com>
parents:
31366
diff
changeset
|
1719 return bytes(self._chunk(rev2)) |
|
5005
72082bfced9a
revlog: minor revdiff reorganization
Matt Mackall <mpm@selenic.com>
parents:
5004
diff
changeset
|
1720 |
|
31758
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1721 return mdiff.textdiff(self.revision(rev1, raw=True), |
|
5d11b5edcb0b
revlog: use raw revisions in revdiff
Jun Wu <quark@fb.com>
parents:
31757
diff
changeset
|
1722 self.revision(rev2, raw=True)) |
|
119
c7a66f9752a4
Add code to retrieve or construct a revlog delta
mpm@selenic.com
parents:
117
diff
changeset
|
1723 |
|
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30589
diff
changeset
|
1724 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
|
1725 """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
|
1726 number. |
|
26377
dfef0d3be65e
revlog: support using an existing file handle when reading revlogs
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26376
diff
changeset
|
1727 |
|
30743
2df983125d37
revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents:
30589
diff
changeset
|
1728 _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:
30589
diff
changeset
|
1729 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:
30589
diff
changeset
|
1730 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:
30589
diff
changeset
|
1731 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
|
1732 """ |
|
16375
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1733 if isinstance(nodeorrev, int): |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1734 rev = nodeorrev |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1735 node = self.node(rev) |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1736 else: |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1737 node = nodeorrev |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1738 rev = None |
|
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16374
diff
changeset
|
1739 |
|
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
|
1740 cachedrev = None |
|
31802
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1741 flags = None |
|
31804
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1742 rawtext = None |
|
4980
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1743 if node == nullid: |
|
fc44c8df9d99
revlog: some codingstyle cleanups
Matt Mackall <mpm@selenic.com>
parents:
4979
diff
changeset
|
1744 return "" |
|
26242
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1745 if self._cache: |
|
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1746 if self._cache[0] == node: |
|
31756
2133437dad17
revlog: fix _cache usage in revision()
Jun Wu <quark@fb.com>
parents:
31755
diff
changeset
|
1747 # _cache only stores rawtext |
|
2133437dad17
revlog: fix _cache usage in revision()
Jun Wu <quark@fb.com>
parents:
31755
diff
changeset
|
1748 if raw: |
|
2133437dad17
revlog: fix _cache usage in revision()
Jun Wu <quark@fb.com>
parents:
31755
diff
changeset
|
1749 return self._cache[2] |
|
31761
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1750 # duplicated, but good for perf |
|
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1751 if rev is None: |
|
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1752 rev = self.rev(node) |
|
31802
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1753 if flags is None: |
|
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1754 flags = self.flags(rev) |
|
31761
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1755 # no extra flags set, no flag processor runs, text = rawtext |
|
31802
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1756 if flags == REVIDX_DEFAULT_FLAGS: |
|
31761
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1757 return self._cache[2] |
|
31804
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1758 # rawtext is reusable. need to run flag processor |
|
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1759 rawtext = self._cache[2] |
|
31761
9ec03d5af48f
revlog: add a fast path for revision(raw=False)
Jun Wu <quark@fb.com>
parents:
31760
diff
changeset
|
1760 |
|
26242
d708873f1f33
revlog: drop local assignment of cache variable
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26241
diff
changeset
|
1761 cachedrev = self._cache[1] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1762 |
| 1083 | 1763 # look up what we need to read |
|
31803
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1764 if rawtext is None: |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1765 if rev is None: |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1766 rev = self.rev(node) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1767 |
|
31803
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1768 chain, stopped = self._deltachain(rev, stoprev=cachedrev) |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1769 if stopped: |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1770 rawtext = self._cache[2] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1771 |
|
31803
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1772 # drop cache to save memory |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1773 self._cache = None |
|
11754
6ccd130eab0e
revlog: drop cache after use to save memory footprint
Matt Mackall <mpm@selenic.com>
parents:
11539
diff
changeset
|
1774 |
|
31803
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1775 bins = self._chunks(chain, df=_df) |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1776 if rawtext is None: |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1777 rawtext = bytes(bins[0]) |
|
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1778 bins = bins[1:] |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1779 |
|
31803
2be73f9720a8
revlog: indent block to make review easier
Jun Wu <quark@fb.com>
parents:
31802
diff
changeset
|
1780 rawtext = mdiff.patches(rawtext, bins) |
|
31804
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1781 self._cache = (node, rev, rawtext) |
| 30745 | 1782 |
|
31802
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1783 if flags is None: |
|
31804
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1784 if rev is None: |
|
726f24123f02
revlog: avoid applying delta chain on cache hit
Jun Wu <quark@fb.com>
parents:
31803
diff
changeset
|
1785 rev = self.rev(node) |
|
31802
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1786 flags = self.flags(rev) |
|
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1787 |
|
ac9a5e89113a
revlog: avoid calculating "flags" twice in revision()
Jun Wu <quark@fb.com>
parents:
31801
diff
changeset
|
1788 text, validatehash = self._processflags(rawtext, flags, 'read', raw=raw) |
| 30745 | 1789 if validatehash: |
| 1790 self.checkhash(text, node, rev=rev) | |
| 1791 | |
|
13239
12ed25f39d0b
revlog: break hash checking into subfunction
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
1792 return text |
|
12ed25f39d0b
revlog: break hash checking into subfunction
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
1793 |
|
22785
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1794 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
|
1795 """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
|
1796 |
|
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1797 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
|
1798 as needed. |
|
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1799 """ |
|
abc44fcc9c57
revlog: move references to revlog.hash to inside the revlog class
Augie Fackler <raf@durin42.com>
parents:
22784
diff
changeset
|
1800 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
|
1801 |
| 30745 | 1802 def _processflags(self, text, flags, operation, raw=False): |
| 1803 """Inspect revision data flags and applies transforms defined by | |
| 1804 registered flag processors. | |
| 1805 | |
| 1806 ``text`` - the revision data to process | |
| 1807 ``flags`` - the revision flags | |
| 1808 ``operation`` - the operation being performed (read or write) | |
| 1809 ``raw`` - an optional argument describing if the raw transform should be | |
| 1810 applied. | |
| 1811 | |
| 1812 This method processes the flags in the order (or reverse order if | |
| 1813 ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the | |
| 1814 flag processors registered for present flags. The order of flags defined | |
| 1815 in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity. | |
| 1816 | |
| 1817 Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the | |
| 1818 processed text and ``validatehash`` is a bool indicating whether the | |
| 1819 returned text should be checked for hash integrity. | |
| 1820 | |
| 1821 Note: If the ``raw`` argument is set, it has precedence over the | |
| 1822 operation and will only update the value of ``validatehash``. | |
| 1823 """ | |
|
32326
539cbe0f8fa3
flagprocessor: add a fast path when flags is 0
Jun Wu <quark@fb.com>
parents:
32284
diff
changeset
|
1824 # fast path: no flag processors will run |
|
539cbe0f8fa3
flagprocessor: add a fast path when flags is 0
Jun Wu <quark@fb.com>
parents:
32284
diff
changeset
|
1825 if flags == 0: |
|
539cbe0f8fa3
flagprocessor: add a fast path when flags is 0
Jun Wu <quark@fb.com>
parents:
32284
diff
changeset
|
1826 return text, True |
| 30745 | 1827 if not operation in ('read', 'write'): |
| 1828 raise ProgrammingError(_("invalid '%s' operation ") % (operation)) | |
| 1829 # Check all flags are known. | |
| 1830 if flags & ~REVIDX_KNOWN_FLAGS: | |
| 1831 raise RevlogError(_("incompatible revision flag '%#x'") % | |
| 1832 (flags & ~REVIDX_KNOWN_FLAGS)) | |
| 1833 validatehash = True | |
| 1834 # Depending on the operation (read or write), the order might be | |
| 1835 # reversed due to non-commutative transforms. | |
| 1836 orderedflags = REVIDX_FLAGS_ORDER | |
| 1837 if operation == 'write': | |
| 1838 orderedflags = reversed(orderedflags) | |
| 1839 | |
| 1840 for flag in orderedflags: | |
| 1841 # If a flagprocessor has been registered for a known flag, apply the | |
| 1842 # related operation transform and update result tuple. | |
| 1843 if flag & flags: | |
| 1844 vhash = True | |
| 1845 | |
| 1846 if flag not in _flagprocessors: | |
| 1847 message = _("missing processor for flag '%#x'") % (flag) | |
| 1848 raise RevlogError(message) | |
| 1849 | |
| 1850 processor = _flagprocessors[flag] | |
| 1851 if processor is not None: | |
| 1852 readtransform, writetransform, rawtransform = processor | |
| 1853 | |
| 1854 if raw: | |
| 1855 vhash = rawtransform(self, text) | |
| 1856 elif operation == 'read': | |
| 1857 text, vhash = readtransform(self, text) | |
| 1858 else: # write operation | |
| 1859 text, vhash = writetransform(self, text) | |
| 1860 validatehash = validatehash and vhash | |
| 1861 | |
| 1862 return text, validatehash | |
| 1863 | |
|
30589
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1864 def checkhash(self, text, node, p1=None, p2=None, rev=None): |
|
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1865 """Check node hash integrity. |
|
19624
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1866 |
|
30589
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1867 Available as a function so that subclasses can extend hash mismatch |
|
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1868 behaviors as needed. |
|
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1869 """ |
|
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1870 if p1 is None and p2 is None: |
|
be5b2098a817
revlog: merge hash checking subfunctions
Remi Chaintron <remi@fb.com>
parents:
30552
diff
changeset
|
1871 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
|
1872 if node != self.hash(text, p1, p2): |
|
19624
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1873 revornode = rev |
|
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1874 if revornode is None: |
|
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1875 revornode = templatefilters.short(hex(node)) |
|
55749cb14d24
revlog: extract 'checkhash' method
Wojciech Lopata <lopek@fb.com>
parents:
19471
diff
changeset
|
1876 raise RevlogError(_("integrity check failed on %s:%s") |
|
34044
b2eb0aa445cb
revlog: use pycompat.bytestr() to reliably have a %s-able value
Augie Fackler <raf@durin42.com>
parents:
33956
diff
changeset
|
1877 % (self.indexfile, pycompat.bytestr(revornode))) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1878 |
|
36013
9ba1d0c724e2
revlog: rename 'self.checkinlinesize' into '_enforceinlinesize'
Boris Feld <boris.feld@octobus.net>
parents:
36012
diff
changeset
|
1879 def _enforceinlinesize(self, tr, fp=None): |
|
26376
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1880 """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
|
1881 |
|
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1882 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
|
1883 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
|
1884 to use multiple index and data files. |
|
344a1621674b
revlog: add docstring for checkinlinesize()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26243
diff
changeset
|
1885 """ |
|
10913
f2ecc5733c89
revlog: factor out _maxinline global.
Greg Ward <greg-hg@gerg.ca>
parents:
10404
diff
changeset
|
1886 if not self._inline or (self.start(-2) + self.length(-2)) < _maxinline: |
| 2073 | 1887 return |
|
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1888 |
| 2084 | 1889 trinfo = tr.find(self.indexfile) |
|
8527
f9a80054dd3c
use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents:
8464
diff
changeset
|
1890 if trinfo is None: |
|
3680
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
1891 raise RevlogError(_("%s not found in the transaction") |
|
69cf255a55a1
Indentation cleanups for 2956948b81f3.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3679
diff
changeset
|
1892 % self.indexfile) |
| 2084 | 1893 |
| 1894 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
|
1895 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
|
1896 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
|
1897 else: |
|
59904edf0a5e
revlog: make converting from inline to non-line work after a strip
Mike Edgar <adgar@google.com>
parents:
24444
diff
changeset
|
1898 # 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
|
1899 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
|
1900 dataoff = self.end(-2) |
| 2084 | 1901 |
| 1902 tr.add(self.datafile, dataoff) | |
|
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1903 |
|
8317
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1904 if fp: |
|
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1905 fp.flush() |
|
5cdf4067857a
revlog: use chunk cache to avoid rereading when splitting inline files
Matt Mackall <mpm@selenic.com>
parents:
8316
diff
changeset
|
1906 fp.close() |
|
8315
c8493310ad9b
revlog: use index to find index size
Matt Mackall <mpm@selenic.com>
parents:
8314
diff
changeset
|
1907 |
|
36009
69cf2e422490
revlog: use context manager for data file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36008
diff
changeset
|
1908 with self._datafp('w') as df: |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
1909 for r in self: |
|
32269
75e93d95aae6
revlog: rename _chunkraw to _getsegmentforrevs()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32267
diff
changeset
|
1910 df.write(self._getsegmentforrevs(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
|
1911 |
|
36010
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1912 with self._indexfp('w') as fp: |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1913 self.version &= ~FLAG_INLINE_DATA |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1914 self._inline = False |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1915 io = self._io |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1916 for i in self: |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1917 e = io.packentry(self.index[i], self.node, self.version, i) |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1918 fp.write(e) |
| 2073 | 1919 |
|
36010
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1920 # the temp file replace the real index when we exit the context |
|
0f2c51afafb2
revlog: use context manager for index file lifetime in checkinlinesize
Boris Feld <boris.feld@octobus.net>
parents:
36009
diff
changeset
|
1921 # manager |
| 2084 | 1922 |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1923 tr.replace(self.indexfile, trindex * self._io.size) |
|
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
1924 self._chunkclear() |
| 2073 | 1925 |
|
19625
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1926 def addrevision(self, text, transaction, link, p1, p2, cachedelta=None, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1927 node=None, flags=REVIDX_DEFAULT_FLAGS, deltacomputer=None): |
| 1083 | 1928 """add a revision to the log |
| 1929 | |
| 1930 text - the revision data to add | |
| 1931 transaction - the transaction object used for rollback | |
| 1932 link - the linkrev data to add | |
| 1933 p1, p2 - the parent nodeids of the revision | |
|
12012
bade7a9c5c07
revlog: fix docstring
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12011
diff
changeset
|
1934 cachedelta - an optional precomputed delta |
|
19625
6a411a06cb1f
revlog: pass node as an argument of addrevision
Wojciech Lopata <lopek@fb.com>
parents:
19624
diff
changeset
|
1935 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
|
1936 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
|
1937 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
|
1938 flags - the known flags to set on the revision |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1939 deltacomputer - an optional _deltacomputer instance shared between |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1940 multiple calls |
| 1083 | 1941 """ |
|
19326
7014526d67a8
revlog: add exception when linkrev == nullrev
Durham Goode <durham@fb.com>
parents:
19200
diff
changeset
|
1942 if link == nullrev: |
|
7014526d67a8
revlog: add exception when linkrev == nullrev
Durham Goode <durham@fb.com>
parents:
19200
diff
changeset
|
1943 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
|
1944 % self.indexfile) |
|
25459
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1945 |
| 30745 | 1946 if flags: |
| 1947 node = node or self.hash(text, p1, p2) | |
| 1948 | |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1949 rawtext, validatehash = self._processflags(text, flags, 'write') |
| 30745 | 1950 |
| 1951 # If the flag processor modifies the revision data, ignore any provided | |
| 1952 # cachedelta. | |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1953 if rawtext != text: |
| 30745 | 1954 cachedelta = None |
| 1955 | |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1956 if len(rawtext) > _maxentrysize: |
|
25459
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1957 raise RevlogError( |
|
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1958 _("%s: size of %d bytes exceeds maximum revlog storage of 2GiB") |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1959 % (self.indexfile, len(rawtext))) |
|
25459
0bda5bfaf0b1
revlog: move size limit check to addrevision
Matt Mackall <mpm@selenic.com>
parents:
25410
diff
changeset
|
1960 |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1961 node = node or self.hash(rawtext, p1, p2) |
|
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
1962 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
|
1963 return node |
|
44c22dc193a4
revlog.addrevision(): move computation of nodeid in addrevision()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12012
diff
changeset
|
1964 |
| 30745 | 1965 if validatehash: |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1966 self.checkhash(rawtext, node, p1=p1, p2=p2) |
| 30745 | 1967 |
|
32284
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1968 return self.addrawrevision(rawtext, transaction, link, p1, p2, node, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1969 flags, cachedelta=cachedelta, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1970 deltacomputer=deltacomputer) |
|
32284
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1971 |
|
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1972 def addrawrevision(self, rawtext, transaction, link, p1, p2, node, flags, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1973 cachedelta=None, deltacomputer=None): |
|
32284
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1974 """add a raw revision with known flags, node and parents |
|
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1975 useful when reusing a revision not stored in this revlog (ex: received |
|
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1976 over wire, or read from an external bundle). |
|
3de4c61b5087
revlog: move part of "addrevision" to "addrawrevision"
Jun Wu <quark@fb.com>
parents:
32269
diff
changeset
|
1977 """ |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
1978 dfh = None |
|
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
1979 if not self._inline: |
|
36006
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
1980 dfh = self._datafp("a+") |
|
36007
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
1981 ifh = self._indexfp("a+") |
|
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1982 try: |
|
31755
f319981c24c9
revlog: rename some "text"s to "rawtext"
Jun Wu <quark@fb.com>
parents:
31754
diff
changeset
|
1983 return self._addrevision(node, rawtext, transaction, link, p1, p2, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1984 flags, cachedelta, ifh, dfh, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
1985 deltacomputer=deltacomputer) |
|
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1986 finally: |
|
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
1987 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
|
1988 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
|
1989 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
|
1990 |
|
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1991 def compress(self, data): |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1992 """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
|
1993 if not data: |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1994 return '', data |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1995 |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1996 compressed = self._compressor.compress(data) |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1997 |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1998 if compressed: |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
1999 # 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
|
2000 return '', compressed |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
2001 |
|
31648
6ceb3c4c3ab6
py3: fix slicing of byte string in revlog.compress()
Yuya Nishihara <yuya@tcha.org>
parents:
31580
diff
changeset
|
2002 if data[0:1] == '\0': |
|
30795
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
2003 return '', data |
|
78ac56aebab6
revlog: use compression engine API for compression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30793
diff
changeset
|
2004 return 'u', data |
|
17128
1028a1c9077a
revlog: make compress a method
Bryan O'Sullivan <bryano@fb.com>
parents:
17009
diff
changeset
|
2005 |
|
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2006 def decompress(self, data): |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2007 """Decompress a revlog chunk. |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2008 |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2009 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
|
2010 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
|
2011 """ |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2012 if not data: |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2013 return data |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2014 |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2015 # 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
|
2016 # 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
|
2017 # important here. |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2018 # |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2019 # 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
|
2020 # |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2021 # 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
|
2022 # raw data). |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2023 # 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
|
2024 # returning raw inline data. |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2025 # 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
|
2026 # engines |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2027 # |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2028 # 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
|
2029 # 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
|
2030 # 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
|
2031 # 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
|
2032 # followed by the compengines lookup. |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2033 # |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2034 # 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
|
2035 # compressed chunks. And this matters for changelog and manifest reads. |
|
31365
ef6888172437
revlog: extract first byte of revlog with a slice so it's portable
Augie Fackler <augie@google.com>
parents:
30829
diff
changeset
|
2036 t = data[0:1] |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2037 |
|
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2038 if t == 'x': |
|
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2039 try: |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2040 return _zlibdecompress(data) |
|
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2041 except zlib.error as e: |
|
36725
f659a407e5ee
py3: use util.forcebytestr instead of str to convert error messages
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36275
diff
changeset
|
2042 raise RevlogError(_('revlog decompress error: %s') % |
|
37087
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36768
diff
changeset
|
2043 stringutil.forcebytestr(e)) |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2044 # '\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
|
2045 elif t == '\0': |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2046 return data |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2047 elif t == 'u': |
|
30793
b6f455a6e4d6
revlog: move decompress() from module to revlog class (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30792
diff
changeset
|
2048 return util.buffer(data, 1) |
|
30817
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2049 |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2050 try: |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2051 compressor = self._decompressors[t] |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2052 except KeyError: |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2053 try: |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2054 engine = util.compengines.forrevlogheader(t) |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2055 compressor = engine.revlogcompressor() |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2056 self._decompressors[t] = compressor |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2057 except KeyError: |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2058 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
|
2059 |
|
2b279126b8f5
revlog: use compression engine APIs for decompression
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30795
diff
changeset
|
2060 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
|
2061 |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2062 def _isgooddeltainfo(self, d, textlen): |
|
26115
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2063 """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
|
2064 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
|
2065 performant.""" |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2066 if d is None: |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2067 return False |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2068 |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2069 # - 'd.distance' is the distance from the base revision -- bounding it |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2070 # limits the amount of I/O we need to do. |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2071 # - 'd.compresseddeltalen' is the sum of the total size of deltas we |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2072 # need to apply -- bounding it limits the amount of CPU we consume. |
|
33207
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
2073 |
|
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
2074 defaultmax = textlen * 4 |
|
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
2075 maxdist = self._maxdeltachainspan |
|
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
2076 if not maxdist: |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2077 maxdist = d.distance # ensure the conditional pass |
|
33207
895ecec31c70
revlog: add an experimental option to mitigated delta issues (issue5480)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33173
diff
changeset
|
2078 maxdist = max(maxdist, defaultmax) |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2079 if (d.distance > maxdist or d.deltalen > textlen or |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2080 d.compresseddeltalen > textlen * 2 or |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2081 (self._maxchainlen and d.chainlen > self._maxchainlen)): |
|
26115
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2082 return False |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2083 |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2084 return True |
|
748347e0e8d4
revlog: move delta check to it's own function
Durham Goode <durham@fb.com>
parents:
25892
diff
changeset
|
2085 |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2086 def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2087 cachedelta, ifh, dfh, alwayscache=False, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2088 deltacomputer=None): |
|
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
2089 """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
|
2090 |
|
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
2091 see addrevision for argument descriptions. |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2092 |
|
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2093 note: "addrevision" takes non-raw text, "_addrevision" takes raw text. |
|
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2094 |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2095 if "deltacomputer" is not provided or None, a defaultdeltacomputer will |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2096 be used. |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2097 |
|
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
2098 invariants: |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2099 - rawtext 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
|
2100 if both are set, they must correspond to each other. |
|
14292
c97d8485b5fa
revlog: add docstring to _addrevision
Sune Foldager <cryo@cyanite.org>
parents:
14270
diff
changeset
|
2101 """ |
|
33956
9180f8f593f3
revlog: abort on attempt to write null revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
33392
diff
changeset
|
2102 if node == nullid: |
|
9180f8f593f3
revlog: abort on attempt to write null revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
33392
diff
changeset
|
2103 raise RevlogError(_("%s: attempt to add null revision") % |
|
9180f8f593f3
revlog: abort on attempt to write null revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
33392
diff
changeset
|
2104 (self.indexfile)) |
|
34045
bfb38c5cebf4
revlog: move check for wdir from changelog to revlog
Martin von Zweigbergk <martinvonz@google.com>
parents:
34044
diff
changeset
|
2105 if node == wdirid: |
|
bfb38c5cebf4
revlog: move check for wdir from changelog to revlog
Martin von Zweigbergk <martinvonz@google.com>
parents:
34044
diff
changeset
|
2106 raise RevlogError(_("%s: attempt to add wdir revision") % |
|
bfb38c5cebf4
revlog: move check for wdir from changelog to revlog
Martin von Zweigbergk <martinvonz@google.com>
parents:
34044
diff
changeset
|
2107 (self.indexfile)) |
|
bfb38c5cebf4
revlog: move check for wdir from changelog to revlog
Martin von Zweigbergk <martinvonz@google.com>
parents:
34044
diff
changeset
|
2108 |
|
35635
0b52c0ecbc23
revlog: choose between ifh and dfh once for all
Paul Morelle <paul.morelle@octobus.net>
parents:
35634
diff
changeset
|
2109 if self._inline: |
|
0b52c0ecbc23
revlog: choose between ifh and dfh once for all
Paul Morelle <paul.morelle@octobus.net>
parents:
35634
diff
changeset
|
2110 fh = ifh |
|
0b52c0ecbc23
revlog: choose between ifh and dfh once for all
Paul Morelle <paul.morelle@octobus.net>
parents:
35634
diff
changeset
|
2111 else: |
|
0b52c0ecbc23
revlog: choose between ifh and dfh once for all
Paul Morelle <paul.morelle@octobus.net>
parents:
35634
diff
changeset
|
2112 fh = dfh |
|
0b52c0ecbc23
revlog: choose between ifh and dfh once for all
Paul Morelle <paul.morelle@octobus.net>
parents:
35634
diff
changeset
|
2113 |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2114 btext = [rawtext] |
|
12623
8f97b50a8d10
revlog._addrevision(): allow text argument to be None, build it lazily
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12336
diff
changeset
|
2115 |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2116 curr = len(self) |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2117 prev = curr - 1 |
|
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2118 offset = self.end(prev) |
|
12889
5482c6b826f4
revlog: precalculate p1 and p2 revisions
Matt Mackall <mpm@selenic.com>
parents:
12888
diff
changeset
|
2119 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
|
2120 |
|
26116
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
2121 # 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
|
2122 # become comparable to the uncompressed text |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2123 if rawtext is None: |
|
35841
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
2124 # need rawtext size, before changed by flag processors, which is |
|
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
2125 # the non-raw size. use revlog explicitly to avoid filelog's extra |
|
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
2126 # logic that might remove metadata size. |
|
369aadf7a326
revlog: resolve lfs rawtext to vanilla rawtext before applying delta
Jun Wu <quark@fb.com>
parents:
35840
diff
changeset
|
2127 textlen = mdiff.patchedsize(revlog.size(self, cachedelta[0]), |
|
26116
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
2128 cachedelta[1]) |
|
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
2129 else: |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2130 textlen = len(rawtext) |
|
26116
562cfc99e611
revlog: move textlen calculation to be above delta chooser
Durham Goode <durham@fb.com>
parents:
26115
diff
changeset
|
2131 |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2132 if deltacomputer is None: |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2133 deltacomputer = _deltacomputer(self) |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2134 |
|
35737
d99b07bc69fb
revlog: refactor out _finddeltainfo from _addrevision
Paul Morelle <paul.morelle@octobus.net>
parents:
35641
diff
changeset
|
2135 revinfo = _revisioninfo(node, p1, p2, btext, textlen, cachedelta, flags) |
|
35840
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2136 |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2137 # no delta for flag processor revision (see "candelta" for why) |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2138 # not calling candelta since only one revision needs test, also to |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2139 # avoid overhead fetching flags again. |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2140 if flags & REVIDX_RAWTEXT_CHANGING_FLAGS: |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2141 deltainfo = None |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2142 else: |
|
33275ab5e837
revlog: do not use delta for lfs revisions
Jun Wu <quark@fb.com>
parents:
35839
diff
changeset
|
2143 deltainfo = deltacomputer.finddeltainfo(revinfo, fh) |
|
35634
b43578ec483a
revlog: refactor out the selection of candidate revisions
Paul Morelle <paul.morelle@octobus.net>
parents:
35525
diff
changeset
|
2144 |
|
35638
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2145 if deltainfo is not None: |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2146 base = deltainfo.base |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2147 chainbase = deltainfo.chainbase |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2148 data = deltainfo.data |
|
edc9330acac1
revlog: introduce 'deltainfo' to distinguish from 'delta'
Paul Morelle <paul.morelle@octobus.net>
parents:
35637
diff
changeset
|
2149 l = deltainfo.deltalen |
|
27250
bff71fe05768
revlog: make calls to _isgooddelta() consistent
Martin von Zweigbergk <martinvonz@google.com>
parents:
27249
diff
changeset
|
2150 else: |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2151 rawtext = deltacomputer.buildtext(revinfo, fh) |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2152 data = self.compress(rawtext) |
|
1533
3d11f81c9145
Reduce string duplication in compression code
mason@suse.com
parents:
1509
diff
changeset
|
2153 l = len(data[1]) + len(data[0]) |
|
14296
62e25c63fb3a
revlog: fix bug in chainbase cache
Sune Foldager <cryo@cyanite.org>
parents:
14292
diff
changeset
|
2154 base = chainbase = curr |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
2155 |
|
12623
8f97b50a8d10
revlog._addrevision(): allow text argument to be None, build it lazily
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12336
diff
changeset
|
2156 e = (offset_type(offset, flags), l, textlen, |
|
12889
5482c6b826f4
revlog: precalculate p1 and p2 revisions
Matt Mackall <mpm@selenic.com>
parents:
12888
diff
changeset
|
2157 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
|
2158 self.index.insert(-1, e) |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2159 self.nodemap[node] = curr |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
2160 |
|
5338
f87685355c9c
revlog: fix revlogio.packentry corner case
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5325
diff
changeset
|
2161 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
|
2162 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
|
2163 |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2164 if alwayscache and rawtext is None: |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2165 rawtext = deltacomputer._buildtext(revinfo, fh) |
|
26243
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
2166 |
|
35885
be923ce44d6a
revlog: correct type in check to verify rawtext is immutable
Augie Fackler <augie@google.com>
parents:
35738
diff
changeset
|
2167 if type(rawtext) == bytes: # only accept immutable objects |
|
31760
ec48d57de110
revlog: make _addrevision only accept rawtext
Jun Wu <quark@fb.com>
parents:
31759
diff
changeset
|
2168 self._cache = (node, curr, rawtext) |
|
29841
92ac2baaea86
revlog: use an LRU cache for delta chain bases
Gregory Szorc <gregory.szorc@gmail.com>
parents:
29840
diff
changeset
|
2169 self._chainbasecache[curr] = chainbase |
|
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
2170 return node |
|
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
2171 |
|
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
2172 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
|
2173 # 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
|
2174 # 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
|
2175 # 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
|
2176 # 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
|
2177 # 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
|
2178 # 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
|
2179 # 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
|
2180 # |
|
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
2181 # 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
|
2182 # 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
|
2183 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
|
2184 if dfh: |
|
27430
e240e914d226
revlog: seek to end of file before writing (issue4943)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26705
diff
changeset
|
2185 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
|
2186 |
|
20217
33394f2e331e
revlog: move file writing to a separate function
Durham Goode <durham@fb.com>
parents:
20180
diff
changeset
|
2187 curr = len(self) - 1 |
|
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
2188 if not self._inline: |
| 2073 | 2189 transaction.add(self.datafile, offset) |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2190 transaction.add(self.indexfile, curr * len(entry)) |
| 2073 | 2191 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
|
2192 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
|
2193 dfh.write(data[1]) |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2194 ifh.write(entry) |
| 2073 | 2195 else: |
|
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
2196 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
|
2197 transaction.add(self.indexfile, offset, curr) |
|
4981
e7131935fbb3
revlog: simplify addrevision
Matt Mackall <mpm@selenic.com>
parents:
4980
diff
changeset
|
2198 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
|
2199 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
|
2200 ifh.write(data[1]) |
|
36013
9ba1d0c724e2
revlog: rename 'self.checkinlinesize' into '_enforceinlinesize'
Boris Feld <boris.feld@octobus.net>
parents:
36012
diff
changeset
|
2201 self._enforceinlinesize(transaction, ifh) |
| 2073 | 2202 |
|
34298
1db9abf407c5
revlog: add revmap back to revlog.addgroup
Durham Goode <durham@fb.com>
parents:
34257
diff
changeset
|
2203 def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): |
| 1083 | 2204 """ |
| 2205 add a delta group | |
| 46 | 2206 |
| 1083 | 2207 given a set of deltas, add them to the revision log. the |
| 2208 first delta is against its parent, which should be in our | |
| 2209 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
|
2210 |
|
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
2211 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
|
2212 this revlog and the node that was added. |
| 1083 | 2213 """ |
| 2214 | |
|
32886
ef015ba5ba2e
revlog: rename list of nodes from "content" to "nodes"
Martin von Zweigbergk <martinvonz@google.com>
parents:
32885
diff
changeset
|
2215 nodes = [] |
| 515 | 2216 |
|
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
2217 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
|
2218 end = 0 |
| 46 | 2219 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
|
2220 end = self.end(r - 1) |
|
36007
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
2221 ifh = self._indexfp("a+") |
|
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
2222 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
|
2223 if self._inline: |
|
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
2224 transaction.add(self.indexfile, end + isize, r) |
| 2073 | 2225 dfh = None |
| 2226 else: | |
|
4996
a0d37976cd5b
revlog: avoid some unnecessary seek/tell syscalls
Matt Mackall <mpm@selenic.com>
parents:
4994
diff
changeset
|
2227 transaction.add(self.indexfile, isize, r) |
| 2073 | 2228 transaction.add(self.datafile, end) |
|
36006
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
2229 dfh = self._datafp("a+") |
|
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2230 def flush(): |
|
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2231 if dfh: |
|
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2232 dfh.flush() |
|
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2233 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
|
2234 try: |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2235 deltacomputer = _deltacomputer(self) |
|
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
2236 # loop through our set of deltas |
|
34160
c8b6ed51386b
changegroup: remove changegroup dependency from revlog.addgroup
Durham Goode <durham@fb.com>
parents:
34159
diff
changeset
|
2237 for data in deltas: |
|
34298
1db9abf407c5
revlog: add revmap back to revlog.addgroup
Durham Goode <durham@fb.com>
parents:
34257
diff
changeset
|
2238 node, p1, p2, linknode, deltabase, delta, flags = data |
|
1db9abf407c5
revlog: add revmap back to revlog.addgroup
Durham Goode <durham@fb.com>
parents:
34257
diff
changeset
|
2239 link = linkmapper(linknode) |
|
34160
c8b6ed51386b
changegroup: remove changegroup dependency from revlog.addgroup
Durham Goode <durham@fb.com>
parents:
34159
diff
changeset
|
2240 flags = flags or REVIDX_DEFAULT_FLAGS |
|
12336
9d234f7d8a77
bundle: move chunk parsing into unbundle class
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
2241 |
|
32886
ef015ba5ba2e
revlog: rename list of nodes from "content" to "nodes"
Martin von Zweigbergk <martinvonz@google.com>
parents:
32885
diff
changeset
|
2242 nodes.append(node) |
|
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
|
2243 |
|
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
2244 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
|
2245 # 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
|
2246 continue |
| 192 | 2247 |
|
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
2248 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
|
2249 if p not in self.nodemap: |
|
14196
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
2250 raise LookupError(p, self.indexfile, |
|
e7483ec3c374
revlog: remove support for punched/shallow
Sune Foldager <cryo@cyanite.org>
parents:
14195
diff
changeset
|
2251 _('unknown parent')) |
| 46 | 2252 |
|
14141
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
2253 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
|
2254 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
|
2255 _('unknown delta base')) |
| 46 | 2256 |
|
14141
bd1cbfe5db5c
bundler: make parsechunk return the base revision of the delta
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14075
diff
changeset
|
2257 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
|
2258 |
|
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
2259 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
|
2260 # 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
|
2261 # single patch operation |
|
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
2262 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
|
2263 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
|
2264 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
|
2265 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
|
2266 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
|
2267 self.node(baserev)) |
|
a450e0a2ba0a
revlog: in addgroup, reject ill-formed deltas based on censored nodes
Mike Edgar <adgar@google.com>
parents:
24118
diff
changeset
|
2268 |
|
27433
12f727a5b434
changegroup: add flags field to cg3 delta header
Mike Edgar <adgar@google.com>
parents:
27431
diff
changeset
|
2269 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
|
2270 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
|
2271 |
|
26243
836291420d53
revlog: optionally cache the full text when adding revisions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
26242
diff
changeset
|
2272 # 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
|
2273 # 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
|
2274 # 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
|
2275 # 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:
30589
diff
changeset
|
2276 # 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:
30589
diff
changeset
|
2277 # 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:
30589
diff
changeset
|
2278 # by the flagprocessor. |
|
34159
b96cfc309ac5
revlog: refactor chain variable
Durham Goode <durham@fb.com>
parents:
34045
diff
changeset
|
2279 self._addrevision(node, None, transaction, link, |
|
b96cfc309ac5
revlog: refactor chain variable
Durham Goode <durham@fb.com>
parents:
34045
diff
changeset
|
2280 p1, p2, flags, (baserev, delta), |
|
b96cfc309ac5
revlog: refactor chain variable
Durham Goode <durham@fb.com>
parents:
34045
diff
changeset
|
2281 ifh, dfh, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2282 alwayscache=bool(addrevisioncb), |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2283 deltacomputer=deltacomputer) |
|
25822
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
2284 |
|
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
2285 if addrevisioncb: |
|
34159
b96cfc309ac5
revlog: refactor chain variable
Durham Goode <durham@fb.com>
parents:
34045
diff
changeset
|
2286 addrevisioncb(self, node) |
|
25822
00e3f909907f
revlog: add support for a callback whenever revisions are added
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
2287 |
|
12624
557988c691d1
revlog.addgroup(): always use _addrevision() to add new revlog entries
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12623
diff
changeset
|
2288 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
|
2289 # 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
|
2290 # reopen the index |
|
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
2291 ifh.close() |
|
36006
61326dd7cb8d
revlog: move datafile opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
35885
diff
changeset
|
2292 dfh = self._datafp("a+") |
|
36007
91b3b11565e5
revlog: move index file opening in a method
Boris Feld <boris.feld@octobus.net>
parents:
36006
diff
changeset
|
2293 ifh = self._indexfp("a+") |
|
6261
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
2294 finally: |
|
7c8101b5ceb1
revlog: make sure the files are closed after an exception happens
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6228
diff
changeset
|
2295 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
|
2296 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
|
2297 ifh.close() |
| 46 | 2298 |
|
32886
ef015ba5ba2e
revlog: rename list of nodes from "content" to "nodes"
Martin von Zweigbergk <martinvonz@google.com>
parents:
32885
diff
changeset
|
2299 return nodes |
|
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
2300 |
|
24118
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
2301 def iscensored(self, rev): |
|
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
2302 """Check if a file revision is censored.""" |
|
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
2303 return False |
|
76f6ae06ddf5
revlog: add "iscensored()" to revlog public API
Mike Edgar <adgar@google.com>
parents:
24030
diff
changeset
|
2304 |
|
24255
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2305 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
|
2306 """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
|
2307 return False |
|
4bfe9f2d9761
revlog: addgroup checks if incoming deltas add censored revs, sets flag bit
Mike Edgar <adgar@google.com>
parents:
24123
diff
changeset
|
2308 |
|
20074
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2309 def getstrippoint(self, minlink): |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2310 """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
|
2311 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2312 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
|
2313 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
|
2314 """ |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2315 brokenrevs = set() |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2316 strippoint = len(self) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2317 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2318 heads = {} |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2319 futurelargelinkrevs = set() |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2320 for head in self.headrevs(): |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2321 headlinkrev = self.linkrev(head) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2322 heads[head] = headlinkrev |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2323 if headlinkrev >= minlink: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2324 futurelargelinkrevs.add(headlinkrev) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2325 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2326 # 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
|
2327 # 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
|
2328 # 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
|
2329 # 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
|
2330 # So we can stop walking. |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2331 while futurelargelinkrevs: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2332 strippoint -= 1 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2333 linkrev = heads.pop(strippoint) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2334 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2335 if linkrev < minlink: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2336 brokenrevs.add(strippoint) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2337 else: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2338 futurelargelinkrevs.remove(linkrev) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2339 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2340 for p in self.parentrevs(strippoint): |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2341 if p != nullrev: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2342 plinkrev = self.linkrev(p) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2343 heads[p] = plinkrev |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2344 if plinkrev >= minlink: |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2345 futurelargelinkrevs.add(plinkrev) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2346 |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2347 return strippoint, brokenrevs |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2348 |
|
8073
e8a28556a0a8
strip: make repair.strip transactional to avoid repository corruption
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
8017
diff
changeset
|
2349 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
|
2350 """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
|
2351 |
|
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
2352 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
|
2353 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
|
2354 |
|
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
2355 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
|
2356 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
|
2357 strip. |
|
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
2358 |
|
b9a830fa10f6
simplify revlog.strip interface and callers; add docstring
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5909
diff
changeset
|
2359 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
|
2360 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
|
2361 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
|
2362 """ |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2363 if len(self) == 0: |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2364 return |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2365 |
|
20074
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2366 rev, _ = self.getstrippoint(minlink) |
|
5fc2ae1c631b
strip: add faster revlog strip computation
Durham Goode <durham@fb.com>
parents:
20073
diff
changeset
|
2367 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
|
2368 return |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2369 |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2370 # first truncate the files on disk |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2371 end = self.start(rev) |
|
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
2372 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
|
2373 transaction.add(self.datafile, end) |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
2374 end = rev * self._io.size |
| 2073 | 2375 else: |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
2376 end += rev * self._io.size |
| 2072 | 2377 |
|
8073
e8a28556a0a8
strip: make repair.strip transactional to avoid repository corruption
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
8017
diff
changeset
|
2378 transaction.add(self.indexfile, end) |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2379 |
|
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2380 # then reset internal state in memory to forget those revisions |
| 4984 | 2381 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
|
2382 self._chaininfocache = {} |
|
8650
ef393d6ec030
revlog: refactor chunk cache interface again
Matt Mackall <mpm@selenic.com>
parents:
8643
diff
changeset
|
2383 self._chunkclear() |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2384 for x in xrange(rev, len(self)): |
| 2072 | 2385 del self.nodemap[self.node(x)] |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2386 |
|
4979
06abdaf78788
revlog: add a magic null revision to our index
Matt Mackall <mpm@selenic.com>
parents:
4978
diff
changeset
|
2387 del self.index[rev:-1] |
|
1535
7ae0ce7a3dc4
Add revlog.strip to truncate away revisions.
mason@suse.com
parents:
1533
diff
changeset
|
2388 |
|
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
2389 def checksize(self): |
|
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1469
diff
changeset
|
2390 expected = 0 |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2391 if len(self): |
|
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2392 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
|
2393 |
|
1494
249ca10d37f4
Handle empty logs in repo.checksize
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
2394 try: |
|
36011
82afb1a5ed94
revlog: use context manager for data file lifetime in checksize
Boris Feld <boris.feld@octobus.net>
parents:
36010
diff
changeset
|
2395 with self._datafp() as f: |
|
82afb1a5ed94
revlog: use context manager for data file lifetime in checksize
Boris Feld <boris.feld@octobus.net>
parents:
36010
diff
changeset
|
2396 f.seek(0, 2) |
|
82afb1a5ed94
revlog: use context manager for data file lifetime in checksize
Boris Feld <boris.feld@octobus.net>
parents:
36010
diff
changeset
|
2397 actual = f.tell() |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2398 dd = actual - expected |
|
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25459
diff
changeset
|
2399 except IOError as inst: |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2400 if inst.errno != errno.ENOENT: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2401 raise |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2402 dd = 0 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2403 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2404 try: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2405 f = self.opener(self.indexfile) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2406 f.seek(0, 2) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2407 actual = f.tell() |
|
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13284
diff
changeset
|
2408 f.close() |
|
4977
6cb30bc4ca32
revlog: parse revlogv0 indexes into v1 internally
Matt Mackall <mpm@selenic.com>
parents:
4976
diff
changeset
|
2409 s = self._io.size |
|
9029
0001e49f1c11
compat: use // for integer division
Alejandro Santos <alejolp@alejolp.com>
parents:
8658
diff
changeset
|
2410 i = max(0, actual // s) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2411 di = actual - (i * s) |
|
4982
9672e3c42b0c
revlog: change _inline from a function to a variable
Matt Mackall <mpm@selenic.com>
parents:
4981
diff
changeset
|
2412 if self._inline: |
| 2073 | 2413 databytes = 0 |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2414 for r in self: |
|
5312
fb070713ff36
revlog: more robust for damaged indexes
Matt Mackall <mpm@selenic.com>
parents:
5007
diff
changeset
|
2415 databytes += max(0, self.length(r)) |
| 2073 | 2416 dd = 0 |
|
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6703
diff
changeset
|
2417 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
|
2418 except IOError as inst: |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2419 if inst.errno != errno.ENOENT: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2420 raise |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2421 di = 0 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2422 |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1660
diff
changeset
|
2423 return (dd, di) |
|
6891
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
2424 |
|
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
2425 def files(self): |
|
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
2426 res = [self.indexfile] |
|
6891
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
2427 if not self._inline: |
|
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
2428 res.append(self.datafile) |
|
22cb82433842
revlog: add files method
Adrian Buehlmann <adrian@cadifra.com>
parents:
6872
diff
changeset
|
2429 return res |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2430 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2431 DELTAREUSEALWAYS = 'always' |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2432 DELTAREUSESAMEREVS = 'samerevs' |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2433 DELTAREUSENEVER = 'never' |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2434 |
|
35354
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2435 DELTAREUSEFULLADD = 'fulladd' |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2436 |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2437 DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'} |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2438 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2439 def clone(self, tr, destrevlog, addrevisioncb=None, |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2440 deltareuse=DELTAREUSESAMEREVS, aggressivemergedeltas=None): |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2441 """Copy this revlog to another, possibly with format changes. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2442 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2443 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
|
2444 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
|
2445 differences. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2446 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2447 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
|
2448 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
|
2449 following values: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2450 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2451 DELTAREUSEALWAYS |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2452 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
|
2453 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
|
2454 fastest mode of operation. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2455 DELTAREUSESAMEREVS |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2456 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
|
2457 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
|
2458 and optimization. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2459 DELTAREUSENEVER |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2460 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
|
2461 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
|
2462 algorithm changes). |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2463 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2464 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
|
2465 significantly affect run time. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2466 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2467 The default policy (``DELTAREUSESAMEREVS``) strikes a balance between |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2468 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
|
2469 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
|
2470 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
|
2471 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
|
2472 revision. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2473 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2474 In addition to the delta policy, the ``aggressivemergedeltas`` argument |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2475 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
|
2476 By default, the current default is used. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2477 """ |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2478 if deltareuse not in self.DELTAREUSEALL: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2479 raise ValueError(_('value for deltareuse invalid: %s') % deltareuse) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2480 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2481 if len(destrevlog): |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2482 raise ValueError(_('destination revlog is not empty')) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2483 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2484 if getattr(self, 'filteredrevs', None): |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2485 raise ValueError(_('source revlog has filtered revisions')) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2486 if getattr(destrevlog, 'filteredrevs', None): |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2487 raise ValueError(_('destination revlog has filtered revisions')) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2488 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2489 # 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
|
2490 oldlazydeltabase = destrevlog._lazydeltabase |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2491 oldamd = destrevlog._aggressivemergedeltas |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2492 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2493 try: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2494 if deltareuse == self.DELTAREUSEALWAYS: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2495 destrevlog._lazydeltabase = True |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2496 elif deltareuse == self.DELTAREUSESAMEREVS: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2497 destrevlog._lazydeltabase = False |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2498 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2499 destrevlog._aggressivemergedeltas = aggressivemergedeltas or oldamd |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2500 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2501 populatecachedelta = deltareuse in (self.DELTAREUSEALWAYS, |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2502 self.DELTAREUSESAMEREVS) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2503 |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2504 deltacomputer = _deltacomputer(destrevlog) |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2505 index = self.index |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2506 for rev in self: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2507 entry = index[rev] |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2508 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2509 # Some classes override linkrev to take filtered revs into |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2510 # account. Use raw entry from index. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2511 flags = entry[0] & 0xffff |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2512 linkrev = entry[4] |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2513 p1 = index[entry[5]][7] |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2514 p2 = index[entry[6]][7] |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2515 node = entry[7] |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2516 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2517 # (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
|
2518 # the revlog chunk is a delta. |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2519 cachedelta = None |
| 31759 | 2520 rawtext = None |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2521 if populatecachedelta: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2522 dp = self.deltaparent(rev) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2523 if dp != nullrev: |
|
36745
6bacb2f663cb
py3: use bytes() instead of str()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36744
diff
changeset
|
2524 cachedelta = (dp, bytes(self._chunk(rev))) |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2525 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2526 if not cachedelta: |
| 31759 | 2527 rawtext = self.revision(rev, raw=True) |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2528 |
|
35354
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2529 |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2530 if deltareuse == self.DELTAREUSEFULLADD: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2531 destrevlog.addrevision(rawtext, tr, linkrev, p1, p2, |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2532 cachedelta=cachedelta, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2533 node=node, flags=flags, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2534 deltacomputer=deltacomputer) |
|
35354
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2535 else: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2536 ifh = destrevlog.opener(destrevlog.indexfile, 'a+', |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2537 checkambig=False) |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2538 dfh = None |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2539 if not destrevlog._inline: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2540 dfh = destrevlog.opener(destrevlog.datafile, 'a+') |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2541 try: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2542 destrevlog._addrevision(node, rawtext, tr, linkrev, p1, |
|
35738
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2543 p2, flags, cachedelta, ifh, dfh, |
|
f90f6fd130c1
revlog: group delta computation methods under _deltacomputer object
Paul Morelle <paul.morelle@octobus.net>
parents:
35737
diff
changeset
|
2544 deltacomputer=deltacomputer) |
|
35354
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2545 finally: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2546 if dfh: |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2547 dfh.close() |
|
6226668a7169
upgrade: add a 'redeltafullall' mode
Boris Feld <boris.feld@octobus.net>
parents:
34898
diff
changeset
|
2548 ifh.close() |
|
30778
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2549 |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2550 if addrevisioncb: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2551 addrevisioncb(self, rev, node) |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2552 finally: |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2553 destrevlog._lazydeltabase = oldlazydeltabase |
|
1c7368d1a25f
revlog: add clone method
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30746
diff
changeset
|
2554 destrevlog._aggressivemergedeltas = oldamd |