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