Mercurial > hg
annotate mercurial/bundlerepo.py @ 30014:d34cf260d15b
wireproto: rename argument to groupchunks()
groupchunks() is a generic "turn a file object into a generator"
function. It isn't limited to changegroups. Rename the argument
and update the docstring to reflect this.
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Sun, 25 Sep 2016 12:20:31 -0700 |
parents | 1619efcde9a4 |
children | 1767723f71cf |
rev | line source |
---|---|
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 | 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, |
5aaf51c14fea
bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25830
diff
changeset
|
38 revlog, |
5aaf51c14fea
bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25830
diff
changeset
|
39 scmutil, |
5aaf51c14fea
bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25830
diff
changeset
|
40 util, |
5aaf51c14fea
bundlerepo: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25830
diff
changeset
|
41 ) |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
42 |
1946
9fee186f7f0d
bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1942
diff
changeset
|
43 class bundlerevlog(revlog.revlog): |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
44 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
|
45 # How it works: |
18410
de7dac2a58e8
bundlerepo: fix outdated comment
Mads Kiilerich <madski@unity3d.com>
parents:
18216
diff
changeset
|
46 # 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
|
47 # 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
|
48 # (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
|
49 # |
18410
de7dac2a58e8
bundlerepo: fix outdated comment
Mads Kiilerich <madski@unity3d.com>
parents:
18216
diff
changeset
|
50 # 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
|
51 # 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
|
52 opener = scmutil.readonlyvfs(opener) |
4257
1b5c38e9d7aa
revlog: don't pass datafile as an argument
Matt Mackall <mpm@selenic.com>
parents:
4029
diff
changeset
|
53 revlog.revlog.__init__(self, opener, indexfile) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
54 self.bundle = bundle |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6647
diff
changeset
|
55 n = len(self) |
18643
cc28a84db8c9
bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents:
18568
diff
changeset
|
56 self.repotiprev = n - 1 |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
57 chain = None |
18411
8b0f0dd56cec
bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents:
18410
diff
changeset
|
58 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
|
59 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
|
60 for chunkdata in iter(getchunk, {}): |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
61 node = chunkdata['node'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
62 p1 = chunkdata['p1'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
63 p2 = chunkdata['p2'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
64 cs = chunkdata['cs'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
65 deltabase = chunkdata['deltabase'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
66 delta = chunkdata['delta'] |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
67 |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
68 size = len(delta) |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
69 start = bundle.tell() - size |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
70 |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
71 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
|
72 if node in self.nodemap: |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
73 # 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
|
74 chain = node |
18411
8b0f0dd56cec
bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents:
18410
diff
changeset
|
75 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
|
76 continue |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
77 |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
78 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
|
79 if p not in self.nodemap: |
9650
1ad02c04356c
bundlerepo: fix small bug in exception raising
Sune Foldager <cryo@cyanite.org>
parents:
9198
diff
changeset
|
80 raise error.LookupError(p, self.indexfile, |
7633 | 81 _("unknown parent")) |
18416
87f370c5fef5
bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents:
18415
diff
changeset
|
82 |
87f370c5fef5
bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents:
18415
diff
changeset
|
83 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
|
84 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
|
85 _('unknown delta base')) |
87f370c5fef5
bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents:
18415
diff
changeset
|
86 |
87f370c5fef5
bundlerepo: store validated deltabase rev in basemap instead of node
Mads Kiilerich <madski@unity3d.com>
parents:
18415
diff
changeset
|
87 baserev = self.rev(deltabase) |
5167
aba624d2301d
fix bundlerepo broken by 4205f626dc05
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
4989
diff
changeset
|
88 # 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
|
89 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
|
90 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
|
91 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
|
92 self.nodemap[node] = n |
18411
8b0f0dd56cec
bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents:
18410
diff
changeset
|
93 self.bundlerevs.add(n) |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
94 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
|
95 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
|
96 |
9676
48bf28d3c8dd
bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
9650
diff
changeset
|
97 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
|
98 # 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
|
99 # 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
|
100 # 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
|
101 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
|
102 return revlog.revlog._chunk(self, rev) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
103 self.bundle.seek(self.start(rev)) |
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
104 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
|
105 |
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
106 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
|
107 """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
|
108 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
|
109 # 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
|
110 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
|
111 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
|
112 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
|
113 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
|
114 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
|
115 |
4989
1aaed3d69772
revlog: eliminate diff and patches functions
Matt Mackall <mpm@selenic.com>
parents:
4988
diff
changeset
|
116 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
|
117 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
|
118 |
16375
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
119 def revision(self, nodeorrev): |
16435
df347129305d
revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents:
16375
diff
changeset
|
120 """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
|
121 number. |
df347129305d
revlog: fix partial revision() docstring (from d7d64b89a65c)
Patrick Mezard <patrick@mezard.eu>
parents:
16375
diff
changeset
|
122 """ |
16375
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
123 if isinstance(nodeorrev, int): |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
124 rev = nodeorrev |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
125 node = self.node(rev) |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
126 else: |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
127 node = nodeorrev |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
128 rev = self.rev(node) |
d7d64b89a65c
revlog: allow retrieving contents by revision number
Matt Mackall <mpm@selenic.com>
parents:
16195
diff
changeset
|
129 |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
130 if node == nullid: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
131 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
|
132 |
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
133 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
|
134 chain = [] |
18415
95b8629fd2de
bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents:
18414
diff
changeset
|
135 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
|
136 # 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
|
137 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
|
138 if self._cache and self._cache[1] == iterrev: |
4984 | 139 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
|
140 break |
18415
95b8629fd2de
bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents:
18414
diff
changeset
|
141 chain.append(iterrev) |
18643
cc28a84db8c9
bundlerepo: replace basemap with the base field in the index
Mads Kiilerich <mads@kiilerich.com>
parents:
18568
diff
changeset
|
142 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
|
143 if text is None: |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
144 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
|
145 |
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
146 while chain: |
9676
48bf28d3c8dd
bundlerepo: keep the bundlerevlog interface in sync with revlog
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
9650
diff
changeset
|
147 delta = self._chunk(chain.pop()) |
4989
1aaed3d69772
revlog: eliminate diff and patches functions
Matt Mackall <mpm@selenic.com>
parents:
4988
diff
changeset
|
148 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
|
149 |
18417
610706715778
bundlerepo: use revlog._checkhash
Mads Kiilerich <madski@unity3d.com>
parents:
18416
diff
changeset
|
150 self._checkhash(text, node, rev) |
18415
95b8629fd2de
bundlerepo: use rev instead of node for iteration in revision()
Mads Kiilerich <madski@unity3d.com>
parents:
18414
diff
changeset
|
151 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
|
152 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
|
153 |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
154 def baserevision(self, nodeorrev): |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
155 # Revlog subclasses may override 'revision' method to modify format of |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
156 # 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
|
157 # needs to override 'baserevision' and make more specific call here. |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
158 return revlog.revlog.revision(self, nodeorrev) |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
159 |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
160 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
|
161 raise NotImplementedError |
6647
602f7c1ab954
drop superfluous param from revlog.addgroup()
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
6569
diff
changeset
|
162 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
|
163 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
|
164 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
|
165 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
|
166 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
|
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 |
1946
9fee186f7f0d
bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1942
diff
changeset
|
169 class bundlechangelog(bundlerevlog, changelog.changelog): |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
170 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
|
171 changelog.changelog.__init__(self, opener) |
14142
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
172 linkmapper = lambda x: x |
cb91ea6af733
bundlerepo: port to new bundle API
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14076
diff
changeset
|
173 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
|
174 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
|
175 |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
176 def baserevision(self, nodeorrev): |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
177 # Although changelog doesn't override 'revision' method, some extensions |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
178 # 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
|
179 # manifest and filelog classes. |
24882
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
180 |
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
181 # 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
|
182 # 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
|
183 oldfilter = self.filteredrevs |
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
184 try: |
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
185 self.filteredrevs = () |
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
186 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
|
187 finally: |
995003a324da
bundlerepo: disable filtering of changelog while constructing revision text
Yuya Nishihara <yuya@tcha.org>
parents:
24834
diff
changeset
|
188 self.filteredrevs = oldfilter |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
189 |
1946
9fee186f7f0d
bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1942
diff
changeset
|
190 class bundlemanifest(bundlerevlog, manifest.manifest): |
29715
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
191 def __init__(self, opener, bundle, linkmapper, dirlogstarts=None, dir=''): |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
192 manifest.manifest.__init__(self, opener, dir=dir) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
193 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
|
194 linkmapper) |
29715
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
195 if dirlogstarts is None: |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
196 dirlogstarts = {} |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
197 if self.bundle.version == "03": |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
198 dirlogstarts = _getfilestarts(self.bundle) |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
199 self._dirlogstarts = dirlogstarts |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
200 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
|
201 |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
202 def baserevision(self, nodeorrev): |
26399
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
203 node = nodeorrev |
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
204 if isinstance(node, int): |
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
205 node = self.node(node) |
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
206 |
29925
1619efcde9a4
manifest: make one use of _mancache avoid manifestctxs
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
207 if node in self.fulltextcache: |
1619efcde9a4
manifest: make one use of _mancache avoid manifestctxs
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
208 result = self.fulltextcache[node].tostring() |
26399
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
209 else: |
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
210 result = manifest.manifest.revision(self, nodeorrev) |
1f0e78f8f55f
bundlerepo: let bundle repo look in the _mancache
Durham Goode <durham@fb.com>
parents:
25920
diff
changeset
|
211 return result |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
212 |
29715
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
213 def dirlog(self, d): |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
214 if d in self._dirlogstarts: |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
215 self.bundle.seek(self._dirlogstarts[d]) |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
216 return bundlemanifest( |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
217 self.opener, self.bundle, self._linkmapper, |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
218 self._dirlogstarts, dir=d) |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
219 return super(bundlemanifest, self).dirlog(d) |
55d341877316
bundlerepo: add support for treemanifests in cg3 bundles
Augie Fackler <augie@google.com>
parents:
29713
diff
changeset
|
220 |
1946
9fee186f7f0d
bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1942
diff
changeset
|
221 class bundlefilelog(bundlerevlog, filelog.filelog): |
24921
86c0b5c09ee6
bundlerepo: remove unused 'repo' parameter
Martin von Zweigbergk <martinvonz@google.com>
parents:
24882
diff
changeset
|
222 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
|
223 filelog.filelog.__init__(self, opener, path) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
224 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
|
225 linkmapper) |
14287
7c231754a621
filelog: add file function to open other filelogs
Sune Foldager <cryo@cyanite.org>
parents:
14190
diff
changeset
|
226 |
19629
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
227 def baserevision(self, nodeorrev): |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
228 return filelog.filelog.revision(self, nodeorrev) |
81241f978fd2
bundlerevlog: extract 'baserevision' method
Wojciech Lopata <lopek@fb.com>
parents:
18825
diff
changeset
|
229 |
17193
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
230 class bundlepeer(localrepo.localpeer): |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
231 def canpush(self): |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
232 return False |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
233 |
23631
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
234 class bundlephasecache(phases.phasecache): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
235 def __init__(self, *args, **kwargs): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
236 super(bundlephasecache, self).__init__(*args, **kwargs) |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
237 if util.safehasattr(self, 'opener'): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
238 self.opener = scmutil.readonlyvfs(self.opener) |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
239 |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
240 def write(self): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
241 raise NotImplementedError |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
242 |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
243 def _write(self, fp): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
244 raise NotImplementedError |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
245 |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
246 def _updateroots(self, phase, newroots, tr): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
247 self.phaseroots[phase] = newroots |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
248 self.invalidate() |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
249 self.dirty = True |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
250 |
29712
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
251 def _getfilestarts(bundle): |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
252 bundlefilespos = {} |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
253 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
|
254 fname = chunkdata['filename'] |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
255 bundlefilespos[fname] = bundle.tell() |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
256 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
|
257 pass |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
258 return bundlefilespos |
9e88077f972c
bundlerepo: introduce method to find file starts and use it
Augie Fackler <augie@google.com>
parents:
29711
diff
changeset
|
259 |
1946
9fee186f7f0d
bundlerepo: remove relative import, fix a comment
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1942
diff
changeset
|
260 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
|
261 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
|
262 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
|
263 """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
|
264 |
7cac6ee41be7
bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26587
diff
changeset
|
265 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
|
266 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
|
267 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
|
268 suffix=".hg10un") |
7cac6ee41be7
bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26587
diff
changeset
|
269 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
|
270 |
27776
6fe2da48a6dd
bundlerepo: use context manager for file I/O in _writetempbundle
Bryan O'Sullivan <bryano@fb.com>
parents:
27753
diff
changeset
|
271 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
|
272 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
|
273 while True: |
7cac6ee41be7
bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26587
diff
changeset
|
274 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
|
275 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
|
276 break |
7cac6ee41be7
bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26587
diff
changeset
|
277 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
|
278 |
7cac6ee41be7
bundlerepo: move temp-bundle writing logic into a closure
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26587
diff
changeset
|
279 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
|
280 self._tempparent = None |
9a1c59283ad3
Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
6312
diff
changeset
|
281 try: |
9a1c59283ad3
Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
6312
diff
changeset
|
282 localrepo.localrepository.__init__(self, ui, path) |
7637 | 283 except error.RepoError: |
6314
9a1c59283ad3
Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
6312
diff
changeset
|
284 self._tempparent = tempfile.mkdtemp() |
9198
061eeb602354
coding style: use a space after comma
Martin Geisler <mg@lazybytes.net>
parents:
8312
diff
changeset
|
285 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
|
286 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
|
287 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
|
288 |
6129
3d666e8e6398
bundlerepo: fix inconsistency of parsed and internal name (issue #821)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5664
diff
changeset
|
289 if path: |
11154
17031fea4e95
expand paths to local repository or bundle in appropriate classes
Alexander Solovyov <piranha@piranha.org.ua>
parents:
10282
diff
changeset
|
290 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
|
291 else: |
3d666e8e6398
bundlerepo: fix inconsistency of parsed and internal name (issue #821)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5664
diff
changeset
|
292 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
|
293 |
2273
f116ddea537f
add support for compressed bundle repositories
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2257
diff
changeset
|
294 self.tempfile = None |
13274
57d433f632b7
bundlerepo: use less intrusive util.posixfile to open bundle
Adrian Buehlmann <adrian@cadifra.com>
parents:
12962
diff
changeset
|
295 f = util.posixfile(bundlename, "rb") |
24072
145b823f5ce7
bundlerepo: keep track of the original bundle object
Eric Sumner <ericsumner@fb.com>
parents:
24003
diff
changeset
|
296 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
|
297 |
24073
ff5caa8dfd99
bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents:
24072
diff
changeset
|
298 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
|
299 cgstream = None |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
300 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
|
301 if part.type == 'changegroup': |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
302 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
|
303 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
|
304 "multiple changegroups") |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
305 cgstream = part |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
306 version = part.params.get('version', '01') |
29713
43924f3a55fa
bundlerepo: use supportedincomingversions instead of allsupportedversions
Augie Fackler <augie@google.com>
parents:
29712
diff
changeset
|
307 legalcgvers = changegroup.supportedincomingversions(self) |
43924f3a55fa
bundlerepo: use supportedincomingversions instead of allsupportedversions
Augie Fackler <augie@google.com>
parents:
29712
diff
changeset
|
308 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
|
309 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
|
310 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
|
311 if self.bundle.compressed(): |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
312 cgstream = _writetempbundle(part.read, |
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
313 ".cg%sun" % version) |
24073
ff5caa8dfd99
bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents:
24072
diff
changeset
|
314 |
26803
ed41ce89822d
bundlerepo: properly extract compressed changegroup from bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26801
diff
changeset
|
315 if cgstream is None: |
29389
98e8313dcd9e
i18n: translate abort messages
liscju <piotr.listkiewicz@gmail.com>
parents:
28714
diff
changeset
|
316 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
|
317 cgstream.seek(0) |
24073
ff5caa8dfd99
bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents:
24072
diff
changeset
|
318 |
27751
a40e2f7fe49d
changegroup: hide packermap behind methods
Martin von Zweigbergk <martinvonz@google.com>
parents:
26803
diff
changeset
|
319 self.bundle = changegroup.getunbundler(version, cgstream, 'UN') |
24073
ff5caa8dfd99
bundlerepo: basic bundle2 support
Eric Sumner <ericsumner@fb.com>
parents:
24072
diff
changeset
|
320 |
26801
73bf76bf6f14
bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26800
diff
changeset
|
321 elif self.bundle.compressed(): |
73bf76bf6f14
bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26800
diff
changeset
|
322 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
|
323 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
|
324 bundlename, |
73bf76bf6f14
bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26800
diff
changeset
|
325 self.vfs) |
73bf76bf6f14
bundlerepo: uncompress changegroup in bundle1 case only
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26800
diff
changeset
|
326 |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
327 # 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
|
328 self.bundlefilespos = {} |
5262 | 329 |
23632
e7fcf58acd71
bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents:
23631
diff
changeset
|
330 self.firstnewrev = self.changelog.repotiprev + 1 |
e7fcf58acd71
bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents:
23631
diff
changeset
|
331 phases.retractboundary(self, None, phases.draft, |
e7fcf58acd71
bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents:
23631
diff
changeset
|
332 [ctx.node() for ctx in self[self.firstnewrev:]]) |
e7fcf58acd71
bundlerepo: retract phase boundary
Eric Sumner <ericsumner@fb.com>
parents:
23631
diff
changeset
|
333 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17913
diff
changeset
|
334 @localrepo.unfilteredpropertycache |
23631
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
335 def _phasecache(self): |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
336 return bundlephasecache(self, self._phasedefaults) |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
337 |
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
22182
diff
changeset
|
338 @localrepo.unfilteredpropertycache |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
339 def changelog(self): |
14144
3c3c53d8343a
unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14142
diff
changeset
|
340 # consume the header if it exists |
3c3c53d8343a
unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14142
diff
changeset
|
341 self.bundle.changelogheader() |
23878
37a92908a382
localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
23633
diff
changeset
|
342 c = bundlechangelog(self.svfs, self.bundle) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
343 self.manstart = self.bundle.tell() |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
344 return c |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
345 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17913
diff
changeset
|
346 @localrepo.unfilteredpropertycache |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
347 def manifest(self): |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
348 self.bundle.seek(self.manstart) |
14144
3c3c53d8343a
unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14142
diff
changeset
|
349 # consume the header if it exists |
3c3c53d8343a
unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14142
diff
changeset
|
350 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
|
351 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
|
352 m = bundlemanifest(self.svfs, self.bundle, linkmapper) |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
353 self.filestart = self.bundle.tell() |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
354 return m |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
355 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17913
diff
changeset
|
356 @localrepo.unfilteredpropertycache |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
357 def manstart(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
358 self.changelog |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
359 return self.manstart |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
360 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17913
diff
changeset
|
361 @localrepo.unfilteredpropertycache |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
362 def filestart(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
363 self.manifest |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8227
diff
changeset
|
364 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
|
365 |
2673
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2273
diff
changeset
|
366 def url(self): |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2273
diff
changeset
|
367 return self._url |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2273
diff
changeset
|
368 |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
369 def file(self, f): |
5262 | 370 if not self.bundlefilespos: |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
371 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
|
372 self.bundlefilespos = _getfilestarts(self.bundle) |
5262 | 373 |
1942
9da45de3118d
add bundlerepo.py: a read-only repo that can use uncompressed bundles
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
diff
changeset
|
374 if f in self.bundlefilespos: |
12332
680fe77ab5b8
bundlerepo: use bundle objects everywhere
Matt Mackall <mpm@selenic.com>
parents:
12331
diff
changeset
|
375 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
|
376 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
|
377 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
|
378 else: |
23878
37a92908a382
localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
23633
diff
changeset
|
379 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
|
380 |
12347
6277a9469dff
bundlerepo: restore close() method
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
381 def close(self): |
6277a9469dff
bundlerepo: restore close() method
Matt Mackall <mpm@selenic.com>
parents:
12335
diff
changeset
|
382 """Close assigned bundle file immediately.""" |
24072
145b823f5ce7
bundlerepo: keep track of the original bundle object
Eric Sumner <ericsumner@fb.com>
parents:
24003
diff
changeset
|
383 self.bundlefile.close() |
12962
ff083040a555
bundlerepository: get rid of temporary bundle files (issue2478)
Klaus Koch <kuk42@gmx.net>
parents:
12961
diff
changeset
|
384 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
|
385 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
|
386 if self._tempparent: |
9a1c59283ad3
Add ability to directly clone from all-history bundles
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
6312
diff
changeset
|
387 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
|
388 |
6315 | 389 def cancopy(self): |
390 return False | |
391 | |
17193
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
392 def peer(self): |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
393 return bundlepeer(self) |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17191
diff
changeset
|
394 |
7435
5e13df32fb74
bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
6953
diff
changeset
|
395 def getcwd(self): |
5e13df32fb74
bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
6953
diff
changeset
|
396 return os.getcwd() # always outside the repo |
5e13df32fb74
bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
6953
diff
changeset
|
397 |
28714
dac81729fea4
bundle: warn when update to revision existing only in a bundle (issue5004)
liscju <piotr.listkiewicz@gmail.com>
parents:
28666
diff
changeset
|
398 # 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
|
399 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
|
400 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
|
401 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
|
402 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
|
403 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
|
404 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
|
405 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
|
406 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
|
407 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
|
408 |
2740
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
409 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
|
410 if create: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26544
diff
changeset
|
411 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
|
412 # 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
|
413 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
|
414 if not parentpath: |
4b7aa1c899dc
bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents:
15597
diff
changeset
|
415 # try to find the correct path to the working directory repo |
4b7aa1c899dc
bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents:
15597
diff
changeset
|
416 parentpath = cmdutil.findrepo(os.getcwd()) |
4b7aa1c899dc
bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents:
15597
diff
changeset
|
417 if parentpath is None: |
4b7aa1c899dc
bundlerepo: try to find containing repo on creation (issue1812)
Matt Mackall <mpm@selenic.com>
parents:
15597
diff
changeset
|
418 parentpath = '' |
5664
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
419 if parentpath: |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
420 # 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
|
421 # In particular, we don't want temp dir names in test outputs. |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
422 cwd = os.getcwd() |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
423 if parentpath == cwd: |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
424 parentpath = '' |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
425 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
|
426 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
|
427 if parentpath.startswith(cwd): |
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
428 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
|
429 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
|
430 path = u.localpath() |
e574207e3bcd
url: refactor util.drop_scheme() and hg.localpath() into url.localpath()
Brodie Rao <brodie@bitheap.org>
parents:
13742
diff
changeset
|
431 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
|
432 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
|
433 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
|
434 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
|
435 else: |
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
436 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
|
437 else: |
5664
da72b4d24797
Fix income/pull with bundle and -R (issue 820).
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
5558
diff
changeset
|
438 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
|
439 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
|
440 |
23633
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
441 class bundletransactionmanager(object): |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
442 def transaction(self): |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
443 return None |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
444 |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
445 def close(self): |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
446 raise NotImplementedError |
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 release(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 |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
451 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
|
452 force=False): |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
453 '''obtains a bundle of changes incoming from other |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
454 |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
455 "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
|
456 specified heads. |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
457 "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
|
458 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
|
459 the returned "cleanupfn". |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
460 "force" indicates whether to proceed on unrelated repos. |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
461 |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
462 Returns a tuple (local, csets, cleanupfn): |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
463 |
16683 | 464 "local" is a local repo from which to obtain the actual incoming |
465 changesets; it is a bundlerepo for the obtained bundle when the | |
466 original "other" is remote. | |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
467 "csets" lists the incoming changeset node ids. |
16683 | 468 "cleanupfn" must be called without arguments when you're done processing |
469 the changes; it closes both the original "other" and the one returned | |
470 here. | |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
471 ''' |
16683 | 472 tmp = discovery.findcommonincoming(repo, other, heads=onlyheads, |
473 force=force) | |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
474 common, incoming, rheads = tmp |
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
475 if not incoming: |
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
476 try: |
15091
106f89299da6
bundlerepo: add argument check before unlink
Sune Foldager <cryo@cyanite.org>
parents:
14494
diff
changeset
|
477 if bundlename: |
21694
c08a22bfa16e
bundlerepo: backout dbf292f65b09
Matt Mackall <mpm@selenic.com>
parents:
21562
diff
changeset
|
478 os.unlink(bundlename) |
14004
97ed99d1f419
eliminate various naked except clauses
Idan Kamara <idankk86@gmail.com>
parents:
13826
diff
changeset
|
479 except OSError: |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
480 pass |
18138
8ab0640c3090
bundlerepo: don't return the peer without bundlerepo from getremotechanges
Mads Kiilerich <madski@unity3d.com>
parents:
17193
diff
changeset
|
481 return repo, [], other.close |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
482 |
22182
510cafe72004
incoming: don't request heads that already are common
Mads Kiilerich <madski@unity3d.com>
parents:
21694
diff
changeset
|
483 commonset = set(common) |
510cafe72004
incoming: don't request heads that already are common
Mads Kiilerich <madski@unity3d.com>
parents:
21694
diff
changeset
|
484 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
|
485 |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
486 bundle = None |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
487 bundlerepo = None |
17191
5884812686f7
peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents:
16686
diff
changeset
|
488 localrepo = other.local() |
5884812686f7
peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents:
16686
diff
changeset
|
489 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
|
490 # 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
|
491 |
29684
ff5d5751fc1b
bundlerepo: also read the 'devel.legacy.exchange' config
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
29389
diff
changeset
|
492 # 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
|
493 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
|
494 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
|
495 canbundle2 = (not forcebundle1 |
26544
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
496 and other.capable('getbundle') |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
497 and other.capable('bundle2')) |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
498 if canbundle2: |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
499 kwargs = {} |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
500 kwargs['common'] = common |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
501 kwargs['heads'] = rheads |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
502 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
|
503 kwargs['cg'] = True |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
504 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
|
505 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
|
506 bundlename) |
1e8e0b01faba
incoming: request a bundle2 when possible (BC)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26543
diff
changeset
|
507 else: |
26543
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
508 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
|
509 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
|
510 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
|
511 # 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
|
512 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
|
513 rheads = None |
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
514 else: |
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
515 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
|
516 if localrepo: |
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
517 bundletype = "HG10BZ" |
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
518 else: |
a018cbabdb51
bundlerepo: indent some code to prepare next patch
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26399
diff
changeset
|
519 bundletype = "HG10UN" |
28666
ae53ecc47414
bundle: move writebundle() from changegroup.py to bundle2.py (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
28221
diff
changeset
|
520 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
|
521 bundletype) |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
522 # keep written bundle? |
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
523 if bundlename: |
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
524 bundle = None |
17191
5884812686f7
peer: introduce peer methods to prepare for peer classes
Sune Foldager <cryo@cyanite.org>
parents:
16686
diff
changeset
|
525 if not localrepo: |
12734
5dfd1c49dcc5
bundlerepo: unify common code into a new getremotechanges
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12347
diff
changeset
|
526 # 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
|
527 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
|
528 fname) |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
529 # 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
|
530 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
|
531 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
|
532 # 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
|
533 # 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
|
534 # 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
|
535 localrepo = localrepo.unfiltered() |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
536 |
14412
9ac479758d3b
bundlerepo: make getremotechanges support filtering of incoming
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14287
diff
changeset
|
537 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
|
538 |
23633
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
539 if bundlerepo: |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
540 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
|
541 remotephases = other.listkeys('phases') |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
542 |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
543 pullop = exchange.pulloperation(bundlerepo, other, heads=reponodes) |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
544 pullop.trmanager = bundletransactionmanager() |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
545 exchange._pullapplyphases(pullop, remotephases) |
96c3cbec006f
incoming: handle phases the same as pull
Eric Sumner <ericsumner@fb.com>
parents:
23632
diff
changeset
|
546 |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
547 def cleanup(): |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
548 if bundlerepo: |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
549 bundlerepo.close() |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
550 if bundle: |
21694
c08a22bfa16e
bundlerepo: backout dbf292f65b09
Matt Mackall <mpm@selenic.com>
parents:
21562
diff
changeset
|
551 os.unlink(bundle) |
14190
8aab5a82685f
bundlerepo: fix closing and docstring of getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14161
diff
changeset
|
552 other.close() |
14161
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
553 |
8a0fca925992
bundlerepo: fix and improve getremotechanges
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14158
diff
changeset
|
554 return (localrepo, csets, cleanup) |