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