Mercurial > hg
annotate mercurial/localrepo.py @ 21811:789b69d597cc
dirstate.status: assign members one by one instead of unpacking the tuple
With this patch, hg status and hg diff regain their previous speed.
The following tests are run against a working copy with over 270,000 files.
Here, 'before' means without this or the previous patch applied.
Note that in this case `hg perfstatus` isn't representative since it doesn't
take dirstate parsing time into account.
$ time hg status # best of 5
before: 2.03s user 1.25s system 99% cpu 3.290 total
after: 2.01s user 1.25s system 99% cpu 3.261 total
$ time hg diff # best of 5
before: 1.32s user 0.78s system 99% cpu 2.105 total
after: 1.27s user 0.79s system 99% cpu 2.066 total
author | Siddharth Agarwal <sid0@fb.com> |
---|---|
date | Tue, 27 May 2014 21:02:16 -0700 |
parents | 99db956b88ab |
children | a2ca9dcb4b77 |
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': (), |
e87d2a12d41b
bundle2: add ``pushkey`` support
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21657
diff
changeset
|
185 'b2x:pushkey': ()} |
21140
4aeb8da68090
bundle2: add bundle2caps dict on localrepo object
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21106
diff
changeset
|
186 |
19928
d1ac3790e10a
localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19884
diff
changeset
|
187 # 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
|
188 # 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
|
189 featuresetupfuncs = set() |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
190 |
17137
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
191 def _baserequirements(self, create): |
b090601a80d1
localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents:
17075
diff
changeset
|
192 return self.requirements[:] |
2439
e8c4f3d3df8c
extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2424
diff
changeset
|
193 |
14363
82f3b0f3f0a5
localrepo, sshrepo: use Boolean create argument in __init__
Martin Geisler <mg@lazybytes.net>
parents:
14333
diff
changeset
|
194 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
|
195 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
|
196 self.wopener = self.wvfs |
17157
87e8440964a0
localrepo: use path expansion API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17156
diff
changeset
|
197 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
|
198 self.path = self.wvfs.join(".hg") |
3850
a4457828ca1a
move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3803
diff
changeset
|
199 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
|
200 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
|
201 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
|
202 self.opener = self.vfs |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
203 self.baseui = baseui |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
204 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
|
205 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
|
206 # 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
|
207 # 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
|
208 # 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
|
209 self._phasedefaults = [] |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
210 try: |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
211 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
|
212 extensions.loadall(self.ui) |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
213 except IOError: |
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
214 pass |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
215 |
19778
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
216 if self.featuresetupfuncs: |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
217 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
|
218 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
|
219 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
|
220 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
|
221 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
|
222 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
|
223 else: |
55ef79031009
localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19650
diff
changeset
|
224 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
|
225 |
17161
be016e96117a
localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17160
diff
changeset
|
226 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
|
227 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
|
228 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
|
229 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
|
230 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
|
231 requirements = self._baserequirements(create) |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
232 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
|
233 self.vfs.mkdir("store") |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
234 requirements.append("store") |
8797
9ed150d2fbd5
repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents:
8796
diff
changeset
|
235 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
|
236 requirements.append("fncache") |
12687
34d8247a4595
store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents:
12622
diff
changeset
|
237 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
|
238 requirements.append('dotencode') |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
239 # 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
|
240 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
|
241 "00changelog.i", |
4166
c0271aba6abe
small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4163
diff
changeset
|
242 '\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
|
243 ' 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
|
244 ) |
14270
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14232
diff
changeset
|
245 if self.ui.configbool('format', 'generaldelta', False): |
d6907a5674a2
revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents:
14232
diff
changeset
|
246 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
|
247 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
|
248 else: |
7637 | 249 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
|
250 elif create: |
7637 | 251 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
|
252 else: |
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
253 try: |
17160
22b9b1d2f5d4
localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17159
diff
changeset
|
254 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
|
255 except IOError, inst: |
8f18e31c4441
add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3850
diff
changeset
|
256 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
|
257 raise |
14482
58b36e9ea783
introduce new function scmutil.readrequires
Adrian Buehlmann <adrian@cadifra.com>
parents:
14434
diff
changeset
|
258 requirements = set() |
405 | 259 |
8799
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
260 self.sharedpath = self.path |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
261 try: |
18946
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
262 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
|
263 realpath=True) |
3d4f41eaae67
localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18945
diff
changeset
|
264 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
|
265 if not vfs.exists(): |
8799
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
266 raise error.RepoError( |
8908
105343f9f744
Fix warning: Seen unexpected token "%"
Dongsheng Song <dongsheng.song@gmail.com>
parents:
8813
diff
changeset
|
267 _('.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
|
268 self.sharedpath = s |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
269 except IOError, inst: |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
270 if inst.errno != errno.ENOENT: |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
271 raise |
87d1fd40f57e
repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents:
8797
diff
changeset
|
272 |
17654
1dc37491e9fb
localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17650
diff
changeset
|
273 self.store = store.store(requirements, self.sharedpath, scmutil.vfs) |
6840
80e51429cb9a
introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents:
6839
diff
changeset
|
274 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
|
275 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
|
276 self.sopener = self.svfs |
6840
80e51429cb9a
introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents:
6839
diff
changeset
|
277 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
|
278 self.vfs.createmode = self.store.createmode |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
279 self._applyrequirements(requirements) |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
280 if create: |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
281 self._writerequirements() |
3850
a4457828ca1a
move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
3803
diff
changeset
|
282 |
9146
5614a628d173
localrepo: rename in-memory tag cache instance attributes (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9145
diff
changeset
|
283 |
18189
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
284 self._branchcaches = {} |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
285 self.filterpats = {} |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
286 self._datafilters = {} |
4916
5c5d23d93447
Use a weakref for recursive transactions
Matt Mackall <mpm@selenic.com>
parents:
4915
diff
changeset
|
287 self._transref = self._lockref = self._wlockref = None |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
288 |
14929
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
289 # 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
|
290 # (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
|
291 # |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
292 # 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
|
293 self._filecache = {} |
4bf9493e7b07
localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents:
14905
diff
changeset
|
294 |
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
|
295 # 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
|
296 # 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
|
297 # - 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
|
298 # - 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
|
299 # - 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
|
300 # - 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
|
301 # - 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
|
302 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
|
303 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
304 def close(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
305 pass |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
306 |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
307 def _restrictcapabilities(self, caps): |
20955
12f161f08d74
bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20954
diff
changeset
|
308 # 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
|
309 # 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
|
310 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
|
311 caps = set(caps) |
21141
d8dd19e09ed4
bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21140
diff
changeset
|
312 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
|
313 caps.add('bundle2-exp=' + urllib.quote(capsblob)) |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
314 return caps |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
315 |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
316 def _applyrequirements(self, requirements): |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
317 self.requirements = requirements |
14333
31a5973fcf96
revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents:
14274
diff
changeset
|
318 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
|
319 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
|
320 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
|
321 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
|
322 self.sopener.options['chunkcachesize'] = chunkcachesize |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
323 |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
324 def _writerequirements(self): |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
325 reqfile = self.opener("requires", "w") |
18356
752f77ef7202
localrepo: store requirements sorted
Mads Kiilerich <mads@kiilerich.com>
parents:
18318
diff
changeset
|
326 for r in sorted(self.requirements): |
12295
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
327 reqfile.write("%s\n" % r) |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
328 reqfile.close() |
3388ab21d768
localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents:
12176
diff
changeset
|
329 |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
330 def _checknested(self, path): |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
331 """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
|
332 if not path.startswith(self.root): |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
333 return False |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
334 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
|
335 normsubpath = util.pconvert(subpath) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
336 |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
337 # 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
|
338 # 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
|
339 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
340 # $ 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
|
341 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
342 # 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
|
343 # parent revision. |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
344 # |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
345 # 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
|
346 # 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
|
347 # 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
|
348 # 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
|
349 # panics when it sees sub/.hg/. |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
350 # |
12174
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
351 # 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
|
352 # 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
|
353 # the filesystem *now*. |
7bccd04292a2
localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents:
12166
diff
changeset
|
354 ctx = self[None] |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
355 parts = util.splitpath(subpath) |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
356 while parts: |
15722
417127af3996
windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15604
diff
changeset
|
357 prefix = '/'.join(parts) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
358 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
|
359 if prefix == normsubpath: |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
360 return True |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
361 else: |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
362 sub = ctx.sub(prefix) |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
363 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
|
364 else: |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
365 parts.pop() |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
366 return False |
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
367 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
368 def peer(self): |
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
369 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
|
370 |
17993
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
371 def unfiltered(self): |
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
372 """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
|
373 |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
374 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
|
375 return self |
1a6f8820eb71
clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
376 |
18100
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
377 def filtered(self, name): |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
378 """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
|
379 # 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
|
380 # (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
|
381 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
|
382 pass |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
383 return proxycls(self, name) |
3a6ddacb7198
clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18092
diff
changeset
|
384 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
385 @repofilecache('bookmarks') |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
386 def _bookmarks(self): |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17857
diff
changeset
|
387 return bookmarks.bmstore(self) |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
388 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
389 @repofilecache('bookmarks.current') |
13355
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
390 def _bookmarkcurrent(self): |
cce2e7b77e36
bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents:
13341
diff
changeset
|
391 return bookmarks.readcurrent(self) |
12162
af8c4929931c
localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12127
diff
changeset
|
392 |
16707
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
393 def bookmarkheads(self, bookmark): |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
394 name = bookmark.split('@', 1)[0] |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
395 heads = [] |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
396 for mark, n in self._bookmarks.iteritems(): |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
397 if mark.split('@', 1)[0] == name: |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
398 heads.append(n) |
f8dee1a8f844
localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents:
16706
diff
changeset
|
399 return heads |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15403
diff
changeset
|
400 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
401 @storecache('phaseroots') |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
402 def _phasecache(self): |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
403 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
|
404 |
17070
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
405 @storecache('obsstore') |
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
406 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
|
407 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
|
408 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
|
409 # 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
|
410 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
|
411 self.ui.warn(msg % len(list(store))) |
17070
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
412 return store |
ad0d6c2b3279
obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents:
17013
diff
changeset
|
413 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
414 @storecache('00changelog.i') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
415 def changelog(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
416 c = changelog.changelog(self.sopener) |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
417 if 'HG_PENDING' in os.environ: |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
418 p = os.environ['HG_PENDING'] |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
419 if p.startswith(self.root): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
420 c.readpending('00changelog.i.a') |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
421 return c |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
422 |
16198
fa8488565afd
filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents:
16144
diff
changeset
|
423 @storecache('00manifest.i') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
424 def manifest(self): |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
425 return manifest.manifest(self.sopener) |
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
426 |
18014
a39fe76c4c65
clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18013
diff
changeset
|
427 @repofilecache('dirstate') |
8260
54a4b520bd7d
localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8244
diff
changeset
|
428 def dirstate(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
429 warned = [0] |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
430 def validate(node): |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
431 try: |
14064
e4bfb9c337f3
remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents:
14056
diff
changeset
|
432 self.changelog.rev(node) |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
433 return node |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
434 except error.LookupError: |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
435 if not warned[0]: |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
436 warned[0] = True |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
437 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
|
438 " 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
|
439 return nullid |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
440 |
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
13001
diff
changeset
|
441 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
|
442 |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
443 def __getitem__(self, changeid): |
8527
f9a80054dd3c
use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents:
8515
diff
changeset
|
444 if changeid is None: |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
445 return context.workingctx(self) |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
446 return context.changectx(self, changeid) |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
447 |
9924
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
448 def __contains__(self, changeid): |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
449 try: |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
450 return bool(self.lookup(changeid)) |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
451 except error.RepoLookupError: |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
452 return False |
ea3acaae25bb
localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents:
9820
diff
changeset
|
453 |
6750
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
454 def __nonzero__(self): |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
455 return True |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
456 |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
457 def __len__(self): |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
458 return len(self.changelog) |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
459 |
fb42030d79d6
add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents:
6747
diff
changeset
|
460 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
|
461 return iter(self.changelog) |
2155
ff255b41b4aa
support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2150
diff
changeset
|
462 |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
463 def revs(self, expr, *args): |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
464 '''Return a list of revisions matching the given revset''' |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
465 expr = revset.formatspec(expr, *args) |
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
466 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
|
467 return m(self, revset.spanset(self)) |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
468 |
14902
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
469 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
|
470 ''' |
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
471 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
|
472 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
|
473 ''' |
15403
e27561eb4a76
localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents:
15381
diff
changeset
|
474 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
|
475 yield self[r] |
96a72cbc6c29
localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents:
14870
diff
changeset
|
476 |
2673
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
477 def url(self): |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
478 return 'file:' + self.root |
109a22f5434a
hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2661
diff
changeset
|
479 |
1718
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
480 def hook(self, name, throw=False, **args): |
4622
fff50306e6dd
hooks: separate hook code into a separate module
Matt Mackall <mpm@selenic.com>
parents:
4619
diff
changeset
|
481 return hook.hook(self.ui, self, name, throw, **args) |
487 | 482 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
483 @unfilteredmethod |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
484 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
|
485 editor=False): |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
486 if isinstance(names, str): |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
487 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
|
488 |
11063
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
489 branches = self.branchmap() |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
490 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
491 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
|
492 local=local) |
11063
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
493 if name in branches: |
eb23c876c111
tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11047
diff
changeset
|
494 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
|
495 " 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
|
496 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
497 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
|
498 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
|
499 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
|
500 fp.write('\n') |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
501 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
|
502 m = munge and munge(name) or name |
16683 | 503 if (self._tagscache.tagtypes and |
504 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
|
505 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
|
506 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
|
507 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
|
508 fp.close() |
5081
ea7b982b6c08
Remove trailing spaces
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4932
diff
changeset
|
509 |
4932
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
510 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
|
511 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
|
512 try: |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
513 fp = self.opener('localtags', 'r+') |
7875
553aa0cbeab6
cleanup: drop unused assignments
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
7848
diff
changeset
|
514 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
|
515 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
|
516 else: |
f0c25ed40ec6
tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents:
4929
diff
changeset
|
517 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
|
518 |
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 # 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
|
520 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
|
521 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
522 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
|
523 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
|
524 |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
525 try: |
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
526 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
|
527 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
|
528 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
|
529 raise |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
530 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
|
531 else: |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
532 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
|
533 |
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
|
534 # 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
|
535 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
|
536 |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13391
diff
changeset
|
537 fp.close() |
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13391
diff
changeset
|
538 |
15929
4091660dc130
tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents:
15922
diff
changeset
|
539 self.invalidatecaches() |
4091660dc130
tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents:
15922
diff
changeset
|
540 |
8402
0ad521500424
tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents:
8401
diff
changeset
|
541 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
|
542 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
|
543 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
544 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
|
545 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
|
546 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
|
547 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
548 for name in names: |
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
549 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
|
550 |
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 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
|
552 |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
553 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
|
554 '''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
|
555 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
556 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
|
557 string. |
6334
7016f7fb8fe3
tab/space cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents:
6321
diff
changeset
|
558 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
559 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
|
560 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
|
561 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
|
562 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
563 keyword arguments: |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
564 |
6321
55ba3bc5b8fd
tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents:
6312
diff
changeset
|
565 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
|
566 (default False) |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
567 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
568 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
|
569 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
570 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
|
571 |
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
572 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
|
573 |
13133
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
574 if not local: |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
575 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
|
576 if '.hgtags' in x: |
c1492615cdee
tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents:
13000
diff
changeset
|
577 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
|
578 '(please commit .hgtags manually)')) |
2601
00fc88b0b256
move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2581
diff
changeset
|
579 |
7814
4421abf8c85d
tag: force load of tag cache
Matt Mackall <mpm@selenic.com>
parents:
7803
diff
changeset
|
580 self.tags() # instantiate the cache |
21237
0054a77f49df
localrepo: add "editor" argument to "tag()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21186
diff
changeset
|
581 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
|
582 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
583 @filteredpropertycache |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
584 def _tagscache(self): |
16683 | 585 '''Returns a tagscache object that contains various tags related |
586 caches.''' | |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
587 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
588 # 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
|
589 # 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
|
590 class tagscache(object): |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
591 def __init__(self): |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
592 # 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
|
593 # 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
|
594 # '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
|
595 # 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
|
596 # 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
|
597 self.tags = self.tagtypes = None |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
598 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
599 self.nodetagscache = self.tagslist = None |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
600 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
601 cache = tagscache() |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
602 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
|
603 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
604 return cache |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
605 |
343 | 606 def tags(self): |
607 '''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
|
608 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
|
609 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
|
610 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
|
611 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
|
612 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
|
613 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
|
614 try: |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
615 # ignore tags to unknown nodes |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
616 self.changelog.rev(v) |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
617 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
|
618 except (error.LookupError, ValueError): |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
619 pass |
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
620 return t |
4210
caff92047e87
Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents:
4178
diff
changeset
|
621 |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
622 def _findtags(self): |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
623 '''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
|
624 (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
|
625 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
|
626 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
|
627 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
|
628 duration of the localrepo object.''' |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
629 |
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
630 # 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
|
631 # 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
|
632 # 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
|
633 # 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
|
634 # quo fine? |
4210
caff92047e87
Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents:
4178
diff
changeset
|
635 |
9148
b7837f0ed9fe
localrepo: factor updatetags() out of readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9147
diff
changeset
|
636 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
|
637 tagtypes = {} |
659 | 638 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
639 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
|
640 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
|
641 |
9152
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
642 # 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
|
643 # 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
|
644 # 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
|
645 # local encoding. |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
646 tags = {} |
9147
234a230cc33b
localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9146
diff
changeset
|
647 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
|
648 if node != nullid: |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
649 tags[encoding.tolocal(name)] = node |
9145
6b03f93b8ff3
localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9134
diff
changeset
|
650 tags['tip'] = self.changelog.tip() |
9152
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
651 tagtypes = dict([(encoding.tolocal(name), value) |
4017291c4c48
tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents:
9151
diff
changeset
|
652 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
|
653 return (tags, tagtypes) |
343 | 654 |
5657
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
655 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
|
656 ''' |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
657 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
|
658 |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
659 '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
|
660 '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
|
661 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
|
662 ''' |
47915bf68c44
Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents:
5637
diff
changeset
|
663 |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
664 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
|
665 |
343 | 666 def tagslist(self): |
667 '''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
|
668 if not self._tagscache.tagslist: |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
669 l = [] |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
670 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
|
671 r = self.changelog.rev(n) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
672 l.append((r, t, n)) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
673 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
|
674 |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
675 return self._tagscache.tagslist |
343 | 676 |
677 def nodetags(self, node): | |
678 '''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
|
679 if not self._tagscache.nodetagscache: |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
680 nodetagscache = {} |
16371
4417eb761ba8
tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents:
16361
diff
changeset
|
681 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
|
682 nodetagscache.setdefault(n, []).append(t) |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
683 for tags in nodetagscache.itervalues(): |
11047
c7dbd6c4877a
tags: return tags in sorted order
Eric Eisner <ede@mit.edu>
parents:
10970
diff
changeset
|
684 tags.sort() |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
685 self._tagscache.nodetagscache = nodetagscache |
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
686 return self._tagscache.nodetagscache.get(node, []) |
343 | 687 |
13384
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
688 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
|
689 marks = [] |
caa561759538
context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents:
13365
diff
changeset
|
690 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
|
691 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
|
692 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
|
693 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
|
694 |
12066
d01e28657429
localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents:
12035
diff
changeset
|
695 def branchmap(self): |
20245
4edd179fefb8
help: branch names primarily denote the tipmost unclosed branch head
Mads Kiilerich <madski@unity3d.com>
parents:
20226
diff
changeset
|
696 '''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
|
697 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
|
698 branchmap.updatecache(self) |
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
699 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
|
700 |
16719
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
701 def branchtip(self, branch): |
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
702 '''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
|
703 try: |
4d6d5ef88538
localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents:
20184
diff
changeset
|
704 return self.branchmap().branchtip(branch) |
4d6d5ef88538
localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents:
20184
diff
changeset
|
705 except KeyError: |
16719
e7bf09acd410
localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents:
16716
diff
changeset
|
706 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
|
707 |
343 | 708 def lookup(self, key): |
16378
c463f46fe050
localrepo: lookup now goes through context
Matt Mackall <mpm@selenic.com>
parents:
16371
diff
changeset
|
709 return self[key].node() |
67 | 710 |
10960
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
711 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
|
712 repo = remote or self |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
713 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
|
714 return key |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
715 |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
716 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
|
717 return repo[key].branch() |
ca739acf1a98
commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents:
10926
diff
changeset
|
718 |
13723
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
719 def known(self, nodes): |
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
720 nm = self.changelog.nodemap |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
721 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
|
722 result = [] |
816209eaf963
phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15888
diff
changeset
|
723 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
|
724 r = nm.get(n) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
725 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
|
726 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
|
727 return result |
13723
e615765fdcc7
wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
13720
diff
changeset
|
728 |
926 | 729 def local(self): |
14603
68a43fdd7d80
localrepo: local() returns self
Matt Mackall <mpm@selenic.com>
parents:
14549
diff
changeset
|
730 return self |
926 | 731 |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
732 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
|
733 # 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
|
734 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
|
735 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
|
736 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
|
737 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
|
738 # 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
|
739 return not self.filtered('visible').changelog.filteredrevs |
17192
1ac628cd7113
peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
17183
diff
changeset
|
740 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
741 def join(self, f): |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
742 return os.path.join(self.path, f) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
743 |
244 | 744 def wjoin(self, f): |
745 return os.path.join(self.root, f) | |
746 | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
747 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
|
748 if f[0] == '/': |
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
749 f = f[1:] |
4258
b11a2fb59cf5
revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents:
4232
diff
changeset
|
750 return filelog.filelog(self.sopener, f) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
751 |
6739
c9fbd6ec3489
context: avoid using None for working parent
Matt Mackall <mpm@selenic.com>
parents:
6736
diff
changeset
|
752 def changectx(self, changeid): |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
753 return self[changeid] |
3218
8d4855fd9d7b
merge: use new working context object in update
Matt Mackall <mpm@selenic.com>
parents:
3164
diff
changeset
|
754 |
3163
1605e336d229
Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents:
3132
diff
changeset
|
755 def parents(self, changeid=None): |
6742
2d54e7c1e69d
context: clean up parents()
Matt Mackall <mpm@selenic.com>
parents:
6740
diff
changeset
|
756 '''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
|
757 return self[changeid].parents() |
3163
1605e336d229
Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents:
3132
diff
changeset
|
758 |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
759 def setparents(self, p1, p2=nullid): |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
760 copies = self.dirstate.setparents(p1, p2) |
18739
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
761 pctx = self[p1] |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
762 if copies: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
763 # 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
|
764 # 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
|
765 # 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
|
766 for f in copies: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
767 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
|
768 self.dirstate.copy(copies[f], f) |
18739
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
769 if p2 == nullid: |
5b7175377bab
setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents:
18520
diff
changeset
|
770 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
|
771 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
|
772 self.dirstate.copy(None, f) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16536
diff
changeset
|
773 |
2564
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
774 def filectx(self, path, changeid=None, fileid=None): |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
775 """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
|
776 fileid can be a file revision or node.""" |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
777 return context.filectx(self, path, changeid, fileid) |
55e592041076
Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents:
2491
diff
changeset
|
778 |
627 | 779 def getcwd(self): |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
780 return self.dirstate.getcwd() |
627 | 781 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4516
diff
changeset
|
782 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
|
783 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
|
784 |
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
785 def wfile(self, f, mode='r'): |
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
786 return self.wopener(f, mode) |
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
787 |
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
|
788 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
|
789 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
|
790 |
11698
9df481f8036d
localrepo: refactor filter computation
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11669
diff
changeset
|
791 def _loadfilter(self, filter): |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
792 if filter not in self.filterpats: |
1258 | 793 l = [] |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
794 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
|
795 if cmd == '!': |
b71a52f101dc
Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents:
7208
diff
changeset
|
796 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
|
797 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
|
798 fn = None |
6066
f3a8b5360100
Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents:
6065
diff
changeset
|
799 params = cmd |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
800 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
|
801 if cmd.startswith(name): |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
802 fn = filterfn |
6066
f3a8b5360100
Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents:
6065
diff
changeset
|
803 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
|
804 break |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
805 if not fn: |
5967
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
806 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
|
807 # 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
|
808 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
|
809 oldfn = fn |
f8ad3b76e923
Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents:
5966
diff
changeset
|
810 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
|
811 l.append((mf, fn, params)) |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
812 self.filterpats[filter] = l |
12706
9ca08fbb750a
localrepo: have _loadfilter return the loaded filter patterns
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12687
diff
changeset
|
813 return self.filterpats[filter] |
1258 | 814 |
12707
2216ab103ea8
localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12706
diff
changeset
|
815 def _filter(self, filterpats, filename, data): |
2216ab103ea8
localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12706
diff
changeset
|
816 for mf, fn, cmd in filterpats: |
1258 | 817 if mf(filename): |
9467
4c041f1ee1b4
do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents:
9437
diff
changeset
|
818 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
|
819 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename) |
1258 | 820 break |
821 | |
822 return data | |
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
823 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
824 @unfilteredpropertycache |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
825 def _encodefilterpats(self): |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
826 return self._loadfilter('encode') |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
827 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
828 @unfilteredpropertycache |
12708
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
829 def _decodefilterpats(self): |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
830 return self._loadfilter('decode') |
8a08b12ae88e
localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
12707
diff
changeset
|
831 |
5966
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
832 def adddatafilter(self, name, filter): |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
833 self._datafilters[name] = filter |
11af38a592ae
Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents:
5915
diff
changeset
|
834 |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
835 def wread(self, filename): |
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
836 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
|
837 data = self.wvfs.readlink(filename) |
4004
c83c35f2f4e2
unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents:
4003
diff
changeset
|
838 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
|
839 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
|
840 return self._filter(self._encodefilterpats, filename, data) |
1258 | 841 |
4006
67982d3ee76c
symlinks: add flags param to wwrite
Matt Mackall <mpm@selenic.com>
parents:
4005
diff
changeset
|
842 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
|
843 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
|
844 if 'l' in flags: |
1d38f3605b20
util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents:
6875
diff
changeset
|
845 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
|
846 else: |
14184
4ab6e2d597cc
fix errors reported by pyflakes test
Sune Foldager <cryo@cyanite.org>
parents:
14168
diff
changeset
|
847 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
|
848 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
|
849 self.wvfs.setflags(filename, False, True) |
1258 | 850 |
4005
656e06eebda7
replace filehandle version of wwrite with wwritedata
Matt Mackall <mpm@selenic.com>
parents:
4004
diff
changeset
|
851 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
|
852 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
|
853 |
19853
eddc2a2d57e6
localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents:
19852
diff
changeset
|
854 def transaction(self, desc, report=None): |
8072
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
855 tr = self._transref and self._transref() or None |
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
856 if tr and tr.running(): |
ecf7795479d5
transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents:
7948
diff
changeset
|
857 return tr.nest() |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
858 |
5865
e7127f669edb
transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents:
5814
diff
changeset
|
859 # 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
|
860 if self.svfs.exists("journal"): |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
861 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
|
862 _("abandoned transaction found"), |
3b4c75690206
journal: set Abort hint when failing due to an abandoned transaction
Johan Bjork <jbjoerk@gmail.com>
parents:
21237
diff
changeset
|
863 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
|
864 |
20883
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
865 def onclose(): |
21698
99ba1d082287
localrepo: prevent leak of transaction object (issue4258)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
21186
diff
changeset
|
866 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
|
867 |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
868 self._writejournal(desc) |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
869 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
|
870 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
|
871 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
|
872 "journal", |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
873 aftertrans(renames), |
20883
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
874 self.store.createmode, |
cd443c7589cc
fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents:
20880
diff
changeset
|
875 onclose) |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
876 self._transref = weakref.ref(tr) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
877 return tr |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
878 |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
879 def _journalfiles(self): |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
880 return ((self.svfs, 'journal'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
881 (self.vfs, 'journal.dirstate'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
882 (self.vfs, 'journal.branch'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
883 (self.vfs, 'journal.desc'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
884 (self.vfs, 'journal.bookmarks'), |
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
885 (self.svfs, 'journal.phaseroots')) |
16236
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
886 |
97efd26eb957
localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents:
16208
diff
changeset
|
887 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
|
888 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
|
889 |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
890 def _writejournal(self, desc): |
16456
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
891 self.opener.write("journal.dirstate", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
892 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
|
893 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
|
894 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
|
895 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
|
896 "%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
|
897 self.opener.write("journal.bookmarks", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
898 self.opener.tryread("bookmarks")) |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
899 self.sopener.write("journal.phaseroots", |
42862d64aa8f
journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents:
16441
diff
changeset
|
900 self.sopener.tryread("phaseroots")) |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
901 |
210 | 902 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
|
903 lock = self.lock() |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
904 try: |
18947
9b82f93e3a7a
localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18946
diff
changeset
|
905 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
|
906 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
|
907 transaction.rollback(self.sopener, "journal", |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
908 self.ui.warn) |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
909 self.invalidate() |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
910 return True |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
911 else: |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
912 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
|
913 return False |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
914 finally: |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
915 lock.release() |
210 | 916 |
15183
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
917 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
|
918 wlock = lock = None |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
919 try: |
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
920 wlock = self.wlock() |
4438
3900f684a150
Fix hg import --exact bug that hangs hg on failure.
Eric Hopper <hopper@omnifarious.org>
parents:
4417
diff
changeset
|
921 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
|
922 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
|
923 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
|
924 else: |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
925 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
|
926 return 1 |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
927 finally: |
8109
496ae1ea4698
switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8108
diff
changeset
|
928 release(lock, wlock) |
162 | 929 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
930 @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
|
931 def _rollback(self, dryrun, force): |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
932 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
|
933 try: |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
934 args = self.opener.read('undo.desc').splitlines() |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
935 (oldlen, desc, detail) = (int(args[0]), args[1], None) |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
936 if len(args) >= 3: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
937 detail = args[2] |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
938 oldtip = oldlen - 1 |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
939 |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
940 if detail and ui.verbose: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
941 msg = (_('repository tip rolled back to revision %s' |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
942 ' (undo %s: %s)\n') |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
943 % (oldtip, desc, detail)) |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
944 else: |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
945 msg = (_('repository tip rolled back to revision %s' |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
946 ' (undo %s)\n') |
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
947 % (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
|
948 except IOError: |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
949 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
|
950 desc = None |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
951 |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
952 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
|
953 raise util.Abort( |
59e8bc22506e
rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents:
15131
diff
changeset
|
954 _('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
|
955 '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
|
956 |
15130
3d44e68360a6
rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents:
15101
diff
changeset
|
957 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
|
958 if dryrun: |
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
959 return 0 |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
960 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
961 parents = self.dirstate.parents() |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
962 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
|
963 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
|
964 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
|
965 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
|
966 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
|
967 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
|
968 self.invalidate() |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
969 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
970 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
|
971 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
|
972 if parentgone: |
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.dirstate', 'dirstate') |
15131
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
974 try: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
975 branch = self.opener.read('undo.branch') |
17360
935831597e16
rollback: write dirstate branch with correct encoding
Sune Foldager <cryo@cyanite.org>
parents:
17324
diff
changeset
|
976 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
|
977 except IOError: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
978 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
|
979 'current branch is still \'%s\'\n') |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
980 % self.dirstate.branch()) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
981 |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
982 self.dirstate.invalidate() |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
983 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
|
984 if len(parents) > 1: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
985 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
|
986 'revisions %d and %d\n') % parents) |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
987 else: |
7c26ce9edbd2
rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents:
15130
diff
changeset
|
988 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
|
989 '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
|
990 # 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
|
991 # 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
|
992 # invalidated. |
15604
b8d8599410da
rollback: always call destroyed() (regression from 1.9)
Greg Ward <greg-hg@gerg.ca>
parents:
15381
diff
changeset
|
993 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
|
994 return 0 |
cda7a87c1871
rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents:
15057
diff
changeset
|
995 |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
996 def invalidatecaches(self): |
15988
827e0126738d
localrepo: delete _phaserev when invalidating caches
Idan Kamara <idankk86@gmail.com>
parents:
15987
diff
changeset
|
997 |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
998 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
|
999 # 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
|
1000 del self.__dict__['_tagscache'] |
14936
9dca7653b525
localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents:
14935
diff
changeset
|
1001 |
18189
b9026ba002f6
branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18186
diff
changeset
|
1002 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
|
1003 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
|
1004 |
312262ebc223
cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18101
diff
changeset
|
1005 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
|
1006 self.filteredrevcache.clear() |
17469
fb72eec7efd8
obsolete: introduce caches for all meaningful sets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17434
diff
changeset
|
1007 obsolete.clearobscaches(self) |
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
1008 |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1009 def invalidatedirstate(self): |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1010 '''Invalidates the dirstate, causing the next call to dirstate |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1011 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
|
1012 rereading it if it has. |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1013 |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1014 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
|
1015 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
|
1016 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
|
1017 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
|
1018 if hasunfilteredcache(self, 'dirstate'): |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1019 for k in self.dirstate._filecache: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1020 try: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1021 delattr(self.dirstate, k) |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1022 except AttributeError: |
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16198
diff
changeset
|
1023 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
|
1024 delattr(self.unfiltered(), 'dirstate') |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1025 |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1026 def invalidate(self): |
18644
3e92772d5383
spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents:
18520
diff
changeset
|
1027 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
|
1028 for k in self._filecache: |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1029 # dirstate is invalidated separately in invalidatedirstate() |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1030 if k == 'dirstate': |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1031 continue |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1032 |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1033 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
|
1034 delattr(unfiltered, k) |
14935
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1035 except AttributeError: |
4ae7473f5b73
localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents:
14934
diff
changeset
|
1036 pass |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1037 self.invalidatecaches() |
20884
2efdd186925d
caches: invalidate store caches when lock is taken
Durham Goode <durham@fb.com>
parents:
20883
diff
changeset
|
1038 self.store.invalidatecaches() |
10547
bae9bb09166b
strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10522
diff
changeset
|
1039 |
20627
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1040 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
|
1041 '''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
|
1042 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
|
1043 # 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
|
1044 self.invalidate() |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1045 self.invalidatedirstate() |
a42ea6d209e6
localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents:
20567
diff
changeset
|
1046 |
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
|
1047 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc): |
161 | 1048 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
|
1049 l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc) |
7640 | 1050 except error.LockHeld, inst: |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1051 if not wait: |
2016
ff5c9a92f556
fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1998
diff
changeset
|
1052 raise |
3688
d92dad355000
Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3687
diff
changeset
|
1053 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
|
1054 (desc, inst.locker)) |
2016
ff5c9a92f556
fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1998
diff
changeset
|
1055 # 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
|
1056 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
|
1057 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
|
1058 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
|
1059 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
|
1060 if acquirefn: |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1061 acquirefn() |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1062 return l |
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1063 |
15587
809d5d30e377
localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents:
15586
diff
changeset
|
1064 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
|
1065 """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
|
1066 |
926a06f7a353
lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15486
diff
changeset
|
1067 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
|
1068 l = self._lockref and self._lockref() |
15588
632f4be4d1f3
localrepo: remove asserts in _afterlock
Matt Mackall <mpm@selenic.com>
parents:
15587
diff
changeset
|
1069 if l: |
15589
cc24e4ed3e0c
lock: change name of release chain
Matt Mackall <mpm@selenic.com>
parents:
15588
diff
changeset
|
1070 l.postrelease.append(callback) |
16680
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1071 else: |
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1072 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 |
4914 | 1074 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
|
1075 '''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
|
1076 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
|
1077 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
|
1078 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
|
1079 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
|
1080 l.lock() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1081 return l |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1082 |
14931
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1083 def unlock(): |
18013
98c867ac1330
clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18009
diff
changeset
|
1084 if hasunfilteredcache(self, '_phasecache'): |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16646
diff
changeset
|
1085 self._phasecache.write() |
14931
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1086 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
|
1087 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
|
1088 continue |
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1089 ce.refresh() |
a710936c3037
localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents:
14930
diff
changeset
|
1090 |
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
|
1091 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
|
1092 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
|
1093 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
|
1094 return l |
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
1095 |
4914 | 1096 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
|
1097 '''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
|
1098 .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
|
1099 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
|
1100 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
|
1101 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
|
1102 l.lock() |
a26d33749bd8
made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
8072
diff
changeset
|
1103 return l |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1104 |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1105 def unlock(): |
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1106 self.dirstate.write() |
18318
948f495fb230
localrepo: drop unnecessary check on wlock unlock
Idan Kamara <idankk86@gmail.com>
parents:
18314
diff
changeset
|
1107 self._filecache['dirstate'].refresh() |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1108 |
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
|
1109 l = self._lock(self.vfs, "wlock", wait, unlock, |
14930
372d9d8b1da4
localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents:
14929
diff
changeset
|
1110 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
|
1111 self.origroot) |
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1112 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
|
1113 return l |
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1114 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1115 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
|
1116 """ |
3294
a2d93b186a0e
commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents:
3293
diff
changeset
|
1117 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
|
1118 """ |
3292
764688cf51e5
merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents:
3241
diff
changeset
|
1119 |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1120 fname = fctx.path() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1121 text = fctx.data() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1122 flog = self.file(fname) |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1123 fparent1 = manifest1.get(fname, nullid) |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1124 fparent2 = fparent2o = manifest2.get(fname, nullid) |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1125 |
3292
764688cf51e5
merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents:
3241
diff
changeset
|
1126 meta = {} |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1127 copy = fctx.renamed() |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1128 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
|
1129 # 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
|
1130 # 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
|
1131 # 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
|
1132 # 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
|
1133 # 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
|
1134 # |
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
|
1135 # 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
|
1136 # \ / 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
|
1137 # \- 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
|
1138 # 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
|
1139 # 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
|
1140 # |
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 # 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
|
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 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
|
1144 # \ / 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
|
1145 # \- 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
|
1146 # |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1147 |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1148 cfname = copy[0] |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1149 crev = manifest1.get(cfname) |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1150 newfparent = fparent2 |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1151 |
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1152 if manifest2: # branch merge |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1153 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
|
1154 if cfname in manifest2: |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1155 crev = manifest2[cfname] |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1156 newfparent = fparent1 |
6874
8dc21876261e
commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents:
6680
diff
changeset
|
1157 |
6875 | 1158 # 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
|
1159 if not crev: |
9467
4c041f1ee1b4
do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents:
9437
diff
changeset
|
1160 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
|
1161 (fname, cfname)) |
13000
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1162 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
|
1163 if cfname in ancestor: |
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1164 crev = ancestor[cfname].filenode() |
6876 | 1165 break |
6875 | 1166 |
13000
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1167 if crev: |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1168 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
|
1169 meta["copy"] = cfname |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1170 meta["copyrev"] = hex(crev) |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1171 fparent1, fparent2 = nullid, newfparent |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1172 else: |
417f3c27983b
commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents:
12899
diff
changeset
|
1173 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
|
1174 "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
|
1175 |
20556
db0740a487ab
localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents:
20469
diff
changeset
|
1176 elif fparent1 == nullid: |
db0740a487ab
localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents:
20469
diff
changeset
|
1177 fparent1, fparent2 = fparent2, nullid |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1178 elif fparent2 != nullid: |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1179 # 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
|
1180 fparentancestors = flog.commonancestorsheads(fparent1, fparent2) |
20987
298c9f346dde
commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20975
diff
changeset
|
1181 if fparent1 in fparentancestors: |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1182 fparent1, fparent2 = fparent2, nullid |
20987
298c9f346dde
commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20975
diff
changeset
|
1183 elif fparent2 in fparentancestors: |
8244
99d7e2db8da8
localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents:
8239
diff
changeset
|
1184 fparent2 = nullid |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1185 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1186 # is the file changed? |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1187 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
|
1188 changelist.append(fname) |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1189 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
|
1190 |
8401
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1191 # are just the flags changed during merge? |
10320
808c187fc556
localrepo: minor formatting - remove double space
Henri Wiechers <hwiechers@gmail.com>
parents:
10282
diff
changeset
|
1192 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
|
1193 changelist.append(fname) |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1194 |
ca7dc47eecc6
filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents:
8400
diff
changeset
|
1195 return fparent1 |
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
1196 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1197 @unfilteredmethod |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1198 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
|
1199 editor=False, extra={}): |
8515
865e08a7d6b0
localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8503
diff
changeset
|
1200 """Add a new revision to current repository. |
865e08a7d6b0
localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
8503
diff
changeset
|
1201 |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1202 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
|
1203 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
|
1204 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
|
1205 """ |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1206 |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1207 def fail(f, msg): |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1208 raise util.Abort('%s: %s' % (f, msg)) |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1209 |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1210 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
|
1211 match = matchmod.always(self.root, '') |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1212 |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1213 if not force: |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1214 vdirs = [] |
19138
e579687cb5d8
localrepo.commit: hook into match.explicitdir
Siddharth Agarwal <sid0@fb.com>
parents:
19097
diff
changeset
|
1215 match.explicitdir = vdirs.append |
8715
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1216 match.bad = fail |
8c667f4c482e
commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents:
8712
diff
changeset
|
1217 |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1218 wlock = self.wlock() |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1219 try: |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1220 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
|
1221 merge = len(wctx.parents()) > 1 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1222 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1223 if (not force and merge and match and |
8501 | 1224 (match.files() or match.anypats())): |
8397
613ac2856535
remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents:
8395
diff
changeset
|
1225 raise util.Abort(_('cannot partially commit a merge ' |
613ac2856535
remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents:
8395
diff
changeset
|
1226 '(do not specify files or patterns)')) |
6706
716a1296e182
localrepo: replace dirstate by workingfilectx in filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6705
diff
changeset
|
1227 |
8706
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1228 changes = self.status(match=match, clean=force) |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1229 if force: |
25e9c71b89de
commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents:
8705
diff
changeset
|
1230 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
|
1231 |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1232 # check subrepos |
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1233 subs = [] |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1234 commitsubs = set() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1235 newstate = wctx.substate.copy() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1236 # 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
|
1237 if '.hgsub' in wctx: |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1238 # 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
|
1239 for c in changes[:3]: |
ca5dd216cb62
localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20776
diff
changeset
|
1240 if '.hgsubstate' in c: |
ca5dd216cb62
localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20776
diff
changeset
|
1241 c.remove('.hgsubstate') |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1242 |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1243 # 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
|
1244 # 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
|
1245 oldstate = wctx.p1().substate |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1246 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
|
1247 if not match(s): |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1248 # 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
|
1249 if s in oldstate: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1250 newstate[s] = oldstate[s] |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1251 continue |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1252 if not force: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1253 raise util.Abort( |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1254 _("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
|
1255 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
|
1256 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
|
1257 raise util.Abort( |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1258 _("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
|
1259 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
|
1260 subs.append(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1261 commitsubs.add(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1262 else: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1263 bs = wctx.sub(s).basestate() |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1264 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
|
1265 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
|
1266 subs.append(s) |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1267 |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1268 # 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
|
1269 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
|
1270 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
|
1271 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
|
1272 if subs: |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1273 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
|
1274 '.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
|
1275 raise util.Abort( |
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1276 _("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
|
1277 changes[0].insert(0, '.hgsubstate') |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1278 |
14536
52cbeb5a651b
subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents:
14529
diff
changeset
|
1279 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
|
1280 # 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
|
1281 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
|
1282 '.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
|
1283 changes[2].insert(0, '.hgsubstate') |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1284 |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1285 # 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
|
1286 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
|
1287 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
|
1288 |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1289 for f in match.files(): |
17378
b05e517c2236
commit: normalize filenames when checking explicit files (issue3576)
Matt Mackall <mpm@selenic.com>
parents:
17360
diff
changeset
|
1290 f = self.dirstate.normalize(f) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1291 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
|
1292 continue |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1293 if f in changes[3]: # missing |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1294 fail(f, _('file not found!')) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1295 if f in vdirs: # visited directory |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1296 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
|
1297 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
|
1298 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
|
1299 break |
bcb6e5bebd93
commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents:
8709
diff
changeset
|
1300 else: |
8709
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1301 fail(f, _("no match under directory!")) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1302 elif f not in self.dirstate: |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1303 fail(f, _("file not tracked!")) |
b9e0ddb04c5c
commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents:
8707
diff
changeset
|
1304 |
18659
b946470efed9
localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents:
18644
diff
changeset
|
1305 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
|
1306 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1307 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
|
1308 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
|
1309 and wctx.branch() == wctx.p1().branch()): |
8404
a2bc39ade36b
commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents:
8403
diff
changeset
|
1310 return None |
a2bc39ade36b
commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents:
8403
diff
changeset
|
1311 |
18660
7e6946ed5756
localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents:
18659
diff
changeset
|
1312 if merge and cctx.deleted(): |
16536
63c817ea4a70
commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents:
16456
diff
changeset
|
1313 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
|
1314 |
10651
5f091fc1bab7
style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10547
diff
changeset
|
1315 ms = mergemod.mergestate(self) |
6888
7c36a4fb05a3
make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6884
diff
changeset
|
1316 for f in changes[0]: |
7c36a4fb05a3
make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents:
6884
diff
changeset
|
1317 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
|
1318 raise util.Abort(_("unresolved merge conflicts " |
13541
919174c0aaff
Improve unresolved merge conflicts warning (issue2681)
Patrick Mezard <pmezard@gmail.com>
parents:
13526
diff
changeset
|
1319 "(see hg help resolve)")) |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1320 |
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1321 if editor: |
8994
4a1187d3cb00
commit: report modified subrepos in commit editor
Matt Mackall <mpm@selenic.com>
parents:
8954
diff
changeset
|
1322 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
|
1323 edited = (text != cctx._text) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1324 |
20765
f042d4b263f4
localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20332
diff
changeset
|
1325 # 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
|
1326 # (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
|
1327 # 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
|
1328 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
|
1329 |
16073
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1330 # 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
|
1331 if subs: |
b254f827b7a6
subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
1332 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
|
1333 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
|
1334 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
|
1335 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
|
1336 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
|
1337 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
|
1338 subrepo.writestate(self, newstate) |
8813
db3c1ab0e632
commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents:
8799
diff
changeset
|
1339 |
10970
3213e8947975
localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10969
diff
changeset
|
1340 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
|
1341 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
|
1342 try: |
16683 | 1343 self.hook("precommit", throw=True, parent1=hookp1, |
1344 parent2=hookp2) | |
9935
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1345 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
|
1346 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
|
1347 if edited: |
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1348 self.ui.write( |
48b81d9bca8d
commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents:
9934
diff
changeset
|
1349 _('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
|
1350 raise |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1351 |
13357
b67867940bd1
bookmarks: move commit action into core
Matt Mackall <mpm@selenic.com>
parents:
13356
diff
changeset
|
1352 # update bookmarks, dirstate and mergestate |
16706
a270ec977ba6
bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents:
16705
diff
changeset
|
1353 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
|
1354 cctx.markcommitted(ret) |
8503
90f86a5330bb
commit: tidy up mergestate slightly
Matt Mackall <mpm@selenic.com>
parents:
8502
diff
changeset
|
1355 ms.reset() |
6710
0aa91f69a4c4
localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents:
6709
diff
changeset
|
1356 finally: |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1357 wlock.release() |
6710
0aa91f69a4c4
localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents:
6709
diff
changeset
|
1358 |
16680
d0e419b0f7de
tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents:
16679
diff
changeset
|
1359 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
|
1360 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
|
1361 self._afterlock(commithook) |
10492
0e64d814d7d0
run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents:
10435
diff
changeset
|
1362 return ret |
0e64d814d7d0
run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents:
10435
diff
changeset
|
1363 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1364 @unfilteredmethod |
8496
a21605de1509
commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents:
8481
diff
changeset
|
1365 def commitctx(self, ctx, error=False): |
7077
ccbd39cad3c3
context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents:
7072
diff
changeset
|
1366 """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
|
1367 Revision information is passed via the context argument. |
7077
ccbd39cad3c3
context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents:
7072
diff
changeset
|
1368 """ |
6715
a3c41abfa828
context: add memctx for memory commits
Patrick Mezard <pmezard@gmail.com>
parents:
6712
diff
changeset
|
1369 |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1370 tr = lock = None |
12899
fabe61418a53
localrepo: do not modify ctx.remove() list in-place
Patrick Mezard <pmezard@gmail.com>
parents:
12847
diff
changeset
|
1371 removed = list(ctx.removed()) |
8414
2348ce25849b
commitctx: use contexts more fully
Matt Mackall <mpm@selenic.com>
parents:
8412
diff
changeset
|
1372 p1, p2 = ctx.p1(), ctx.p2() |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1373 user = ctx.user() |
990 | 1374 |
8411
4d5916358abd
commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents:
8410
diff
changeset
|
1375 lock = self.lock() |
4d5916358abd
commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents:
8410
diff
changeset
|
1376 try: |
10881
a685011ed38e
localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents:
10877
diff
changeset
|
1377 tr = self.transaction("commit") |
4970
30d4d8985dd8
transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents:
4917
diff
changeset
|
1378 trp = weakref.proxy(tr) |
151 | 1379 |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1380 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
|
1381 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
|
1382 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
|
1383 |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1384 # 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
|
1385 new = {} |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1386 changed = [] |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1387 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
|
1388 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
|
1389 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
|
1390 try: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1391 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
|
1392 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
|
1393 changed) |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1394 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
|
1395 except OSError, inst: |
4915
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1396 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
|
1397 raise |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1398 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
|
1399 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
|
1400 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
|
1401 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
|
1402 raise |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1403 else: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1404 removed.append(f) |
220 | 1405 |
14162
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1406 # update manifest |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1407 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
|
1408 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
|
1409 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
|
1410 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
|
1411 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
|
1412 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
|
1413 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
|
1414 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
|
1415 else: |
301725c3df9a
localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14155
diff
changeset
|
1416 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
|
1417 files = [] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1418 |
8499
fb9b83df45f3
commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents:
8498
diff
changeset
|
1419 # update changelog |
7787
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1420 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
|
1421 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
|
1422 trp, p1.node(), p2.node(), |
8412
2bf4f380f6ab
commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents:
8411
diff
changeset
|
1423 user, ctx.date(), ctx.extra().copy()) |
7787
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1424 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
|
1425 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
|
1426 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
|
1427 parent2=xp2, pending=p) |
b8d750daadde
Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents:
7728
diff
changeset
|
1428 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
|
1429 # 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
|
1430 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
|
1431 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
|
1432 # 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
|
1433 # 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
|
1434 # 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
|
1435 # |
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
|
1436 # 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
|
1437 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
|
1438 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
|
1439 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
|
1440 return n |
97b734fb9c6f
Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents:
4914
diff
changeset
|
1441 finally: |
11230
5116a077c3da
make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
11228
diff
changeset
|
1442 if tr: |
5116a077c3da
make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents:
11228
diff
changeset
|
1443 tr.release() |
8405
7cbf8fcd2453
commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents:
8404
diff
changeset
|
1444 lock.release() |
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
1445 |
18016
2a393df0f5cc
clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18014
diff
changeset
|
1446 @unfilteredmethod |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1447 def destroying(self): |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1448 '''Inform the repository that nodes are about to be destroyed. |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1449 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
|
1450 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
|
1451 |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1452 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
|
1453 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
|
1454 destroyed is imminent, the repo will be invalidated causing those |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1455 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
|
1456 completely. |
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1457 ''' |
18312
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1458 # 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
|
1459 # 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
|
1460 # causing those changes to disappear. |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1461 if '_phasecache' in vars(self): |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1462 self._phasecache.write() |
7331ee72f99c
localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents:
18311
diff
changeset
|
1463 |
18310
4499ba5ac35c
localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents:
18309
diff
changeset
|
1464 @unfilteredmethod |
18395
904b7109938e
destroyed: drop complex branchcache rebuilt logic
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18394
diff
changeset
|
1465 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
|
1466 '''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
|
1467 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
|
1468 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
|
1469 ''' |
18221
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1470 # When one tries to: |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1471 # 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
|
1472 # 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
|
1473 # |
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1474 # 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
|
1475 # 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
|
1476 # 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
|
1477 # 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
|
1478 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
|
1479 self._phasecache.write() |
18221
082d6929fd4d
localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents:
18219
diff
changeset
|
1480 |
18396
dd3fd3353e23
destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18395
diff
changeset
|
1481 # 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
|
1482 # 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
|
1483 # 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
|
1484 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
|
1485 |
9151
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1486 # 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
|
1487 # 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
|
1488 # 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
|
1489 # guarantees that "cachetip == currenttip" (comparing both rev |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1490 # 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
|
1491 |
f528d1a93491
tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents:
9150
diff
changeset
|
1492 # 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
|
1493 # 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
|
1494 # 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
|
1495 # 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
|
1496 self.invalidate() |
17324
9f94358f9f93
localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents:
17306
diff
changeset
|
1497 |
6585 | 1498 def walk(self, match, node=None): |
3532 | 1499 ''' |
1500 walk recursively through the directory tree or a given | |
1501 changeset, finding all files matched by the match | |
1502 function | |
1503 ''' | |
6764 | 1504 return self[node].walk(match) |
3532 | 1505 |
6769 | 1506 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
|
1507 ignored=False, clean=False, unknown=False, |
441a74b8def1
status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents:
12162
diff
changeset
|
1508 listsubrepos=False): |
21596
83bbfb23cb24
localrepo: replace status method with a shim
Sean Farley <sean.michael.farley@gmail.com>
parents:
21591
diff
changeset
|
1509 '''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
|
1510 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
|
1511 listsubrepos) |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2621
diff
changeset
|
1512 |
8796
2bcef677a6c3
localrepo: remove 'closed' argument to heads(...) function
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
8731
diff
changeset
|
1513 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
|
1514 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
|
1515 # 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
|
1516 return sorted(heads, key=self.changelog.rev, reverse=True) |
222 | 1517 |
8694
ca8d05e1f1d1
localrepo: set heads and branchheads to be closed=False by default
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
8680
diff
changeset
|
1518 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
|
1519 '''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
|
1520 |
c295a82a020b
localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents:
9423
diff
changeset
|
1521 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
|
1522 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
|
1523 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
|
1524 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
|
1525 ''' |
6747
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
1526 if branch is None: |
f6c00b17387c
use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents:
6743
diff
changeset
|
1527 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
|
1528 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
|
1529 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
|
1530 return [] |
7654
816b708f23af
store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents:
7644
diff
changeset
|
1531 # 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
|
1532 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
|
1533 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
|
1534 # 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
|
1535 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
|
1536 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
|
1537 return bheads |
4648
8e503fa54d2d
Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents:
4635
diff
changeset
|
1538 |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1539 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
|
1540 if not nodes: |
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1541 nodes = [self.changelog.tip()] |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1542 b = [] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1543 for n in nodes: |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1544 t = n |
14494
1ffeeb91c55d
check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents:
14482
diff
changeset
|
1545 while True: |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1546 p = self.changelog.parents(n) |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1547 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
|
1548 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
|
1549 break |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1550 n = p[0] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1551 return b |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1552 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1553 def between(self, pairs): |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1554 r = [] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1555 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1556 for top, bottom in pairs: |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1557 n, l, i = top, [], 0 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1558 f = 1 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1559 |
7708
a32847fa0df0
wire protocol: avoid infinite loop (issue1483)
Matt Mackall <mpm@selenic.com>
parents:
7564
diff
changeset
|
1560 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
|
1561 p = self.changelog.parents(n)[0] |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1562 if i == f: |
575 | 1563 l.append(n) |
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1564 f = f * 2 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1565 n = p |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1566 i += 1 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1567 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1568 r.append(l) |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1569 |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1570 return r |
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1571 |
4917
126f527b3ba3
Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents:
4916
diff
changeset
|
1572 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
|
1573 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
|
1574 |
20924
e10000369b47
push: pass a `pushoperation` object to localrepo.checkpush
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20884
diff
changeset
|
1575 def checkpush(self, pushop): |
13327
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1576 """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
|
1577 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
|
1578 command. |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1579 """ |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1580 pass |
dc11e30b48a3
mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents:
13272
diff
changeset
|
1581 |
21043
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1582 @unfilteredpropertycache |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1583 def prepushoutgoinghooks(self): |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1584 """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
|
1585 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
|
1586 """ |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1587 return util.hooks() |
6c383c871fdb
localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20987
diff
changeset
|
1588 |
11211
e43c23d189a5
push: add --new-branch option to allow intial push of new branches
Sune Foldager <cryo@cyanite.org>
parents:
11177
diff
changeset
|
1589 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
|
1590 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
|
1591 |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1592 def stream_in(self, remote, requirements): |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1593 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
|
1594 try: |
17740
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1595 # 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
|
1596 # to speed up branchcache creation |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1597 rbranchmap = None |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1598 if remote.capable("branchmap"): |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1599 rbranchmap = remote.branchmap() |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1600 |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1601 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
|
1602 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
|
1603 try: |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1604 resp = int(l) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1605 except ValueError: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1606 raise error.ResponseError( |
16941
a1eb17bed550
localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents:
16866
diff
changeset
|
1607 _('unexpected response from remote server:'), l) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1608 if resp == 1: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1609 raise util.Abort(_('operation forbidden by server')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1610 elif resp == 2: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1611 raise util.Abort(_('locking the remote repository failed')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1612 elif resp != 0: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1613 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
|
1614 self.ui.status(_('streaming all changes\n')) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1615 l = fp.readline() |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1616 try: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1617 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
|
1618 except (ValueError, TypeError): |
7641
d2f753830f80
error: move UnexpectedOutput (now ResponseError)
Matt Mackall <mpm@selenic.com>
parents:
7640
diff
changeset
|
1619 raise error.ResponseError( |
16941
a1eb17bed550
localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents:
16866
diff
changeset
|
1620 _('unexpected response from remote server:'), l) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1621 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
|
1622 (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
|
1623 handled_bytes = 0 |
b3435385f99f
clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents:
16745
diff
changeset
|
1624 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
|
1625 start = time.time() |
20880
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1626 |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1627 tr = self.transaction(_('clone')) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1628 try: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1629 for i in xrange(total_files): |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1630 # 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
|
1631 l = fp.readline() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1632 try: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1633 name, size = l.split('\0', 1) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1634 size = int(size) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1635 except (ValueError, TypeError): |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1636 raise error.ResponseError( |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1637 _('unexpected response from remote server:'), l) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1638 if self.ui.debugflag: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1639 self.ui.debug('adding %s (%s)\n' % |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1640 (name, util.bytecount(size))) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1641 # for backwards compat, name was partially encoded |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1642 ofp = self.sopener(store.decodedir(name), 'w') |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1643 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
|
1644 handled_bytes += len(chunk) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1645 self.ui.progress(_('clone'), handled_bytes, |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1646 total=total_bytes) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1647 ofp.write(chunk) |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1648 ofp.close() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1649 tr.close() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1650 finally: |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1651 tr.release() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1652 |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1653 # 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
|
1654 self.invalidate() |
925c2d604389
clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents:
20827
diff
changeset
|
1655 |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1656 elapsed = time.time() - start |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1657 if elapsed <= 0: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1658 elapsed = 0.001 |
16770
b3435385f99f
clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents:
16745
diff
changeset
|
1659 self.ui.progress(_('clone'), None) |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1660 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
|
1661 (util.bytecount(total_bytes), elapsed, |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1662 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
|
1663 |
16683 | 1664 # new requirements = old non-format requirements + |
1665 # new format-related | |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1666 # requirements from the streamed-in repository |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1667 requirements.update(set(self.requirements) - self.supportedformats) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1668 self._applyrequirements(requirements) |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1669 self._writerequirements() |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1670 |
17740
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1671 if rbranchmap: |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1672 rbheads = [] |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1673 for bheads in rbranchmap.itervalues(): |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1674 rbheads.extend(bheads) |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1675 |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1676 if rbheads: |
e6067bec18da
branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents:
17716
diff
changeset
|
1677 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
|
1678 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
|
1679 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
|
1680 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
|
1681 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
|
1682 # 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
|
1683 # 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
|
1684 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
|
1685 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
|
1686 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
|
1687 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
|
1688 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
|
1689 break |
13390
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1690 self.invalidate() |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1691 return len(self.heads()) + 1 |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1692 finally: |
327719a44b6a
localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents:
13385
diff
changeset
|
1693 lock.release() |
515 | 1694 |
2613
479e26afa10f
clone: do not make streaming default. add --stream option instead.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2612
diff
changeset
|
1695 def clone(self, remote, heads=[], stream=False): |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1696 '''clone remote repository. |
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1697 |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1698 keyword arguments: |
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1699 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
|
1700 stream: use streaming clone if possible''' |
247 | 1701 |
2621
5a5852a417b1
clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2613
diff
changeset
|
1702 # 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
|
1703 # 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
|
1704 # them. |
247 | 1705 |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1706 # 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
|
1707 # 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
|
1708 # uncompressed only if compatible. |
247 | 1709 |
16361
6097ede2be4d
protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents:
16253
diff
changeset
|
1710 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
|
1711 # 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
|
1712 stream = remote.capable('stream-preferred') |
6097ede2be4d
protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents:
16253
diff
changeset
|
1713 |
12296
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1714 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
|
1715 # '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
|
1716 if remote.capable('stream'): |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1717 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
|
1718 # 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
|
1719 streamreqs = remote.capable('streamreqs') |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1720 if streamreqs: |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1721 streamreqs = set(streamreqs.split(',')) |
d7fff529d85d
clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents:
12295
diff
changeset
|
1722 # 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
|
1723 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
|
1724 return self.stream_in(remote, streamreqs) |
2612
ffb895f16925
add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2601
diff
changeset
|
1725 return self.pull(remote, heads) |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1726 |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1727 def pushkey(self, namespace, key, old, new): |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1728 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
|
1729 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
|
1730 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
|
1731 ret = pushkey.push(self, namespace, key, old, new) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1732 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
|
1733 ret=ret) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1734 return ret |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1735 |
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1736 def listkeys(self, namespace): |
14102
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1737 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
|
1738 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
|
1739 values = pushkey.list(self, namespace) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1740 self.hook('listkeys', namespace=namespace, values=values) |
7f45b1911893
pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents:
14076
diff
changeset
|
1741 return values |
11368
b9eb005c54ad
pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents:
11303
diff
changeset
|
1742 |
14048
58e58406ed19
wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
14036
diff
changeset
|
1743 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
|
1744 '''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
|
1745 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
|
1746 |
14529
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1747 def savecommitmessage(self, text): |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1748 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
|
1749 try: |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1750 fp.write(text) |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1751 finally: |
e7a1814854b9
localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents:
14522
diff
changeset
|
1752 fp.close() |
18054
b35e3364f94a
check-code: there must also be whitespace between ')' and operator
Mads Kiilerich <madski@unity3d.com>
parents:
18044
diff
changeset
|
1753 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
|
1754 |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1755 # 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
|
1756 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
|
1757 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
|
1758 def a(): |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
1759 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
|
1760 try: |
18952
8086b530e2ac
localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18951
diff
changeset
|
1761 vfs.rename(src, dest) |
16441
9dd10a574af2
localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents:
16426
diff
changeset
|
1762 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
|
1763 pass |
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1764 return a |
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1765 |
14266
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1766 def undoname(fn): |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1767 base, name = os.path.split(fn) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1768 assert name.startswith('journal') |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1769 return os.path.join(base, name.replace('journal', 'undo', 1)) |
89e7d35e0ef0
fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents:
13957
diff
changeset
|
1770 |
2740
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
1771 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
|
1772 return localrepository(ui, util.urllocalpath(path), create) |
3223
53e843840349
Whitespace/Tab cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents:
3164
diff
changeset
|
1773 |
2740
386f04d6ecb3
clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2673
diff
changeset
|
1774 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
|
1775 return True |