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