Mercurial > hg
annotate mercurial/localrepo.py @ 22044:a06172e85fd4
run-tests: add support for xunit test reports
The Jenkins CI system understands xunit reports natively, so this will
be helpful for anyone that wants to use Jenkins for testing hg or
extensions that use run-tests.py for their testing.
author | Augie Fackler <raf@durin42.com> |
---|---|
date | Tue, 05 Aug 2014 21:17:11 -0400 |
parents | bdb6d97f0a04 |
children | c1ca47204590 |
rev | line source |
---|---|
1089 | 1 # localrepo.py - read/write repository class for mercurial |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
2 # |
4635
63b9d2deed48
Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4633
diff
changeset
|
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
4 # |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
8210
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. |
18118
e70ff1e599f4
branchmap: extract read logic from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18117
diff
changeset
|
7 from node import hex, nullid, short |
3891 | 8 from i18n import _ |
21141
d8dd19e09ed4
bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21140
diff
changeset
|
9 import urllib |
20930
4a987060d97e
localrepo: move the getbundle method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20928
diff
changeset
|
10 import peer, changegroup, subrepo, pushkey, obsolete, repoview |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15403
diff
changeset
|
11 import changelog, dirstate, filelog, manifest, context, bookmarks, phases |
20088
7cbb79bddee7
localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20087
diff
changeset
|
12 import lock as lockmod |
21068
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
13 import transaction, store, encoding, exchange, bundle2 |
14902
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
14 import scmutil, util, extensions, hook, error, revset |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
15 import match as matchmod |
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
16 import merge as mergemod |
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
17 import tags as tagsmod |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
18 from lock import release |
11303
a1aad8333864
move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
11301
diff
changeset
|
19 import weakref, errno, os, time, inspect |
20033
f962870712da
pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents:
20027
diff
changeset
|
20 import branchmap, pathutil |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
21 propertycache = util.propertycache |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
22 filecache = scmutil.filecache |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
23 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
24 class repofilecache(filecache): |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
25 """All filecache usage on repo are done for logic that should be unfiltered |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
26 """ |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
27 |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
28 def __get__(self, repo, type=None): |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
29 return super(repofilecache, self).__get__(repo.unfiltered(), type) |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
30 def __set__(self, repo, value): |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
31 return super(repofilecache, self).__set__(repo.unfiltered(), value) |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
32 def __delete__(self, repo): |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
33 return super(repofilecache, self).__delete__(repo.unfiltered()) |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
34 |
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
35 class storecache(repofilecache): |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
36 """filecache for files in the store""" |
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
37 def join(self, obj, fname): |
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
38 return obj.sjoin(fname) |
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
39 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
40 class unfilteredpropertycache(propertycache): |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
41 """propertycache that apply to unfiltered repo only""" |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
42 |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
43 def __get__(self, repo, type=None): |
19846
9789670992d6
repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
19515
diff
changeset
|
44 unfi = repo.unfiltered() |
9789670992d6
repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
19515
diff
changeset
|
45 if unfi is repo: |
9789670992d6
repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
19515
diff
changeset
|
46 return super(unfilteredpropertycache, self).__get__(unfi) |
9789670992d6
repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
19515
diff
changeset
|
47 return getattr(unfi, self.name) |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
48 |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
49 class filteredpropertycache(propertycache): |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
50 """propertycache that must take filtering in account""" |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
51 |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
52 def cachevalue(self, obj, value): |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
53 object.__setattr__(obj, self.name, value) |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
54 |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
55 |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
56 def hasunfilteredcache(repo, name): |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
57 """check if a repo has an unfilteredpropertycache value for <name>""" |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
58 return name in vars(repo.unfiltered()) |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
59 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
60 def unfilteredmethod(orig): |
17994
8899bf48116a
clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17993
diff
changeset
|
61 """decorate method that always need to be run on unfiltered version""" |
8899bf48116a
clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17993
diff
changeset
|
62 def wrapper(repo, *args, **kwargs): |
8899bf48116a
clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17993
diff
changeset
|
63 return orig(repo.unfiltered(), *args, **kwargs) |
8899bf48116a
clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17993
diff
changeset
|
64 return wrapper |
8899bf48116a
clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17993
diff
changeset
|
65 |
20955
12f161f08d74
bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20954
diff
changeset
|
66 moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle', |
21141
d8dd19e09ed4
bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21140
diff
changeset
|
67 'unbundle')) |
20776
d00c731f4637
localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20773
diff
changeset
|
68 legacycaps = moderncaps.union(set(['changegroupsubset'])) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
69 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
70 class localpeer(peer.peerrepository): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
71 '''peer for a local repo; reflects only the most recent API''' |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
72 |
20776
d00c731f4637
localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20773
diff
changeset
|
73 def __init__(self, repo, caps=moderncaps): |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
74 peer.peerrepository.__init__(self) |
18382
f3b21beb9802
filtering: rename filters to their antonyms
Kevin Bullock <kbullock@ringworld.org>
parents:
18364
diff
changeset
|
75 self._repo = repo.filtered('served') |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
76 self.ui = repo.ui |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
77 self._caps = repo._restrictcapabilities(caps) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
78 self.requirements = repo.requirements |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
79 self.supportedformats = repo.supportedformats |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
80 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
81 def close(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
82 self._repo.close() |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
83 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
84 def _capabilities(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
85 return self._caps |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
86 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
87 def local(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
88 return self._repo |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
89 |
17193
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17192
diff
changeset
|
90 def canpush(self): |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17192
diff
changeset
|
91 return True |
1d710fe5ee0e
peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents:
17192
diff
changeset
|
92 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
93 def url(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
94 return self._repo.url() |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
95 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
96 def lookup(self, key): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
97 return self._repo.lookup(key) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
98 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
99 def branchmap(self): |
18279
679767c38cb5
clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18278
diff
changeset
|
100 return self._repo.branchmap() |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
101 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
102 def heads(self): |
18279
679767c38cb5
clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18278
diff
changeset
|
103 return self._repo.heads() |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
104 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
105 def known(self, nodes): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
106 return self._repo.known(nodes) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
107 |
20953
8d853cad6b14
localpeer: propagate bundlecaps in getbundle call
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20933
diff
changeset
|
108 def getbundle(self, source, heads=None, common=None, bundlecaps=None, |
21157
60ad2ea5b106
getbundle: pass arbitrary arguments all along the call chain
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21147
diff
changeset
|
109 format='HG10', **kwargs): |
21068
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
110 cg = exchange.getbundle(self._repo, source, heads=heads, |
21157
60ad2ea5b106
getbundle: pass arbitrary arguments all along the call chain
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21147
diff
changeset
|
111 common=common, bundlecaps=bundlecaps, **kwargs) |
21144
7a20fe8dc080
bundle2: use HG2X in the header
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21141
diff
changeset
|
112 if bundlecaps is not None and 'HG2X' in bundlecaps: |
21068
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
113 # When requesting a bundle2, getbundle returns a stream to make the |
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
114 # wire level function happier. We need to build a proper object |
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
115 # from it in local peer. |
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
116 cg = bundle2.unbundle20(self.ui, cg) |
c15b66a6bbb4
bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21043
diff
changeset
|
117 return cg |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
118 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
119 # TODO We might want to move the next two calls into legacypeer and add |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
120 # unbundle instead. |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
121 |
20969
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
122 def unbundle(self, cg, heads, url): |
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
123 """apply a bundle on a repo |
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
124 |
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
125 This function handles the repo locking itself.""" |
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
126 try: |
21070
408877d491fb
bundle2: feed a binary stream to `peer.unbundle`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21068
diff
changeset
|
127 cg = exchange.readbundle(self.ui, cg, None) |
21071
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
128 ret = exchange.unbundle(self._repo, cg, heads, 'push', url) |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
129 if util.safehasattr(ret, 'getchunks'): |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
130 # This is a bundle20 object, turn it into an unbundler. |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
131 # This little dance should be dropped eventually when the API |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
132 # is finally improved. |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
133 stream = util.chunkbuffer(ret.getchunks()) |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
134 ret = bundle2.unbundle20(self.ui, stream) |
19b9f23a8c6f
bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21070
diff
changeset
|
135 return ret |
21184
28d76afa1568
bundle2: fix raising errors during heads checking
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21157
diff
changeset
|
136 except error.PushRaced, exc: |
21186
9f3652e851f8
bundle2: gracefully handle PushRaced error during unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21184
diff
changeset
|
137 raise error.ResponseError(_('push failed:'), str(exc)) |
20969
7a679918ee2b
localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20963
diff
changeset
|
138 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
139 def lock(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
140 return self._repo.lock() |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
141 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
142 def addchangegroup(self, cg, source, url): |
20933
d3775db748a0
localrepo: move the addchangegroup method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20932
diff
changeset
|
143 return changegroup.addchangegroup(self._repo, cg, source, url) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
144 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
145 def pushkey(self, namespace, key, old, new): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
146 return self._repo.pushkey(namespace, key, old, new) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
147 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
148 def listkeys(self, namespace): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
149 return self._repo.listkeys(namespace) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
150 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
151 def debugwireargs(self, one, two, three=None, four=None, five=None): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
152 '''used to test argument passing over the wire''' |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
153 return "%s %s %s %s %s" % (one, two, three, four, five) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
154 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
155 class locallegacypeer(localpeer): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
156 '''peer extension which implements legacy methods too; used for tests with |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
157 restricted capabilities''' |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
158 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
159 def __init__(self, repo): |
20776
d00c731f4637
localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20773
diff
changeset
|
160 localpeer.__init__(self, repo, caps=legacycaps) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
161 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
162 def branches(self, nodes): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
163 return self._repo.branches(nodes) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
164 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
165 def between(self, pairs): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
166 return self._repo.between(pairs) |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
167 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
168 def changegroup(self, basenodes, source): |
20931
de60ca3a390e
localrepo: move the changegroup method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20930
diff
changeset
|
169 return changegroup.changegroup(self._repo, basenodes, source) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
170 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
171 def changegroupsubset(self, bases, heads, source): |
20927
24a443948627
localrepo: move the changegroupsubset method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20926
diff
changeset
|
172 return changegroup.changegroupsubset(self._repo, bases, heads, source) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
173 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
174 class localrepository(object): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
175 |
14270
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14232
diff
changeset
|
176 supportedformats = set(('revlogv1', 'generaldelta')) |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
177 _basesupported = supportedformats | set(('store', 'fncache', 'shared', |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
178 'dotencode')) |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
179 openerreqs = set(('revlogv1', 'generaldelta')) |
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
180 requirements = ['revlogv1'] |
18186
d336f53cb2e3
clfilter: ensure unfiltered repo have a filtername attribute too
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18162
diff
changeset
|
181 filtername = None |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
182 |
21657
0ff44e06275d
getbundle: support of listkeys argument when bundle2 is used
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21596
diff
changeset
|
183 bundle2caps = {'HG2X': (), |
21660
e87d2a12d41b
bundle2: add ``pushkey`` support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21657
diff
changeset
|
184 'b2x:listkeys': (), |
21989
bdb6d97f0a04
getbundle: add a ``cg`` boolean argument to control changegroup inclusion
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21866
diff
changeset
|
185 'b2x:pushkey': (), |
bdb6d97f0a04
getbundle: add a ``cg`` boolean argument to control changegroup inclusion
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21866
diff
changeset
|
186 'b2x:changegroup': (), |
bdb6d97f0a04
getbundle: add a ``cg`` boolean argument to control changegroup inclusion
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21866
diff
changeset
|
187 } |
21140
4aeb8da68090
bundle2: add bundle2caps dict on localrepo object
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21106
diff
changeset
|
188 |
19928
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
189 # a list of (ui, featureset) functions. |
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
190 # only functions defined in module of enabled extensions are invoked |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
191 featuresetupfuncs = set() |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
192 |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
193 def _baserequirements(self, create): |
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
194 return self.requirements[:] |
2439
e8c4f3d3df8c
extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2424
diff
changeset
|
195 |
14363
82f3b0f3f0a5
localrepo, sshrepo: use Boolean create argument in __init__
Martin Geisler <mg@lazybytes.net>
parents:
14333
diff
changeset
|
196 def __init__(self, baseui, path=None, create=False): |
18945
e75b72fffdfe
vfs: split "expand" into "realpath"/"expandpath" to apply each separately
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18811
diff
changeset
|
197 self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True) |
17650
bf2eb3a126d2
localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17550
diff
changeset
|
198 self.wopener = self.wvfs |
17157
87e8440964a0
localrepo: use path expansion API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17156
diff
changeset
|
199 self.root = self.wvfs.base |
17158
60338880d265
localrepo: use "self.wvfs.join()" instead of "os.path.join()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17157
diff
changeset
|
200 self.path = self.wvfs.join(".hg") |
3850
a4457828ca1a
move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3803
diff
changeset
|
201 self.origroot = path |
20033
f962870712da
pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents:
20027
diff
changeset
|
202 self.auditor = pathutil.pathauditor(self.root, self._checknested) |
17650
bf2eb3a126d2
localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17550
diff
changeset
|
203 self.vfs = scmutil.vfs(self.path) |
bf2eb3a126d2
localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17550
diff
changeset
|
204 self.opener = self.vfs |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
205 self.baseui = baseui |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
206 self.ui = baseui.copy() |
20082
b04cc8651a63
localrepo: prevent to copy repo local config, copy baseui instead
Simon Heimberg <simohe@besonet.ch>
parents:
20033
diff
changeset
|
207 self.ui.copy = baseui.copy # prevent copying repo configuration |
15922
23921c17299a
phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15892
diff
changeset
|
208 # A list of callback to shape the phase if no data were found. |
23921c17299a
phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15892
diff
changeset
|
209 # Callback are in the form: func(repo, roots) --> processed root. |
23921c17299a
phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15892
diff
changeset
|
210 # This list it to be filled by extension during repo setup |
23921c17299a
phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15892
diff
changeset
|
211 self._phasedefaults = [] |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
212 try: |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
213 self.ui.readconfig(self.join("hgrc"), self.root) |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
214 extensions.loadall(self.ui) |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
215 except IOError: |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
216 pass |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
217 |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
218 if self.featuresetupfuncs: |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
219 self.supported = set(self._basesupported) # use private copy |
19928
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
220 extmods = set(m.__name__ for n, m |
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
221 in extensions.extensions(self.ui)) |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
222 for setupfunc in self.featuresetupfuncs: |
19928
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
223 if setupfunc.__module__ in extmods: |
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
224 setupfunc(self.ui, self.supported) |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
225 else: |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
226 self.supported = self._basesupported |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
227 |
17161
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
228 if not self.vfs.isdir(): |
3035
4d0e0f149581
localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3019
diff
changeset
|
229 if create: |
17161
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
230 if not self.wvfs.exists(): |
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
231 self.wvfs.makedirs() |
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
232 self.vfs.makedir(notindexed=True) |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
233 requirements = self._baserequirements(create) |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
234 if self.ui.configbool('format', 'usestore', True): |
17161
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
235 self.vfs.mkdir("store") |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
236 requirements.append("store") |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
237 if self.ui.configbool('format', 'usefncache', True): |
7234
ae70fe6143fc
add format.usefncache config option (default is true)
Adrian Buehlmann <adrian@cadifra.com>
parents:
7233
diff
changeset
|
238 requirements.append("fncache") |
12687
34d8247a4595
store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents:
12622
diff
changeset
|
239 if self.ui.configbool('format', 'dotencode', True): |
34d8247a4595
store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents:
12622
diff
changeset
|
240 requirements.append('dotencode') |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
241 # create an invalid changelog |
17160
22b9b1d2f5d4
localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17159
diff
changeset
|
242 self.vfs.append( |
14168
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
243 "00changelog.i", |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
244 '\0\0\0\2' # represents revlogv2 |
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
245 ' dummy changelog to prevent using the old repo layout' |
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
246 ) |
14270
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14232
diff
changeset
|
247 if self.ui.configbool('format', 'generaldelta', False): |
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14232
diff
changeset
|
248 requirements.append("generaldelta") |
14905
207935cda6dc
localrepo: make requirements attribute of newly-created repos contain a set
Andrew Pritchard <andrewp@fogcreek.com>
parents:
14904
diff
changeset
|
249 requirements = set(requirements) |
3035
4d0e0f149581
localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3019
diff
changeset
|
250 else: |
7637 | 251 raise error.RepoError(_("repository %s not found") % path) |
3035
4d0e0f149581
localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3019
diff
changeset
|
252 elif create: |
7637 | 253 raise error.RepoError(_("repository %s already exists") % path) |
3851
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
254 else: |
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
255 try: |
17160
22b9b1d2f5d4
localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17159
diff
changeset
|
256 requirements = scmutil.readrequires(self.vfs, self.supported) |
3851
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
257 except IOError, inst: |
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
258 if inst.errno != errno.ENOENT: |
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
259 raise |
14482
58b36e9ea783
introduce new function scmutil.readrequires
Adrian Buehlmann <adrian@cadifra.com>
parents:
14434
diff
changeset
|
260 requirements = set() |
405 | 261 |
8799
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
262 self.sharedpath = self.path |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
263 try: |
18946
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
264 vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'), |
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
265 realpath=True) |
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
266 s = vfs.base |
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
267 if not vfs.exists(): |
8799
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
268 raise error.RepoError( |
8908
105343f9f744
Fix warning: Seen unexpected token "%"
Dongsheng Song <dongsheng.song@gmail.com>
parents:
8813
diff
changeset
|
269 _('.hg/sharedpath points to nonexistent directory %s') % s) |
8799
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
270 self.sharedpath = s |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
271 except IOError, inst: |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
272 if inst.errno != errno.ENOENT: |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
273 raise |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
274 |
17654
1dc37491e9fb
localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17650
diff
changeset
|
275 self.store = store.store(requirements, self.sharedpath, scmutil.vfs) |
6840
80e51429cb9a
introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents:
6839
diff
changeset
|
276 self.spath = self.store.path |
17654
1dc37491e9fb
localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17650
diff
changeset
|
277 self.svfs = self.store.vfs |
1dc37491e9fb
localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17650
diff
changeset
|
278 self.sopener = self.svfs |
6840
80e51429cb9a
introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents:
6839
diff
changeset
|
279 self.sjoin = self.store.join |
17654
1dc37491e9fb
localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17650
diff
changeset
|
280 self.vfs.createmode = self.store.createmode |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
281 self._applyrequirements(requirements) |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
282 if create: |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
283 self._writerequirements() |
3850
a4457828ca1a
move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3803
diff
changeset
|
284 |
9146
5614a628d173
localrepo: rename in-memory tag cache instance attributes (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9145
diff
changeset
|
285 |
18189
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
286 self._branchcaches = {} |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
287 self.filterpats = {} |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
288 self._datafilters = {} |
4916
5c5d23d93447
Use a weakref for recursive transactions
Matt Mackall <mpm@selenic.com>
parents:
4915
diff
changeset
|
289 self._transref = self._lockref = self._wlockref = None |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
290 |
14929
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
291 # A cache for various files under .hg/ that tracks file changes, |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
292 # (used by the filecache decorator) |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
293 # |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
294 # Maps a property name to its util.filecacheentry |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
295 self._filecache = {} |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
296 |
18101
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
297 # hold sets of revision to be filtered |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
298 # should be cleared when something might have changed the filter value: |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
299 # - new changesets, |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
300 # - phase change, |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
301 # - new obsolescence marker, |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
302 # - working directory parent change, |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
303 # - bookmark changes |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
304 self.filteredrevcache = {} |
a464deecc9dd
clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18100
diff
changeset
|
305 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
306 def close(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
307 pass |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
308 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
309 def _restrictcapabilities(self, caps): |
20955
12f161f08d74
bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20954
diff
changeset
|
310 # bundle2 is not ready for prime time, drop it unless explicitly |
12f161f08d74
bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20954
diff
changeset
|
311 # required by the tests (or some brave tester) |
21147
2a246e737f92
bundle2: move bundle2 config option to section "experimental"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21145
diff
changeset
|
312 if self.ui.configbool('experimental', 'bundle2-exp', False): |
20955
12f161f08d74
bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20954
diff
changeset
|
313 caps = set(caps) |
21141
d8dd19e09ed4
bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21140
diff
changeset
|
314 capsblob = bundle2.encodecaps(self.bundle2caps) |
21145
0c5088be66af
bundle2: rename server capability to bundle2-exp
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21144
diff
changeset
|
315 caps.add('bundle2-exp=' + urllib.quote(capsblob)) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
316 return caps |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
317 |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
318 def _applyrequirements(self, requirements): |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
319 self.requirements = requirements |
14333
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14274
diff
changeset
|
320 self.sopener.options = dict((r, 1) for r in requirements |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
321 if r in self.openerreqs) |
20180
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20176
diff
changeset
|
322 chunkcachesize = self.ui.configint('format', 'chunkcachesize') |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20176
diff
changeset
|
323 if chunkcachesize is not None: |
969148b49fc6
revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents:
20176
diff
changeset
|
324 self.sopener.options['chunkcachesize'] = chunkcachesize |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
325 |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
326 def _writerequirements(self): |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
327 reqfile = self.opener("requires", "w") |
18356
752f77ef7202
localrepo: store requirements sorted
Mads Kiilerich <mads@kiilerich.com>
parents:
18318
diff
changeset
|
328 for r in sorted(self.requirements): |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
329 reqfile.write("%s\n" % r) |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
330 reqfile.close() |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
331 |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
332 def _checknested(self, path): |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
333 """Determine if path is a legal nested repository.""" |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
334 if not path.startswith(self.root): |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
335 return False |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
336 subpath = path[len(self.root) + 1:] |
15722
417127af3996
windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15604
diff
changeset
|
337 normsubpath = util.pconvert(subpath) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
338 |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
339 # XXX: Checking against the current working copy is wrong in |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
340 # the sense that it can reject things like |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
341 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
342 # $ hg cat -r 10 sub/x.txt |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
343 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
344 # if sub/ is no longer a subrepository in the working copy |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
345 # parent revision. |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
346 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
347 # However, it can of course also allow things that would have |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
348 # been rejected before, such as the above cat command if sub/ |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
349 # is a subrepository now, but was a normal directory before. |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
350 # The old path auditor would have rejected by mistake since it |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
351 # panics when it sees sub/.hg/. |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
352 # |
12174
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
353 # All in all, checking against the working copy seems sensible |
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
354 # since we want to prevent access to nested repositories on |
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
355 # the filesystem *now*. |
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
356 ctx = self[None] |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
357 parts = util.splitpath(subpath) |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
358 while parts: |
15722
417127af3996
windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15604
diff
changeset
|
359 prefix = '/'.join(parts) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
360 if prefix in ctx.substate: |
15722
417127af3996
windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15604
diff
changeset
|
361 if prefix == normsubpath: |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
362 return True |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
363 else: |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
364 sub = ctx.sub(prefix) |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
365 return sub.checknested(subpath[len(prefix) + 1:]) |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
366 else: |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
367 parts.pop() |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
368 return False |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
369 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
370 def peer(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
371 return localpeer(self) # not cached to avoid reference cycle |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
372 |
17993
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
373 def unfiltered(self): |
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
374 """Return unfiltered version of the repository |
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
375 |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
376 Intended to be overwritten by filtered repo.""" |
17993
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
377 return self |
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
378 |
18100
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
379 def filtered(self, name): |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
380 """Return a filtered version of a repository""" |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
381 # build a new class with the mixin and the current class |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
382 # (possibly subclass of the repo) |
18100
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
383 class proxycls(repoview.repoview, self.unfiltered().__class__): |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
384 pass |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
385 return proxycls(self, name) |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
386 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
387 @repofilecache('bookmarks') |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
388 def _bookmarks(self): |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17857
diff
changeset
|
389 return bookmarks.bmstore(self) |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
390 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
391 @repofilecache('bookmarks.current') |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
392 def _bookmarkcurrent(self): |
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
393 return bookmarks.readcurrent(self) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
394 |
16707
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
395 def bookmarkheads(self, bookmark): |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
396 name = bookmark.split('@', 1)[0] |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
397 heads = [] |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
398 for mark, n in self._bookmarks.iteritems(): |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
399 if mark.split('@', 1)[0] == name: |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
400 heads.append(n) |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
401 return heads |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15403
diff
changeset
|
402 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
403 @storecache('phaseroots') |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
404 def _phasecache(self): |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
405 return phases.phasecache(self, self._phasedefaults) |
15420
e80d0d3198f0
phases: add a cache allowing to know in which phase a changeset is
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15418
diff
changeset
|
406 |
17070
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
407 @storecache('obsstore') |
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
408 def obsstore(self): |
17124
f1b7683f3f95
obsolete: move obsolete markers read/write logic to obsstore object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17075
diff
changeset
|
409 store = obsolete.obsstore(self.sopener) |
17297
6955d69a52a4
obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17295
diff
changeset
|
410 if store and not obsolete._enabled: |
17306
7d2967de2c04
obsolete: fix typos in comments introduced by 6955d69a52a4
Thomas Arendsen Hein <thomas@intevation.de>
parents:
17299
diff
changeset
|
411 # message is rare enough to not be translated |
17297
6955d69a52a4
obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17295
diff
changeset
|
412 msg = 'obsolete feature not enabled but %i markers found!\n' |
6955d69a52a4
obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17295
diff
changeset
|
413 self.ui.warn(msg % len(list(store))) |
17070
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
414 return store |
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
415 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
416 @storecache('00changelog.i') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
417 def changelog(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
418 c = changelog.changelog(self.sopener) |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
419 if 'HG_PENDING' in os.environ: |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
420 p = os.environ['HG_PENDING'] |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
421 if p.startswith(self.root): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
422 c.readpending('00changelog.i.a') |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
423 return c |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
424 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
425 @storecache('00manifest.i') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
426 def manifest(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
427 return manifest.manifest(self.sopener) |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
428 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
429 @repofilecache('dirstate') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
430 def dirstate(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
431 warned = [0] |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
432 def validate(node): |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
433 try: |
14064
e4bfb9c337f3
remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents:
14056
diff
changeset
|
434 self.changelog.rev(node) |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
435 return node |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
436 except error.LookupError: |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
437 if not warned[0]: |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
438 warned[0] = True |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
439 self.ui.warn(_("warning: ignoring unknown" |
13037
9beac11b8c56
localrepo: move string formatting out of gettext call
Martin Geisler <mg@aragost.com>
parents:
13032
diff
changeset
|
440 " working parent %s!\n") % short(node)) |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
441 return nullid |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
442 |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
443 return dirstate.dirstate(self.opener, self.ui, self.root, validate) |
2155
ff255b41b4aa
support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2150
diff
changeset
|
444 |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
445 def __getitem__(self, changeid): |
8527
f9a80054dd3c
use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents:
8515
diff
changeset
|
446 if changeid is None: |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
447 return context.workingctx(self) |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
448 return context.changectx(self, changeid) |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
449 |
9924
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
450 def __contains__(self, changeid): |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
451 try: |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
452 return bool(self.lookup(changeid)) |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
453 except error.RepoLookupError: |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
454 return False |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
455 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
456 def __nonzero__(self): |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
457 return True |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
458 |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
459 def __len__(self): |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
460 return len(self.changelog) |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
461 |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
462 def __iter__(self): |
17675
8575f4a2126e
clfilter: remove usage of `range` in favor of iteration over changelog
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17670
diff
changeset
|
463 return iter(self.changelog) |
2155
ff255b41b4aa
support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2150
diff
changeset
|
464 |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
465 def revs(self, expr, *args): |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
466 '''Return a list of revisions matching the given revset''' |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
467 expr = revset.formatspec(expr, *args) |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
468 m = revset.match(None, expr) |
20646
a4d587c6e3dd
localrepo: changed revs to use spanset instead of baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20627
diff
changeset
|
469 return m(self, revset.spanset(self)) |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
470 |
14902
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
471 def set(self, expr, *args): |
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
472 ''' |
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
473 Yield a context for each matching revision, after doing arg |
14904
ff2d907a5af8
localrepo: fix comment on set
Matt Mackall <mpm@selenic.com>
parents:
14902
diff
changeset
|
474 replacement via revset.formatspec |
14902
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
475 ''' |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
476 for r in self.revs(expr, *args): |
14902
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
477 yield self[r] |
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
478 |
2673
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
479 def url(self): |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
480 return 'file:' + self.root |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
481 |
1718
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
482 def hook(self, name, throw=False, **args): |
21866
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
483 """Call a hook, passing this repo instance. |
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
484 |
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
485 This a convenience method to aid invoking hooks. Extensions likely |
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
486 won't call this unless they have registered a custom hook or are |
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
487 replacing code that is expected to call a hook. |
a2ca9dcb4b77
localrepo: document localrepo.hook()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21702
diff
changeset
|
488 """ |
4622
fff50306e6dd
hooks: separate hook code into a separate module
Matt Mackall <mpm@selenic.com>
parents:
4619
diff
changeset
|
489 return hook.hook(self.ui, self, name, throw, **args) |
487 | 490 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
491 @unfilteredmethod |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
492 def _tag(self, names, node, message, local, user, date, extra={}, |
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
493 editor=False): |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
494 if isinstance(names, str): |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
495 names = (names,) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
496 |
11063
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
497 branches = self.branchmap() |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
498 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
499 self.hook('pretag', throw=True, node=hex(node), tag=name, |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
500 local=local) |
11063
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
501 if name in branches: |
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
502 self.ui.warn(_("warning: tag %s conflicts with existing" |
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
503 " branch name\n") % name) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
504 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
505 def writetags(fp, names, munge, prevtags): |
5985
850494d62674
localrepo._tag: add a seek before writing the new tag
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5882
diff
changeset
|
506 fp.seek(0, 2) |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
507 if prevtags and prevtags[-1] != '\n': |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
508 fp.write('\n') |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
509 for name in names: |
6671
938eddd76237
tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents:
6647
diff
changeset
|
510 m = munge and munge(name) or name |
16683 | 511 if (self._tagscache.tagtypes and |
512 name in self._tagscache.tagtypes): | |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
513 old = self.tags().get(name, nullid) |
6671
938eddd76237
tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents:
6647
diff
changeset
|
514 fp.write('%s %s\n' % (hex(old), m)) |
938eddd76237
tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents:
6647
diff
changeset
|
515 fp.write('%s %s\n' % (hex(node), m)) |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
516 fp.close() |
5081
ea7b982b6c08
Remove trailing spaces
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4932
diff
changeset
|
517 |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
518 prevtags = '' |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
519 if local: |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
520 try: |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
521 fp = self.opener('localtags', 'r+') |
7875
553aa0cbeab6
cleanup: drop unused assignments
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7848
diff
changeset
|
522 except IOError: |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
523 fp = self.opener('localtags', 'a') |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
524 else: |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
525 prevtags = fp.read() |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
526 |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
527 # local tags are stored in the current charset |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
528 writetags(fp, names, None, prevtags) |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
529 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
530 self.hook('tag', node=hex(node), tag=name, local=local) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
531 return |
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
532 |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
533 try: |
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
534 fp = self.wfile('.hgtags', 'rb+') |
14646
001788ef4bbb
localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents:
14603
diff
changeset
|
535 except IOError, e: |
001788ef4bbb
localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents:
14603
diff
changeset
|
536 if e.errno != errno.ENOENT: |
001788ef4bbb
localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents:
14603
diff
changeset
|
537 raise |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
538 fp = self.wfile('.hgtags', 'ab') |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
539 else: |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
540 prevtags = fp.read() |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
541 |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
542 # committed tags are stored in UTF-8 |
7948
de377b1a9a84
move encoding bits from util to encoding
Matt Mackall <mpm@selenic.com>
parents:
7930
diff
changeset
|
543 writetags(fp, names, encoding.fromlocal, prevtags) |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
544 |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13391
diff
changeset
|
545 fp.close() |
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13391
diff
changeset
|
546 |
15929
4091660dc130
tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents:
15922
diff
changeset
|
547 self.invalidatecaches() |
4091660dc130
tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents:
15922
diff
changeset
|
548 |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
549 if '.hgtags' not in self.dirstate: |
11303
a1aad8333864
move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
11301
diff
changeset
|
550 self[None].add(['.hgtags']) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
551 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
552 m = matchmod.exact(self.root, '', ['.hgtags']) |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
553 tagnode = self.commit(message, user, date, extra=extra, match=m, |
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
554 editor=editor) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
555 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
556 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
557 self.hook('tag', node=hex(node), tag=name, local=local) |
4118
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
558 |
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
559 return tagnode |
35b39097c3e6
Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents:
4070
diff
changeset
|
560 |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
561 def tag(self, names, node, message, local, user, date, editor=False): |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
562 '''tag a revision with one or more symbolic names. |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
563 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
564 names is a list of strings or, when adding a single tag, names may be a |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
565 string. |
6334
7016f7fb8fe3
tab/space cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents:
6321
diff
changeset
|
566 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
567 if local is True, the tags are stored in a per-repository file. |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
568 otherwise, they are stored in the .hgtags file, and a new |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
569 changeset is committed with the change. |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
570 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
571 keyword arguments: |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
572 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
573 local: whether to store tags in non-version-controlled file |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
574 (default False) |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
575 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
576 message: commit message to use if committing |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
577 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
578 user: name of user to use if committing |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
579 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
580 date: date tuple to use if committing''' |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
581 |
13133
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
582 if not local: |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
583 for x in self.status()[:5]: |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
584 if '.hgtags' in x: |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
585 raise util.Abort(_('working copy of .hgtags is changed ' |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
586 '(please commit .hgtags manually)')) |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
587 |
7814
4421abf8c85d
tag: force load of tag cache
Matt Mackall <mpm@selenic.com>
parents:
7803
diff
changeset
|
588 self.tags() # instantiate the cache |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
589 self._tag(names, node, message, local, user, date, editor=editor) |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
590 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
591 @filteredpropertycache |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
592 def _tagscache(self): |
16683 | 593 '''Returns a tagscache object that contains various tags related |
594 caches.''' | |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
595 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
596 # This simplifies its cache management by having one decorated |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
597 # function (this one) and the rest simply fetch things from it. |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
598 class tagscache(object): |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
599 def __init__(self): |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
600 # These two define the set of tags for this repository. tags |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
601 # maps tag name to node; tagtypes maps tag name to 'global' or |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
602 # 'local'. (Global tags are defined by .hgtags across all |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
603 # heads, and local tags are defined in .hg/localtags.) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
604 # They constitute the in-memory cache of tags. |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
605 self.tags = self.tagtypes = None |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
606 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
607 self.nodetagscache = self.tagslist = None |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
608 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
609 cache = tagscache() |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
610 cache.tags, cache.tagtypes = self._findtags() |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
611 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
612 return cache |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
613 |
343 | 614 def tags(self): |
615 '''return a mapping of tag to node''' | |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
616 t = {} |
17715
21c503480986
clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17714
diff
changeset
|
617 if self.changelog.filteredrevs: |
21c503480986
clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17714
diff
changeset
|
618 tags, tt = self._findtags() |
21c503480986
clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17714
diff
changeset
|
619 else: |
21c503480986
clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17714
diff
changeset
|
620 tags = self._tagscache.tags |
21c503480986
clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17714
diff
changeset
|
621 for k, v in tags.iteritems(): |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
622 try: |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
623 # ignore tags to unknown nodes |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
624 self.changelog.rev(v) |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
625 t[k] = v |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16551
diff
changeset
|
626 except (error.LookupError, ValueError): |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
627 pass |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
628 return t |
4210
caff92047e87
Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents:
4178
diff
changeset
|
629 |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
630 def _findtags(self): |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
631 '''Do the hard work of finding tags. Return a pair of dicts |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
632 (tags, tagtypes) where tags maps tag name to node, and tagtypes |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
633 maps tag name to a string like \'global\' or \'local\'. |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
634 Subclasses or extensions are free to add their own tags, but |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
635 should be aware that the returned dicts will be retained for the |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
636 duration of the localrepo object.''' |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
637 |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
638 # XXX what tagtype should subclasses/extensions use? Currently |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
639 # mq and bookmarks add tags, but do not set the tagtype at all. |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
640 # Should each extension invent its own tag type? Should there |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
641 # be one tagtype for all such "virtual" tags? Or is the status |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
642 # quo fine? |
4210
caff92047e87
Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents:
4178
diff
changeset
|
643 |
9148
b7837f0ed9fe
localrepo: factor updatetags() out of readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9147
diff
changeset
|
644 alltags = {} # map tag name to (node, hist) |
5657
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
645 tagtypes = {} |
659 | 646 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
647 tagsmod.findglobaltags(self.ui, self, alltags, tagtypes) |
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
648 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) |
5657
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
649 |
9152
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
650 # Build the return dicts. Have to re-encode tag names because |
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
651 # the tags module always uses UTF-8 (in order not to lose info |
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
652 # writing to the cache), but the rest of Mercurial wants them in |
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
653 # local encoding. |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
654 tags = {} |
9147
234a230cc33b
localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9146
diff
changeset
|
655 for (name, (node, hist)) in alltags.iteritems(): |
234a230cc33b
localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9146
diff
changeset
|
656 if node != nullid: |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
657 tags[encoding.tolocal(name)] = node |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
658 tags['tip'] = self.changelog.tip() |
9152
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
659 tagtypes = dict([(encoding.tolocal(name), value) |
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
660 for (name, value) in tagtypes.iteritems()]) |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
661 return (tags, tagtypes) |
343 | 662 |
5657
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
663 def tagtype(self, tagname): |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
664 ''' |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
665 return the type of the given tag. result can be: |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
666 |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
667 'local' : a local tag |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
668 'global' : a global tag |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
669 None : tag does not exist |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
670 ''' |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
671 |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
672 return self._tagscache.tagtypes.get(tagname) |
5657
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
673 |
343 | 674 def tagslist(self): |
675 '''return a list of tags ordered by revision''' | |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
676 if not self._tagscache.tagslist: |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
677 l = [] |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
678 for t, n in self.tags().iteritems(): |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
679 r = self.changelog.rev(n) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
680 l.append((r, t, n)) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
681 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)] |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
682 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
683 return self._tagscache.tagslist |
343 | 684 |
685 def nodetags(self, node): | |
686 '''return the tags associated with a node''' | |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
687 if not self._tagscache.nodetagscache: |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
688 nodetagscache = {} |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
689 for t, n in self._tagscache.tags.iteritems(): |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
690 nodetagscache.setdefault(n, []).append(t) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
691 for tags in nodetagscache.itervalues(): |
11047
c7dbd6c4877a
tags: return tags in sorted order
Eric Eisner <ede@mit.edu>
parents:
10970
diff
changeset
|
692 tags.sort() |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
693 self._tagscache.nodetagscache = nodetagscache |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
694 return self._tagscache.nodetagscache.get(node, []) |
343 | 695 |
13384
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
696 def nodebookmarks(self, node): |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
697 marks = [] |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
698 for bookmark, n in self._bookmarks.iteritems(): |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
699 if n == node: |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
700 marks.append(bookmark) |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
701 return sorted(marks) |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
702 |
12066
d01e28657429
localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents:
12035
diff
changeset
|
703 def branchmap(self): |
20245
4edd179fefb8
help: branch names primarily denote the tipmost unclosed branch head
Mads Kiilerich <madski@unity3d.com>
parents:
20226
diff
changeset
|
704 '''returns a dictionary {branch: [branchheads]} with branchheads |
4edd179fefb8
help: branch names primarily denote the tipmost unclosed branch head
Mads Kiilerich <madski@unity3d.com>
parents:
20226
diff
changeset
|
705 ordered by increasing revision number''' |
18189
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
706 branchmap.updatecache(self) |
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
707 return self._branchcaches[self.filtername] |
17714
5210e5a556d9
clfilter: do not use branchmap cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17675
diff
changeset
|
708 |
16719
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
709 def branchtip(self, branch): |
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
710 '''return the tip node for a given branch''' |
20187
4d6d5ef88538
localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents:
20184
diff
changeset
|
711 try: |
4d6d5ef88538
localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents:
20184
diff
changeset
|
712 return self.branchmap().branchtip(branch) |
4d6d5ef88538
localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents:
20184
diff
changeset
|
713 except KeyError: |
16719
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
714 raise error.RepoLookupError(_("unknown branch '%s'") % branch) |
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
715 |
343 | 716 def lookup(self, key): |
16378
c463f46fe050
localrepo: lookup now goes through context
Matt Mackall <mpm@selenic.com>
parents:
16371
diff
changeset
|
717 return self[key].node() |
67 | 718 |
10960
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
719 def lookupbranch(self, key, remote=None): |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
720 repo = remote or self |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
721 if key in repo.branchmap(): |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
722 return key |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
723 |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
724 repo = (remote and remote.local()) and remote or self |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
725 return repo[key].branch() |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
726 |
13723
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
727 def known(self, nodes): |
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
728 nm = self.changelog.nodemap |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
729 pc = self._phasecache |
15889
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
730 result = [] |
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
731 for n in nodes: |
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
732 r = nm.get(n) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
733 resp = not (r is None or pc.phase(self, r) >= phases.secret) |
15889
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
734 result.append(resp) |
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
735 return result |
13723
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
736 |
926 | 737 def local(self): |
14603
68a43fdd7d80
localrepo: local() returns self
Matt Mackall <mpm@selenic.com>
parents:
14549
diff
changeset
|
738 return self |
926 | 739 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
740 def cancopy(self): |
20332
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
741 # so statichttprepo's override of local() works |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
742 if not self.local(): |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
743 return False |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
744 if not self.ui.configbool('phases', 'publish', True): |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
745 return True |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
746 # if publishing we can't copy if there is filtered content |
a959f7167077
clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20314
diff
changeset
|
747 return not self.filtered('visible').changelog.filteredrevs |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
748 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
749 def join(self, f): |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
750 return os.path.join(self.path, f) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
751 |
244 | 752 def wjoin(self, f): |
753 return os.path.join(self.root, f) | |
754 | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
755 def file(self, f): |
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
756 if f[0] == '/': |
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
757 f = f[1:] |
4258
b11a2fb59cf5
revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4232
diff
changeset
|
758 return filelog.filelog(self.sopener, f) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
759 |
6739
c9fbd6ec3489
context: avoid using None for working parent
Matt Mackall <mpm@selenic.com>
parents:
6736
diff
changeset
|
760 def changectx(self, changeid): |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
761 return self[changeid] |
3218
8d4855fd9d7b
merge: use new working context object in update
Matt Mackall <mpm@selenic.com>
parents:
3164
diff
changeset
|
762 |
3163
1605e336d229
Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents:
3132
diff
changeset
|
763 def parents(self, changeid=None): |
6742
2d54e7c1e69d
context: clean up parents()
Matt Mackall <mpm@selenic.com>
parents:
6740
diff
changeset
|
764 '''get list of changectxs for parents of changeid''' |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
765 return self[changeid].parents() |
3163
1605e336d229
Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents:
3132
diff
changeset
|
766 |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
767 def setparents(self, p1, p2=nullid): |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
768 copies = self.dirstate.setparents(p1, p2) |
18739
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
769 pctx = self[p1] |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
770 if copies: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
771 # Adjust copy records, the dirstate cannot do it, it |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
772 # requires access to parents manifests. Preserve them |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
773 # only for entries added to first parent. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
774 for f in copies: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
775 if f not in pctx and copies[f] in pctx: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
776 self.dirstate.copy(copies[f], f) |
18739
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
777 if p2 == nullid: |
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
778 for f, s in sorted(self.dirstate.copies().items()): |
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
779 if f not in pctx and s not in pctx: |
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
780 self.dirstate.copy(None, f) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
781 |
2564
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
782 def filectx(self, path, changeid=None, fileid=None): |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
783 """changeid can be a changeset revision, node, or tag. |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
784 fileid can be a file revision or node.""" |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
785 return context.filectx(self, path, changeid, fileid) |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
786 |
627 | 787 def getcwd(self): |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
788 return self.dirstate.getcwd() |
627 | 789 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4516
diff
changeset
|
790 def pathto(self, f, cwd=None): |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4516
diff
changeset
|
791 return self.dirstate.pathto(f, cwd) |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4516
diff
changeset
|
792 |
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
793 def wfile(self, f, mode='r'): |
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
794 return self.wopener(f, mode) |
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
795 |
4275
81402b2b294d
use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4273
diff
changeset
|
796 def _link(self, f): |
18949
138978f20180
localrepo: use "vfs.islink()" instead of "os.path.islink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18948
diff
changeset
|
797 return self.wvfs.islink(f) |
4275
81402b2b294d
use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4273
diff
changeset
|
798 |
11698
9df481f8036d
localrepo: refactor filter computation
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11669
diff
changeset
|
799 def _loadfilter(self, filter): |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
800 if filter not in self.filterpats: |
1258 | 801 l = [] |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
802 for pat, cmd in self.ui.configitems(filter): |
7226
b71a52f101dc
Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents:
7208
diff
changeset
|
803 if cmd == '!': |
b71a52f101dc
Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents:
7208
diff
changeset
|
804 continue |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
805 mf = matchmod.match(self.root, '', [pat]) |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
806 fn = None |
6066
f3a8b5360100
Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents:
6065
diff
changeset
|
807 params = cmd |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
808 for name, filterfn in self._datafilters.iteritems(): |
6210
942287cb1f57
Removed trailing spaces from everything except test output
Thomas Arendsen Hein <thomas@intevation.de>
parents:
6201
diff
changeset
|
809 if cmd.startswith(name): |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
810 fn = filterfn |
6066
f3a8b5360100
Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents:
6065
diff
changeset
|
811 params = cmd[len(name):].lstrip() |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
812 break |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
813 if not fn: |
5967
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
814 fn = lambda s, c, **kwargs: util.filter(s, c) |
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
815 # Wrap old filters not supporting keyword arguments |
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
816 if not inspect.getargspec(fn)[2]: |
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
817 oldfn = fn |
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
818 fn = lambda s, c, **kwargs: oldfn(s, c) |
6066
f3a8b5360100
Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents:
6065
diff
changeset
|
819 l.append((mf, fn, params)) |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
820 self.filterpats[filter] = l |
12706
9ca08fbb750a
localrepo: have _loadfilter return the loaded filter patterns
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12687
diff
changeset
|
821 return self.filterpats[filter] |
1258 | 822 |
12707
2216ab103ea8
localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12706
diff
changeset
|
823 def _filter(self, filterpats, filename, data): |
2216ab103ea8
localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12706
diff
changeset
|
824 for mf, fn, cmd in filterpats: |
1258 | 825 if mf(filename): |
9467
4c041f1ee1b4
do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents:
9437
diff
changeset
|
826 self.ui.debug("filtering %s through %s\n" % (filename, cmd)) |
5967
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
827 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename) |
1258 | 828 break |
829 | |
830 return data | |
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
831 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
832 @unfilteredpropertycache |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
833 def _encodefilterpats(self): |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
834 return self._loadfilter('encode') |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
835 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
836 @unfilteredpropertycache |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
837 def _decodefilterpats(self): |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
838 return self._loadfilter('decode') |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
839 |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
840 def adddatafilter(self, name, filter): |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
841 self._datafilters[name] = filter |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
842 |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
843 def wread(self, filename): |
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
844 if self._link(filename): |
18950
647e3b0c8751
localrepo: use "vfs.readlink()" instead of "os.readlink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18949
diff
changeset
|
845 data = self.wvfs.readlink(filename) |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
846 else: |
14168
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
847 data = self.wopener.read(filename) |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
848 return self._filter(self._encodefilterpats, filename, data) |
1258 | 849 |
4006
67982d3ee76c
symlinks: add flags param to wwrite
Matt Mackall <mpm@selenic.com>
parents:
4005
diff
changeset
|
850 def wwrite(self, filename, data, flags): |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
851 data = self._filter(self._decodefilterpats, filename, data) |
6877
1d38f3605b20
util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents:
6875
diff
changeset
|
852 if 'l' in flags: |
1d38f3605b20
util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents:
6875
diff
changeset
|
853 self.wopener.symlink(data, filename) |
1d38f3605b20
util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents:
6875
diff
changeset
|
854 else: |
14184
4ab6e2d597cc
fix errors reported by pyflakes test
Sune Foldager <cryo@cyanite.org>
parents:
14168
diff
changeset
|
855 self.wopener.write(filename, data) |
6877
1d38f3605b20
util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents:
6875
diff
changeset
|
856 if 'x' in flags: |
18951
d13916a00b7e
localrepo: use "vfs.setflags()" instead of "util.setflags()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18950
diff
changeset
|
857 self.wvfs.setflags(filename, False, True) |
1258 | 858 |
4005
656e06eebda7
replace filehandle version of wwrite with wwritedata
Matt Mackall <mpm@selenic.com>
parents:
4004
diff
changeset
|
859 def wwritedata(self, filename, data): |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
860 return self._filter(self._decodefilterpats, filename, data) |
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
861 |
19853
eddc2a2d57e6
localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents:
19852
diff
changeset
|
862 def transaction(self, desc, report=None): |
8072
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
863 tr = self._transref and self._transref() or None |
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
864 if tr and tr.running(): |
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
865 return tr.nest() |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
866 |
5865
e7127f669edb
transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents:
5814
diff
changeset
|
867 # abort here if the journal already exists |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
868 if self.svfs.exists("journal"): |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
869 raise error.RepoError( |
21274
3b4c75690206
journal: set Abort hint when failing due to an abandoned transaction
Johan Bjork <jbjoerk@gmail.com>
parents:
21237
diff
changeset
|
870 _("abandoned transaction found"), |
3b4c75690206
journal: set Abort hint when failing due to an abandoned transaction
Johan Bjork <jbjoerk@gmail.com>
parents:
21237
diff
changeset
|
871 hint=_("run 'hg recover' to clean up transaction")) |
5865
e7127f669edb
transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents:
5814
diff
changeset
|
872 |
20883
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
873 def onclose(): |
21698
99ba1d082287
localrepo: prevent leak of transaction object (issue4258)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21186
diff
changeset
|
874 self.store.write(self._transref()) |
20883
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
875 |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
876 self._writejournal(desc) |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
877 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()] |
19853
eddc2a2d57e6
localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents:
19852
diff
changeset
|
878 rp = report and report or self.ui.warn |
eddc2a2d57e6
localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents:
19852
diff
changeset
|
879 tr = transaction.transaction(rp, self.sopener, |
20087
cf3b8285af00
transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20082
diff
changeset
|
880 "journal", |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
881 aftertrans(renames), |
20883
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
882 self.store.createmode, |
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
883 onclose) |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
884 self._transref = weakref.ref(tr) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
885 return tr |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
886 |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
887 def _journalfiles(self): |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
888 return ((self.svfs, 'journal'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
889 (self.vfs, 'journal.dirstate'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
890 (self.vfs, 'journal.branch'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
891 (self.vfs, 'journal.desc'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
892 (self.vfs, 'journal.bookmarks'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
893 (self.svfs, 'journal.phaseroots')) |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
894 |
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
895 def undofiles(self): |
20975
37cdf1fca1b2
localrepo: make "undofiles()" return list of tuples "(vfs, relative filename)"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20969
diff
changeset
|
896 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()] |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
897 |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
898 def _writejournal(self, desc): |
16456
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
899 self.opener.write("journal.dirstate", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
900 self.opener.tryread("dirstate")) |
14168
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
901 self.opener.write("journal.branch", |
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
902 encoding.fromlocal(self.dirstate.branch())) |
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
903 self.opener.write("journal.desc", |
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
14162
diff
changeset
|
904 "%d\n%s\n" % (len(self), desc)) |
16456
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
905 self.opener.write("journal.bookmarks", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
906 self.opener.tryread("bookmarks")) |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
907 self.sopener.write("journal.phaseroots", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
908 self.sopener.tryread("phaseroots")) |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
909 |
210 | 910 def recover(self): |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
911 lock = self.lock() |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
912 try: |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
913 if self.svfs.exists("journal"): |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
914 self.ui.status(_("rolling back interrupted transaction\n")) |
20087
cf3b8285af00
transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20082
diff
changeset
|
915 transaction.rollback(self.sopener, "journal", |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
916 self.ui.warn) |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
917 self.invalidate() |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
918 return True |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
919 else: |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
920 self.ui.warn(_("no interrupted transaction available\n")) |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
921 return False |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
922 finally: |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
923 lock.release() |
210 | 924 |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
925 def rollback(self, dryrun=False, force=False): |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
926 wlock = lock = None |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
927 try: |
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
928 wlock = self.wlock() |
4438
3900f684a150
Fix hg import --exact bug that hangs hg on failure.
Eric Hopper <hopper@omnifarious.org>
parents:
4417
diff
changeset
|
929 lock = self.lock() |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
930 if self.svfs.exists("undo"): |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
931 return self._rollback(dryrun, force) |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
932 else: |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
933 self.ui.warn(_("no rollback information available\n")) |
11177
6a64813276ed
commands: initial audit of exit codes
Matt Mackall <mpm@selenic.com>
parents:
11174
diff
changeset
|
934 return 1 |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
935 finally: |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
936 release(lock, wlock) |
162 | 937 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
938 @unfilteredmethod # Until we get smarter cache management |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
939 def _rollback(self, dryrun, force): |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
940 ui = self.ui |
15097
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
941 try: |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
942 args = self.opener.read('undo.desc').splitlines() |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
943 (oldlen, desc, detail) = (int(args[0]), args[1], None) |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
944 if len(args) >= 3: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
945 detail = args[2] |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
946 oldtip = oldlen - 1 |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
947 |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
948 if detail and ui.verbose: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
949 msg = (_('repository tip rolled back to revision %s' |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
950 ' (undo %s: %s)\n') |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
951 % (oldtip, desc, detail)) |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
952 else: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
953 msg = (_('repository tip rolled back to revision %s' |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
954 ' (undo %s)\n') |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
955 % (oldtip, desc)) |
15097
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
956 except IOError: |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
957 msg = _('rolling back unknown transaction\n') |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
958 desc = None |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
959 |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
960 if not force and self['.'] != self['tip'] and desc == 'commit': |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
961 raise util.Abort( |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
962 _('rollback of last commit while not checked out ' |
15187
0292f88d3b86
rollback: use a hint for force
Matt Mackall <mpm@selenic.com>
parents:
15183
diff
changeset
|
963 'may lose data'), hint=_('use -f to force')) |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
964 |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
965 ui.status(msg) |
15097
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
966 if dryrun: |
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
967 return 0 |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
968 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
969 parents = self.dirstate.parents() |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
970 self.destroying() |
20087
cf3b8285af00
transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20082
diff
changeset
|
971 transaction.rollback(self.sopener, 'undo', ui.warn) |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
972 if self.vfs.exists('undo.bookmarks'): |
18948
2f05fa162316
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18947
diff
changeset
|
973 self.vfs.rename('undo.bookmarks', 'bookmarks') |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
974 if self.svfs.exists('undo.phaseroots'): |
18948
2f05fa162316
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18947
diff
changeset
|
975 self.svfs.rename('undo.phaseroots', 'phaseroots') |
15097
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
976 self.invalidate() |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
977 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
978 parentgone = (parents[0] not in self.changelog.nodemap or |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
979 parents[1] not in self.changelog.nodemap) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
980 if parentgone: |
18948
2f05fa162316
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18947
diff
changeset
|
981 self.vfs.rename('undo.dirstate', 'dirstate') |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
982 try: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
983 branch = self.opener.read('undo.branch') |
17360
935831597e16
rollback: write dirstate branch with correct encoding
Sune Foldager <cryo@cyanite.org>
parents:
17324
diff
changeset
|
984 self.dirstate.setbranch(encoding.tolocal(branch)) |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
985 except IOError: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
986 ui.warn(_('named branch could not be reset: ' |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
987 'current branch is still \'%s\'\n') |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
988 % self.dirstate.branch()) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
989 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
990 self.dirstate.invalidate() |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
991 parents = tuple([p.rev() for p in self.parents()]) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
992 if len(parents) > 1: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
993 ui.status(_('working directory now based on ' |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
994 'revisions %d and %d\n') % parents) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
995 else: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
996 ui.status(_('working directory now based on ' |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
997 'revision %d\n') % parents) |
17013
c8eda7bbdcab
strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents:
17012
diff
changeset
|
998 # TODO: if we know which new heads may result from this rollback, pass |
c8eda7bbdcab
strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents:
17012
diff
changeset
|
999 # them to destroy(), which will prevent the branchhead cache from being |
c8eda7bbdcab
strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents:
17012
diff
changeset
|
1000 # invalidated. |
15604
b8d8599410da
rollback: always call destroyed() (regression from 1.9)
Greg Ward <greg-hg@gerg.ca>
parents:
15381
diff
changeset
|
1001 self.destroyed() |
15097
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
1002 return 0 |
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
1003 |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1004 def invalidatecaches(self): |
15988
827e0126738d
localrepo: delete _phaserev when invalidating caches
Idan Kamara <idankk86@gmail.com>
parents:
15987
diff
changeset
|
1005 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1006 if '_tagscache' in vars(self): |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1007 # can't use delattr on proxy |
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1008 del self.__dict__['_tagscache'] |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
1009 |
18189
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
1010 self.unfiltered()._branchcaches.clear() |
18105
312262ebc223
cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18101
diff
changeset
|
1011 self.invalidatevolatilesets() |
312262ebc223
cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18101
diff
changeset
|
1012 |
312262ebc223
cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18101
diff
changeset
|
1013 def invalidatevolatilesets(self): |
312262ebc223
cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18101
diff
changeset
|
1014 self.filteredrevcache.clear() |
17469
fb72eec7efd8
obsolete: introduce caches for all meaningful sets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17434
diff
changeset
|
1015 obsolete.clearobscaches(self) |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
1016 |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1017 def invalidatedirstate(self): |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1018 '''Invalidates the dirstate, causing the next call to dirstate |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1019 to check if it was modified since the last time it was read, |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1020 rereading it if it has. |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1021 |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1022 This is different to dirstate.invalidate() that it doesn't always |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1023 rereads the dirstate. Use dirstate.invalidate() if you want to |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1024 explicitly read the dirstate again (i.e. restoring it to a previous |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1025 known good state).''' |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1026 if hasunfilteredcache(self, 'dirstate'): |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1027 for k in self.dirstate._filecache: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1028 try: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1029 delattr(self.dirstate, k) |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1030 except AttributeError: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1031 pass |
17997
6089956e9880
clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17996
diff
changeset
|
1032 delattr(self.unfiltered(), 'dirstate') |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1033 |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1034 def invalidate(self): |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
1035 unfiltered = self.unfiltered() # all file caches are stored unfiltered |
14935
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1036 for k in self._filecache: |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1037 # dirstate is invalidated separately in invalidatedirstate() |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1038 if k == 'dirstate': |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1039 continue |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1040 |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1041 try: |
17997
6089956e9880
clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17996
diff
changeset
|
1042 delattr(unfiltered, k) |
14935
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1043 except AttributeError: |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1044 pass |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1045 self.invalidatecaches() |
20884
2efdd186925d
caches: invalidate store caches when lock is taken
Durham Goode <durham@fb.com>
parents:
20883
diff
changeset
|
1046 self.store.invalidatecaches() |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1047 |
20627
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1048 def invalidateall(self): |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1049 '''Fully invalidates both store and non-store parts, causing the |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1050 subsequent operation to reread any outside changes.''' |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1051 # extension should hook this to invalidate its caches |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1052 self.invalidate() |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1053 self.invalidatedirstate() |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1054 |
20091
abfe6a8e619b
lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20088
diff
changeset
|
1055 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc): |
161 | 1056 try: |
20091
abfe6a8e619b
lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20088
diff
changeset
|
1057 l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc) |
7640 | 1058 except error.LockHeld, inst: |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1059 if not wait: |
2016
ff5c9a92f556
fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1998
diff
changeset
|
1060 raise |
3688
d92dad355000
Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3687
diff
changeset
|
1061 self.ui.warn(_("waiting for lock on %s held by %r\n") % |
d92dad355000
Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3687
diff
changeset
|
1062 (desc, inst.locker)) |
2016
ff5c9a92f556
fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1998
diff
changeset
|
1063 # default to 600 seconds timeout |
20091
abfe6a8e619b
lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20088
diff
changeset
|
1064 l = lockmod.lock(vfs, lockname, |
20088
7cbb79bddee7
localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20087
diff
changeset
|
1065 int(self.ui.config("ui", "timeout", "600")), |
7cbb79bddee7
localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20087
diff
changeset
|
1066 releasefn, desc=desc) |
20380
c697b70f295f
localrepo: give a sigh of relief when getting lock after waiting for it
Mads Kiilerich <madski@unity3d.com>
parents:
20364
diff
changeset
|
1067 self.ui.warn(_("got lock after %s seconds\n") % l.delay) |
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1068 if acquirefn: |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1069 acquirefn() |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1070 return l |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1071 |
15587
809d5d30e377
localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents:
15586
diff
changeset
|
1072 def _afterlock(self, callback): |
15583
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1073 """add a callback to the current repository lock. |
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1074 |
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1075 The callback will be executed on lock release.""" |
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1076 l = self._lockref and self._lockref() |
15588
632f4be4d1f3
localrepo: remove asserts in _afterlock
Matt Mackall <mpm@selenic.com>
parents:
15587
diff
changeset
|
1077 if l: |
15589
cc24e4ed3e0c
lock: change name of release chain
Matt Mackall <mpm@selenic.com>
parents:
15588
diff
changeset
|
1078 l.postrelease.append(callback) |
16680
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1079 else: |
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1080 callback() |
15583
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1081 |
4914 | 1082 def lock(self, wait=True): |
9309
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1083 '''Lock the repository store (.hg/store) and return a weak reference |
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1084 to the lock. Use this before modifying the store (e.g. committing or |
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1085 stripping). If you are opening a transaction, get a lock as well.)''' |
8108
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1086 l = self._lockref and self._lockref() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1087 if l is not None and l.held: |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1088 l.lock() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1089 return l |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1090 |
14931
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1091 def unlock(): |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1092 if hasunfilteredcache(self, '_phasecache'): |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
1093 self._phasecache.write() |
14931
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1094 for k, ce in self._filecache.items(): |
18309
cfeab932cff7
localrepo: don't refresh filecache entries that aren't in __dict__
Idan Kamara <idankk86@gmail.com>
parents:
18305
diff
changeset
|
1095 if k == 'dirstate' or k not in self.__dict__: |
14931
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1096 continue |
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1097 ce.refresh() |
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1098 |
20091
abfe6a8e619b
lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20088
diff
changeset
|
1099 l = self._lock(self.svfs, "lock", wait, unlock, |
13391
d00bbff8600e
fncachestore: defer updating the fncache file to a single file open
Adrian Buehlmann <adrian@cadifra.com>
parents:
13390
diff
changeset
|
1100 self.invalidate, _('repository %s') % self.origroot) |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1101 self._lockref = weakref.ref(l) |
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1102 return l |
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1103 |
4914 | 1104 def wlock(self, wait=True): |
9309
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1105 '''Lock the non-store parts of the repository (everything under |
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1106 .hg except .hg/store) and return a weak reference to the lock. |
cfdcb7a465af
localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents:
9152
diff
changeset
|
1107 Use this before modifying files in .hg.''' |
8108
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1108 l = self._wlockref and self._wlockref() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1109 if l is not None and l.held: |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1110 l.lock() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1111 return l |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1112 |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1113 def unlock(): |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1114 self.dirstate.write() |
18318
948f495fb230
localrepo: drop unnecessary check on wlock unlock
Idan Kamara <idankk86@gmail.com>
parents:
18314
diff
changeset
|
1115 self._filecache['dirstate'].refresh() |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1116 |
20091
abfe6a8e619b
lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20088
diff
changeset
|
1117 l = self._lock(self.vfs, "wlock", wait, unlock, |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1118 self.invalidatedirstate, _('working directory of %s') % |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1119 self.origroot) |
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1120 self._wlockref = weakref.ref(l) |
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1121 return l |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1122 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1123 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist): |
3292
764688cf51e5
merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents:
3241
diff
changeset
|
1124 """ |
3294
a2d93b186a0e
commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents:
3293
diff
changeset
|
1125 commit an individual file as part of a larger transaction |
a2d93b186a0e
commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents:
3293
diff
changeset
|
1126 """ |
3292
764688cf51e5
merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents:
3241
diff
changeset
|
1127 |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1128 fname = fctx.path() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1129 text = fctx.data() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1130 flog = self.file(fname) |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1131 fparent1 = manifest1.get(fname, nullid) |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1132 fparent2 = fparent2o = manifest2.get(fname, nullid) |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1133 |
3292
764688cf51e5
merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents:
3241
diff
changeset
|
1134 meta = {} |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1135 copy = fctx.renamed() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1136 if copy and copy[0] != fname: |
4058
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1137 # Mark the new revision of this file as a copy of another |
4516
96d8a56d4ef9
Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4510
diff
changeset
|
1138 # file. This copy data will effectively act as a parent |
96d8a56d4ef9
Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4510
diff
changeset
|
1139 # of this new revision. If this is a merge, the first |
4058
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1140 # parent will be the nullid (meaning "look up the copy data") |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1141 # and the second one will be the other parent. For example: |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1142 # |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1143 # 0 --- 1 --- 3 rev1 changes file foo |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1144 # \ / rev2 renames foo to bar and changes it |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1145 # \- 2 -/ rev3 should have bar with all changes and |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1146 # should record that bar descends from |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1147 # bar in rev2 and foo in rev1 |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1148 # |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1149 # this allows this merge to succeed: |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1150 # |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1151 # 0 --- 1 --- 3 rev4 reverts the content change from rev2 |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1152 # \ / merging rev3 and rev4 should use bar@rev2 |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1153 # \- 2 --- 4 as the merge base |
e7282dede8cd
filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
3923
diff
changeset
|
1154 # |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1155 |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1156 cfname = copy[0] |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1157 crev = manifest1.get(cfname) |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1158 newfparent = fparent2 |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1159 |
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1160 if manifest2: # branch merge |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1161 if fparent2 == nullid or crev is None: # copied on remote side |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1162 if cfname in manifest2: |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1163 crev = manifest2[cfname] |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1164 newfparent = fparent1 |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1165 |
6875 | 1166 # find source in nearest ancestor if we've lost track |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1167 if not crev: |
9467
4c041f1ee1b4
do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents:
9437
diff
changeset
|
1168 self.ui.debug(" %s: searching for copy revision for %s\n" % |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1169 (fname, cfname)) |
13000
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1170 for ancestor in self[None].ancestors(): |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1171 if cfname in ancestor: |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1172 crev = ancestor[cfname].filenode() |
6876 | 1173 break |
6875 | 1174 |
13000
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1175 if crev: |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1176 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev))) |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1177 meta["copy"] = cfname |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1178 meta["copyrev"] = hex(crev) |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1179 fparent1, fparent2 = nullid, newfparent |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1180 else: |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1181 self.ui.warn(_("warning: can't find ancestor for '%s' " |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1182 "copied from '%s'!\n") % (fname, cfname)) |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1183 |
20556
db0740a487ab
localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents:
20469
diff
changeset
|
1184 elif fparent1 == nullid: |
db0740a487ab
localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents:
20469
diff
changeset
|
1185 fparent1, fparent2 = fparent2, nullid |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1186 elif fparent2 != nullid: |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1187 # is one parent an ancestor of the other? |
21106
53433d8f1faa
localrepo: use commonancestorsheads for checking linear heritage in file commit
Mads Kiilerich <madski@unity3d.com>
parents:
21071
diff
changeset
|
1188 fparentancestors = flog.commonancestorsheads(fparent1, fparent2) |
20987
298c9f346dde
commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20975
diff
changeset
|
1189 if fparent1 in fparentancestors: |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1190 fparent1, fparent2 = fparent2, nullid |
20987
298c9f346dde
commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20975
diff
changeset
|
1191 elif fparent2 in fparentancestors: |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1192 fparent2 = nullid |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1193 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1194 # is the file changed? |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1195 if fparent2 != nullid or flog.cmp(fparent1, text) or meta: |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1196 changelist.append(fname) |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1197 return flog.add(text, meta, tr, linkrev, fparent1, fparent2) |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1198 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1199 # are just the flags changed during merge? |
10320
808c187fc556
localrepo: minor formatting - remove double space
Henri Wiechers <hwiechers@gmail.com>
parents:
10282
diff
changeset
|
1200 if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags(): |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1201 changelist.append(fname) |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1202 |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1203 return fparent1 |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1204 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1205 @unfilteredmethod |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1206 def commit(self, text="", user=None, date=None, match=None, force=False, |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1207 editor=False, extra={}): |
8515
865e08a7d6b0
localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8503
diff
changeset
|
1208 """Add a new revision to current repository. |
865e08a7d6b0
localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8503
diff
changeset
|
1209 |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1210 Revision information is gathered from the working directory, |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1211 match can be used to filter the committed files. If editor is |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1212 supplied, it is called to get a commit message. |
8515
865e08a7d6b0
localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8503
diff
changeset
|
1213 """ |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1214 |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1215 def fail(f, msg): |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1216 raise util.Abort('%s: %s' % (f, msg)) |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1217 |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1218 if not match: |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
1219 match = matchmod.always(self.root, '') |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1220 |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1221 if not force: |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1222 vdirs = [] |
19138
e579687cb5d8
localrepo.commit: hook into match.explicitdir
Siddharth Agarwal <sid0@fb.com>
parents:
19097
diff
changeset
|
1223 match.explicitdir = vdirs.append |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1224 match.bad = fail |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1225 |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1226 wlock = self.wlock() |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1227 try: |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1228 wctx = self[None] |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1229 merge = len(wctx.parents()) > 1 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1230 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1231 if (not force and merge and match and |
8501 | 1232 (match.files() or match.anypats())): |
8397
613ac2856535
remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents:
8395
diff
changeset
|
1233 raise util.Abort(_('cannot partially commit a merge ' |
613ac2856535
remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents:
8395
diff
changeset
|
1234 '(do not specify files or patterns)')) |
6706
716a1296e182
localrepo: replace dirstate by workingfilectx in filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6705
diff
changeset
|
1235 |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1236 changes = self.status(match=match, clean=force) |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1237 if force: |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1238 changes[0].extend(changes[6]) # mq may commit unchanged files |
3621
7d3d603e7df9
localrepo: factor commit and rawcommit
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3620
diff
changeset
|
1239 |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1240 # check subrepos |
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1241 subs = [] |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1242 commitsubs = set() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1243 newstate = wctx.substate.copy() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1244 # only manage subrepos and .hgsubstate if .hgsub is present |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1245 if '.hgsub' in wctx: |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1246 # we'll decide whether to track this ourselves, thanks |
20827
ca5dd216cb62
localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20776
diff
changeset
|
1247 for c in changes[:3]: |
ca5dd216cb62
localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20776
diff
changeset
|
1248 if '.hgsubstate' in c: |
ca5dd216cb62
localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20776
diff
changeset
|
1249 c.remove('.hgsubstate') |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1250 |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1251 # compare current state to last committed state |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1252 # build new substate based on last committed state |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1253 oldstate = wctx.p1().substate |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1254 for s in sorted(newstate.keys()): |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1255 if not match(s): |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1256 # ignore working copy, use old state if present |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1257 if s in oldstate: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1258 newstate[s] = oldstate[s] |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1259 continue |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1260 if not force: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1261 raise util.Abort( |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1262 _("commit with new subrepo %s excluded") % s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1263 if wctx.sub(s).dirty(True): |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1264 if not self.ui.configbool('ui', 'commitsubrepos'): |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1265 raise util.Abort( |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1266 _("uncommitted changes in subrepo %s") % s, |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1267 hint=_("use --subrepos for recursive commit")) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1268 subs.append(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1269 commitsubs.add(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1270 else: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1271 bs = wctx.sub(s).basestate() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1272 newstate[s] = (newstate[s][0], bs, newstate[s][2]) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1273 if oldstate.get(s, (None, None, None))[1] != bs: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1274 subs.append(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1275 |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1276 # check for removed subrepos |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1277 for p in wctx.parents(): |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1278 r = [s for s in p.substate if s not in newstate] |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1279 subs += [s for s in r if match(s)] |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1280 if subs: |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1281 if (not match('.hgsub') and |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1282 '.hgsub' in (wctx.modified() + wctx.added())): |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1283 raise util.Abort( |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1284 _("can't commit subrepos without .hgsub")) |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1285 changes[0].insert(0, '.hgsubstate') |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1286 |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1287 elif '.hgsub' in changes[2]: |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1288 # clean up .hgsubstate when .hgsub is removed |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1289 if ('.hgsubstate' in wctx and |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1290 '.hgsubstate' not in changes[0] + changes[1] + changes[2]): |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1291 changes[2].insert(0, '.hgsubstate') |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1292 |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1293 # make sure all explicit patterns are matched |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1294 if not force and match.files(): |
8710
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1295 matched = set(changes[0] + changes[1] + changes[2]) |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1296 |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1297 for f in match.files(): |
17378
b05e517c2236
commit: normalize filenames when checking explicit files (issue3576)
Matt Mackall <mpm@selenic.com>
parents:
17360
diff
changeset
|
1298 f = self.dirstate.normalize(f) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1299 if f == '.' or f in matched or f in wctx.substate: |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1300 continue |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1301 if f in changes[3]: # missing |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1302 fail(f, _('file not found!')) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1303 if f in vdirs: # visited directory |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1304 d = f + '/' |
8710
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1305 for mf in matched: |
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1306 if mf.startswith(d): |
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1307 break |
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1308 else: |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1309 fail(f, _("no match under directory!")) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1310 elif f not in self.dirstate: |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1311 fail(f, _("file not tracked!")) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1312 |
18659
b946470efed9
localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents:
18644
diff
changeset
|
1313 cctx = context.workingctx(self, text, user, date, extra, changes) |
b946470efed9
localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents:
18644
diff
changeset
|
1314 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1315 if (not force and not extra.get("close") and not merge |
18660
7e6946ed5756
localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents:
18659
diff
changeset
|
1316 and not cctx.files() |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1317 and wctx.branch() == wctx.p1().branch()): |
8404
a2bc39ade36b
commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents:
8403
diff
changeset
|
1318 return None |
a2bc39ade36b
commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents:
8403
diff
changeset
|
1319 |
18660
7e6946ed5756
localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents:
18659
diff
changeset
|
1320 if merge and cctx.deleted(): |
16536
63c817ea4a70
commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents:
16456
diff
changeset
|
1321 raise util.Abort(_("cannot commit merge with missing files")) |
63c817ea4a70
commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents:
16456
diff
changeset
|
1322 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
1323 ms = mergemod.mergestate(self) |
6888
7c36a4fb05a3
make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6884
diff
changeset
|
1324 for f in changes[0]: |
7c36a4fb05a3
make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6884
diff
changeset
|
1325 if f in ms and ms[f] == 'u': |
7c36a4fb05a3
make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6884
diff
changeset
|
1326 raise util.Abort(_("unresolved merge conflicts " |
13541
919174c0aaff
Improve unresolved merge conflicts warning (issue2681)
Patrick Mezard <pmezard@gmail.com>
parents:
13526
diff
changeset
|
1327 "(see hg help resolve)")) |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1328 |
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1329 if editor: |
8994
4a1187d3cb00
commit: report modified subrepos in commit editor
Matt Mackall <mpm@selenic.com>
parents:
8954
diff
changeset
|
1330 cctx._text = editor(self, cctx, subs) |
9935
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1331 edited = (text != cctx._text) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1332 |
20765
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1333 # Save commit message in case this transaction gets rolled back |
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1334 # (e.g. by a pretxncommit hook). Leave the content alone on |
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1335 # the assumption that the user will use the same editor again. |
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1336 msgfn = self.savecommitmessage(cctx._text) |
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1337 |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1338 # commit subs and write new state |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1339 if subs: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1340 for s in sorted(commitsubs): |
11112
4a9bee613737
subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents:
11063
diff
changeset
|
1341 sub = wctx.sub(s) |
4a9bee613737
subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents:
11063
diff
changeset
|
1342 self.ui.status(_('committing subrepository %s\n') % |
12752
18b5b6392fcf
subrepo: rename relpath to subrelpath and introduce reporelpath
Mads Kiilerich <mads@kiilerich.com>
parents:
12708
diff
changeset
|
1343 subrepo.subrelpath(sub)) |
11112
4a9bee613737
subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents:
11063
diff
changeset
|
1344 sr = sub.commit(cctx._text, user, date) |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1345 newstate[s] = (newstate[s][0], sr) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1346 subrepo.writestate(self, newstate) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1347 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1348 p1, p2 = self.dirstate.parents() |
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1349 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '') |
9935
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1350 try: |
16683 | 1351 self.hook("precommit", throw=True, parent1=hookp1, |
1352 parent2=hookp2) | |
9935
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1353 ret = self.commitctx(cctx, True) |
16705
c2d9ef43ff6c
check-code: ignore naked excepts with a "re-raise" comment
Brodie Rao <brodie@sf.io>
parents:
16699
diff
changeset
|
1354 except: # re-raises |
9935
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1355 if edited: |
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1356 self.ui.write( |
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1357 _('note: commit message saved in %s\n') % msgfn) |
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1358 raise |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1359 |
13357
b67867940bd1
bookmarks: move commit action into core
Matt Mackall <mpm@selenic.com>
parents:
13356
diff
changeset
|
1360 # update bookmarks, dirstate and mergestate |
16706
a270ec977ba6
bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents:
16705
diff
changeset
|
1361 bookmarks.update(self, [p1, p2], ret) |
18661
4fb92f14a97a
commit: factor out post-commit cleanup into workingctx
David Schleimer <dschleimer@fb.com>
parents:
18660
diff
changeset
|
1362 cctx.markcommitted(ret) |
8503
90f86a5330bb
commit: tidy up mergestate slightly
Matt Mackall <mpm@selenic.com>
parents:
8502
diff
changeset
|
1363 ms.reset() |
6710
0aa91f69a4c4
localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents:
6709
diff
changeset
|
1364 finally: |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1365 wlock.release() |
6710
0aa91f69a4c4
localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents:
6709
diff
changeset
|
1366 |
16680
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1367 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2): |
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1368 self.hook("commit", node=node, parent1=parent1, parent2=parent2) |
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1369 self._afterlock(commithook) |
10492
0e64d814d7d0
run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents:
10435
diff
changeset
|
1370 return ret |
0e64d814d7d0
run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents:
10435
diff
changeset
|
1371 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1372 @unfilteredmethod |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1373 def commitctx(self, ctx, error=False): |
7077
ccbd39cad3c3
context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents:
7072
diff
changeset
|
1374 """Add a new revision to current repository. |
8410
1d11d985c179
commit: combine _commitctx and commitctx, drop unused force argument
Matt Mackall <mpm@selenic.com>
parents:
8407
diff
changeset
|
1375 Revision information is passed via the context argument. |
7077
ccbd39cad3c3
context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents:
7072
diff
changeset
|
1376 """ |
6715
a3c41abfa828
context: add memctx for memory commits
Patrick Mezard <pmezard@gmail.com>
parents:
6712
diff
changeset
|
1377 |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1378 tr = lock = None |
12899
fabe61418a53
localrepo: do not modify ctx.remove() list in-place
Patrick Mezard <pmezard@gmail.com>
parents:
12847
diff
changeset
|
1379 removed = list(ctx.removed()) |
8414
2348ce25849b
commitctx: use contexts more fully
Matt Mackall <mpm@selenic.com>
parents:
8412
diff
changeset
|
1380 p1, p2 = ctx.p1(), ctx.p2() |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1381 user = ctx.user() |
990 | 1382 |
8411
4d5916358abd
commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents:
8410
diff
changeset
|
1383 lock = self.lock() |
4d5916358abd
commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents:
8410
diff
changeset
|
1384 try: |
10881
a685011ed38e
localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents:
10877
diff
changeset
|
1385 tr = self.transaction("commit") |
4970
30d4d8985dd8
transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents:
4917
diff
changeset
|
1386 trp = weakref.proxy(tr) |
151 | 1387 |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1388 if ctx.files(): |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1389 m1 = p1.manifest().copy() |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1390 m2 = p2.manifest() |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1391 |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1392 # check in files |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1393 new = {} |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1394 changed = [] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1395 linkrev = len(self) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1396 for f in sorted(ctx.modified() + ctx.added()): |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1397 self.ui.note(f + "\n") |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1398 try: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1399 fctx = ctx[f] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1400 new[f] = self._filecommit(fctx, m1, m2, linkrev, trp, |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1401 changed) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1402 m1.set(f, fctx.flags()) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1403 except OSError, inst: |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1404 self.ui.warn(_("trouble committing %s!\n") % f) |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1405 raise |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1406 except IOError, inst: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1407 errcode = getattr(inst, 'errno', errno.ENOENT) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1408 if error or errcode and errcode != errno.ENOENT: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1409 self.ui.warn(_("trouble committing %s!\n") % f) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1410 raise |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1411 else: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1412 removed.append(f) |
220 | 1413 |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1414 # update manifest |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1415 m1.update(new) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1416 removed = [f for f in sorted(removed) if f in m1 or f in m2] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1417 drop = [f for f in removed if f in m1] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1418 for f in drop: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1419 del m1[f] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1420 mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(), |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1421 p2.manifestnode(), (new, drop)) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1422 files = changed + removed |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1423 else: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1424 mn = p1.manifestnode() |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1425 files = [] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1426 |
8499
fb9b83df45f3
commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents:
8498
diff
changeset
|
1427 # update changelog |
7787
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1428 self.changelog.delayupdate() |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1429 n = self.changelog.add(mn, files, ctx.description(), |
8499
fb9b83df45f3
commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents:
8498
diff
changeset
|
1430 trp, p1.node(), p2.node(), |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1431 user, ctx.date(), ctx.extra().copy()) |
7787
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1432 p = lambda: self.changelog.writepending() and self.root or "" |
10492
0e64d814d7d0
run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents:
10435
diff
changeset
|
1433 xp1, xp2 = p1.hex(), p2 and p2.hex() or '' |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1434 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1, |
7787
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1435 parent2=xp2, pending=p) |
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1436 self.changelog.finalize(trp) |
15706
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1437 # set the new commit is proper phase |
20176
4c96c50ef937
subrepo: check phase of state in each subrepositories before committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20091
diff
changeset
|
1438 targetphase = subrepo.newcommitphase(self.ui, ctx) |
15706
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1439 if targetphase: |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1440 # retract boundary do not alter parent changeset. |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1441 # if a parent have higher the resulting phase will |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1442 # be compliant anyway |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1443 # |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1444 # if minimal phase was 0 we don't need to retract anything |
ebaefd8c6028
Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15659
diff
changeset
|
1445 phases.retractboundary(self, targetphase, [n]) |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1446 tr.close() |
18394
5010448197bc
branchmap: update cache of 'unserved' filter on new changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18382
diff
changeset
|
1447 branchmap.updatecache(self.filtered('served')) |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1448 return n |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1449 finally: |
11230
5116a077c3da
make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
11228
diff
changeset
|
1450 if tr: |
5116a077c3da
make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
11228
diff
changeset
|
1451 tr.release() |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1452 lock.release() |
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
1453 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1454 @unfilteredmethod |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1455 def destroying(self): |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1456 '''Inform the repository that nodes are about to be destroyed. |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1457 Intended for use by strip and rollback, so there's a common |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1458 place for anything that has to be done before destroying history. |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1459 |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1460 This is mostly useful for saving state that is in memory and waiting |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1461 to be flushed when the current lock is released. Because a call to |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1462 destroyed is imminent, the repo will be invalidated causing those |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1463 changes to stay in memory (waiting for the next unlock), or vanish |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1464 completely. |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1465 ''' |
18312
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1466 # When using the same lock to commit and strip, the phasecache is left |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1467 # dirty after committing. Then when we strip, the repo is invalidated, |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1468 # causing those changes to disappear. |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1469 if '_phasecache' in vars(self): |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1470 self._phasecache.write() |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1471 |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1472 @unfilteredmethod |
18395
904b7109938e
destroyed: drop complex branchcache rebuilt logic
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18394
diff
changeset
|
1473 def destroyed(self): |
9150
09a1ee498756
localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9149
diff
changeset
|
1474 '''Inform the repository that nodes have been destroyed. |
09a1ee498756
localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9149
diff
changeset
|
1475 Intended for use by strip and rollback, so there's a common |
17013
c8eda7bbdcab
strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents:
17012
diff
changeset
|
1476 place for anything that has to be done after destroying history. |
c8eda7bbdcab
strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents:
17012
diff
changeset
|
1477 ''' |
18221
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1478 # When one tries to: |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1479 # 1) destroy nodes thus calling this method (e.g. strip) |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1480 # 2) use phasecache somewhere (e.g. commit) |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1481 # |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1482 # then 2) will fail because the phasecache contains nodes that were |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1483 # removed. We can either remove phasecache from the filecache, |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1484 # causing it to reload next time it is accessed, or simply filter |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1485 # the removed nodes now and write the updated cache. |
18757
1c8e0d6ac3b0
localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents:
18739
diff
changeset
|
1486 self._phasecache.filterunknown(self) |
1c8e0d6ac3b0
localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents:
18739
diff
changeset
|
1487 self._phasecache.write() |
18221
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1488 |
18396
dd3fd3353e23
destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18395
diff
changeset
|
1489 # update the 'served' branch cache to help read only server process |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
1490 # Thanks to branchcache collaboration this is done from the nearest |
18396
dd3fd3353e23
destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18395
diff
changeset
|
1491 # filtered subset and it is expected to be fast. |
dd3fd3353e23
destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18395
diff
changeset
|
1492 branchmap.updatecache(self.filtered('served')) |
18223
6d6d0248530b
destroyed: filter unknown before computing branchcache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18222
diff
changeset
|
1493 |
9151
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1494 # Ensure the persistent tag cache is updated. Doing it now |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1495 # means that the tag cache only has to worry about destroyed |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1496 # heads immediately after a strip/rollback. That in turn |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1497 # guarantees that "cachetip == currenttip" (comparing both rev |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1498 # and node) always means no nodes have been added or destroyed. |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1499 |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1500 # XXX this is suboptimal when qrefresh'ing: we strip the current |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1501 # head, refresh the tag cache, then immediately add a new head. |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1502 # But I think doing it this way is necessary for the "instant |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1503 # tag cache retrieval" case to work. |
18313
3e4a944c0d04
destroyed: keep the filecache in sync with __dict__ (issue3335) (issue3693) (issue3743)
Idan Kamara <idankk86@gmail.com>
parents:
18312
diff
changeset
|
1504 self.invalidate() |
17324
9f94358f9f93
localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents:
17306
diff
changeset
|
1505 |
6585 | 1506 def walk(self, match, node=None): |
3532 | 1507 ''' |
1508 walk recursively through the directory tree or a given | |
1509 changeset, finding all files matched by the match | |
1510 function | |
1511 ''' | |
6764 | 1512 return self[node].walk(match) |
3532 | 1513 |
6769 | 1514 def status(self, node1='.', node2=None, match=None, |
12166
441a74b8def1
status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents:
12162
diff
changeset
|
1515 ignored=False, clean=False, unknown=False, |
441a74b8def1
status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents:
12162
diff
changeset
|
1516 listsubrepos=False): |
21596
83bbfb23cb24
localrepo: replace status method with a shim
Sean Farley <sean.michael.farley@gmail.com>
parents:
21591
diff
changeset
|
1517 '''a convenience method that calls node1.status(node2)''' |
83bbfb23cb24
localrepo: replace status method with a shim
Sean Farley <sean.michael.farley@gmail.com>
parents:
21591
diff
changeset
|
1518 return self[node1].status(node2, match, ignored, clean, unknown, |
83bbfb23cb24
localrepo: replace status method with a shim
Sean Farley <sean.michael.farley@gmail.com>
parents:
21591
diff
changeset
|
1519 listsubrepos) |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2621
diff
changeset
|
1520 |
8796
2bcef677a6c3
localrepo: remove 'closed' argument to heads(...) function
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
8731
diff
changeset
|
1521 def heads(self, start=None): |
1550
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
1522 heads = self.changelog.heads(start) |
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
1523 # sort the output in rev descending order |
13075
d73c3034deee
coding style: fix gratuitous whitespace after Python keywords
Thomas Arendsen Hein <thomas@jtah.de>
parents:
13047
diff
changeset
|
1524 return sorted(heads, key=self.changelog.rev, reverse=True) |
222 | 1525 |
8694
ca8d05e1f1d1
localrepo: set heads and branchheads to be closed=False by default
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
8680
diff
changeset
|
1526 def branchheads(self, branch=None, start=None, closed=False): |
9475
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1527 '''return a (possibly filtered) list of heads for the given branch |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1528 |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1529 Heads are returned in topological order, from newest to oldest. |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1530 If branch is None, use the dirstate branch. |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1531 If start is not None, return only heads reachable from start. |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1532 If closed is True, return heads that are marked as closed as well. |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1533 ''' |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
1534 if branch is None: |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
1535 branch = self[None].branch() |
9675
ee913987e4b0
localrepo/branchcache: remove lbranchmap(), convert users to use utf-8 names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
9674
diff
changeset
|
1536 branches = self.branchmap() |
4648
8e503fa54d2d
Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents:
4635
diff
changeset
|
1537 if branch not in branches: |
8e503fa54d2d
Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents:
4635
diff
changeset
|
1538 return [] |
7654
816b708f23af
store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
7644
diff
changeset
|
1539 # the cache returns heads ordered lowest to highest |
20189
1831993d0902
localrepo: refactor repo.branchheads() to use repo.branchmap().branchheads()
Brodie Rao <brodie@sf.io>
parents:
20187
diff
changeset
|
1540 bheads = list(reversed(branches.branchheads(branch, closed=closed))) |
4648
8e503fa54d2d
Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents:
4635
diff
changeset
|
1541 if start is not None: |
7654
816b708f23af
store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
7644
diff
changeset
|
1542 # filter out the heads that cannot be reached from startrev |
9475
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1543 fbheads = set(self.changelog.nodesbetween([start], bheads)[2]) |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1544 bheads = [h for h in bheads if h in fbheads] |
7654
816b708f23af
store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
7644
diff
changeset
|
1545 return bheads |
4648
8e503fa54d2d
Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents:
4635
diff
changeset
|
1546 |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1547 def branches(self, nodes): |
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1548 if not nodes: |
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1549 nodes = [self.changelog.tip()] |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1550 b = [] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1551 for n in nodes: |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1552 t = n |
14494
1ffeeb91c55d
check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents:
14482
diff
changeset
|
1553 while True: |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1554 p = self.changelog.parents(n) |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1555 if p[1] != nullid or p[0] == nullid: |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1556 b.append((t, n, p[0], p[1])) |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1557 break |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1558 n = p[0] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1559 return b |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1560 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1561 def between(self, pairs): |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1562 r = [] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1563 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1564 for top, bottom in pairs: |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1565 n, l, i = top, [], 0 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1566 f = 1 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1567 |
7708
a32847fa0df0
wire protocol: avoid infinite loop (issue1483)
Matt Mackall <mpm@selenic.com>
parents:
7564
diff
changeset
|
1568 while n != bottom and n != nullid: |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1569 p = self.changelog.parents(n)[0] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1570 if i == f: |
575 | 1571 l.append(n) |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1572 f = f * 2 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1573 n = p |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1574 i += 1 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1575 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1576 r.append(l) |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1577 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1578 return r |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1579 |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1580 def pull(self, remote, heads=None, force=False): |
20469
6b4c789d618d
exchange: extract pull function from localrepo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20406
diff
changeset
|
1581 return exchange.pull (self, remote, heads, force) |
13364
ddddb76f2da3
bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents:
13363
diff
changeset
|
1582 |
20924
e10000369b47
push: pass a `pushoperation` object to localrepo.checkpush
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20884
diff
changeset
|
1583 def checkpush(self, pushop): |
13327
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1584 """Extensions can override this function if additional checks have |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1585 to be performed before pushing, or call it if they override push |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1586 command. |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1587 """ |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1588 pass |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1589 |
21043
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1590 @unfilteredpropertycache |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1591 def prepushoutgoinghooks(self): |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1592 """Return util.hooks consists of "(repo, remote, outgoing)" |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1593 functions, which are called before pushing changesets. |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1594 """ |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1595 return util.hooks() |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1596 |
11211
e43c23d189a5
push: add --new-branch option to allow intial push of new branches
Sune Foldager <cryo@cyanite.org>
parents:
11177
diff
changeset
|
1597 def push(self, remote, force=False, revs=None, newbranch=False): |
20345
8567b4ea76ac
exchange: extract push function from localrepo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20332
diff
changeset
|
1598 return exchange.push(self, remote, force, revs, newbranch) |
13364
ddddb76f2da3
bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents:
13363
diff
changeset
|
1599 |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1600 def stream_in(self, remote, requirements): |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1601 lock = self.lock() |
3564
eda9e7c9300d
New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3513
diff
changeset
|
1602 try: |
17740
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1603 # Save remote branchmap. We will use it later |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1604 # to speed up branchcache creation |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1605 rbranchmap = None |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1606 if remote.capable("branchmap"): |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1607 rbranchmap = remote.branchmap() |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1608 |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1609 fp = remote.stream_out() |
3564
eda9e7c9300d
New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3513
diff
changeset
|
1610 l = fp.readline() |
eda9e7c9300d
New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3513
diff
changeset
|
1611 try: |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1612 resp = int(l) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1613 except ValueError: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1614 raise error.ResponseError( |
16941
a1eb17bed550
localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents:
16866
diff
changeset
|
1615 _('unexpected response from remote server:'), l) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1616 if resp == 1: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1617 raise util.Abort(_('operation forbidden by server')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1618 elif resp == 2: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1619 raise util.Abort(_('locking the remote repository failed')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1620 elif resp != 0: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1621 raise util.Abort(_('the server sent an unknown error code')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1622 self.ui.status(_('streaming all changes\n')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1623 l = fp.readline() |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1624 try: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1625 total_files, total_bytes = map(int, l.split(' ', 1)) |
7063
be2daa324ddf
Add missing catch of a TypeError
Bernhard Leiner <bleiner@gmail.com>
parents:
6877
diff
changeset
|
1626 except (ValueError, TypeError): |
7641
d2f753830f80
error: move UnexpectedOutput (now ResponseError)
Matt Mackall <mpm@selenic.com>
parents:
7640
diff
changeset
|
1627 raise error.ResponseError( |
16941
a1eb17bed550
localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents:
16866
diff
changeset
|
1628 _('unexpected response from remote server:'), l) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1629 self.ui.status(_('%d files to transfer, %s of data\n') % |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1630 (total_files, util.bytecount(total_bytes))) |
16770
b3435385f99f
clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents:
16745
diff
changeset
|
1631 handled_bytes = 0 |
b3435385f99f
clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents:
16745
diff
changeset
|
1632 self.ui.progress(_('clone'), 0, total=total_bytes) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1633 start = time.time() |
20880
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1634 |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1635 tr = self.transaction(_('clone')) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1636 try: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1637 for i in xrange(total_files): |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1638 # XXX doesn't support '\n' or '\r' in filenames |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1639 l = fp.readline() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1640 try: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1641 name, size = l.split('\0', 1) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1642 size = int(size) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1643 except (ValueError, TypeError): |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1644 raise error.ResponseError( |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1645 _('unexpected response from remote server:'), l) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1646 if self.ui.debugflag: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1647 self.ui.debug('adding %s (%s)\n' % |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1648 (name, util.bytecount(size))) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1649 # for backwards compat, name was partially encoded |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1650 ofp = self.sopener(store.decodedir(name), 'w') |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1651 for chunk in util.filechunkiter(fp, limit=size): |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1652 handled_bytes += len(chunk) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1653 self.ui.progress(_('clone'), handled_bytes, |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1654 total=total_bytes) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1655 ofp.write(chunk) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1656 ofp.close() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1657 tr.close() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1658 finally: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1659 tr.release() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1660 |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1661 # Writing straight to files circumvented the inmemory caches |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1662 self.invalidate() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1663 |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1664 elapsed = time.time() - start |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1665 if elapsed <= 0: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1666 elapsed = 0.001 |
16770
b3435385f99f
clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents:
16745
diff
changeset
|
1667 self.ui.progress(_('clone'), None) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1668 self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') % |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1669 (util.bytecount(total_bytes), elapsed, |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1670 util.bytecount(total_bytes / elapsed))) |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1671 |
16683 | 1672 # new requirements = old non-format requirements + |
1673 # new format-related | |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1674 # requirements from the streamed-in repository |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1675 requirements.update(set(self.requirements) - self.supportedformats) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1676 self._applyrequirements(requirements) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1677 self._writerequirements() |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1678 |
17740
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1679 if rbranchmap: |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1680 rbheads = [] |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1681 for bheads in rbranchmap.itervalues(): |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1682 rbheads.extend(bheads) |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1683 |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1684 if rbheads: |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1685 rtiprev = max((int(self.changelog.rev(node)) |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1686 for node in rbheads)) |
18125
ad194a8ab5c1
branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18124
diff
changeset
|
1687 cache = branchmap.branchcache(rbranchmap, |
18126
090ada0acddb
branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18125
diff
changeset
|
1688 self[rtiprev].node(), |
090ada0acddb
branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18125
diff
changeset
|
1689 rtiprev) |
18397
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1690 # Try to stick it as low as possible |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1691 # filter above served are unlikely to be fetch from a clone |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1692 for candidate in ('base', 'immutable', 'served'): |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1693 rview = self.filtered(candidate) |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1694 if cache.validfor(rview): |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1695 self._branchcaches[candidate] = cache |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1696 cache.write(rview) |
ecf4f79cc600
stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18396
diff
changeset
|
1697 break |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1698 self.invalidate() |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1699 return len(self.heads()) + 1 |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1700 finally: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1701 lock.release() |
515 | 1702 |
2613
479e26afa10f
clone: do not make streaming default. add --stream option instead.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2612
diff
changeset
|
1703 def clone(self, remote, heads=[], stream=False): |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1704 '''clone remote repository. |
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1705 |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1706 keyword arguments: |
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1707 heads: list of revs to clone (forces use of pull) |
2621
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1708 stream: use streaming clone if possible''' |
247 | 1709 |
2621
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1710 # now, all clients that can request uncompressed clones can |
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1711 # read repo formats supported by all servers that can serve |
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1712 # them. |
247 | 1713 |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1714 # if revlog format changes, client will have to check version |
2621
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1715 # and format flags on "stream" capability, and use |
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1716 # uncompressed only if compatible. |
247 | 1717 |
16361
6097ede2be4d
protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents:
16253
diff
changeset
|
1718 if not stream: |
17427
57c6c24b9bc4
improve some comments and docstrings, fixing issues found when spell checking
Mads Kiilerich <mads@kiilerich.com>
parents:
17424
diff
changeset
|
1719 # if the server explicitly prefers to stream (for fast LANs) |
16361
6097ede2be4d
protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents:
16253
diff
changeset
|
1720 stream = remote.capable('stream-preferred') |
6097ede2be4d
protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents:
16253
diff
changeset
|
1721 |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1722 if stream and not heads: |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1723 # 'stream' means remote revlog format is revlogv1 only |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1724 if remote.capable('stream'): |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1725 return self.stream_in(remote, set(('revlogv1',))) |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1726 # otherwise, 'streamreqs' contains the remote revlog format |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1727 streamreqs = remote.capable('streamreqs') |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1728 if streamreqs: |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1729 streamreqs = set(streamreqs.split(',')) |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1730 # if we support it, stream in and adjust our requirements |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1731 if not streamreqs - self.supportedformats: |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1732 return self.stream_in(remote, streamreqs) |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1733 return self.pull(remote, heads) |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1734 |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1735 def pushkey(self, namespace, key, old, new): |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1736 self.hook('prepushkey', throw=True, namespace=namespace, key=key, |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1737 old=old, new=new) |
17293
d3f84ccc5495
pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17252
diff
changeset
|
1738 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key)) |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1739 ret = pushkey.push(self, namespace, key, old, new) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1740 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new, |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1741 ret=ret) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1742 return ret |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1743 |
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1744 def listkeys(self, namespace): |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1745 self.hook('prelistkeys', throw=True, namespace=namespace) |
17293
d3f84ccc5495
pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17252
diff
changeset
|
1746 self.ui.debug('listing keys for "%s"\n' % namespace) |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1747 values = pushkey.list(self, namespace) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1748 self.hook('listkeys', namespace=namespace, values=values) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1749 return values |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1750 |
14048
58e58406ed19
wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14036
diff
changeset
|
1751 def debugwireargs(self, one, two, three=None, four=None, five=None): |
13720
9c4e04fe267e
debug: add debugwireargs to test argument passing over the wire
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13716
diff
changeset
|
1752 '''used to test argument passing over the wire''' |
14048
58e58406ed19
wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14036
diff
changeset
|
1753 return "%s %s %s %s %s" % (one, two, three, four, five) |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1754 |
14529
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1755 def savecommitmessage(self, text): |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1756 fp = self.opener('last-message.txt', 'wb') |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1757 try: |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1758 fp.write(text) |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1759 finally: |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1760 fp.close() |
18054
b35e3364f94a
check-code: there must also be whitespace between ')' and operator
Mads Kiilerich <madski@unity3d.com>
parents:
18044
diff
changeset
|
1761 return self.pathto(fp.name[len(self.root) + 1:]) |
14529
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1762 |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1763 # used to avoid circular references so destructors work |
3790
f183c18568df
localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3773
diff
changeset
|
1764 def aftertrans(files): |
f183c18568df
localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3773
diff
changeset
|
1765 renamefiles = [tuple(t) for t in files] |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1766 def a(): |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
1767 for vfs, src, dest in renamefiles: |
16441
9dd10a574af2
localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents:
16426
diff
changeset
|
1768 try: |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
1769 vfs.rename(src, dest) |
16441
9dd10a574af2
localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents:
16426
diff
changeset
|
1770 except OSError: # journal file does not yet exist |
9dd10a574af2
localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents:
16426
diff
changeset
|
1771 pass |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1772 return a |
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1773 |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1774 def undoname(fn): |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1775 base, name = os.path.split(fn) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1776 assert name.startswith('journal') |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1777 return os.path.join(base, name.replace('journal', 'undo', 1)) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1778 |
2740
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
1779 def instance(ui, path, create): |
14825
de9eb6b1da4f
util: rename the util.localpath that uses url to urllocalpath (issue2875)
Mads Kiilerich <mads@kiilerich.com>
parents:
14756
diff
changeset
|
1780 return localrepository(ui, util.urllocalpath(path), create) |
3223
53e843840349
Whitespace/Tab cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3164
diff
changeset
|
1781 |
2740
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
1782 def islocal(path): |
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
1783 return True |