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