##// END OF EJS Templates
localrepo: add a way to get the current lock if it's held...
Siddharth Agarwal -
r26488:df2dc514 default
parent child Browse files
Show More
@@ -1,1873 +1,1882 b''
1 # localrepo.py - read/write repository class for mercurial
1 # localrepo.py - read/write repository class for mercurial
2 #
2 #
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7 from node import hex, nullid, wdirrev, short
7 from node import hex, nullid, wdirrev, short
8 from i18n import _
8 from i18n import _
9 import urllib
9 import urllib
10 import peer, changegroup, subrepo, pushkey, obsolete, repoview
10 import peer, changegroup, subrepo, pushkey, obsolete, repoview
11 import changelog, dirstate, filelog, manifest, context, bookmarks, phases
11 import changelog, dirstate, filelog, manifest, context, bookmarks, phases
12 import lock as lockmod
12 import lock as lockmod
13 import transaction, store, encoding, exchange, bundle2
13 import transaction, store, encoding, exchange, bundle2
14 import scmutil, util, extensions, hook, error, revset
14 import scmutil, util, extensions, hook, error, revset
15 import match as matchmod
15 import match as matchmod
16 import merge as mergemod
16 import merge as mergemod
17 import tags as tagsmod
17 import tags as tagsmod
18 from lock import release
18 from lock import release
19 import weakref, errno, os, time, inspect, random
19 import weakref, errno, os, time, inspect, random
20 import branchmap, pathutil
20 import branchmap, pathutil
21 import namespaces
21 import namespaces
22 propertycache = util.propertycache
22 propertycache = util.propertycache
23 filecache = scmutil.filecache
23 filecache = scmutil.filecache
24
24
25 class repofilecache(filecache):
25 class repofilecache(filecache):
26 """All filecache usage on repo are done for logic that should be unfiltered
26 """All filecache usage on repo are done for logic that should be unfiltered
27 """
27 """
28
28
29 def __get__(self, repo, type=None):
29 def __get__(self, repo, type=None):
30 return super(repofilecache, self).__get__(repo.unfiltered(), type)
30 return super(repofilecache, self).__get__(repo.unfiltered(), type)
31 def __set__(self, repo, value):
31 def __set__(self, repo, value):
32 return super(repofilecache, self).__set__(repo.unfiltered(), value)
32 return super(repofilecache, self).__set__(repo.unfiltered(), value)
33 def __delete__(self, repo):
33 def __delete__(self, repo):
34 return super(repofilecache, self).__delete__(repo.unfiltered())
34 return super(repofilecache, self).__delete__(repo.unfiltered())
35
35
36 class storecache(repofilecache):
36 class storecache(repofilecache):
37 """filecache for files in the store"""
37 """filecache for files in the store"""
38 def join(self, obj, fname):
38 def join(self, obj, fname):
39 return obj.sjoin(fname)
39 return obj.sjoin(fname)
40
40
41 class unfilteredpropertycache(propertycache):
41 class unfilteredpropertycache(propertycache):
42 """propertycache that apply to unfiltered repo only"""
42 """propertycache that apply to unfiltered repo only"""
43
43
44 def __get__(self, repo, type=None):
44 def __get__(self, repo, type=None):
45 unfi = repo.unfiltered()
45 unfi = repo.unfiltered()
46 if unfi is repo:
46 if unfi is repo:
47 return super(unfilteredpropertycache, self).__get__(unfi)
47 return super(unfilteredpropertycache, self).__get__(unfi)
48 return getattr(unfi, self.name)
48 return getattr(unfi, self.name)
49
49
50 class filteredpropertycache(propertycache):
50 class filteredpropertycache(propertycache):
51 """propertycache that must take filtering in account"""
51 """propertycache that must take filtering in account"""
52
52
53 def cachevalue(self, obj, value):
53 def cachevalue(self, obj, value):
54 object.__setattr__(obj, self.name, value)
54 object.__setattr__(obj, self.name, value)
55
55
56
56
57 def hasunfilteredcache(repo, name):
57 def hasunfilteredcache(repo, name):
58 """check if a repo has an unfilteredpropertycache value for <name>"""
58 """check if a repo has an unfilteredpropertycache value for <name>"""
59 return name in vars(repo.unfiltered())
59 return name in vars(repo.unfiltered())
60
60
61 def unfilteredmethod(orig):
61 def unfilteredmethod(orig):
62 """decorate method that always need to be run on unfiltered version"""
62 """decorate method that always need to be run on unfiltered version"""
63 def wrapper(repo, *args, **kwargs):
63 def wrapper(repo, *args, **kwargs):
64 return orig(repo.unfiltered(), *args, **kwargs)
64 return orig(repo.unfiltered(), *args, **kwargs)
65 return wrapper
65 return wrapper
66
66
67 moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
67 moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
68 'unbundle'))
68 'unbundle'))
69 legacycaps = moderncaps.union(set(['changegroupsubset']))
69 legacycaps = moderncaps.union(set(['changegroupsubset']))
70
70
71 class localpeer(peer.peerrepository):
71 class localpeer(peer.peerrepository):
72 '''peer for a local repo; reflects only the most recent API'''
72 '''peer for a local repo; reflects only the most recent API'''
73
73
74 def __init__(self, repo, caps=moderncaps):
74 def __init__(self, repo, caps=moderncaps):
75 peer.peerrepository.__init__(self)
75 peer.peerrepository.__init__(self)
76 self._repo = repo.filtered('served')
76 self._repo = repo.filtered('served')
77 self.ui = repo.ui
77 self.ui = repo.ui
78 self._caps = repo._restrictcapabilities(caps)
78 self._caps = repo._restrictcapabilities(caps)
79 self.requirements = repo.requirements
79 self.requirements = repo.requirements
80 self.supportedformats = repo.supportedformats
80 self.supportedformats = repo.supportedformats
81
81
82 def close(self):
82 def close(self):
83 self._repo.close()
83 self._repo.close()
84
84
85 def _capabilities(self):
85 def _capabilities(self):
86 return self._caps
86 return self._caps
87
87
88 def local(self):
88 def local(self):
89 return self._repo
89 return self._repo
90
90
91 def canpush(self):
91 def canpush(self):
92 return True
92 return True
93
93
94 def url(self):
94 def url(self):
95 return self._repo.url()
95 return self._repo.url()
96
96
97 def lookup(self, key):
97 def lookup(self, key):
98 return self._repo.lookup(key)
98 return self._repo.lookup(key)
99
99
100 def branchmap(self):
100 def branchmap(self):
101 return self._repo.branchmap()
101 return self._repo.branchmap()
102
102
103 def heads(self):
103 def heads(self):
104 return self._repo.heads()
104 return self._repo.heads()
105
105
106 def known(self, nodes):
106 def known(self, nodes):
107 return self._repo.known(nodes)
107 return self._repo.known(nodes)
108
108
109 def getbundle(self, source, heads=None, common=None, bundlecaps=None,
109 def getbundle(self, source, heads=None, common=None, bundlecaps=None,
110 **kwargs):
110 **kwargs):
111 cg = exchange.getbundle(self._repo, source, heads=heads,
111 cg = exchange.getbundle(self._repo, source, heads=heads,
112 common=common, bundlecaps=bundlecaps, **kwargs)
112 common=common, bundlecaps=bundlecaps, **kwargs)
113 if bundlecaps is not None and 'HG20' in bundlecaps:
113 if bundlecaps is not None and 'HG20' in bundlecaps:
114 # When requesting a bundle2, getbundle returns a stream to make the
114 # When requesting a bundle2, getbundle returns a stream to make the
115 # wire level function happier. We need to build a proper object
115 # wire level function happier. We need to build a proper object
116 # from it in local peer.
116 # from it in local peer.
117 cg = bundle2.getunbundler(self.ui, cg)
117 cg = bundle2.getunbundler(self.ui, cg)
118 return cg
118 return cg
119
119
120 # TODO We might want to move the next two calls into legacypeer and add
120 # TODO We might want to move the next two calls into legacypeer and add
121 # unbundle instead.
121 # unbundle instead.
122
122
123 def unbundle(self, cg, heads, url):
123 def unbundle(self, cg, heads, url):
124 """apply a bundle on a repo
124 """apply a bundle on a repo
125
125
126 This function handles the repo locking itself."""
126 This function handles the repo locking itself."""
127 try:
127 try:
128 try:
128 try:
129 cg = exchange.readbundle(self.ui, cg, None)
129 cg = exchange.readbundle(self.ui, cg, None)
130 ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
130 ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
131 if util.safehasattr(ret, 'getchunks'):
131 if util.safehasattr(ret, 'getchunks'):
132 # This is a bundle20 object, turn it into an unbundler.
132 # This is a bundle20 object, turn it into an unbundler.
133 # This little dance should be dropped eventually when the
133 # This little dance should be dropped eventually when the
134 # API is finally improved.
134 # API is finally improved.
135 stream = util.chunkbuffer(ret.getchunks())
135 stream = util.chunkbuffer(ret.getchunks())
136 ret = bundle2.getunbundler(self.ui, stream)
136 ret = bundle2.getunbundler(self.ui, stream)
137 return ret
137 return ret
138 except Exception as exc:
138 except Exception as exc:
139 # If the exception contains output salvaged from a bundle2
139 # If the exception contains output salvaged from a bundle2
140 # reply, we need to make sure it is printed before continuing
140 # reply, we need to make sure it is printed before continuing
141 # to fail. So we build a bundle2 with such output and consume
141 # to fail. So we build a bundle2 with such output and consume
142 # it directly.
142 # it directly.
143 #
143 #
144 # This is not very elegant but allows a "simple" solution for
144 # This is not very elegant but allows a "simple" solution for
145 # issue4594
145 # issue4594
146 output = getattr(exc, '_bundle2salvagedoutput', ())
146 output = getattr(exc, '_bundle2salvagedoutput', ())
147 if output:
147 if output:
148 bundler = bundle2.bundle20(self._repo.ui)
148 bundler = bundle2.bundle20(self._repo.ui)
149 for out in output:
149 for out in output:
150 bundler.addpart(out)
150 bundler.addpart(out)
151 stream = util.chunkbuffer(bundler.getchunks())
151 stream = util.chunkbuffer(bundler.getchunks())
152 b = bundle2.getunbundler(self.ui, stream)
152 b = bundle2.getunbundler(self.ui, stream)
153 bundle2.processbundle(self._repo, b)
153 bundle2.processbundle(self._repo, b)
154 raise
154 raise
155 except error.PushRaced as exc:
155 except error.PushRaced as exc:
156 raise error.ResponseError(_('push failed:'), str(exc))
156 raise error.ResponseError(_('push failed:'), str(exc))
157
157
158 def lock(self):
158 def lock(self):
159 return self._repo.lock()
159 return self._repo.lock()
160
160
161 def addchangegroup(self, cg, source, url):
161 def addchangegroup(self, cg, source, url):
162 return changegroup.addchangegroup(self._repo, cg, source, url)
162 return changegroup.addchangegroup(self._repo, cg, source, url)
163
163
164 def pushkey(self, namespace, key, old, new):
164 def pushkey(self, namespace, key, old, new):
165 return self._repo.pushkey(namespace, key, old, new)
165 return self._repo.pushkey(namespace, key, old, new)
166
166
167 def listkeys(self, namespace):
167 def listkeys(self, namespace):
168 return self._repo.listkeys(namespace)
168 return self._repo.listkeys(namespace)
169
169
170 def debugwireargs(self, one, two, three=None, four=None, five=None):
170 def debugwireargs(self, one, two, three=None, four=None, five=None):
171 '''used to test argument passing over the wire'''
171 '''used to test argument passing over the wire'''
172 return "%s %s %s %s %s" % (one, two, three, four, five)
172 return "%s %s %s %s %s" % (one, two, three, four, five)
173
173
174 class locallegacypeer(localpeer):
174 class locallegacypeer(localpeer):
175 '''peer extension which implements legacy methods too; used for tests with
175 '''peer extension which implements legacy methods too; used for tests with
176 restricted capabilities'''
176 restricted capabilities'''
177
177
178 def __init__(self, repo):
178 def __init__(self, repo):
179 localpeer.__init__(self, repo, caps=legacycaps)
179 localpeer.__init__(self, repo, caps=legacycaps)
180
180
181 def branches(self, nodes):
181 def branches(self, nodes):
182 return self._repo.branches(nodes)
182 return self._repo.branches(nodes)
183
183
184 def between(self, pairs):
184 def between(self, pairs):
185 return self._repo.between(pairs)
185 return self._repo.between(pairs)
186
186
187 def changegroup(self, basenodes, source):
187 def changegroup(self, basenodes, source):
188 return changegroup.changegroup(self._repo, basenodes, source)
188 return changegroup.changegroup(self._repo, basenodes, source)
189
189
190 def changegroupsubset(self, bases, heads, source):
190 def changegroupsubset(self, bases, heads, source):
191 return changegroup.changegroupsubset(self._repo, bases, heads, source)
191 return changegroup.changegroupsubset(self._repo, bases, heads, source)
192
192
193 class localrepository(object):
193 class localrepository(object):
194
194
195 supportedformats = set(('revlogv1', 'generaldelta', 'treemanifest',
195 supportedformats = set(('revlogv1', 'generaldelta', 'treemanifest',
196 'manifestv2'))
196 'manifestv2'))
197 _basesupported = supportedformats | set(('store', 'fncache', 'shared',
197 _basesupported = supportedformats | set(('store', 'fncache', 'shared',
198 'dotencode'))
198 'dotencode'))
199 openerreqs = set(('revlogv1', 'generaldelta', 'treemanifest', 'manifestv2'))
199 openerreqs = set(('revlogv1', 'generaldelta', 'treemanifest', 'manifestv2'))
200 filtername = None
200 filtername = None
201
201
202 # a list of (ui, featureset) functions.
202 # a list of (ui, featureset) functions.
203 # only functions defined in module of enabled extensions are invoked
203 # only functions defined in module of enabled extensions are invoked
204 featuresetupfuncs = set()
204 featuresetupfuncs = set()
205
205
206 def _baserequirements(self, create):
206 def _baserequirements(self, create):
207 return ['revlogv1']
207 return ['revlogv1']
208
208
209 def __init__(self, baseui, path=None, create=False):
209 def __init__(self, baseui, path=None, create=False):
210 self.requirements = set()
210 self.requirements = set()
211 self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
211 self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
212 self.wopener = self.wvfs
212 self.wopener = self.wvfs
213 self.root = self.wvfs.base
213 self.root = self.wvfs.base
214 self.path = self.wvfs.join(".hg")
214 self.path = self.wvfs.join(".hg")
215 self.origroot = path
215 self.origroot = path
216 self.auditor = pathutil.pathauditor(self.root, self._checknested)
216 self.auditor = pathutil.pathauditor(self.root, self._checknested)
217 self.vfs = scmutil.vfs(self.path)
217 self.vfs = scmutil.vfs(self.path)
218 self.opener = self.vfs
218 self.opener = self.vfs
219 self.baseui = baseui
219 self.baseui = baseui
220 self.ui = baseui.copy()
220 self.ui = baseui.copy()
221 self.ui.copy = baseui.copy # prevent copying repo configuration
221 self.ui.copy = baseui.copy # prevent copying repo configuration
222 # A list of callback to shape the phase if no data were found.
222 # A list of callback to shape the phase if no data were found.
223 # Callback are in the form: func(repo, roots) --> processed root.
223 # Callback are in the form: func(repo, roots) --> processed root.
224 # This list it to be filled by extension during repo setup
224 # This list it to be filled by extension during repo setup
225 self._phasedefaults = []
225 self._phasedefaults = []
226 try:
226 try:
227 self.ui.readconfig(self.join("hgrc"), self.root)
227 self.ui.readconfig(self.join("hgrc"), self.root)
228 extensions.loadall(self.ui)
228 extensions.loadall(self.ui)
229 except IOError:
229 except IOError:
230 pass
230 pass
231
231
232 if self.featuresetupfuncs:
232 if self.featuresetupfuncs:
233 self.supported = set(self._basesupported) # use private copy
233 self.supported = set(self._basesupported) # use private copy
234 extmods = set(m.__name__ for n, m
234 extmods = set(m.__name__ for n, m
235 in extensions.extensions(self.ui))
235 in extensions.extensions(self.ui))
236 for setupfunc in self.featuresetupfuncs:
236 for setupfunc in self.featuresetupfuncs:
237 if setupfunc.__module__ in extmods:
237 if setupfunc.__module__ in extmods:
238 setupfunc(self.ui, self.supported)
238 setupfunc(self.ui, self.supported)
239 else:
239 else:
240 self.supported = self._basesupported
240 self.supported = self._basesupported
241
241
242 if not self.vfs.isdir():
242 if not self.vfs.isdir():
243 if create:
243 if create:
244 if not self.wvfs.exists():
244 if not self.wvfs.exists():
245 self.wvfs.makedirs()
245 self.wvfs.makedirs()
246 self.vfs.makedir(notindexed=True)
246 self.vfs.makedir(notindexed=True)
247 self.requirements.update(self._baserequirements(create))
247 self.requirements.update(self._baserequirements(create))
248 if self.ui.configbool('format', 'usestore', True):
248 if self.ui.configbool('format', 'usestore', True):
249 self.vfs.mkdir("store")
249 self.vfs.mkdir("store")
250 self.requirements.add("store")
250 self.requirements.add("store")
251 if self.ui.configbool('format', 'usefncache', True):
251 if self.ui.configbool('format', 'usefncache', True):
252 self.requirements.add("fncache")
252 self.requirements.add("fncache")
253 if self.ui.configbool('format', 'dotencode', True):
253 if self.ui.configbool('format', 'dotencode', True):
254 self.requirements.add('dotencode')
254 self.requirements.add('dotencode')
255 # create an invalid changelog
255 # create an invalid changelog
256 self.vfs.append(
256 self.vfs.append(
257 "00changelog.i",
257 "00changelog.i",
258 '\0\0\0\2' # represents revlogv2
258 '\0\0\0\2' # represents revlogv2
259 ' dummy changelog to prevent using the old repo layout'
259 ' dummy changelog to prevent using the old repo layout'
260 )
260 )
261 # experimental config: format.generaldelta
261 # experimental config: format.generaldelta
262 if self.ui.configbool('format', 'generaldelta', False):
262 if self.ui.configbool('format', 'generaldelta', False):
263 self.requirements.add("generaldelta")
263 self.requirements.add("generaldelta")
264 if self.ui.configbool('experimental', 'treemanifest', False):
264 if self.ui.configbool('experimental', 'treemanifest', False):
265 self.requirements.add("treemanifest")
265 self.requirements.add("treemanifest")
266 if self.ui.configbool('experimental', 'manifestv2', False):
266 if self.ui.configbool('experimental', 'manifestv2', False):
267 self.requirements.add("manifestv2")
267 self.requirements.add("manifestv2")
268 else:
268 else:
269 raise error.RepoError(_("repository %s not found") % path)
269 raise error.RepoError(_("repository %s not found") % path)
270 elif create:
270 elif create:
271 raise error.RepoError(_("repository %s already exists") % path)
271 raise error.RepoError(_("repository %s already exists") % path)
272 else:
272 else:
273 try:
273 try:
274 self.requirements = scmutil.readrequires(
274 self.requirements = scmutil.readrequires(
275 self.vfs, self.supported)
275 self.vfs, self.supported)
276 except IOError as inst:
276 except IOError as inst:
277 if inst.errno != errno.ENOENT:
277 if inst.errno != errno.ENOENT:
278 raise
278 raise
279
279
280 self.sharedpath = self.path
280 self.sharedpath = self.path
281 try:
281 try:
282 vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
282 vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
283 realpath=True)
283 realpath=True)
284 s = vfs.base
284 s = vfs.base
285 if not vfs.exists():
285 if not vfs.exists():
286 raise error.RepoError(
286 raise error.RepoError(
287 _('.hg/sharedpath points to nonexistent directory %s') % s)
287 _('.hg/sharedpath points to nonexistent directory %s') % s)
288 self.sharedpath = s
288 self.sharedpath = s
289 except IOError as inst:
289 except IOError as inst:
290 if inst.errno != errno.ENOENT:
290 if inst.errno != errno.ENOENT:
291 raise
291 raise
292
292
293 self.store = store.store(
293 self.store = store.store(
294 self.requirements, self.sharedpath, scmutil.vfs)
294 self.requirements, self.sharedpath, scmutil.vfs)
295 self.spath = self.store.path
295 self.spath = self.store.path
296 self.svfs = self.store.vfs
296 self.svfs = self.store.vfs
297 self.sjoin = self.store.join
297 self.sjoin = self.store.join
298 self.vfs.createmode = self.store.createmode
298 self.vfs.createmode = self.store.createmode
299 self._applyopenerreqs()
299 self._applyopenerreqs()
300 if create:
300 if create:
301 self._writerequirements()
301 self._writerequirements()
302
302
303 self._dirstatevalidatewarned = False
303 self._dirstatevalidatewarned = False
304
304
305 self._branchcaches = {}
305 self._branchcaches = {}
306 self._revbranchcache = None
306 self._revbranchcache = None
307 self.filterpats = {}
307 self.filterpats = {}
308 self._datafilters = {}
308 self._datafilters = {}
309 self._transref = self._lockref = self._wlockref = None
309 self._transref = self._lockref = self._wlockref = None
310
310
311 # A cache for various files under .hg/ that tracks file changes,
311 # A cache for various files under .hg/ that tracks file changes,
312 # (used by the filecache decorator)
312 # (used by the filecache decorator)
313 #
313 #
314 # Maps a property name to its util.filecacheentry
314 # Maps a property name to its util.filecacheentry
315 self._filecache = {}
315 self._filecache = {}
316
316
317 # hold sets of revision to be filtered
317 # hold sets of revision to be filtered
318 # should be cleared when something might have changed the filter value:
318 # should be cleared when something might have changed the filter value:
319 # - new changesets,
319 # - new changesets,
320 # - phase change,
320 # - phase change,
321 # - new obsolescence marker,
321 # - new obsolescence marker,
322 # - working directory parent change,
322 # - working directory parent change,
323 # - bookmark changes
323 # - bookmark changes
324 self.filteredrevcache = {}
324 self.filteredrevcache = {}
325
325
326 # generic mapping between names and nodes
326 # generic mapping between names and nodes
327 self.names = namespaces.namespaces()
327 self.names = namespaces.namespaces()
328
328
329 def close(self):
329 def close(self):
330 self._writecaches()
330 self._writecaches()
331
331
332 def _writecaches(self):
332 def _writecaches(self):
333 if self._revbranchcache:
333 if self._revbranchcache:
334 self._revbranchcache.write()
334 self._revbranchcache.write()
335
335
336 def _restrictcapabilities(self, caps):
336 def _restrictcapabilities(self, caps):
337 if self.ui.configbool('experimental', 'bundle2-advertise', True):
337 if self.ui.configbool('experimental', 'bundle2-advertise', True):
338 caps = set(caps)
338 caps = set(caps)
339 capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))
339 capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))
340 caps.add('bundle2=' + urllib.quote(capsblob))
340 caps.add('bundle2=' + urllib.quote(capsblob))
341 return caps
341 return caps
342
342
343 def _applyopenerreqs(self):
343 def _applyopenerreqs(self):
344 self.svfs.options = dict((r, 1) for r in self.requirements
344 self.svfs.options = dict((r, 1) for r in self.requirements
345 if r in self.openerreqs)
345 if r in self.openerreqs)
346 # experimental config: format.chunkcachesize
346 # experimental config: format.chunkcachesize
347 chunkcachesize = self.ui.configint('format', 'chunkcachesize')
347 chunkcachesize = self.ui.configint('format', 'chunkcachesize')
348 if chunkcachesize is not None:
348 if chunkcachesize is not None:
349 self.svfs.options['chunkcachesize'] = chunkcachesize
349 self.svfs.options['chunkcachesize'] = chunkcachesize
350 # experimental config: format.maxchainlen
350 # experimental config: format.maxchainlen
351 maxchainlen = self.ui.configint('format', 'maxchainlen')
351 maxchainlen = self.ui.configint('format', 'maxchainlen')
352 if maxchainlen is not None:
352 if maxchainlen is not None:
353 self.svfs.options['maxchainlen'] = maxchainlen
353 self.svfs.options['maxchainlen'] = maxchainlen
354 # experimental config: format.manifestcachesize
354 # experimental config: format.manifestcachesize
355 manifestcachesize = self.ui.configint('format', 'manifestcachesize')
355 manifestcachesize = self.ui.configint('format', 'manifestcachesize')
356 if manifestcachesize is not None:
356 if manifestcachesize is not None:
357 self.svfs.options['manifestcachesize'] = manifestcachesize
357 self.svfs.options['manifestcachesize'] = manifestcachesize
358 # experimental config: format.aggressivemergedeltas
358 # experimental config: format.aggressivemergedeltas
359 aggressivemergedeltas = self.ui.configbool('format',
359 aggressivemergedeltas = self.ui.configbool('format',
360 'aggressivemergedeltas', False)
360 'aggressivemergedeltas', False)
361 self.svfs.options['aggressivemergedeltas'] = aggressivemergedeltas
361 self.svfs.options['aggressivemergedeltas'] = aggressivemergedeltas
362
362
363 def _writerequirements(self):
363 def _writerequirements(self):
364 scmutil.writerequires(self.vfs, self.requirements)
364 scmutil.writerequires(self.vfs, self.requirements)
365
365
366 def _checknested(self, path):
366 def _checknested(self, path):
367 """Determine if path is a legal nested repository."""
367 """Determine if path is a legal nested repository."""
368 if not path.startswith(self.root):
368 if not path.startswith(self.root):
369 return False
369 return False
370 subpath = path[len(self.root) + 1:]
370 subpath = path[len(self.root) + 1:]
371 normsubpath = util.pconvert(subpath)
371 normsubpath = util.pconvert(subpath)
372
372
373 # XXX: Checking against the current working copy is wrong in
373 # XXX: Checking against the current working copy is wrong in
374 # the sense that it can reject things like
374 # the sense that it can reject things like
375 #
375 #
376 # $ hg cat -r 10 sub/x.txt
376 # $ hg cat -r 10 sub/x.txt
377 #
377 #
378 # if sub/ is no longer a subrepository in the working copy
378 # if sub/ is no longer a subrepository in the working copy
379 # parent revision.
379 # parent revision.
380 #
380 #
381 # However, it can of course also allow things that would have
381 # However, it can of course also allow things that would have
382 # been rejected before, such as the above cat command if sub/
382 # been rejected before, such as the above cat command if sub/
383 # is a subrepository now, but was a normal directory before.
383 # is a subrepository now, but was a normal directory before.
384 # The old path auditor would have rejected by mistake since it
384 # The old path auditor would have rejected by mistake since it
385 # panics when it sees sub/.hg/.
385 # panics when it sees sub/.hg/.
386 #
386 #
387 # All in all, checking against the working copy seems sensible
387 # All in all, checking against the working copy seems sensible
388 # since we want to prevent access to nested repositories on
388 # since we want to prevent access to nested repositories on
389 # the filesystem *now*.
389 # the filesystem *now*.
390 ctx = self[None]
390 ctx = self[None]
391 parts = util.splitpath(subpath)
391 parts = util.splitpath(subpath)
392 while parts:
392 while parts:
393 prefix = '/'.join(parts)
393 prefix = '/'.join(parts)
394 if prefix in ctx.substate:
394 if prefix in ctx.substate:
395 if prefix == normsubpath:
395 if prefix == normsubpath:
396 return True
396 return True
397 else:
397 else:
398 sub = ctx.sub(prefix)
398 sub = ctx.sub(prefix)
399 return sub.checknested(subpath[len(prefix) + 1:])
399 return sub.checknested(subpath[len(prefix) + 1:])
400 else:
400 else:
401 parts.pop()
401 parts.pop()
402 return False
402 return False
403
403
404 def peer(self):
404 def peer(self):
405 return localpeer(self) # not cached to avoid reference cycle
405 return localpeer(self) # not cached to avoid reference cycle
406
406
407 def unfiltered(self):
407 def unfiltered(self):
408 """Return unfiltered version of the repository
408 """Return unfiltered version of the repository
409
409
410 Intended to be overwritten by filtered repo."""
410 Intended to be overwritten by filtered repo."""
411 return self
411 return self
412
412
413 def filtered(self, name):
413 def filtered(self, name):
414 """Return a filtered version of a repository"""
414 """Return a filtered version of a repository"""
415 # build a new class with the mixin and the current class
415 # build a new class with the mixin and the current class
416 # (possibly subclass of the repo)
416 # (possibly subclass of the repo)
417 class proxycls(repoview.repoview, self.unfiltered().__class__):
417 class proxycls(repoview.repoview, self.unfiltered().__class__):
418 pass
418 pass
419 return proxycls(self, name)
419 return proxycls(self, name)
420
420
421 @repofilecache('bookmarks')
421 @repofilecache('bookmarks')
422 def _bookmarks(self):
422 def _bookmarks(self):
423 return bookmarks.bmstore(self)
423 return bookmarks.bmstore(self)
424
424
425 @repofilecache('bookmarks.current')
425 @repofilecache('bookmarks.current')
426 def _activebookmark(self):
426 def _activebookmark(self):
427 return bookmarks.readactive(self)
427 return bookmarks.readactive(self)
428
428
429 def bookmarkheads(self, bookmark):
429 def bookmarkheads(self, bookmark):
430 name = bookmark.split('@', 1)[0]
430 name = bookmark.split('@', 1)[0]
431 heads = []
431 heads = []
432 for mark, n in self._bookmarks.iteritems():
432 for mark, n in self._bookmarks.iteritems():
433 if mark.split('@', 1)[0] == name:
433 if mark.split('@', 1)[0] == name:
434 heads.append(n)
434 heads.append(n)
435 return heads
435 return heads
436
436
437 # _phaserevs and _phasesets depend on changelog. what we need is to
437 # _phaserevs and _phasesets depend on changelog. what we need is to
438 # call _phasecache.invalidate() if '00changelog.i' was changed, but it
438 # call _phasecache.invalidate() if '00changelog.i' was changed, but it
439 # can't be easily expressed in filecache mechanism.
439 # can't be easily expressed in filecache mechanism.
440 @storecache('phaseroots', '00changelog.i')
440 @storecache('phaseroots', '00changelog.i')
441 def _phasecache(self):
441 def _phasecache(self):
442 return phases.phasecache(self, self._phasedefaults)
442 return phases.phasecache(self, self._phasedefaults)
443
443
444 @storecache('obsstore')
444 @storecache('obsstore')
445 def obsstore(self):
445 def obsstore(self):
446 # read default format for new obsstore.
446 # read default format for new obsstore.
447 # developer config: format.obsstore-version
447 # developer config: format.obsstore-version
448 defaultformat = self.ui.configint('format', 'obsstore-version', None)
448 defaultformat = self.ui.configint('format', 'obsstore-version', None)
449 # rely on obsstore class default when possible.
449 # rely on obsstore class default when possible.
450 kwargs = {}
450 kwargs = {}
451 if defaultformat is not None:
451 if defaultformat is not None:
452 kwargs['defaultformat'] = defaultformat
452 kwargs['defaultformat'] = defaultformat
453 readonly = not obsolete.isenabled(self, obsolete.createmarkersopt)
453 readonly = not obsolete.isenabled(self, obsolete.createmarkersopt)
454 store = obsolete.obsstore(self.svfs, readonly=readonly,
454 store = obsolete.obsstore(self.svfs, readonly=readonly,
455 **kwargs)
455 **kwargs)
456 if store and readonly:
456 if store and readonly:
457 self.ui.warn(
457 self.ui.warn(
458 _('obsolete feature not enabled but %i markers found!\n')
458 _('obsolete feature not enabled but %i markers found!\n')
459 % len(list(store)))
459 % len(list(store)))
460 return store
460 return store
461
461
462 @storecache('00changelog.i')
462 @storecache('00changelog.i')
463 def changelog(self):
463 def changelog(self):
464 c = changelog.changelog(self.svfs)
464 c = changelog.changelog(self.svfs)
465 if 'HG_PENDING' in os.environ:
465 if 'HG_PENDING' in os.environ:
466 p = os.environ['HG_PENDING']
466 p = os.environ['HG_PENDING']
467 if p.startswith(self.root):
467 if p.startswith(self.root):
468 c.readpending('00changelog.i.a')
468 c.readpending('00changelog.i.a')
469 return c
469 return c
470
470
471 @storecache('00manifest.i')
471 @storecache('00manifest.i')
472 def manifest(self):
472 def manifest(self):
473 return manifest.manifest(self.svfs)
473 return manifest.manifest(self.svfs)
474
474
475 def dirlog(self, dir):
475 def dirlog(self, dir):
476 return self.manifest.dirlog(dir)
476 return self.manifest.dirlog(dir)
477
477
478 @repofilecache('dirstate')
478 @repofilecache('dirstate')
479 def dirstate(self):
479 def dirstate(self):
480 return dirstate.dirstate(self.vfs, self.ui, self.root,
480 return dirstate.dirstate(self.vfs, self.ui, self.root,
481 self._dirstatevalidate)
481 self._dirstatevalidate)
482
482
483 def _dirstatevalidate(self, node):
483 def _dirstatevalidate(self, node):
484 try:
484 try:
485 self.changelog.rev(node)
485 self.changelog.rev(node)
486 return node
486 return node
487 except error.LookupError:
487 except error.LookupError:
488 if not self._dirstatevalidatewarned:
488 if not self._dirstatevalidatewarned:
489 self._dirstatevalidatewarned = True
489 self._dirstatevalidatewarned = True
490 self.ui.warn(_("warning: ignoring unknown"
490 self.ui.warn(_("warning: ignoring unknown"
491 " working parent %s!\n") % short(node))
491 " working parent %s!\n") % short(node))
492 return nullid
492 return nullid
493
493
494 def __getitem__(self, changeid):
494 def __getitem__(self, changeid):
495 if changeid is None or changeid == wdirrev:
495 if changeid is None or changeid == wdirrev:
496 return context.workingctx(self)
496 return context.workingctx(self)
497 if isinstance(changeid, slice):
497 if isinstance(changeid, slice):
498 return [context.changectx(self, i)
498 return [context.changectx(self, i)
499 for i in xrange(*changeid.indices(len(self)))
499 for i in xrange(*changeid.indices(len(self)))
500 if i not in self.changelog.filteredrevs]
500 if i not in self.changelog.filteredrevs]
501 return context.changectx(self, changeid)
501 return context.changectx(self, changeid)
502
502
503 def __contains__(self, changeid):
503 def __contains__(self, changeid):
504 try:
504 try:
505 self[changeid]
505 self[changeid]
506 return True
506 return True
507 except error.RepoLookupError:
507 except error.RepoLookupError:
508 return False
508 return False
509
509
510 def __nonzero__(self):
510 def __nonzero__(self):
511 return True
511 return True
512
512
513 def __len__(self):
513 def __len__(self):
514 return len(self.changelog)
514 return len(self.changelog)
515
515
516 def __iter__(self):
516 def __iter__(self):
517 return iter(self.changelog)
517 return iter(self.changelog)
518
518
519 def revs(self, expr, *args):
519 def revs(self, expr, *args):
520 '''Return a list of revisions matching the given revset'''
520 '''Return a list of revisions matching the given revset'''
521 expr = revset.formatspec(expr, *args)
521 expr = revset.formatspec(expr, *args)
522 m = revset.match(None, expr)
522 m = revset.match(None, expr)
523 return m(self)
523 return m(self)
524
524
525 def set(self, expr, *args):
525 def set(self, expr, *args):
526 '''
526 '''
527 Yield a context for each matching revision, after doing arg
527 Yield a context for each matching revision, after doing arg
528 replacement via revset.formatspec
528 replacement via revset.formatspec
529 '''
529 '''
530 for r in self.revs(expr, *args):
530 for r in self.revs(expr, *args):
531 yield self[r]
531 yield self[r]
532
532
533 def url(self):
533 def url(self):
534 return 'file:' + self.root
534 return 'file:' + self.root
535
535
536 def hook(self, name, throw=False, **args):
536 def hook(self, name, throw=False, **args):
537 """Call a hook, passing this repo instance.
537 """Call a hook, passing this repo instance.
538
538
539 This a convenience method to aid invoking hooks. Extensions likely
539 This a convenience method to aid invoking hooks. Extensions likely
540 won't call this unless they have registered a custom hook or are
540 won't call this unless they have registered a custom hook or are
541 replacing code that is expected to call a hook.
541 replacing code that is expected to call a hook.
542 """
542 """
543 return hook.hook(self.ui, self, name, throw, **args)
543 return hook.hook(self.ui, self, name, throw, **args)
544
544
545 @unfilteredmethod
545 @unfilteredmethod
546 def _tag(self, names, node, message, local, user, date, extra=None,
546 def _tag(self, names, node, message, local, user, date, extra=None,
547 editor=False):
547 editor=False):
548 if isinstance(names, str):
548 if isinstance(names, str):
549 names = (names,)
549 names = (names,)
550
550
551 branches = self.branchmap()
551 branches = self.branchmap()
552 for name in names:
552 for name in names:
553 self.hook('pretag', throw=True, node=hex(node), tag=name,
553 self.hook('pretag', throw=True, node=hex(node), tag=name,
554 local=local)
554 local=local)
555 if name in branches:
555 if name in branches:
556 self.ui.warn(_("warning: tag %s conflicts with existing"
556 self.ui.warn(_("warning: tag %s conflicts with existing"
557 " branch name\n") % name)
557 " branch name\n") % name)
558
558
559 def writetags(fp, names, munge, prevtags):
559 def writetags(fp, names, munge, prevtags):
560 fp.seek(0, 2)
560 fp.seek(0, 2)
561 if prevtags and prevtags[-1] != '\n':
561 if prevtags and prevtags[-1] != '\n':
562 fp.write('\n')
562 fp.write('\n')
563 for name in names:
563 for name in names:
564 if munge:
564 if munge:
565 m = munge(name)
565 m = munge(name)
566 else:
566 else:
567 m = name
567 m = name
568
568
569 if (self._tagscache.tagtypes and
569 if (self._tagscache.tagtypes and
570 name in self._tagscache.tagtypes):
570 name in self._tagscache.tagtypes):
571 old = self.tags().get(name, nullid)
571 old = self.tags().get(name, nullid)
572 fp.write('%s %s\n' % (hex(old), m))
572 fp.write('%s %s\n' % (hex(old), m))
573 fp.write('%s %s\n' % (hex(node), m))
573 fp.write('%s %s\n' % (hex(node), m))
574 fp.close()
574 fp.close()
575
575
576 prevtags = ''
576 prevtags = ''
577 if local:
577 if local:
578 try:
578 try:
579 fp = self.vfs('localtags', 'r+')
579 fp = self.vfs('localtags', 'r+')
580 except IOError:
580 except IOError:
581 fp = self.vfs('localtags', 'a')
581 fp = self.vfs('localtags', 'a')
582 else:
582 else:
583 prevtags = fp.read()
583 prevtags = fp.read()
584
584
585 # local tags are stored in the current charset
585 # local tags are stored in the current charset
586 writetags(fp, names, None, prevtags)
586 writetags(fp, names, None, prevtags)
587 for name in names:
587 for name in names:
588 self.hook('tag', node=hex(node), tag=name, local=local)
588 self.hook('tag', node=hex(node), tag=name, local=local)
589 return
589 return
590
590
591 try:
591 try:
592 fp = self.wfile('.hgtags', 'rb+')
592 fp = self.wfile('.hgtags', 'rb+')
593 except IOError as e:
593 except IOError as e:
594 if e.errno != errno.ENOENT:
594 if e.errno != errno.ENOENT:
595 raise
595 raise
596 fp = self.wfile('.hgtags', 'ab')
596 fp = self.wfile('.hgtags', 'ab')
597 else:
597 else:
598 prevtags = fp.read()
598 prevtags = fp.read()
599
599
600 # committed tags are stored in UTF-8
600 # committed tags are stored in UTF-8
601 writetags(fp, names, encoding.fromlocal, prevtags)
601 writetags(fp, names, encoding.fromlocal, prevtags)
602
602
603 fp.close()
603 fp.close()
604
604
605 self.invalidatecaches()
605 self.invalidatecaches()
606
606
607 if '.hgtags' not in self.dirstate:
607 if '.hgtags' not in self.dirstate:
608 self[None].add(['.hgtags'])
608 self[None].add(['.hgtags'])
609
609
610 m = matchmod.exact(self.root, '', ['.hgtags'])
610 m = matchmod.exact(self.root, '', ['.hgtags'])
611 tagnode = self.commit(message, user, date, extra=extra, match=m,
611 tagnode = self.commit(message, user, date, extra=extra, match=m,
612 editor=editor)
612 editor=editor)
613
613
614 for name in names:
614 for name in names:
615 self.hook('tag', node=hex(node), tag=name, local=local)
615 self.hook('tag', node=hex(node), tag=name, local=local)
616
616
617 return tagnode
617 return tagnode
618
618
619 def tag(self, names, node, message, local, user, date, editor=False):
619 def tag(self, names, node, message, local, user, date, editor=False):
620 '''tag a revision with one or more symbolic names.
620 '''tag a revision with one or more symbolic names.
621
621
622 names is a list of strings or, when adding a single tag, names may be a
622 names is a list of strings or, when adding a single tag, names may be a
623 string.
623 string.
624
624
625 if local is True, the tags are stored in a per-repository file.
625 if local is True, the tags are stored in a per-repository file.
626 otherwise, they are stored in the .hgtags file, and a new
626 otherwise, they are stored in the .hgtags file, and a new
627 changeset is committed with the change.
627 changeset is committed with the change.
628
628
629 keyword arguments:
629 keyword arguments:
630
630
631 local: whether to store tags in non-version-controlled file
631 local: whether to store tags in non-version-controlled file
632 (default False)
632 (default False)
633
633
634 message: commit message to use if committing
634 message: commit message to use if committing
635
635
636 user: name of user to use if committing
636 user: name of user to use if committing
637
637
638 date: date tuple to use if committing'''
638 date: date tuple to use if committing'''
639
639
640 if not local:
640 if not local:
641 m = matchmod.exact(self.root, '', ['.hgtags'])
641 m = matchmod.exact(self.root, '', ['.hgtags'])
642 if any(self.status(match=m, unknown=True, ignored=True)):
642 if any(self.status(match=m, unknown=True, ignored=True)):
643 raise util.Abort(_('working copy of .hgtags is changed'),
643 raise util.Abort(_('working copy of .hgtags is changed'),
644 hint=_('please commit .hgtags manually'))
644 hint=_('please commit .hgtags manually'))
645
645
646 self.tags() # instantiate the cache
646 self.tags() # instantiate the cache
647 self._tag(names, node, message, local, user, date, editor=editor)
647 self._tag(names, node, message, local, user, date, editor=editor)
648
648
649 @filteredpropertycache
649 @filteredpropertycache
650 def _tagscache(self):
650 def _tagscache(self):
651 '''Returns a tagscache object that contains various tags related
651 '''Returns a tagscache object that contains various tags related
652 caches.'''
652 caches.'''
653
653
654 # This simplifies its cache management by having one decorated
654 # This simplifies its cache management by having one decorated
655 # function (this one) and the rest simply fetch things from it.
655 # function (this one) and the rest simply fetch things from it.
656 class tagscache(object):
656 class tagscache(object):
657 def __init__(self):
657 def __init__(self):
658 # These two define the set of tags for this repository. tags
658 # These two define the set of tags for this repository. tags
659 # maps tag name to node; tagtypes maps tag name to 'global' or
659 # maps tag name to node; tagtypes maps tag name to 'global' or
660 # 'local'. (Global tags are defined by .hgtags across all
660 # 'local'. (Global tags are defined by .hgtags across all
661 # heads, and local tags are defined in .hg/localtags.)
661 # heads, and local tags are defined in .hg/localtags.)
662 # They constitute the in-memory cache of tags.
662 # They constitute the in-memory cache of tags.
663 self.tags = self.tagtypes = None
663 self.tags = self.tagtypes = None
664
664
665 self.nodetagscache = self.tagslist = None
665 self.nodetagscache = self.tagslist = None
666
666
667 cache = tagscache()
667 cache = tagscache()
668 cache.tags, cache.tagtypes = self._findtags()
668 cache.tags, cache.tagtypes = self._findtags()
669
669
670 return cache
670 return cache
671
671
672 def tags(self):
672 def tags(self):
673 '''return a mapping of tag to node'''
673 '''return a mapping of tag to node'''
674 t = {}
674 t = {}
675 if self.changelog.filteredrevs:
675 if self.changelog.filteredrevs:
676 tags, tt = self._findtags()
676 tags, tt = self._findtags()
677 else:
677 else:
678 tags = self._tagscache.tags
678 tags = self._tagscache.tags
679 for k, v in tags.iteritems():
679 for k, v in tags.iteritems():
680 try:
680 try:
681 # ignore tags to unknown nodes
681 # ignore tags to unknown nodes
682 self.changelog.rev(v)
682 self.changelog.rev(v)
683 t[k] = v
683 t[k] = v
684 except (error.LookupError, ValueError):
684 except (error.LookupError, ValueError):
685 pass
685 pass
686 return t
686 return t
687
687
688 def _findtags(self):
688 def _findtags(self):
689 '''Do the hard work of finding tags. Return a pair of dicts
689 '''Do the hard work of finding tags. Return a pair of dicts
690 (tags, tagtypes) where tags maps tag name to node, and tagtypes
690 (tags, tagtypes) where tags maps tag name to node, and tagtypes
691 maps tag name to a string like \'global\' or \'local\'.
691 maps tag name to a string like \'global\' or \'local\'.
692 Subclasses or extensions are free to add their own tags, but
692 Subclasses or extensions are free to add their own tags, but
693 should be aware that the returned dicts will be retained for the
693 should be aware that the returned dicts will be retained for the
694 duration of the localrepo object.'''
694 duration of the localrepo object.'''
695
695
696 # XXX what tagtype should subclasses/extensions use? Currently
696 # XXX what tagtype should subclasses/extensions use? Currently
697 # mq and bookmarks add tags, but do not set the tagtype at all.
697 # mq and bookmarks add tags, but do not set the tagtype at all.
698 # Should each extension invent its own tag type? Should there
698 # Should each extension invent its own tag type? Should there
699 # be one tagtype for all such "virtual" tags? Or is the status
699 # be one tagtype for all such "virtual" tags? Or is the status
700 # quo fine?
700 # quo fine?
701
701
702 alltags = {} # map tag name to (node, hist)
702 alltags = {} # map tag name to (node, hist)
703 tagtypes = {}
703 tagtypes = {}
704
704
705 tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
705 tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
706 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
706 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
707
707
708 # Build the return dicts. Have to re-encode tag names because
708 # Build the return dicts. Have to re-encode tag names because
709 # the tags module always uses UTF-8 (in order not to lose info
709 # the tags module always uses UTF-8 (in order not to lose info
710 # writing to the cache), but the rest of Mercurial wants them in
710 # writing to the cache), but the rest of Mercurial wants them in
711 # local encoding.
711 # local encoding.
712 tags = {}
712 tags = {}
713 for (name, (node, hist)) in alltags.iteritems():
713 for (name, (node, hist)) in alltags.iteritems():
714 if node != nullid:
714 if node != nullid:
715 tags[encoding.tolocal(name)] = node
715 tags[encoding.tolocal(name)] = node
716 tags['tip'] = self.changelog.tip()
716 tags['tip'] = self.changelog.tip()
717 tagtypes = dict([(encoding.tolocal(name), value)
717 tagtypes = dict([(encoding.tolocal(name), value)
718 for (name, value) in tagtypes.iteritems()])
718 for (name, value) in tagtypes.iteritems()])
719 return (tags, tagtypes)
719 return (tags, tagtypes)
720
720
721 def tagtype(self, tagname):
721 def tagtype(self, tagname):
722 '''
722 '''
723 return the type of the given tag. result can be:
723 return the type of the given tag. result can be:
724
724
725 'local' : a local tag
725 'local' : a local tag
726 'global' : a global tag
726 'global' : a global tag
727 None : tag does not exist
727 None : tag does not exist
728 '''
728 '''
729
729
730 return self._tagscache.tagtypes.get(tagname)
730 return self._tagscache.tagtypes.get(tagname)
731
731
732 def tagslist(self):
732 def tagslist(self):
733 '''return a list of tags ordered by revision'''
733 '''return a list of tags ordered by revision'''
734 if not self._tagscache.tagslist:
734 if not self._tagscache.tagslist:
735 l = []
735 l = []
736 for t, n in self.tags().iteritems():
736 for t, n in self.tags().iteritems():
737 l.append((self.changelog.rev(n), t, n))
737 l.append((self.changelog.rev(n), t, n))
738 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
738 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
739
739
740 return self._tagscache.tagslist
740 return self._tagscache.tagslist
741
741
742 def nodetags(self, node):
742 def nodetags(self, node):
743 '''return the tags associated with a node'''
743 '''return the tags associated with a node'''
744 if not self._tagscache.nodetagscache:
744 if not self._tagscache.nodetagscache:
745 nodetagscache = {}
745 nodetagscache = {}
746 for t, n in self._tagscache.tags.iteritems():
746 for t, n in self._tagscache.tags.iteritems():
747 nodetagscache.setdefault(n, []).append(t)
747 nodetagscache.setdefault(n, []).append(t)
748 for tags in nodetagscache.itervalues():
748 for tags in nodetagscache.itervalues():
749 tags.sort()
749 tags.sort()
750 self._tagscache.nodetagscache = nodetagscache
750 self._tagscache.nodetagscache = nodetagscache
751 return self._tagscache.nodetagscache.get(node, [])
751 return self._tagscache.nodetagscache.get(node, [])
752
752
753 def nodebookmarks(self, node):
753 def nodebookmarks(self, node):
754 marks = []
754 marks = []
755 for bookmark, n in self._bookmarks.iteritems():
755 for bookmark, n in self._bookmarks.iteritems():
756 if n == node:
756 if n == node:
757 marks.append(bookmark)
757 marks.append(bookmark)
758 return sorted(marks)
758 return sorted(marks)
759
759
760 def branchmap(self):
760 def branchmap(self):
761 '''returns a dictionary {branch: [branchheads]} with branchheads
761 '''returns a dictionary {branch: [branchheads]} with branchheads
762 ordered by increasing revision number'''
762 ordered by increasing revision number'''
763 branchmap.updatecache(self)
763 branchmap.updatecache(self)
764 return self._branchcaches[self.filtername]
764 return self._branchcaches[self.filtername]
765
765
766 @unfilteredmethod
766 @unfilteredmethod
767 def revbranchcache(self):
767 def revbranchcache(self):
768 if not self._revbranchcache:
768 if not self._revbranchcache:
769 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
769 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
770 return self._revbranchcache
770 return self._revbranchcache
771
771
772 def branchtip(self, branch, ignoremissing=False):
772 def branchtip(self, branch, ignoremissing=False):
773 '''return the tip node for a given branch
773 '''return the tip node for a given branch
774
774
775 If ignoremissing is True, then this method will not raise an error.
775 If ignoremissing is True, then this method will not raise an error.
776 This is helpful for callers that only expect None for a missing branch
776 This is helpful for callers that only expect None for a missing branch
777 (e.g. namespace).
777 (e.g. namespace).
778
778
779 '''
779 '''
780 try:
780 try:
781 return self.branchmap().branchtip(branch)
781 return self.branchmap().branchtip(branch)
782 except KeyError:
782 except KeyError:
783 if not ignoremissing:
783 if not ignoremissing:
784 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
784 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
785 else:
785 else:
786 pass
786 pass
787
787
788 def lookup(self, key):
788 def lookup(self, key):
789 return self[key].node()
789 return self[key].node()
790
790
791 def lookupbranch(self, key, remote=None):
791 def lookupbranch(self, key, remote=None):
792 repo = remote or self
792 repo = remote or self
793 if key in repo.branchmap():
793 if key in repo.branchmap():
794 return key
794 return key
795
795
796 repo = (remote and remote.local()) and remote or self
796 repo = (remote and remote.local()) and remote or self
797 return repo[key].branch()
797 return repo[key].branch()
798
798
799 def known(self, nodes):
799 def known(self, nodes):
800 nm = self.changelog.nodemap
800 nm = self.changelog.nodemap
801 pc = self._phasecache
801 pc = self._phasecache
802 result = []
802 result = []
803 for n in nodes:
803 for n in nodes:
804 r = nm.get(n)
804 r = nm.get(n)
805 resp = not (r is None or pc.phase(self, r) >= phases.secret)
805 resp = not (r is None or pc.phase(self, r) >= phases.secret)
806 result.append(resp)
806 result.append(resp)
807 return result
807 return result
808
808
809 def local(self):
809 def local(self):
810 return self
810 return self
811
811
812 def publishing(self):
812 def publishing(self):
813 # it's safe (and desirable) to trust the publish flag unconditionally
813 # it's safe (and desirable) to trust the publish flag unconditionally
814 # so that we don't finalize changes shared between users via ssh or nfs
814 # so that we don't finalize changes shared between users via ssh or nfs
815 return self.ui.configbool('phases', 'publish', True, untrusted=True)
815 return self.ui.configbool('phases', 'publish', True, untrusted=True)
816
816
817 def cancopy(self):
817 def cancopy(self):
818 # so statichttprepo's override of local() works
818 # so statichttprepo's override of local() works
819 if not self.local():
819 if not self.local():
820 return False
820 return False
821 if not self.publishing():
821 if not self.publishing():
822 return True
822 return True
823 # if publishing we can't copy if there is filtered content
823 # if publishing we can't copy if there is filtered content
824 return not self.filtered('visible').changelog.filteredrevs
824 return not self.filtered('visible').changelog.filteredrevs
825
825
826 def shared(self):
826 def shared(self):
827 '''the type of shared repository (None if not shared)'''
827 '''the type of shared repository (None if not shared)'''
828 if self.sharedpath != self.path:
828 if self.sharedpath != self.path:
829 return 'store'
829 return 'store'
830 return None
830 return None
831
831
832 def join(self, f, *insidef):
832 def join(self, f, *insidef):
833 return self.vfs.join(os.path.join(f, *insidef))
833 return self.vfs.join(os.path.join(f, *insidef))
834
834
835 def wjoin(self, f, *insidef):
835 def wjoin(self, f, *insidef):
836 return self.vfs.reljoin(self.root, f, *insidef)
836 return self.vfs.reljoin(self.root, f, *insidef)
837
837
838 def file(self, f):
838 def file(self, f):
839 if f[0] == '/':
839 if f[0] == '/':
840 f = f[1:]
840 f = f[1:]
841 return filelog.filelog(self.svfs, f)
841 return filelog.filelog(self.svfs, f)
842
842
843 def changectx(self, changeid):
843 def changectx(self, changeid):
844 return self[changeid]
844 return self[changeid]
845
845
846 def parents(self, changeid=None):
846 def parents(self, changeid=None):
847 '''get list of changectxs for parents of changeid'''
847 '''get list of changectxs for parents of changeid'''
848 return self[changeid].parents()
848 return self[changeid].parents()
849
849
850 def setparents(self, p1, p2=nullid):
850 def setparents(self, p1, p2=nullid):
851 self.dirstate.beginparentchange()
851 self.dirstate.beginparentchange()
852 copies = self.dirstate.setparents(p1, p2)
852 copies = self.dirstate.setparents(p1, p2)
853 pctx = self[p1]
853 pctx = self[p1]
854 if copies:
854 if copies:
855 # Adjust copy records, the dirstate cannot do it, it
855 # Adjust copy records, the dirstate cannot do it, it
856 # requires access to parents manifests. Preserve them
856 # requires access to parents manifests. Preserve them
857 # only for entries added to first parent.
857 # only for entries added to first parent.
858 for f in copies:
858 for f in copies:
859 if f not in pctx and copies[f] in pctx:
859 if f not in pctx and copies[f] in pctx:
860 self.dirstate.copy(copies[f], f)
860 self.dirstate.copy(copies[f], f)
861 if p2 == nullid:
861 if p2 == nullid:
862 for f, s in sorted(self.dirstate.copies().items()):
862 for f, s in sorted(self.dirstate.copies().items()):
863 if f not in pctx and s not in pctx:
863 if f not in pctx and s not in pctx:
864 self.dirstate.copy(None, f)
864 self.dirstate.copy(None, f)
865 self.dirstate.endparentchange()
865 self.dirstate.endparentchange()
866
866
867 def filectx(self, path, changeid=None, fileid=None):
867 def filectx(self, path, changeid=None, fileid=None):
868 """changeid can be a changeset revision, node, or tag.
868 """changeid can be a changeset revision, node, or tag.
869 fileid can be a file revision or node."""
869 fileid can be a file revision or node."""
870 return context.filectx(self, path, changeid, fileid)
870 return context.filectx(self, path, changeid, fileid)
871
871
872 def getcwd(self):
872 def getcwd(self):
873 return self.dirstate.getcwd()
873 return self.dirstate.getcwd()
874
874
875 def pathto(self, f, cwd=None):
875 def pathto(self, f, cwd=None):
876 return self.dirstate.pathto(f, cwd)
876 return self.dirstate.pathto(f, cwd)
877
877
878 def wfile(self, f, mode='r'):
878 def wfile(self, f, mode='r'):
879 return self.wvfs(f, mode)
879 return self.wvfs(f, mode)
880
880
881 def _link(self, f):
881 def _link(self, f):
882 return self.wvfs.islink(f)
882 return self.wvfs.islink(f)
883
883
884 def _loadfilter(self, filter):
884 def _loadfilter(self, filter):
885 if filter not in self.filterpats:
885 if filter not in self.filterpats:
886 l = []
886 l = []
887 for pat, cmd in self.ui.configitems(filter):
887 for pat, cmd in self.ui.configitems(filter):
888 if cmd == '!':
888 if cmd == '!':
889 continue
889 continue
890 mf = matchmod.match(self.root, '', [pat])
890 mf = matchmod.match(self.root, '', [pat])
891 fn = None
891 fn = None
892 params = cmd
892 params = cmd
893 for name, filterfn in self._datafilters.iteritems():
893 for name, filterfn in self._datafilters.iteritems():
894 if cmd.startswith(name):
894 if cmd.startswith(name):
895 fn = filterfn
895 fn = filterfn
896 params = cmd[len(name):].lstrip()
896 params = cmd[len(name):].lstrip()
897 break
897 break
898 if not fn:
898 if not fn:
899 fn = lambda s, c, **kwargs: util.filter(s, c)
899 fn = lambda s, c, **kwargs: util.filter(s, c)
900 # Wrap old filters not supporting keyword arguments
900 # Wrap old filters not supporting keyword arguments
901 if not inspect.getargspec(fn)[2]:
901 if not inspect.getargspec(fn)[2]:
902 oldfn = fn
902 oldfn = fn
903 fn = lambda s, c, **kwargs: oldfn(s, c)
903 fn = lambda s, c, **kwargs: oldfn(s, c)
904 l.append((mf, fn, params))
904 l.append((mf, fn, params))
905 self.filterpats[filter] = l
905 self.filterpats[filter] = l
906 return self.filterpats[filter]
906 return self.filterpats[filter]
907
907
908 def _filter(self, filterpats, filename, data):
908 def _filter(self, filterpats, filename, data):
909 for mf, fn, cmd in filterpats:
909 for mf, fn, cmd in filterpats:
910 if mf(filename):
910 if mf(filename):
911 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
911 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
912 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
912 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
913 break
913 break
914
914
915 return data
915 return data
916
916
917 @unfilteredpropertycache
917 @unfilteredpropertycache
918 def _encodefilterpats(self):
918 def _encodefilterpats(self):
919 return self._loadfilter('encode')
919 return self._loadfilter('encode')
920
920
921 @unfilteredpropertycache
921 @unfilteredpropertycache
922 def _decodefilterpats(self):
922 def _decodefilterpats(self):
923 return self._loadfilter('decode')
923 return self._loadfilter('decode')
924
924
925 def adddatafilter(self, name, filter):
925 def adddatafilter(self, name, filter):
926 self._datafilters[name] = filter
926 self._datafilters[name] = filter
927
927
928 def wread(self, filename):
928 def wread(self, filename):
929 if self._link(filename):
929 if self._link(filename):
930 data = self.wvfs.readlink(filename)
930 data = self.wvfs.readlink(filename)
931 else:
931 else:
932 data = self.wvfs.read(filename)
932 data = self.wvfs.read(filename)
933 return self._filter(self._encodefilterpats, filename, data)
933 return self._filter(self._encodefilterpats, filename, data)
934
934
935 def wwrite(self, filename, data, flags):
935 def wwrite(self, filename, data, flags):
936 """write ``data`` into ``filename`` in the working directory
936 """write ``data`` into ``filename`` in the working directory
937
937
938 This returns length of written (maybe decoded) data.
938 This returns length of written (maybe decoded) data.
939 """
939 """
940 data = self._filter(self._decodefilterpats, filename, data)
940 data = self._filter(self._decodefilterpats, filename, data)
941 if 'l' in flags:
941 if 'l' in flags:
942 self.wvfs.symlink(data, filename)
942 self.wvfs.symlink(data, filename)
943 else:
943 else:
944 self.wvfs.write(filename, data)
944 self.wvfs.write(filename, data)
945 if 'x' in flags:
945 if 'x' in flags:
946 self.wvfs.setflags(filename, False, True)
946 self.wvfs.setflags(filename, False, True)
947 return len(data)
947 return len(data)
948
948
949 def wwritedata(self, filename, data):
949 def wwritedata(self, filename, data):
950 return self._filter(self._decodefilterpats, filename, data)
950 return self._filter(self._decodefilterpats, filename, data)
951
951
952 def currenttransaction(self):
952 def currenttransaction(self):
953 """return the current transaction or None if non exists"""
953 """return the current transaction or None if non exists"""
954 if self._transref:
954 if self._transref:
955 tr = self._transref()
955 tr = self._transref()
956 else:
956 else:
957 tr = None
957 tr = None
958
958
959 if tr and tr.running():
959 if tr and tr.running():
960 return tr
960 return tr
961 return None
961 return None
962
962
963 def transaction(self, desc, report=None):
963 def transaction(self, desc, report=None):
964 if (self.ui.configbool('devel', 'all-warnings')
964 if (self.ui.configbool('devel', 'all-warnings')
965 or self.ui.configbool('devel', 'check-locks')):
965 or self.ui.configbool('devel', 'check-locks')):
966 l = self._lockref and self._lockref()
966 l = self._lockref and self._lockref()
967 if l is None or not l.held:
967 if l is None or not l.held:
968 self.ui.develwarn('transaction with no lock')
968 self.ui.develwarn('transaction with no lock')
969 tr = self.currenttransaction()
969 tr = self.currenttransaction()
970 if tr is not None:
970 if tr is not None:
971 return tr.nest()
971 return tr.nest()
972
972
973 # abort here if the journal already exists
973 # abort here if the journal already exists
974 if self.svfs.exists("journal"):
974 if self.svfs.exists("journal"):
975 raise error.RepoError(
975 raise error.RepoError(
976 _("abandoned transaction found"),
976 _("abandoned transaction found"),
977 hint=_("run 'hg recover' to clean up transaction"))
977 hint=_("run 'hg recover' to clean up transaction"))
978
978
979 # make journal.dirstate contain in-memory changes at this point
979 # make journal.dirstate contain in-memory changes at this point
980 self.dirstate.write()
980 self.dirstate.write()
981
981
982 idbase = "%.40f#%f" % (random.random(), time.time())
982 idbase = "%.40f#%f" % (random.random(), time.time())
983 txnid = 'TXN:' + util.sha1(idbase).hexdigest()
983 txnid = 'TXN:' + util.sha1(idbase).hexdigest()
984 self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
984 self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
985
985
986 self._writejournal(desc)
986 self._writejournal(desc)
987 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
987 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
988 if report:
988 if report:
989 rp = report
989 rp = report
990 else:
990 else:
991 rp = self.ui.warn
991 rp = self.ui.warn
992 vfsmap = {'plain': self.vfs} # root of .hg/
992 vfsmap = {'plain': self.vfs} # root of .hg/
993 # we must avoid cyclic reference between repo and transaction.
993 # we must avoid cyclic reference between repo and transaction.
994 reporef = weakref.ref(self)
994 reporef = weakref.ref(self)
995 def validate(tr):
995 def validate(tr):
996 """will run pre-closing hooks"""
996 """will run pre-closing hooks"""
997 pending = lambda: tr.writepending() and self.root or ""
997 pending = lambda: tr.writepending() and self.root or ""
998 reporef().hook('pretxnclose', throw=True, pending=pending,
998 reporef().hook('pretxnclose', throw=True, pending=pending,
999 txnname=desc, **tr.hookargs)
999 txnname=desc, **tr.hookargs)
1000
1000
1001 tr = transaction.transaction(rp, self.svfs, vfsmap,
1001 tr = transaction.transaction(rp, self.svfs, vfsmap,
1002 "journal",
1002 "journal",
1003 "undo",
1003 "undo",
1004 aftertrans(renames),
1004 aftertrans(renames),
1005 self.store.createmode,
1005 self.store.createmode,
1006 validator=validate)
1006 validator=validate)
1007
1007
1008 tr.hookargs['txnid'] = txnid
1008 tr.hookargs['txnid'] = txnid
1009 # note: writing the fncache only during finalize mean that the file is
1009 # note: writing the fncache only during finalize mean that the file is
1010 # outdated when running hooks. As fncache is used for streaming clone,
1010 # outdated when running hooks. As fncache is used for streaming clone,
1011 # this is not expected to break anything that happen during the hooks.
1011 # this is not expected to break anything that happen during the hooks.
1012 tr.addfinalize('flush-fncache', self.store.write)
1012 tr.addfinalize('flush-fncache', self.store.write)
1013 def txnclosehook(tr2):
1013 def txnclosehook(tr2):
1014 """To be run if transaction is successful, will schedule a hook run
1014 """To be run if transaction is successful, will schedule a hook run
1015 """
1015 """
1016 def hook():
1016 def hook():
1017 reporef().hook('txnclose', throw=False, txnname=desc,
1017 reporef().hook('txnclose', throw=False, txnname=desc,
1018 **tr2.hookargs)
1018 **tr2.hookargs)
1019 reporef()._afterlock(hook)
1019 reporef()._afterlock(hook)
1020 tr.addfinalize('txnclose-hook', txnclosehook)
1020 tr.addfinalize('txnclose-hook', txnclosehook)
1021 def txnaborthook(tr2):
1021 def txnaborthook(tr2):
1022 """To be run if transaction is aborted
1022 """To be run if transaction is aborted
1023 """
1023 """
1024 reporef().hook('txnabort', throw=False, txnname=desc,
1024 reporef().hook('txnabort', throw=False, txnname=desc,
1025 **tr2.hookargs)
1025 **tr2.hookargs)
1026 tr.addabort('txnabort-hook', txnaborthook)
1026 tr.addabort('txnabort-hook', txnaborthook)
1027 # avoid eager cache invalidation. in-memory data should be identical
1027 # avoid eager cache invalidation. in-memory data should be identical
1028 # to stored data if transaction has no error.
1028 # to stored data if transaction has no error.
1029 tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
1029 tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
1030 self._transref = weakref.ref(tr)
1030 self._transref = weakref.ref(tr)
1031 return tr
1031 return tr
1032
1032
1033 def _journalfiles(self):
1033 def _journalfiles(self):
1034 return ((self.svfs, 'journal'),
1034 return ((self.svfs, 'journal'),
1035 (self.vfs, 'journal.dirstate'),
1035 (self.vfs, 'journal.dirstate'),
1036 (self.vfs, 'journal.branch'),
1036 (self.vfs, 'journal.branch'),
1037 (self.vfs, 'journal.desc'),
1037 (self.vfs, 'journal.desc'),
1038 (self.vfs, 'journal.bookmarks'),
1038 (self.vfs, 'journal.bookmarks'),
1039 (self.svfs, 'journal.phaseroots'))
1039 (self.svfs, 'journal.phaseroots'))
1040
1040
1041 def undofiles(self):
1041 def undofiles(self):
1042 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
1042 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
1043
1043
1044 def _writejournal(self, desc):
1044 def _writejournal(self, desc):
1045 self.vfs.write("journal.dirstate",
1045 self.vfs.write("journal.dirstate",
1046 self.vfs.tryread("dirstate"))
1046 self.vfs.tryread("dirstate"))
1047 self.vfs.write("journal.branch",
1047 self.vfs.write("journal.branch",
1048 encoding.fromlocal(self.dirstate.branch()))
1048 encoding.fromlocal(self.dirstate.branch()))
1049 self.vfs.write("journal.desc",
1049 self.vfs.write("journal.desc",
1050 "%d\n%s\n" % (len(self), desc))
1050 "%d\n%s\n" % (len(self), desc))
1051 self.vfs.write("journal.bookmarks",
1051 self.vfs.write("journal.bookmarks",
1052 self.vfs.tryread("bookmarks"))
1052 self.vfs.tryread("bookmarks"))
1053 self.svfs.write("journal.phaseroots",
1053 self.svfs.write("journal.phaseroots",
1054 self.svfs.tryread("phaseroots"))
1054 self.svfs.tryread("phaseroots"))
1055
1055
1056 def recover(self):
1056 def recover(self):
1057 lock = self.lock()
1057 lock = self.lock()
1058 try:
1058 try:
1059 if self.svfs.exists("journal"):
1059 if self.svfs.exists("journal"):
1060 self.ui.status(_("rolling back interrupted transaction\n"))
1060 self.ui.status(_("rolling back interrupted transaction\n"))
1061 vfsmap = {'': self.svfs,
1061 vfsmap = {'': self.svfs,
1062 'plain': self.vfs,}
1062 'plain': self.vfs,}
1063 transaction.rollback(self.svfs, vfsmap, "journal",
1063 transaction.rollback(self.svfs, vfsmap, "journal",
1064 self.ui.warn)
1064 self.ui.warn)
1065 self.invalidate()
1065 self.invalidate()
1066 return True
1066 return True
1067 else:
1067 else:
1068 self.ui.warn(_("no interrupted transaction available\n"))
1068 self.ui.warn(_("no interrupted transaction available\n"))
1069 return False
1069 return False
1070 finally:
1070 finally:
1071 lock.release()
1071 lock.release()
1072
1072
1073 def rollback(self, dryrun=False, force=False):
1073 def rollback(self, dryrun=False, force=False):
1074 wlock = lock = None
1074 wlock = lock = None
1075 try:
1075 try:
1076 wlock = self.wlock()
1076 wlock = self.wlock()
1077 lock = self.lock()
1077 lock = self.lock()
1078 if self.svfs.exists("undo"):
1078 if self.svfs.exists("undo"):
1079 return self._rollback(dryrun, force)
1079 return self._rollback(dryrun, force)
1080 else:
1080 else:
1081 self.ui.warn(_("no rollback information available\n"))
1081 self.ui.warn(_("no rollback information available\n"))
1082 return 1
1082 return 1
1083 finally:
1083 finally:
1084 release(lock, wlock)
1084 release(lock, wlock)
1085
1085
1086 @unfilteredmethod # Until we get smarter cache management
1086 @unfilteredmethod # Until we get smarter cache management
1087 def _rollback(self, dryrun, force):
1087 def _rollback(self, dryrun, force):
1088 ui = self.ui
1088 ui = self.ui
1089 try:
1089 try:
1090 args = self.vfs.read('undo.desc').splitlines()
1090 args = self.vfs.read('undo.desc').splitlines()
1091 (oldlen, desc, detail) = (int(args[0]), args[1], None)
1091 (oldlen, desc, detail) = (int(args[0]), args[1], None)
1092 if len(args) >= 3:
1092 if len(args) >= 3:
1093 detail = args[2]
1093 detail = args[2]
1094 oldtip = oldlen - 1
1094 oldtip = oldlen - 1
1095
1095
1096 if detail and ui.verbose:
1096 if detail and ui.verbose:
1097 msg = (_('repository tip rolled back to revision %s'
1097 msg = (_('repository tip rolled back to revision %s'
1098 ' (undo %s: %s)\n')
1098 ' (undo %s: %s)\n')
1099 % (oldtip, desc, detail))
1099 % (oldtip, desc, detail))
1100 else:
1100 else:
1101 msg = (_('repository tip rolled back to revision %s'
1101 msg = (_('repository tip rolled back to revision %s'
1102 ' (undo %s)\n')
1102 ' (undo %s)\n')
1103 % (oldtip, desc))
1103 % (oldtip, desc))
1104 except IOError:
1104 except IOError:
1105 msg = _('rolling back unknown transaction\n')
1105 msg = _('rolling back unknown transaction\n')
1106 desc = None
1106 desc = None
1107
1107
1108 if not force and self['.'] != self['tip'] and desc == 'commit':
1108 if not force and self['.'] != self['tip'] and desc == 'commit':
1109 raise util.Abort(
1109 raise util.Abort(
1110 _('rollback of last commit while not checked out '
1110 _('rollback of last commit while not checked out '
1111 'may lose data'), hint=_('use -f to force'))
1111 'may lose data'), hint=_('use -f to force'))
1112
1112
1113 ui.status(msg)
1113 ui.status(msg)
1114 if dryrun:
1114 if dryrun:
1115 return 0
1115 return 0
1116
1116
1117 parents = self.dirstate.parents()
1117 parents = self.dirstate.parents()
1118 self.destroying()
1118 self.destroying()
1119 vfsmap = {'plain': self.vfs, '': self.svfs}
1119 vfsmap = {'plain': self.vfs, '': self.svfs}
1120 transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn)
1120 transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn)
1121 if self.vfs.exists('undo.bookmarks'):
1121 if self.vfs.exists('undo.bookmarks'):
1122 self.vfs.rename('undo.bookmarks', 'bookmarks')
1122 self.vfs.rename('undo.bookmarks', 'bookmarks')
1123 if self.svfs.exists('undo.phaseroots'):
1123 if self.svfs.exists('undo.phaseroots'):
1124 self.svfs.rename('undo.phaseroots', 'phaseroots')
1124 self.svfs.rename('undo.phaseroots', 'phaseroots')
1125 self.invalidate()
1125 self.invalidate()
1126
1126
1127 parentgone = (parents[0] not in self.changelog.nodemap or
1127 parentgone = (parents[0] not in self.changelog.nodemap or
1128 parents[1] not in self.changelog.nodemap)
1128 parents[1] not in self.changelog.nodemap)
1129 if parentgone:
1129 if parentgone:
1130 self.vfs.rename('undo.dirstate', 'dirstate')
1130 self.vfs.rename('undo.dirstate', 'dirstate')
1131 try:
1131 try:
1132 branch = self.vfs.read('undo.branch')
1132 branch = self.vfs.read('undo.branch')
1133 self.dirstate.setbranch(encoding.tolocal(branch))
1133 self.dirstate.setbranch(encoding.tolocal(branch))
1134 except IOError:
1134 except IOError:
1135 ui.warn(_('named branch could not be reset: '
1135 ui.warn(_('named branch could not be reset: '
1136 'current branch is still \'%s\'\n')
1136 'current branch is still \'%s\'\n')
1137 % self.dirstate.branch())
1137 % self.dirstate.branch())
1138
1138
1139 self.dirstate.invalidate()
1139 self.dirstate.invalidate()
1140 parents = tuple([p.rev() for p in self.parents()])
1140 parents = tuple([p.rev() for p in self.parents()])
1141 if len(parents) > 1:
1141 if len(parents) > 1:
1142 ui.status(_('working directory now based on '
1142 ui.status(_('working directory now based on '
1143 'revisions %d and %d\n') % parents)
1143 'revisions %d and %d\n') % parents)
1144 else:
1144 else:
1145 ui.status(_('working directory now based on '
1145 ui.status(_('working directory now based on '
1146 'revision %d\n') % parents)
1146 'revision %d\n') % parents)
1147 ms = mergemod.mergestate(self)
1147 ms = mergemod.mergestate(self)
1148 ms.reset(self['.'].node())
1148 ms.reset(self['.'].node())
1149
1149
1150 # TODO: if we know which new heads may result from this rollback, pass
1150 # TODO: if we know which new heads may result from this rollback, pass
1151 # them to destroy(), which will prevent the branchhead cache from being
1151 # them to destroy(), which will prevent the branchhead cache from being
1152 # invalidated.
1152 # invalidated.
1153 self.destroyed()
1153 self.destroyed()
1154 return 0
1154 return 0
1155
1155
1156 def invalidatecaches(self):
1156 def invalidatecaches(self):
1157
1157
1158 if '_tagscache' in vars(self):
1158 if '_tagscache' in vars(self):
1159 # can't use delattr on proxy
1159 # can't use delattr on proxy
1160 del self.__dict__['_tagscache']
1160 del self.__dict__['_tagscache']
1161
1161
1162 self.unfiltered()._branchcaches.clear()
1162 self.unfiltered()._branchcaches.clear()
1163 self.invalidatevolatilesets()
1163 self.invalidatevolatilesets()
1164
1164
1165 def invalidatevolatilesets(self):
1165 def invalidatevolatilesets(self):
1166 self.filteredrevcache.clear()
1166 self.filteredrevcache.clear()
1167 obsolete.clearobscaches(self)
1167 obsolete.clearobscaches(self)
1168
1168
1169 def invalidatedirstate(self):
1169 def invalidatedirstate(self):
1170 '''Invalidates the dirstate, causing the next call to dirstate
1170 '''Invalidates the dirstate, causing the next call to dirstate
1171 to check if it was modified since the last time it was read,
1171 to check if it was modified since the last time it was read,
1172 rereading it if it has.
1172 rereading it if it has.
1173
1173
1174 This is different to dirstate.invalidate() that it doesn't always
1174 This is different to dirstate.invalidate() that it doesn't always
1175 rereads the dirstate. Use dirstate.invalidate() if you want to
1175 rereads the dirstate. Use dirstate.invalidate() if you want to
1176 explicitly read the dirstate again (i.e. restoring it to a previous
1176 explicitly read the dirstate again (i.e. restoring it to a previous
1177 known good state).'''
1177 known good state).'''
1178 if hasunfilteredcache(self, 'dirstate'):
1178 if hasunfilteredcache(self, 'dirstate'):
1179 for k in self.dirstate._filecache:
1179 for k in self.dirstate._filecache:
1180 try:
1180 try:
1181 delattr(self.dirstate, k)
1181 delattr(self.dirstate, k)
1182 except AttributeError:
1182 except AttributeError:
1183 pass
1183 pass
1184 delattr(self.unfiltered(), 'dirstate')
1184 delattr(self.unfiltered(), 'dirstate')
1185
1185
1186 def invalidate(self):
1186 def invalidate(self):
1187 unfiltered = self.unfiltered() # all file caches are stored unfiltered
1187 unfiltered = self.unfiltered() # all file caches are stored unfiltered
1188 for k in self._filecache:
1188 for k in self._filecache:
1189 # dirstate is invalidated separately in invalidatedirstate()
1189 # dirstate is invalidated separately in invalidatedirstate()
1190 if k == 'dirstate':
1190 if k == 'dirstate':
1191 continue
1191 continue
1192
1192
1193 try:
1193 try:
1194 delattr(unfiltered, k)
1194 delattr(unfiltered, k)
1195 except AttributeError:
1195 except AttributeError:
1196 pass
1196 pass
1197 self.invalidatecaches()
1197 self.invalidatecaches()
1198 self.store.invalidatecaches()
1198 self.store.invalidatecaches()
1199
1199
1200 def invalidateall(self):
1200 def invalidateall(self):
1201 '''Fully invalidates both store and non-store parts, causing the
1201 '''Fully invalidates both store and non-store parts, causing the
1202 subsequent operation to reread any outside changes.'''
1202 subsequent operation to reread any outside changes.'''
1203 # extension should hook this to invalidate its caches
1203 # extension should hook this to invalidate its caches
1204 self.invalidate()
1204 self.invalidate()
1205 self.invalidatedirstate()
1205 self.invalidatedirstate()
1206
1206
1207 def _refreshfilecachestats(self, tr):
1207 def _refreshfilecachestats(self, tr):
1208 """Reload stats of cached files so that they are flagged as valid"""
1208 """Reload stats of cached files so that they are flagged as valid"""
1209 for k, ce in self._filecache.items():
1209 for k, ce in self._filecache.items():
1210 if k == 'dirstate' or k not in self.__dict__:
1210 if k == 'dirstate' or k not in self.__dict__:
1211 continue
1211 continue
1212 ce.refresh()
1212 ce.refresh()
1213
1213
1214 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
1214 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
1215 parentenvvar=None):
1215 parentenvvar=None):
1216 parentlock = None
1216 parentlock = None
1217 # the contents of parentenvvar are used by the underlying lock to
1217 # the contents of parentenvvar are used by the underlying lock to
1218 # determine whether it can be inherited
1218 # determine whether it can be inherited
1219 if parentenvvar is not None:
1219 if parentenvvar is not None:
1220 parentlock = os.environ.get(parentenvvar)
1220 parentlock = os.environ.get(parentenvvar)
1221 try:
1221 try:
1222 l = lockmod.lock(vfs, lockname, 0, releasefn=releasefn,
1222 l = lockmod.lock(vfs, lockname, 0, releasefn=releasefn,
1223 acquirefn=acquirefn, desc=desc,
1223 acquirefn=acquirefn, desc=desc,
1224 parentlock=parentlock)
1224 parentlock=parentlock)
1225 except error.LockHeld as inst:
1225 except error.LockHeld as inst:
1226 if not wait:
1226 if not wait:
1227 raise
1227 raise
1228 self.ui.warn(_("waiting for lock on %s held by %r\n") %
1228 self.ui.warn(_("waiting for lock on %s held by %r\n") %
1229 (desc, inst.locker))
1229 (desc, inst.locker))
1230 # default to 600 seconds timeout
1230 # default to 600 seconds timeout
1231 l = lockmod.lock(vfs, lockname,
1231 l = lockmod.lock(vfs, lockname,
1232 int(self.ui.config("ui", "timeout", "600")),
1232 int(self.ui.config("ui", "timeout", "600")),
1233 releasefn=releasefn, acquirefn=acquirefn,
1233 releasefn=releasefn, acquirefn=acquirefn,
1234 desc=desc)
1234 desc=desc)
1235 self.ui.warn(_("got lock after %s seconds\n") % l.delay)
1235 self.ui.warn(_("got lock after %s seconds\n") % l.delay)
1236 return l
1236 return l
1237
1237
1238 def _afterlock(self, callback):
1238 def _afterlock(self, callback):
1239 """add a callback to be run when the repository is fully unlocked
1239 """add a callback to be run when the repository is fully unlocked
1240
1240
1241 The callback will be executed when the outermost lock is released
1241 The callback will be executed when the outermost lock is released
1242 (with wlock being higher level than 'lock')."""
1242 (with wlock being higher level than 'lock')."""
1243 for ref in (self._wlockref, self._lockref):
1243 for ref in (self._wlockref, self._lockref):
1244 l = ref and ref()
1244 l = ref and ref()
1245 if l and l.held:
1245 if l and l.held:
1246 l.postrelease.append(callback)
1246 l.postrelease.append(callback)
1247 break
1247 break
1248 else: # no lock have been found.
1248 else: # no lock have been found.
1249 callback()
1249 callback()
1250
1250
1251 def lock(self, wait=True):
1251 def lock(self, wait=True):
1252 '''Lock the repository store (.hg/store) and return a weak reference
1252 '''Lock the repository store (.hg/store) and return a weak reference
1253 to the lock. Use this before modifying the store (e.g. committing or
1253 to the lock. Use this before modifying the store (e.g. committing or
1254 stripping). If you are opening a transaction, get a lock as well.)
1254 stripping). If you are opening a transaction, get a lock as well.)
1255
1255
1256 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1256 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1257 'wlock' first to avoid a dead-lock hazard.'''
1257 'wlock' first to avoid a dead-lock hazard.'''
1258 l = self._lockref and self._lockref()
1258 l = self._lockref and self._lockref()
1259 if l is not None and l.held:
1259 if l is not None and l.held:
1260 l.lock()
1260 l.lock()
1261 return l
1261 return l
1262
1262
1263 l = self._lock(self.svfs, "lock", wait, None,
1263 l = self._lock(self.svfs, "lock", wait, None,
1264 self.invalidate, _('repository %s') % self.origroot)
1264 self.invalidate, _('repository %s') % self.origroot)
1265 self._lockref = weakref.ref(l)
1265 self._lockref = weakref.ref(l)
1266 return l
1266 return l
1267
1267
1268 def wlock(self, wait=True):
1268 def wlock(self, wait=True):
1269 '''Lock the non-store parts of the repository (everything under
1269 '''Lock the non-store parts of the repository (everything under
1270 .hg except .hg/store) and return a weak reference to the lock.
1270 .hg except .hg/store) and return a weak reference to the lock.
1271
1271
1272 Use this before modifying files in .hg.
1272 Use this before modifying files in .hg.
1273
1273
1274 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1274 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1275 'wlock' first to avoid a dead-lock hazard.'''
1275 'wlock' first to avoid a dead-lock hazard.'''
1276 l = self._wlockref and self._wlockref()
1276 l = self._wlockref and self._wlockref()
1277 if l is not None and l.held:
1277 if l is not None and l.held:
1278 l.lock()
1278 l.lock()
1279 return l
1279 return l
1280
1280
1281 # We do not need to check for non-waiting lock aquisition. Such
1281 # We do not need to check for non-waiting lock aquisition. Such
1282 # acquisition would not cause dead-lock as they would just fail.
1282 # acquisition would not cause dead-lock as they would just fail.
1283 if wait and (self.ui.configbool('devel', 'all-warnings')
1283 if wait and (self.ui.configbool('devel', 'all-warnings')
1284 or self.ui.configbool('devel', 'check-locks')):
1284 or self.ui.configbool('devel', 'check-locks')):
1285 l = self._lockref and self._lockref()
1285 l = self._lockref and self._lockref()
1286 if l is not None and l.held:
1286 if l is not None and l.held:
1287 self.ui.develwarn('"wlock" acquired after "lock"')
1287 self.ui.develwarn('"wlock" acquired after "lock"')
1288
1288
1289 def unlock():
1289 def unlock():
1290 if self.dirstate.pendingparentchange():
1290 if self.dirstate.pendingparentchange():
1291 self.dirstate.invalidate()
1291 self.dirstate.invalidate()
1292 else:
1292 else:
1293 self.dirstate.write()
1293 self.dirstate.write()
1294
1294
1295 self._filecache['dirstate'].refresh()
1295 self._filecache['dirstate'].refresh()
1296
1296
1297 l = self._lock(self.vfs, "wlock", wait, unlock,
1297 l = self._lock(self.vfs, "wlock", wait, unlock,
1298 self.invalidatedirstate, _('working directory of %s') %
1298 self.invalidatedirstate, _('working directory of %s') %
1299 self.origroot, parentenvvar='HG_WLOCK_LOCKER')
1299 self.origroot, parentenvvar='HG_WLOCK_LOCKER')
1300 self._wlockref = weakref.ref(l)
1300 self._wlockref = weakref.ref(l)
1301 return l
1301 return l
1302
1302
1303 def _currentlock(self, lockref):
1304 """Returns the lock if it's held, or None if it's not."""
1305 if lockref is None:
1306 return None
1307 l = lockref()
1308 if l is None or not l.held:
1309 return None
1310 return l
1311
1303 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
1312 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
1304 """
1313 """
1305 commit an individual file as part of a larger transaction
1314 commit an individual file as part of a larger transaction
1306 """
1315 """
1307
1316
1308 fname = fctx.path()
1317 fname = fctx.path()
1309 fparent1 = manifest1.get(fname, nullid)
1318 fparent1 = manifest1.get(fname, nullid)
1310 fparent2 = manifest2.get(fname, nullid)
1319 fparent2 = manifest2.get(fname, nullid)
1311 if isinstance(fctx, context.filectx):
1320 if isinstance(fctx, context.filectx):
1312 node = fctx.filenode()
1321 node = fctx.filenode()
1313 if node in [fparent1, fparent2]:
1322 if node in [fparent1, fparent2]:
1314 self.ui.debug('reusing %s filelog entry\n' % fname)
1323 self.ui.debug('reusing %s filelog entry\n' % fname)
1315 return node
1324 return node
1316
1325
1317 flog = self.file(fname)
1326 flog = self.file(fname)
1318 meta = {}
1327 meta = {}
1319 copy = fctx.renamed()
1328 copy = fctx.renamed()
1320 if copy and copy[0] != fname:
1329 if copy and copy[0] != fname:
1321 # Mark the new revision of this file as a copy of another
1330 # Mark the new revision of this file as a copy of another
1322 # file. This copy data will effectively act as a parent
1331 # file. This copy data will effectively act as a parent
1323 # of this new revision. If this is a merge, the first
1332 # of this new revision. If this is a merge, the first
1324 # parent will be the nullid (meaning "look up the copy data")
1333 # parent will be the nullid (meaning "look up the copy data")
1325 # and the second one will be the other parent. For example:
1334 # and the second one will be the other parent. For example:
1326 #
1335 #
1327 # 0 --- 1 --- 3 rev1 changes file foo
1336 # 0 --- 1 --- 3 rev1 changes file foo
1328 # \ / rev2 renames foo to bar and changes it
1337 # \ / rev2 renames foo to bar and changes it
1329 # \- 2 -/ rev3 should have bar with all changes and
1338 # \- 2 -/ rev3 should have bar with all changes and
1330 # should record that bar descends from
1339 # should record that bar descends from
1331 # bar in rev2 and foo in rev1
1340 # bar in rev2 and foo in rev1
1332 #
1341 #
1333 # this allows this merge to succeed:
1342 # this allows this merge to succeed:
1334 #
1343 #
1335 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
1344 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
1336 # \ / merging rev3 and rev4 should use bar@rev2
1345 # \ / merging rev3 and rev4 should use bar@rev2
1337 # \- 2 --- 4 as the merge base
1346 # \- 2 --- 4 as the merge base
1338 #
1347 #
1339
1348
1340 cfname = copy[0]
1349 cfname = copy[0]
1341 crev = manifest1.get(cfname)
1350 crev = manifest1.get(cfname)
1342 newfparent = fparent2
1351 newfparent = fparent2
1343
1352
1344 if manifest2: # branch merge
1353 if manifest2: # branch merge
1345 if fparent2 == nullid or crev is None: # copied on remote side
1354 if fparent2 == nullid or crev is None: # copied on remote side
1346 if cfname in manifest2:
1355 if cfname in manifest2:
1347 crev = manifest2[cfname]
1356 crev = manifest2[cfname]
1348 newfparent = fparent1
1357 newfparent = fparent1
1349
1358
1350 # Here, we used to search backwards through history to try to find
1359 # Here, we used to search backwards through history to try to find
1351 # where the file copy came from if the source of a copy was not in
1360 # where the file copy came from if the source of a copy was not in
1352 # the parent directory. However, this doesn't actually make sense to
1361 # the parent directory. However, this doesn't actually make sense to
1353 # do (what does a copy from something not in your working copy even
1362 # do (what does a copy from something not in your working copy even
1354 # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
1363 # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
1355 # the user that copy information was dropped, so if they didn't
1364 # the user that copy information was dropped, so if they didn't
1356 # expect this outcome it can be fixed, but this is the correct
1365 # expect this outcome it can be fixed, but this is the correct
1357 # behavior in this circumstance.
1366 # behavior in this circumstance.
1358
1367
1359 if crev:
1368 if crev:
1360 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
1369 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
1361 meta["copy"] = cfname
1370 meta["copy"] = cfname
1362 meta["copyrev"] = hex(crev)
1371 meta["copyrev"] = hex(crev)
1363 fparent1, fparent2 = nullid, newfparent
1372 fparent1, fparent2 = nullid, newfparent
1364 else:
1373 else:
1365 self.ui.warn(_("warning: can't find ancestor for '%s' "
1374 self.ui.warn(_("warning: can't find ancestor for '%s' "
1366 "copied from '%s'!\n") % (fname, cfname))
1375 "copied from '%s'!\n") % (fname, cfname))
1367
1376
1368 elif fparent1 == nullid:
1377 elif fparent1 == nullid:
1369 fparent1, fparent2 = fparent2, nullid
1378 fparent1, fparent2 = fparent2, nullid
1370 elif fparent2 != nullid:
1379 elif fparent2 != nullid:
1371 # is one parent an ancestor of the other?
1380 # is one parent an ancestor of the other?
1372 fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
1381 fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
1373 if fparent1 in fparentancestors:
1382 if fparent1 in fparentancestors:
1374 fparent1, fparent2 = fparent2, nullid
1383 fparent1, fparent2 = fparent2, nullid
1375 elif fparent2 in fparentancestors:
1384 elif fparent2 in fparentancestors:
1376 fparent2 = nullid
1385 fparent2 = nullid
1377
1386
1378 # is the file changed?
1387 # is the file changed?
1379 text = fctx.data()
1388 text = fctx.data()
1380 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
1389 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
1381 changelist.append(fname)
1390 changelist.append(fname)
1382 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
1391 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
1383 # are just the flags changed during merge?
1392 # are just the flags changed during merge?
1384 elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
1393 elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
1385 changelist.append(fname)
1394 changelist.append(fname)
1386
1395
1387 return fparent1
1396 return fparent1
1388
1397
1389 @unfilteredmethod
1398 @unfilteredmethod
1390 def commit(self, text="", user=None, date=None, match=None, force=False,
1399 def commit(self, text="", user=None, date=None, match=None, force=False,
1391 editor=False, extra=None):
1400 editor=False, extra=None):
1392 """Add a new revision to current repository.
1401 """Add a new revision to current repository.
1393
1402
1394 Revision information is gathered from the working directory,
1403 Revision information is gathered from the working directory,
1395 match can be used to filter the committed files. If editor is
1404 match can be used to filter the committed files. If editor is
1396 supplied, it is called to get a commit message.
1405 supplied, it is called to get a commit message.
1397 """
1406 """
1398 if extra is None:
1407 if extra is None:
1399 extra = {}
1408 extra = {}
1400
1409
1401 def fail(f, msg):
1410 def fail(f, msg):
1402 raise util.Abort('%s: %s' % (f, msg))
1411 raise util.Abort('%s: %s' % (f, msg))
1403
1412
1404 if not match:
1413 if not match:
1405 match = matchmod.always(self.root, '')
1414 match = matchmod.always(self.root, '')
1406
1415
1407 if not force:
1416 if not force:
1408 vdirs = []
1417 vdirs = []
1409 match.explicitdir = vdirs.append
1418 match.explicitdir = vdirs.append
1410 match.bad = fail
1419 match.bad = fail
1411
1420
1412 wlock = self.wlock()
1421 wlock = self.wlock()
1413 try:
1422 try:
1414 wctx = self[None]
1423 wctx = self[None]
1415 merge = len(wctx.parents()) > 1
1424 merge = len(wctx.parents()) > 1
1416
1425
1417 if not force and merge and match.ispartial():
1426 if not force and merge and match.ispartial():
1418 raise util.Abort(_('cannot partially commit a merge '
1427 raise util.Abort(_('cannot partially commit a merge '
1419 '(do not specify files or patterns)'))
1428 '(do not specify files or patterns)'))
1420
1429
1421 status = self.status(match=match, clean=force)
1430 status = self.status(match=match, clean=force)
1422 if force:
1431 if force:
1423 status.modified.extend(status.clean) # mq may commit clean files
1432 status.modified.extend(status.clean) # mq may commit clean files
1424
1433
1425 # check subrepos
1434 # check subrepos
1426 subs = []
1435 subs = []
1427 commitsubs = set()
1436 commitsubs = set()
1428 newstate = wctx.substate.copy()
1437 newstate = wctx.substate.copy()
1429 # only manage subrepos and .hgsubstate if .hgsub is present
1438 # only manage subrepos and .hgsubstate if .hgsub is present
1430 if '.hgsub' in wctx:
1439 if '.hgsub' in wctx:
1431 # we'll decide whether to track this ourselves, thanks
1440 # we'll decide whether to track this ourselves, thanks
1432 for c in status.modified, status.added, status.removed:
1441 for c in status.modified, status.added, status.removed:
1433 if '.hgsubstate' in c:
1442 if '.hgsubstate' in c:
1434 c.remove('.hgsubstate')
1443 c.remove('.hgsubstate')
1435
1444
1436 # compare current state to last committed state
1445 # compare current state to last committed state
1437 # build new substate based on last committed state
1446 # build new substate based on last committed state
1438 oldstate = wctx.p1().substate
1447 oldstate = wctx.p1().substate
1439 for s in sorted(newstate.keys()):
1448 for s in sorted(newstate.keys()):
1440 if not match(s):
1449 if not match(s):
1441 # ignore working copy, use old state if present
1450 # ignore working copy, use old state if present
1442 if s in oldstate:
1451 if s in oldstate:
1443 newstate[s] = oldstate[s]
1452 newstate[s] = oldstate[s]
1444 continue
1453 continue
1445 if not force:
1454 if not force:
1446 raise util.Abort(
1455 raise util.Abort(
1447 _("commit with new subrepo %s excluded") % s)
1456 _("commit with new subrepo %s excluded") % s)
1448 dirtyreason = wctx.sub(s).dirtyreason(True)
1457 dirtyreason = wctx.sub(s).dirtyreason(True)
1449 if dirtyreason:
1458 if dirtyreason:
1450 if not self.ui.configbool('ui', 'commitsubrepos'):
1459 if not self.ui.configbool('ui', 'commitsubrepos'):
1451 raise util.Abort(dirtyreason,
1460 raise util.Abort(dirtyreason,
1452 hint=_("use --subrepos for recursive commit"))
1461 hint=_("use --subrepos for recursive commit"))
1453 subs.append(s)
1462 subs.append(s)
1454 commitsubs.add(s)
1463 commitsubs.add(s)
1455 else:
1464 else:
1456 bs = wctx.sub(s).basestate()
1465 bs = wctx.sub(s).basestate()
1457 newstate[s] = (newstate[s][0], bs, newstate[s][2])
1466 newstate[s] = (newstate[s][0], bs, newstate[s][2])
1458 if oldstate.get(s, (None, None, None))[1] != bs:
1467 if oldstate.get(s, (None, None, None))[1] != bs:
1459 subs.append(s)
1468 subs.append(s)
1460
1469
1461 # check for removed subrepos
1470 # check for removed subrepos
1462 for p in wctx.parents():
1471 for p in wctx.parents():
1463 r = [s for s in p.substate if s not in newstate]
1472 r = [s for s in p.substate if s not in newstate]
1464 subs += [s for s in r if match(s)]
1473 subs += [s for s in r if match(s)]
1465 if subs:
1474 if subs:
1466 if (not match('.hgsub') and
1475 if (not match('.hgsub') and
1467 '.hgsub' in (wctx.modified() + wctx.added())):
1476 '.hgsub' in (wctx.modified() + wctx.added())):
1468 raise util.Abort(
1477 raise util.Abort(
1469 _("can't commit subrepos without .hgsub"))
1478 _("can't commit subrepos without .hgsub"))
1470 status.modified.insert(0, '.hgsubstate')
1479 status.modified.insert(0, '.hgsubstate')
1471
1480
1472 elif '.hgsub' in status.removed:
1481 elif '.hgsub' in status.removed:
1473 # clean up .hgsubstate when .hgsub is removed
1482 # clean up .hgsubstate when .hgsub is removed
1474 if ('.hgsubstate' in wctx and
1483 if ('.hgsubstate' in wctx and
1475 '.hgsubstate' not in (status.modified + status.added +
1484 '.hgsubstate' not in (status.modified + status.added +
1476 status.removed)):
1485 status.removed)):
1477 status.removed.insert(0, '.hgsubstate')
1486 status.removed.insert(0, '.hgsubstate')
1478
1487
1479 # make sure all explicit patterns are matched
1488 # make sure all explicit patterns are matched
1480 if not force and (match.isexact() or match.prefix()):
1489 if not force and (match.isexact() or match.prefix()):
1481 matched = set(status.modified + status.added + status.removed)
1490 matched = set(status.modified + status.added + status.removed)
1482
1491
1483 for f in match.files():
1492 for f in match.files():
1484 f = self.dirstate.normalize(f)
1493 f = self.dirstate.normalize(f)
1485 if f == '.' or f in matched or f in wctx.substate:
1494 if f == '.' or f in matched or f in wctx.substate:
1486 continue
1495 continue
1487 if f in status.deleted:
1496 if f in status.deleted:
1488 fail(f, _('file not found!'))
1497 fail(f, _('file not found!'))
1489 if f in vdirs: # visited directory
1498 if f in vdirs: # visited directory
1490 d = f + '/'
1499 d = f + '/'
1491 for mf in matched:
1500 for mf in matched:
1492 if mf.startswith(d):
1501 if mf.startswith(d):
1493 break
1502 break
1494 else:
1503 else:
1495 fail(f, _("no match under directory!"))
1504 fail(f, _("no match under directory!"))
1496 elif f not in self.dirstate:
1505 elif f not in self.dirstate:
1497 fail(f, _("file not tracked!"))
1506 fail(f, _("file not tracked!"))
1498
1507
1499 cctx = context.workingcommitctx(self, status,
1508 cctx = context.workingcommitctx(self, status,
1500 text, user, date, extra)
1509 text, user, date, extra)
1501
1510
1502 # internal config: ui.allowemptycommit
1511 # internal config: ui.allowemptycommit
1503 allowemptycommit = (wctx.branch() != wctx.p1().branch()
1512 allowemptycommit = (wctx.branch() != wctx.p1().branch()
1504 or extra.get('close') or merge or cctx.files()
1513 or extra.get('close') or merge or cctx.files()
1505 or self.ui.configbool('ui', 'allowemptycommit'))
1514 or self.ui.configbool('ui', 'allowemptycommit'))
1506 if not allowemptycommit:
1515 if not allowemptycommit:
1507 return None
1516 return None
1508
1517
1509 if merge and cctx.deleted():
1518 if merge and cctx.deleted():
1510 raise util.Abort(_("cannot commit merge with missing files"))
1519 raise util.Abort(_("cannot commit merge with missing files"))
1511
1520
1512 ms = mergemod.mergestate(self)
1521 ms = mergemod.mergestate(self)
1513 for f in status.modified:
1522 for f in status.modified:
1514 if f in ms and ms[f] == 'u':
1523 if f in ms and ms[f] == 'u':
1515 raise util.Abort(_('unresolved merge conflicts '
1524 raise util.Abort(_('unresolved merge conflicts '
1516 '(see "hg help resolve")'))
1525 '(see "hg help resolve")'))
1517
1526
1518 if editor:
1527 if editor:
1519 cctx._text = editor(self, cctx, subs)
1528 cctx._text = editor(self, cctx, subs)
1520 edited = (text != cctx._text)
1529 edited = (text != cctx._text)
1521
1530
1522 # Save commit message in case this transaction gets rolled back
1531 # Save commit message in case this transaction gets rolled back
1523 # (e.g. by a pretxncommit hook). Leave the content alone on
1532 # (e.g. by a pretxncommit hook). Leave the content alone on
1524 # the assumption that the user will use the same editor again.
1533 # the assumption that the user will use the same editor again.
1525 msgfn = self.savecommitmessage(cctx._text)
1534 msgfn = self.savecommitmessage(cctx._text)
1526
1535
1527 # commit subs and write new state
1536 # commit subs and write new state
1528 if subs:
1537 if subs:
1529 for s in sorted(commitsubs):
1538 for s in sorted(commitsubs):
1530 sub = wctx.sub(s)
1539 sub = wctx.sub(s)
1531 self.ui.status(_('committing subrepository %s\n') %
1540 self.ui.status(_('committing subrepository %s\n') %
1532 subrepo.subrelpath(sub))
1541 subrepo.subrelpath(sub))
1533 sr = sub.commit(cctx._text, user, date)
1542 sr = sub.commit(cctx._text, user, date)
1534 newstate[s] = (newstate[s][0], sr)
1543 newstate[s] = (newstate[s][0], sr)
1535 subrepo.writestate(self, newstate)
1544 subrepo.writestate(self, newstate)
1536
1545
1537 p1, p2 = self.dirstate.parents()
1546 p1, p2 = self.dirstate.parents()
1538 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
1547 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
1539 try:
1548 try:
1540 self.hook("precommit", throw=True, parent1=hookp1,
1549 self.hook("precommit", throw=True, parent1=hookp1,
1541 parent2=hookp2)
1550 parent2=hookp2)
1542 ret = self.commitctx(cctx, True)
1551 ret = self.commitctx(cctx, True)
1543 except: # re-raises
1552 except: # re-raises
1544 if edited:
1553 if edited:
1545 self.ui.write(
1554 self.ui.write(
1546 _('note: commit message saved in %s\n') % msgfn)
1555 _('note: commit message saved in %s\n') % msgfn)
1547 raise
1556 raise
1548
1557
1549 # update bookmarks, dirstate and mergestate
1558 # update bookmarks, dirstate and mergestate
1550 bookmarks.update(self, [p1, p2], ret)
1559 bookmarks.update(self, [p1, p2], ret)
1551 cctx.markcommitted(ret)
1560 cctx.markcommitted(ret)
1552 ms.reset()
1561 ms.reset()
1553 finally:
1562 finally:
1554 wlock.release()
1563 wlock.release()
1555
1564
1556 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
1565 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
1557 # hack for command that use a temporary commit (eg: histedit)
1566 # hack for command that use a temporary commit (eg: histedit)
1558 # temporary commit got stripped before hook release
1567 # temporary commit got stripped before hook release
1559 if self.changelog.hasnode(ret):
1568 if self.changelog.hasnode(ret):
1560 self.hook("commit", node=node, parent1=parent1,
1569 self.hook("commit", node=node, parent1=parent1,
1561 parent2=parent2)
1570 parent2=parent2)
1562 self._afterlock(commithook)
1571 self._afterlock(commithook)
1563 return ret
1572 return ret
1564
1573
1565 @unfilteredmethod
1574 @unfilteredmethod
1566 def commitctx(self, ctx, error=False):
1575 def commitctx(self, ctx, error=False):
1567 """Add a new revision to current repository.
1576 """Add a new revision to current repository.
1568 Revision information is passed via the context argument.
1577 Revision information is passed via the context argument.
1569 """
1578 """
1570
1579
1571 tr = None
1580 tr = None
1572 p1, p2 = ctx.p1(), ctx.p2()
1581 p1, p2 = ctx.p1(), ctx.p2()
1573 user = ctx.user()
1582 user = ctx.user()
1574
1583
1575 lock = self.lock()
1584 lock = self.lock()
1576 try:
1585 try:
1577 tr = self.transaction("commit")
1586 tr = self.transaction("commit")
1578 trp = weakref.proxy(tr)
1587 trp = weakref.proxy(tr)
1579
1588
1580 if ctx.files():
1589 if ctx.files():
1581 m1 = p1.manifest()
1590 m1 = p1.manifest()
1582 m2 = p2.manifest()
1591 m2 = p2.manifest()
1583 m = m1.copy()
1592 m = m1.copy()
1584
1593
1585 # check in files
1594 # check in files
1586 added = []
1595 added = []
1587 changed = []
1596 changed = []
1588 removed = list(ctx.removed())
1597 removed = list(ctx.removed())
1589 linkrev = len(self)
1598 linkrev = len(self)
1590 self.ui.note(_("committing files:\n"))
1599 self.ui.note(_("committing files:\n"))
1591 for f in sorted(ctx.modified() + ctx.added()):
1600 for f in sorted(ctx.modified() + ctx.added()):
1592 self.ui.note(f + "\n")
1601 self.ui.note(f + "\n")
1593 try:
1602 try:
1594 fctx = ctx[f]
1603 fctx = ctx[f]
1595 if fctx is None:
1604 if fctx is None:
1596 removed.append(f)
1605 removed.append(f)
1597 else:
1606 else:
1598 added.append(f)
1607 added.append(f)
1599 m[f] = self._filecommit(fctx, m1, m2, linkrev,
1608 m[f] = self._filecommit(fctx, m1, m2, linkrev,
1600 trp, changed)
1609 trp, changed)
1601 m.setflag(f, fctx.flags())
1610 m.setflag(f, fctx.flags())
1602 except OSError as inst:
1611 except OSError as inst:
1603 self.ui.warn(_("trouble committing %s!\n") % f)
1612 self.ui.warn(_("trouble committing %s!\n") % f)
1604 raise
1613 raise
1605 except IOError as inst:
1614 except IOError as inst:
1606 errcode = getattr(inst, 'errno', errno.ENOENT)
1615 errcode = getattr(inst, 'errno', errno.ENOENT)
1607 if error or errcode and errcode != errno.ENOENT:
1616 if error or errcode and errcode != errno.ENOENT:
1608 self.ui.warn(_("trouble committing %s!\n") % f)
1617 self.ui.warn(_("trouble committing %s!\n") % f)
1609 raise
1618 raise
1610
1619
1611 # update manifest
1620 # update manifest
1612 self.ui.note(_("committing manifest\n"))
1621 self.ui.note(_("committing manifest\n"))
1613 removed = [f for f in sorted(removed) if f in m1 or f in m2]
1622 removed = [f for f in sorted(removed) if f in m1 or f in m2]
1614 drop = [f for f in removed if f in m]
1623 drop = [f for f in removed if f in m]
1615 for f in drop:
1624 for f in drop:
1616 del m[f]
1625 del m[f]
1617 mn = self.manifest.add(m, trp, linkrev,
1626 mn = self.manifest.add(m, trp, linkrev,
1618 p1.manifestnode(), p2.manifestnode(),
1627 p1.manifestnode(), p2.manifestnode(),
1619 added, drop)
1628 added, drop)
1620 files = changed + removed
1629 files = changed + removed
1621 else:
1630 else:
1622 mn = p1.manifestnode()
1631 mn = p1.manifestnode()
1623 files = []
1632 files = []
1624
1633
1625 # update changelog
1634 # update changelog
1626 self.ui.note(_("committing changelog\n"))
1635 self.ui.note(_("committing changelog\n"))
1627 self.changelog.delayupdate(tr)
1636 self.changelog.delayupdate(tr)
1628 n = self.changelog.add(mn, files, ctx.description(),
1637 n = self.changelog.add(mn, files, ctx.description(),
1629 trp, p1.node(), p2.node(),
1638 trp, p1.node(), p2.node(),
1630 user, ctx.date(), ctx.extra().copy())
1639 user, ctx.date(), ctx.extra().copy())
1631 p = lambda: tr.writepending() and self.root or ""
1640 p = lambda: tr.writepending() and self.root or ""
1632 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
1641 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
1633 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
1642 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
1634 parent2=xp2, pending=p)
1643 parent2=xp2, pending=p)
1635 # set the new commit is proper phase
1644 # set the new commit is proper phase
1636 targetphase = subrepo.newcommitphase(self.ui, ctx)
1645 targetphase = subrepo.newcommitphase(self.ui, ctx)
1637 if targetphase:
1646 if targetphase:
1638 # retract boundary do not alter parent changeset.
1647 # retract boundary do not alter parent changeset.
1639 # if a parent have higher the resulting phase will
1648 # if a parent have higher the resulting phase will
1640 # be compliant anyway
1649 # be compliant anyway
1641 #
1650 #
1642 # if minimal phase was 0 we don't need to retract anything
1651 # if minimal phase was 0 we don't need to retract anything
1643 phases.retractboundary(self, tr, targetphase, [n])
1652 phases.retractboundary(self, tr, targetphase, [n])
1644 tr.close()
1653 tr.close()
1645 branchmap.updatecache(self.filtered('served'))
1654 branchmap.updatecache(self.filtered('served'))
1646 return n
1655 return n
1647 finally:
1656 finally:
1648 if tr:
1657 if tr:
1649 tr.release()
1658 tr.release()
1650 lock.release()
1659 lock.release()
1651
1660
1652 @unfilteredmethod
1661 @unfilteredmethod
1653 def destroying(self):
1662 def destroying(self):
1654 '''Inform the repository that nodes are about to be destroyed.
1663 '''Inform the repository that nodes are about to be destroyed.
1655 Intended for use by strip and rollback, so there's a common
1664 Intended for use by strip and rollback, so there's a common
1656 place for anything that has to be done before destroying history.
1665 place for anything that has to be done before destroying history.
1657
1666
1658 This is mostly useful for saving state that is in memory and waiting
1667 This is mostly useful for saving state that is in memory and waiting
1659 to be flushed when the current lock is released. Because a call to
1668 to be flushed when the current lock is released. Because a call to
1660 destroyed is imminent, the repo will be invalidated causing those
1669 destroyed is imminent, the repo will be invalidated causing those
1661 changes to stay in memory (waiting for the next unlock), or vanish
1670 changes to stay in memory (waiting for the next unlock), or vanish
1662 completely.
1671 completely.
1663 '''
1672 '''
1664 # When using the same lock to commit and strip, the phasecache is left
1673 # When using the same lock to commit and strip, the phasecache is left
1665 # dirty after committing. Then when we strip, the repo is invalidated,
1674 # dirty after committing. Then when we strip, the repo is invalidated,
1666 # causing those changes to disappear.
1675 # causing those changes to disappear.
1667 if '_phasecache' in vars(self):
1676 if '_phasecache' in vars(self):
1668 self._phasecache.write()
1677 self._phasecache.write()
1669
1678
1670 @unfilteredmethod
1679 @unfilteredmethod
1671 def destroyed(self):
1680 def destroyed(self):
1672 '''Inform the repository that nodes have been destroyed.
1681 '''Inform the repository that nodes have been destroyed.
1673 Intended for use by strip and rollback, so there's a common
1682 Intended for use by strip and rollback, so there's a common
1674 place for anything that has to be done after destroying history.
1683 place for anything that has to be done after destroying history.
1675 '''
1684 '''
1676 # When one tries to:
1685 # When one tries to:
1677 # 1) destroy nodes thus calling this method (e.g. strip)
1686 # 1) destroy nodes thus calling this method (e.g. strip)
1678 # 2) use phasecache somewhere (e.g. commit)
1687 # 2) use phasecache somewhere (e.g. commit)
1679 #
1688 #
1680 # then 2) will fail because the phasecache contains nodes that were
1689 # then 2) will fail because the phasecache contains nodes that were
1681 # removed. We can either remove phasecache from the filecache,
1690 # removed. We can either remove phasecache from the filecache,
1682 # causing it to reload next time it is accessed, or simply filter
1691 # causing it to reload next time it is accessed, or simply filter
1683 # the removed nodes now and write the updated cache.
1692 # the removed nodes now and write the updated cache.
1684 self._phasecache.filterunknown(self)
1693 self._phasecache.filterunknown(self)
1685 self._phasecache.write()
1694 self._phasecache.write()
1686
1695
1687 # update the 'served' branch cache to help read only server process
1696 # update the 'served' branch cache to help read only server process
1688 # Thanks to branchcache collaboration this is done from the nearest
1697 # Thanks to branchcache collaboration this is done from the nearest
1689 # filtered subset and it is expected to be fast.
1698 # filtered subset and it is expected to be fast.
1690 branchmap.updatecache(self.filtered('served'))
1699 branchmap.updatecache(self.filtered('served'))
1691
1700
1692 # Ensure the persistent tag cache is updated. Doing it now
1701 # Ensure the persistent tag cache is updated. Doing it now
1693 # means that the tag cache only has to worry about destroyed
1702 # means that the tag cache only has to worry about destroyed
1694 # heads immediately after a strip/rollback. That in turn
1703 # heads immediately after a strip/rollback. That in turn
1695 # guarantees that "cachetip == currenttip" (comparing both rev
1704 # guarantees that "cachetip == currenttip" (comparing both rev
1696 # and node) always means no nodes have been added or destroyed.
1705 # and node) always means no nodes have been added or destroyed.
1697
1706
1698 # XXX this is suboptimal when qrefresh'ing: we strip the current
1707 # XXX this is suboptimal when qrefresh'ing: we strip the current
1699 # head, refresh the tag cache, then immediately add a new head.
1708 # head, refresh the tag cache, then immediately add a new head.
1700 # But I think doing it this way is necessary for the "instant
1709 # But I think doing it this way is necessary for the "instant
1701 # tag cache retrieval" case to work.
1710 # tag cache retrieval" case to work.
1702 self.invalidate()
1711 self.invalidate()
1703
1712
1704 def walk(self, match, node=None):
1713 def walk(self, match, node=None):
1705 '''
1714 '''
1706 walk recursively through the directory tree or a given
1715 walk recursively through the directory tree or a given
1707 changeset, finding all files matched by the match
1716 changeset, finding all files matched by the match
1708 function
1717 function
1709 '''
1718 '''
1710 return self[node].walk(match)
1719 return self[node].walk(match)
1711
1720
1712 def status(self, node1='.', node2=None, match=None,
1721 def status(self, node1='.', node2=None, match=None,
1713 ignored=False, clean=False, unknown=False,
1722 ignored=False, clean=False, unknown=False,
1714 listsubrepos=False):
1723 listsubrepos=False):
1715 '''a convenience method that calls node1.status(node2)'''
1724 '''a convenience method that calls node1.status(node2)'''
1716 return self[node1].status(node2, match, ignored, clean, unknown,
1725 return self[node1].status(node2, match, ignored, clean, unknown,
1717 listsubrepos)
1726 listsubrepos)
1718
1727
1719 def heads(self, start=None):
1728 def heads(self, start=None):
1720 heads = self.changelog.heads(start)
1729 heads = self.changelog.heads(start)
1721 # sort the output in rev descending order
1730 # sort the output in rev descending order
1722 return sorted(heads, key=self.changelog.rev, reverse=True)
1731 return sorted(heads, key=self.changelog.rev, reverse=True)
1723
1732
1724 def branchheads(self, branch=None, start=None, closed=False):
1733 def branchheads(self, branch=None, start=None, closed=False):
1725 '''return a (possibly filtered) list of heads for the given branch
1734 '''return a (possibly filtered) list of heads for the given branch
1726
1735
1727 Heads are returned in topological order, from newest to oldest.
1736 Heads are returned in topological order, from newest to oldest.
1728 If branch is None, use the dirstate branch.
1737 If branch is None, use the dirstate branch.
1729 If start is not None, return only heads reachable from start.
1738 If start is not None, return only heads reachable from start.
1730 If closed is True, return heads that are marked as closed as well.
1739 If closed is True, return heads that are marked as closed as well.
1731 '''
1740 '''
1732 if branch is None:
1741 if branch is None:
1733 branch = self[None].branch()
1742 branch = self[None].branch()
1734 branches = self.branchmap()
1743 branches = self.branchmap()
1735 if branch not in branches:
1744 if branch not in branches:
1736 return []
1745 return []
1737 # the cache returns heads ordered lowest to highest
1746 # the cache returns heads ordered lowest to highest
1738 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
1747 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
1739 if start is not None:
1748 if start is not None:
1740 # filter out the heads that cannot be reached from startrev
1749 # filter out the heads that cannot be reached from startrev
1741 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
1750 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
1742 bheads = [h for h in bheads if h in fbheads]
1751 bheads = [h for h in bheads if h in fbheads]
1743 return bheads
1752 return bheads
1744
1753
1745 def branches(self, nodes):
1754 def branches(self, nodes):
1746 if not nodes:
1755 if not nodes:
1747 nodes = [self.changelog.tip()]
1756 nodes = [self.changelog.tip()]
1748 b = []
1757 b = []
1749 for n in nodes:
1758 for n in nodes:
1750 t = n
1759 t = n
1751 while True:
1760 while True:
1752 p = self.changelog.parents(n)
1761 p = self.changelog.parents(n)
1753 if p[1] != nullid or p[0] == nullid:
1762 if p[1] != nullid or p[0] == nullid:
1754 b.append((t, n, p[0], p[1]))
1763 b.append((t, n, p[0], p[1]))
1755 break
1764 break
1756 n = p[0]
1765 n = p[0]
1757 return b
1766 return b
1758
1767
1759 def between(self, pairs):
1768 def between(self, pairs):
1760 r = []
1769 r = []
1761
1770
1762 for top, bottom in pairs:
1771 for top, bottom in pairs:
1763 n, l, i = top, [], 0
1772 n, l, i = top, [], 0
1764 f = 1
1773 f = 1
1765
1774
1766 while n != bottom and n != nullid:
1775 while n != bottom and n != nullid:
1767 p = self.changelog.parents(n)[0]
1776 p = self.changelog.parents(n)[0]
1768 if i == f:
1777 if i == f:
1769 l.append(n)
1778 l.append(n)
1770 f = f * 2
1779 f = f * 2
1771 n = p
1780 n = p
1772 i += 1
1781 i += 1
1773
1782
1774 r.append(l)
1783 r.append(l)
1775
1784
1776 return r
1785 return r
1777
1786
1778 def checkpush(self, pushop):
1787 def checkpush(self, pushop):
1779 """Extensions can override this function if additional checks have
1788 """Extensions can override this function if additional checks have
1780 to be performed before pushing, or call it if they override push
1789 to be performed before pushing, or call it if they override push
1781 command.
1790 command.
1782 """
1791 """
1783 pass
1792 pass
1784
1793
1785 @unfilteredpropertycache
1794 @unfilteredpropertycache
1786 def prepushoutgoinghooks(self):
1795 def prepushoutgoinghooks(self):
1787 """Return util.hooks consists of "(repo, remote, outgoing)"
1796 """Return util.hooks consists of "(repo, remote, outgoing)"
1788 functions, which are called before pushing changesets.
1797 functions, which are called before pushing changesets.
1789 """
1798 """
1790 return util.hooks()
1799 return util.hooks()
1791
1800
1792 def clone(self, remote, heads=[], stream=None):
1801 def clone(self, remote, heads=[], stream=None):
1793 '''clone remote repository.
1802 '''clone remote repository.
1794
1803
1795 keyword arguments:
1804 keyword arguments:
1796 heads: list of revs to clone (forces use of pull)
1805 heads: list of revs to clone (forces use of pull)
1797 stream: use streaming clone if possible'''
1806 stream: use streaming clone if possible'''
1798 # internal config: ui.quietbookmarkmove
1807 # internal config: ui.quietbookmarkmove
1799 quiet = self.ui.backupconfig('ui', 'quietbookmarkmove')
1808 quiet = self.ui.backupconfig('ui', 'quietbookmarkmove')
1800 try:
1809 try:
1801 self.ui.setconfig('ui', 'quietbookmarkmove', True, 'clone')
1810 self.ui.setconfig('ui', 'quietbookmarkmove', True, 'clone')
1802 pullop = exchange.pull(self, remote, heads,
1811 pullop = exchange.pull(self, remote, heads,
1803 streamclonerequested=stream)
1812 streamclonerequested=stream)
1804 return pullop.cgresult
1813 return pullop.cgresult
1805 finally:
1814 finally:
1806 self.ui.restoreconfig(quiet)
1815 self.ui.restoreconfig(quiet)
1807
1816
1808 def pushkey(self, namespace, key, old, new):
1817 def pushkey(self, namespace, key, old, new):
1809 try:
1818 try:
1810 tr = self.currenttransaction()
1819 tr = self.currenttransaction()
1811 hookargs = {}
1820 hookargs = {}
1812 if tr is not None:
1821 if tr is not None:
1813 hookargs.update(tr.hookargs)
1822 hookargs.update(tr.hookargs)
1814 pending = lambda: tr.writepending() and self.root or ""
1823 pending = lambda: tr.writepending() and self.root or ""
1815 hookargs['pending'] = pending
1824 hookargs['pending'] = pending
1816 hookargs['namespace'] = namespace
1825 hookargs['namespace'] = namespace
1817 hookargs['key'] = key
1826 hookargs['key'] = key
1818 hookargs['old'] = old
1827 hookargs['old'] = old
1819 hookargs['new'] = new
1828 hookargs['new'] = new
1820 self.hook('prepushkey', throw=True, **hookargs)
1829 self.hook('prepushkey', throw=True, **hookargs)
1821 except error.HookAbort as exc:
1830 except error.HookAbort as exc:
1822 self.ui.write_err(_("pushkey-abort: %s\n") % exc)
1831 self.ui.write_err(_("pushkey-abort: %s\n") % exc)
1823 if exc.hint:
1832 if exc.hint:
1824 self.ui.write_err(_("(%s)\n") % exc.hint)
1833 self.ui.write_err(_("(%s)\n") % exc.hint)
1825 return False
1834 return False
1826 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
1835 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
1827 ret = pushkey.push(self, namespace, key, old, new)
1836 ret = pushkey.push(self, namespace, key, old, new)
1828 def runhook():
1837 def runhook():
1829 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
1838 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
1830 ret=ret)
1839 ret=ret)
1831 self._afterlock(runhook)
1840 self._afterlock(runhook)
1832 return ret
1841 return ret
1833
1842
1834 def listkeys(self, namespace):
1843 def listkeys(self, namespace):
1835 self.hook('prelistkeys', throw=True, namespace=namespace)
1844 self.hook('prelistkeys', throw=True, namespace=namespace)
1836 self.ui.debug('listing keys for "%s"\n' % namespace)
1845 self.ui.debug('listing keys for "%s"\n' % namespace)
1837 values = pushkey.list(self, namespace)
1846 values = pushkey.list(self, namespace)
1838 self.hook('listkeys', namespace=namespace, values=values)
1847 self.hook('listkeys', namespace=namespace, values=values)
1839 return values
1848 return values
1840
1849
1841 def debugwireargs(self, one, two, three=None, four=None, five=None):
1850 def debugwireargs(self, one, two, three=None, four=None, five=None):
1842 '''used to test argument passing over the wire'''
1851 '''used to test argument passing over the wire'''
1843 return "%s %s %s %s %s" % (one, two, three, four, five)
1852 return "%s %s %s %s %s" % (one, two, three, four, five)
1844
1853
1845 def savecommitmessage(self, text):
1854 def savecommitmessage(self, text):
1846 fp = self.vfs('last-message.txt', 'wb')
1855 fp = self.vfs('last-message.txt', 'wb')
1847 try:
1856 try:
1848 fp.write(text)
1857 fp.write(text)
1849 finally:
1858 finally:
1850 fp.close()
1859 fp.close()
1851 return self.pathto(fp.name[len(self.root) + 1:])
1860 return self.pathto(fp.name[len(self.root) + 1:])
1852
1861
1853 # used to avoid circular references so destructors work
1862 # used to avoid circular references so destructors work
1854 def aftertrans(files):
1863 def aftertrans(files):
1855 renamefiles = [tuple(t) for t in files]
1864 renamefiles = [tuple(t) for t in files]
1856 def a():
1865 def a():
1857 for vfs, src, dest in renamefiles:
1866 for vfs, src, dest in renamefiles:
1858 try:
1867 try:
1859 vfs.rename(src, dest)
1868 vfs.rename(src, dest)
1860 except OSError: # journal file does not yet exist
1869 except OSError: # journal file does not yet exist
1861 pass
1870 pass
1862 return a
1871 return a
1863
1872
1864 def undoname(fn):
1873 def undoname(fn):
1865 base, name = os.path.split(fn)
1874 base, name = os.path.split(fn)
1866 assert name.startswith('journal')
1875 assert name.startswith('journal')
1867 return os.path.join(base, name.replace('journal', 'undo', 1))
1876 return os.path.join(base, name.replace('journal', 'undo', 1))
1868
1877
1869 def instance(ui, path, create):
1878 def instance(ui, path, create):
1870 return localrepository(ui, util.urllocalpath(path), create)
1879 return localrepository(ui, util.urllocalpath(path), create)
1871
1880
1872 def islocal(path):
1881 def islocal(path):
1873 return True
1882 return True
General Comments 0
You need to be logged in to leave comments. Login now