##// END OF EJS Templates
revlog: use a less probable revlog version for backwards compatibility...
Raphaël Gomès -
r47135:95054317 default
parent child Browse files
Show More
@@ -1,3695 +1,3695 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
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import errno
10 import errno
11 import functools
11 import functools
12 import os
12 import os
13 import random
13 import random
14 import sys
14 import sys
15 import time
15 import time
16 import weakref
16 import weakref
17
17
18 from .i18n import _
18 from .i18n import _
19 from .node import (
19 from .node import (
20 bin,
20 bin,
21 hex,
21 hex,
22 nullid,
22 nullid,
23 nullrev,
23 nullrev,
24 short,
24 short,
25 )
25 )
26 from .pycompat import (
26 from .pycompat import (
27 delattr,
27 delattr,
28 getattr,
28 getattr,
29 )
29 )
30 from . import (
30 from . import (
31 bookmarks,
31 bookmarks,
32 branchmap,
32 branchmap,
33 bundle2,
33 bundle2,
34 bundlecaches,
34 bundlecaches,
35 changegroup,
35 changegroup,
36 color,
36 color,
37 commit,
37 commit,
38 context,
38 context,
39 dirstate,
39 dirstate,
40 dirstateguard,
40 dirstateguard,
41 discovery,
41 discovery,
42 encoding,
42 encoding,
43 error,
43 error,
44 exchange,
44 exchange,
45 extensions,
45 extensions,
46 filelog,
46 filelog,
47 hook,
47 hook,
48 lock as lockmod,
48 lock as lockmod,
49 match as matchmod,
49 match as matchmod,
50 mergestate as mergestatemod,
50 mergestate as mergestatemod,
51 mergeutil,
51 mergeutil,
52 namespaces,
52 namespaces,
53 narrowspec,
53 narrowspec,
54 obsolete,
54 obsolete,
55 pathutil,
55 pathutil,
56 phases,
56 phases,
57 pushkey,
57 pushkey,
58 pycompat,
58 pycompat,
59 rcutil,
59 rcutil,
60 repoview,
60 repoview,
61 requirements as requirementsmod,
61 requirements as requirementsmod,
62 revlog,
62 revlog,
63 revset,
63 revset,
64 revsetlang,
64 revsetlang,
65 scmutil,
65 scmutil,
66 sparse,
66 sparse,
67 store as storemod,
67 store as storemod,
68 subrepoutil,
68 subrepoutil,
69 tags as tagsmod,
69 tags as tagsmod,
70 transaction,
70 transaction,
71 txnutil,
71 txnutil,
72 util,
72 util,
73 vfs as vfsmod,
73 vfs as vfsmod,
74 )
74 )
75
75
76 from .interfaces import (
76 from .interfaces import (
77 repository,
77 repository,
78 util as interfaceutil,
78 util as interfaceutil,
79 )
79 )
80
80
81 from .utils import (
81 from .utils import (
82 hashutil,
82 hashutil,
83 procutil,
83 procutil,
84 stringutil,
84 stringutil,
85 )
85 )
86
86
87 from .revlogutils import constants as revlogconst
87 from .revlogutils import constants as revlogconst
88
88
89 release = lockmod.release
89 release = lockmod.release
90 urlerr = util.urlerr
90 urlerr = util.urlerr
91 urlreq = util.urlreq
91 urlreq = util.urlreq
92
92
93 # set of (path, vfs-location) tuples. vfs-location is:
93 # set of (path, vfs-location) tuples. vfs-location is:
94 # - 'plain for vfs relative paths
94 # - 'plain for vfs relative paths
95 # - '' for svfs relative paths
95 # - '' for svfs relative paths
96 _cachedfiles = set()
96 _cachedfiles = set()
97
97
98
98
99 class _basefilecache(scmutil.filecache):
99 class _basefilecache(scmutil.filecache):
100 """All filecache usage on repo are done for logic that should be unfiltered"""
100 """All filecache usage on repo are done for logic that should be unfiltered"""
101
101
102 def __get__(self, repo, type=None):
102 def __get__(self, repo, type=None):
103 if repo is None:
103 if repo is None:
104 return self
104 return self
105 # proxy to unfiltered __dict__ since filtered repo has no entry
105 # proxy to unfiltered __dict__ since filtered repo has no entry
106 unfi = repo.unfiltered()
106 unfi = repo.unfiltered()
107 try:
107 try:
108 return unfi.__dict__[self.sname]
108 return unfi.__dict__[self.sname]
109 except KeyError:
109 except KeyError:
110 pass
110 pass
111 return super(_basefilecache, self).__get__(unfi, type)
111 return super(_basefilecache, self).__get__(unfi, type)
112
112
113 def set(self, repo, value):
113 def set(self, repo, value):
114 return super(_basefilecache, self).set(repo.unfiltered(), value)
114 return super(_basefilecache, self).set(repo.unfiltered(), value)
115
115
116
116
117 class repofilecache(_basefilecache):
117 class repofilecache(_basefilecache):
118 """filecache for files in .hg but outside of .hg/store"""
118 """filecache for files in .hg but outside of .hg/store"""
119
119
120 def __init__(self, *paths):
120 def __init__(self, *paths):
121 super(repofilecache, self).__init__(*paths)
121 super(repofilecache, self).__init__(*paths)
122 for path in paths:
122 for path in paths:
123 _cachedfiles.add((path, b'plain'))
123 _cachedfiles.add((path, b'plain'))
124
124
125 def join(self, obj, fname):
125 def join(self, obj, fname):
126 return obj.vfs.join(fname)
126 return obj.vfs.join(fname)
127
127
128
128
129 class storecache(_basefilecache):
129 class storecache(_basefilecache):
130 """filecache for files in the store"""
130 """filecache for files in the store"""
131
131
132 def __init__(self, *paths):
132 def __init__(self, *paths):
133 super(storecache, self).__init__(*paths)
133 super(storecache, self).__init__(*paths)
134 for path in paths:
134 for path in paths:
135 _cachedfiles.add((path, b''))
135 _cachedfiles.add((path, b''))
136
136
137 def join(self, obj, fname):
137 def join(self, obj, fname):
138 return obj.sjoin(fname)
138 return obj.sjoin(fname)
139
139
140
140
141 class mixedrepostorecache(_basefilecache):
141 class mixedrepostorecache(_basefilecache):
142 """filecache for a mix files in .hg/store and outside"""
142 """filecache for a mix files in .hg/store and outside"""
143
143
144 def __init__(self, *pathsandlocations):
144 def __init__(self, *pathsandlocations):
145 # scmutil.filecache only uses the path for passing back into our
145 # scmutil.filecache only uses the path for passing back into our
146 # join(), so we can safely pass a list of paths and locations
146 # join(), so we can safely pass a list of paths and locations
147 super(mixedrepostorecache, self).__init__(*pathsandlocations)
147 super(mixedrepostorecache, self).__init__(*pathsandlocations)
148 _cachedfiles.update(pathsandlocations)
148 _cachedfiles.update(pathsandlocations)
149
149
150 def join(self, obj, fnameandlocation):
150 def join(self, obj, fnameandlocation):
151 fname, location = fnameandlocation
151 fname, location = fnameandlocation
152 if location == b'plain':
152 if location == b'plain':
153 return obj.vfs.join(fname)
153 return obj.vfs.join(fname)
154 else:
154 else:
155 if location != b'':
155 if location != b'':
156 raise error.ProgrammingError(
156 raise error.ProgrammingError(
157 b'unexpected location: %s' % location
157 b'unexpected location: %s' % location
158 )
158 )
159 return obj.sjoin(fname)
159 return obj.sjoin(fname)
160
160
161
161
162 def isfilecached(repo, name):
162 def isfilecached(repo, name):
163 """check if a repo has already cached "name" filecache-ed property
163 """check if a repo has already cached "name" filecache-ed property
164
164
165 This returns (cachedobj-or-None, iscached) tuple.
165 This returns (cachedobj-or-None, iscached) tuple.
166 """
166 """
167 cacheentry = repo.unfiltered()._filecache.get(name, None)
167 cacheentry = repo.unfiltered()._filecache.get(name, None)
168 if not cacheentry:
168 if not cacheentry:
169 return None, False
169 return None, False
170 return cacheentry.obj, True
170 return cacheentry.obj, True
171
171
172
172
173 class unfilteredpropertycache(util.propertycache):
173 class unfilteredpropertycache(util.propertycache):
174 """propertycache that apply to unfiltered repo only"""
174 """propertycache that apply to unfiltered repo only"""
175
175
176 def __get__(self, repo, type=None):
176 def __get__(self, repo, type=None):
177 unfi = repo.unfiltered()
177 unfi = repo.unfiltered()
178 if unfi is repo:
178 if unfi is repo:
179 return super(unfilteredpropertycache, self).__get__(unfi)
179 return super(unfilteredpropertycache, self).__get__(unfi)
180 return getattr(unfi, self.name)
180 return getattr(unfi, self.name)
181
181
182
182
183 class filteredpropertycache(util.propertycache):
183 class filteredpropertycache(util.propertycache):
184 """propertycache that must take filtering in account"""
184 """propertycache that must take filtering in account"""
185
185
186 def cachevalue(self, obj, value):
186 def cachevalue(self, obj, value):
187 object.__setattr__(obj, self.name, value)
187 object.__setattr__(obj, self.name, value)
188
188
189
189
190 def hasunfilteredcache(repo, name):
190 def hasunfilteredcache(repo, name):
191 """check if a repo has an unfilteredpropertycache value for <name>"""
191 """check if a repo has an unfilteredpropertycache value for <name>"""
192 return name in vars(repo.unfiltered())
192 return name in vars(repo.unfiltered())
193
193
194
194
195 def unfilteredmethod(orig):
195 def unfilteredmethod(orig):
196 """decorate method that always need to be run on unfiltered version"""
196 """decorate method that always need to be run on unfiltered version"""
197
197
198 @functools.wraps(orig)
198 @functools.wraps(orig)
199 def wrapper(repo, *args, **kwargs):
199 def wrapper(repo, *args, **kwargs):
200 return orig(repo.unfiltered(), *args, **kwargs)
200 return orig(repo.unfiltered(), *args, **kwargs)
201
201
202 return wrapper
202 return wrapper
203
203
204
204
205 moderncaps = {
205 moderncaps = {
206 b'lookup',
206 b'lookup',
207 b'branchmap',
207 b'branchmap',
208 b'pushkey',
208 b'pushkey',
209 b'known',
209 b'known',
210 b'getbundle',
210 b'getbundle',
211 b'unbundle',
211 b'unbundle',
212 }
212 }
213 legacycaps = moderncaps.union({b'changegroupsubset'})
213 legacycaps = moderncaps.union({b'changegroupsubset'})
214
214
215
215
216 @interfaceutil.implementer(repository.ipeercommandexecutor)
216 @interfaceutil.implementer(repository.ipeercommandexecutor)
217 class localcommandexecutor(object):
217 class localcommandexecutor(object):
218 def __init__(self, peer):
218 def __init__(self, peer):
219 self._peer = peer
219 self._peer = peer
220 self._sent = False
220 self._sent = False
221 self._closed = False
221 self._closed = False
222
222
223 def __enter__(self):
223 def __enter__(self):
224 return self
224 return self
225
225
226 def __exit__(self, exctype, excvalue, exctb):
226 def __exit__(self, exctype, excvalue, exctb):
227 self.close()
227 self.close()
228
228
229 def callcommand(self, command, args):
229 def callcommand(self, command, args):
230 if self._sent:
230 if self._sent:
231 raise error.ProgrammingError(
231 raise error.ProgrammingError(
232 b'callcommand() cannot be used after sendcommands()'
232 b'callcommand() cannot be used after sendcommands()'
233 )
233 )
234
234
235 if self._closed:
235 if self._closed:
236 raise error.ProgrammingError(
236 raise error.ProgrammingError(
237 b'callcommand() cannot be used after close()'
237 b'callcommand() cannot be used after close()'
238 )
238 )
239
239
240 # We don't need to support anything fancy. Just call the named
240 # We don't need to support anything fancy. Just call the named
241 # method on the peer and return a resolved future.
241 # method on the peer and return a resolved future.
242 fn = getattr(self._peer, pycompat.sysstr(command))
242 fn = getattr(self._peer, pycompat.sysstr(command))
243
243
244 f = pycompat.futures.Future()
244 f = pycompat.futures.Future()
245
245
246 try:
246 try:
247 result = fn(**pycompat.strkwargs(args))
247 result = fn(**pycompat.strkwargs(args))
248 except Exception:
248 except Exception:
249 pycompat.future_set_exception_info(f, sys.exc_info()[1:])
249 pycompat.future_set_exception_info(f, sys.exc_info()[1:])
250 else:
250 else:
251 f.set_result(result)
251 f.set_result(result)
252
252
253 return f
253 return f
254
254
255 def sendcommands(self):
255 def sendcommands(self):
256 self._sent = True
256 self._sent = True
257
257
258 def close(self):
258 def close(self):
259 self._closed = True
259 self._closed = True
260
260
261
261
262 @interfaceutil.implementer(repository.ipeercommands)
262 @interfaceutil.implementer(repository.ipeercommands)
263 class localpeer(repository.peer):
263 class localpeer(repository.peer):
264 '''peer for a local repo; reflects only the most recent API'''
264 '''peer for a local repo; reflects only the most recent API'''
265
265
266 def __init__(self, repo, caps=None):
266 def __init__(self, repo, caps=None):
267 super(localpeer, self).__init__()
267 super(localpeer, self).__init__()
268
268
269 if caps is None:
269 if caps is None:
270 caps = moderncaps.copy()
270 caps = moderncaps.copy()
271 self._repo = repo.filtered(b'served')
271 self._repo = repo.filtered(b'served')
272 self.ui = repo.ui
272 self.ui = repo.ui
273 self._caps = repo._restrictcapabilities(caps)
273 self._caps = repo._restrictcapabilities(caps)
274
274
275 # Begin of _basepeer interface.
275 # Begin of _basepeer interface.
276
276
277 def url(self):
277 def url(self):
278 return self._repo.url()
278 return self._repo.url()
279
279
280 def local(self):
280 def local(self):
281 return self._repo
281 return self._repo
282
282
283 def peer(self):
283 def peer(self):
284 return self
284 return self
285
285
286 def canpush(self):
286 def canpush(self):
287 return True
287 return True
288
288
289 def close(self):
289 def close(self):
290 self._repo.close()
290 self._repo.close()
291
291
292 # End of _basepeer interface.
292 # End of _basepeer interface.
293
293
294 # Begin of _basewirecommands interface.
294 # Begin of _basewirecommands interface.
295
295
296 def branchmap(self):
296 def branchmap(self):
297 return self._repo.branchmap()
297 return self._repo.branchmap()
298
298
299 def capabilities(self):
299 def capabilities(self):
300 return self._caps
300 return self._caps
301
301
302 def clonebundles(self):
302 def clonebundles(self):
303 return self._repo.tryread(bundlecaches.CB_MANIFEST_FILE)
303 return self._repo.tryread(bundlecaches.CB_MANIFEST_FILE)
304
304
305 def debugwireargs(self, one, two, three=None, four=None, five=None):
305 def debugwireargs(self, one, two, three=None, four=None, five=None):
306 """Used to test argument passing over the wire"""
306 """Used to test argument passing over the wire"""
307 return b"%s %s %s %s %s" % (
307 return b"%s %s %s %s %s" % (
308 one,
308 one,
309 two,
309 two,
310 pycompat.bytestr(three),
310 pycompat.bytestr(three),
311 pycompat.bytestr(four),
311 pycompat.bytestr(four),
312 pycompat.bytestr(five),
312 pycompat.bytestr(five),
313 )
313 )
314
314
315 def getbundle(
315 def getbundle(
316 self, source, heads=None, common=None, bundlecaps=None, **kwargs
316 self, source, heads=None, common=None, bundlecaps=None, **kwargs
317 ):
317 ):
318 chunks = exchange.getbundlechunks(
318 chunks = exchange.getbundlechunks(
319 self._repo,
319 self._repo,
320 source,
320 source,
321 heads=heads,
321 heads=heads,
322 common=common,
322 common=common,
323 bundlecaps=bundlecaps,
323 bundlecaps=bundlecaps,
324 **kwargs
324 **kwargs
325 )[1]
325 )[1]
326 cb = util.chunkbuffer(chunks)
326 cb = util.chunkbuffer(chunks)
327
327
328 if exchange.bundle2requested(bundlecaps):
328 if exchange.bundle2requested(bundlecaps):
329 # When requesting a bundle2, getbundle returns a stream to make the
329 # When requesting a bundle2, getbundle returns a stream to make the
330 # wire level function happier. We need to build a proper object
330 # wire level function happier. We need to build a proper object
331 # from it in local peer.
331 # from it in local peer.
332 return bundle2.getunbundler(self.ui, cb)
332 return bundle2.getunbundler(self.ui, cb)
333 else:
333 else:
334 return changegroup.getunbundler(b'01', cb, None)
334 return changegroup.getunbundler(b'01', cb, None)
335
335
336 def heads(self):
336 def heads(self):
337 return self._repo.heads()
337 return self._repo.heads()
338
338
339 def known(self, nodes):
339 def known(self, nodes):
340 return self._repo.known(nodes)
340 return self._repo.known(nodes)
341
341
342 def listkeys(self, namespace):
342 def listkeys(self, namespace):
343 return self._repo.listkeys(namespace)
343 return self._repo.listkeys(namespace)
344
344
345 def lookup(self, key):
345 def lookup(self, key):
346 return self._repo.lookup(key)
346 return self._repo.lookup(key)
347
347
348 def pushkey(self, namespace, key, old, new):
348 def pushkey(self, namespace, key, old, new):
349 return self._repo.pushkey(namespace, key, old, new)
349 return self._repo.pushkey(namespace, key, old, new)
350
350
351 def stream_out(self):
351 def stream_out(self):
352 raise error.Abort(_(b'cannot perform stream clone against local peer'))
352 raise error.Abort(_(b'cannot perform stream clone against local peer'))
353
353
354 def unbundle(self, bundle, heads, url):
354 def unbundle(self, bundle, heads, url):
355 """apply a bundle on a repo
355 """apply a bundle on a repo
356
356
357 This function handles the repo locking itself."""
357 This function handles the repo locking itself."""
358 try:
358 try:
359 try:
359 try:
360 bundle = exchange.readbundle(self.ui, bundle, None)
360 bundle = exchange.readbundle(self.ui, bundle, None)
361 ret = exchange.unbundle(self._repo, bundle, heads, b'push', url)
361 ret = exchange.unbundle(self._repo, bundle, heads, b'push', url)
362 if util.safehasattr(ret, b'getchunks'):
362 if util.safehasattr(ret, b'getchunks'):
363 # This is a bundle20 object, turn it into an unbundler.
363 # This is a bundle20 object, turn it into an unbundler.
364 # This little dance should be dropped eventually when the
364 # This little dance should be dropped eventually when the
365 # API is finally improved.
365 # API is finally improved.
366 stream = util.chunkbuffer(ret.getchunks())
366 stream = util.chunkbuffer(ret.getchunks())
367 ret = bundle2.getunbundler(self.ui, stream)
367 ret = bundle2.getunbundler(self.ui, stream)
368 return ret
368 return ret
369 except Exception as exc:
369 except Exception as exc:
370 # If the exception contains output salvaged from a bundle2
370 # If the exception contains output salvaged from a bundle2
371 # reply, we need to make sure it is printed before continuing
371 # reply, we need to make sure it is printed before continuing
372 # to fail. So we build a bundle2 with such output and consume
372 # to fail. So we build a bundle2 with such output and consume
373 # it directly.
373 # it directly.
374 #
374 #
375 # This is not very elegant but allows a "simple" solution for
375 # This is not very elegant but allows a "simple" solution for
376 # issue4594
376 # issue4594
377 output = getattr(exc, '_bundle2salvagedoutput', ())
377 output = getattr(exc, '_bundle2salvagedoutput', ())
378 if output:
378 if output:
379 bundler = bundle2.bundle20(self._repo.ui)
379 bundler = bundle2.bundle20(self._repo.ui)
380 for out in output:
380 for out in output:
381 bundler.addpart(out)
381 bundler.addpart(out)
382 stream = util.chunkbuffer(bundler.getchunks())
382 stream = util.chunkbuffer(bundler.getchunks())
383 b = bundle2.getunbundler(self.ui, stream)
383 b = bundle2.getunbundler(self.ui, stream)
384 bundle2.processbundle(self._repo, b)
384 bundle2.processbundle(self._repo, b)
385 raise
385 raise
386 except error.PushRaced as exc:
386 except error.PushRaced as exc:
387 raise error.ResponseError(
387 raise error.ResponseError(
388 _(b'push failed:'), stringutil.forcebytestr(exc)
388 _(b'push failed:'), stringutil.forcebytestr(exc)
389 )
389 )
390
390
391 # End of _basewirecommands interface.
391 # End of _basewirecommands interface.
392
392
393 # Begin of peer interface.
393 # Begin of peer interface.
394
394
395 def commandexecutor(self):
395 def commandexecutor(self):
396 return localcommandexecutor(self)
396 return localcommandexecutor(self)
397
397
398 # End of peer interface.
398 # End of peer interface.
399
399
400
400
401 @interfaceutil.implementer(repository.ipeerlegacycommands)
401 @interfaceutil.implementer(repository.ipeerlegacycommands)
402 class locallegacypeer(localpeer):
402 class locallegacypeer(localpeer):
403 """peer extension which implements legacy methods too; used for tests with
403 """peer extension which implements legacy methods too; used for tests with
404 restricted capabilities"""
404 restricted capabilities"""
405
405
406 def __init__(self, repo):
406 def __init__(self, repo):
407 super(locallegacypeer, self).__init__(repo, caps=legacycaps)
407 super(locallegacypeer, self).__init__(repo, caps=legacycaps)
408
408
409 # Begin of baselegacywirecommands interface.
409 # Begin of baselegacywirecommands interface.
410
410
411 def between(self, pairs):
411 def between(self, pairs):
412 return self._repo.between(pairs)
412 return self._repo.between(pairs)
413
413
414 def branches(self, nodes):
414 def branches(self, nodes):
415 return self._repo.branches(nodes)
415 return self._repo.branches(nodes)
416
416
417 def changegroup(self, nodes, source):
417 def changegroup(self, nodes, source):
418 outgoing = discovery.outgoing(
418 outgoing = discovery.outgoing(
419 self._repo, missingroots=nodes, ancestorsof=self._repo.heads()
419 self._repo, missingroots=nodes, ancestorsof=self._repo.heads()
420 )
420 )
421 return changegroup.makechangegroup(self._repo, outgoing, b'01', source)
421 return changegroup.makechangegroup(self._repo, outgoing, b'01', source)
422
422
423 def changegroupsubset(self, bases, heads, source):
423 def changegroupsubset(self, bases, heads, source):
424 outgoing = discovery.outgoing(
424 outgoing = discovery.outgoing(
425 self._repo, missingroots=bases, ancestorsof=heads
425 self._repo, missingroots=bases, ancestorsof=heads
426 )
426 )
427 return changegroup.makechangegroup(self._repo, outgoing, b'01', source)
427 return changegroup.makechangegroup(self._repo, outgoing, b'01', source)
428
428
429 # End of baselegacywirecommands interface.
429 # End of baselegacywirecommands interface.
430
430
431
431
432 # Functions receiving (ui, features) that extensions can register to impact
432 # Functions receiving (ui, features) that extensions can register to impact
433 # the ability to load repositories with custom requirements. Only
433 # the ability to load repositories with custom requirements. Only
434 # functions defined in loaded extensions are called.
434 # functions defined in loaded extensions are called.
435 #
435 #
436 # The function receives a set of requirement strings that the repository
436 # The function receives a set of requirement strings that the repository
437 # is capable of opening. Functions will typically add elements to the
437 # is capable of opening. Functions will typically add elements to the
438 # set to reflect that the extension knows how to handle that requirements.
438 # set to reflect that the extension knows how to handle that requirements.
439 featuresetupfuncs = set()
439 featuresetupfuncs = set()
440
440
441
441
442 def _getsharedvfs(hgvfs, requirements):
442 def _getsharedvfs(hgvfs, requirements):
443 """returns the vfs object pointing to root of shared source
443 """returns the vfs object pointing to root of shared source
444 repo for a shared repository
444 repo for a shared repository
445
445
446 hgvfs is vfs pointing at .hg/ of current repo (shared one)
446 hgvfs is vfs pointing at .hg/ of current repo (shared one)
447 requirements is a set of requirements of current repo (shared one)
447 requirements is a set of requirements of current repo (shared one)
448 """
448 """
449 # The ``shared`` or ``relshared`` requirements indicate the
449 # The ``shared`` or ``relshared`` requirements indicate the
450 # store lives in the path contained in the ``.hg/sharedpath`` file.
450 # store lives in the path contained in the ``.hg/sharedpath`` file.
451 # This is an absolute path for ``shared`` and relative to
451 # This is an absolute path for ``shared`` and relative to
452 # ``.hg/`` for ``relshared``.
452 # ``.hg/`` for ``relshared``.
453 sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
453 sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
454 if requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements:
454 if requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements:
455 sharedpath = hgvfs.join(sharedpath)
455 sharedpath = hgvfs.join(sharedpath)
456
456
457 sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
457 sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
458
458
459 if not sharedvfs.exists():
459 if not sharedvfs.exists():
460 raise error.RepoError(
460 raise error.RepoError(
461 _(b'.hg/sharedpath points to nonexistent directory %s')
461 _(b'.hg/sharedpath points to nonexistent directory %s')
462 % sharedvfs.base
462 % sharedvfs.base
463 )
463 )
464 return sharedvfs
464 return sharedvfs
465
465
466
466
467 def _readrequires(vfs, allowmissing):
467 def _readrequires(vfs, allowmissing):
468 """reads the require file present at root of this vfs
468 """reads the require file present at root of this vfs
469 and return a set of requirements
469 and return a set of requirements
470
470
471 If allowmissing is True, we suppress ENOENT if raised"""
471 If allowmissing is True, we suppress ENOENT if raised"""
472 # requires file contains a newline-delimited list of
472 # requires file contains a newline-delimited list of
473 # features/capabilities the opener (us) must have in order to use
473 # features/capabilities the opener (us) must have in order to use
474 # the repository. This file was introduced in Mercurial 0.9.2,
474 # the repository. This file was introduced in Mercurial 0.9.2,
475 # which means very old repositories may not have one. We assume
475 # which means very old repositories may not have one. We assume
476 # a missing file translates to no requirements.
476 # a missing file translates to no requirements.
477 try:
477 try:
478 requirements = set(vfs.read(b'requires').splitlines())
478 requirements = set(vfs.read(b'requires').splitlines())
479 except IOError as e:
479 except IOError as e:
480 if not (allowmissing and e.errno == errno.ENOENT):
480 if not (allowmissing and e.errno == errno.ENOENT):
481 raise
481 raise
482 requirements = set()
482 requirements = set()
483 return requirements
483 return requirements
484
484
485
485
486 def makelocalrepository(baseui, path, intents=None):
486 def makelocalrepository(baseui, path, intents=None):
487 """Create a local repository object.
487 """Create a local repository object.
488
488
489 Given arguments needed to construct a local repository, this function
489 Given arguments needed to construct a local repository, this function
490 performs various early repository loading functionality (such as
490 performs various early repository loading functionality (such as
491 reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
491 reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
492 the repository can be opened, derives a type suitable for representing
492 the repository can be opened, derives a type suitable for representing
493 that repository, and returns an instance of it.
493 that repository, and returns an instance of it.
494
494
495 The returned object conforms to the ``repository.completelocalrepository``
495 The returned object conforms to the ``repository.completelocalrepository``
496 interface.
496 interface.
497
497
498 The repository type is derived by calling a series of factory functions
498 The repository type is derived by calling a series of factory functions
499 for each aspect/interface of the final repository. These are defined by
499 for each aspect/interface of the final repository. These are defined by
500 ``REPO_INTERFACES``.
500 ``REPO_INTERFACES``.
501
501
502 Each factory function is called to produce a type implementing a specific
502 Each factory function is called to produce a type implementing a specific
503 interface. The cumulative list of returned types will be combined into a
503 interface. The cumulative list of returned types will be combined into a
504 new type and that type will be instantiated to represent the local
504 new type and that type will be instantiated to represent the local
505 repository.
505 repository.
506
506
507 The factory functions each receive various state that may be consulted
507 The factory functions each receive various state that may be consulted
508 as part of deriving a type.
508 as part of deriving a type.
509
509
510 Extensions should wrap these factory functions to customize repository type
510 Extensions should wrap these factory functions to customize repository type
511 creation. Note that an extension's wrapped function may be called even if
511 creation. Note that an extension's wrapped function may be called even if
512 that extension is not loaded for the repo being constructed. Extensions
512 that extension is not loaded for the repo being constructed. Extensions
513 should check if their ``__name__`` appears in the
513 should check if their ``__name__`` appears in the
514 ``extensionmodulenames`` set passed to the factory function and no-op if
514 ``extensionmodulenames`` set passed to the factory function and no-op if
515 not.
515 not.
516 """
516 """
517 ui = baseui.copy()
517 ui = baseui.copy()
518 # Prevent copying repo configuration.
518 # Prevent copying repo configuration.
519 ui.copy = baseui.copy
519 ui.copy = baseui.copy
520
520
521 # Working directory VFS rooted at repository root.
521 # Working directory VFS rooted at repository root.
522 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
522 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
523
523
524 # Main VFS for .hg/ directory.
524 # Main VFS for .hg/ directory.
525 hgpath = wdirvfs.join(b'.hg')
525 hgpath = wdirvfs.join(b'.hg')
526 hgvfs = vfsmod.vfs(hgpath, cacheaudited=True)
526 hgvfs = vfsmod.vfs(hgpath, cacheaudited=True)
527 # Whether this repository is shared one or not
527 # Whether this repository is shared one or not
528 shared = False
528 shared = False
529 # If this repository is shared, vfs pointing to shared repo
529 # If this repository is shared, vfs pointing to shared repo
530 sharedvfs = None
530 sharedvfs = None
531
531
532 # The .hg/ path should exist and should be a directory. All other
532 # The .hg/ path should exist and should be a directory. All other
533 # cases are errors.
533 # cases are errors.
534 if not hgvfs.isdir():
534 if not hgvfs.isdir():
535 try:
535 try:
536 hgvfs.stat()
536 hgvfs.stat()
537 except OSError as e:
537 except OSError as e:
538 if e.errno != errno.ENOENT:
538 if e.errno != errno.ENOENT:
539 raise
539 raise
540 except ValueError as e:
540 except ValueError as e:
541 # Can be raised on Python 3.8 when path is invalid.
541 # Can be raised on Python 3.8 when path is invalid.
542 raise error.Abort(
542 raise error.Abort(
543 _(b'invalid path %s: %s') % (path, pycompat.bytestr(e))
543 _(b'invalid path %s: %s') % (path, pycompat.bytestr(e))
544 )
544 )
545
545
546 raise error.RepoError(_(b'repository %s not found') % path)
546 raise error.RepoError(_(b'repository %s not found') % path)
547
547
548 requirements = _readrequires(hgvfs, True)
548 requirements = _readrequires(hgvfs, True)
549 shared = (
549 shared = (
550 requirementsmod.SHARED_REQUIREMENT in requirements
550 requirementsmod.SHARED_REQUIREMENT in requirements
551 or requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements
551 or requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements
552 )
552 )
553 storevfs = None
553 storevfs = None
554 if shared:
554 if shared:
555 # This is a shared repo
555 # This is a shared repo
556 sharedvfs = _getsharedvfs(hgvfs, requirements)
556 sharedvfs = _getsharedvfs(hgvfs, requirements)
557 storevfs = vfsmod.vfs(sharedvfs.join(b'store'))
557 storevfs = vfsmod.vfs(sharedvfs.join(b'store'))
558 else:
558 else:
559 storevfs = vfsmod.vfs(hgvfs.join(b'store'))
559 storevfs = vfsmod.vfs(hgvfs.join(b'store'))
560
560
561 # if .hg/requires contains the sharesafe requirement, it means
561 # if .hg/requires contains the sharesafe requirement, it means
562 # there exists a `.hg/store/requires` too and we should read it
562 # there exists a `.hg/store/requires` too and we should read it
563 # NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
563 # NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
564 # is present. We never write SHARESAFE_REQUIREMENT for a repo if store
564 # is present. We never write SHARESAFE_REQUIREMENT for a repo if store
565 # is not present, refer checkrequirementscompat() for that
565 # is not present, refer checkrequirementscompat() for that
566 #
566 #
567 # However, if SHARESAFE_REQUIREMENT is not present, it means that the
567 # However, if SHARESAFE_REQUIREMENT is not present, it means that the
568 # repository was shared the old way. We check the share source .hg/requires
568 # repository was shared the old way. We check the share source .hg/requires
569 # for SHARESAFE_REQUIREMENT to detect whether the current repository needs
569 # for SHARESAFE_REQUIREMENT to detect whether the current repository needs
570 # to be reshared
570 # to be reshared
571 if requirementsmod.SHARESAFE_REQUIREMENT in requirements:
571 if requirementsmod.SHARESAFE_REQUIREMENT in requirements:
572
572
573 if (
573 if (
574 shared
574 shared
575 and requirementsmod.SHARESAFE_REQUIREMENT
575 and requirementsmod.SHARESAFE_REQUIREMENT
576 not in _readrequires(sharedvfs, True)
576 not in _readrequires(sharedvfs, True)
577 ):
577 ):
578 mismatch_warn = ui.configbool(
578 mismatch_warn = ui.configbool(
579 b'share', b'safe-mismatch.source-not-safe.warn'
579 b'share', b'safe-mismatch.source-not-safe.warn'
580 )
580 )
581 mismatch_config = ui.config(
581 mismatch_config = ui.config(
582 b'share', b'safe-mismatch.source-not-safe'
582 b'share', b'safe-mismatch.source-not-safe'
583 )
583 )
584 if mismatch_config in (
584 if mismatch_config in (
585 b'downgrade-allow',
585 b'downgrade-allow',
586 b'allow',
586 b'allow',
587 b'downgrade-abort',
587 b'downgrade-abort',
588 ):
588 ):
589 # prevent cyclic import localrepo -> upgrade -> localrepo
589 # prevent cyclic import localrepo -> upgrade -> localrepo
590 from . import upgrade
590 from . import upgrade
591
591
592 upgrade.downgrade_share_to_non_safe(
592 upgrade.downgrade_share_to_non_safe(
593 ui,
593 ui,
594 hgvfs,
594 hgvfs,
595 sharedvfs,
595 sharedvfs,
596 requirements,
596 requirements,
597 mismatch_config,
597 mismatch_config,
598 mismatch_warn,
598 mismatch_warn,
599 )
599 )
600 elif mismatch_config == b'abort':
600 elif mismatch_config == b'abort':
601 raise error.Abort(
601 raise error.Abort(
602 _(
602 _(
603 b"share source does not support exp-sharesafe requirement"
603 b"share source does not support exp-sharesafe requirement"
604 )
604 )
605 )
605 )
606 else:
606 else:
607 hint = _(
607 hint = _(
608 "run `hg help config.share.safe-mismatch.source-not-safe`"
608 "run `hg help config.share.safe-mismatch.source-not-safe`"
609 )
609 )
610 raise error.Abort(
610 raise error.Abort(
611 _(
611 _(
612 b"share-safe mismatch with source.\nUnrecognized"
612 b"share-safe mismatch with source.\nUnrecognized"
613 b" value '%s' of `share.safe-mismatch.source-not-safe`"
613 b" value '%s' of `share.safe-mismatch.source-not-safe`"
614 b" set."
614 b" set."
615 )
615 )
616 % mismatch_config,
616 % mismatch_config,
617 hint=hint,
617 hint=hint,
618 )
618 )
619 else:
619 else:
620 requirements |= _readrequires(storevfs, False)
620 requirements |= _readrequires(storevfs, False)
621 elif shared:
621 elif shared:
622 sourcerequires = _readrequires(sharedvfs, False)
622 sourcerequires = _readrequires(sharedvfs, False)
623 if requirementsmod.SHARESAFE_REQUIREMENT in sourcerequires:
623 if requirementsmod.SHARESAFE_REQUIREMENT in sourcerequires:
624 mismatch_config = ui.config(b'share', b'safe-mismatch.source-safe')
624 mismatch_config = ui.config(b'share', b'safe-mismatch.source-safe')
625 mismatch_warn = ui.configbool(
625 mismatch_warn = ui.configbool(
626 b'share', b'safe-mismatch.source-safe.warn'
626 b'share', b'safe-mismatch.source-safe.warn'
627 )
627 )
628 if mismatch_config in (
628 if mismatch_config in (
629 b'upgrade-allow',
629 b'upgrade-allow',
630 b'allow',
630 b'allow',
631 b'upgrade-abort',
631 b'upgrade-abort',
632 ):
632 ):
633 # prevent cyclic import localrepo -> upgrade -> localrepo
633 # prevent cyclic import localrepo -> upgrade -> localrepo
634 from . import upgrade
634 from . import upgrade
635
635
636 upgrade.upgrade_share_to_safe(
636 upgrade.upgrade_share_to_safe(
637 ui,
637 ui,
638 hgvfs,
638 hgvfs,
639 storevfs,
639 storevfs,
640 requirements,
640 requirements,
641 mismatch_config,
641 mismatch_config,
642 mismatch_warn,
642 mismatch_warn,
643 )
643 )
644 elif mismatch_config == b'abort':
644 elif mismatch_config == b'abort':
645 raise error.Abort(
645 raise error.Abort(
646 _(
646 _(
647 b'version mismatch: source uses share-safe'
647 b'version mismatch: source uses share-safe'
648 b' functionality while the current share does not'
648 b' functionality while the current share does not'
649 )
649 )
650 )
650 )
651 else:
651 else:
652 hint = _("run `hg help config.share.safe-mismatch.source-safe`")
652 hint = _("run `hg help config.share.safe-mismatch.source-safe`")
653 raise error.Abort(
653 raise error.Abort(
654 _(
654 _(
655 b"share-safe mismatch with source.\nUnrecognized"
655 b"share-safe mismatch with source.\nUnrecognized"
656 b" value '%s' of `share.safe-mismatch.source-safe` set."
656 b" value '%s' of `share.safe-mismatch.source-safe` set."
657 )
657 )
658 % mismatch_config,
658 % mismatch_config,
659 hint=hint,
659 hint=hint,
660 )
660 )
661
661
662 # The .hg/hgrc file may load extensions or contain config options
662 # The .hg/hgrc file may load extensions or contain config options
663 # that influence repository construction. Attempt to load it and
663 # that influence repository construction. Attempt to load it and
664 # process any new extensions that it may have pulled in.
664 # process any new extensions that it may have pulled in.
665 if loadhgrc(ui, wdirvfs, hgvfs, requirements, sharedvfs):
665 if loadhgrc(ui, wdirvfs, hgvfs, requirements, sharedvfs):
666 afterhgrcload(ui, wdirvfs, hgvfs, requirements)
666 afterhgrcload(ui, wdirvfs, hgvfs, requirements)
667 extensions.loadall(ui)
667 extensions.loadall(ui)
668 extensions.populateui(ui)
668 extensions.populateui(ui)
669
669
670 # Set of module names of extensions loaded for this repository.
670 # Set of module names of extensions loaded for this repository.
671 extensionmodulenames = {m.__name__ for n, m in extensions.extensions(ui)}
671 extensionmodulenames = {m.__name__ for n, m in extensions.extensions(ui)}
672
672
673 supportedrequirements = gathersupportedrequirements(ui)
673 supportedrequirements = gathersupportedrequirements(ui)
674
674
675 # We first validate the requirements are known.
675 # We first validate the requirements are known.
676 ensurerequirementsrecognized(requirements, supportedrequirements)
676 ensurerequirementsrecognized(requirements, supportedrequirements)
677
677
678 # Then we validate that the known set is reasonable to use together.
678 # Then we validate that the known set is reasonable to use together.
679 ensurerequirementscompatible(ui, requirements)
679 ensurerequirementscompatible(ui, requirements)
680
680
681 # TODO there are unhandled edge cases related to opening repositories with
681 # TODO there are unhandled edge cases related to opening repositories with
682 # shared storage. If storage is shared, we should also test for requirements
682 # shared storage. If storage is shared, we should also test for requirements
683 # compatibility in the pointed-to repo. This entails loading the .hg/hgrc in
683 # compatibility in the pointed-to repo. This entails loading the .hg/hgrc in
684 # that repo, as that repo may load extensions needed to open it. This is a
684 # that repo, as that repo may load extensions needed to open it. This is a
685 # bit complicated because we don't want the other hgrc to overwrite settings
685 # bit complicated because we don't want the other hgrc to overwrite settings
686 # in this hgrc.
686 # in this hgrc.
687 #
687 #
688 # This bug is somewhat mitigated by the fact that we copy the .hg/requires
688 # This bug is somewhat mitigated by the fact that we copy the .hg/requires
689 # file when sharing repos. But if a requirement is added after the share is
689 # file when sharing repos. But if a requirement is added after the share is
690 # performed, thereby introducing a new requirement for the opener, we may
690 # performed, thereby introducing a new requirement for the opener, we may
691 # will not see that and could encounter a run-time error interacting with
691 # will not see that and could encounter a run-time error interacting with
692 # that shared store since it has an unknown-to-us requirement.
692 # that shared store since it has an unknown-to-us requirement.
693
693
694 # At this point, we know we should be capable of opening the repository.
694 # At this point, we know we should be capable of opening the repository.
695 # Now get on with doing that.
695 # Now get on with doing that.
696
696
697 features = set()
697 features = set()
698
698
699 # The "store" part of the repository holds versioned data. How it is
699 # The "store" part of the repository holds versioned data. How it is
700 # accessed is determined by various requirements. If `shared` or
700 # accessed is determined by various requirements. If `shared` or
701 # `relshared` requirements are present, this indicates current repository
701 # `relshared` requirements are present, this indicates current repository
702 # is a share and store exists in path mentioned in `.hg/sharedpath`
702 # is a share and store exists in path mentioned in `.hg/sharedpath`
703 if shared:
703 if shared:
704 storebasepath = sharedvfs.base
704 storebasepath = sharedvfs.base
705 cachepath = sharedvfs.join(b'cache')
705 cachepath = sharedvfs.join(b'cache')
706 features.add(repository.REPO_FEATURE_SHARED_STORAGE)
706 features.add(repository.REPO_FEATURE_SHARED_STORAGE)
707 else:
707 else:
708 storebasepath = hgvfs.base
708 storebasepath = hgvfs.base
709 cachepath = hgvfs.join(b'cache')
709 cachepath = hgvfs.join(b'cache')
710 wcachepath = hgvfs.join(b'wcache')
710 wcachepath = hgvfs.join(b'wcache')
711
711
712 # The store has changed over time and the exact layout is dictated by
712 # The store has changed over time and the exact layout is dictated by
713 # requirements. The store interface abstracts differences across all
713 # requirements. The store interface abstracts differences across all
714 # of them.
714 # of them.
715 store = makestore(
715 store = makestore(
716 requirements,
716 requirements,
717 storebasepath,
717 storebasepath,
718 lambda base: vfsmod.vfs(base, cacheaudited=True),
718 lambda base: vfsmod.vfs(base, cacheaudited=True),
719 )
719 )
720 hgvfs.createmode = store.createmode
720 hgvfs.createmode = store.createmode
721
721
722 storevfs = store.vfs
722 storevfs = store.vfs
723 storevfs.options = resolvestorevfsoptions(ui, requirements, features)
723 storevfs.options = resolvestorevfsoptions(ui, requirements, features)
724
724
725 # The cache vfs is used to manage cache files.
725 # The cache vfs is used to manage cache files.
726 cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
726 cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
727 cachevfs.createmode = store.createmode
727 cachevfs.createmode = store.createmode
728 # The cache vfs is used to manage cache files related to the working copy
728 # The cache vfs is used to manage cache files related to the working copy
729 wcachevfs = vfsmod.vfs(wcachepath, cacheaudited=True)
729 wcachevfs = vfsmod.vfs(wcachepath, cacheaudited=True)
730 wcachevfs.createmode = store.createmode
730 wcachevfs.createmode = store.createmode
731
731
732 # Now resolve the type for the repository object. We do this by repeatedly
732 # Now resolve the type for the repository object. We do this by repeatedly
733 # calling a factory function to produces types for specific aspects of the
733 # calling a factory function to produces types for specific aspects of the
734 # repo's operation. The aggregate returned types are used as base classes
734 # repo's operation. The aggregate returned types are used as base classes
735 # for a dynamically-derived type, which will represent our new repository.
735 # for a dynamically-derived type, which will represent our new repository.
736
736
737 bases = []
737 bases = []
738 extrastate = {}
738 extrastate = {}
739
739
740 for iface, fn in REPO_INTERFACES:
740 for iface, fn in REPO_INTERFACES:
741 # We pass all potentially useful state to give extensions tons of
741 # We pass all potentially useful state to give extensions tons of
742 # flexibility.
742 # flexibility.
743 typ = fn()(
743 typ = fn()(
744 ui=ui,
744 ui=ui,
745 intents=intents,
745 intents=intents,
746 requirements=requirements,
746 requirements=requirements,
747 features=features,
747 features=features,
748 wdirvfs=wdirvfs,
748 wdirvfs=wdirvfs,
749 hgvfs=hgvfs,
749 hgvfs=hgvfs,
750 store=store,
750 store=store,
751 storevfs=storevfs,
751 storevfs=storevfs,
752 storeoptions=storevfs.options,
752 storeoptions=storevfs.options,
753 cachevfs=cachevfs,
753 cachevfs=cachevfs,
754 wcachevfs=wcachevfs,
754 wcachevfs=wcachevfs,
755 extensionmodulenames=extensionmodulenames,
755 extensionmodulenames=extensionmodulenames,
756 extrastate=extrastate,
756 extrastate=extrastate,
757 baseclasses=bases,
757 baseclasses=bases,
758 )
758 )
759
759
760 if not isinstance(typ, type):
760 if not isinstance(typ, type):
761 raise error.ProgrammingError(
761 raise error.ProgrammingError(
762 b'unable to construct type for %s' % iface
762 b'unable to construct type for %s' % iface
763 )
763 )
764
764
765 bases.append(typ)
765 bases.append(typ)
766
766
767 # type() allows you to use characters in type names that wouldn't be
767 # type() allows you to use characters in type names that wouldn't be
768 # recognized as Python symbols in source code. We abuse that to add
768 # recognized as Python symbols in source code. We abuse that to add
769 # rich information about our constructed repo.
769 # rich information about our constructed repo.
770 name = pycompat.sysstr(
770 name = pycompat.sysstr(
771 b'derivedrepo:%s<%s>' % (wdirvfs.base, b','.join(sorted(requirements)))
771 b'derivedrepo:%s<%s>' % (wdirvfs.base, b','.join(sorted(requirements)))
772 )
772 )
773
773
774 cls = type(name, tuple(bases), {})
774 cls = type(name, tuple(bases), {})
775
775
776 return cls(
776 return cls(
777 baseui=baseui,
777 baseui=baseui,
778 ui=ui,
778 ui=ui,
779 origroot=path,
779 origroot=path,
780 wdirvfs=wdirvfs,
780 wdirvfs=wdirvfs,
781 hgvfs=hgvfs,
781 hgvfs=hgvfs,
782 requirements=requirements,
782 requirements=requirements,
783 supportedrequirements=supportedrequirements,
783 supportedrequirements=supportedrequirements,
784 sharedpath=storebasepath,
784 sharedpath=storebasepath,
785 store=store,
785 store=store,
786 cachevfs=cachevfs,
786 cachevfs=cachevfs,
787 wcachevfs=wcachevfs,
787 wcachevfs=wcachevfs,
788 features=features,
788 features=features,
789 intents=intents,
789 intents=intents,
790 )
790 )
791
791
792
792
793 def loadhgrc(ui, wdirvfs, hgvfs, requirements, sharedvfs=None):
793 def loadhgrc(ui, wdirvfs, hgvfs, requirements, sharedvfs=None):
794 """Load hgrc files/content into a ui instance.
794 """Load hgrc files/content into a ui instance.
795
795
796 This is called during repository opening to load any additional
796 This is called during repository opening to load any additional
797 config files or settings relevant to the current repository.
797 config files or settings relevant to the current repository.
798
798
799 Returns a bool indicating whether any additional configs were loaded.
799 Returns a bool indicating whether any additional configs were loaded.
800
800
801 Extensions should monkeypatch this function to modify how per-repo
801 Extensions should monkeypatch this function to modify how per-repo
802 configs are loaded. For example, an extension may wish to pull in
802 configs are loaded. For example, an extension may wish to pull in
803 configs from alternate files or sources.
803 configs from alternate files or sources.
804
804
805 sharedvfs is vfs object pointing to source repo if the current one is a
805 sharedvfs is vfs object pointing to source repo if the current one is a
806 shared one
806 shared one
807 """
807 """
808 if not rcutil.use_repo_hgrc():
808 if not rcutil.use_repo_hgrc():
809 return False
809 return False
810
810
811 ret = False
811 ret = False
812 # first load config from shared source if we has to
812 # first load config from shared source if we has to
813 if requirementsmod.SHARESAFE_REQUIREMENT in requirements and sharedvfs:
813 if requirementsmod.SHARESAFE_REQUIREMENT in requirements and sharedvfs:
814 try:
814 try:
815 ui.readconfig(sharedvfs.join(b'hgrc'), root=sharedvfs.base)
815 ui.readconfig(sharedvfs.join(b'hgrc'), root=sharedvfs.base)
816 ret = True
816 ret = True
817 except IOError:
817 except IOError:
818 pass
818 pass
819
819
820 try:
820 try:
821 ui.readconfig(hgvfs.join(b'hgrc'), root=wdirvfs.base)
821 ui.readconfig(hgvfs.join(b'hgrc'), root=wdirvfs.base)
822 ret = True
822 ret = True
823 except IOError:
823 except IOError:
824 pass
824 pass
825
825
826 try:
826 try:
827 ui.readconfig(hgvfs.join(b'hgrc-not-shared'), root=wdirvfs.base)
827 ui.readconfig(hgvfs.join(b'hgrc-not-shared'), root=wdirvfs.base)
828 ret = True
828 ret = True
829 except IOError:
829 except IOError:
830 pass
830 pass
831
831
832 return ret
832 return ret
833
833
834
834
835 def afterhgrcload(ui, wdirvfs, hgvfs, requirements):
835 def afterhgrcload(ui, wdirvfs, hgvfs, requirements):
836 """Perform additional actions after .hg/hgrc is loaded.
836 """Perform additional actions after .hg/hgrc is loaded.
837
837
838 This function is called during repository loading immediately after
838 This function is called during repository loading immediately after
839 the .hg/hgrc file is loaded and before per-repo extensions are loaded.
839 the .hg/hgrc file is loaded and before per-repo extensions are loaded.
840
840
841 The function can be used to validate configs, automatically add
841 The function can be used to validate configs, automatically add
842 options (including extensions) based on requirements, etc.
842 options (including extensions) based on requirements, etc.
843 """
843 """
844
844
845 # Map of requirements to list of extensions to load automatically when
845 # Map of requirements to list of extensions to load automatically when
846 # requirement is present.
846 # requirement is present.
847 autoextensions = {
847 autoextensions = {
848 b'git': [b'git'],
848 b'git': [b'git'],
849 b'largefiles': [b'largefiles'],
849 b'largefiles': [b'largefiles'],
850 b'lfs': [b'lfs'],
850 b'lfs': [b'lfs'],
851 }
851 }
852
852
853 for requirement, names in sorted(autoextensions.items()):
853 for requirement, names in sorted(autoextensions.items()):
854 if requirement not in requirements:
854 if requirement not in requirements:
855 continue
855 continue
856
856
857 for name in names:
857 for name in names:
858 if not ui.hasconfig(b'extensions', name):
858 if not ui.hasconfig(b'extensions', name):
859 ui.setconfig(b'extensions', name, b'', source=b'autoload')
859 ui.setconfig(b'extensions', name, b'', source=b'autoload')
860
860
861
861
862 def gathersupportedrequirements(ui):
862 def gathersupportedrequirements(ui):
863 """Determine the complete set of recognized requirements."""
863 """Determine the complete set of recognized requirements."""
864 # Start with all requirements supported by this file.
864 # Start with all requirements supported by this file.
865 supported = set(localrepository._basesupported)
865 supported = set(localrepository._basesupported)
866
866
867 # Execute ``featuresetupfuncs`` entries if they belong to an extension
867 # Execute ``featuresetupfuncs`` entries if they belong to an extension
868 # relevant to this ui instance.
868 # relevant to this ui instance.
869 modules = {m.__name__ for n, m in extensions.extensions(ui)}
869 modules = {m.__name__ for n, m in extensions.extensions(ui)}
870
870
871 for fn in featuresetupfuncs:
871 for fn in featuresetupfuncs:
872 if fn.__module__ in modules:
872 if fn.__module__ in modules:
873 fn(ui, supported)
873 fn(ui, supported)
874
874
875 # Add derived requirements from registered compression engines.
875 # Add derived requirements from registered compression engines.
876 for name in util.compengines:
876 for name in util.compengines:
877 engine = util.compengines[name]
877 engine = util.compengines[name]
878 if engine.available() and engine.revlogheader():
878 if engine.available() and engine.revlogheader():
879 supported.add(b'exp-compression-%s' % name)
879 supported.add(b'exp-compression-%s' % name)
880 if engine.name() == b'zstd':
880 if engine.name() == b'zstd':
881 supported.add(b'revlog-compression-zstd')
881 supported.add(b'revlog-compression-zstd')
882
882
883 return supported
883 return supported
884
884
885
885
886 def ensurerequirementsrecognized(requirements, supported):
886 def ensurerequirementsrecognized(requirements, supported):
887 """Validate that a set of local requirements is recognized.
887 """Validate that a set of local requirements is recognized.
888
888
889 Receives a set of requirements. Raises an ``error.RepoError`` if there
889 Receives a set of requirements. Raises an ``error.RepoError`` if there
890 exists any requirement in that set that currently loaded code doesn't
890 exists any requirement in that set that currently loaded code doesn't
891 recognize.
891 recognize.
892
892
893 Returns a set of supported requirements.
893 Returns a set of supported requirements.
894 """
894 """
895 missing = set()
895 missing = set()
896
896
897 for requirement in requirements:
897 for requirement in requirements:
898 if requirement in supported:
898 if requirement in supported:
899 continue
899 continue
900
900
901 if not requirement or not requirement[0:1].isalnum():
901 if not requirement or not requirement[0:1].isalnum():
902 raise error.RequirementError(_(b'.hg/requires file is corrupt'))
902 raise error.RequirementError(_(b'.hg/requires file is corrupt'))
903
903
904 missing.add(requirement)
904 missing.add(requirement)
905
905
906 if missing:
906 if missing:
907 raise error.RequirementError(
907 raise error.RequirementError(
908 _(b'repository requires features unknown to this Mercurial: %s')
908 _(b'repository requires features unknown to this Mercurial: %s')
909 % b' '.join(sorted(missing)),
909 % b' '.join(sorted(missing)),
910 hint=_(
910 hint=_(
911 b'see https://mercurial-scm.org/wiki/MissingRequirement '
911 b'see https://mercurial-scm.org/wiki/MissingRequirement '
912 b'for more information'
912 b'for more information'
913 ),
913 ),
914 )
914 )
915
915
916
916
917 def ensurerequirementscompatible(ui, requirements):
917 def ensurerequirementscompatible(ui, requirements):
918 """Validates that a set of recognized requirements is mutually compatible.
918 """Validates that a set of recognized requirements is mutually compatible.
919
919
920 Some requirements may not be compatible with others or require
920 Some requirements may not be compatible with others or require
921 config options that aren't enabled. This function is called during
921 config options that aren't enabled. This function is called during
922 repository opening to ensure that the set of requirements needed
922 repository opening to ensure that the set of requirements needed
923 to open a repository is sane and compatible with config options.
923 to open a repository is sane and compatible with config options.
924
924
925 Extensions can monkeypatch this function to perform additional
925 Extensions can monkeypatch this function to perform additional
926 checking.
926 checking.
927
927
928 ``error.RepoError`` should be raised on failure.
928 ``error.RepoError`` should be raised on failure.
929 """
929 """
930 if (
930 if (
931 requirementsmod.SPARSE_REQUIREMENT in requirements
931 requirementsmod.SPARSE_REQUIREMENT in requirements
932 and not sparse.enabled
932 and not sparse.enabled
933 ):
933 ):
934 raise error.RepoError(
934 raise error.RepoError(
935 _(
935 _(
936 b'repository is using sparse feature but '
936 b'repository is using sparse feature but '
937 b'sparse is not enabled; enable the '
937 b'sparse is not enabled; enable the '
938 b'"sparse" extensions to access'
938 b'"sparse" extensions to access'
939 )
939 )
940 )
940 )
941
941
942
942
943 def makestore(requirements, path, vfstype):
943 def makestore(requirements, path, vfstype):
944 """Construct a storage object for a repository."""
944 """Construct a storage object for a repository."""
945 if b'store' in requirements:
945 if b'store' in requirements:
946 if b'fncache' in requirements:
946 if b'fncache' in requirements:
947 return storemod.fncachestore(
947 return storemod.fncachestore(
948 path, vfstype, b'dotencode' in requirements
948 path, vfstype, b'dotencode' in requirements
949 )
949 )
950
950
951 return storemod.encodedstore(path, vfstype)
951 return storemod.encodedstore(path, vfstype)
952
952
953 return storemod.basicstore(path, vfstype)
953 return storemod.basicstore(path, vfstype)
954
954
955
955
956 def resolvestorevfsoptions(ui, requirements, features):
956 def resolvestorevfsoptions(ui, requirements, features):
957 """Resolve the options to pass to the store vfs opener.
957 """Resolve the options to pass to the store vfs opener.
958
958
959 The returned dict is used to influence behavior of the storage layer.
959 The returned dict is used to influence behavior of the storage layer.
960 """
960 """
961 options = {}
961 options = {}
962
962
963 if requirementsmod.TREEMANIFEST_REQUIREMENT in requirements:
963 if requirementsmod.TREEMANIFEST_REQUIREMENT in requirements:
964 options[b'treemanifest'] = True
964 options[b'treemanifest'] = True
965
965
966 # experimental config: format.manifestcachesize
966 # experimental config: format.manifestcachesize
967 manifestcachesize = ui.configint(b'format', b'manifestcachesize')
967 manifestcachesize = ui.configint(b'format', b'manifestcachesize')
968 if manifestcachesize is not None:
968 if manifestcachesize is not None:
969 options[b'manifestcachesize'] = manifestcachesize
969 options[b'manifestcachesize'] = manifestcachesize
970
970
971 # In the absence of another requirement superseding a revlog-related
971 # In the absence of another requirement superseding a revlog-related
972 # requirement, we have to assume the repo is using revlog version 0.
972 # requirement, we have to assume the repo is using revlog version 0.
973 # This revlog format is super old and we don't bother trying to parse
973 # This revlog format is super old and we don't bother trying to parse
974 # opener options for it because those options wouldn't do anything
974 # opener options for it because those options wouldn't do anything
975 # meaningful on such old repos.
975 # meaningful on such old repos.
976 if (
976 if (
977 b'revlogv1' in requirements
977 b'revlogv1' in requirements
978 or requirementsmod.REVLOGV2_REQUIREMENT in requirements
978 or requirementsmod.REVLOGV2_REQUIREMENT in requirements
979 ):
979 ):
980 options.update(resolverevlogstorevfsoptions(ui, requirements, features))
980 options.update(resolverevlogstorevfsoptions(ui, requirements, features))
981 else: # explicitly mark repo as using revlogv0
981 else: # explicitly mark repo as using revlogv0
982 options[b'revlogv0'] = True
982 options[b'revlogv0'] = True
983
983
984 if requirementsmod.COPIESSDC_REQUIREMENT in requirements:
984 if requirementsmod.COPIESSDC_REQUIREMENT in requirements:
985 options[b'copies-storage'] = b'changeset-sidedata'
985 options[b'copies-storage'] = b'changeset-sidedata'
986 else:
986 else:
987 writecopiesto = ui.config(b'experimental', b'copies.write-to')
987 writecopiesto = ui.config(b'experimental', b'copies.write-to')
988 copiesextramode = (b'changeset-only', b'compatibility')
988 copiesextramode = (b'changeset-only', b'compatibility')
989 if writecopiesto in copiesextramode:
989 if writecopiesto in copiesextramode:
990 options[b'copies-storage'] = b'extra'
990 options[b'copies-storage'] = b'extra'
991
991
992 return options
992 return options
993
993
994
994
995 def resolverevlogstorevfsoptions(ui, requirements, features):
995 def resolverevlogstorevfsoptions(ui, requirements, features):
996 """Resolve opener options specific to revlogs."""
996 """Resolve opener options specific to revlogs."""
997
997
998 options = {}
998 options = {}
999 options[b'flagprocessors'] = {}
999 options[b'flagprocessors'] = {}
1000
1000
1001 if b'revlogv1' in requirements:
1001 if b'revlogv1' in requirements:
1002 options[b'revlogv1'] = True
1002 options[b'revlogv1'] = True
1003 if requirementsmod.REVLOGV2_REQUIREMENT in requirements:
1003 if requirementsmod.REVLOGV2_REQUIREMENT in requirements:
1004 options[b'revlogv2'] = True
1004 options[b'revlogv2'] = True
1005
1005
1006 if b'generaldelta' in requirements:
1006 if b'generaldelta' in requirements:
1007 options[b'generaldelta'] = True
1007 options[b'generaldelta'] = True
1008
1008
1009 # experimental config: format.chunkcachesize
1009 # experimental config: format.chunkcachesize
1010 chunkcachesize = ui.configint(b'format', b'chunkcachesize')
1010 chunkcachesize = ui.configint(b'format', b'chunkcachesize')
1011 if chunkcachesize is not None:
1011 if chunkcachesize is not None:
1012 options[b'chunkcachesize'] = chunkcachesize
1012 options[b'chunkcachesize'] = chunkcachesize
1013
1013
1014 deltabothparents = ui.configbool(
1014 deltabothparents = ui.configbool(
1015 b'storage', b'revlog.optimize-delta-parent-choice'
1015 b'storage', b'revlog.optimize-delta-parent-choice'
1016 )
1016 )
1017 options[b'deltabothparents'] = deltabothparents
1017 options[b'deltabothparents'] = deltabothparents
1018
1018
1019 lazydelta = ui.configbool(b'storage', b'revlog.reuse-external-delta')
1019 lazydelta = ui.configbool(b'storage', b'revlog.reuse-external-delta')
1020 lazydeltabase = False
1020 lazydeltabase = False
1021 if lazydelta:
1021 if lazydelta:
1022 lazydeltabase = ui.configbool(
1022 lazydeltabase = ui.configbool(
1023 b'storage', b'revlog.reuse-external-delta-parent'
1023 b'storage', b'revlog.reuse-external-delta-parent'
1024 )
1024 )
1025 if lazydeltabase is None:
1025 if lazydeltabase is None:
1026 lazydeltabase = not scmutil.gddeltaconfig(ui)
1026 lazydeltabase = not scmutil.gddeltaconfig(ui)
1027 options[b'lazydelta'] = lazydelta
1027 options[b'lazydelta'] = lazydelta
1028 options[b'lazydeltabase'] = lazydeltabase
1028 options[b'lazydeltabase'] = lazydeltabase
1029
1029
1030 chainspan = ui.configbytes(b'experimental', b'maxdeltachainspan')
1030 chainspan = ui.configbytes(b'experimental', b'maxdeltachainspan')
1031 if 0 <= chainspan:
1031 if 0 <= chainspan:
1032 options[b'maxdeltachainspan'] = chainspan
1032 options[b'maxdeltachainspan'] = chainspan
1033
1033
1034 mmapindexthreshold = ui.configbytes(b'experimental', b'mmapindexthreshold')
1034 mmapindexthreshold = ui.configbytes(b'experimental', b'mmapindexthreshold')
1035 if mmapindexthreshold is not None:
1035 if mmapindexthreshold is not None:
1036 options[b'mmapindexthreshold'] = mmapindexthreshold
1036 options[b'mmapindexthreshold'] = mmapindexthreshold
1037
1037
1038 withsparseread = ui.configbool(b'experimental', b'sparse-read')
1038 withsparseread = ui.configbool(b'experimental', b'sparse-read')
1039 srdensitythres = float(
1039 srdensitythres = float(
1040 ui.config(b'experimental', b'sparse-read.density-threshold')
1040 ui.config(b'experimental', b'sparse-read.density-threshold')
1041 )
1041 )
1042 srmingapsize = ui.configbytes(b'experimental', b'sparse-read.min-gap-size')
1042 srmingapsize = ui.configbytes(b'experimental', b'sparse-read.min-gap-size')
1043 options[b'with-sparse-read'] = withsparseread
1043 options[b'with-sparse-read'] = withsparseread
1044 options[b'sparse-read-density-threshold'] = srdensitythres
1044 options[b'sparse-read-density-threshold'] = srdensitythres
1045 options[b'sparse-read-min-gap-size'] = srmingapsize
1045 options[b'sparse-read-min-gap-size'] = srmingapsize
1046
1046
1047 sparserevlog = requirementsmod.SPARSEREVLOG_REQUIREMENT in requirements
1047 sparserevlog = requirementsmod.SPARSEREVLOG_REQUIREMENT in requirements
1048 options[b'sparse-revlog'] = sparserevlog
1048 options[b'sparse-revlog'] = sparserevlog
1049 if sparserevlog:
1049 if sparserevlog:
1050 options[b'generaldelta'] = True
1050 options[b'generaldelta'] = True
1051
1051
1052 sidedata = requirementsmod.SIDEDATA_REQUIREMENT in requirements
1052 sidedata = requirementsmod.SIDEDATA_REQUIREMENT in requirements
1053 options[b'side-data'] = sidedata
1053 options[b'side-data'] = sidedata
1054
1054
1055 maxchainlen = None
1055 maxchainlen = None
1056 if sparserevlog:
1056 if sparserevlog:
1057 maxchainlen = revlogconst.SPARSE_REVLOG_MAX_CHAIN_LENGTH
1057 maxchainlen = revlogconst.SPARSE_REVLOG_MAX_CHAIN_LENGTH
1058 # experimental config: format.maxchainlen
1058 # experimental config: format.maxchainlen
1059 maxchainlen = ui.configint(b'format', b'maxchainlen', maxchainlen)
1059 maxchainlen = ui.configint(b'format', b'maxchainlen', maxchainlen)
1060 if maxchainlen is not None:
1060 if maxchainlen is not None:
1061 options[b'maxchainlen'] = maxchainlen
1061 options[b'maxchainlen'] = maxchainlen
1062
1062
1063 for r in requirements:
1063 for r in requirements:
1064 # we allow multiple compression engine requirement to co-exist because
1064 # we allow multiple compression engine requirement to co-exist because
1065 # strickly speaking, revlog seems to support mixed compression style.
1065 # strickly speaking, revlog seems to support mixed compression style.
1066 #
1066 #
1067 # The compression used for new entries will be "the last one"
1067 # The compression used for new entries will be "the last one"
1068 prefix = r.startswith
1068 prefix = r.startswith
1069 if prefix(b'revlog-compression-') or prefix(b'exp-compression-'):
1069 if prefix(b'revlog-compression-') or prefix(b'exp-compression-'):
1070 options[b'compengine'] = r.split(b'-', 2)[2]
1070 options[b'compengine'] = r.split(b'-', 2)[2]
1071
1071
1072 options[b'zlib.level'] = ui.configint(b'storage', b'revlog.zlib.level')
1072 options[b'zlib.level'] = ui.configint(b'storage', b'revlog.zlib.level')
1073 if options[b'zlib.level'] is not None:
1073 if options[b'zlib.level'] is not None:
1074 if not (0 <= options[b'zlib.level'] <= 9):
1074 if not (0 <= options[b'zlib.level'] <= 9):
1075 msg = _(b'invalid value for `storage.revlog.zlib.level` config: %d')
1075 msg = _(b'invalid value for `storage.revlog.zlib.level` config: %d')
1076 raise error.Abort(msg % options[b'zlib.level'])
1076 raise error.Abort(msg % options[b'zlib.level'])
1077 options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level')
1077 options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level')
1078 if options[b'zstd.level'] is not None:
1078 if options[b'zstd.level'] is not None:
1079 if not (0 <= options[b'zstd.level'] <= 22):
1079 if not (0 <= options[b'zstd.level'] <= 22):
1080 msg = _(b'invalid value for `storage.revlog.zstd.level` config: %d')
1080 msg = _(b'invalid value for `storage.revlog.zstd.level` config: %d')
1081 raise error.Abort(msg % options[b'zstd.level'])
1081 raise error.Abort(msg % options[b'zstd.level'])
1082
1082
1083 if requirementsmod.NARROW_REQUIREMENT in requirements:
1083 if requirementsmod.NARROW_REQUIREMENT in requirements:
1084 options[b'enableellipsis'] = True
1084 options[b'enableellipsis'] = True
1085
1085
1086 if ui.configbool(b'experimental', b'rust.index'):
1086 if ui.configbool(b'experimental', b'rust.index'):
1087 options[b'rust.index'] = True
1087 options[b'rust.index'] = True
1088 if requirementsmod.NODEMAP_REQUIREMENT in requirements:
1088 if requirementsmod.NODEMAP_REQUIREMENT in requirements:
1089 slow_path = ui.config(
1089 slow_path = ui.config(
1090 b'storage', b'revlog.persistent-nodemap.slow-path'
1090 b'storage', b'revlog.persistent-nodemap.slow-path'
1091 )
1091 )
1092 if slow_path not in (b'allow', b'warn', b'abort'):
1092 if slow_path not in (b'allow', b'warn', b'abort'):
1093 default = ui.config_default(
1093 default = ui.config_default(
1094 b'storage', b'revlog.persistent-nodemap.slow-path'
1094 b'storage', b'revlog.persistent-nodemap.slow-path'
1095 )
1095 )
1096 msg = _(
1096 msg = _(
1097 b'unknown value for config '
1097 b'unknown value for config '
1098 b'"storage.revlog.persistent-nodemap.slow-path": "%s"\n'
1098 b'"storage.revlog.persistent-nodemap.slow-path": "%s"\n'
1099 )
1099 )
1100 ui.warn(msg % slow_path)
1100 ui.warn(msg % slow_path)
1101 if not ui.quiet:
1101 if not ui.quiet:
1102 ui.warn(_(b'falling back to default value: %s\n') % default)
1102 ui.warn(_(b'falling back to default value: %s\n') % default)
1103 slow_path = default
1103 slow_path = default
1104
1104
1105 msg = _(
1105 msg = _(
1106 b"accessing `persistent-nodemap` repository without associated "
1106 b"accessing `persistent-nodemap` repository without associated "
1107 b"fast implementation."
1107 b"fast implementation."
1108 )
1108 )
1109 hint = _(
1109 hint = _(
1110 b"check `hg help config.format.use-persistent-nodemap` "
1110 b"check `hg help config.format.use-persistent-nodemap` "
1111 b"for details"
1111 b"for details"
1112 )
1112 )
1113 if not revlog.HAS_FAST_PERSISTENT_NODEMAP:
1113 if not revlog.HAS_FAST_PERSISTENT_NODEMAP:
1114 if slow_path == b'warn':
1114 if slow_path == b'warn':
1115 msg = b"warning: " + msg + b'\n'
1115 msg = b"warning: " + msg + b'\n'
1116 ui.warn(msg)
1116 ui.warn(msg)
1117 if not ui.quiet:
1117 if not ui.quiet:
1118 hint = b'(' + hint + b')\n'
1118 hint = b'(' + hint + b')\n'
1119 ui.warn(hint)
1119 ui.warn(hint)
1120 if slow_path == b'abort':
1120 if slow_path == b'abort':
1121 raise error.Abort(msg, hint=hint)
1121 raise error.Abort(msg, hint=hint)
1122 options[b'persistent-nodemap'] = True
1122 options[b'persistent-nodemap'] = True
1123 if ui.configbool(b'storage', b'revlog.persistent-nodemap.mmap'):
1123 if ui.configbool(b'storage', b'revlog.persistent-nodemap.mmap'):
1124 options[b'persistent-nodemap.mmap'] = True
1124 options[b'persistent-nodemap.mmap'] = True
1125 if ui.configbool(b'devel', b'persistent-nodemap'):
1125 if ui.configbool(b'devel', b'persistent-nodemap'):
1126 options[b'devel-force-nodemap'] = True
1126 options[b'devel-force-nodemap'] = True
1127
1127
1128 return options
1128 return options
1129
1129
1130
1130
1131 def makemain(**kwargs):
1131 def makemain(**kwargs):
1132 """Produce a type conforming to ``ilocalrepositorymain``."""
1132 """Produce a type conforming to ``ilocalrepositorymain``."""
1133 return localrepository
1133 return localrepository
1134
1134
1135
1135
1136 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
1136 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
1137 class revlogfilestorage(object):
1137 class revlogfilestorage(object):
1138 """File storage when using revlogs."""
1138 """File storage when using revlogs."""
1139
1139
1140 def file(self, path):
1140 def file(self, path):
1141 if path[0] == b'/':
1141 if path[0] == b'/':
1142 path = path[1:]
1142 path = path[1:]
1143
1143
1144 return filelog.filelog(self.svfs, path)
1144 return filelog.filelog(self.svfs, path)
1145
1145
1146
1146
1147 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
1147 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
1148 class revlognarrowfilestorage(object):
1148 class revlognarrowfilestorage(object):
1149 """File storage when using revlogs and narrow files."""
1149 """File storage when using revlogs and narrow files."""
1150
1150
1151 def file(self, path):
1151 def file(self, path):
1152 if path[0] == b'/':
1152 if path[0] == b'/':
1153 path = path[1:]
1153 path = path[1:]
1154
1154
1155 return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
1155 return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
1156
1156
1157
1157
1158 def makefilestorage(requirements, features, **kwargs):
1158 def makefilestorage(requirements, features, **kwargs):
1159 """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
1159 """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
1160 features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
1160 features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
1161 features.add(repository.REPO_FEATURE_STREAM_CLONE)
1161 features.add(repository.REPO_FEATURE_STREAM_CLONE)
1162
1162
1163 if requirementsmod.NARROW_REQUIREMENT in requirements:
1163 if requirementsmod.NARROW_REQUIREMENT in requirements:
1164 return revlognarrowfilestorage
1164 return revlognarrowfilestorage
1165 else:
1165 else:
1166 return revlogfilestorage
1166 return revlogfilestorage
1167
1167
1168
1168
1169 # List of repository interfaces and factory functions for them. Each
1169 # List of repository interfaces and factory functions for them. Each
1170 # will be called in order during ``makelocalrepository()`` to iteratively
1170 # will be called in order during ``makelocalrepository()`` to iteratively
1171 # derive the final type for a local repository instance. We capture the
1171 # derive the final type for a local repository instance. We capture the
1172 # function as a lambda so we don't hold a reference and the module-level
1172 # function as a lambda so we don't hold a reference and the module-level
1173 # functions can be wrapped.
1173 # functions can be wrapped.
1174 REPO_INTERFACES = [
1174 REPO_INTERFACES = [
1175 (repository.ilocalrepositorymain, lambda: makemain),
1175 (repository.ilocalrepositorymain, lambda: makemain),
1176 (repository.ilocalrepositoryfilestorage, lambda: makefilestorage),
1176 (repository.ilocalrepositoryfilestorage, lambda: makefilestorage),
1177 ]
1177 ]
1178
1178
1179
1179
1180 @interfaceutil.implementer(repository.ilocalrepositorymain)
1180 @interfaceutil.implementer(repository.ilocalrepositorymain)
1181 class localrepository(object):
1181 class localrepository(object):
1182 """Main class for representing local repositories.
1182 """Main class for representing local repositories.
1183
1183
1184 All local repositories are instances of this class.
1184 All local repositories are instances of this class.
1185
1185
1186 Constructed on its own, instances of this class are not usable as
1186 Constructed on its own, instances of this class are not usable as
1187 repository objects. To obtain a usable repository object, call
1187 repository objects. To obtain a usable repository object, call
1188 ``hg.repository()``, ``localrepo.instance()``, or
1188 ``hg.repository()``, ``localrepo.instance()``, or
1189 ``localrepo.makelocalrepository()``. The latter is the lowest-level.
1189 ``localrepo.makelocalrepository()``. The latter is the lowest-level.
1190 ``instance()`` adds support for creating new repositories.
1190 ``instance()`` adds support for creating new repositories.
1191 ``hg.repository()`` adds more extension integration, including calling
1191 ``hg.repository()`` adds more extension integration, including calling
1192 ``reposetup()``. Generally speaking, ``hg.repository()`` should be
1192 ``reposetup()``. Generally speaking, ``hg.repository()`` should be
1193 used.
1193 used.
1194 """
1194 """
1195
1195
1196 # obsolete experimental requirements:
1196 # obsolete experimental requirements:
1197 # - manifestv2: An experimental new manifest format that allowed
1197 # - manifestv2: An experimental new manifest format that allowed
1198 # for stem compression of long paths. Experiment ended up not
1198 # for stem compression of long paths. Experiment ended up not
1199 # being successful (repository sizes went up due to worse delta
1199 # being successful (repository sizes went up due to worse delta
1200 # chains), and the code was deleted in 4.6.
1200 # chains), and the code was deleted in 4.6.
1201 supportedformats = {
1201 supportedformats = {
1202 b'revlogv1',
1202 b'revlogv1',
1203 b'generaldelta',
1203 b'generaldelta',
1204 requirementsmod.TREEMANIFEST_REQUIREMENT,
1204 requirementsmod.TREEMANIFEST_REQUIREMENT,
1205 requirementsmod.COPIESSDC_REQUIREMENT,
1205 requirementsmod.COPIESSDC_REQUIREMENT,
1206 requirementsmod.REVLOGV2_REQUIREMENT,
1206 requirementsmod.REVLOGV2_REQUIREMENT,
1207 requirementsmod.SIDEDATA_REQUIREMENT,
1207 requirementsmod.SIDEDATA_REQUIREMENT,
1208 requirementsmod.SPARSEREVLOG_REQUIREMENT,
1208 requirementsmod.SPARSEREVLOG_REQUIREMENT,
1209 requirementsmod.NODEMAP_REQUIREMENT,
1209 requirementsmod.NODEMAP_REQUIREMENT,
1210 bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT,
1210 bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT,
1211 requirementsmod.SHARESAFE_REQUIREMENT,
1211 requirementsmod.SHARESAFE_REQUIREMENT,
1212 }
1212 }
1213 _basesupported = supportedformats | {
1213 _basesupported = supportedformats | {
1214 b'store',
1214 b'store',
1215 b'fncache',
1215 b'fncache',
1216 requirementsmod.SHARED_REQUIREMENT,
1216 requirementsmod.SHARED_REQUIREMENT,
1217 requirementsmod.RELATIVE_SHARED_REQUIREMENT,
1217 requirementsmod.RELATIVE_SHARED_REQUIREMENT,
1218 b'dotencode',
1218 b'dotencode',
1219 requirementsmod.SPARSE_REQUIREMENT,
1219 requirementsmod.SPARSE_REQUIREMENT,
1220 requirementsmod.INTERNAL_PHASE_REQUIREMENT,
1220 requirementsmod.INTERNAL_PHASE_REQUIREMENT,
1221 }
1221 }
1222
1222
1223 # list of prefix for file which can be written without 'wlock'
1223 # list of prefix for file which can be written without 'wlock'
1224 # Extensions should extend this list when needed
1224 # Extensions should extend this list when needed
1225 _wlockfreeprefix = {
1225 _wlockfreeprefix = {
1226 # We migh consider requiring 'wlock' for the next
1226 # We migh consider requiring 'wlock' for the next
1227 # two, but pretty much all the existing code assume
1227 # two, but pretty much all the existing code assume
1228 # wlock is not needed so we keep them excluded for
1228 # wlock is not needed so we keep them excluded for
1229 # now.
1229 # now.
1230 b'hgrc',
1230 b'hgrc',
1231 b'requires',
1231 b'requires',
1232 # XXX cache is a complicatged business someone
1232 # XXX cache is a complicatged business someone
1233 # should investigate this in depth at some point
1233 # should investigate this in depth at some point
1234 b'cache/',
1234 b'cache/',
1235 # XXX shouldn't be dirstate covered by the wlock?
1235 # XXX shouldn't be dirstate covered by the wlock?
1236 b'dirstate',
1236 b'dirstate',
1237 # XXX bisect was still a bit too messy at the time
1237 # XXX bisect was still a bit too messy at the time
1238 # this changeset was introduced. Someone should fix
1238 # this changeset was introduced. Someone should fix
1239 # the remainig bit and drop this line
1239 # the remainig bit and drop this line
1240 b'bisect.state',
1240 b'bisect.state',
1241 }
1241 }
1242
1242
1243 def __init__(
1243 def __init__(
1244 self,
1244 self,
1245 baseui,
1245 baseui,
1246 ui,
1246 ui,
1247 origroot,
1247 origroot,
1248 wdirvfs,
1248 wdirvfs,
1249 hgvfs,
1249 hgvfs,
1250 requirements,
1250 requirements,
1251 supportedrequirements,
1251 supportedrequirements,
1252 sharedpath,
1252 sharedpath,
1253 store,
1253 store,
1254 cachevfs,
1254 cachevfs,
1255 wcachevfs,
1255 wcachevfs,
1256 features,
1256 features,
1257 intents=None,
1257 intents=None,
1258 ):
1258 ):
1259 """Create a new local repository instance.
1259 """Create a new local repository instance.
1260
1260
1261 Most callers should use ``hg.repository()``, ``localrepo.instance()``,
1261 Most callers should use ``hg.repository()``, ``localrepo.instance()``,
1262 or ``localrepo.makelocalrepository()`` for obtaining a new repository
1262 or ``localrepo.makelocalrepository()`` for obtaining a new repository
1263 object.
1263 object.
1264
1264
1265 Arguments:
1265 Arguments:
1266
1266
1267 baseui
1267 baseui
1268 ``ui.ui`` instance that ``ui`` argument was based off of.
1268 ``ui.ui`` instance that ``ui`` argument was based off of.
1269
1269
1270 ui
1270 ui
1271 ``ui.ui`` instance for use by the repository.
1271 ``ui.ui`` instance for use by the repository.
1272
1272
1273 origroot
1273 origroot
1274 ``bytes`` path to working directory root of this repository.
1274 ``bytes`` path to working directory root of this repository.
1275
1275
1276 wdirvfs
1276 wdirvfs
1277 ``vfs.vfs`` rooted at the working directory.
1277 ``vfs.vfs`` rooted at the working directory.
1278
1278
1279 hgvfs
1279 hgvfs
1280 ``vfs.vfs`` rooted at .hg/
1280 ``vfs.vfs`` rooted at .hg/
1281
1281
1282 requirements
1282 requirements
1283 ``set`` of bytestrings representing repository opening requirements.
1283 ``set`` of bytestrings representing repository opening requirements.
1284
1284
1285 supportedrequirements
1285 supportedrequirements
1286 ``set`` of bytestrings representing repository requirements that we
1286 ``set`` of bytestrings representing repository requirements that we
1287 know how to open. May be a supetset of ``requirements``.
1287 know how to open. May be a supetset of ``requirements``.
1288
1288
1289 sharedpath
1289 sharedpath
1290 ``bytes`` Defining path to storage base directory. Points to a
1290 ``bytes`` Defining path to storage base directory. Points to a
1291 ``.hg/`` directory somewhere.
1291 ``.hg/`` directory somewhere.
1292
1292
1293 store
1293 store
1294 ``store.basicstore`` (or derived) instance providing access to
1294 ``store.basicstore`` (or derived) instance providing access to
1295 versioned storage.
1295 versioned storage.
1296
1296
1297 cachevfs
1297 cachevfs
1298 ``vfs.vfs`` used for cache files.
1298 ``vfs.vfs`` used for cache files.
1299
1299
1300 wcachevfs
1300 wcachevfs
1301 ``vfs.vfs`` used for cache files related to the working copy.
1301 ``vfs.vfs`` used for cache files related to the working copy.
1302
1302
1303 features
1303 features
1304 ``set`` of bytestrings defining features/capabilities of this
1304 ``set`` of bytestrings defining features/capabilities of this
1305 instance.
1305 instance.
1306
1306
1307 intents
1307 intents
1308 ``set`` of system strings indicating what this repo will be used
1308 ``set`` of system strings indicating what this repo will be used
1309 for.
1309 for.
1310 """
1310 """
1311 self.baseui = baseui
1311 self.baseui = baseui
1312 self.ui = ui
1312 self.ui = ui
1313 self.origroot = origroot
1313 self.origroot = origroot
1314 # vfs rooted at working directory.
1314 # vfs rooted at working directory.
1315 self.wvfs = wdirvfs
1315 self.wvfs = wdirvfs
1316 self.root = wdirvfs.base
1316 self.root = wdirvfs.base
1317 # vfs rooted at .hg/. Used to access most non-store paths.
1317 # vfs rooted at .hg/. Used to access most non-store paths.
1318 self.vfs = hgvfs
1318 self.vfs = hgvfs
1319 self.path = hgvfs.base
1319 self.path = hgvfs.base
1320 self.requirements = requirements
1320 self.requirements = requirements
1321 self.supported = supportedrequirements
1321 self.supported = supportedrequirements
1322 self.sharedpath = sharedpath
1322 self.sharedpath = sharedpath
1323 self.store = store
1323 self.store = store
1324 self.cachevfs = cachevfs
1324 self.cachevfs = cachevfs
1325 self.wcachevfs = wcachevfs
1325 self.wcachevfs = wcachevfs
1326 self.features = features
1326 self.features = features
1327
1327
1328 self.filtername = None
1328 self.filtername = None
1329
1329
1330 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
1330 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
1331 b'devel', b'check-locks'
1331 b'devel', b'check-locks'
1332 ):
1332 ):
1333 self.vfs.audit = self._getvfsward(self.vfs.audit)
1333 self.vfs.audit = self._getvfsward(self.vfs.audit)
1334 # A list of callback to shape the phase if no data were found.
1334 # A list of callback to shape the phase if no data were found.
1335 # Callback are in the form: func(repo, roots) --> processed root.
1335 # Callback are in the form: func(repo, roots) --> processed root.
1336 # This list it to be filled by extension during repo setup
1336 # This list it to be filled by extension during repo setup
1337 self._phasedefaults = []
1337 self._phasedefaults = []
1338
1338
1339 color.setup(self.ui)
1339 color.setup(self.ui)
1340
1340
1341 self.spath = self.store.path
1341 self.spath = self.store.path
1342 self.svfs = self.store.vfs
1342 self.svfs = self.store.vfs
1343 self.sjoin = self.store.join
1343 self.sjoin = self.store.join
1344 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
1344 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
1345 b'devel', b'check-locks'
1345 b'devel', b'check-locks'
1346 ):
1346 ):
1347 if util.safehasattr(self.svfs, b'vfs'): # this is filtervfs
1347 if util.safehasattr(self.svfs, b'vfs'): # this is filtervfs
1348 self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
1348 self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
1349 else: # standard vfs
1349 else: # standard vfs
1350 self.svfs.audit = self._getsvfsward(self.svfs.audit)
1350 self.svfs.audit = self._getsvfsward(self.svfs.audit)
1351
1351
1352 self._dirstatevalidatewarned = False
1352 self._dirstatevalidatewarned = False
1353
1353
1354 self._branchcaches = branchmap.BranchMapCache()
1354 self._branchcaches = branchmap.BranchMapCache()
1355 self._revbranchcache = None
1355 self._revbranchcache = None
1356 self._filterpats = {}
1356 self._filterpats = {}
1357 self._datafilters = {}
1357 self._datafilters = {}
1358 self._transref = self._lockref = self._wlockref = None
1358 self._transref = self._lockref = self._wlockref = None
1359
1359
1360 # A cache for various files under .hg/ that tracks file changes,
1360 # A cache for various files under .hg/ that tracks file changes,
1361 # (used by the filecache decorator)
1361 # (used by the filecache decorator)
1362 #
1362 #
1363 # Maps a property name to its util.filecacheentry
1363 # Maps a property name to its util.filecacheentry
1364 self._filecache = {}
1364 self._filecache = {}
1365
1365
1366 # hold sets of revision to be filtered
1366 # hold sets of revision to be filtered
1367 # should be cleared when something might have changed the filter value:
1367 # should be cleared when something might have changed the filter value:
1368 # - new changesets,
1368 # - new changesets,
1369 # - phase change,
1369 # - phase change,
1370 # - new obsolescence marker,
1370 # - new obsolescence marker,
1371 # - working directory parent change,
1371 # - working directory parent change,
1372 # - bookmark changes
1372 # - bookmark changes
1373 self.filteredrevcache = {}
1373 self.filteredrevcache = {}
1374
1374
1375 # post-dirstate-status hooks
1375 # post-dirstate-status hooks
1376 self._postdsstatus = []
1376 self._postdsstatus = []
1377
1377
1378 # generic mapping between names and nodes
1378 # generic mapping between names and nodes
1379 self.names = namespaces.namespaces()
1379 self.names = namespaces.namespaces()
1380
1380
1381 # Key to signature value.
1381 # Key to signature value.
1382 self._sparsesignaturecache = {}
1382 self._sparsesignaturecache = {}
1383 # Signature to cached matcher instance.
1383 # Signature to cached matcher instance.
1384 self._sparsematchercache = {}
1384 self._sparsematchercache = {}
1385
1385
1386 self._extrafilterid = repoview.extrafilter(ui)
1386 self._extrafilterid = repoview.extrafilter(ui)
1387
1387
1388 self.filecopiesmode = None
1388 self.filecopiesmode = None
1389 if requirementsmod.COPIESSDC_REQUIREMENT in self.requirements:
1389 if requirementsmod.COPIESSDC_REQUIREMENT in self.requirements:
1390 self.filecopiesmode = b'changeset-sidedata'
1390 self.filecopiesmode = b'changeset-sidedata'
1391
1391
1392 def _getvfsward(self, origfunc):
1392 def _getvfsward(self, origfunc):
1393 """build a ward for self.vfs"""
1393 """build a ward for self.vfs"""
1394 rref = weakref.ref(self)
1394 rref = weakref.ref(self)
1395
1395
1396 def checkvfs(path, mode=None):
1396 def checkvfs(path, mode=None):
1397 ret = origfunc(path, mode=mode)
1397 ret = origfunc(path, mode=mode)
1398 repo = rref()
1398 repo = rref()
1399 if (
1399 if (
1400 repo is None
1400 repo is None
1401 or not util.safehasattr(repo, b'_wlockref')
1401 or not util.safehasattr(repo, b'_wlockref')
1402 or not util.safehasattr(repo, b'_lockref')
1402 or not util.safehasattr(repo, b'_lockref')
1403 ):
1403 ):
1404 return
1404 return
1405 if mode in (None, b'r', b'rb'):
1405 if mode in (None, b'r', b'rb'):
1406 return
1406 return
1407 if path.startswith(repo.path):
1407 if path.startswith(repo.path):
1408 # truncate name relative to the repository (.hg)
1408 # truncate name relative to the repository (.hg)
1409 path = path[len(repo.path) + 1 :]
1409 path = path[len(repo.path) + 1 :]
1410 if path.startswith(b'cache/'):
1410 if path.startswith(b'cache/'):
1411 msg = b'accessing cache with vfs instead of cachevfs: "%s"'
1411 msg = b'accessing cache with vfs instead of cachevfs: "%s"'
1412 repo.ui.develwarn(msg % path, stacklevel=3, config=b"cache-vfs")
1412 repo.ui.develwarn(msg % path, stacklevel=3, config=b"cache-vfs")
1413 # path prefixes covered by 'lock'
1413 # path prefixes covered by 'lock'
1414 vfs_path_prefixes = (
1414 vfs_path_prefixes = (
1415 b'journal.',
1415 b'journal.',
1416 b'undo.',
1416 b'undo.',
1417 b'strip-backup/',
1417 b'strip-backup/',
1418 b'cache/',
1418 b'cache/',
1419 )
1419 )
1420 if any(path.startswith(prefix) for prefix in vfs_path_prefixes):
1420 if any(path.startswith(prefix) for prefix in vfs_path_prefixes):
1421 if repo._currentlock(repo._lockref) is None:
1421 if repo._currentlock(repo._lockref) is None:
1422 repo.ui.develwarn(
1422 repo.ui.develwarn(
1423 b'write with no lock: "%s"' % path,
1423 b'write with no lock: "%s"' % path,
1424 stacklevel=3,
1424 stacklevel=3,
1425 config=b'check-locks',
1425 config=b'check-locks',
1426 )
1426 )
1427 elif repo._currentlock(repo._wlockref) is None:
1427 elif repo._currentlock(repo._wlockref) is None:
1428 # rest of vfs files are covered by 'wlock'
1428 # rest of vfs files are covered by 'wlock'
1429 #
1429 #
1430 # exclude special files
1430 # exclude special files
1431 for prefix in self._wlockfreeprefix:
1431 for prefix in self._wlockfreeprefix:
1432 if path.startswith(prefix):
1432 if path.startswith(prefix):
1433 return
1433 return
1434 repo.ui.develwarn(
1434 repo.ui.develwarn(
1435 b'write with no wlock: "%s"' % path,
1435 b'write with no wlock: "%s"' % path,
1436 stacklevel=3,
1436 stacklevel=3,
1437 config=b'check-locks',
1437 config=b'check-locks',
1438 )
1438 )
1439 return ret
1439 return ret
1440
1440
1441 return checkvfs
1441 return checkvfs
1442
1442
1443 def _getsvfsward(self, origfunc):
1443 def _getsvfsward(self, origfunc):
1444 """build a ward for self.svfs"""
1444 """build a ward for self.svfs"""
1445 rref = weakref.ref(self)
1445 rref = weakref.ref(self)
1446
1446
1447 def checksvfs(path, mode=None):
1447 def checksvfs(path, mode=None):
1448 ret = origfunc(path, mode=mode)
1448 ret = origfunc(path, mode=mode)
1449 repo = rref()
1449 repo = rref()
1450 if repo is None or not util.safehasattr(repo, b'_lockref'):
1450 if repo is None or not util.safehasattr(repo, b'_lockref'):
1451 return
1451 return
1452 if mode in (None, b'r', b'rb'):
1452 if mode in (None, b'r', b'rb'):
1453 return
1453 return
1454 if path.startswith(repo.sharedpath):
1454 if path.startswith(repo.sharedpath):
1455 # truncate name relative to the repository (.hg)
1455 # truncate name relative to the repository (.hg)
1456 path = path[len(repo.sharedpath) + 1 :]
1456 path = path[len(repo.sharedpath) + 1 :]
1457 if repo._currentlock(repo._lockref) is None:
1457 if repo._currentlock(repo._lockref) is None:
1458 repo.ui.develwarn(
1458 repo.ui.develwarn(
1459 b'write with no lock: "%s"' % path, stacklevel=4
1459 b'write with no lock: "%s"' % path, stacklevel=4
1460 )
1460 )
1461 return ret
1461 return ret
1462
1462
1463 return checksvfs
1463 return checksvfs
1464
1464
1465 def close(self):
1465 def close(self):
1466 self._writecaches()
1466 self._writecaches()
1467
1467
1468 def _writecaches(self):
1468 def _writecaches(self):
1469 if self._revbranchcache:
1469 if self._revbranchcache:
1470 self._revbranchcache.write()
1470 self._revbranchcache.write()
1471
1471
1472 def _restrictcapabilities(self, caps):
1472 def _restrictcapabilities(self, caps):
1473 if self.ui.configbool(b'experimental', b'bundle2-advertise'):
1473 if self.ui.configbool(b'experimental', b'bundle2-advertise'):
1474 caps = set(caps)
1474 caps = set(caps)
1475 capsblob = bundle2.encodecaps(
1475 capsblob = bundle2.encodecaps(
1476 bundle2.getrepocaps(self, role=b'client')
1476 bundle2.getrepocaps(self, role=b'client')
1477 )
1477 )
1478 caps.add(b'bundle2=' + urlreq.quote(capsblob))
1478 caps.add(b'bundle2=' + urlreq.quote(capsblob))
1479 return caps
1479 return caps
1480
1480
1481 # Don't cache auditor/nofsauditor, or you'll end up with reference cycle:
1481 # Don't cache auditor/nofsauditor, or you'll end up with reference cycle:
1482 # self -> auditor -> self._checknested -> self
1482 # self -> auditor -> self._checknested -> self
1483
1483
1484 @property
1484 @property
1485 def auditor(self):
1485 def auditor(self):
1486 # This is only used by context.workingctx.match in order to
1486 # This is only used by context.workingctx.match in order to
1487 # detect files in subrepos.
1487 # detect files in subrepos.
1488 return pathutil.pathauditor(self.root, callback=self._checknested)
1488 return pathutil.pathauditor(self.root, callback=self._checknested)
1489
1489
1490 @property
1490 @property
1491 def nofsauditor(self):
1491 def nofsauditor(self):
1492 # This is only used by context.basectx.match in order to detect
1492 # This is only used by context.basectx.match in order to detect
1493 # files in subrepos.
1493 # files in subrepos.
1494 return pathutil.pathauditor(
1494 return pathutil.pathauditor(
1495 self.root, callback=self._checknested, realfs=False, cached=True
1495 self.root, callback=self._checknested, realfs=False, cached=True
1496 )
1496 )
1497
1497
1498 def _checknested(self, path):
1498 def _checknested(self, path):
1499 """Determine if path is a legal nested repository."""
1499 """Determine if path is a legal nested repository."""
1500 if not path.startswith(self.root):
1500 if not path.startswith(self.root):
1501 return False
1501 return False
1502 subpath = path[len(self.root) + 1 :]
1502 subpath = path[len(self.root) + 1 :]
1503 normsubpath = util.pconvert(subpath)
1503 normsubpath = util.pconvert(subpath)
1504
1504
1505 # XXX: Checking against the current working copy is wrong in
1505 # XXX: Checking against the current working copy is wrong in
1506 # the sense that it can reject things like
1506 # the sense that it can reject things like
1507 #
1507 #
1508 # $ hg cat -r 10 sub/x.txt
1508 # $ hg cat -r 10 sub/x.txt
1509 #
1509 #
1510 # if sub/ is no longer a subrepository in the working copy
1510 # if sub/ is no longer a subrepository in the working copy
1511 # parent revision.
1511 # parent revision.
1512 #
1512 #
1513 # However, it can of course also allow things that would have
1513 # However, it can of course also allow things that would have
1514 # been rejected before, such as the above cat command if sub/
1514 # been rejected before, such as the above cat command if sub/
1515 # is a subrepository now, but was a normal directory before.
1515 # is a subrepository now, but was a normal directory before.
1516 # The old path auditor would have rejected by mistake since it
1516 # The old path auditor would have rejected by mistake since it
1517 # panics when it sees sub/.hg/.
1517 # panics when it sees sub/.hg/.
1518 #
1518 #
1519 # All in all, checking against the working copy seems sensible
1519 # All in all, checking against the working copy seems sensible
1520 # since we want to prevent access to nested repositories on
1520 # since we want to prevent access to nested repositories on
1521 # the filesystem *now*.
1521 # the filesystem *now*.
1522 ctx = self[None]
1522 ctx = self[None]
1523 parts = util.splitpath(subpath)
1523 parts = util.splitpath(subpath)
1524 while parts:
1524 while parts:
1525 prefix = b'/'.join(parts)
1525 prefix = b'/'.join(parts)
1526 if prefix in ctx.substate:
1526 if prefix in ctx.substate:
1527 if prefix == normsubpath:
1527 if prefix == normsubpath:
1528 return True
1528 return True
1529 else:
1529 else:
1530 sub = ctx.sub(prefix)
1530 sub = ctx.sub(prefix)
1531 return sub.checknested(subpath[len(prefix) + 1 :])
1531 return sub.checknested(subpath[len(prefix) + 1 :])
1532 else:
1532 else:
1533 parts.pop()
1533 parts.pop()
1534 return False
1534 return False
1535
1535
1536 def peer(self):
1536 def peer(self):
1537 return localpeer(self) # not cached to avoid reference cycle
1537 return localpeer(self) # not cached to avoid reference cycle
1538
1538
1539 def unfiltered(self):
1539 def unfiltered(self):
1540 """Return unfiltered version of the repository
1540 """Return unfiltered version of the repository
1541
1541
1542 Intended to be overwritten by filtered repo."""
1542 Intended to be overwritten by filtered repo."""
1543 return self
1543 return self
1544
1544
1545 def filtered(self, name, visibilityexceptions=None):
1545 def filtered(self, name, visibilityexceptions=None):
1546 """Return a filtered version of a repository
1546 """Return a filtered version of a repository
1547
1547
1548 The `name` parameter is the identifier of the requested view. This
1548 The `name` parameter is the identifier of the requested view. This
1549 will return a repoview object set "exactly" to the specified view.
1549 will return a repoview object set "exactly" to the specified view.
1550
1550
1551 This function does not apply recursive filtering to a repository. For
1551 This function does not apply recursive filtering to a repository. For
1552 example calling `repo.filtered("served")` will return a repoview using
1552 example calling `repo.filtered("served")` will return a repoview using
1553 the "served" view, regardless of the initial view used by `repo`.
1553 the "served" view, regardless of the initial view used by `repo`.
1554
1554
1555 In other word, there is always only one level of `repoview` "filtering".
1555 In other word, there is always only one level of `repoview` "filtering".
1556 """
1556 """
1557 if self._extrafilterid is not None and b'%' not in name:
1557 if self._extrafilterid is not None and b'%' not in name:
1558 name = name + b'%' + self._extrafilterid
1558 name = name + b'%' + self._extrafilterid
1559
1559
1560 cls = repoview.newtype(self.unfiltered().__class__)
1560 cls = repoview.newtype(self.unfiltered().__class__)
1561 return cls(self, name, visibilityexceptions)
1561 return cls(self, name, visibilityexceptions)
1562
1562
1563 @mixedrepostorecache(
1563 @mixedrepostorecache(
1564 (b'bookmarks', b'plain'),
1564 (b'bookmarks', b'plain'),
1565 (b'bookmarks.current', b'plain'),
1565 (b'bookmarks.current', b'plain'),
1566 (b'bookmarks', b''),
1566 (b'bookmarks', b''),
1567 (b'00changelog.i', b''),
1567 (b'00changelog.i', b''),
1568 )
1568 )
1569 def _bookmarks(self):
1569 def _bookmarks(self):
1570 # Since the multiple files involved in the transaction cannot be
1570 # Since the multiple files involved in the transaction cannot be
1571 # written atomically (with current repository format), there is a race
1571 # written atomically (with current repository format), there is a race
1572 # condition here.
1572 # condition here.
1573 #
1573 #
1574 # 1) changelog content A is read
1574 # 1) changelog content A is read
1575 # 2) outside transaction update changelog to content B
1575 # 2) outside transaction update changelog to content B
1576 # 3) outside transaction update bookmark file referring to content B
1576 # 3) outside transaction update bookmark file referring to content B
1577 # 4) bookmarks file content is read and filtered against changelog-A
1577 # 4) bookmarks file content is read and filtered against changelog-A
1578 #
1578 #
1579 # When this happens, bookmarks against nodes missing from A are dropped.
1579 # When this happens, bookmarks against nodes missing from A are dropped.
1580 #
1580 #
1581 # Having this happening during read is not great, but it become worse
1581 # Having this happening during read is not great, but it become worse
1582 # when this happen during write because the bookmarks to the "unknown"
1582 # when this happen during write because the bookmarks to the "unknown"
1583 # nodes will be dropped for good. However, writes happen within locks.
1583 # nodes will be dropped for good. However, writes happen within locks.
1584 # This locking makes it possible to have a race free consistent read.
1584 # This locking makes it possible to have a race free consistent read.
1585 # For this purpose data read from disc before locking are
1585 # For this purpose data read from disc before locking are
1586 # "invalidated" right after the locks are taken. This invalidations are
1586 # "invalidated" right after the locks are taken. This invalidations are
1587 # "light", the `filecache` mechanism keep the data in memory and will
1587 # "light", the `filecache` mechanism keep the data in memory and will
1588 # reuse them if the underlying files did not changed. Not parsing the
1588 # reuse them if the underlying files did not changed. Not parsing the
1589 # same data multiple times helps performances.
1589 # same data multiple times helps performances.
1590 #
1590 #
1591 # Unfortunately in the case describe above, the files tracked by the
1591 # Unfortunately in the case describe above, the files tracked by the
1592 # bookmarks file cache might not have changed, but the in-memory
1592 # bookmarks file cache might not have changed, but the in-memory
1593 # content is still "wrong" because we used an older changelog content
1593 # content is still "wrong" because we used an older changelog content
1594 # to process the on-disk data. So after locking, the changelog would be
1594 # to process the on-disk data. So after locking, the changelog would be
1595 # refreshed but `_bookmarks` would be preserved.
1595 # refreshed but `_bookmarks` would be preserved.
1596 # Adding `00changelog.i` to the list of tracked file is not
1596 # Adding `00changelog.i` to the list of tracked file is not
1597 # enough, because at the time we build the content for `_bookmarks` in
1597 # enough, because at the time we build the content for `_bookmarks` in
1598 # (4), the changelog file has already diverged from the content used
1598 # (4), the changelog file has already diverged from the content used
1599 # for loading `changelog` in (1)
1599 # for loading `changelog` in (1)
1600 #
1600 #
1601 # To prevent the issue, we force the changelog to be explicitly
1601 # To prevent the issue, we force the changelog to be explicitly
1602 # reloaded while computing `_bookmarks`. The data race can still happen
1602 # reloaded while computing `_bookmarks`. The data race can still happen
1603 # without the lock (with a narrower window), but it would no longer go
1603 # without the lock (with a narrower window), but it would no longer go
1604 # undetected during the lock time refresh.
1604 # undetected during the lock time refresh.
1605 #
1605 #
1606 # The new schedule is as follow
1606 # The new schedule is as follow
1607 #
1607 #
1608 # 1) filecache logic detect that `_bookmarks` needs to be computed
1608 # 1) filecache logic detect that `_bookmarks` needs to be computed
1609 # 2) cachestat for `bookmarks` and `changelog` are captured (for book)
1609 # 2) cachestat for `bookmarks` and `changelog` are captured (for book)
1610 # 3) We force `changelog` filecache to be tested
1610 # 3) We force `changelog` filecache to be tested
1611 # 4) cachestat for `changelog` are captured (for changelog)
1611 # 4) cachestat for `changelog` are captured (for changelog)
1612 # 5) `_bookmarks` is computed and cached
1612 # 5) `_bookmarks` is computed and cached
1613 #
1613 #
1614 # The step in (3) ensure we have a changelog at least as recent as the
1614 # The step in (3) ensure we have a changelog at least as recent as the
1615 # cache stat computed in (1). As a result at locking time:
1615 # cache stat computed in (1). As a result at locking time:
1616 # * if the changelog did not changed since (1) -> we can reuse the data
1616 # * if the changelog did not changed since (1) -> we can reuse the data
1617 # * otherwise -> the bookmarks get refreshed.
1617 # * otherwise -> the bookmarks get refreshed.
1618 self._refreshchangelog()
1618 self._refreshchangelog()
1619 return bookmarks.bmstore(self)
1619 return bookmarks.bmstore(self)
1620
1620
1621 def _refreshchangelog(self):
1621 def _refreshchangelog(self):
1622 """make sure the in memory changelog match the on-disk one"""
1622 """make sure the in memory changelog match the on-disk one"""
1623 if 'changelog' in vars(self) and self.currenttransaction() is None:
1623 if 'changelog' in vars(self) and self.currenttransaction() is None:
1624 del self.changelog
1624 del self.changelog
1625
1625
1626 @property
1626 @property
1627 def _activebookmark(self):
1627 def _activebookmark(self):
1628 return self._bookmarks.active
1628 return self._bookmarks.active
1629
1629
1630 # _phasesets depend on changelog. what we need is to call
1630 # _phasesets depend on changelog. what we need is to call
1631 # _phasecache.invalidate() if '00changelog.i' was changed, but it
1631 # _phasecache.invalidate() if '00changelog.i' was changed, but it
1632 # can't be easily expressed in filecache mechanism.
1632 # can't be easily expressed in filecache mechanism.
1633 @storecache(b'phaseroots', b'00changelog.i')
1633 @storecache(b'phaseroots', b'00changelog.i')
1634 def _phasecache(self):
1634 def _phasecache(self):
1635 return phases.phasecache(self, self._phasedefaults)
1635 return phases.phasecache(self, self._phasedefaults)
1636
1636
1637 @storecache(b'obsstore')
1637 @storecache(b'obsstore')
1638 def obsstore(self):
1638 def obsstore(self):
1639 return obsolete.makestore(self.ui, self)
1639 return obsolete.makestore(self.ui, self)
1640
1640
1641 @storecache(b'00changelog.i')
1641 @storecache(b'00changelog.i')
1642 def changelog(self):
1642 def changelog(self):
1643 # load dirstate before changelog to avoid race see issue6303
1643 # load dirstate before changelog to avoid race see issue6303
1644 self.dirstate.prefetch_parents()
1644 self.dirstate.prefetch_parents()
1645 return self.store.changelog(txnutil.mayhavepending(self.root))
1645 return self.store.changelog(txnutil.mayhavepending(self.root))
1646
1646
1647 @storecache(b'00manifest.i')
1647 @storecache(b'00manifest.i')
1648 def manifestlog(self):
1648 def manifestlog(self):
1649 return self.store.manifestlog(self, self._storenarrowmatch)
1649 return self.store.manifestlog(self, self._storenarrowmatch)
1650
1650
1651 @repofilecache(b'dirstate')
1651 @repofilecache(b'dirstate')
1652 def dirstate(self):
1652 def dirstate(self):
1653 return self._makedirstate()
1653 return self._makedirstate()
1654
1654
1655 def _makedirstate(self):
1655 def _makedirstate(self):
1656 """Extension point for wrapping the dirstate per-repo."""
1656 """Extension point for wrapping the dirstate per-repo."""
1657 sparsematchfn = lambda: sparse.matcher(self)
1657 sparsematchfn = lambda: sparse.matcher(self)
1658
1658
1659 return dirstate.dirstate(
1659 return dirstate.dirstate(
1660 self.vfs, self.ui, self.root, self._dirstatevalidate, sparsematchfn
1660 self.vfs, self.ui, self.root, self._dirstatevalidate, sparsematchfn
1661 )
1661 )
1662
1662
1663 def _dirstatevalidate(self, node):
1663 def _dirstatevalidate(self, node):
1664 try:
1664 try:
1665 self.changelog.rev(node)
1665 self.changelog.rev(node)
1666 return node
1666 return node
1667 except error.LookupError:
1667 except error.LookupError:
1668 if not self._dirstatevalidatewarned:
1668 if not self._dirstatevalidatewarned:
1669 self._dirstatevalidatewarned = True
1669 self._dirstatevalidatewarned = True
1670 self.ui.warn(
1670 self.ui.warn(
1671 _(b"warning: ignoring unknown working parent %s!\n")
1671 _(b"warning: ignoring unknown working parent %s!\n")
1672 % short(node)
1672 % short(node)
1673 )
1673 )
1674 return nullid
1674 return nullid
1675
1675
1676 @storecache(narrowspec.FILENAME)
1676 @storecache(narrowspec.FILENAME)
1677 def narrowpats(self):
1677 def narrowpats(self):
1678 """matcher patterns for this repository's narrowspec
1678 """matcher patterns for this repository's narrowspec
1679
1679
1680 A tuple of (includes, excludes).
1680 A tuple of (includes, excludes).
1681 """
1681 """
1682 return narrowspec.load(self)
1682 return narrowspec.load(self)
1683
1683
1684 @storecache(narrowspec.FILENAME)
1684 @storecache(narrowspec.FILENAME)
1685 def _storenarrowmatch(self):
1685 def _storenarrowmatch(self):
1686 if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
1686 if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
1687 return matchmod.always()
1687 return matchmod.always()
1688 include, exclude = self.narrowpats
1688 include, exclude = self.narrowpats
1689 return narrowspec.match(self.root, include=include, exclude=exclude)
1689 return narrowspec.match(self.root, include=include, exclude=exclude)
1690
1690
1691 @storecache(narrowspec.FILENAME)
1691 @storecache(narrowspec.FILENAME)
1692 def _narrowmatch(self):
1692 def _narrowmatch(self):
1693 if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
1693 if requirementsmod.NARROW_REQUIREMENT not in self.requirements:
1694 return matchmod.always()
1694 return matchmod.always()
1695 narrowspec.checkworkingcopynarrowspec(self)
1695 narrowspec.checkworkingcopynarrowspec(self)
1696 include, exclude = self.narrowpats
1696 include, exclude = self.narrowpats
1697 return narrowspec.match(self.root, include=include, exclude=exclude)
1697 return narrowspec.match(self.root, include=include, exclude=exclude)
1698
1698
1699 def narrowmatch(self, match=None, includeexact=False):
1699 def narrowmatch(self, match=None, includeexact=False):
1700 """matcher corresponding the the repo's narrowspec
1700 """matcher corresponding the the repo's narrowspec
1701
1701
1702 If `match` is given, then that will be intersected with the narrow
1702 If `match` is given, then that will be intersected with the narrow
1703 matcher.
1703 matcher.
1704
1704
1705 If `includeexact` is True, then any exact matches from `match` will
1705 If `includeexact` is True, then any exact matches from `match` will
1706 be included even if they're outside the narrowspec.
1706 be included even if they're outside the narrowspec.
1707 """
1707 """
1708 if match:
1708 if match:
1709 if includeexact and not self._narrowmatch.always():
1709 if includeexact and not self._narrowmatch.always():
1710 # do not exclude explicitly-specified paths so that they can
1710 # do not exclude explicitly-specified paths so that they can
1711 # be warned later on
1711 # be warned later on
1712 em = matchmod.exact(match.files())
1712 em = matchmod.exact(match.files())
1713 nm = matchmod.unionmatcher([self._narrowmatch, em])
1713 nm = matchmod.unionmatcher([self._narrowmatch, em])
1714 return matchmod.intersectmatchers(match, nm)
1714 return matchmod.intersectmatchers(match, nm)
1715 return matchmod.intersectmatchers(match, self._narrowmatch)
1715 return matchmod.intersectmatchers(match, self._narrowmatch)
1716 return self._narrowmatch
1716 return self._narrowmatch
1717
1717
1718 def setnarrowpats(self, newincludes, newexcludes):
1718 def setnarrowpats(self, newincludes, newexcludes):
1719 narrowspec.save(self, newincludes, newexcludes)
1719 narrowspec.save(self, newincludes, newexcludes)
1720 self.invalidate(clearfilecache=True)
1720 self.invalidate(clearfilecache=True)
1721
1721
1722 @unfilteredpropertycache
1722 @unfilteredpropertycache
1723 def _quick_access_changeid_null(self):
1723 def _quick_access_changeid_null(self):
1724 return {
1724 return {
1725 b'null': (nullrev, nullid),
1725 b'null': (nullrev, nullid),
1726 nullrev: (nullrev, nullid),
1726 nullrev: (nullrev, nullid),
1727 nullid: (nullrev, nullid),
1727 nullid: (nullrev, nullid),
1728 }
1728 }
1729
1729
1730 @unfilteredpropertycache
1730 @unfilteredpropertycache
1731 def _quick_access_changeid_wc(self):
1731 def _quick_access_changeid_wc(self):
1732 # also fast path access to the working copy parents
1732 # also fast path access to the working copy parents
1733 # however, only do it for filter that ensure wc is visible.
1733 # however, only do it for filter that ensure wc is visible.
1734 quick = self._quick_access_changeid_null.copy()
1734 quick = self._quick_access_changeid_null.copy()
1735 cl = self.unfiltered().changelog
1735 cl = self.unfiltered().changelog
1736 for node in self.dirstate.parents():
1736 for node in self.dirstate.parents():
1737 if node == nullid:
1737 if node == nullid:
1738 continue
1738 continue
1739 rev = cl.index.get_rev(node)
1739 rev = cl.index.get_rev(node)
1740 if rev is None:
1740 if rev is None:
1741 # unknown working copy parent case:
1741 # unknown working copy parent case:
1742 #
1742 #
1743 # skip the fast path and let higher code deal with it
1743 # skip the fast path and let higher code deal with it
1744 continue
1744 continue
1745 pair = (rev, node)
1745 pair = (rev, node)
1746 quick[rev] = pair
1746 quick[rev] = pair
1747 quick[node] = pair
1747 quick[node] = pair
1748 # also add the parents of the parents
1748 # also add the parents of the parents
1749 for r in cl.parentrevs(rev):
1749 for r in cl.parentrevs(rev):
1750 if r == nullrev:
1750 if r == nullrev:
1751 continue
1751 continue
1752 n = cl.node(r)
1752 n = cl.node(r)
1753 pair = (r, n)
1753 pair = (r, n)
1754 quick[r] = pair
1754 quick[r] = pair
1755 quick[n] = pair
1755 quick[n] = pair
1756 p1node = self.dirstate.p1()
1756 p1node = self.dirstate.p1()
1757 if p1node != nullid:
1757 if p1node != nullid:
1758 quick[b'.'] = quick[p1node]
1758 quick[b'.'] = quick[p1node]
1759 return quick
1759 return quick
1760
1760
1761 @unfilteredmethod
1761 @unfilteredmethod
1762 def _quick_access_changeid_invalidate(self):
1762 def _quick_access_changeid_invalidate(self):
1763 if '_quick_access_changeid_wc' in vars(self):
1763 if '_quick_access_changeid_wc' in vars(self):
1764 del self.__dict__['_quick_access_changeid_wc']
1764 del self.__dict__['_quick_access_changeid_wc']
1765
1765
1766 @property
1766 @property
1767 def _quick_access_changeid(self):
1767 def _quick_access_changeid(self):
1768 """an helper dictionnary for __getitem__ calls
1768 """an helper dictionnary for __getitem__ calls
1769
1769
1770 This contains a list of symbol we can recognise right away without
1770 This contains a list of symbol we can recognise right away without
1771 further processing.
1771 further processing.
1772 """
1772 """
1773 if self.filtername in repoview.filter_has_wc:
1773 if self.filtername in repoview.filter_has_wc:
1774 return self._quick_access_changeid_wc
1774 return self._quick_access_changeid_wc
1775 return self._quick_access_changeid_null
1775 return self._quick_access_changeid_null
1776
1776
1777 def __getitem__(self, changeid):
1777 def __getitem__(self, changeid):
1778 # dealing with special cases
1778 # dealing with special cases
1779 if changeid is None:
1779 if changeid is None:
1780 return context.workingctx(self)
1780 return context.workingctx(self)
1781 if isinstance(changeid, context.basectx):
1781 if isinstance(changeid, context.basectx):
1782 return changeid
1782 return changeid
1783
1783
1784 # dealing with multiple revisions
1784 # dealing with multiple revisions
1785 if isinstance(changeid, slice):
1785 if isinstance(changeid, slice):
1786 # wdirrev isn't contiguous so the slice shouldn't include it
1786 # wdirrev isn't contiguous so the slice shouldn't include it
1787 return [
1787 return [
1788 self[i]
1788 self[i]
1789 for i in pycompat.xrange(*changeid.indices(len(self)))
1789 for i in pycompat.xrange(*changeid.indices(len(self)))
1790 if i not in self.changelog.filteredrevs
1790 if i not in self.changelog.filteredrevs
1791 ]
1791 ]
1792
1792
1793 # dealing with some special values
1793 # dealing with some special values
1794 quick_access = self._quick_access_changeid.get(changeid)
1794 quick_access = self._quick_access_changeid.get(changeid)
1795 if quick_access is not None:
1795 if quick_access is not None:
1796 rev, node = quick_access
1796 rev, node = quick_access
1797 return context.changectx(self, rev, node, maybe_filtered=False)
1797 return context.changectx(self, rev, node, maybe_filtered=False)
1798 if changeid == b'tip':
1798 if changeid == b'tip':
1799 node = self.changelog.tip()
1799 node = self.changelog.tip()
1800 rev = self.changelog.rev(node)
1800 rev = self.changelog.rev(node)
1801 return context.changectx(self, rev, node)
1801 return context.changectx(self, rev, node)
1802
1802
1803 # dealing with arbitrary values
1803 # dealing with arbitrary values
1804 try:
1804 try:
1805 if isinstance(changeid, int):
1805 if isinstance(changeid, int):
1806 node = self.changelog.node(changeid)
1806 node = self.changelog.node(changeid)
1807 rev = changeid
1807 rev = changeid
1808 elif changeid == b'.':
1808 elif changeid == b'.':
1809 # this is a hack to delay/avoid loading obsmarkers
1809 # this is a hack to delay/avoid loading obsmarkers
1810 # when we know that '.' won't be hidden
1810 # when we know that '.' won't be hidden
1811 node = self.dirstate.p1()
1811 node = self.dirstate.p1()
1812 rev = self.unfiltered().changelog.rev(node)
1812 rev = self.unfiltered().changelog.rev(node)
1813 elif len(changeid) == 20:
1813 elif len(changeid) == 20:
1814 try:
1814 try:
1815 node = changeid
1815 node = changeid
1816 rev = self.changelog.rev(changeid)
1816 rev = self.changelog.rev(changeid)
1817 except error.FilteredLookupError:
1817 except error.FilteredLookupError:
1818 changeid = hex(changeid) # for the error message
1818 changeid = hex(changeid) # for the error message
1819 raise
1819 raise
1820 except LookupError:
1820 except LookupError:
1821 # check if it might have come from damaged dirstate
1821 # check if it might have come from damaged dirstate
1822 #
1822 #
1823 # XXX we could avoid the unfiltered if we had a recognizable
1823 # XXX we could avoid the unfiltered if we had a recognizable
1824 # exception for filtered changeset access
1824 # exception for filtered changeset access
1825 if (
1825 if (
1826 self.local()
1826 self.local()
1827 and changeid in self.unfiltered().dirstate.parents()
1827 and changeid in self.unfiltered().dirstate.parents()
1828 ):
1828 ):
1829 msg = _(b"working directory has unknown parent '%s'!")
1829 msg = _(b"working directory has unknown parent '%s'!")
1830 raise error.Abort(msg % short(changeid))
1830 raise error.Abort(msg % short(changeid))
1831 changeid = hex(changeid) # for the error message
1831 changeid = hex(changeid) # for the error message
1832 raise
1832 raise
1833
1833
1834 elif len(changeid) == 40:
1834 elif len(changeid) == 40:
1835 node = bin(changeid)
1835 node = bin(changeid)
1836 rev = self.changelog.rev(node)
1836 rev = self.changelog.rev(node)
1837 else:
1837 else:
1838 raise error.ProgrammingError(
1838 raise error.ProgrammingError(
1839 b"unsupported changeid '%s' of type %s"
1839 b"unsupported changeid '%s' of type %s"
1840 % (changeid, pycompat.bytestr(type(changeid)))
1840 % (changeid, pycompat.bytestr(type(changeid)))
1841 )
1841 )
1842
1842
1843 return context.changectx(self, rev, node)
1843 return context.changectx(self, rev, node)
1844
1844
1845 except (error.FilteredIndexError, error.FilteredLookupError):
1845 except (error.FilteredIndexError, error.FilteredLookupError):
1846 raise error.FilteredRepoLookupError(
1846 raise error.FilteredRepoLookupError(
1847 _(b"filtered revision '%s'") % pycompat.bytestr(changeid)
1847 _(b"filtered revision '%s'") % pycompat.bytestr(changeid)
1848 )
1848 )
1849 except (IndexError, LookupError):
1849 except (IndexError, LookupError):
1850 raise error.RepoLookupError(
1850 raise error.RepoLookupError(
1851 _(b"unknown revision '%s'") % pycompat.bytestr(changeid)
1851 _(b"unknown revision '%s'") % pycompat.bytestr(changeid)
1852 )
1852 )
1853 except error.WdirUnsupported:
1853 except error.WdirUnsupported:
1854 return context.workingctx(self)
1854 return context.workingctx(self)
1855
1855
1856 def __contains__(self, changeid):
1856 def __contains__(self, changeid):
1857 """True if the given changeid exists"""
1857 """True if the given changeid exists"""
1858 try:
1858 try:
1859 self[changeid]
1859 self[changeid]
1860 return True
1860 return True
1861 except error.RepoLookupError:
1861 except error.RepoLookupError:
1862 return False
1862 return False
1863
1863
1864 def __nonzero__(self):
1864 def __nonzero__(self):
1865 return True
1865 return True
1866
1866
1867 __bool__ = __nonzero__
1867 __bool__ = __nonzero__
1868
1868
1869 def __len__(self):
1869 def __len__(self):
1870 # no need to pay the cost of repoview.changelog
1870 # no need to pay the cost of repoview.changelog
1871 unfi = self.unfiltered()
1871 unfi = self.unfiltered()
1872 return len(unfi.changelog)
1872 return len(unfi.changelog)
1873
1873
1874 def __iter__(self):
1874 def __iter__(self):
1875 return iter(self.changelog)
1875 return iter(self.changelog)
1876
1876
1877 def revs(self, expr, *args):
1877 def revs(self, expr, *args):
1878 """Find revisions matching a revset.
1878 """Find revisions matching a revset.
1879
1879
1880 The revset is specified as a string ``expr`` that may contain
1880 The revset is specified as a string ``expr`` that may contain
1881 %-formatting to escape certain types. See ``revsetlang.formatspec``.
1881 %-formatting to escape certain types. See ``revsetlang.formatspec``.
1882
1882
1883 Revset aliases from the configuration are not expanded. To expand
1883 Revset aliases from the configuration are not expanded. To expand
1884 user aliases, consider calling ``scmutil.revrange()`` or
1884 user aliases, consider calling ``scmutil.revrange()`` or
1885 ``repo.anyrevs([expr], user=True)``.
1885 ``repo.anyrevs([expr], user=True)``.
1886
1886
1887 Returns a smartset.abstractsmartset, which is a list-like interface
1887 Returns a smartset.abstractsmartset, which is a list-like interface
1888 that contains integer revisions.
1888 that contains integer revisions.
1889 """
1889 """
1890 tree = revsetlang.spectree(expr, *args)
1890 tree = revsetlang.spectree(expr, *args)
1891 return revset.makematcher(tree)(self)
1891 return revset.makematcher(tree)(self)
1892
1892
1893 def set(self, expr, *args):
1893 def set(self, expr, *args):
1894 """Find revisions matching a revset and emit changectx instances.
1894 """Find revisions matching a revset and emit changectx instances.
1895
1895
1896 This is a convenience wrapper around ``revs()`` that iterates the
1896 This is a convenience wrapper around ``revs()`` that iterates the
1897 result and is a generator of changectx instances.
1897 result and is a generator of changectx instances.
1898
1898
1899 Revset aliases from the configuration are not expanded. To expand
1899 Revset aliases from the configuration are not expanded. To expand
1900 user aliases, consider calling ``scmutil.revrange()``.
1900 user aliases, consider calling ``scmutil.revrange()``.
1901 """
1901 """
1902 for r in self.revs(expr, *args):
1902 for r in self.revs(expr, *args):
1903 yield self[r]
1903 yield self[r]
1904
1904
1905 def anyrevs(self, specs, user=False, localalias=None):
1905 def anyrevs(self, specs, user=False, localalias=None):
1906 """Find revisions matching one of the given revsets.
1906 """Find revisions matching one of the given revsets.
1907
1907
1908 Revset aliases from the configuration are not expanded by default. To
1908 Revset aliases from the configuration are not expanded by default. To
1909 expand user aliases, specify ``user=True``. To provide some local
1909 expand user aliases, specify ``user=True``. To provide some local
1910 definitions overriding user aliases, set ``localalias`` to
1910 definitions overriding user aliases, set ``localalias`` to
1911 ``{name: definitionstring}``.
1911 ``{name: definitionstring}``.
1912 """
1912 """
1913 if specs == [b'null']:
1913 if specs == [b'null']:
1914 return revset.baseset([nullrev])
1914 return revset.baseset([nullrev])
1915 if specs == [b'.']:
1915 if specs == [b'.']:
1916 quick_data = self._quick_access_changeid.get(b'.')
1916 quick_data = self._quick_access_changeid.get(b'.')
1917 if quick_data is not None:
1917 if quick_data is not None:
1918 return revset.baseset([quick_data[0]])
1918 return revset.baseset([quick_data[0]])
1919 if user:
1919 if user:
1920 m = revset.matchany(
1920 m = revset.matchany(
1921 self.ui,
1921 self.ui,
1922 specs,
1922 specs,
1923 lookup=revset.lookupfn(self),
1923 lookup=revset.lookupfn(self),
1924 localalias=localalias,
1924 localalias=localalias,
1925 )
1925 )
1926 else:
1926 else:
1927 m = revset.matchany(None, specs, localalias=localalias)
1927 m = revset.matchany(None, specs, localalias=localalias)
1928 return m(self)
1928 return m(self)
1929
1929
1930 def url(self):
1930 def url(self):
1931 return b'file:' + self.root
1931 return b'file:' + self.root
1932
1932
1933 def hook(self, name, throw=False, **args):
1933 def hook(self, name, throw=False, **args):
1934 """Call a hook, passing this repo instance.
1934 """Call a hook, passing this repo instance.
1935
1935
1936 This a convenience method to aid invoking hooks. Extensions likely
1936 This a convenience method to aid invoking hooks. Extensions likely
1937 won't call this unless they have registered a custom hook or are
1937 won't call this unless they have registered a custom hook or are
1938 replacing code that is expected to call a hook.
1938 replacing code that is expected to call a hook.
1939 """
1939 """
1940 return hook.hook(self.ui, self, name, throw, **args)
1940 return hook.hook(self.ui, self, name, throw, **args)
1941
1941
1942 @filteredpropertycache
1942 @filteredpropertycache
1943 def _tagscache(self):
1943 def _tagscache(self):
1944 """Returns a tagscache object that contains various tags related
1944 """Returns a tagscache object that contains various tags related
1945 caches."""
1945 caches."""
1946
1946
1947 # This simplifies its cache management by having one decorated
1947 # This simplifies its cache management by having one decorated
1948 # function (this one) and the rest simply fetch things from it.
1948 # function (this one) and the rest simply fetch things from it.
1949 class tagscache(object):
1949 class tagscache(object):
1950 def __init__(self):
1950 def __init__(self):
1951 # These two define the set of tags for this repository. tags
1951 # These two define the set of tags for this repository. tags
1952 # maps tag name to node; tagtypes maps tag name to 'global' or
1952 # maps tag name to node; tagtypes maps tag name to 'global' or
1953 # 'local'. (Global tags are defined by .hgtags across all
1953 # 'local'. (Global tags are defined by .hgtags across all
1954 # heads, and local tags are defined in .hg/localtags.)
1954 # heads, and local tags are defined in .hg/localtags.)
1955 # They constitute the in-memory cache of tags.
1955 # They constitute the in-memory cache of tags.
1956 self.tags = self.tagtypes = None
1956 self.tags = self.tagtypes = None
1957
1957
1958 self.nodetagscache = self.tagslist = None
1958 self.nodetagscache = self.tagslist = None
1959
1959
1960 cache = tagscache()
1960 cache = tagscache()
1961 cache.tags, cache.tagtypes = self._findtags()
1961 cache.tags, cache.tagtypes = self._findtags()
1962
1962
1963 return cache
1963 return cache
1964
1964
1965 def tags(self):
1965 def tags(self):
1966 '''return a mapping of tag to node'''
1966 '''return a mapping of tag to node'''
1967 t = {}
1967 t = {}
1968 if self.changelog.filteredrevs:
1968 if self.changelog.filteredrevs:
1969 tags, tt = self._findtags()
1969 tags, tt = self._findtags()
1970 else:
1970 else:
1971 tags = self._tagscache.tags
1971 tags = self._tagscache.tags
1972 rev = self.changelog.rev
1972 rev = self.changelog.rev
1973 for k, v in pycompat.iteritems(tags):
1973 for k, v in pycompat.iteritems(tags):
1974 try:
1974 try:
1975 # ignore tags to unknown nodes
1975 # ignore tags to unknown nodes
1976 rev(v)
1976 rev(v)
1977 t[k] = v
1977 t[k] = v
1978 except (error.LookupError, ValueError):
1978 except (error.LookupError, ValueError):
1979 pass
1979 pass
1980 return t
1980 return t
1981
1981
1982 def _findtags(self):
1982 def _findtags(self):
1983 """Do the hard work of finding tags. Return a pair of dicts
1983 """Do the hard work of finding tags. Return a pair of dicts
1984 (tags, tagtypes) where tags maps tag name to node, and tagtypes
1984 (tags, tagtypes) where tags maps tag name to node, and tagtypes
1985 maps tag name to a string like \'global\' or \'local\'.
1985 maps tag name to a string like \'global\' or \'local\'.
1986 Subclasses or extensions are free to add their own tags, but
1986 Subclasses or extensions are free to add their own tags, but
1987 should be aware that the returned dicts will be retained for the
1987 should be aware that the returned dicts will be retained for the
1988 duration of the localrepo object."""
1988 duration of the localrepo object."""
1989
1989
1990 # XXX what tagtype should subclasses/extensions use? Currently
1990 # XXX what tagtype should subclasses/extensions use? Currently
1991 # mq and bookmarks add tags, but do not set the tagtype at all.
1991 # mq and bookmarks add tags, but do not set the tagtype at all.
1992 # Should each extension invent its own tag type? Should there
1992 # Should each extension invent its own tag type? Should there
1993 # be one tagtype for all such "virtual" tags? Or is the status
1993 # be one tagtype for all such "virtual" tags? Or is the status
1994 # quo fine?
1994 # quo fine?
1995
1995
1996 # map tag name to (node, hist)
1996 # map tag name to (node, hist)
1997 alltags = tagsmod.findglobaltags(self.ui, self)
1997 alltags = tagsmod.findglobaltags(self.ui, self)
1998 # map tag name to tag type
1998 # map tag name to tag type
1999 tagtypes = {tag: b'global' for tag in alltags}
1999 tagtypes = {tag: b'global' for tag in alltags}
2000
2000
2001 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
2001 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
2002
2002
2003 # Build the return dicts. Have to re-encode tag names because
2003 # Build the return dicts. Have to re-encode tag names because
2004 # the tags module always uses UTF-8 (in order not to lose info
2004 # the tags module always uses UTF-8 (in order not to lose info
2005 # writing to the cache), but the rest of Mercurial wants them in
2005 # writing to the cache), but the rest of Mercurial wants them in
2006 # local encoding.
2006 # local encoding.
2007 tags = {}
2007 tags = {}
2008 for (name, (node, hist)) in pycompat.iteritems(alltags):
2008 for (name, (node, hist)) in pycompat.iteritems(alltags):
2009 if node != nullid:
2009 if node != nullid:
2010 tags[encoding.tolocal(name)] = node
2010 tags[encoding.tolocal(name)] = node
2011 tags[b'tip'] = self.changelog.tip()
2011 tags[b'tip'] = self.changelog.tip()
2012 tagtypes = {
2012 tagtypes = {
2013 encoding.tolocal(name): value
2013 encoding.tolocal(name): value
2014 for (name, value) in pycompat.iteritems(tagtypes)
2014 for (name, value) in pycompat.iteritems(tagtypes)
2015 }
2015 }
2016 return (tags, tagtypes)
2016 return (tags, tagtypes)
2017
2017
2018 def tagtype(self, tagname):
2018 def tagtype(self, tagname):
2019 """
2019 """
2020 return the type of the given tag. result can be:
2020 return the type of the given tag. result can be:
2021
2021
2022 'local' : a local tag
2022 'local' : a local tag
2023 'global' : a global tag
2023 'global' : a global tag
2024 None : tag does not exist
2024 None : tag does not exist
2025 """
2025 """
2026
2026
2027 return self._tagscache.tagtypes.get(tagname)
2027 return self._tagscache.tagtypes.get(tagname)
2028
2028
2029 def tagslist(self):
2029 def tagslist(self):
2030 '''return a list of tags ordered by revision'''
2030 '''return a list of tags ordered by revision'''
2031 if not self._tagscache.tagslist:
2031 if not self._tagscache.tagslist:
2032 l = []
2032 l = []
2033 for t, n in pycompat.iteritems(self.tags()):
2033 for t, n in pycompat.iteritems(self.tags()):
2034 l.append((self.changelog.rev(n), t, n))
2034 l.append((self.changelog.rev(n), t, n))
2035 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
2035 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
2036
2036
2037 return self._tagscache.tagslist
2037 return self._tagscache.tagslist
2038
2038
2039 def nodetags(self, node):
2039 def nodetags(self, node):
2040 '''return the tags associated with a node'''
2040 '''return the tags associated with a node'''
2041 if not self._tagscache.nodetagscache:
2041 if not self._tagscache.nodetagscache:
2042 nodetagscache = {}
2042 nodetagscache = {}
2043 for t, n in pycompat.iteritems(self._tagscache.tags):
2043 for t, n in pycompat.iteritems(self._tagscache.tags):
2044 nodetagscache.setdefault(n, []).append(t)
2044 nodetagscache.setdefault(n, []).append(t)
2045 for tags in pycompat.itervalues(nodetagscache):
2045 for tags in pycompat.itervalues(nodetagscache):
2046 tags.sort()
2046 tags.sort()
2047 self._tagscache.nodetagscache = nodetagscache
2047 self._tagscache.nodetagscache = nodetagscache
2048 return self._tagscache.nodetagscache.get(node, [])
2048 return self._tagscache.nodetagscache.get(node, [])
2049
2049
2050 def nodebookmarks(self, node):
2050 def nodebookmarks(self, node):
2051 """return the list of bookmarks pointing to the specified node"""
2051 """return the list of bookmarks pointing to the specified node"""
2052 return self._bookmarks.names(node)
2052 return self._bookmarks.names(node)
2053
2053
2054 def branchmap(self):
2054 def branchmap(self):
2055 """returns a dictionary {branch: [branchheads]} with branchheads
2055 """returns a dictionary {branch: [branchheads]} with branchheads
2056 ordered by increasing revision number"""
2056 ordered by increasing revision number"""
2057 return self._branchcaches[self]
2057 return self._branchcaches[self]
2058
2058
2059 @unfilteredmethod
2059 @unfilteredmethod
2060 def revbranchcache(self):
2060 def revbranchcache(self):
2061 if not self._revbranchcache:
2061 if not self._revbranchcache:
2062 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
2062 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
2063 return self._revbranchcache
2063 return self._revbranchcache
2064
2064
2065 def register_changeset(self, rev, changelogrevision):
2065 def register_changeset(self, rev, changelogrevision):
2066 self.revbranchcache().setdata(rev, changelogrevision)
2066 self.revbranchcache().setdata(rev, changelogrevision)
2067
2067
2068 def branchtip(self, branch, ignoremissing=False):
2068 def branchtip(self, branch, ignoremissing=False):
2069 """return the tip node for a given branch
2069 """return the tip node for a given branch
2070
2070
2071 If ignoremissing is True, then this method will not raise an error.
2071 If ignoremissing is True, then this method will not raise an error.
2072 This is helpful for callers that only expect None for a missing branch
2072 This is helpful for callers that only expect None for a missing branch
2073 (e.g. namespace).
2073 (e.g. namespace).
2074
2074
2075 """
2075 """
2076 try:
2076 try:
2077 return self.branchmap().branchtip(branch)
2077 return self.branchmap().branchtip(branch)
2078 except KeyError:
2078 except KeyError:
2079 if not ignoremissing:
2079 if not ignoremissing:
2080 raise error.RepoLookupError(_(b"unknown branch '%s'") % branch)
2080 raise error.RepoLookupError(_(b"unknown branch '%s'") % branch)
2081 else:
2081 else:
2082 pass
2082 pass
2083
2083
2084 def lookup(self, key):
2084 def lookup(self, key):
2085 node = scmutil.revsymbol(self, key).node()
2085 node = scmutil.revsymbol(self, key).node()
2086 if node is None:
2086 if node is None:
2087 raise error.RepoLookupError(_(b"unknown revision '%s'") % key)
2087 raise error.RepoLookupError(_(b"unknown revision '%s'") % key)
2088 return node
2088 return node
2089
2089
2090 def lookupbranch(self, key):
2090 def lookupbranch(self, key):
2091 if self.branchmap().hasbranch(key):
2091 if self.branchmap().hasbranch(key):
2092 return key
2092 return key
2093
2093
2094 return scmutil.revsymbol(self, key).branch()
2094 return scmutil.revsymbol(self, key).branch()
2095
2095
2096 def known(self, nodes):
2096 def known(self, nodes):
2097 cl = self.changelog
2097 cl = self.changelog
2098 get_rev = cl.index.get_rev
2098 get_rev = cl.index.get_rev
2099 filtered = cl.filteredrevs
2099 filtered = cl.filteredrevs
2100 result = []
2100 result = []
2101 for n in nodes:
2101 for n in nodes:
2102 r = get_rev(n)
2102 r = get_rev(n)
2103 resp = not (r is None or r in filtered)
2103 resp = not (r is None or r in filtered)
2104 result.append(resp)
2104 result.append(resp)
2105 return result
2105 return result
2106
2106
2107 def local(self):
2107 def local(self):
2108 return self
2108 return self
2109
2109
2110 def publishing(self):
2110 def publishing(self):
2111 # it's safe (and desirable) to trust the publish flag unconditionally
2111 # it's safe (and desirable) to trust the publish flag unconditionally
2112 # so that we don't finalize changes shared between users via ssh or nfs
2112 # so that we don't finalize changes shared between users via ssh or nfs
2113 return self.ui.configbool(b'phases', b'publish', untrusted=True)
2113 return self.ui.configbool(b'phases', b'publish', untrusted=True)
2114
2114
2115 def cancopy(self):
2115 def cancopy(self):
2116 # so statichttprepo's override of local() works
2116 # so statichttprepo's override of local() works
2117 if not self.local():
2117 if not self.local():
2118 return False
2118 return False
2119 if not self.publishing():
2119 if not self.publishing():
2120 return True
2120 return True
2121 # if publishing we can't copy if there is filtered content
2121 # if publishing we can't copy if there is filtered content
2122 return not self.filtered(b'visible').changelog.filteredrevs
2122 return not self.filtered(b'visible').changelog.filteredrevs
2123
2123
2124 def shared(self):
2124 def shared(self):
2125 '''the type of shared repository (None if not shared)'''
2125 '''the type of shared repository (None if not shared)'''
2126 if self.sharedpath != self.path:
2126 if self.sharedpath != self.path:
2127 return b'store'
2127 return b'store'
2128 return None
2128 return None
2129
2129
2130 def wjoin(self, f, *insidef):
2130 def wjoin(self, f, *insidef):
2131 return self.vfs.reljoin(self.root, f, *insidef)
2131 return self.vfs.reljoin(self.root, f, *insidef)
2132
2132
2133 def setparents(self, p1, p2=nullid):
2133 def setparents(self, p1, p2=nullid):
2134 self[None].setparents(p1, p2)
2134 self[None].setparents(p1, p2)
2135 self._quick_access_changeid_invalidate()
2135 self._quick_access_changeid_invalidate()
2136
2136
2137 def filectx(self, path, changeid=None, fileid=None, changectx=None):
2137 def filectx(self, path, changeid=None, fileid=None, changectx=None):
2138 """changeid must be a changeset revision, if specified.
2138 """changeid must be a changeset revision, if specified.
2139 fileid can be a file revision or node."""
2139 fileid can be a file revision or node."""
2140 return context.filectx(
2140 return context.filectx(
2141 self, path, changeid, fileid, changectx=changectx
2141 self, path, changeid, fileid, changectx=changectx
2142 )
2142 )
2143
2143
2144 def getcwd(self):
2144 def getcwd(self):
2145 return self.dirstate.getcwd()
2145 return self.dirstate.getcwd()
2146
2146
2147 def pathto(self, f, cwd=None):
2147 def pathto(self, f, cwd=None):
2148 return self.dirstate.pathto(f, cwd)
2148 return self.dirstate.pathto(f, cwd)
2149
2149
2150 def _loadfilter(self, filter):
2150 def _loadfilter(self, filter):
2151 if filter not in self._filterpats:
2151 if filter not in self._filterpats:
2152 l = []
2152 l = []
2153 for pat, cmd in self.ui.configitems(filter):
2153 for pat, cmd in self.ui.configitems(filter):
2154 if cmd == b'!':
2154 if cmd == b'!':
2155 continue
2155 continue
2156 mf = matchmod.match(self.root, b'', [pat])
2156 mf = matchmod.match(self.root, b'', [pat])
2157 fn = None
2157 fn = None
2158 params = cmd
2158 params = cmd
2159 for name, filterfn in pycompat.iteritems(self._datafilters):
2159 for name, filterfn in pycompat.iteritems(self._datafilters):
2160 if cmd.startswith(name):
2160 if cmd.startswith(name):
2161 fn = filterfn
2161 fn = filterfn
2162 params = cmd[len(name) :].lstrip()
2162 params = cmd[len(name) :].lstrip()
2163 break
2163 break
2164 if not fn:
2164 if not fn:
2165 fn = lambda s, c, **kwargs: procutil.filter(s, c)
2165 fn = lambda s, c, **kwargs: procutil.filter(s, c)
2166 fn.__name__ = 'commandfilter'
2166 fn.__name__ = 'commandfilter'
2167 # Wrap old filters not supporting keyword arguments
2167 # Wrap old filters not supporting keyword arguments
2168 if not pycompat.getargspec(fn)[2]:
2168 if not pycompat.getargspec(fn)[2]:
2169 oldfn = fn
2169 oldfn = fn
2170 fn = lambda s, c, oldfn=oldfn, **kwargs: oldfn(s, c)
2170 fn = lambda s, c, oldfn=oldfn, **kwargs: oldfn(s, c)
2171 fn.__name__ = 'compat-' + oldfn.__name__
2171 fn.__name__ = 'compat-' + oldfn.__name__
2172 l.append((mf, fn, params))
2172 l.append((mf, fn, params))
2173 self._filterpats[filter] = l
2173 self._filterpats[filter] = l
2174 return self._filterpats[filter]
2174 return self._filterpats[filter]
2175
2175
2176 def _filter(self, filterpats, filename, data):
2176 def _filter(self, filterpats, filename, data):
2177 for mf, fn, cmd in filterpats:
2177 for mf, fn, cmd in filterpats:
2178 if mf(filename):
2178 if mf(filename):
2179 self.ui.debug(
2179 self.ui.debug(
2180 b"filtering %s through %s\n"
2180 b"filtering %s through %s\n"
2181 % (filename, cmd or pycompat.sysbytes(fn.__name__))
2181 % (filename, cmd or pycompat.sysbytes(fn.__name__))
2182 )
2182 )
2183 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
2183 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
2184 break
2184 break
2185
2185
2186 return data
2186 return data
2187
2187
2188 @unfilteredpropertycache
2188 @unfilteredpropertycache
2189 def _encodefilterpats(self):
2189 def _encodefilterpats(self):
2190 return self._loadfilter(b'encode')
2190 return self._loadfilter(b'encode')
2191
2191
2192 @unfilteredpropertycache
2192 @unfilteredpropertycache
2193 def _decodefilterpats(self):
2193 def _decodefilterpats(self):
2194 return self._loadfilter(b'decode')
2194 return self._loadfilter(b'decode')
2195
2195
2196 def adddatafilter(self, name, filter):
2196 def adddatafilter(self, name, filter):
2197 self._datafilters[name] = filter
2197 self._datafilters[name] = filter
2198
2198
2199 def wread(self, filename):
2199 def wread(self, filename):
2200 if self.wvfs.islink(filename):
2200 if self.wvfs.islink(filename):
2201 data = self.wvfs.readlink(filename)
2201 data = self.wvfs.readlink(filename)
2202 else:
2202 else:
2203 data = self.wvfs.read(filename)
2203 data = self.wvfs.read(filename)
2204 return self._filter(self._encodefilterpats, filename, data)
2204 return self._filter(self._encodefilterpats, filename, data)
2205
2205
2206 def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
2206 def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
2207 """write ``data`` into ``filename`` in the working directory
2207 """write ``data`` into ``filename`` in the working directory
2208
2208
2209 This returns length of written (maybe decoded) data.
2209 This returns length of written (maybe decoded) data.
2210 """
2210 """
2211 data = self._filter(self._decodefilterpats, filename, data)
2211 data = self._filter(self._decodefilterpats, filename, data)
2212 if b'l' in flags:
2212 if b'l' in flags:
2213 self.wvfs.symlink(data, filename)
2213 self.wvfs.symlink(data, filename)
2214 else:
2214 else:
2215 self.wvfs.write(
2215 self.wvfs.write(
2216 filename, data, backgroundclose=backgroundclose, **kwargs
2216 filename, data, backgroundclose=backgroundclose, **kwargs
2217 )
2217 )
2218 if b'x' in flags:
2218 if b'x' in flags:
2219 self.wvfs.setflags(filename, False, True)
2219 self.wvfs.setflags(filename, False, True)
2220 else:
2220 else:
2221 self.wvfs.setflags(filename, False, False)
2221 self.wvfs.setflags(filename, False, False)
2222 return len(data)
2222 return len(data)
2223
2223
2224 def wwritedata(self, filename, data):
2224 def wwritedata(self, filename, data):
2225 return self._filter(self._decodefilterpats, filename, data)
2225 return self._filter(self._decodefilterpats, filename, data)
2226
2226
2227 def currenttransaction(self):
2227 def currenttransaction(self):
2228 """return the current transaction or None if non exists"""
2228 """return the current transaction or None if non exists"""
2229 if self._transref:
2229 if self._transref:
2230 tr = self._transref()
2230 tr = self._transref()
2231 else:
2231 else:
2232 tr = None
2232 tr = None
2233
2233
2234 if tr and tr.running():
2234 if tr and tr.running():
2235 return tr
2235 return tr
2236 return None
2236 return None
2237
2237
2238 def transaction(self, desc, report=None):
2238 def transaction(self, desc, report=None):
2239 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
2239 if self.ui.configbool(b'devel', b'all-warnings') or self.ui.configbool(
2240 b'devel', b'check-locks'
2240 b'devel', b'check-locks'
2241 ):
2241 ):
2242 if self._currentlock(self._lockref) is None:
2242 if self._currentlock(self._lockref) is None:
2243 raise error.ProgrammingError(b'transaction requires locking')
2243 raise error.ProgrammingError(b'transaction requires locking')
2244 tr = self.currenttransaction()
2244 tr = self.currenttransaction()
2245 if tr is not None:
2245 if tr is not None:
2246 return tr.nest(name=desc)
2246 return tr.nest(name=desc)
2247
2247
2248 # abort here if the journal already exists
2248 # abort here if the journal already exists
2249 if self.svfs.exists(b"journal"):
2249 if self.svfs.exists(b"journal"):
2250 raise error.RepoError(
2250 raise error.RepoError(
2251 _(b"abandoned transaction found"),
2251 _(b"abandoned transaction found"),
2252 hint=_(b"run 'hg recover' to clean up transaction"),
2252 hint=_(b"run 'hg recover' to clean up transaction"),
2253 )
2253 )
2254
2254
2255 idbase = b"%.40f#%f" % (random.random(), time.time())
2255 idbase = b"%.40f#%f" % (random.random(), time.time())
2256 ha = hex(hashutil.sha1(idbase).digest())
2256 ha = hex(hashutil.sha1(idbase).digest())
2257 txnid = b'TXN:' + ha
2257 txnid = b'TXN:' + ha
2258 self.hook(b'pretxnopen', throw=True, txnname=desc, txnid=txnid)
2258 self.hook(b'pretxnopen', throw=True, txnname=desc, txnid=txnid)
2259
2259
2260 self._writejournal(desc)
2260 self._writejournal(desc)
2261 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
2261 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
2262 if report:
2262 if report:
2263 rp = report
2263 rp = report
2264 else:
2264 else:
2265 rp = self.ui.warn
2265 rp = self.ui.warn
2266 vfsmap = {b'plain': self.vfs, b'store': self.svfs} # root of .hg/
2266 vfsmap = {b'plain': self.vfs, b'store': self.svfs} # root of .hg/
2267 # we must avoid cyclic reference between repo and transaction.
2267 # we must avoid cyclic reference between repo and transaction.
2268 reporef = weakref.ref(self)
2268 reporef = weakref.ref(self)
2269 # Code to track tag movement
2269 # Code to track tag movement
2270 #
2270 #
2271 # Since tags are all handled as file content, it is actually quite hard
2271 # Since tags are all handled as file content, it is actually quite hard
2272 # to track these movement from a code perspective. So we fallback to a
2272 # to track these movement from a code perspective. So we fallback to a
2273 # tracking at the repository level. One could envision to track changes
2273 # tracking at the repository level. One could envision to track changes
2274 # to the '.hgtags' file through changegroup apply but that fails to
2274 # to the '.hgtags' file through changegroup apply but that fails to
2275 # cope with case where transaction expose new heads without changegroup
2275 # cope with case where transaction expose new heads without changegroup
2276 # being involved (eg: phase movement).
2276 # being involved (eg: phase movement).
2277 #
2277 #
2278 # For now, We gate the feature behind a flag since this likely comes
2278 # For now, We gate the feature behind a flag since this likely comes
2279 # with performance impacts. The current code run more often than needed
2279 # with performance impacts. The current code run more often than needed
2280 # and do not use caches as much as it could. The current focus is on
2280 # and do not use caches as much as it could. The current focus is on
2281 # the behavior of the feature so we disable it by default. The flag
2281 # the behavior of the feature so we disable it by default. The flag
2282 # will be removed when we are happy with the performance impact.
2282 # will be removed when we are happy with the performance impact.
2283 #
2283 #
2284 # Once this feature is no longer experimental move the following
2284 # Once this feature is no longer experimental move the following
2285 # documentation to the appropriate help section:
2285 # documentation to the appropriate help section:
2286 #
2286 #
2287 # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
2287 # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
2288 # tags (new or changed or deleted tags). In addition the details of
2288 # tags (new or changed or deleted tags). In addition the details of
2289 # these changes are made available in a file at:
2289 # these changes are made available in a file at:
2290 # ``REPOROOT/.hg/changes/tags.changes``.
2290 # ``REPOROOT/.hg/changes/tags.changes``.
2291 # Make sure you check for HG_TAG_MOVED before reading that file as it
2291 # Make sure you check for HG_TAG_MOVED before reading that file as it
2292 # might exist from a previous transaction even if no tag were touched
2292 # might exist from a previous transaction even if no tag were touched
2293 # in this one. Changes are recorded in a line base format::
2293 # in this one. Changes are recorded in a line base format::
2294 #
2294 #
2295 # <action> <hex-node> <tag-name>\n
2295 # <action> <hex-node> <tag-name>\n
2296 #
2296 #
2297 # Actions are defined as follow:
2297 # Actions are defined as follow:
2298 # "-R": tag is removed,
2298 # "-R": tag is removed,
2299 # "+A": tag is added,
2299 # "+A": tag is added,
2300 # "-M": tag is moved (old value),
2300 # "-M": tag is moved (old value),
2301 # "+M": tag is moved (new value),
2301 # "+M": tag is moved (new value),
2302 tracktags = lambda x: None
2302 tracktags = lambda x: None
2303 # experimental config: experimental.hook-track-tags
2303 # experimental config: experimental.hook-track-tags
2304 shouldtracktags = self.ui.configbool(
2304 shouldtracktags = self.ui.configbool(
2305 b'experimental', b'hook-track-tags'
2305 b'experimental', b'hook-track-tags'
2306 )
2306 )
2307 if desc != b'strip' and shouldtracktags:
2307 if desc != b'strip' and shouldtracktags:
2308 oldheads = self.changelog.headrevs()
2308 oldheads = self.changelog.headrevs()
2309
2309
2310 def tracktags(tr2):
2310 def tracktags(tr2):
2311 repo = reporef()
2311 repo = reporef()
2312 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
2312 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
2313 newheads = repo.changelog.headrevs()
2313 newheads = repo.changelog.headrevs()
2314 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
2314 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
2315 # notes: we compare lists here.
2315 # notes: we compare lists here.
2316 # As we do it only once buiding set would not be cheaper
2316 # As we do it only once buiding set would not be cheaper
2317 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
2317 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
2318 if changes:
2318 if changes:
2319 tr2.hookargs[b'tag_moved'] = b'1'
2319 tr2.hookargs[b'tag_moved'] = b'1'
2320 with repo.vfs(
2320 with repo.vfs(
2321 b'changes/tags.changes', b'w', atomictemp=True
2321 b'changes/tags.changes', b'w', atomictemp=True
2322 ) as changesfile:
2322 ) as changesfile:
2323 # note: we do not register the file to the transaction
2323 # note: we do not register the file to the transaction
2324 # because we needs it to still exist on the transaction
2324 # because we needs it to still exist on the transaction
2325 # is close (for txnclose hooks)
2325 # is close (for txnclose hooks)
2326 tagsmod.writediff(changesfile, changes)
2326 tagsmod.writediff(changesfile, changes)
2327
2327
2328 def validate(tr2):
2328 def validate(tr2):
2329 """will run pre-closing hooks"""
2329 """will run pre-closing hooks"""
2330 # XXX the transaction API is a bit lacking here so we take a hacky
2330 # XXX the transaction API is a bit lacking here so we take a hacky
2331 # path for now
2331 # path for now
2332 #
2332 #
2333 # We cannot add this as a "pending" hooks since the 'tr.hookargs'
2333 # We cannot add this as a "pending" hooks since the 'tr.hookargs'
2334 # dict is copied before these run. In addition we needs the data
2334 # dict is copied before these run. In addition we needs the data
2335 # available to in memory hooks too.
2335 # available to in memory hooks too.
2336 #
2336 #
2337 # Moreover, we also need to make sure this runs before txnclose
2337 # Moreover, we also need to make sure this runs before txnclose
2338 # hooks and there is no "pending" mechanism that would execute
2338 # hooks and there is no "pending" mechanism that would execute
2339 # logic only if hooks are about to run.
2339 # logic only if hooks are about to run.
2340 #
2340 #
2341 # Fixing this limitation of the transaction is also needed to track
2341 # Fixing this limitation of the transaction is also needed to track
2342 # other families of changes (bookmarks, phases, obsolescence).
2342 # other families of changes (bookmarks, phases, obsolescence).
2343 #
2343 #
2344 # This will have to be fixed before we remove the experimental
2344 # This will have to be fixed before we remove the experimental
2345 # gating.
2345 # gating.
2346 tracktags(tr2)
2346 tracktags(tr2)
2347 repo = reporef()
2347 repo = reporef()
2348
2348
2349 singleheadopt = (b'experimental', b'single-head-per-branch')
2349 singleheadopt = (b'experimental', b'single-head-per-branch')
2350 singlehead = repo.ui.configbool(*singleheadopt)
2350 singlehead = repo.ui.configbool(*singleheadopt)
2351 if singlehead:
2351 if singlehead:
2352 singleheadsub = repo.ui.configsuboptions(*singleheadopt)[1]
2352 singleheadsub = repo.ui.configsuboptions(*singleheadopt)[1]
2353 accountclosed = singleheadsub.get(
2353 accountclosed = singleheadsub.get(
2354 b"account-closed-heads", False
2354 b"account-closed-heads", False
2355 )
2355 )
2356 if singleheadsub.get(b"public-changes-only", False):
2356 if singleheadsub.get(b"public-changes-only", False):
2357 filtername = b"immutable"
2357 filtername = b"immutable"
2358 else:
2358 else:
2359 filtername = b"visible"
2359 filtername = b"visible"
2360 scmutil.enforcesinglehead(
2360 scmutil.enforcesinglehead(
2361 repo, tr2, desc, accountclosed, filtername
2361 repo, tr2, desc, accountclosed, filtername
2362 )
2362 )
2363 if hook.hashook(repo.ui, b'pretxnclose-bookmark'):
2363 if hook.hashook(repo.ui, b'pretxnclose-bookmark'):
2364 for name, (old, new) in sorted(
2364 for name, (old, new) in sorted(
2365 tr.changes[b'bookmarks'].items()
2365 tr.changes[b'bookmarks'].items()
2366 ):
2366 ):
2367 args = tr.hookargs.copy()
2367 args = tr.hookargs.copy()
2368 args.update(bookmarks.preparehookargs(name, old, new))
2368 args.update(bookmarks.preparehookargs(name, old, new))
2369 repo.hook(
2369 repo.hook(
2370 b'pretxnclose-bookmark',
2370 b'pretxnclose-bookmark',
2371 throw=True,
2371 throw=True,
2372 **pycompat.strkwargs(args)
2372 **pycompat.strkwargs(args)
2373 )
2373 )
2374 if hook.hashook(repo.ui, b'pretxnclose-phase'):
2374 if hook.hashook(repo.ui, b'pretxnclose-phase'):
2375 cl = repo.unfiltered().changelog
2375 cl = repo.unfiltered().changelog
2376 for revs, (old, new) in tr.changes[b'phases']:
2376 for revs, (old, new) in tr.changes[b'phases']:
2377 for rev in revs:
2377 for rev in revs:
2378 args = tr.hookargs.copy()
2378 args = tr.hookargs.copy()
2379 node = hex(cl.node(rev))
2379 node = hex(cl.node(rev))
2380 args.update(phases.preparehookargs(node, old, new))
2380 args.update(phases.preparehookargs(node, old, new))
2381 repo.hook(
2381 repo.hook(
2382 b'pretxnclose-phase',
2382 b'pretxnclose-phase',
2383 throw=True,
2383 throw=True,
2384 **pycompat.strkwargs(args)
2384 **pycompat.strkwargs(args)
2385 )
2385 )
2386
2386
2387 repo.hook(
2387 repo.hook(
2388 b'pretxnclose', throw=True, **pycompat.strkwargs(tr.hookargs)
2388 b'pretxnclose', throw=True, **pycompat.strkwargs(tr.hookargs)
2389 )
2389 )
2390
2390
2391 def releasefn(tr, success):
2391 def releasefn(tr, success):
2392 repo = reporef()
2392 repo = reporef()
2393 if repo is None:
2393 if repo is None:
2394 # If the repo has been GC'd (and this release function is being
2394 # If the repo has been GC'd (and this release function is being
2395 # called from transaction.__del__), there's not much we can do,
2395 # called from transaction.__del__), there's not much we can do,
2396 # so just leave the unfinished transaction there and let the
2396 # so just leave the unfinished transaction there and let the
2397 # user run `hg recover`.
2397 # user run `hg recover`.
2398 return
2398 return
2399 if success:
2399 if success:
2400 # this should be explicitly invoked here, because
2400 # this should be explicitly invoked here, because
2401 # in-memory changes aren't written out at closing
2401 # in-memory changes aren't written out at closing
2402 # transaction, if tr.addfilegenerator (via
2402 # transaction, if tr.addfilegenerator (via
2403 # dirstate.write or so) isn't invoked while
2403 # dirstate.write or so) isn't invoked while
2404 # transaction running
2404 # transaction running
2405 repo.dirstate.write(None)
2405 repo.dirstate.write(None)
2406 else:
2406 else:
2407 # discard all changes (including ones already written
2407 # discard all changes (including ones already written
2408 # out) in this transaction
2408 # out) in this transaction
2409 narrowspec.restorebackup(self, b'journal.narrowspec')
2409 narrowspec.restorebackup(self, b'journal.narrowspec')
2410 narrowspec.restorewcbackup(self, b'journal.narrowspec.dirstate')
2410 narrowspec.restorewcbackup(self, b'journal.narrowspec.dirstate')
2411 repo.dirstate.restorebackup(None, b'journal.dirstate')
2411 repo.dirstate.restorebackup(None, b'journal.dirstate')
2412
2412
2413 repo.invalidate(clearfilecache=True)
2413 repo.invalidate(clearfilecache=True)
2414
2414
2415 tr = transaction.transaction(
2415 tr = transaction.transaction(
2416 rp,
2416 rp,
2417 self.svfs,
2417 self.svfs,
2418 vfsmap,
2418 vfsmap,
2419 b"journal",
2419 b"journal",
2420 b"undo",
2420 b"undo",
2421 aftertrans(renames),
2421 aftertrans(renames),
2422 self.store.createmode,
2422 self.store.createmode,
2423 validator=validate,
2423 validator=validate,
2424 releasefn=releasefn,
2424 releasefn=releasefn,
2425 checkambigfiles=_cachedfiles,
2425 checkambigfiles=_cachedfiles,
2426 name=desc,
2426 name=desc,
2427 )
2427 )
2428 tr.changes[b'origrepolen'] = len(self)
2428 tr.changes[b'origrepolen'] = len(self)
2429 tr.changes[b'obsmarkers'] = set()
2429 tr.changes[b'obsmarkers'] = set()
2430 tr.changes[b'phases'] = []
2430 tr.changes[b'phases'] = []
2431 tr.changes[b'bookmarks'] = {}
2431 tr.changes[b'bookmarks'] = {}
2432
2432
2433 tr.hookargs[b'txnid'] = txnid
2433 tr.hookargs[b'txnid'] = txnid
2434 tr.hookargs[b'txnname'] = desc
2434 tr.hookargs[b'txnname'] = desc
2435 tr.hookargs[b'changes'] = tr.changes
2435 tr.hookargs[b'changes'] = tr.changes
2436 # note: writing the fncache only during finalize mean that the file is
2436 # note: writing the fncache only during finalize mean that the file is
2437 # outdated when running hooks. As fncache is used for streaming clone,
2437 # outdated when running hooks. As fncache is used for streaming clone,
2438 # this is not expected to break anything that happen during the hooks.
2438 # this is not expected to break anything that happen during the hooks.
2439 tr.addfinalize(b'flush-fncache', self.store.write)
2439 tr.addfinalize(b'flush-fncache', self.store.write)
2440
2440
2441 def txnclosehook(tr2):
2441 def txnclosehook(tr2):
2442 """To be run if transaction is successful, will schedule a hook run"""
2442 """To be run if transaction is successful, will schedule a hook run"""
2443 # Don't reference tr2 in hook() so we don't hold a reference.
2443 # Don't reference tr2 in hook() so we don't hold a reference.
2444 # This reduces memory consumption when there are multiple
2444 # This reduces memory consumption when there are multiple
2445 # transactions per lock. This can likely go away if issue5045
2445 # transactions per lock. This can likely go away if issue5045
2446 # fixes the function accumulation.
2446 # fixes the function accumulation.
2447 hookargs = tr2.hookargs
2447 hookargs = tr2.hookargs
2448
2448
2449 def hookfunc(unused_success):
2449 def hookfunc(unused_success):
2450 repo = reporef()
2450 repo = reporef()
2451 if hook.hashook(repo.ui, b'txnclose-bookmark'):
2451 if hook.hashook(repo.ui, b'txnclose-bookmark'):
2452 bmchanges = sorted(tr.changes[b'bookmarks'].items())
2452 bmchanges = sorted(tr.changes[b'bookmarks'].items())
2453 for name, (old, new) in bmchanges:
2453 for name, (old, new) in bmchanges:
2454 args = tr.hookargs.copy()
2454 args = tr.hookargs.copy()
2455 args.update(bookmarks.preparehookargs(name, old, new))
2455 args.update(bookmarks.preparehookargs(name, old, new))
2456 repo.hook(
2456 repo.hook(
2457 b'txnclose-bookmark',
2457 b'txnclose-bookmark',
2458 throw=False,
2458 throw=False,
2459 **pycompat.strkwargs(args)
2459 **pycompat.strkwargs(args)
2460 )
2460 )
2461
2461
2462 if hook.hashook(repo.ui, b'txnclose-phase'):
2462 if hook.hashook(repo.ui, b'txnclose-phase'):
2463 cl = repo.unfiltered().changelog
2463 cl = repo.unfiltered().changelog
2464 phasemv = sorted(
2464 phasemv = sorted(
2465 tr.changes[b'phases'], key=lambda r: r[0][0]
2465 tr.changes[b'phases'], key=lambda r: r[0][0]
2466 )
2466 )
2467 for revs, (old, new) in phasemv:
2467 for revs, (old, new) in phasemv:
2468 for rev in revs:
2468 for rev in revs:
2469 args = tr.hookargs.copy()
2469 args = tr.hookargs.copy()
2470 node = hex(cl.node(rev))
2470 node = hex(cl.node(rev))
2471 args.update(phases.preparehookargs(node, old, new))
2471 args.update(phases.preparehookargs(node, old, new))
2472 repo.hook(
2472 repo.hook(
2473 b'txnclose-phase',
2473 b'txnclose-phase',
2474 throw=False,
2474 throw=False,
2475 **pycompat.strkwargs(args)
2475 **pycompat.strkwargs(args)
2476 )
2476 )
2477
2477
2478 repo.hook(
2478 repo.hook(
2479 b'txnclose', throw=False, **pycompat.strkwargs(hookargs)
2479 b'txnclose', throw=False, **pycompat.strkwargs(hookargs)
2480 )
2480 )
2481
2481
2482 reporef()._afterlock(hookfunc)
2482 reporef()._afterlock(hookfunc)
2483
2483
2484 tr.addfinalize(b'txnclose-hook', txnclosehook)
2484 tr.addfinalize(b'txnclose-hook', txnclosehook)
2485 # Include a leading "-" to make it happen before the transaction summary
2485 # Include a leading "-" to make it happen before the transaction summary
2486 # reports registered via scmutil.registersummarycallback() whose names
2486 # reports registered via scmutil.registersummarycallback() whose names
2487 # are 00-txnreport etc. That way, the caches will be warm when the
2487 # are 00-txnreport etc. That way, the caches will be warm when the
2488 # callbacks run.
2488 # callbacks run.
2489 tr.addpostclose(b'-warm-cache', self._buildcacheupdater(tr))
2489 tr.addpostclose(b'-warm-cache', self._buildcacheupdater(tr))
2490
2490
2491 def txnaborthook(tr2):
2491 def txnaborthook(tr2):
2492 """To be run if transaction is aborted"""
2492 """To be run if transaction is aborted"""
2493 reporef().hook(
2493 reporef().hook(
2494 b'txnabort', throw=False, **pycompat.strkwargs(tr2.hookargs)
2494 b'txnabort', throw=False, **pycompat.strkwargs(tr2.hookargs)
2495 )
2495 )
2496
2496
2497 tr.addabort(b'txnabort-hook', txnaborthook)
2497 tr.addabort(b'txnabort-hook', txnaborthook)
2498 # avoid eager cache invalidation. in-memory data should be identical
2498 # avoid eager cache invalidation. in-memory data should be identical
2499 # to stored data if transaction has no error.
2499 # to stored data if transaction has no error.
2500 tr.addpostclose(b'refresh-filecachestats', self._refreshfilecachestats)
2500 tr.addpostclose(b'refresh-filecachestats', self._refreshfilecachestats)
2501 self._transref = weakref.ref(tr)
2501 self._transref = weakref.ref(tr)
2502 scmutil.registersummarycallback(self, tr, desc)
2502 scmutil.registersummarycallback(self, tr, desc)
2503 return tr
2503 return tr
2504
2504
2505 def _journalfiles(self):
2505 def _journalfiles(self):
2506 return (
2506 return (
2507 (self.svfs, b'journal'),
2507 (self.svfs, b'journal'),
2508 (self.svfs, b'journal.narrowspec'),
2508 (self.svfs, b'journal.narrowspec'),
2509 (self.vfs, b'journal.narrowspec.dirstate'),
2509 (self.vfs, b'journal.narrowspec.dirstate'),
2510 (self.vfs, b'journal.dirstate'),
2510 (self.vfs, b'journal.dirstate'),
2511 (self.vfs, b'journal.branch'),
2511 (self.vfs, b'journal.branch'),
2512 (self.vfs, b'journal.desc'),
2512 (self.vfs, b'journal.desc'),
2513 (bookmarks.bookmarksvfs(self), b'journal.bookmarks'),
2513 (bookmarks.bookmarksvfs(self), b'journal.bookmarks'),
2514 (self.svfs, b'journal.phaseroots'),
2514 (self.svfs, b'journal.phaseroots'),
2515 )
2515 )
2516
2516
2517 def undofiles(self):
2517 def undofiles(self):
2518 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
2518 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
2519
2519
2520 @unfilteredmethod
2520 @unfilteredmethod
2521 def _writejournal(self, desc):
2521 def _writejournal(self, desc):
2522 self.dirstate.savebackup(None, b'journal.dirstate')
2522 self.dirstate.savebackup(None, b'journal.dirstate')
2523 narrowspec.savewcbackup(self, b'journal.narrowspec.dirstate')
2523 narrowspec.savewcbackup(self, b'journal.narrowspec.dirstate')
2524 narrowspec.savebackup(self, b'journal.narrowspec')
2524 narrowspec.savebackup(self, b'journal.narrowspec')
2525 self.vfs.write(
2525 self.vfs.write(
2526 b"journal.branch", encoding.fromlocal(self.dirstate.branch())
2526 b"journal.branch", encoding.fromlocal(self.dirstate.branch())
2527 )
2527 )
2528 self.vfs.write(b"journal.desc", b"%d\n%s\n" % (len(self), desc))
2528 self.vfs.write(b"journal.desc", b"%d\n%s\n" % (len(self), desc))
2529 bookmarksvfs = bookmarks.bookmarksvfs(self)
2529 bookmarksvfs = bookmarks.bookmarksvfs(self)
2530 bookmarksvfs.write(
2530 bookmarksvfs.write(
2531 b"journal.bookmarks", bookmarksvfs.tryread(b"bookmarks")
2531 b"journal.bookmarks", bookmarksvfs.tryread(b"bookmarks")
2532 )
2532 )
2533 self.svfs.write(b"journal.phaseroots", self.svfs.tryread(b"phaseroots"))
2533 self.svfs.write(b"journal.phaseroots", self.svfs.tryread(b"phaseroots"))
2534
2534
2535 def recover(self):
2535 def recover(self):
2536 with self.lock():
2536 with self.lock():
2537 if self.svfs.exists(b"journal"):
2537 if self.svfs.exists(b"journal"):
2538 self.ui.status(_(b"rolling back interrupted transaction\n"))
2538 self.ui.status(_(b"rolling back interrupted transaction\n"))
2539 vfsmap = {
2539 vfsmap = {
2540 b'': self.svfs,
2540 b'': self.svfs,
2541 b'plain': self.vfs,
2541 b'plain': self.vfs,
2542 }
2542 }
2543 transaction.rollback(
2543 transaction.rollback(
2544 self.svfs,
2544 self.svfs,
2545 vfsmap,
2545 vfsmap,
2546 b"journal",
2546 b"journal",
2547 self.ui.warn,
2547 self.ui.warn,
2548 checkambigfiles=_cachedfiles,
2548 checkambigfiles=_cachedfiles,
2549 )
2549 )
2550 self.invalidate()
2550 self.invalidate()
2551 return True
2551 return True
2552 else:
2552 else:
2553 self.ui.warn(_(b"no interrupted transaction available\n"))
2553 self.ui.warn(_(b"no interrupted transaction available\n"))
2554 return False
2554 return False
2555
2555
2556 def rollback(self, dryrun=False, force=False):
2556 def rollback(self, dryrun=False, force=False):
2557 wlock = lock = dsguard = None
2557 wlock = lock = dsguard = None
2558 try:
2558 try:
2559 wlock = self.wlock()
2559 wlock = self.wlock()
2560 lock = self.lock()
2560 lock = self.lock()
2561 if self.svfs.exists(b"undo"):
2561 if self.svfs.exists(b"undo"):
2562 dsguard = dirstateguard.dirstateguard(self, b'rollback')
2562 dsguard = dirstateguard.dirstateguard(self, b'rollback')
2563
2563
2564 return self._rollback(dryrun, force, dsguard)
2564 return self._rollback(dryrun, force, dsguard)
2565 else:
2565 else:
2566 self.ui.warn(_(b"no rollback information available\n"))
2566 self.ui.warn(_(b"no rollback information available\n"))
2567 return 1
2567 return 1
2568 finally:
2568 finally:
2569 release(dsguard, lock, wlock)
2569 release(dsguard, lock, wlock)
2570
2570
2571 @unfilteredmethod # Until we get smarter cache management
2571 @unfilteredmethod # Until we get smarter cache management
2572 def _rollback(self, dryrun, force, dsguard):
2572 def _rollback(self, dryrun, force, dsguard):
2573 ui = self.ui
2573 ui = self.ui
2574 try:
2574 try:
2575 args = self.vfs.read(b'undo.desc').splitlines()
2575 args = self.vfs.read(b'undo.desc').splitlines()
2576 (oldlen, desc, detail) = (int(args[0]), args[1], None)
2576 (oldlen, desc, detail) = (int(args[0]), args[1], None)
2577 if len(args) >= 3:
2577 if len(args) >= 3:
2578 detail = args[2]
2578 detail = args[2]
2579 oldtip = oldlen - 1
2579 oldtip = oldlen - 1
2580
2580
2581 if detail and ui.verbose:
2581 if detail and ui.verbose:
2582 msg = _(
2582 msg = _(
2583 b'repository tip rolled back to revision %d'
2583 b'repository tip rolled back to revision %d'
2584 b' (undo %s: %s)\n'
2584 b' (undo %s: %s)\n'
2585 ) % (oldtip, desc, detail)
2585 ) % (oldtip, desc, detail)
2586 else:
2586 else:
2587 msg = _(
2587 msg = _(
2588 b'repository tip rolled back to revision %d (undo %s)\n'
2588 b'repository tip rolled back to revision %d (undo %s)\n'
2589 ) % (oldtip, desc)
2589 ) % (oldtip, desc)
2590 except IOError:
2590 except IOError:
2591 msg = _(b'rolling back unknown transaction\n')
2591 msg = _(b'rolling back unknown transaction\n')
2592 desc = None
2592 desc = None
2593
2593
2594 if not force and self[b'.'] != self[b'tip'] and desc == b'commit':
2594 if not force and self[b'.'] != self[b'tip'] and desc == b'commit':
2595 raise error.Abort(
2595 raise error.Abort(
2596 _(
2596 _(
2597 b'rollback of last commit while not checked out '
2597 b'rollback of last commit while not checked out '
2598 b'may lose data'
2598 b'may lose data'
2599 ),
2599 ),
2600 hint=_(b'use -f to force'),
2600 hint=_(b'use -f to force'),
2601 )
2601 )
2602
2602
2603 ui.status(msg)
2603 ui.status(msg)
2604 if dryrun:
2604 if dryrun:
2605 return 0
2605 return 0
2606
2606
2607 parents = self.dirstate.parents()
2607 parents = self.dirstate.parents()
2608 self.destroying()
2608 self.destroying()
2609 vfsmap = {b'plain': self.vfs, b'': self.svfs}
2609 vfsmap = {b'plain': self.vfs, b'': self.svfs}
2610 transaction.rollback(
2610 transaction.rollback(
2611 self.svfs, vfsmap, b'undo', ui.warn, checkambigfiles=_cachedfiles
2611 self.svfs, vfsmap, b'undo', ui.warn, checkambigfiles=_cachedfiles
2612 )
2612 )
2613 bookmarksvfs = bookmarks.bookmarksvfs(self)
2613 bookmarksvfs = bookmarks.bookmarksvfs(self)
2614 if bookmarksvfs.exists(b'undo.bookmarks'):
2614 if bookmarksvfs.exists(b'undo.bookmarks'):
2615 bookmarksvfs.rename(
2615 bookmarksvfs.rename(
2616 b'undo.bookmarks', b'bookmarks', checkambig=True
2616 b'undo.bookmarks', b'bookmarks', checkambig=True
2617 )
2617 )
2618 if self.svfs.exists(b'undo.phaseroots'):
2618 if self.svfs.exists(b'undo.phaseroots'):
2619 self.svfs.rename(b'undo.phaseroots', b'phaseroots', checkambig=True)
2619 self.svfs.rename(b'undo.phaseroots', b'phaseroots', checkambig=True)
2620 self.invalidate()
2620 self.invalidate()
2621
2621
2622 has_node = self.changelog.index.has_node
2622 has_node = self.changelog.index.has_node
2623 parentgone = any(not has_node(p) for p in parents)
2623 parentgone = any(not has_node(p) for p in parents)
2624 if parentgone:
2624 if parentgone:
2625 # prevent dirstateguard from overwriting already restored one
2625 # prevent dirstateguard from overwriting already restored one
2626 dsguard.close()
2626 dsguard.close()
2627
2627
2628 narrowspec.restorebackup(self, b'undo.narrowspec')
2628 narrowspec.restorebackup(self, b'undo.narrowspec')
2629 narrowspec.restorewcbackup(self, b'undo.narrowspec.dirstate')
2629 narrowspec.restorewcbackup(self, b'undo.narrowspec.dirstate')
2630 self.dirstate.restorebackup(None, b'undo.dirstate')
2630 self.dirstate.restorebackup(None, b'undo.dirstate')
2631 try:
2631 try:
2632 branch = self.vfs.read(b'undo.branch')
2632 branch = self.vfs.read(b'undo.branch')
2633 self.dirstate.setbranch(encoding.tolocal(branch))
2633 self.dirstate.setbranch(encoding.tolocal(branch))
2634 except IOError:
2634 except IOError:
2635 ui.warn(
2635 ui.warn(
2636 _(
2636 _(
2637 b'named branch could not be reset: '
2637 b'named branch could not be reset: '
2638 b'current branch is still \'%s\'\n'
2638 b'current branch is still \'%s\'\n'
2639 )
2639 )
2640 % self.dirstate.branch()
2640 % self.dirstate.branch()
2641 )
2641 )
2642
2642
2643 parents = tuple([p.rev() for p in self[None].parents()])
2643 parents = tuple([p.rev() for p in self[None].parents()])
2644 if len(parents) > 1:
2644 if len(parents) > 1:
2645 ui.status(
2645 ui.status(
2646 _(
2646 _(
2647 b'working directory now based on '
2647 b'working directory now based on '
2648 b'revisions %d and %d\n'
2648 b'revisions %d and %d\n'
2649 )
2649 )
2650 % parents
2650 % parents
2651 )
2651 )
2652 else:
2652 else:
2653 ui.status(
2653 ui.status(
2654 _(b'working directory now based on revision %d\n') % parents
2654 _(b'working directory now based on revision %d\n') % parents
2655 )
2655 )
2656 mergestatemod.mergestate.clean(self)
2656 mergestatemod.mergestate.clean(self)
2657
2657
2658 # TODO: if we know which new heads may result from this rollback, pass
2658 # TODO: if we know which new heads may result from this rollback, pass
2659 # them to destroy(), which will prevent the branchhead cache from being
2659 # them to destroy(), which will prevent the branchhead cache from being
2660 # invalidated.
2660 # invalidated.
2661 self.destroyed()
2661 self.destroyed()
2662 return 0
2662 return 0
2663
2663
2664 def _buildcacheupdater(self, newtransaction):
2664 def _buildcacheupdater(self, newtransaction):
2665 """called during transaction to build the callback updating cache
2665 """called during transaction to build the callback updating cache
2666
2666
2667 Lives on the repository to help extension who might want to augment
2667 Lives on the repository to help extension who might want to augment
2668 this logic. For this purpose, the created transaction is passed to the
2668 this logic. For this purpose, the created transaction is passed to the
2669 method.
2669 method.
2670 """
2670 """
2671 # we must avoid cyclic reference between repo and transaction.
2671 # we must avoid cyclic reference between repo and transaction.
2672 reporef = weakref.ref(self)
2672 reporef = weakref.ref(self)
2673
2673
2674 def updater(tr):
2674 def updater(tr):
2675 repo = reporef()
2675 repo = reporef()
2676 repo.updatecaches(tr)
2676 repo.updatecaches(tr)
2677
2677
2678 return updater
2678 return updater
2679
2679
2680 @unfilteredmethod
2680 @unfilteredmethod
2681 def updatecaches(self, tr=None, full=False):
2681 def updatecaches(self, tr=None, full=False):
2682 """warm appropriate caches
2682 """warm appropriate caches
2683
2683
2684 If this function is called after a transaction closed. The transaction
2684 If this function is called after a transaction closed. The transaction
2685 will be available in the 'tr' argument. This can be used to selectively
2685 will be available in the 'tr' argument. This can be used to selectively
2686 update caches relevant to the changes in that transaction.
2686 update caches relevant to the changes in that transaction.
2687
2687
2688 If 'full' is set, make sure all caches the function knows about have
2688 If 'full' is set, make sure all caches the function knows about have
2689 up-to-date data. Even the ones usually loaded more lazily.
2689 up-to-date data. Even the ones usually loaded more lazily.
2690 """
2690 """
2691 if tr is not None and tr.hookargs.get(b'source') == b'strip':
2691 if tr is not None and tr.hookargs.get(b'source') == b'strip':
2692 # During strip, many caches are invalid but
2692 # During strip, many caches are invalid but
2693 # later call to `destroyed` will refresh them.
2693 # later call to `destroyed` will refresh them.
2694 return
2694 return
2695
2695
2696 if tr is None or tr.changes[b'origrepolen'] < len(self):
2696 if tr is None or tr.changes[b'origrepolen'] < len(self):
2697 # accessing the 'served' branchmap should refresh all the others,
2697 # accessing the 'served' branchmap should refresh all the others,
2698 self.ui.debug(b'updating the branch cache\n')
2698 self.ui.debug(b'updating the branch cache\n')
2699 self.filtered(b'served').branchmap()
2699 self.filtered(b'served').branchmap()
2700 self.filtered(b'served.hidden').branchmap()
2700 self.filtered(b'served.hidden').branchmap()
2701
2701
2702 if full:
2702 if full:
2703 unfi = self.unfiltered()
2703 unfi = self.unfiltered()
2704
2704
2705 self.changelog.update_caches(transaction=tr)
2705 self.changelog.update_caches(transaction=tr)
2706 self.manifestlog.update_caches(transaction=tr)
2706 self.manifestlog.update_caches(transaction=tr)
2707
2707
2708 rbc = unfi.revbranchcache()
2708 rbc = unfi.revbranchcache()
2709 for r in unfi.changelog:
2709 for r in unfi.changelog:
2710 rbc.branchinfo(r)
2710 rbc.branchinfo(r)
2711 rbc.write()
2711 rbc.write()
2712
2712
2713 # ensure the working copy parents are in the manifestfulltextcache
2713 # ensure the working copy parents are in the manifestfulltextcache
2714 for ctx in self[b'.'].parents():
2714 for ctx in self[b'.'].parents():
2715 ctx.manifest() # accessing the manifest is enough
2715 ctx.manifest() # accessing the manifest is enough
2716
2716
2717 # accessing fnode cache warms the cache
2717 # accessing fnode cache warms the cache
2718 tagsmod.fnoderevs(self.ui, unfi, unfi.changelog.revs())
2718 tagsmod.fnoderevs(self.ui, unfi, unfi.changelog.revs())
2719 # accessing tags warm the cache
2719 # accessing tags warm the cache
2720 self.tags()
2720 self.tags()
2721 self.filtered(b'served').tags()
2721 self.filtered(b'served').tags()
2722
2722
2723 # The `full` arg is documented as updating even the lazily-loaded
2723 # The `full` arg is documented as updating even the lazily-loaded
2724 # caches immediately, so we're forcing a write to cause these caches
2724 # caches immediately, so we're forcing a write to cause these caches
2725 # to be warmed up even if they haven't explicitly been requested
2725 # to be warmed up even if they haven't explicitly been requested
2726 # yet (if they've never been used by hg, they won't ever have been
2726 # yet (if they've never been used by hg, they won't ever have been
2727 # written, even if they're a subset of another kind of cache that
2727 # written, even if they're a subset of another kind of cache that
2728 # *has* been used).
2728 # *has* been used).
2729 for filt in repoview.filtertable.keys():
2729 for filt in repoview.filtertable.keys():
2730 filtered = self.filtered(filt)
2730 filtered = self.filtered(filt)
2731 filtered.branchmap().write(filtered)
2731 filtered.branchmap().write(filtered)
2732
2732
2733 def invalidatecaches(self):
2733 def invalidatecaches(self):
2734
2734
2735 if '_tagscache' in vars(self):
2735 if '_tagscache' in vars(self):
2736 # can't use delattr on proxy
2736 # can't use delattr on proxy
2737 del self.__dict__['_tagscache']
2737 del self.__dict__['_tagscache']
2738
2738
2739 self._branchcaches.clear()
2739 self._branchcaches.clear()
2740 self.invalidatevolatilesets()
2740 self.invalidatevolatilesets()
2741 self._sparsesignaturecache.clear()
2741 self._sparsesignaturecache.clear()
2742
2742
2743 def invalidatevolatilesets(self):
2743 def invalidatevolatilesets(self):
2744 self.filteredrevcache.clear()
2744 self.filteredrevcache.clear()
2745 obsolete.clearobscaches(self)
2745 obsolete.clearobscaches(self)
2746 self._quick_access_changeid_invalidate()
2746 self._quick_access_changeid_invalidate()
2747
2747
2748 def invalidatedirstate(self):
2748 def invalidatedirstate(self):
2749 """Invalidates the dirstate, causing the next call to dirstate
2749 """Invalidates the dirstate, causing the next call to dirstate
2750 to check if it was modified since the last time it was read,
2750 to check if it was modified since the last time it was read,
2751 rereading it if it has.
2751 rereading it if it has.
2752
2752
2753 This is different to dirstate.invalidate() that it doesn't always
2753 This is different to dirstate.invalidate() that it doesn't always
2754 rereads the dirstate. Use dirstate.invalidate() if you want to
2754 rereads the dirstate. Use dirstate.invalidate() if you want to
2755 explicitly read the dirstate again (i.e. restoring it to a previous
2755 explicitly read the dirstate again (i.e. restoring it to a previous
2756 known good state)."""
2756 known good state)."""
2757 if hasunfilteredcache(self, 'dirstate'):
2757 if hasunfilteredcache(self, 'dirstate'):
2758 for k in self.dirstate._filecache:
2758 for k in self.dirstate._filecache:
2759 try:
2759 try:
2760 delattr(self.dirstate, k)
2760 delattr(self.dirstate, k)
2761 except AttributeError:
2761 except AttributeError:
2762 pass
2762 pass
2763 delattr(self.unfiltered(), 'dirstate')
2763 delattr(self.unfiltered(), 'dirstate')
2764
2764
2765 def invalidate(self, clearfilecache=False):
2765 def invalidate(self, clearfilecache=False):
2766 """Invalidates both store and non-store parts other than dirstate
2766 """Invalidates both store and non-store parts other than dirstate
2767
2767
2768 If a transaction is running, invalidation of store is omitted,
2768 If a transaction is running, invalidation of store is omitted,
2769 because discarding in-memory changes might cause inconsistency
2769 because discarding in-memory changes might cause inconsistency
2770 (e.g. incomplete fncache causes unintentional failure, but
2770 (e.g. incomplete fncache causes unintentional failure, but
2771 redundant one doesn't).
2771 redundant one doesn't).
2772 """
2772 """
2773 unfiltered = self.unfiltered() # all file caches are stored unfiltered
2773 unfiltered = self.unfiltered() # all file caches are stored unfiltered
2774 for k in list(self._filecache.keys()):
2774 for k in list(self._filecache.keys()):
2775 # dirstate is invalidated separately in invalidatedirstate()
2775 # dirstate is invalidated separately in invalidatedirstate()
2776 if k == b'dirstate':
2776 if k == b'dirstate':
2777 continue
2777 continue
2778 if (
2778 if (
2779 k == b'changelog'
2779 k == b'changelog'
2780 and self.currenttransaction()
2780 and self.currenttransaction()
2781 and self.changelog._delayed
2781 and self.changelog._delayed
2782 ):
2782 ):
2783 # The changelog object may store unwritten revisions. We don't
2783 # The changelog object may store unwritten revisions. We don't
2784 # want to lose them.
2784 # want to lose them.
2785 # TODO: Solve the problem instead of working around it.
2785 # TODO: Solve the problem instead of working around it.
2786 continue
2786 continue
2787
2787
2788 if clearfilecache:
2788 if clearfilecache:
2789 del self._filecache[k]
2789 del self._filecache[k]
2790 try:
2790 try:
2791 delattr(unfiltered, k)
2791 delattr(unfiltered, k)
2792 except AttributeError:
2792 except AttributeError:
2793 pass
2793 pass
2794 self.invalidatecaches()
2794 self.invalidatecaches()
2795 if not self.currenttransaction():
2795 if not self.currenttransaction():
2796 # TODO: Changing contents of store outside transaction
2796 # TODO: Changing contents of store outside transaction
2797 # causes inconsistency. We should make in-memory store
2797 # causes inconsistency. We should make in-memory store
2798 # changes detectable, and abort if changed.
2798 # changes detectable, and abort if changed.
2799 self.store.invalidatecaches()
2799 self.store.invalidatecaches()
2800
2800
2801 def invalidateall(self):
2801 def invalidateall(self):
2802 """Fully invalidates both store and non-store parts, causing the
2802 """Fully invalidates both store and non-store parts, causing the
2803 subsequent operation to reread any outside changes."""
2803 subsequent operation to reread any outside changes."""
2804 # extension should hook this to invalidate its caches
2804 # extension should hook this to invalidate its caches
2805 self.invalidate()
2805 self.invalidate()
2806 self.invalidatedirstate()
2806 self.invalidatedirstate()
2807
2807
2808 @unfilteredmethod
2808 @unfilteredmethod
2809 def _refreshfilecachestats(self, tr):
2809 def _refreshfilecachestats(self, tr):
2810 """Reload stats of cached files so that they are flagged as valid"""
2810 """Reload stats of cached files so that they are flagged as valid"""
2811 for k, ce in self._filecache.items():
2811 for k, ce in self._filecache.items():
2812 k = pycompat.sysstr(k)
2812 k = pycompat.sysstr(k)
2813 if k == 'dirstate' or k not in self.__dict__:
2813 if k == 'dirstate' or k not in self.__dict__:
2814 continue
2814 continue
2815 ce.refresh()
2815 ce.refresh()
2816
2816
2817 def _lock(
2817 def _lock(
2818 self,
2818 self,
2819 vfs,
2819 vfs,
2820 lockname,
2820 lockname,
2821 wait,
2821 wait,
2822 releasefn,
2822 releasefn,
2823 acquirefn,
2823 acquirefn,
2824 desc,
2824 desc,
2825 ):
2825 ):
2826 timeout = 0
2826 timeout = 0
2827 warntimeout = 0
2827 warntimeout = 0
2828 if wait:
2828 if wait:
2829 timeout = self.ui.configint(b"ui", b"timeout")
2829 timeout = self.ui.configint(b"ui", b"timeout")
2830 warntimeout = self.ui.configint(b"ui", b"timeout.warn")
2830 warntimeout = self.ui.configint(b"ui", b"timeout.warn")
2831 # internal config: ui.signal-safe-lock
2831 # internal config: ui.signal-safe-lock
2832 signalsafe = self.ui.configbool(b'ui', b'signal-safe-lock')
2832 signalsafe = self.ui.configbool(b'ui', b'signal-safe-lock')
2833
2833
2834 l = lockmod.trylock(
2834 l = lockmod.trylock(
2835 self.ui,
2835 self.ui,
2836 vfs,
2836 vfs,
2837 lockname,
2837 lockname,
2838 timeout,
2838 timeout,
2839 warntimeout,
2839 warntimeout,
2840 releasefn=releasefn,
2840 releasefn=releasefn,
2841 acquirefn=acquirefn,
2841 acquirefn=acquirefn,
2842 desc=desc,
2842 desc=desc,
2843 signalsafe=signalsafe,
2843 signalsafe=signalsafe,
2844 )
2844 )
2845 return l
2845 return l
2846
2846
2847 def _afterlock(self, callback):
2847 def _afterlock(self, callback):
2848 """add a callback to be run when the repository is fully unlocked
2848 """add a callback to be run when the repository is fully unlocked
2849
2849
2850 The callback will be executed when the outermost lock is released
2850 The callback will be executed when the outermost lock is released
2851 (with wlock being higher level than 'lock')."""
2851 (with wlock being higher level than 'lock')."""
2852 for ref in (self._wlockref, self._lockref):
2852 for ref in (self._wlockref, self._lockref):
2853 l = ref and ref()
2853 l = ref and ref()
2854 if l and l.held:
2854 if l and l.held:
2855 l.postrelease.append(callback)
2855 l.postrelease.append(callback)
2856 break
2856 break
2857 else: # no lock have been found.
2857 else: # no lock have been found.
2858 callback(True)
2858 callback(True)
2859
2859
2860 def lock(self, wait=True):
2860 def lock(self, wait=True):
2861 """Lock the repository store (.hg/store) and return a weak reference
2861 """Lock the repository store (.hg/store) and return a weak reference
2862 to the lock. Use this before modifying the store (e.g. committing or
2862 to the lock. Use this before modifying the store (e.g. committing or
2863 stripping). If you are opening a transaction, get a lock as well.)
2863 stripping). If you are opening a transaction, get a lock as well.)
2864
2864
2865 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2865 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2866 'wlock' first to avoid a dead-lock hazard."""
2866 'wlock' first to avoid a dead-lock hazard."""
2867 l = self._currentlock(self._lockref)
2867 l = self._currentlock(self._lockref)
2868 if l is not None:
2868 if l is not None:
2869 l.lock()
2869 l.lock()
2870 return l
2870 return l
2871
2871
2872 l = self._lock(
2872 l = self._lock(
2873 vfs=self.svfs,
2873 vfs=self.svfs,
2874 lockname=b"lock",
2874 lockname=b"lock",
2875 wait=wait,
2875 wait=wait,
2876 releasefn=None,
2876 releasefn=None,
2877 acquirefn=self.invalidate,
2877 acquirefn=self.invalidate,
2878 desc=_(b'repository %s') % self.origroot,
2878 desc=_(b'repository %s') % self.origroot,
2879 )
2879 )
2880 self._lockref = weakref.ref(l)
2880 self._lockref = weakref.ref(l)
2881 return l
2881 return l
2882
2882
2883 def wlock(self, wait=True):
2883 def wlock(self, wait=True):
2884 """Lock the non-store parts of the repository (everything under
2884 """Lock the non-store parts of the repository (everything under
2885 .hg except .hg/store) and return a weak reference to the lock.
2885 .hg except .hg/store) and return a weak reference to the lock.
2886
2886
2887 Use this before modifying files in .hg.
2887 Use this before modifying files in .hg.
2888
2888
2889 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2889 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2890 'wlock' first to avoid a dead-lock hazard."""
2890 'wlock' first to avoid a dead-lock hazard."""
2891 l = self._wlockref and self._wlockref()
2891 l = self._wlockref and self._wlockref()
2892 if l is not None and l.held:
2892 if l is not None and l.held:
2893 l.lock()
2893 l.lock()
2894 return l
2894 return l
2895
2895
2896 # We do not need to check for non-waiting lock acquisition. Such
2896 # We do not need to check for non-waiting lock acquisition. Such
2897 # acquisition would not cause dead-lock as they would just fail.
2897 # acquisition would not cause dead-lock as they would just fail.
2898 if wait and (
2898 if wait and (
2899 self.ui.configbool(b'devel', b'all-warnings')
2899 self.ui.configbool(b'devel', b'all-warnings')
2900 or self.ui.configbool(b'devel', b'check-locks')
2900 or self.ui.configbool(b'devel', b'check-locks')
2901 ):
2901 ):
2902 if self._currentlock(self._lockref) is not None:
2902 if self._currentlock(self._lockref) is not None:
2903 self.ui.develwarn(b'"wlock" acquired after "lock"')
2903 self.ui.develwarn(b'"wlock" acquired after "lock"')
2904
2904
2905 def unlock():
2905 def unlock():
2906 if self.dirstate.pendingparentchange():
2906 if self.dirstate.pendingparentchange():
2907 self.dirstate.invalidate()
2907 self.dirstate.invalidate()
2908 else:
2908 else:
2909 self.dirstate.write(None)
2909 self.dirstate.write(None)
2910
2910
2911 self._filecache[b'dirstate'].refresh()
2911 self._filecache[b'dirstate'].refresh()
2912
2912
2913 l = self._lock(
2913 l = self._lock(
2914 self.vfs,
2914 self.vfs,
2915 b"wlock",
2915 b"wlock",
2916 wait,
2916 wait,
2917 unlock,
2917 unlock,
2918 self.invalidatedirstate,
2918 self.invalidatedirstate,
2919 _(b'working directory of %s') % self.origroot,
2919 _(b'working directory of %s') % self.origroot,
2920 )
2920 )
2921 self._wlockref = weakref.ref(l)
2921 self._wlockref = weakref.ref(l)
2922 return l
2922 return l
2923
2923
2924 def _currentlock(self, lockref):
2924 def _currentlock(self, lockref):
2925 """Returns the lock if it's held, or None if it's not."""
2925 """Returns the lock if it's held, or None if it's not."""
2926 if lockref is None:
2926 if lockref is None:
2927 return None
2927 return None
2928 l = lockref()
2928 l = lockref()
2929 if l is None or not l.held:
2929 if l is None or not l.held:
2930 return None
2930 return None
2931 return l
2931 return l
2932
2932
2933 def currentwlock(self):
2933 def currentwlock(self):
2934 """Returns the wlock if it's held, or None if it's not."""
2934 """Returns the wlock if it's held, or None if it's not."""
2935 return self._currentlock(self._wlockref)
2935 return self._currentlock(self._wlockref)
2936
2936
2937 def checkcommitpatterns(self, wctx, match, status, fail):
2937 def checkcommitpatterns(self, wctx, match, status, fail):
2938 """check for commit arguments that aren't committable"""
2938 """check for commit arguments that aren't committable"""
2939 if match.isexact() or match.prefix():
2939 if match.isexact() or match.prefix():
2940 matched = set(status.modified + status.added + status.removed)
2940 matched = set(status.modified + status.added + status.removed)
2941
2941
2942 for f in match.files():
2942 for f in match.files():
2943 f = self.dirstate.normalize(f)
2943 f = self.dirstate.normalize(f)
2944 if f == b'.' or f in matched or f in wctx.substate:
2944 if f == b'.' or f in matched or f in wctx.substate:
2945 continue
2945 continue
2946 if f in status.deleted:
2946 if f in status.deleted:
2947 fail(f, _(b'file not found!'))
2947 fail(f, _(b'file not found!'))
2948 # Is it a directory that exists or used to exist?
2948 # Is it a directory that exists or used to exist?
2949 if self.wvfs.isdir(f) or wctx.p1().hasdir(f):
2949 if self.wvfs.isdir(f) or wctx.p1().hasdir(f):
2950 d = f + b'/'
2950 d = f + b'/'
2951 for mf in matched:
2951 for mf in matched:
2952 if mf.startswith(d):
2952 if mf.startswith(d):
2953 break
2953 break
2954 else:
2954 else:
2955 fail(f, _(b"no match under directory!"))
2955 fail(f, _(b"no match under directory!"))
2956 elif f not in self.dirstate:
2956 elif f not in self.dirstate:
2957 fail(f, _(b"file not tracked!"))
2957 fail(f, _(b"file not tracked!"))
2958
2958
2959 @unfilteredmethod
2959 @unfilteredmethod
2960 def commit(
2960 def commit(
2961 self,
2961 self,
2962 text=b"",
2962 text=b"",
2963 user=None,
2963 user=None,
2964 date=None,
2964 date=None,
2965 match=None,
2965 match=None,
2966 force=False,
2966 force=False,
2967 editor=None,
2967 editor=None,
2968 extra=None,
2968 extra=None,
2969 ):
2969 ):
2970 """Add a new revision to current repository.
2970 """Add a new revision to current repository.
2971
2971
2972 Revision information is gathered from the working directory,
2972 Revision information is gathered from the working directory,
2973 match can be used to filter the committed files. If editor is
2973 match can be used to filter the committed files. If editor is
2974 supplied, it is called to get a commit message.
2974 supplied, it is called to get a commit message.
2975 """
2975 """
2976 if extra is None:
2976 if extra is None:
2977 extra = {}
2977 extra = {}
2978
2978
2979 def fail(f, msg):
2979 def fail(f, msg):
2980 raise error.InputError(b'%s: %s' % (f, msg))
2980 raise error.InputError(b'%s: %s' % (f, msg))
2981
2981
2982 if not match:
2982 if not match:
2983 match = matchmod.always()
2983 match = matchmod.always()
2984
2984
2985 if not force:
2985 if not force:
2986 match.bad = fail
2986 match.bad = fail
2987
2987
2988 # lock() for recent changelog (see issue4368)
2988 # lock() for recent changelog (see issue4368)
2989 with self.wlock(), self.lock():
2989 with self.wlock(), self.lock():
2990 wctx = self[None]
2990 wctx = self[None]
2991 merge = len(wctx.parents()) > 1
2991 merge = len(wctx.parents()) > 1
2992
2992
2993 if not force and merge and not match.always():
2993 if not force and merge and not match.always():
2994 raise error.Abort(
2994 raise error.Abort(
2995 _(
2995 _(
2996 b'cannot partially commit a merge '
2996 b'cannot partially commit a merge '
2997 b'(do not specify files or patterns)'
2997 b'(do not specify files or patterns)'
2998 )
2998 )
2999 )
2999 )
3000
3000
3001 status = self.status(match=match, clean=force)
3001 status = self.status(match=match, clean=force)
3002 if force:
3002 if force:
3003 status.modified.extend(
3003 status.modified.extend(
3004 status.clean
3004 status.clean
3005 ) # mq may commit clean files
3005 ) # mq may commit clean files
3006
3006
3007 # check subrepos
3007 # check subrepos
3008 subs, commitsubs, newstate = subrepoutil.precommit(
3008 subs, commitsubs, newstate = subrepoutil.precommit(
3009 self.ui, wctx, status, match, force=force
3009 self.ui, wctx, status, match, force=force
3010 )
3010 )
3011
3011
3012 # make sure all explicit patterns are matched
3012 # make sure all explicit patterns are matched
3013 if not force:
3013 if not force:
3014 self.checkcommitpatterns(wctx, match, status, fail)
3014 self.checkcommitpatterns(wctx, match, status, fail)
3015
3015
3016 cctx = context.workingcommitctx(
3016 cctx = context.workingcommitctx(
3017 self, status, text, user, date, extra
3017 self, status, text, user, date, extra
3018 )
3018 )
3019
3019
3020 ms = mergestatemod.mergestate.read(self)
3020 ms = mergestatemod.mergestate.read(self)
3021 mergeutil.checkunresolved(ms)
3021 mergeutil.checkunresolved(ms)
3022
3022
3023 # internal config: ui.allowemptycommit
3023 # internal config: ui.allowemptycommit
3024 if cctx.isempty() and not self.ui.configbool(
3024 if cctx.isempty() and not self.ui.configbool(
3025 b'ui', b'allowemptycommit'
3025 b'ui', b'allowemptycommit'
3026 ):
3026 ):
3027 self.ui.debug(b'nothing to commit, clearing merge state\n')
3027 self.ui.debug(b'nothing to commit, clearing merge state\n')
3028 ms.reset()
3028 ms.reset()
3029 return None
3029 return None
3030
3030
3031 if merge and cctx.deleted():
3031 if merge and cctx.deleted():
3032 raise error.Abort(_(b"cannot commit merge with missing files"))
3032 raise error.Abort(_(b"cannot commit merge with missing files"))
3033
3033
3034 if editor:
3034 if editor:
3035 cctx._text = editor(self, cctx, subs)
3035 cctx._text = editor(self, cctx, subs)
3036 edited = text != cctx._text
3036 edited = text != cctx._text
3037
3037
3038 # Save commit message in case this transaction gets rolled back
3038 # Save commit message in case this transaction gets rolled back
3039 # (e.g. by a pretxncommit hook). Leave the content alone on
3039 # (e.g. by a pretxncommit hook). Leave the content alone on
3040 # the assumption that the user will use the same editor again.
3040 # the assumption that the user will use the same editor again.
3041 msgfn = self.savecommitmessage(cctx._text)
3041 msgfn = self.savecommitmessage(cctx._text)
3042
3042
3043 # commit subs and write new state
3043 # commit subs and write new state
3044 if subs:
3044 if subs:
3045 uipathfn = scmutil.getuipathfn(self)
3045 uipathfn = scmutil.getuipathfn(self)
3046 for s in sorted(commitsubs):
3046 for s in sorted(commitsubs):
3047 sub = wctx.sub(s)
3047 sub = wctx.sub(s)
3048 self.ui.status(
3048 self.ui.status(
3049 _(b'committing subrepository %s\n')
3049 _(b'committing subrepository %s\n')
3050 % uipathfn(subrepoutil.subrelpath(sub))
3050 % uipathfn(subrepoutil.subrelpath(sub))
3051 )
3051 )
3052 sr = sub.commit(cctx._text, user, date)
3052 sr = sub.commit(cctx._text, user, date)
3053 newstate[s] = (newstate[s][0], sr)
3053 newstate[s] = (newstate[s][0], sr)
3054 subrepoutil.writestate(self, newstate)
3054 subrepoutil.writestate(self, newstate)
3055
3055
3056 p1, p2 = self.dirstate.parents()
3056 p1, p2 = self.dirstate.parents()
3057 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or b'')
3057 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or b'')
3058 try:
3058 try:
3059 self.hook(
3059 self.hook(
3060 b"precommit", throw=True, parent1=hookp1, parent2=hookp2
3060 b"precommit", throw=True, parent1=hookp1, parent2=hookp2
3061 )
3061 )
3062 with self.transaction(b'commit'):
3062 with self.transaction(b'commit'):
3063 ret = self.commitctx(cctx, True)
3063 ret = self.commitctx(cctx, True)
3064 # update bookmarks, dirstate and mergestate
3064 # update bookmarks, dirstate and mergestate
3065 bookmarks.update(self, [p1, p2], ret)
3065 bookmarks.update(self, [p1, p2], ret)
3066 cctx.markcommitted(ret)
3066 cctx.markcommitted(ret)
3067 ms.reset()
3067 ms.reset()
3068 except: # re-raises
3068 except: # re-raises
3069 if edited:
3069 if edited:
3070 self.ui.write(
3070 self.ui.write(
3071 _(b'note: commit message saved in %s\n') % msgfn
3071 _(b'note: commit message saved in %s\n') % msgfn
3072 )
3072 )
3073 self.ui.write(
3073 self.ui.write(
3074 _(
3074 _(
3075 b"note: use 'hg commit --logfile "
3075 b"note: use 'hg commit --logfile "
3076 b".hg/last-message.txt --edit' to reuse it\n"
3076 b".hg/last-message.txt --edit' to reuse it\n"
3077 )
3077 )
3078 )
3078 )
3079 raise
3079 raise
3080
3080
3081 def commithook(unused_success):
3081 def commithook(unused_success):
3082 # hack for command that use a temporary commit (eg: histedit)
3082 # hack for command that use a temporary commit (eg: histedit)
3083 # temporary commit got stripped before hook release
3083 # temporary commit got stripped before hook release
3084 if self.changelog.hasnode(ret):
3084 if self.changelog.hasnode(ret):
3085 self.hook(
3085 self.hook(
3086 b"commit", node=hex(ret), parent1=hookp1, parent2=hookp2
3086 b"commit", node=hex(ret), parent1=hookp1, parent2=hookp2
3087 )
3087 )
3088
3088
3089 self._afterlock(commithook)
3089 self._afterlock(commithook)
3090 return ret
3090 return ret
3091
3091
3092 @unfilteredmethod
3092 @unfilteredmethod
3093 def commitctx(self, ctx, error=False, origctx=None):
3093 def commitctx(self, ctx, error=False, origctx=None):
3094 return commit.commitctx(self, ctx, error=error, origctx=origctx)
3094 return commit.commitctx(self, ctx, error=error, origctx=origctx)
3095
3095
3096 @unfilteredmethod
3096 @unfilteredmethod
3097 def destroying(self):
3097 def destroying(self):
3098 """Inform the repository that nodes are about to be destroyed.
3098 """Inform the repository that nodes are about to be destroyed.
3099 Intended for use by strip and rollback, so there's a common
3099 Intended for use by strip and rollback, so there's a common
3100 place for anything that has to be done before destroying history.
3100 place for anything that has to be done before destroying history.
3101
3101
3102 This is mostly useful for saving state that is in memory and waiting
3102 This is mostly useful for saving state that is in memory and waiting
3103 to be flushed when the current lock is released. Because a call to
3103 to be flushed when the current lock is released. Because a call to
3104 destroyed is imminent, the repo will be invalidated causing those
3104 destroyed is imminent, the repo will be invalidated causing those
3105 changes to stay in memory (waiting for the next unlock), or vanish
3105 changes to stay in memory (waiting for the next unlock), or vanish
3106 completely.
3106 completely.
3107 """
3107 """
3108 # When using the same lock to commit and strip, the phasecache is left
3108 # When using the same lock to commit and strip, the phasecache is left
3109 # dirty after committing. Then when we strip, the repo is invalidated,
3109 # dirty after committing. Then when we strip, the repo is invalidated,
3110 # causing those changes to disappear.
3110 # causing those changes to disappear.
3111 if '_phasecache' in vars(self):
3111 if '_phasecache' in vars(self):
3112 self._phasecache.write()
3112 self._phasecache.write()
3113
3113
3114 @unfilteredmethod
3114 @unfilteredmethod
3115 def destroyed(self):
3115 def destroyed(self):
3116 """Inform the repository that nodes have been destroyed.
3116 """Inform the repository that nodes have been destroyed.
3117 Intended for use by strip and rollback, so there's a common
3117 Intended for use by strip and rollback, so there's a common
3118 place for anything that has to be done after destroying history.
3118 place for anything that has to be done after destroying history.
3119 """
3119 """
3120 # When one tries to:
3120 # When one tries to:
3121 # 1) destroy nodes thus calling this method (e.g. strip)
3121 # 1) destroy nodes thus calling this method (e.g. strip)
3122 # 2) use phasecache somewhere (e.g. commit)
3122 # 2) use phasecache somewhere (e.g. commit)
3123 #
3123 #
3124 # then 2) will fail because the phasecache contains nodes that were
3124 # then 2) will fail because the phasecache contains nodes that were
3125 # removed. We can either remove phasecache from the filecache,
3125 # removed. We can either remove phasecache from the filecache,
3126 # causing it to reload next time it is accessed, or simply filter
3126 # causing it to reload next time it is accessed, or simply filter
3127 # the removed nodes now and write the updated cache.
3127 # the removed nodes now and write the updated cache.
3128 self._phasecache.filterunknown(self)
3128 self._phasecache.filterunknown(self)
3129 self._phasecache.write()
3129 self._phasecache.write()
3130
3130
3131 # refresh all repository caches
3131 # refresh all repository caches
3132 self.updatecaches()
3132 self.updatecaches()
3133
3133
3134 # Ensure the persistent tag cache is updated. Doing it now
3134 # Ensure the persistent tag cache is updated. Doing it now
3135 # means that the tag cache only has to worry about destroyed
3135 # means that the tag cache only has to worry about destroyed
3136 # heads immediately after a strip/rollback. That in turn
3136 # heads immediately after a strip/rollback. That in turn
3137 # guarantees that "cachetip == currenttip" (comparing both rev
3137 # guarantees that "cachetip == currenttip" (comparing both rev
3138 # and node) always means no nodes have been added or destroyed.
3138 # and node) always means no nodes have been added or destroyed.
3139
3139
3140 # XXX this is suboptimal when qrefresh'ing: we strip the current
3140 # XXX this is suboptimal when qrefresh'ing: we strip the current
3141 # head, refresh the tag cache, then immediately add a new head.
3141 # head, refresh the tag cache, then immediately add a new head.
3142 # But I think doing it this way is necessary for the "instant
3142 # But I think doing it this way is necessary for the "instant
3143 # tag cache retrieval" case to work.
3143 # tag cache retrieval" case to work.
3144 self.invalidate()
3144 self.invalidate()
3145
3145
3146 def status(
3146 def status(
3147 self,
3147 self,
3148 node1=b'.',
3148 node1=b'.',
3149 node2=None,
3149 node2=None,
3150 match=None,
3150 match=None,
3151 ignored=False,
3151 ignored=False,
3152 clean=False,
3152 clean=False,
3153 unknown=False,
3153 unknown=False,
3154 listsubrepos=False,
3154 listsubrepos=False,
3155 ):
3155 ):
3156 '''a convenience method that calls node1.status(node2)'''
3156 '''a convenience method that calls node1.status(node2)'''
3157 return self[node1].status(
3157 return self[node1].status(
3158 node2, match, ignored, clean, unknown, listsubrepos
3158 node2, match, ignored, clean, unknown, listsubrepos
3159 )
3159 )
3160
3160
3161 def addpostdsstatus(self, ps):
3161 def addpostdsstatus(self, ps):
3162 """Add a callback to run within the wlock, at the point at which status
3162 """Add a callback to run within the wlock, at the point at which status
3163 fixups happen.
3163 fixups happen.
3164
3164
3165 On status completion, callback(wctx, status) will be called with the
3165 On status completion, callback(wctx, status) will be called with the
3166 wlock held, unless the dirstate has changed from underneath or the wlock
3166 wlock held, unless the dirstate has changed from underneath or the wlock
3167 couldn't be grabbed.
3167 couldn't be grabbed.
3168
3168
3169 Callbacks should not capture and use a cached copy of the dirstate --
3169 Callbacks should not capture and use a cached copy of the dirstate --
3170 it might change in the meanwhile. Instead, they should access the
3170 it might change in the meanwhile. Instead, they should access the
3171 dirstate via wctx.repo().dirstate.
3171 dirstate via wctx.repo().dirstate.
3172
3172
3173 This list is emptied out after each status run -- extensions should
3173 This list is emptied out after each status run -- extensions should
3174 make sure it adds to this list each time dirstate.status is called.
3174 make sure it adds to this list each time dirstate.status is called.
3175 Extensions should also make sure they don't call this for statuses
3175 Extensions should also make sure they don't call this for statuses
3176 that don't involve the dirstate.
3176 that don't involve the dirstate.
3177 """
3177 """
3178
3178
3179 # The list is located here for uniqueness reasons -- it is actually
3179 # The list is located here for uniqueness reasons -- it is actually
3180 # managed by the workingctx, but that isn't unique per-repo.
3180 # managed by the workingctx, but that isn't unique per-repo.
3181 self._postdsstatus.append(ps)
3181 self._postdsstatus.append(ps)
3182
3182
3183 def postdsstatus(self):
3183 def postdsstatus(self):
3184 """Used by workingctx to get the list of post-dirstate-status hooks."""
3184 """Used by workingctx to get the list of post-dirstate-status hooks."""
3185 return self._postdsstatus
3185 return self._postdsstatus
3186
3186
3187 def clearpostdsstatus(self):
3187 def clearpostdsstatus(self):
3188 """Used by workingctx to clear post-dirstate-status hooks."""
3188 """Used by workingctx to clear post-dirstate-status hooks."""
3189 del self._postdsstatus[:]
3189 del self._postdsstatus[:]
3190
3190
3191 def heads(self, start=None):
3191 def heads(self, start=None):
3192 if start is None:
3192 if start is None:
3193 cl = self.changelog
3193 cl = self.changelog
3194 headrevs = reversed(cl.headrevs())
3194 headrevs = reversed(cl.headrevs())
3195 return [cl.node(rev) for rev in headrevs]
3195 return [cl.node(rev) for rev in headrevs]
3196
3196
3197 heads = self.changelog.heads(start)
3197 heads = self.changelog.heads(start)
3198 # sort the output in rev descending order
3198 # sort the output in rev descending order
3199 return sorted(heads, key=self.changelog.rev, reverse=True)
3199 return sorted(heads, key=self.changelog.rev, reverse=True)
3200
3200
3201 def branchheads(self, branch=None, start=None, closed=False):
3201 def branchheads(self, branch=None, start=None, closed=False):
3202 """return a (possibly filtered) list of heads for the given branch
3202 """return a (possibly filtered) list of heads for the given branch
3203
3203
3204 Heads are returned in topological order, from newest to oldest.
3204 Heads are returned in topological order, from newest to oldest.
3205 If branch is None, use the dirstate branch.
3205 If branch is None, use the dirstate branch.
3206 If start is not None, return only heads reachable from start.
3206 If start is not None, return only heads reachable from start.
3207 If closed is True, return heads that are marked as closed as well.
3207 If closed is True, return heads that are marked as closed as well.
3208 """
3208 """
3209 if branch is None:
3209 if branch is None:
3210 branch = self[None].branch()
3210 branch = self[None].branch()
3211 branches = self.branchmap()
3211 branches = self.branchmap()
3212 if not branches.hasbranch(branch):
3212 if not branches.hasbranch(branch):
3213 return []
3213 return []
3214 # the cache returns heads ordered lowest to highest
3214 # the cache returns heads ordered lowest to highest
3215 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
3215 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
3216 if start is not None:
3216 if start is not None:
3217 # filter out the heads that cannot be reached from startrev
3217 # filter out the heads that cannot be reached from startrev
3218 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
3218 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
3219 bheads = [h for h in bheads if h in fbheads]
3219 bheads = [h for h in bheads if h in fbheads]
3220 return bheads
3220 return bheads
3221
3221
3222 def branches(self, nodes):
3222 def branches(self, nodes):
3223 if not nodes:
3223 if not nodes:
3224 nodes = [self.changelog.tip()]
3224 nodes = [self.changelog.tip()]
3225 b = []
3225 b = []
3226 for n in nodes:
3226 for n in nodes:
3227 t = n
3227 t = n
3228 while True:
3228 while True:
3229 p = self.changelog.parents(n)
3229 p = self.changelog.parents(n)
3230 if p[1] != nullid or p[0] == nullid:
3230 if p[1] != nullid or p[0] == nullid:
3231 b.append((t, n, p[0], p[1]))
3231 b.append((t, n, p[0], p[1]))
3232 break
3232 break
3233 n = p[0]
3233 n = p[0]
3234 return b
3234 return b
3235
3235
3236 def between(self, pairs):
3236 def between(self, pairs):
3237 r = []
3237 r = []
3238
3238
3239 for top, bottom in pairs:
3239 for top, bottom in pairs:
3240 n, l, i = top, [], 0
3240 n, l, i = top, [], 0
3241 f = 1
3241 f = 1
3242
3242
3243 while n != bottom and n != nullid:
3243 while n != bottom and n != nullid:
3244 p = self.changelog.parents(n)[0]
3244 p = self.changelog.parents(n)[0]
3245 if i == f:
3245 if i == f:
3246 l.append(n)
3246 l.append(n)
3247 f = f * 2
3247 f = f * 2
3248 n = p
3248 n = p
3249 i += 1
3249 i += 1
3250
3250
3251 r.append(l)
3251 r.append(l)
3252
3252
3253 return r
3253 return r
3254
3254
3255 def checkpush(self, pushop):
3255 def checkpush(self, pushop):
3256 """Extensions can override this function if additional checks have
3256 """Extensions can override this function if additional checks have
3257 to be performed before pushing, or call it if they override push
3257 to be performed before pushing, or call it if they override push
3258 command.
3258 command.
3259 """
3259 """
3260
3260
3261 @unfilteredpropertycache
3261 @unfilteredpropertycache
3262 def prepushoutgoinghooks(self):
3262 def prepushoutgoinghooks(self):
3263 """Return util.hooks consists of a pushop with repo, remote, outgoing
3263 """Return util.hooks consists of a pushop with repo, remote, outgoing
3264 methods, which are called before pushing changesets.
3264 methods, which are called before pushing changesets.
3265 """
3265 """
3266 return util.hooks()
3266 return util.hooks()
3267
3267
3268 def pushkey(self, namespace, key, old, new):
3268 def pushkey(self, namespace, key, old, new):
3269 try:
3269 try:
3270 tr = self.currenttransaction()
3270 tr = self.currenttransaction()
3271 hookargs = {}
3271 hookargs = {}
3272 if tr is not None:
3272 if tr is not None:
3273 hookargs.update(tr.hookargs)
3273 hookargs.update(tr.hookargs)
3274 hookargs = pycompat.strkwargs(hookargs)
3274 hookargs = pycompat.strkwargs(hookargs)
3275 hookargs['namespace'] = namespace
3275 hookargs['namespace'] = namespace
3276 hookargs['key'] = key
3276 hookargs['key'] = key
3277 hookargs['old'] = old
3277 hookargs['old'] = old
3278 hookargs['new'] = new
3278 hookargs['new'] = new
3279 self.hook(b'prepushkey', throw=True, **hookargs)
3279 self.hook(b'prepushkey', throw=True, **hookargs)
3280 except error.HookAbort as exc:
3280 except error.HookAbort as exc:
3281 self.ui.write_err(_(b"pushkey-abort: %s\n") % exc)
3281 self.ui.write_err(_(b"pushkey-abort: %s\n") % exc)
3282 if exc.hint:
3282 if exc.hint:
3283 self.ui.write_err(_(b"(%s)\n") % exc.hint)
3283 self.ui.write_err(_(b"(%s)\n") % exc.hint)
3284 return False
3284 return False
3285 self.ui.debug(b'pushing key for "%s:%s"\n' % (namespace, key))
3285 self.ui.debug(b'pushing key for "%s:%s"\n' % (namespace, key))
3286 ret = pushkey.push(self, namespace, key, old, new)
3286 ret = pushkey.push(self, namespace, key, old, new)
3287
3287
3288 def runhook(unused_success):
3288 def runhook(unused_success):
3289 self.hook(
3289 self.hook(
3290 b'pushkey',
3290 b'pushkey',
3291 namespace=namespace,
3291 namespace=namespace,
3292 key=key,
3292 key=key,
3293 old=old,
3293 old=old,
3294 new=new,
3294 new=new,
3295 ret=ret,
3295 ret=ret,
3296 )
3296 )
3297
3297
3298 self._afterlock(runhook)
3298 self._afterlock(runhook)
3299 return ret
3299 return ret
3300
3300
3301 def listkeys(self, namespace):
3301 def listkeys(self, namespace):
3302 self.hook(b'prelistkeys', throw=True, namespace=namespace)
3302 self.hook(b'prelistkeys', throw=True, namespace=namespace)
3303 self.ui.debug(b'listing keys for "%s"\n' % namespace)
3303 self.ui.debug(b'listing keys for "%s"\n' % namespace)
3304 values = pushkey.list(self, namespace)
3304 values = pushkey.list(self, namespace)
3305 self.hook(b'listkeys', namespace=namespace, values=values)
3305 self.hook(b'listkeys', namespace=namespace, values=values)
3306 return values
3306 return values
3307
3307
3308 def debugwireargs(self, one, two, three=None, four=None, five=None):
3308 def debugwireargs(self, one, two, three=None, four=None, five=None):
3309 '''used to test argument passing over the wire'''
3309 '''used to test argument passing over the wire'''
3310 return b"%s %s %s %s %s" % (
3310 return b"%s %s %s %s %s" % (
3311 one,
3311 one,
3312 two,
3312 two,
3313 pycompat.bytestr(three),
3313 pycompat.bytestr(three),
3314 pycompat.bytestr(four),
3314 pycompat.bytestr(four),
3315 pycompat.bytestr(five),
3315 pycompat.bytestr(five),
3316 )
3316 )
3317
3317
3318 def savecommitmessage(self, text):
3318 def savecommitmessage(self, text):
3319 fp = self.vfs(b'last-message.txt', b'wb')
3319 fp = self.vfs(b'last-message.txt', b'wb')
3320 try:
3320 try:
3321 fp.write(text)
3321 fp.write(text)
3322 finally:
3322 finally:
3323 fp.close()
3323 fp.close()
3324 return self.pathto(fp.name[len(self.root) + 1 :])
3324 return self.pathto(fp.name[len(self.root) + 1 :])
3325
3325
3326
3326
3327 # used to avoid circular references so destructors work
3327 # used to avoid circular references so destructors work
3328 def aftertrans(files):
3328 def aftertrans(files):
3329 renamefiles = [tuple(t) for t in files]
3329 renamefiles = [tuple(t) for t in files]
3330
3330
3331 def a():
3331 def a():
3332 for vfs, src, dest in renamefiles:
3332 for vfs, src, dest in renamefiles:
3333 # if src and dest refer to a same file, vfs.rename is a no-op,
3333 # if src and dest refer to a same file, vfs.rename is a no-op,
3334 # leaving both src and dest on disk. delete dest to make sure
3334 # leaving both src and dest on disk. delete dest to make sure
3335 # the rename couldn't be such a no-op.
3335 # the rename couldn't be such a no-op.
3336 vfs.tryunlink(dest)
3336 vfs.tryunlink(dest)
3337 try:
3337 try:
3338 vfs.rename(src, dest)
3338 vfs.rename(src, dest)
3339 except OSError: # journal file does not yet exist
3339 except OSError: # journal file does not yet exist
3340 pass
3340 pass
3341
3341
3342 return a
3342 return a
3343
3343
3344
3344
3345 def undoname(fn):
3345 def undoname(fn):
3346 base, name = os.path.split(fn)
3346 base, name = os.path.split(fn)
3347 assert name.startswith(b'journal')
3347 assert name.startswith(b'journal')
3348 return os.path.join(base, name.replace(b'journal', b'undo', 1))
3348 return os.path.join(base, name.replace(b'journal', b'undo', 1))
3349
3349
3350
3350
3351 def instance(ui, path, create, intents=None, createopts=None):
3351 def instance(ui, path, create, intents=None, createopts=None):
3352 localpath = util.urllocalpath(path)
3352 localpath = util.urllocalpath(path)
3353 if create:
3353 if create:
3354 createrepository(ui, localpath, createopts=createopts)
3354 createrepository(ui, localpath, createopts=createopts)
3355
3355
3356 return makelocalrepository(ui, localpath, intents=intents)
3356 return makelocalrepository(ui, localpath, intents=intents)
3357
3357
3358
3358
3359 def islocal(path):
3359 def islocal(path):
3360 return True
3360 return True
3361
3361
3362
3362
3363 def defaultcreateopts(ui, createopts=None):
3363 def defaultcreateopts(ui, createopts=None):
3364 """Populate the default creation options for a repository.
3364 """Populate the default creation options for a repository.
3365
3365
3366 A dictionary of explicitly requested creation options can be passed
3366 A dictionary of explicitly requested creation options can be passed
3367 in. Missing keys will be populated.
3367 in. Missing keys will be populated.
3368 """
3368 """
3369 createopts = dict(createopts or {})
3369 createopts = dict(createopts or {})
3370
3370
3371 if b'backend' not in createopts:
3371 if b'backend' not in createopts:
3372 # experimental config: storage.new-repo-backend
3372 # experimental config: storage.new-repo-backend
3373 createopts[b'backend'] = ui.config(b'storage', b'new-repo-backend')
3373 createopts[b'backend'] = ui.config(b'storage', b'new-repo-backend')
3374
3374
3375 return createopts
3375 return createopts
3376
3376
3377
3377
3378 def newreporequirements(ui, createopts):
3378 def newreporequirements(ui, createopts):
3379 """Determine the set of requirements for a new local repository.
3379 """Determine the set of requirements for a new local repository.
3380
3380
3381 Extensions can wrap this function to specify custom requirements for
3381 Extensions can wrap this function to specify custom requirements for
3382 new repositories.
3382 new repositories.
3383 """
3383 """
3384 # If the repo is being created from a shared repository, we copy
3384 # If the repo is being created from a shared repository, we copy
3385 # its requirements.
3385 # its requirements.
3386 if b'sharedrepo' in createopts:
3386 if b'sharedrepo' in createopts:
3387 requirements = set(createopts[b'sharedrepo'].requirements)
3387 requirements = set(createopts[b'sharedrepo'].requirements)
3388 if createopts.get(b'sharedrelative'):
3388 if createopts.get(b'sharedrelative'):
3389 requirements.add(requirementsmod.RELATIVE_SHARED_REQUIREMENT)
3389 requirements.add(requirementsmod.RELATIVE_SHARED_REQUIREMENT)
3390 else:
3390 else:
3391 requirements.add(requirementsmod.SHARED_REQUIREMENT)
3391 requirements.add(requirementsmod.SHARED_REQUIREMENT)
3392
3392
3393 return requirements
3393 return requirements
3394
3394
3395 if b'backend' not in createopts:
3395 if b'backend' not in createopts:
3396 raise error.ProgrammingError(
3396 raise error.ProgrammingError(
3397 b'backend key not present in createopts; '
3397 b'backend key not present in createopts; '
3398 b'was defaultcreateopts() called?'
3398 b'was defaultcreateopts() called?'
3399 )
3399 )
3400
3400
3401 if createopts[b'backend'] != b'revlogv1':
3401 if createopts[b'backend'] != b'revlogv1':
3402 raise error.Abort(
3402 raise error.Abort(
3403 _(
3403 _(
3404 b'unable to determine repository requirements for '
3404 b'unable to determine repository requirements for '
3405 b'storage backend: %s'
3405 b'storage backend: %s'
3406 )
3406 )
3407 % createopts[b'backend']
3407 % createopts[b'backend']
3408 )
3408 )
3409
3409
3410 requirements = {b'revlogv1'}
3410 requirements = {b'revlogv1'}
3411 if ui.configbool(b'format', b'usestore'):
3411 if ui.configbool(b'format', b'usestore'):
3412 requirements.add(b'store')
3412 requirements.add(b'store')
3413 if ui.configbool(b'format', b'usefncache'):
3413 if ui.configbool(b'format', b'usefncache'):
3414 requirements.add(b'fncache')
3414 requirements.add(b'fncache')
3415 if ui.configbool(b'format', b'dotencode'):
3415 if ui.configbool(b'format', b'dotencode'):
3416 requirements.add(b'dotencode')
3416 requirements.add(b'dotencode')
3417
3417
3418 compengines = ui.configlist(b'format', b'revlog-compression')
3418 compengines = ui.configlist(b'format', b'revlog-compression')
3419 for compengine in compengines:
3419 for compengine in compengines:
3420 if compengine in util.compengines:
3420 if compengine in util.compengines:
3421 break
3421 break
3422 else:
3422 else:
3423 raise error.Abort(
3423 raise error.Abort(
3424 _(
3424 _(
3425 b'compression engines %s defined by '
3425 b'compression engines %s defined by '
3426 b'format.revlog-compression not available'
3426 b'format.revlog-compression not available'
3427 )
3427 )
3428 % b', '.join(b'"%s"' % e for e in compengines),
3428 % b', '.join(b'"%s"' % e for e in compengines),
3429 hint=_(
3429 hint=_(
3430 b'run "hg debuginstall" to list available '
3430 b'run "hg debuginstall" to list available '
3431 b'compression engines'
3431 b'compression engines'
3432 ),
3432 ),
3433 )
3433 )
3434
3434
3435 # zlib is the historical default and doesn't need an explicit requirement.
3435 # zlib is the historical default and doesn't need an explicit requirement.
3436 if compengine == b'zstd':
3436 if compengine == b'zstd':
3437 requirements.add(b'revlog-compression-zstd')
3437 requirements.add(b'revlog-compression-zstd')
3438 elif compengine != b'zlib':
3438 elif compengine != b'zlib':
3439 requirements.add(b'exp-compression-%s' % compengine)
3439 requirements.add(b'exp-compression-%s' % compengine)
3440
3440
3441 if scmutil.gdinitconfig(ui):
3441 if scmutil.gdinitconfig(ui):
3442 requirements.add(b'generaldelta')
3442 requirements.add(b'generaldelta')
3443 if ui.configbool(b'format', b'sparse-revlog'):
3443 if ui.configbool(b'format', b'sparse-revlog'):
3444 requirements.add(requirementsmod.SPARSEREVLOG_REQUIREMENT)
3444 requirements.add(requirementsmod.SPARSEREVLOG_REQUIREMENT)
3445
3445
3446 # experimental config: format.exp-use-side-data
3446 # experimental config: format.exp-use-side-data
3447 if ui.configbool(b'format', b'exp-use-side-data'):
3447 if ui.configbool(b'format', b'exp-use-side-data'):
3448 requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
3448 requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
3449 # experimental config: format.exp-use-copies-side-data-changeset
3449 # experimental config: format.exp-use-copies-side-data-changeset
3450 if ui.configbool(b'format', b'exp-use-copies-side-data-changeset'):
3450 if ui.configbool(b'format', b'exp-use-copies-side-data-changeset'):
3451 requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
3451 requirements.add(requirementsmod.SIDEDATA_REQUIREMENT)
3452 requirements.add(requirementsmod.COPIESSDC_REQUIREMENT)
3452 requirements.add(requirementsmod.COPIESSDC_REQUIREMENT)
3453 if ui.configbool(b'experimental', b'treemanifest'):
3453 if ui.configbool(b'experimental', b'treemanifest'):
3454 requirements.add(requirementsmod.TREEMANIFEST_REQUIREMENT)
3454 requirements.add(requirementsmod.TREEMANIFEST_REQUIREMENT)
3455
3455
3456 revlogv2 = ui.config(b'experimental', b'revlogv2')
3456 revlogv2 = ui.config(b'experimental', b'revlogv2')
3457 if revlogv2 == b'enable-unstable-format-and-corrupt-my-data':
3457 if revlogv2 == b'enable-unstable-format-and-corrupt-my-data':
3458 requirements.remove(b'revlogv1')
3458 requirements.remove(b'revlogv1')
3459 # generaldelta is implied by revlogv2.
3459 # generaldelta is implied by revlogv2.
3460 requirements.discard(b'generaldelta')
3460 requirements.discard(b'generaldelta')
3461 requirements.add(requirementsmod.REVLOGV2_REQUIREMENT)
3461 requirements.add(requirementsmod.REVLOGV2_REQUIREMENT)
3462 # experimental config: format.internal-phase
3462 # experimental config: format.internal-phase
3463 if ui.configbool(b'format', b'internal-phase'):
3463 if ui.configbool(b'format', b'internal-phase'):
3464 requirements.add(requirementsmod.INTERNAL_PHASE_REQUIREMENT)
3464 requirements.add(requirementsmod.INTERNAL_PHASE_REQUIREMENT)
3465
3465
3466 if createopts.get(b'narrowfiles'):
3466 if createopts.get(b'narrowfiles'):
3467 requirements.add(requirementsmod.NARROW_REQUIREMENT)
3467 requirements.add(requirementsmod.NARROW_REQUIREMENT)
3468
3468
3469 if createopts.get(b'lfs'):
3469 if createopts.get(b'lfs'):
3470 requirements.add(b'lfs')
3470 requirements.add(b'lfs')
3471
3471
3472 if ui.configbool(b'format', b'bookmarks-in-store'):
3472 if ui.configbool(b'format', b'bookmarks-in-store'):
3473 requirements.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
3473 requirements.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
3474
3474
3475 if ui.configbool(b'format', b'use-persistent-nodemap'):
3475 if ui.configbool(b'format', b'use-persistent-nodemap'):
3476 requirements.add(requirementsmod.NODEMAP_REQUIREMENT)
3476 requirements.add(requirementsmod.NODEMAP_REQUIREMENT)
3477
3477
3478 # if share-safe is enabled, let's create the new repository with the new
3478 # if share-safe is enabled, let's create the new repository with the new
3479 # requirement
3479 # requirement
3480 if ui.configbool(b'format', b'use-share-safe'):
3480 if ui.configbool(b'format', b'use-share-safe'):
3481 requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)
3481 requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)
3482
3482
3483 return requirements
3483 return requirements
3484
3484
3485
3485
3486 def checkrequirementscompat(ui, requirements):
3486 def checkrequirementscompat(ui, requirements):
3487 """Checks compatibility of repository requirements enabled and disabled.
3487 """Checks compatibility of repository requirements enabled and disabled.
3488
3488
3489 Returns a set of requirements which needs to be dropped because dependend
3489 Returns a set of requirements which needs to be dropped because dependend
3490 requirements are not enabled. Also warns users about it"""
3490 requirements are not enabled. Also warns users about it"""
3491
3491
3492 dropped = set()
3492 dropped = set()
3493
3493
3494 if b'store' not in requirements:
3494 if b'store' not in requirements:
3495 if bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT in requirements:
3495 if bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT in requirements:
3496 ui.warn(
3496 ui.warn(
3497 _(
3497 _(
3498 b'ignoring enabled \'format.bookmarks-in-store\' config '
3498 b'ignoring enabled \'format.bookmarks-in-store\' config '
3499 b'beacuse it is incompatible with disabled '
3499 b'beacuse it is incompatible with disabled '
3500 b'\'format.usestore\' config\n'
3500 b'\'format.usestore\' config\n'
3501 )
3501 )
3502 )
3502 )
3503 dropped.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
3503 dropped.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
3504
3504
3505 if (
3505 if (
3506 requirementsmod.SHARED_REQUIREMENT in requirements
3506 requirementsmod.SHARED_REQUIREMENT in requirements
3507 or requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements
3507 or requirementsmod.RELATIVE_SHARED_REQUIREMENT in requirements
3508 ):
3508 ):
3509 raise error.Abort(
3509 raise error.Abort(
3510 _(
3510 _(
3511 b"cannot create shared repository as source was created"
3511 b"cannot create shared repository as source was created"
3512 b" with 'format.usestore' config disabled"
3512 b" with 'format.usestore' config disabled"
3513 )
3513 )
3514 )
3514 )
3515
3515
3516 if requirementsmod.SHARESAFE_REQUIREMENT in requirements:
3516 if requirementsmod.SHARESAFE_REQUIREMENT in requirements:
3517 ui.warn(
3517 ui.warn(
3518 _(
3518 _(
3519 b"ignoring enabled 'format.use-share-safe' config because "
3519 b"ignoring enabled 'format.use-share-safe' config because "
3520 b"it is incompatible with disabled 'format.usestore'"
3520 b"it is incompatible with disabled 'format.usestore'"
3521 b" config\n"
3521 b" config\n"
3522 )
3522 )
3523 )
3523 )
3524 dropped.add(requirementsmod.SHARESAFE_REQUIREMENT)
3524 dropped.add(requirementsmod.SHARESAFE_REQUIREMENT)
3525
3525
3526 return dropped
3526 return dropped
3527
3527
3528
3528
3529 def filterknowncreateopts(ui, createopts):
3529 def filterknowncreateopts(ui, createopts):
3530 """Filters a dict of repo creation options against options that are known.
3530 """Filters a dict of repo creation options against options that are known.
3531
3531
3532 Receives a dict of repo creation options and returns a dict of those
3532 Receives a dict of repo creation options and returns a dict of those
3533 options that we don't know how to handle.
3533 options that we don't know how to handle.
3534
3534
3535 This function is called as part of repository creation. If the
3535 This function is called as part of repository creation. If the
3536 returned dict contains any items, repository creation will not
3536 returned dict contains any items, repository creation will not
3537 be allowed, as it means there was a request to create a repository
3537 be allowed, as it means there was a request to create a repository
3538 with options not recognized by loaded code.
3538 with options not recognized by loaded code.
3539
3539
3540 Extensions can wrap this function to filter out creation options
3540 Extensions can wrap this function to filter out creation options
3541 they know how to handle.
3541 they know how to handle.
3542 """
3542 """
3543 known = {
3543 known = {
3544 b'backend',
3544 b'backend',
3545 b'lfs',
3545 b'lfs',
3546 b'narrowfiles',
3546 b'narrowfiles',
3547 b'sharedrepo',
3547 b'sharedrepo',
3548 b'sharedrelative',
3548 b'sharedrelative',
3549 b'shareditems',
3549 b'shareditems',
3550 b'shallowfilestore',
3550 b'shallowfilestore',
3551 }
3551 }
3552
3552
3553 return {k: v for k, v in createopts.items() if k not in known}
3553 return {k: v for k, v in createopts.items() if k not in known}
3554
3554
3555
3555
3556 def createrepository(ui, path, createopts=None):
3556 def createrepository(ui, path, createopts=None):
3557 """Create a new repository in a vfs.
3557 """Create a new repository in a vfs.
3558
3558
3559 ``path`` path to the new repo's working directory.
3559 ``path`` path to the new repo's working directory.
3560 ``createopts`` options for the new repository.
3560 ``createopts`` options for the new repository.
3561
3561
3562 The following keys for ``createopts`` are recognized:
3562 The following keys for ``createopts`` are recognized:
3563
3563
3564 backend
3564 backend
3565 The storage backend to use.
3565 The storage backend to use.
3566 lfs
3566 lfs
3567 Repository will be created with ``lfs`` requirement. The lfs extension
3567 Repository will be created with ``lfs`` requirement. The lfs extension
3568 will automatically be loaded when the repository is accessed.
3568 will automatically be loaded when the repository is accessed.
3569 narrowfiles
3569 narrowfiles
3570 Set up repository to support narrow file storage.
3570 Set up repository to support narrow file storage.
3571 sharedrepo
3571 sharedrepo
3572 Repository object from which storage should be shared.
3572 Repository object from which storage should be shared.
3573 sharedrelative
3573 sharedrelative
3574 Boolean indicating if the path to the shared repo should be
3574 Boolean indicating if the path to the shared repo should be
3575 stored as relative. By default, the pointer to the "parent" repo
3575 stored as relative. By default, the pointer to the "parent" repo
3576 is stored as an absolute path.
3576 is stored as an absolute path.
3577 shareditems
3577 shareditems
3578 Set of items to share to the new repository (in addition to storage).
3578 Set of items to share to the new repository (in addition to storage).
3579 shallowfilestore
3579 shallowfilestore
3580 Indicates that storage for files should be shallow (not all ancestor
3580 Indicates that storage for files should be shallow (not all ancestor
3581 revisions are known).
3581 revisions are known).
3582 """
3582 """
3583 createopts = defaultcreateopts(ui, createopts=createopts)
3583 createopts = defaultcreateopts(ui, createopts=createopts)
3584
3584
3585 unknownopts = filterknowncreateopts(ui, createopts)
3585 unknownopts = filterknowncreateopts(ui, createopts)
3586
3586
3587 if not isinstance(unknownopts, dict):
3587 if not isinstance(unknownopts, dict):
3588 raise error.ProgrammingError(
3588 raise error.ProgrammingError(
3589 b'filterknowncreateopts() did not return a dict'
3589 b'filterknowncreateopts() did not return a dict'
3590 )
3590 )
3591
3591
3592 if unknownopts:
3592 if unknownopts:
3593 raise error.Abort(
3593 raise error.Abort(
3594 _(
3594 _(
3595 b'unable to create repository because of unknown '
3595 b'unable to create repository because of unknown '
3596 b'creation option: %s'
3596 b'creation option: %s'
3597 )
3597 )
3598 % b', '.join(sorted(unknownopts)),
3598 % b', '.join(sorted(unknownopts)),
3599 hint=_(b'is a required extension not loaded?'),
3599 hint=_(b'is a required extension not loaded?'),
3600 )
3600 )
3601
3601
3602 requirements = newreporequirements(ui, createopts=createopts)
3602 requirements = newreporequirements(ui, createopts=createopts)
3603 requirements -= checkrequirementscompat(ui, requirements)
3603 requirements -= checkrequirementscompat(ui, requirements)
3604
3604
3605 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
3605 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
3606
3606
3607 hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
3607 hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
3608 if hgvfs.exists():
3608 if hgvfs.exists():
3609 raise error.RepoError(_(b'repository %s already exists') % path)
3609 raise error.RepoError(_(b'repository %s already exists') % path)
3610
3610
3611 if b'sharedrepo' in createopts:
3611 if b'sharedrepo' in createopts:
3612 sharedpath = createopts[b'sharedrepo'].sharedpath
3612 sharedpath = createopts[b'sharedrepo'].sharedpath
3613
3613
3614 if createopts.get(b'sharedrelative'):
3614 if createopts.get(b'sharedrelative'):
3615 try:
3615 try:
3616 sharedpath = os.path.relpath(sharedpath, hgvfs.base)
3616 sharedpath = os.path.relpath(sharedpath, hgvfs.base)
3617 except (IOError, ValueError) as e:
3617 except (IOError, ValueError) as e:
3618 # ValueError is raised on Windows if the drive letters differ
3618 # ValueError is raised on Windows if the drive letters differ
3619 # on each path.
3619 # on each path.
3620 raise error.Abort(
3620 raise error.Abort(
3621 _(b'cannot calculate relative path'),
3621 _(b'cannot calculate relative path'),
3622 hint=stringutil.forcebytestr(e),
3622 hint=stringutil.forcebytestr(e),
3623 )
3623 )
3624
3624
3625 if not wdirvfs.exists():
3625 if not wdirvfs.exists():
3626 wdirvfs.makedirs()
3626 wdirvfs.makedirs()
3627
3627
3628 hgvfs.makedir(notindexed=True)
3628 hgvfs.makedir(notindexed=True)
3629 if b'sharedrepo' not in createopts:
3629 if b'sharedrepo' not in createopts:
3630 hgvfs.mkdir(b'cache')
3630 hgvfs.mkdir(b'cache')
3631 hgvfs.mkdir(b'wcache')
3631 hgvfs.mkdir(b'wcache')
3632
3632
3633 if b'store' in requirements and b'sharedrepo' not in createopts:
3633 if b'store' in requirements and b'sharedrepo' not in createopts:
3634 hgvfs.mkdir(b'store')
3634 hgvfs.mkdir(b'store')
3635
3635
3636 # We create an invalid changelog outside the store so very old
3636 # We create an invalid changelog outside the store so very old
3637 # Mercurial versions (which didn't know about the requirements
3637 # Mercurial versions (which didn't know about the requirements
3638 # file) encounter an error on reading the changelog. This
3638 # file) encounter an error on reading the changelog. This
3639 # effectively locks out old clients and prevents them from
3639 # effectively locks out old clients and prevents them from
3640 # mucking with a repo in an unknown format.
3640 # mucking with a repo in an unknown format.
3641 #
3641 #
3642 # The revlog header has version 2, which won't be recognized by
3642 # The revlog header has version 65535, which won't be recognized by
3643 # such old clients.
3643 # such old clients.
3644 hgvfs.append(
3644 hgvfs.append(
3645 b'00changelog.i',
3645 b'00changelog.i',
3646 b'\0\0\0\2 dummy changelog to prevent using the old repo '
3646 b'\0\0\xFF\xFF dummy changelog to prevent using the old repo '
3647 b'layout',
3647 b'layout',
3648 )
3648 )
3649
3649
3650 # Filter the requirements into working copy and store ones
3650 # Filter the requirements into working copy and store ones
3651 wcreq, storereq = scmutil.filterrequirements(requirements)
3651 wcreq, storereq = scmutil.filterrequirements(requirements)
3652 # write working copy ones
3652 # write working copy ones
3653 scmutil.writerequires(hgvfs, wcreq)
3653 scmutil.writerequires(hgvfs, wcreq)
3654 # If there are store requirements and the current repository
3654 # If there are store requirements and the current repository
3655 # is not a shared one, write stored requirements
3655 # is not a shared one, write stored requirements
3656 # For new shared repository, we don't need to write the store
3656 # For new shared repository, we don't need to write the store
3657 # requirements as they are already present in store requires
3657 # requirements as they are already present in store requires
3658 if storereq and b'sharedrepo' not in createopts:
3658 if storereq and b'sharedrepo' not in createopts:
3659 storevfs = vfsmod.vfs(hgvfs.join(b'store'), cacheaudited=True)
3659 storevfs = vfsmod.vfs(hgvfs.join(b'store'), cacheaudited=True)
3660 scmutil.writerequires(storevfs, storereq)
3660 scmutil.writerequires(storevfs, storereq)
3661
3661
3662 # Write out file telling readers where to find the shared store.
3662 # Write out file telling readers where to find the shared store.
3663 if b'sharedrepo' in createopts:
3663 if b'sharedrepo' in createopts:
3664 hgvfs.write(b'sharedpath', sharedpath)
3664 hgvfs.write(b'sharedpath', sharedpath)
3665
3665
3666 if createopts.get(b'shareditems'):
3666 if createopts.get(b'shareditems'):
3667 shared = b'\n'.join(sorted(createopts[b'shareditems'])) + b'\n'
3667 shared = b'\n'.join(sorted(createopts[b'shareditems'])) + b'\n'
3668 hgvfs.write(b'shared', shared)
3668 hgvfs.write(b'shared', shared)
3669
3669
3670
3670
3671 def poisonrepository(repo):
3671 def poisonrepository(repo):
3672 """Poison a repository instance so it can no longer be used."""
3672 """Poison a repository instance so it can no longer be used."""
3673 # Perform any cleanup on the instance.
3673 # Perform any cleanup on the instance.
3674 repo.close()
3674 repo.close()
3675
3675
3676 # Our strategy is to replace the type of the object with one that
3676 # Our strategy is to replace the type of the object with one that
3677 # has all attribute lookups result in error.
3677 # has all attribute lookups result in error.
3678 #
3678 #
3679 # But we have to allow the close() method because some constructors
3679 # But we have to allow the close() method because some constructors
3680 # of repos call close() on repo references.
3680 # of repos call close() on repo references.
3681 class poisonedrepository(object):
3681 class poisonedrepository(object):
3682 def __getattribute__(self, item):
3682 def __getattribute__(self, item):
3683 if item == 'close':
3683 if item == 'close':
3684 return object.__getattribute__(self, item)
3684 return object.__getattribute__(self, item)
3685
3685
3686 raise error.ProgrammingError(
3686 raise error.ProgrammingError(
3687 b'repo instances should not be used after unshare'
3687 b'repo instances should not be used after unshare'
3688 )
3688 )
3689
3689
3690 def close(self):
3690 def close(self):
3691 pass
3691 pass
3692
3692
3693 # We may have a repoview, which intercepts __setattr__. So be sure
3693 # We may have a repoview, which intercepts __setattr__. So be sure
3694 # we operate at the lowest level possible.
3694 # we operate at the lowest level possible.
3695 object.__setattr__(repo, '__class__', poisonedrepository)
3695 object.__setattr__(repo, '__class__', poisonedrepository)
@@ -1,81 +1,81 b''
1 $ hg init t
1 $ hg init t
2 $ cd t
2 $ cd t
3 $ echo a > a
3 $ echo a > a
4 $ hg add a
4 $ hg add a
5 $ hg commit -m test
5 $ hg commit -m test
6 $ rm .hg/requires
6 $ rm .hg/requires
7 $ hg tip
7 $ hg tip
8 abort: unknown version (2) in revlog 00changelog.i
8 abort: unknown version (65535) in revlog 00changelog.i
9 [50]
9 [50]
10 $ echo indoor-pool > .hg/requires
10 $ echo indoor-pool > .hg/requires
11 $ hg tip
11 $ hg tip
12 abort: repository requires features unknown to this Mercurial: indoor-pool
12 abort: repository requires features unknown to this Mercurial: indoor-pool
13 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
13 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
14 [255]
14 [255]
15 $ echo outdoor-pool >> .hg/requires
15 $ echo outdoor-pool >> .hg/requires
16 $ hg tip
16 $ hg tip
17 abort: repository requires features unknown to this Mercurial: indoor-pool outdoor-pool
17 abort: repository requires features unknown to this Mercurial: indoor-pool outdoor-pool
18 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
18 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
19 [255]
19 [255]
20 $ cd ..
20 $ cd ..
21
21
22 Test checking between features supported locally and ones required in
22 Test checking between features supported locally and ones required in
23 another repository of push/pull/clone on localhost:
23 another repository of push/pull/clone on localhost:
24
24
25 $ mkdir supported-locally
25 $ mkdir supported-locally
26 $ cd supported-locally
26 $ cd supported-locally
27
27
28 $ hg init supported
28 $ hg init supported
29 $ echo a > supported/a
29 $ echo a > supported/a
30 $ hg -R supported commit -Am '#0 at supported'
30 $ hg -R supported commit -Am '#0 at supported'
31 adding a
31 adding a
32
32
33 $ echo 'featuresetup-test' >> supported/.hg/requires
33 $ echo 'featuresetup-test' >> supported/.hg/requires
34 $ cat > $TESTTMP/supported-locally/supportlocally.py <<EOF
34 $ cat > $TESTTMP/supported-locally/supportlocally.py <<EOF
35 > from __future__ import absolute_import
35 > from __future__ import absolute_import
36 > from mercurial import extensions, localrepo
36 > from mercurial import extensions, localrepo
37 > def featuresetup(ui, supported):
37 > def featuresetup(ui, supported):
38 > for name, module in extensions.extensions(ui):
38 > for name, module in extensions.extensions(ui):
39 > if __name__ == module.__name__:
39 > if __name__ == module.__name__:
40 > # support specific feature locally
40 > # support specific feature locally
41 > supported |= {b'featuresetup-test'}
41 > supported |= {b'featuresetup-test'}
42 > return
42 > return
43 > def uisetup(ui):
43 > def uisetup(ui):
44 > localrepo.featuresetupfuncs.add(featuresetup)
44 > localrepo.featuresetupfuncs.add(featuresetup)
45 > EOF
45 > EOF
46 $ cat > supported/.hg/hgrc <<EOF
46 $ cat > supported/.hg/hgrc <<EOF
47 > [extensions]
47 > [extensions]
48 > # enable extension locally
48 > # enable extension locally
49 > supportlocally = $TESTTMP/supported-locally/supportlocally.py
49 > supportlocally = $TESTTMP/supported-locally/supportlocally.py
50 > EOF
50 > EOF
51 $ hg -R supported debugrequirements
51 $ hg -R supported debugrequirements
52 dotencode
52 dotencode
53 featuresetup-test
53 featuresetup-test
54 fncache
54 fncache
55 generaldelta
55 generaldelta
56 revlogv1
56 revlogv1
57 sparserevlog
57 sparserevlog
58 store
58 store
59 $ hg -R supported status
59 $ hg -R supported status
60
60
61 $ hg init push-dst
61 $ hg init push-dst
62 $ hg -R supported push push-dst
62 $ hg -R supported push push-dst
63 pushing to push-dst
63 pushing to push-dst
64 abort: required features are not supported in the destination: featuresetup-test
64 abort: required features are not supported in the destination: featuresetup-test
65 [255]
65 [255]
66
66
67 $ hg init pull-src
67 $ hg init pull-src
68 $ hg -R pull-src pull supported
68 $ hg -R pull-src pull supported
69 pulling from supported
69 pulling from supported
70 abort: required features are not supported in the destination: featuresetup-test
70 abort: required features are not supported in the destination: featuresetup-test
71 [255]
71 [255]
72
72
73 $ hg clone supported clone-dst
73 $ hg clone supported clone-dst
74 abort: repository requires features unknown to this Mercurial: featuresetup-test
74 abort: repository requires features unknown to this Mercurial: featuresetup-test
75 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
75 (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
76 [255]
76 [255]
77 $ hg clone --pull supported clone-dst
77 $ hg clone --pull supported clone-dst
78 abort: required features are not supported in the destination: featuresetup-test
78 abort: required features are not supported in the destination: featuresetup-test
79 [255]
79 [255]
80
80
81 $ cd ..
81 $ cd ..
General Comments 0
You need to be logged in to leave comments. Login now