mercurial/bundlerepo.py
author Remi Chaintron <remi@fb.com>
Tue, 10 Jan 2017 16:15:21 +0000
changeset 30745 c1b7b2285522
parent 30743 2df983125d37
child 30924 48dea083f66d
permissions -rw-r--r--
revlog: flag processor Add the ability for revlog objects to process revision flags and apply registered transforms on read/write operations. This patch introduces: - the 'revlog._processflags()' method that looks at revision flags and applies flag processors registered on them. Due to the need to handle non-commutative operations, flag transforms are applied in stable order but the order in which the transforms are applied is reversed between read and write operations. - the 'addflagprocessor()' method allowing to register processors on flags. Flag processors are defined as a 3-tuple of (read, write, raw) functions to be applied depending on the operation being performed. - an update on 'revlog.addrevision()' behavior. The current flagprocessor design relies on extensions to wrap around 'addrevision()' to set flags on revision data, and on the flagprocessor to perform the actual transformation of its contents. In the lfs case, this means we need to process flags before we meet the 2GB size check, leading to performing some operations before it happens: - if flags are set on the revision data, we assume some extensions might be modifying the contents using the flag processor next, and we compute the node for the original revision data (still allowing extension to override the node by wrapping around 'addrevision()'). - we then invoke the flag processor to apply registered transforms (in lfs's case, drastically reducing the size of large blobs). - finally, we proceed with the 2GB size check. Note: In the case a cachedelta is passed to 'addrevision()' and we detect the flag processor modified the revision data, we chose to trust the flag processor and drop the cachedelta.
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
# bundlerepo.py - repository class for viewing uncompressed bundles
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 2006, 2007 Benoit Boissinot <bboissin@gmail.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: 9676
diff changeset
     6
# GNU General Public License version 2 or any later version.
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
     7
8227
0a9542703300 turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents: 8226
diff changeset
     8
"""Repository class for viewing uncompressed bundles.
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 a read-only repository interface to bundles as if they
0a9542703300 turn some comments back into module docstrings
Martin Geisler <mg@lazybytes.net>
parents: 8226
diff changeset
    11
were part of the actual repository.
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
25920
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    14
from __future__ import absolute_import
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    15
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    16
import os
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    17
import shutil
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    18
import tempfile
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    19
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    20
from .i18n import _
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    21
from .node import nullid
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    22
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    23
from . import (
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    24
    bundle2,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    25
    changegroup,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    26
    changelog,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    27
    cmdutil,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    28
    discovery,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    29
    error,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    30
    exchange,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    31
    filelog,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    32
    localrepo,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    33
    manifest,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    34
    mdiff,
28714
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
    35
    node as nodemod,
25920
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    36
    pathutil,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    37
    phases,
30519
20a42325fdef py3: use pycompat.getcwd() instead of os.getcwd()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30375
diff changeset
    38
    pycompat,
25920
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    39
    revlog,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    40
    scmutil,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    41
    util,
5aaf51c14fea bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25830
diff changeset
    42
)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    43
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
    44
class bundlerevlog(revlog.revlog):
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    45
    def __init__(self, opener, indexfile, bundle, linkmapper):
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    46
        # How it works:
18410
de7dac2a58e8 bundlerepo: fix outdated comment
Mads Kiilerich <madski@unity3d.com>
parents: 18216
diff changeset
    47
        # To retrieve a revision, we need to know the offset of the revision in
de7dac2a58e8 bundlerepo: fix outdated comment
Mads Kiilerich <madski@unity3d.com>
parents: 18216
diff changeset
    48
        # the bundle (an unbundle object). We store this offset in the index
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
    49
        # (start). The base of the delta is stored in the base field.
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    50
        #
18410
de7dac2a58e8 bundlerepo: fix outdated comment
Mads Kiilerich <madski@unity3d.com>
parents: 18216
diff changeset
    51
        # To differentiate a rev in the bundle from a rev in the revlog, we
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
    52
        # check revision against repotiprev.
18215
5e851ca54189 bundlerepo: enforce reading from core repo only
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18142
diff changeset
    53
        opener = scmutil.readonlyvfs(opener)
4257
1b5c38e9d7aa revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents: 4029
diff changeset
    54
        revlog.revlog.__init__(self, opener, indexfile)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
    55
        self.bundle = bundle
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
    56
        n = len(self)
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
    57
        self.repotiprev = n - 1
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    58
        chain = None
18411
8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents: 18410
diff changeset
    59
        self.bundlerevs = set() # used by 'bundle()' revset expression
29711
ac5f6b11aa91 bundlerevlog: use for loop over iterator instead of while True
Augie Fackler <augie@google.com>
parents: 29710
diff changeset
    60
        getchunk = lambda: bundle.deltachunk(chain)
ac5f6b11aa91 bundlerevlog: use for loop over iterator instead of while True
Augie Fackler <augie@google.com>
parents: 29710
diff changeset
    61
        for chunkdata in iter(getchunk, {}):
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    62
            node = chunkdata['node']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    63
            p1 = chunkdata['p1']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    64
            p2 = chunkdata['p2']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    65
            cs = chunkdata['cs']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    66
            deltabase = chunkdata['deltabase']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    67
            delta = chunkdata['delta']
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    68
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    69
            size = len(delta)
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    70
            start = bundle.tell() - size
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    71
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    72
            link = linkmapper(cs)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    73
            if node in self.nodemap:
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    74
                # this can happen if two branches make the same change
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    75
                chain = node
18411
8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents: 18410
diff changeset
    76
                self.bundlerevs.add(self.nodemap[node])
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    77
                continue
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    78
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    79
            for p in (p1, p2):
16686
67964cda8701 cleanup: "not x in y" -> "x not in y"
Brodie Rao <brodie@sf.io>
parents: 16683
diff changeset
    80
                if p not in self.nodemap:
9650
1ad02c04356c bundlerepo: fix small bug in exception raising
Sune Foldager <cryo@cyanite.org>
parents: 9198
diff changeset
    81
                    raise error.LookupError(p, self.indexfile,
7633
08cabecfa8a8 errors: move revlog errors
Matt Mackall <mpm@selenic.com>
parents: 7435
diff changeset
    82
                                            _("unknown parent"))
18416
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    83
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    84
            if deltabase not in self.nodemap:
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    85
                raise LookupError(deltabase, self.indexfile,
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    86
                                  _('unknown delta base'))
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    87
87f370c5fef5 bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents: 18415
diff changeset
    88
            baserev = self.rev(deltabase)
5167
aba624d2301d fix bundlerepo broken by 4205f626dc05
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 4989
diff changeset
    89
            # start, size, full unc. size, base (unused), link, p1, p2, node
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
    90
            e = (revlog.offset_type(start, 0), size, -1, baserev, link,
4979
06abdaf78788 revlog: add a magic null revision to our index
Matt Mackall <mpm@selenic.com>
parents: 4918
diff changeset
    91
                 self.rev(p1), self.rev(p2), node)
06abdaf78788 revlog: add a magic null revision to our index
Matt Mackall <mpm@selenic.com>
parents: 4918
diff changeset
    92
            self.index.insert(-1, e)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    93
            self.nodemap[node] = n
18411
8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents: 18410
diff changeset
    94
            self.bundlerevs.add(n)
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
    95
            chain = node
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    96
            n += 1
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
    97
9676
48bf28d3c8dd bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9650
diff changeset
    98
    def _chunk(self, rev):
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
    99
        # Warning: in case of bundle, the diff is against what we stored as
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   100
        # delta base, not against rev - 1
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   101
        # XXX: could use some caching
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   102
        if rev <= self.repotiprev:
9676
48bf28d3c8dd bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9650
diff changeset
   103
            return revlog.revlog._chunk(self, rev)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   104
        self.bundle.seek(self.start(rev))
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   105
        return self.bundle.read(self.length(rev))
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   106
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   107
    def revdiff(self, rev1, rev2):
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   108
        """return or calculate a delta between two revisions"""
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   109
        if rev1 > self.repotiprev and rev2 > self.repotiprev:
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   110
            # hot path for bundle
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   111
            revb = self.index[rev2][3]
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   112
            if revb == rev1:
9676
48bf28d3c8dd bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9650
diff changeset
   113
                return self._chunk(rev2)
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   114
        elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
4028
540d1059c802 bundlerepo: it was meant to be revdiff() instead of chunk()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3791
diff changeset
   115
            return revlog.revlog.revdiff(self, rev1, rev2)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   116
4989
1aaed3d69772 revlog: eliminate diff and patches functions
Matt Mackall <mpm@selenic.com>
parents: 4988
diff changeset
   117
        return mdiff.textdiff(self.revision(self.node(rev1)),
18413
0ccb16f5956a bundlerepo: drop bundlebase wrapper function for basemap
Mads Kiilerich <madski@unity3d.com>
parents: 18412
diff changeset
   118
                              self.revision(self.node(rev2)))
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   119
30743
2df983125d37 revlog: add 'raw' argument to revision and _addrevision
Remi Chaintron <remi@fb.com>
parents: 30584
diff changeset
   120
    def revision(self, nodeorrev, raw=False):
16435
df347129305d revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents: 16375
diff changeset
   121
        """return an uncompressed revision of a given node or revision
df347129305d revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents: 16375
diff changeset
   122
        number.
df347129305d revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents: 16375
diff changeset
   123
        """
16375
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   124
        if isinstance(nodeorrev, int):
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   125
            rev = nodeorrev
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   126
            node = self.node(rev)
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   127
        else:
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   128
            node = nodeorrev
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   129
            rev = self.rev(node)
d7d64b89a65c revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents: 16195
diff changeset
   130
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10263
diff changeset
   131
        if node == nullid:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10263
diff changeset
   132
            return ""
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   133
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   134
        text = None
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   135
        chain = []
18415
95b8629fd2de bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents: 18414
diff changeset
   136
        iterrev = rev
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   137
        # reconstruct the revision if it is from a changegroup
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   138
        while iterrev > self.repotiprev:
18415
95b8629fd2de bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents: 18414
diff changeset
   139
            if self._cache and self._cache[1] == iterrev:
4984
b4066fcbd6ba revlog: mark cache private
Matt Mackall <mpm@selenic.com>
parents: 4979
diff changeset
   140
                text = self._cache[2]
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   141
                break
18415
95b8629fd2de bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents: 18414
diff changeset
   142
            chain.append(iterrev)
18643
cc28a84db8c9 bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents: 18568
diff changeset
   143
            iterrev = self.index[iterrev][3]
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   144
        if text is None:
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   145
            text = self.baserevision(iterrev)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   146
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   147
        while chain:
9676
48bf28d3c8dd bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9650
diff changeset
   148
            delta = self._chunk(chain.pop())
4989
1aaed3d69772 revlog: eliminate diff and patches functions
Matt Mackall <mpm@selenic.com>
parents: 4988
diff changeset
   149
            text = mdiff.patches(text, [delta])
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   150
30745
c1b7b2285522 revlog: flag processor
Remi Chaintron <remi@fb.com>
parents: 30743
diff changeset
   151
        text, validatehash = self._processflags(text, self.flags(rev),
c1b7b2285522 revlog: flag processor
Remi Chaintron <remi@fb.com>
parents: 30743
diff changeset
   152
                                                'read', raw=raw)
c1b7b2285522 revlog: flag processor
Remi Chaintron <remi@fb.com>
parents: 30743
diff changeset
   153
        if validatehash:
c1b7b2285522 revlog: flag processor
Remi Chaintron <remi@fb.com>
parents: 30743
diff changeset
   154
            self.checkhash(text, node, rev=rev)
18415
95b8629fd2de bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents: 18414
diff changeset
   155
        self._cache = (node, rev, text)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   156
        return text
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   157
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   158
    def baserevision(self, nodeorrev):
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   159
        # Revlog subclasses may override 'revision' method to modify format of
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   160
        # content retrieved from revlog. To use bundlerevlog with such class one
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   161
        # needs to override 'baserevision' and make more specific call here.
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   162
        return revlog.revlog.revision(self, nodeorrev)
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   163
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   164
    def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   165
        raise NotImplementedError
6647
602f7c1ab954 drop superfluous param from revlog.addgroup()
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 6569
diff changeset
   166
    def addgroup(self, revs, linkmapper, transaction):
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   167
        raise NotImplementedError
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   168
    def strip(self, rev, minlink):
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   169
        raise NotImplementedError
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   170
    def checksize(self):
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   171
        raise NotImplementedError
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   172
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
   173
class bundlechangelog(bundlerevlog, changelog.changelog):
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   174
    def __init__(self, opener, bundle):
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
   175
        changelog.changelog.__init__(self, opener)
14142
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
   176
        linkmapper = lambda x: x
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
   177
        bundlerevlog.__init__(self, opener, self.indexfile, bundle,
cb91ea6af733 bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14076
diff changeset
   178
                              linkmapper)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   179
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   180
    def baserevision(self, nodeorrev):
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   181
        # Although changelog doesn't override 'revision' method, some extensions
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   182
        # may replace this class with another that does. Same story with
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   183
        # manifest and filelog classes.
24882
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   184
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   185
        # This bypasses filtering on changelog.node() and rev() because we need
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   186
        # revision text of the bundle base even if it is hidden.
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   187
        oldfilter = self.filteredrevs
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   188
        try:
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   189
            self.filteredrevs = ()
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   190
            return changelog.changelog.revision(self, nodeorrev)
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   191
        finally:
995003a324da bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents: 24834
diff changeset
   192
            self.filteredrevs = oldfilter
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   193
30373
31de088945cd manifest: add bundlemanifestlog support
Durham Goode <durham@fb.com>
parents: 30218
diff changeset
   194
class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
29715
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   195
    def __init__(self, opener, bundle, linkmapper, dirlogstarts=None, dir=''):
30373
31de088945cd manifest: add bundlemanifestlog support
Durham Goode <durham@fb.com>
parents: 30218
diff changeset
   196
        manifest.manifestrevlog.__init__(self, opener, dir=dir)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   197
        bundlerevlog.__init__(self, opener, self.indexfile, bundle,
4257
1b5c38e9d7aa revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents: 4029
diff changeset
   198
                              linkmapper)
29715
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   199
        if dirlogstarts is None:
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   200
            dirlogstarts = {}
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   201
            if self.bundle.version == "03":
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   202
                dirlogstarts = _getfilestarts(self.bundle)
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   203
        self._dirlogstarts = dirlogstarts
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   204
        self._linkmapper = linkmapper
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   205
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   206
    def baserevision(self, nodeorrev):
26399
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   207
        node = nodeorrev
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   208
        if isinstance(node, int):
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   209
            node = self.node(node)
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   210
29925
1619efcde9a4 manifest: make one use of _mancache avoid manifestctxs
Durham Goode <durham@fb.com>
parents: 29916
diff changeset
   211
        if node in self.fulltextcache:
1619efcde9a4 manifest: make one use of _mancache avoid manifestctxs
Durham Goode <durham@fb.com>
parents: 29916
diff changeset
   212
            result = self.fulltextcache[node].tostring()
26399
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   213
        else:
30373
31de088945cd manifest: add bundlemanifestlog support
Durham Goode <durham@fb.com>
parents: 30218
diff changeset
   214
            result = manifest.manifestrevlog.revision(self, nodeorrev)
26399
1f0e78f8f55f bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents: 25920
diff changeset
   215
        return result
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   216
29715
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   217
    def dirlog(self, d):
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   218
        if d in self._dirlogstarts:
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   219
            self.bundle.seek(self._dirlogstarts[d])
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   220
            return bundlemanifest(
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   221
                self.opener, self.bundle, self._linkmapper,
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   222
                self._dirlogstarts, dir=d)
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   223
        return super(bundlemanifest, self).dirlog(d)
55d341877316 bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents: 29713
diff changeset
   224
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
   225
class bundlefilelog(bundlerevlog, filelog.filelog):
24921
86c0b5c09ee6 bundlerepo: remove unused 'repo' parameter
Martin von Zweigbergk <martinvonz@google.com>
parents: 24882
diff changeset
   226
    def __init__(self, opener, path, bundle, linkmapper):
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
   227
        filelog.filelog.__init__(self, opener, path)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   228
        bundlerevlog.__init__(self, opener, self.indexfile, bundle,
4257
1b5c38e9d7aa revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents: 4029
diff changeset
   229
                              linkmapper)
14287
7c231754a621 filelog: add file function to open other filelogs
Sune Foldager <cryo@cyanite.org>
parents: 14190
diff changeset
   230
19629
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   231
    def baserevision(self, nodeorrev):
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   232
        return filelog.filelog.revision(self, nodeorrev)
81241f978fd2 bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents: 18825
diff changeset
   233
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   234
class bundlepeer(localrepo.localpeer):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   235
    def canpush(self):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   236
        return False
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   237
23631
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   238
class bundlephasecache(phases.phasecache):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   239
    def __init__(self, *args, **kwargs):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   240
        super(bundlephasecache, self).__init__(*args, **kwargs)
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   241
        if util.safehasattr(self, 'opener'):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   242
            self.opener = scmutil.readonlyvfs(self.opener)
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   243
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   244
    def write(self):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   245
        raise NotImplementedError
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   246
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   247
    def _write(self, fp):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   248
        raise NotImplementedError
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   249
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   250
    def _updateroots(self, phase, newroots, tr):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   251
        self.phaseroots[phase] = newroots
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   252
        self.invalidate()
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   253
        self.dirty = True
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   254
29712
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   255
def _getfilestarts(bundle):
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   256
    bundlefilespos = {}
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   257
    for chunkdata in iter(bundle.filelogheader, {}):
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   258
        fname = chunkdata['filename']
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   259
        bundlefilespos[fname] = bundle.tell()
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   260
        for chunk in iter(lambda: bundle.deltachunk(None), {}):
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   261
            pass
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   262
    return bundlefilespos
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   263
1946
9fee186f7f0d bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1942
diff changeset
   264
class bundlerepository(localrepo.localrepository):
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   265
    def __init__(self, ui, path, bundlename):
26800
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   266
        def _writetempbundle(read, suffix, header=''):
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   267
            """Write a temporary file to disk
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   268
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   269
            This is closure because we need to make sure this tracked by
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   270
            self.tempfile for cleanup purposes."""
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   271
            fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-",
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   272
                                            suffix=".hg10un")
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   273
            self.tempfile = temp
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   274
27776
6fe2da48a6dd bundlerepo: use context manager for file I/O in _writetempbundle
Bryan O'Sullivan <bryano@fb.com>
parents: 27753
diff changeset
   275
            with os.fdopen(fdtemp, 'wb') as fptemp:
26800
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   276
                fptemp.write(header)
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   277
                while True:
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   278
                    chunk = read(2**18)
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   279
                    if not chunk:
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   280
                        break
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   281
                    fptemp.write(chunk)
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   282
7cac6ee41be7 bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26587
diff changeset
   283
            return self.vfs.open(self.tempfile, mode="rb")
6314
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   284
        self._tempparent = None
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   285
        try:
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   286
            localrepo.localrepository.__init__(self, ui, path)
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   287
        except error.RepoError:
6314
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   288
            self._tempparent = tempfile.mkdtemp()
9198
061eeb602354 coding style: use a space after comma
Martin Geisler <mg@lazybytes.net>
parents: 8312
diff changeset
   289
            localrepo.instance(ui, self._tempparent, 1)
6314
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   290
            localrepo.localrepository.__init__(self, ui, self._tempparent)
20790
49f2d5644f04 config: set a 'source' in most cases where config don't come from file but code
Mads Kiilerich <madski@unity3d.com>
parents: 19629
diff changeset
   291
        self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2273
diff changeset
   292
6129
3d666e8e6398 bundlerepo: fix inconsistency of parsed and internal name (issue #821)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5664
diff changeset
   293
        if path:
11154
17031fea4e95 expand paths to local repository or bundle in appropriate classes
Alexander Solovyov <piranha@piranha.org.ua>
parents: 10282
diff changeset
   294
            self._url = 'bundle:' + util.expandpath(path) + '+' + bundlename
6129
3d666e8e6398 bundlerepo: fix inconsistency of parsed and internal name (issue #821)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5664
diff changeset
   295
        else:
3d666e8e6398 bundlerepo: fix inconsistency of parsed and internal name (issue #821)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5664
diff changeset
   296
            self._url = 'bundle:' + bundlename
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2273
diff changeset
   297
2273
f116ddea537f add support for compressed bundle repositories
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 2257
diff changeset
   298
        self.tempfile = None
13274
57d433f632b7 bundlerepo: use less intrusive util.posixfile to open bundle
Adrian Buehlmann <adrian@cadifra.com>
parents: 12962
diff changeset
   299
        f = util.posixfile(bundlename, "rb")
24072
145b823f5ce7 bundlerepo: keep track of the original bundle object
Eric Sumner <ericsumner@fb.com>
parents: 24003
diff changeset
   300
        self.bundlefile = self.bundle = exchange.readbundle(ui, f, bundlename)
12044
bcc7139521b7 bundlerepo: remove duplication of bundle decompressors
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
   301
24073
ff5caa8dfd99 bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents: 24072
diff changeset
   302
        if isinstance(self.bundle, bundle2.unbundle20):
26803
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   303
            cgstream = None
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   304
            for part in self.bundle.iterparts():
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   305
                if part.type == 'changegroup':
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   306
                    if cgstream is not None:
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   307
                        raise NotImplementedError("can't process "
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   308
                                                  "multiple changegroups")
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   309
                    cgstream = part
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   310
                    version = part.params.get('version', '01')
29713
43924f3a55fa bundlerepo: use supportedincomingversions instead of allsupportedversions
Augie Fackler <augie@google.com>
parents: 29712
diff changeset
   311
                    legalcgvers = changegroup.supportedincomingversions(self)
43924f3a55fa bundlerepo: use supportedincomingversions instead of allsupportedversions
Augie Fackler <augie@google.com>
parents: 29712
diff changeset
   312
                    if version not in legalcgvers:
26803
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   313
                        msg = _('Unsupported changegroup version: %s')
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   314
                        raise error.Abort(msg % version)
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   315
                    if self.bundle.compressed():
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   316
                        cgstream = _writetempbundle(part.read,
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   317
                                                    ".cg%sun" % version)
24073
ff5caa8dfd99 bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents: 24072
diff changeset
   318
26803
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   319
            if cgstream is None:
29389
98e8313dcd9e i18n: translate abort messages
liscju <piotr.listkiewicz@gmail.com>
parents: 28714
diff changeset
   320
                raise error.Abort(_('No changegroups found'))
26803
ed41ce89822d bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26801
diff changeset
   321
            cgstream.seek(0)
24073
ff5caa8dfd99 bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents: 24072
diff changeset
   322
27751
a40e2f7fe49d changegroup: hide packermap behind methods
Martin von Zweigbergk <martinvonz@google.com>
parents: 26803
diff changeset
   323
            self.bundle = changegroup.getunbundler(version, cgstream, 'UN')
24073
ff5caa8dfd99 bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents: 24072
diff changeset
   324
26801
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   325
        elif self.bundle.compressed():
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   326
            f = _writetempbundle(self.bundle.read, '.hg10un', header='HG10UN')
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   327
            self.bundlefile = self.bundle = exchange.readbundle(ui, f,
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   328
                                                                bundlename,
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   329
                                                                self.vfs)
73bf76bf6f14 bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26800
diff changeset
   330
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   331
        # dict with the mapping 'filename' -> position in the bundle
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   332
        self.bundlefilespos = {}
5262
a35756389ef4 Make bundlerepo lazier
Brendan Cully <brendan@kublai.com>
parents: 5167
diff changeset
   333
23632
e7fcf58acd71 bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents: 23631
diff changeset
   334
        self.firstnewrev = self.changelog.repotiprev + 1
e7fcf58acd71 bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents: 23631
diff changeset
   335
        phases.retractboundary(self, None, phases.draft,
e7fcf58acd71 bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents: 23631
diff changeset
   336
                               [ctx.node() for ctx in self[self.firstnewrev:]])
e7fcf58acd71 bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents: 23631
diff changeset
   337
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17913
diff changeset
   338
    @localrepo.unfilteredpropertycache
23631
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   339
    def _phasecache(self):
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   340
        return bundlephasecache(self, self._phasedefaults)
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   341
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 22182
diff changeset
   342
    @localrepo.unfilteredpropertycache
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   343
    def changelog(self):
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14142
diff changeset
   344
        # consume the header if it exists
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14142
diff changeset
   345
        self.bundle.changelogheader()
23878
37a92908a382 localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 23633
diff changeset
   346
        c = bundlechangelog(self.svfs, self.bundle)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   347
        self.manstart = self.bundle.tell()
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   348
        return c
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   349
30218
1767723f71cf manifest: move manifest creation to a helper function
Durham Goode <durham@fb.com>
parents: 29925
diff changeset
   350
    def _constructmanifest(self):
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   351
        self.bundle.seek(self.manstart)
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14142
diff changeset
   352
        # consume the header if it exists
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14142
diff changeset
   353
        self.bundle.manifestheader()
28221
7a8c44844f57 bundlerepo: properly handle hidden linkrev in manifestlog (issue4945)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28186
diff changeset
   354
        linkmapper = self.unfiltered().changelog.rev
7a8c44844f57 bundlerepo: properly handle hidden linkrev in manifestlog (issue4945)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28186
diff changeset
   355
        m = bundlemanifest(self.svfs, self.bundle, linkmapper)
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   356
        self.filestart = self.bundle.tell()
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   357
        return m
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   358
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17913
diff changeset
   359
    @localrepo.unfilteredpropertycache
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   360
    def manstart(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   361
        self.changelog
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   362
        return self.manstart
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   363
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17913
diff changeset
   364
    @localrepo.unfilteredpropertycache
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   365
    def filestart(self):
30375
11b8b740d54a manifest: remove last uses of repo.manifest
Durham Goode <durham@fb.com>
parents: 30373
diff changeset
   366
        self.manifestlog
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8227
diff changeset
   367
        return self.filestart
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   368
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2273
diff changeset
   369
    def url(self):
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2273
diff changeset
   370
        return self._url
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2273
diff changeset
   371
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   372
    def file(self, f):
5262
a35756389ef4 Make bundlerepo lazier
Brendan Cully <brendan@kublai.com>
parents: 5167
diff changeset
   373
        if not self.bundlefilespos:
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   374
            self.bundle.seek(self.filestart)
29712
9e88077f972c bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents: 29711
diff changeset
   375
            self.bundlefilespos = _getfilestarts(self.bundle)
5262
a35756389ef4 Make bundlerepo lazier
Brendan Cully <brendan@kublai.com>
parents: 5167
diff changeset
   376
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   377
        if f in self.bundlefilespos:
12332
680fe77ab5b8 bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents: 12331
diff changeset
   378
            self.bundle.seek(self.bundlefilespos[f])
28186
5ab6f0fde75f bundlerepo: properly handle hidden linkrev in filelog (issue4945)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 27953
diff changeset
   379
            linkmapper = self.unfiltered().changelog.rev
5ab6f0fde75f bundlerepo: properly handle hidden linkrev in filelog (issue4945)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 27953
diff changeset
   380
            return bundlefilelog(self.svfs, f, self.bundle, linkmapper)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   381
        else:
23878
37a92908a382 localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 23633
diff changeset
   382
            return filelog.filelog(self.svfs, f)
1942
9da45de3118d add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff changeset
   383
12347
6277a9469dff bundlerepo: restore close() method
Matt Mackall <mpm@selenic.com>
parents: 12335
diff changeset
   384
    def close(self):
6277a9469dff bundlerepo: restore close() method
Matt Mackall <mpm@selenic.com>
parents: 12335
diff changeset
   385
        """Close assigned bundle file immediately."""
24072
145b823f5ce7 bundlerepo: keep track of the original bundle object
Eric Sumner <ericsumner@fb.com>
parents: 24003
diff changeset
   386
        self.bundlefile.close()
12962
ff083040a555 bundlerepository: get rid of temporary bundle files (issue2478)
Klaus Koch <kuk42@gmx.net>
parents: 12961
diff changeset
   387
        if self.tempfile is not None:
20981
4fdd1172d37e bundlerepo: treat temporarily extracted bundle file via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20790
diff changeset
   388
            self.vfs.unlink(self.tempfile)
6314
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   389
        if self._tempparent:
9a1c59283ad3 Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 6312
diff changeset
   390
            shutil.rmtree(self._tempparent, True)
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   391
6315
5c96a4bca66b clone: use cancopy
Matt Mackall <mpm@selenic.com>
parents: 6314
diff changeset
   392
    def cancopy(self):
5c96a4bca66b clone: use cancopy
Matt Mackall <mpm@selenic.com>
parents: 6314
diff changeset
   393
        return False
5c96a4bca66b clone: use cancopy
Matt Mackall <mpm@selenic.com>
parents: 6314
diff changeset
   394
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   395
    def peer(self):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   396
        return bundlepeer(self)
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17191
diff changeset
   397
7435
5e13df32fb74 bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 6953
diff changeset
   398
    def getcwd(self):
30519
20a42325fdef py3: use pycompat.getcwd() instead of os.getcwd()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30375
diff changeset
   399
        return pycompat.getcwd() # always outside the repo
7435
5e13df32fb74 bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 6953
diff changeset
   400
28714
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   401
    # Check if parents exist in localrepo before setting
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   402
    def setparents(self, p1, p2=nullid):
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   403
        p1rev = self.changelog.rev(p1)
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   404
        p2rev = self.changelog.rev(p2)
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   405
        msg = _("setting parent to node %s that only exists in the bundle\n")
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   406
        if self.changelog.repotiprev < p1rev:
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   407
            self.ui.warn(msg % nodemod.hex(p1))
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   408
        if self.changelog.repotiprev < p2rev:
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   409
            self.ui.warn(msg % nodemod.hex(p2))
dac81729fea4 bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents: 28666
diff changeset
   410
        return super(bundlerepository, self).setparents(p1, p2)
15597
bc0778f5619a bundlerepo: don't write branch cache to disk
Sune Foldager <cryo@cyanite.org>
parents: 15091
diff changeset
   411
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   412
def instance(ui, path, create):
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   413
    if create:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26544
diff changeset
   414
        raise error.Abort(_('cannot create new bundle repository'))
25830
5418dd5be8ac bundlerepo: mark internal-only config variable
Matt Mackall <mpm@selenic.com>
parents: 24921
diff changeset
   415
    # internal config: bundle.mainreporoot
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   416
    parentpath = ui.config("bundle", "mainreporoot", "")
16042
4b7aa1c899dc bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents: 15597
diff changeset
   417
    if not parentpath:
4b7aa1c899dc bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents: 15597
diff changeset
   418
        # try to find the correct path to the working directory repo
30519
20a42325fdef py3: use pycompat.getcwd() instead of os.getcwd()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30375
diff changeset
   419
        parentpath = cmdutil.findrepo(pycompat.getcwd())
16042
4b7aa1c899dc bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents: 15597
diff changeset
   420
        if parentpath is None:
4b7aa1c899dc bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents: 15597
diff changeset
   421
            parentpath = ''
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   422
    if parentpath:
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   423
        # Try to make the full path relative so we get a nice, short URL.
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   424
        # In particular, we don't want temp dir names in test outputs.
30519
20a42325fdef py3: use pycompat.getcwd() instead of os.getcwd()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30375
diff changeset
   425
        cwd = pycompat.getcwd()
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   426
        if parentpath == cwd:
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   427
            parentpath = ''
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   428
        else:
24834
6e31e1274080 bundlerepo: use pathutil.normasprefix to ensure os.sep at the end of cwd
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 24686
diff changeset
   429
            cwd = pathutil.normasprefix(cwd)
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   430
            if parentpath.startswith(cwd):
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   431
                parentpath = parentpath[len(cwd):]
14076
924c82157d46 url: move URL parsing functions into util to improve startup time
Brodie Rao <brodie@bitheap.org>
parents: 14073
diff changeset
   432
    u = util.url(path)
13826
e574207e3bcd url: refactor util.drop_scheme() and hg.localpath() into url.localpath()
Brodie Rao <brodie@bitheap.org>
parents: 13742
diff changeset
   433
    path = u.localpath()
e574207e3bcd url: refactor util.drop_scheme() and hg.localpath() into url.localpath()
Brodie Rao <brodie@bitheap.org>
parents: 13742
diff changeset
   434
    if u.scheme == 'bundle':
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   435
        s = path.split("+", 1)
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   436
        if len(s) == 1:
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   437
            repopath, bundlename = parentpath, s[0]
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   438
        else:
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   439
            repopath, bundlename = s
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   440
    else:
5664
da72b4d24797 Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 5558
diff changeset
   441
        repopath, bundlename = parentpath, path
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
   442
    return bundlerepository(ui, repopath, bundlename)
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   443
23633
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   444
class bundletransactionmanager(object):
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   445
    def transaction(self):
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   446
        return None
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   447
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   448
    def close(self):
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   449
        raise NotImplementedError
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   450
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   451
    def release(self):
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   452
        raise NotImplementedError
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   453
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   454
def getremotechanges(ui, repo, other, onlyheads=None, bundlename=None,
14073
72c84f24b420 discovery: drop findoutgoing and simplify findcommonincoming's api
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14004
diff changeset
   455
                     force=False):
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   456
    '''obtains a bundle of changes incoming from other
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   457
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   458
    "onlyheads" restricts the returned changes to those reachable from the
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   459
      specified heads.
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   460
    "bundlename", if given, stores the bundle to this file path permanently;
14190
8aab5a82685f bundlerepo: fix closing and docstring of getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14161
diff changeset
   461
      otherwise it's stored to a temp file and gets deleted again when you call
8aab5a82685f bundlerepo: fix closing and docstring of getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14161
diff changeset
   462
      the returned "cleanupfn".
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   463
    "force" indicates whether to proceed on unrelated repos.
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   464
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   465
    Returns a tuple (local, csets, cleanupfn):
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   466
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   467
    "local" is a local repo from which to obtain the actual incoming
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   468
      changesets; it is a bundlerepo for the obtained bundle when the
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   469
      original "other" is remote.
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   470
    "csets" lists the incoming changeset node ids.
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   471
    "cleanupfn" must be called without arguments when you're done processing
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   472
      the changes; it closes both the original "other" and the one returned
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   473
      here.
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   474
    '''
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   475
    tmp = discovery.findcommonincoming(repo, other, heads=onlyheads,
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16435
diff changeset
   476
                                       force=force)
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   477
    common, incoming, rheads = tmp
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   478
    if not incoming:
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   479
        try:
15091
106f89299da6 bundlerepo: add argument check before unlink
Sune Foldager <cryo@cyanite.org>
parents: 14494
diff changeset
   480
            if bundlename:
21694
c08a22bfa16e bundlerepo: backout dbf292f65b09
Matt Mackall <mpm@selenic.com>
parents: 21562
diff changeset
   481
                os.unlink(bundlename)
14004
97ed99d1f419 eliminate various naked except clauses
Idan Kamara <idankk86@gmail.com>
parents: 13826
diff changeset
   482
        except OSError:
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   483
            pass
18138
8ab0640c3090 bundlerepo: don't return the peer without bundlerepo from getremotechanges
Mads Kiilerich <madski@unity3d.com>
parents: 17193
diff changeset
   484
        return repo, [], other.close
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   485
22182
510cafe72004 incoming: don't request heads that already are common
Mads Kiilerich <madski@unity3d.com>
parents: 21694
diff changeset
   486
    commonset = set(common)
510cafe72004 incoming: don't request heads that already are common
Mads Kiilerich <madski@unity3d.com>
parents: 21694
diff changeset
   487
    rheads = [x for x in rheads if x not in commonset]
510cafe72004 incoming: don't request heads that already are common
Mads Kiilerich <madski@unity3d.com>
parents: 21694
diff changeset
   488
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   489
    bundle = None
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   490
    bundlerepo = None
17191
5884812686f7 peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents: 16686
diff changeset
   491
    localrepo = other.local()
5884812686f7 peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents: 16686
diff changeset
   492
    if bundlename or not localrepo:
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   493
        # create a bundle (uncompressed if other repo is not local)
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   494
29684
ff5d5751fc1b bundlerepo: also read the 'devel.legacy.exchange' config
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29389
diff changeset
   495
        # developer config: devel.legacy.exchange
ff5d5751fc1b bundlerepo: also read the 'devel.legacy.exchange' config
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29389
diff changeset
   496
        legexc = ui.configlist('devel', 'legacy.exchange')
29689
39537bc64442 bundle2: remove 'experimental.bundle2-exp' boolean config (BC)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29684
diff changeset
   497
        forcebundle1 = 'bundle2' not in legexc and 'bundle1' in legexc
29684
ff5d5751fc1b bundlerepo: also read the 'devel.legacy.exchange' config
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29389
diff changeset
   498
        canbundle2 = (not forcebundle1
26544
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   499
                      and other.capable('getbundle')
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   500
                      and other.capable('bundle2'))
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   501
        if canbundle2:
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   502
            kwargs = {}
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   503
            kwargs['common'] = common
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   504
            kwargs['heads'] = rheads
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   505
            kwargs['bundlecaps'] = exchange.caps20to10(repo)
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   506
            kwargs['cg'] = True
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   507
            b2 = other.getbundle('incoming', **kwargs)
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   508
            fname = bundle = changegroup.writechunks(ui, b2._forwardchunks(),
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   509
                                                     bundlename)
1e8e0b01faba incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26543
diff changeset
   510
        else:
26543
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   511
            if other.capable('getbundle'):
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   512
                cg = other.getbundle('incoming', common=common, heads=rheads)
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   513
            elif onlyheads is None and not other.capable('changegroupsubset'):
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   514
                # compat with older servers when pulling all remote heads
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   515
                cg = other.changegroup(incoming, "incoming")
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   516
                rheads = None
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   517
            else:
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   518
                cg = other.changegroupsubset(incoming, rheads, 'incoming')
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   519
            if localrepo:
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   520
                bundletype = "HG10BZ"
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   521
            else:
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   522
                bundletype = "HG10UN"
28666
ae53ecc47414 bundle: move writebundle() from changegroup.py to bundle2.py (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 28221
diff changeset
   523
            fname = bundle = bundle2.writebundle(ui, cg, bundlename,
26543
a018cbabdb51 bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26399
diff changeset
   524
                                                     bundletype)
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   525
        # keep written bundle?
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   526
        if bundlename:
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   527
            bundle = None
17191
5884812686f7 peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents: 16686
diff changeset
   528
        if not localrepo:
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   529
            # use the created uncompressed bundlerepo
18825
f0564402d059 repo: repo isolation, do not pass on repo.ui for creating new repos
Simon Heimberg <simohe@besonet.ch>
parents: 18643
diff changeset
   530
            localrepo = bundlerepo = bundlerepository(repo.baseui, repo.root,
f0564402d059 repo: repo isolation, do not pass on repo.ui for creating new repos
Simon Heimberg <simohe@besonet.ch>
parents: 18643
diff changeset
   531
                                                      fname)
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   532
            # this repo contains local and other now, so filter out local again
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   533
            common = repo.heads()
18568
cd403d6d96ef incoming: fix incoming when a local head is remotely filtered (issue3805)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18418
diff changeset
   534
    if localrepo:
cd403d6d96ef incoming: fix incoming when a local head is remotely filtered (issue3805)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18418
diff changeset
   535
        # Part of common may be remotely filtered
cd403d6d96ef incoming: fix incoming when a local head is remotely filtered (issue3805)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18418
diff changeset
   536
        # So use an unfiltered version
cd403d6d96ef incoming: fix incoming when a local head is remotely filtered (issue3805)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18418
diff changeset
   537
        # The discovery process probably need cleanup to avoid that
cd403d6d96ef incoming: fix incoming when a local head is remotely filtered (issue3805)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18418
diff changeset
   538
        localrepo = localrepo.unfiltered()
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   539
14412
9ac479758d3b bundlerepo: make getremotechanges support filtering of incoming
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14287
diff changeset
   540
    csets = localrepo.changelog.findmissing(common, rheads)
12734
5dfd1c49dcc5 bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12347
diff changeset
   541
23633
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   542
    if bundlerepo:
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   543
        reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev:]]
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   544
        remotephases = other.listkeys('phases')
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   545
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   546
        pullop = exchange.pulloperation(bundlerepo, other, heads=reponodes)
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   547
        pullop.trmanager = bundletransactionmanager()
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   548
        exchange._pullapplyphases(pullop, remotephases)
96c3cbec006f incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents: 23632
diff changeset
   549
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   550
    def cleanup():
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   551
        if bundlerepo:
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   552
            bundlerepo.close()
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   553
        if bundle:
21694
c08a22bfa16e bundlerepo: backout dbf292f65b09
Matt Mackall <mpm@selenic.com>
parents: 21562
diff changeset
   554
            os.unlink(bundle)
14190
8aab5a82685f bundlerepo: fix closing and docstring of getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14161
diff changeset
   555
        other.close()
14161
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   556
8a0fca925992 bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14158
diff changeset
   557
    return (localrepo, csets, cleanup)