contrib/lock-checker.py

demandimport: support "absolute_import" for external libraries (issue4029)

Before this patch, demandimport of Mercurial may fail to load external
libraries using "from __future__ import absolute_import": for example,
importing "foo" in "bar.baz" module will load "bar.foo" if it exists,
even though "absolute_import" is enabled in "bar.baz" module.

So, extensions for Mercurial can't use such external libraries.

This patch saves "level" of import request for on-demand module
loading in the future: default value of level is -1, and level is 0
when "absolute_import" is enabled.

"level" value is passed to built-in import function in
"_demandmod._load()" and it should load target module correctly.

This patch changes only one "_demandmod" construction case other than
cases below:

    - construction in "_demandmod._load()"

      this code path should be used only in relative sub-module
      loading case

    - constructions other than patched one in"_demandimport()"

      these code paths shouldn't be used in "level != -1" case

"""Extension to verify locks are obtained in the required places.

This works by wrapping functions that should be surrounded by a lock
and asserting the lock is held. Missing locks are called out with a
traceback printed to stderr.

This currently only checks store locks, not working copy locks.
"""
import os
import traceback

def _warnstack(ui, msg, skip=1):
    '''issue warning with the message and the current stack, skipping the
    skip last entries'''
    ui.warn('%s at:\n' % msg)
    entries = traceback.extract_stack()[:-skip]
    fnmax = max(len(entry[0]) for entry in entries)
    for fn, ln, func, _text in entries:
        ui.warn(' %*s:%-4s in %s\n' % (fnmax, fn, ln, func))

def _checklock(repo):
    l = repo._lockref and repo._lockref()
    if l is None or not l.held:
        _warnstack(repo.ui, 'missing lock', skip=2)

def reposetup(ui, repo):
    orig = repo.__class__
    class lockcheckrepo(repo.__class__):
        def _writejournal(self, *args, **kwargs):
            _checklock(self)
            return orig._writejournal(self, *args, **kwargs)

        def transaction(self, *args, **kwargs):
            _checklock(self)
            return orig.transaction(self, *args, **kwargs)

        # TODO(durin42): kiilerix had a commented-out lock check in
        # _writebranchcache and _writerequirements

        def _tag(self, *args, **kwargs):
            _checklock(self)
            return orig._tag(self, *args, **kwargs)

        def write(self, *args, **kwargs):
            assert os.path.lexists(self._join('.hg/wlock'))
            return orig.write(self, *args, **kwargs)

    repo.__class__ = lockcheckrepo