316 #####################################################################

   316 cachefuncs = obsolete.cachefuncs

   317 ### Obsolescence Caching Logic                                    ###

   317 cachefor = obsolete.cachefor

   318 #####################################################################

   318 getobscache = obsolete.getobscache

   319 

   319 clearobscaches = obsolete.clearobscaches

   320 # IN CORE fb72eec7efd8

   321 

   322 # Obsolescence related logic can be very slow if we don't have efficient cache.

   323 #

   324 # This section implements a cache mechanism that did not make it into core for

   325 # time reason. It stores meaningful set of revisions related to obsolescence

   326 # (obsolete, unstable, etc.)

   327 #

   328 # Here is:

   329 #

   330 # - Computation of meaningful sets

   331 # - Cache access logic,

   332 # - Cache invalidation logic,

   333 # - revset and ctx using this cache.

   334 #

   335 

   336 

   337 ### Computation of meaningful set

   338 #

   339 # Most set can be computed with "simple" revset.

   340 

   341 #: { set name -> function to compute this set } mapping

   342 #:   function take a single "repo" argument.

   343 #:

   344 #: Use the `cachefor` decorator to register new cache function

   345 try:

   346     cachefuncs = obsolete.cachefuncs

   347     cachefor = obsolete.cachefor

   348     getobscache = obsolete.getobscache

   349     clearobscaches = obsolete.clearobscaches

   350 except AttributeError:

   351     cachefuncs = {}

   352 

   353     def cachefor(name):

   354         """Decorator to register a function as computing the cache for a set"""

   355         def decorator(func):

   356             assert name not in cachefuncs

   357             cachefuncs[name] = func

   358             return func

   359         return decorator

   360 

   361     @cachefor('obsolete')

   362     def _computeobsoleteset(repo):

   363         """the set of obsolete revisions"""

   364         obs = set()

   365         nm = repo.changelog.nodemap

   366         for prec in repo.obsstore.precursors:

   367             rev = nm.get(prec)

   368             if rev is not None:

   369                 obs.add(rev)

   370         return set(repo.revs('%ld - public()', obs))

   371 

   372     @cachefor('unstable')

   373     def _computeunstableset(repo):

   374         """the set of non obsolete revisions with obsolete parents"""

   375         return set(repo.revs('(obsolete()::) - obsolete()'))

   376 

   377     @cachefor('suspended')

   378     def _computesuspendedset(repo):

   379         """the set of obsolete parents with non obsolete descendants"""

   380         return set(repo.revs('obsolete() and obsolete()::unstable()'))

   381 

   382     @cachefor('extinct')

   383     def _computeextinctset(repo):

   384         """the set of obsolete parents without non obsolete descendants"""

   385         return set(repo.revs('obsolete() - obsolete()::unstable()'))

   386 

   387     @eh.wrapfunction(obsolete.obsstore, '__init__')

   388     def _initobsstorecache(orig, obsstore, *args, **kwargs):

   389         """add a cache attribute to obsstore"""

   390         obsstore.caches = {}

   391         return orig(obsstore, *args, **kwargs)

   392 

   393 ### Cache access

   394 

   395     def getobscache(repo, name):

   396         """Return the set of revision that belong to the <name> set

   397 

   398         Such access may compute the set and cache it for future use"""

   399         if not repo.obsstore:

   400             return ()

   401         if name not in repo.obsstore.caches:

   402             repo.obsstore.caches[name] = cachefuncs[name](repo)

   403         return repo.obsstore.caches[name]

   404 

   405 ### Cache clean up

   406 #

   407 # To be simple we need to invalidate obsolescence cache when:

   408 #

   409 # - new changeset is added:

   410 # - public phase is changed

   411 # - obsolescence marker are added

   412 # - strip is used a repo

   413 

   414 

   415     def clearobscaches(repo):

   416         """Remove all obsolescence related cache from a repo

   417 

   418         This remove all cache in obsstore is the obsstore already exist on the

   419         repo.

   420 

   421         (We could be smarter here)"""

   422         if 'obsstore' in repo._filecache:

   423             repo.obsstore.caches.clear()

   424 

   425     @eh.wrapfunction(localrepo.localrepository, 'addchangegroup')  # new changeset

   426     @eh.wrapfunction(phases, 'retractboundary')  # phase movement

   427     @eh.wrapfunction(phases, 'advanceboundary')  # phase movement

   428     @eh.wrapfunction(localrepo.localrepository, 'destroyed')  # strip

   429     def wrapclearcache(orig, repo, *args, **kwargs):

   430         try:

   431             return orig(repo, *args, **kwargs)

   432         finally:

   433             # we are a bit wide here

   434             # we could restrict to:

   435             # advanceboundary + phase==public

   436             # retractboundary + phase==draft

   437             clearobscaches(repo)

   438 

   439     @eh.wrapfunction(obsolete.obsstore, 'add')  # new marker

   440     def clearonadd(orig, obsstore, *args, **kwargs):

   441         try:

   442             return orig(obsstore, *args, **kwargs)

   443         finally:

   444             obsstore.caches.clear()

   445 

   446 ### Use the case

   447 # Function in core that could benefic from the cache are overwritten by cache using version

   448 

   449 # changectx method

   450 

   451     @eh.addattr(context.changectx, 'unstable')

   452     def unstable(ctx):

   453         """is the changeset unstable (have obsolete ancestor)"""

   454         if ctx.node() is None:

   455             return False

   456         return ctx.rev() in getobscache(ctx._repo, 'unstable')

   457 

   458 

   459     @eh.addattr(context.changectx, 'extinct')

   460     def extinct(ctx):

   461         """is the changeset extinct by other"""

   462         if ctx.node() is None:

   463             return False

   464         return ctx.rev() in getobscache(ctx._repo, 'extinct')

   465 

   466 # revset

   467 

   468     @eh.revset('obsolete')

   469     def revsetobsolete(repo, subset, x):

   470         """``obsolete()``

   471         Changeset is obsolete.

   472         """

   473         args = revset.getargs(x, 0, 0, 'obsolete takes no argument')

   474         obsoletes = getobscache(repo, 'obsolete')

   475         return [r for r in subset if r in obsoletes]

   476 

   477     @eh.revset('unstable')

   478     def revsetunstable(repo, subset, x):

   479         """``unstable()``

   480         Unstable changesets are non-obsolete with obsolete ancestors.

   481         """

   482         args = revset.getargs(x, 0, 0, 'unstable takes no arguments')

   483         unstables = getobscache(repo, 'unstable')

   484         return [r for r in subset if r in unstables]

   485 

   486     @eh.revset('extinct')

   487     def revsetextinct(repo, subset, x):

   488         """``extinct()``

   489         Obsolete changesets with obsolete descendants only.

   490         """

   491         args = revset.getargs(x, 0, 0, 'extinct takes no arguments')

   492         extincts = getobscache(repo, 'extinct')

   493         return [r for r in subset if r in extincts]

   653 ### Marker Create

   479 createmarkers = obsolete.createmarkers

   654 # NOW IN CORE f85816af6294

   655 try:

   656     createmarkers = obsolete.createmarkers

   657 except AttributeError:

   658     def createmarkers(repo, relations, metadata=None, flag=0):

   659         """Add obsolete markers between changeset in a repo

   660 

   661         <relations> must be an iterable of (<old>, (<new>, ...)) tuple.

   662         `old` and `news` are changectx.

   663 

   664         Current user and date are used except if specified otherwise in the

   665         metadata attribute.

   666 

   667         /!\ assume the repo have been locked by the user /!\

   668         """

   669         # prepare metadata

   670         if metadata is None:

   671             metadata = {}

   672         if 'date' not in metadata:

   673             metadata['date'] = '%i %i' % util.makedate()

   674         if 'user' not in metadata:

   675             metadata['user'] = repo.ui.username()

   676         # check future marker

   677         tr = repo.transaction('add-obsolescence-marker')

   678         try:

   679             for prec, sucs in relations:

   680                 if not prec.mutable():

   681                     raise util.Abort("cannot obsolete immutable changeset: %s" % prec)

   682                 nprec = prec.node()

   683                 nsucs = tuple(s.node() for s in sucs)

   684                 if nprec in nsucs:

   685                     raise util.Abort("changeset %s cannot obsolete himself" % prec)

   686                 repo.obsstore.create(tr, nprec, nsucs, flag, metadata)

   687                 clearobscaches(repo)

   688             tr.close()

   689         finally:

   690             tr.release()