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