hgext/inhibit.py
branchmercurial-3.6
changeset 1819 642f86363883
parent 1818 f23df9d65565
parent 1798 acfc610ec304
child 1820 056c8052884d
child 2105 d4e7d8392cfa
equal deleted inserted replaced
1818:f23df9d65565 1819:642f86363883
     1 """reduce the changesets evolution feature scope for early and noob friendly ui
       
     2 
       
     3 the full scale changeset evolution have some massive bleeding edge and it is
       
     4 very easy for people not very intimate with the concept to end up in intricate
       
     5 situation. in order to get some of the benefit sooner, this extension is
       
     6 disabling some of the less polished aspect of evolution. it should gradually
       
     7 get thinner and thinner as changeset evolution will get more polished. this
       
     8 extension is only recommended for large scale organisations. individual user
       
     9 should probably stick on using evolution in its current state, understand its
       
    10 concept and provide feedback
       
    11 
       
    12 This extension provides the ability to "inhibit" obsolescence markers. obsolete
       
    13 revision can be cheaply brought back to life that way.
       
    14 However as the inhibitor are not fitting in an append only model, this is
       
    15 incompatible with sharing mutable history.
       
    16 """
       
    17 from mercurial import localrepo
       
    18 from mercurial import obsolete
       
    19 from mercurial import extensions
       
    20 from mercurial import cmdutil
       
    21 from mercurial import error
       
    22 from mercurial import scmutil
       
    23 from mercurial import commands
       
    24 from mercurial import lock as lockmod
       
    25 from mercurial import bookmarks
       
    26 from mercurial import util
       
    27 from mercurial.i18n import _
       
    28 
       
    29 cmdtable = {}
       
    30 command = cmdutil.command(cmdtable)
       
    31 
       
    32 def _inhibitenabled(repo):
       
    33     return util.safehasattr(repo, '_obsinhibit')
       
    34 
       
    35 def reposetup(ui, repo):
       
    36 
       
    37     class obsinhibitedrepo(repo.__class__):
       
    38 
       
    39         @localrepo.storecache('obsinhibit')
       
    40         def _obsinhibit(self):
       
    41             # XXX we should make sure it is invalidated by transaction failure
       
    42             obsinhibit = set()
       
    43             raw = self.svfs.tryread('obsinhibit')
       
    44             for i in xrange(0, len(raw), 20):
       
    45                 obsinhibit.add(raw[i:i + 20])
       
    46             return obsinhibit
       
    47 
       
    48         def commit(self, *args, **kwargs):
       
    49             newnode = super(obsinhibitedrepo, self).commit(*args, **kwargs)
       
    50             if newnode is not None:
       
    51                 _inhibitmarkers(repo, [newnode])
       
    52             return newnode
       
    53 
       
    54     repo.__class__ = obsinhibitedrepo
       
    55 
       
    56 def _update(orig, ui, repo, *args, **kwargs):
       
    57     """
       
    58     When moving to a commit we want to inhibit any obsolete commit affecting
       
    59     the changeset we are updating to. In other words we don't want any visible
       
    60     commit to be obsolete.
       
    61     """
       
    62     wlock = None
       
    63     try:
       
    64         # Evolve is running a hook on lock release to display a warning message
       
    65         # if the workind dir's parent is obsolete.
       
    66         # We take the lock here to make sure that we inhibit the parent before
       
    67         # that hook get a chance to run.
       
    68         wlock = repo.wlock()
       
    69         res = orig(ui, repo, *args, **kwargs)
       
    70         newhead = repo['.'].node()
       
    71         _inhibitmarkers(repo, [newhead])
       
    72         return res
       
    73     finally:
       
    74         lockmod.release(wlock)
       
    75 
       
    76 def _bookmarkchanged(orig, bkmstoreinst, *args, **kwargs):
       
    77     """ Add inhibition markers to every obsolete bookmarks """
       
    78     repo = bkmstoreinst._repo
       
    79     bkmstorenodes = [repo[v].node() for v in bkmstoreinst.values()]
       
    80     _inhibitmarkers(repo, bkmstorenodes)
       
    81     return orig(bkmstoreinst, *args, **kwargs)
       
    82 
       
    83 def _bookmark(orig, ui, repo, *bookmarks, **opts):
       
    84     """ Add a -D option to the bookmark command, map it to prune -B """
       
    85     haspruneopt = opts.get('prune', False)
       
    86     if not haspruneopt:
       
    87         return orig(ui, repo, *bookmarks, **opts)
       
    88     elif opts.get('rename'):
       
    89         raise error.Abort('Cannot use both -m and -D')
       
    90     elif len(bookmarks) == 0:
       
    91         hint = _('make sure to put a space between -D and your bookmark name')
       
    92         raise error.Abort(_('Error, please check your command'), hint=hint)
       
    93 
       
    94     # Call prune -B
       
    95     evolve = extensions.find('evolve')
       
    96     optsdict = {
       
    97         'new': [],
       
    98         'succ': [],
       
    99         'rev': [],
       
   100         'bookmark': bookmarks,
       
   101         'keep': None,
       
   102         'biject': False,
       
   103     }
       
   104     evolve.cmdprune(ui, repo, **optsdict)
       
   105 
       
   106 # obsolescence inhibitor
       
   107 ########################
       
   108 
       
   109 def _schedulewrite(tr, obsinhibit):
       
   110     """Make sure on disk content will be updated on transaction commit"""
       
   111     def writer(fp):
       
   112         """Serialize the inhibited list to disk.
       
   113         """
       
   114         raw = ''.join(obsinhibit)
       
   115         fp.write(raw)
       
   116     tr.addfilegenerator('obsinhibit', ('obsinhibit',), writer)
       
   117     tr.hookargs['obs_inbihited'] = '1'
       
   118 
       
   119 def _filterpublic(repo, nodes):
       
   120     """filter out inhibitor on public changeset
       
   121 
       
   122     Public changesets are already immune to obsolescence"""
       
   123     getrev = repo.changelog.nodemap.get
       
   124     getphase = repo._phasecache.phase
       
   125     return (n for n in nodes
       
   126             if getrev(n) is not None and getphase(repo, getrev(n)))
       
   127 
       
   128 def _inhibitmarkers(repo, nodes):
       
   129     """add marker inhibitor for all obsolete revision under <nodes>
       
   130 
       
   131     Content of <nodes> and all mutable ancestors are considered. Marker for
       
   132     obsolete revision only are created.
       
   133     """
       
   134     if not _inhibitenabled(repo):
       
   135         return
       
   136 
       
   137     # we add (non public()) as a lower boundary to
       
   138     # - use the C code in 3.6 (no ancestors in C as this is written)
       
   139     # - restrict the search space. Otherwise, the ancestors can spend a lot of
       
   140     #   time iterating if you have a check very low in the repo. We do not need
       
   141     #   to iterate over tens of thousand of public revisions with higher
       
   142     #   revision number
       
   143     #
       
   144     # In addition, the revset logic could be made significantly smarter here.
       
   145     newinhibit = repo.revs('(not public())::%ln and obsolete()', nodes)
       
   146     if newinhibit:
       
   147         node = repo.changelog.node
       
   148         lock = tr = None
       
   149         try:
       
   150             lock = repo.lock()
       
   151             tr = repo.transaction('obsinhibit')
       
   152             repo._obsinhibit.update(node(r) for r in newinhibit)
       
   153             _schedulewrite(tr, _filterpublic(repo, repo._obsinhibit))
       
   154             repo.invalidatevolatilesets()
       
   155             tr.close()
       
   156         finally:
       
   157             lockmod.release(tr, lock)
       
   158 
       
   159 def _deinhibitmarkers(repo, nodes):
       
   160     """lift obsolescence inhibition on a set of nodes
       
   161 
       
   162     This will be triggered when inhibited nodes received new obsolescence
       
   163     markers. Otherwise the new obsolescence markers would also be inhibited.
       
   164     """
       
   165     if not _inhibitenabled(repo):
       
   166         return
       
   167 
       
   168     deinhibited = repo._obsinhibit & set(nodes)
       
   169     if deinhibited:
       
   170         tr = repo.transaction('obsinhibit')
       
   171         try:
       
   172             repo._obsinhibit -= deinhibited
       
   173             _schedulewrite(tr, _filterpublic(repo, repo._obsinhibit))
       
   174             repo.invalidatevolatilesets()
       
   175             tr.close()
       
   176         finally:
       
   177             tr.release()
       
   178 
       
   179 def _createmarkers(orig, repo, relations, flag=0, date=None, metadata=None):
       
   180     """wrap markers create to make sure we de-inhibit target nodes"""
       
   181     # wrapping transactio to unify the one in each function
       
   182     lock = tr = None
       
   183     try:
       
   184         lock = repo.lock()
       
   185         tr = repo.transaction('add-obsolescence-marker')
       
   186         orig(repo, relations, flag, date, metadata)
       
   187         precs = (r[0].node() for r in relations)
       
   188         _deinhibitmarkers(repo, precs)
       
   189         tr.close()
       
   190     finally:
       
   191         lockmod.release(tr, lock)
       
   192 
       
   193 def _filterobsoleterevswrap(orig, repo, rebasesetrevs, *args, **kwargs):
       
   194     repo._notinhibited = rebasesetrevs
       
   195     try:
       
   196         repo.invalidatevolatilesets()
       
   197         r = orig(repo, rebasesetrevs, *args, **kwargs)
       
   198     finally:
       
   199         del repo._notinhibited
       
   200         repo.invalidatevolatilesets()
       
   201     return r
       
   202 
       
   203 def transactioncallback(orig, repo, desc, *args, **kwargs):
       
   204     """ Wrap localrepo.transaction to inhibit new obsolete changes """
       
   205     def inhibitposttransaction(transaction):
       
   206         # At the end of the transaction we catch all the new visible and
       
   207         # obsolete commit to inhibit them
       
   208         visibleobsolete = repo.revs('obsolete() - hidden()')
       
   209         ignoreset = set(getattr(repo, '_rebaseset', []))
       
   210         ignoreset |= set(getattr(repo, '_obsoletenotrebased', []))
       
   211         visibleobsolete = list(r for r in visibleobsolete if r not in ignoreset)
       
   212         if visibleobsolete:
       
   213             _inhibitmarkers(repo, [repo[r].node() for r in visibleobsolete])
       
   214     transaction = orig(repo, desc, *args, **kwargs)
       
   215     if desc != 'strip' and _inhibitenabled(repo):
       
   216         transaction.addpostclose('inhibitposttransaction',
       
   217                                  inhibitposttransaction)
       
   218     return transaction
       
   219 
       
   220 
       
   221 # We wrap these two functions to address the following scenario:
       
   222 # - Assuming that we have markers between commits in the rebase set and
       
   223 #   destination and that these markers are inhibited
       
   224 # - At the end of the rebase the nodes are still visible because rebase operate
       
   225 #   without inhibition and skip these nodes
       
   226 # We keep track in repo._obsoletenotrebased of the obsolete commits skipped by
       
   227 # the rebase and lift the inhibition in the end of the rebase.
       
   228 
       
   229 def _computeobsoletenotrebased(orig, repo, *args, **kwargs):
       
   230     r = orig(repo, *args, **kwargs)
       
   231     repo._obsoletenotrebased = r.keys()
       
   232     return r
       
   233 
       
   234 def _clearrebased(orig, ui, repo, *args, **kwargs):
       
   235     r = orig(ui, repo, *args, **kwargs)
       
   236     tonode = repo.changelog.node
       
   237     if util.safehasattr(repo, '_obsoletenotrebased'):
       
   238         _deinhibitmarkers(repo, [tonode(k) for k in repo._obsoletenotrebased])
       
   239     return r
       
   240 
       
   241 
       
   242 def extsetup(ui):
       
   243     # lets wrap the computation of the obsolete set
       
   244     # We apply inhibition there
       
   245     obsfunc = obsolete.cachefuncs['obsolete']
       
   246     def _computeobsoleteset(repo):
       
   247         """remove any inhibited nodes from the obsolete set
       
   248 
       
   249         This will trickle down to other part of mercurial (hidden, log, etc)"""
       
   250         obs = obsfunc(repo)
       
   251         if _inhibitenabled(repo):
       
   252             getrev = repo.changelog.nodemap.get
       
   253             blacklist = getattr(repo, '_notinhibited', set())
       
   254             for n in repo._obsinhibit:
       
   255                 if getrev(n) not in blacklist:
       
   256                     obs.discard(getrev(n))
       
   257         return obs
       
   258     try:
       
   259         extensions.find('directaccess')
       
   260     except KeyError:
       
   261         errormsg = _('cannot use inhibit without the direct access extension\n')
       
   262         hint = _("(please enable it or inhibit won\'t work)\n")
       
   263         ui.warn(errormsg)
       
   264         ui.warn(hint)
       
   265         return
       
   266 
       
   267     # Wrapping this to inhibit obsolete revs resulting from a transaction
       
   268     extensions.wrapfunction(localrepo.localrepository,
       
   269                             'transaction', transactioncallback)
       
   270 
       
   271     obsolete.cachefuncs['obsolete'] = _computeobsoleteset
       
   272     # wrap create marker to make it able to lift the inhibition
       
   273     extensions.wrapfunction(obsolete, 'createmarkers', _createmarkers)
       
   274     # drop divergence computation since it is incompatible with "light revive"
       
   275     obsolete.cachefuncs['divergent'] = lambda repo: set()
       
   276     # drop bumped computation since it is incompatible with "light revive"
       
   277     obsolete.cachefuncs['bumped'] = lambda repo: set()
       
   278     # wrap update to make sure that no obsolete commit is visible after an
       
   279     # update
       
   280     extensions.wrapcommand(commands.table, 'update', _update)
       
   281     try:
       
   282         rebase = extensions.find('rebase')
       
   283         if rebase:
       
   284             if util.safehasattr(rebase, '_filterobsoleterevs'):
       
   285                 extensions.wrapfunction(rebase,
       
   286                                         '_filterobsoleterevs',
       
   287                                         _filterobsoleterevswrap)
       
   288             extensions.wrapfunction(rebase, 'clearrebased', _clearrebased)
       
   289             if util.safehasattr(rebase, '_computeobsoletenotrebased'):
       
   290                 extensions.wrapfunction(rebase,
       
   291                                         '_computeobsoletenotrebased',
       
   292                                         _computeobsoletenotrebased)
       
   293 
       
   294     except KeyError:
       
   295         pass
       
   296     # There are two ways to save bookmark changes during a transation, we
       
   297     # wrap both to add inhibition markers.
       
   298     extensions.wrapfunction(bookmarks.bmstore, 'recordchange', _bookmarkchanged)
       
   299     if getattr(bookmarks.bmstore, 'write', None) is not None:# mercurial < 3.9
       
   300         extensions.wrapfunction(bookmarks.bmstore, 'write', _bookmarkchanged)
       
   301     # Add bookmark -D option
       
   302     entry = extensions.wrapcommand(commands.table, 'bookmark', _bookmark)
       
   303     entry[1].append(('D','prune',None,
       
   304                     _('delete the bookmark and prune the commits underneath')))
       
   305 
       
   306 @command('debugobsinhibit', [], '')
       
   307 def cmddebugobsinhibit(ui, repo, *revs):
       
   308     """inhibit obsolescence markers effect on a set of revs"""
       
   309     nodes = (repo[r].node() for r in scmutil.revrange(repo, revs))
       
   310     _inhibitmarkers(repo, nodes)