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