Make it possible to debug failed hook imports via use of --traceback

Prior to this change, if a Python hook module failed to load (e.g. due
to an import error or path problem), it was impossible to figure out
why the error occurred, because the ImportErrors that got raised were
caught but never displayed.

If run with --traceback or ui.traceback=True, hg now prints tracebacks
of both of the ImportError instances that get raised before it bails.

mercurial/hook.py

@@ -1,139 +1,147 b''
 # hook.py - hook support for mercurial
 #
 # Copyright 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from i18n import _
 import os, sys
 import extensions, util
 
 def _pythonhook(ui, repo, name, hname, funcname, args, throw):
     '''call python hook. hook is callable object, looked up as
     name in python module. if callable returns "true", hook
     fails, else passes. if hook raises exception, treated as
     hook failure. exception propagates if throw is "true".
 
     reason for "true" meaning "hook failed" is so that
     unmodified commands (e.g. mercurial.commands.update) can
     be run as hooks without wrappers to convert return values.'''
 
     ui.note(_("calling hook %s: %s\n") % (hname, funcname))
     obj = funcname
     if not hasattr(obj, '__call__'):
         d = funcname.rfind('.')
         if d == -1:
             raise util.Abort(_('%s hook is invalid ("%s" not in '
                                'a module)') % (hname, funcname))
         modname = funcname[:d]
         oldpaths = sys.path[:]
         if hasattr(sys, "frozen"):
             # binary installs require sys.path manipulation
             path, name = os.path.split(modname)
             if path and name:
                 sys.path.append(path)
                 modname = name
         try:
             obj = __import__(modname)
         except ImportError:
+            e1 = sys.exc_type, sys.exc_value, sys.exc_traceback
             try:
                 # extensions are loaded with hgext_ prefix
                 obj = __import__("hgext_%s" % modname)
             except ImportError:
+                e2 = sys.exc_type, sys.exc_value, sys.exc_traceback
+                if ui.tracebackflag:
+                    ui.warn(_('exception from first failed import attempt:\n'))
+                ui.traceback(e1)
+                if ui.tracebackflag:
+                    ui.warn(_('exception from second failed import attempt:\n'))
+                ui.traceback(e2)
                 raise util.Abort(_('%s hook is invalid '
                                    '(import of "%s" failed)') %
                                  (hname, modname))
         sys.path = oldpaths
         try:
             for p in funcname.split('.')[1:]:
                 obj = getattr(obj, p)
         except AttributeError:
             raise util.Abort(_('%s hook is invalid '
                                '("%s" is not defined)') %
                              (hname, funcname))
         if not hasattr(obj, '__call__'):
             raise util.Abort(_('%s hook is invalid '
                                '("%s" is not callable)') %
                              (hname, funcname))
     try:
         r = obj(ui=ui, repo=repo, hooktype=name, **args)
     except KeyboardInterrupt:
         raise
     except Exception, exc:
         if isinstance(exc, util.Abort):
             ui.warn(_('error: %s hook failed: %s\n') %
                          (hname, exc.args[0]))
         else:
             ui.warn(_('error: %s hook raised an exception: '
                            '%s\n') % (hname, exc))
         if throw:
             raise
         ui.traceback()
         return True
     if r:
         if throw:
             raise util.Abort(_('%s hook failed') % hname)
         ui.warn(_('warning: %s hook failed\n') % hname)
     return r
 
 def _exthook(ui, repo, name, cmd, args, throw):
     ui.note(_("running hook %s: %s\n") % (name, cmd))
 
     env = {}
     for k, v in args.iteritems():
         if hasattr(v, '__call__'):
             v = v()
         env['HG_' + k.upper()] = v
 
     if repo:
         cwd = repo.root
     else:
         cwd = os.getcwd()
     r = util.system(cmd, environ=env, cwd=cwd)
     if r:
         desc, r = util.explain_exit(r)
         if throw:
             raise util.Abort(_('%s hook %s') % (name, desc))
         ui.warn(_('warning: %s hook %s\n') % (name, desc))
     return r
 
 _redirect = False
 def redirect(state):
     global _redirect
     _redirect = state
 
 def hook(ui, repo, name, throw=False, **args):
     r = False
 
     oldstdout = -1
     if _redirect:
         stdoutno = sys.__stdout__.fileno()
         stderrno = sys.__stderr__.fileno()
         # temporarily redirect stdout to stderr, if possible
         if stdoutno >= 0 and stderrno >= 0:
             oldstdout = os.dup(stdoutno)
             os.dup2(stderrno, stdoutno)
 
     try:
         for hname, cmd in ui.configitems('hooks'):
             if hname.split('.')[0] != name or not cmd:
                 continue
             if hasattr(cmd, '__call__'):
                 r = _pythonhook(ui, repo, name, hname, cmd, args, throw) or r
             elif cmd.startswith('python:'):
                 if cmd.count(':') >= 2:
                     path, cmd = cmd[7:].rsplit(':', 1)
                     mod = extensions.loadpath(path, 'hghook.%s' % hname)
                     hookfn = getattr(mod, cmd)
                 else:
                     hookfn = cmd[7:].strip()
                 r = _pythonhook(ui, repo, name, hname, hookfn, args, throw) or r
             else:
                 r = _exthook(ui, repo, hname, cmd, args, throw) or r
     finally:
         if _redirect and oldstdout >= 0:
             os.dup2(oldstdout, stdoutno)
             os.close(oldstdout)
 
     return r

mercurial/ui.py

@@ -1,383 +1,386 b''
 # ui.py - user interface bits for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from i18n import _
 import errno, getpass, os, socket, sys, tempfile, traceback
 import config, util, error
 
 _booleans = {'1': True, 'yes': True, 'true': True, 'on': True,
              '0': False, 'no': False, 'false': False, 'off': False}
 
 class ui(object):
     def __init__(self, src=None):
         self._buffers = []
-        self.quiet = self.verbose = self.debugflag = self._traceback = False
+        self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
         self._reportuntrusted = True
         self._ocfg = config.config() # overlay
         self._tcfg = config.config() # trusted
         self._ucfg = config.config() # untrusted
         self._trustusers = set()
         self._trustgroups = set()
 
         if src:
             self._tcfg = src._tcfg.copy()
             self._ucfg = src._ucfg.copy()
             self._ocfg = src._ocfg.copy()
             self._trustusers = src._trustusers.copy()
             self._trustgroups = src._trustgroups.copy()
             self.fixconfig()
         else:
             # we always trust global config files
             for f in util.rcpath():
                 self.readconfig(f, trust=True)
 
     def copy(self):
         return self.__class__(self)
 
     def _is_trusted(self, fp, f):
         st = util.fstat(fp)
         if util.isowner(st):
             return True
 
         tusers, tgroups = self._trustusers, self._trustgroups
         if '*' in tusers or '*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self._reportuntrusted:
             self.warn(_('Not trusting file %s from untrusted '
                         'user %s, group %s\n') % (f, user, group))
         return False
 
     def readconfig(self, filename, root=None, trust=False,
                    sections=None, remap=None):
         try:
             fp = open(filename)
         except IOError:
             if not sections: # ignore unless we were looking for something
                 return
             raise
 
         cfg = config.config()
         trusted = sections or trust or self._is_trusted(fp, filename)
 
         try:
             cfg.read(filename, fp, sections=sections, remap=remap)
         except error.ConfigError, inst:
             if trusted:
                 raise
             self.warn(_("Ignored: %s\n") % str(inst))
 
         if trusted:
             self._tcfg.update(cfg)
             self._tcfg.update(self._ocfg)
         self._ucfg.update(cfg)
         self._ucfg.update(self._ocfg)
 
         if root is None:
             root = os.path.expanduser('~')
         self.fixconfig(root=root)
 
     def fixconfig(self, root=None):
         # translate paths relative to root (or home) into absolute paths
         root = root or os.getcwd()
         for c in self._tcfg, self._ucfg, self._ocfg:
             for n, p in c.items('paths'):
                 if p and "://" not in p and not os.path.isabs(p):
                     c.set("paths", n, os.path.normpath(os.path.join(root, p)))
 
         # update ui options
         self.debugflag = self.configbool('ui', 'debug')
         self.verbose = self.debugflag or self.configbool('ui', 'verbose')
         self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
         if self.verbose and self.quiet:
             self.quiet = self.verbose = False
         self._reportuntrusted = self.configbool("ui", "report_untrusted", True)
-        self._traceback = self.configbool('ui', 'traceback', False)
+        self.tracebackflag = self.configbool('ui', 'traceback', False)
 
         # update trust information
         self._trustusers.update(self.configlist('trusted', 'users'))
         self._trustgroups.update(self.configlist('trusted', 'groups'))
 
     def setconfig(self, section, name, value):
         for cfg in (self._ocfg, self._tcfg, self._ucfg):
             cfg.set(section, name, value)
         self.fixconfig()
 
     def _data(self, untrusted):
         return untrusted and self._ucfg or self._tcfg
 
     def configsource(self, section, name, untrusted=False):
         return self._data(untrusted).source(section, name) or 'none'
 
     def config(self, section, name, default=None, untrusted=False):
         value = self._data(untrusted).get(section, name, default)
         if self.debugflag and not untrusted and self._reportuntrusted:
             uvalue = self._ucfg.get(section, name)
             if uvalue is not None and uvalue != value:
                 self.debug(_("ignoring untrusted configuration option "
                              "%s.%s = %s\n") % (section, name, uvalue))
         return value
 
     def configbool(self, section, name, default=False, untrusted=False):
         v = self.config(section, name, None, untrusted)
         if v is None:
             return default
         if v.lower() not in _booleans:
             raise error.ConfigError(_("%s.%s not a boolean ('%s')")
                                     % (section, name, v))
         return _booleans[v.lower()]
 
     def configlist(self, section, name, default=None, untrusted=False):
         """Return a list of comma/space separated strings"""
         result = self.config(section, name, untrusted=untrusted)
         if result is None:
             result = default or []
         if isinstance(result, basestring):
             result = result.replace(",", " ").split()
         return result
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         return section in self._data(untrusted)
 
     def configitems(self, section, untrusted=False):
         items = self._data(untrusted).items(section)
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in self._ucfg.items(section):
                 if self._tcfg.get(section, k) != v:
                     self.debug(_("ignoring untrusted configuration option "
                                 "%s.%s = %s\n") % (section, k, v))
         return items
 
     def walkconfig(self, untrusted=False):
         cfg = self._data(untrusted)
         for section in cfg.sections():
             for name, value in self.configitems(section, untrusted):
                 yield section, name, str(value).replace('\n', '\\n')
 
     def username(self):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         """
         user = os.environ.get("HGUSER")
         if user is None:
             user = self.config("ui", "username")
         if user is None:
             user = os.environ.get("EMAIL")
         if user is None and self.configbool("ui", "askusername"):
             user = self.prompt(_("enter a commit username:"), default=None)
         if user is None and not self.interactive():
             try:
                 user = '%s@%s' % (util.getuser(), socket.getfqdn())
                 self.warn(_("No username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise util.Abort(_('no username supplied (see "hg help config")'))
         if "\n" in user:
             raise util.Abort(_("username %s contains a newline\n") % repr(user))
         return user
 
     def shortuser(self, user):
         """Return a short representation of a user name or email address."""
         if not self.verbose: user = util.shortuser(user)
         return user
 
     def _path(self, loc):
         p = self.config('paths', loc)
         if p:
             if '%%' in p:
                 self.warn("(deprecated '%%' in path %s=%s from %s)\n" %
                           (loc, p, self.configsource('paths', loc)))
                 p = p.replace('%%', '%')
             p = util.expandpath(p)
         return p
 
     def expandpath(self, loc, default=None):
         """Return repository location relative to cwd or from [paths]"""
         if "://" in loc or os.path.isdir(os.path.join(loc, '.hg')):
             return loc
 
         path = self._path(loc)
         if not path and default is not None:
             path = self._path(default)
         return path or loc
 
     def pushbuffer(self):
         self._buffers.append([])
 
     def popbuffer(self):
         return "".join(self._buffers.pop())
 
     def write(self, *args):
         if self._buffers:
             self._buffers[-1].extend([str(a) for a in args])
         else:
             for a in args:
                 sys.stdout.write(str(a))
 
     def write_err(self, *args):
         try:
             if not sys.stdout.closed: sys.stdout.flush()
             for a in args:
                 sys.stderr.write(str(a))
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if not sys.stderr.closed: sys.stderr.flush()
         except IOError, inst:
             if inst.errno != errno.EPIPE:
                 raise
 
     def flush(self):
         try: sys.stdout.flush()
         except: pass
         try: sys.stderr.flush()
         except: pass
 
     def interactive(self):
         i = self.configbool("ui", "interactive", None)
         if i is None:
             return sys.stdin.isatty()
         return i
 
     def _readline(self, prompt=''):
         if sys.stdin.isatty():
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 pass
         line = raw_input(prompt)
         # When stdin is in binary mode on Windows, it can cause
         # raw_input() to emit an extra trailing carriage return
         if os.linesep == '\r\n' and line and line[-1] == '\r':
             line = line[:-1]
         return line
 
     def prompt(self, msg, default="y"):
         """Prompt user with msg, read response.
         If ui is not interactive, the default is returned.
         """
         if not self.interactive():
             self.write(msg, ' ', default, "\n")
             return default
         try:
             r = self._readline(msg + ' ')
             if not r:
                 return default
             return r
         except EOFError:
             raise util.Abort(_('response expected'))
 
     def promptchoice(self, msg, choices, default=0):
         """Prompt user with msg, read response, and ensure it matches
         one of the provided choices. The index of the choice is returned.
         choices is a sequence of acceptable responses with the format:
         ('&None', 'E&xec', 'Sym&link') Responses are case insensitive.
         If ui is not interactive, the default is returned.
         """
         resps = [s[s.index('&')+1].lower() for s in choices]
         while True:
             r = self.prompt(msg, resps[default])
             if r.lower() in resps:
                 return resps.index(r.lower())
             self.write(_("unrecognized response\n"))
 
 
     def getpass(self, prompt=None, default=None):
         if not self.interactive(): return default
         try:
             return getpass.getpass(prompt or _('password: '))
         except EOFError:
             raise util.Abort(_('response expected'))
     def status(self, *msg):
         if not self.quiet: self.write(*msg)
     def warn(self, *msg):
         self.write_err(*msg)
     def note(self, *msg):
         if self.verbose: self.write(*msg)
     def debug(self, *msg):
         if self.debugflag: self.write(*msg)
     def edit(self, text, user):
         (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt",
                                       text=True)
         try:
             f = os.fdopen(fd, "w")
             f.write(text)
             f.close()
 
             editor = self.geteditor()
 
             util.system("%s \"%s\"" % (editor, name),
                         environ={'HGUSER': user},
                         onerr=util.Abort, errprefix=_("edit failed"))
 
             f = open(name)
             t = f.read()
             f.close()
         finally:
             os.unlink(name)
 
         return t
 
-    def traceback(self):
+    def traceback(self, exc=None):
         '''print exception traceback if traceback printing enabled.
         only to call in exception handler. returns true if traceback
         printed.'''
-        if self._traceback:
+        if self.tracebackflag:
+            if exc:
+                traceback.print_exception(exc[0], exc[1], exc[2])
+            else:
             traceback.print_exc()
-        return self._traceback
+        return self.tracebackflag
 
     def geteditor(self):
         '''return editor to use'''
         return (os.environ.get("HGEDITOR") or
                 self.config("ui", "editor") or
                 os.environ.get("VISUAL") or
                 os.environ.get("EDITOR", "vi"))
 
     def progress(self, topic, pos, item="", unit="", total=None):
         '''show a progress message
 
         With stock hg, this is simply a debug message that is hidden
         by default, but with extensions or GUI tools it may be
         visible. 'topic' is the current operation, 'item' is a
         non-numeric marker of the current position (ie the currently
         in-process file), 'pos' is the current numeric position (ie
         revision, bytes, etc.), unit is a corresponding unit label,
         and total is the highest expected pos.
 
         Multiple nested topics may be active at a time. All topics
         should be marked closed by setting pos to None at termination.
         '''
 
         if pos == None or not self.debugflag:
             return
 
         if unit:
             unit = ' ' + unit
         if item:
             item = ' ' + item
 
         if total:
             pct = 100.0 * pos / total
             self.debug('%s:%s %s/%s%s (%4.2g%%)\n'
                      % (topic, item, pos, total, unit, pct))
         else:
             self.debug('%s:%s %s%s\n' % (topic, item, pos, unit))

tests/test-hook

@@ -1,251 +1,265 b''
 #!/bin/sh
 
 cp "$TESTDIR"/printenv.py .
 
 # commit hooks can see env vars
 hg init a
 cd a
 echo "[hooks]" > .hg/hgrc
 echo 'commit = unset HG_LOCAL HG_TAG; python ../printenv.py commit' >> .hg/hgrc
 echo 'commit.b = unset HG_LOCAL HG_TAG; python ../printenv.py commit.b' >> .hg/hgrc
 echo 'precommit = unset HG_LOCAL HG_NODE HG_TAG; python ../printenv.py precommit' >> .hg/hgrc
 echo 'pretxncommit = unset HG_LOCAL HG_TAG; python ../printenv.py pretxncommit' >> .hg/hgrc
 echo 'pretxncommit.tip = hg -q tip' >> .hg/hgrc
 echo 'pre-identify = python ../printenv.py pre-identify 1' >> .hg/hgrc
 echo 'pre-cat = python ../printenv.py pre-cat' >> .hg/hgrc
 echo 'post-cat = python ../printenv.py post-cat' >> .hg/hgrc
 echo a > a
 hg add a
 hg commit -m a -d "1000000 0"
 
 hg clone . ../b
 cd ../b
 
 # changegroup hooks can see env vars
 echo '[hooks]' > .hg/hgrc
 echo 'prechangegroup = python ../printenv.py prechangegroup' >> .hg/hgrc
 echo 'changegroup = python ../printenv.py changegroup' >> .hg/hgrc
 echo 'incoming = python ../printenv.py incoming' >> .hg/hgrc
 
 # pretxncommit and commit hooks can see both parents of merge
 cd ../a
 echo b >> a
 hg commit -m a1 -d "1 0"
 hg update -C 0
 echo b > b
 hg add b
 hg commit -m b -d '1 0'
 hg merge 1
 hg commit -m merge -d '2 0'
 
 # test generic hooks
 hg id
 hg cat b
 
 cd ../b
 hg pull ../a
 
 # tag hooks can see env vars
 cd ../a
 echo 'pretag = python ../printenv.py pretag' >> .hg/hgrc
 echo 'tag = unset HG_PARENT1 HG_PARENT2; python ../printenv.py tag' >> .hg/hgrc
 hg tag -d '3 0' a
 hg tag -l la
 
 # pretag hook can forbid tagging
 echo 'pretag.forbid = python ../printenv.py pretag.forbid 1' >> .hg/hgrc
 hg tag -d '4 0' fa
 hg tag -l fla
 
 # pretxncommit hook can see changeset, can roll back txn, changeset
 # no more there after
 echo 'pretxncommit.forbid0 = hg tip -q' >> .hg/hgrc
 echo 'pretxncommit.forbid1 = python ../printenv.py pretxncommit.forbid 1' >> .hg/hgrc
 echo z > z
 hg add z
 hg -q tip
 hg commit -m 'fail' -d '4 0'
 hg -q tip
 
 # precommit hook can prevent commit
 echo 'precommit.forbid = python ../printenv.py precommit.forbid 1' >> .hg/hgrc
 hg commit -m 'fail' -d '4 0'
 hg -q tip
 
 # preupdate hook can prevent update
 echo 'preupdate = python ../printenv.py preupdate' >> .hg/hgrc
 hg update 1
 
 # update hook
 echo 'update = python ../printenv.py update' >> .hg/hgrc
 hg update
 
 # prechangegroup hook can prevent incoming changes
 cd ../b
 hg -q tip
 echo '[hooks]' > .hg/hgrc
 echo 'prechangegroup.forbid = python ../printenv.py prechangegroup.forbid 1' >> .hg/hgrc
 hg pull ../a
 
 # pretxnchangegroup hook can see incoming changes, can roll back txn,
 # incoming changes no longer there after
 echo '[hooks]' > .hg/hgrc
 echo 'pretxnchangegroup.forbid0 = hg tip -q' >> .hg/hgrc
 echo 'pretxnchangegroup.forbid1 = python ../printenv.py pretxnchangegroup.forbid 1' >> .hg/hgrc
 hg pull ../a
 hg -q tip
 
 # outgoing hooks can see env vars
 rm .hg/hgrc
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing = python ../printenv.py preoutgoing' >> ../a/.hg/hgrc
 echo 'outgoing = python ../printenv.py outgoing' >> ../a/.hg/hgrc
 hg pull ../a
 hg rollback
 
 # preoutgoing hook can prevent outgoing changes
 echo 'preoutgoing.forbid = python ../printenv.py preoutgoing.forbid 1' >> ../a/.hg/hgrc
 hg pull ../a
 
 # outgoing hooks work for local clones
 cd ..
 echo '[hooks]' > a/.hg/hgrc
 echo 'preoutgoing = python ../printenv.py preoutgoing' >> a/.hg/hgrc
 echo 'outgoing = python ../printenv.py outgoing' >> a/.hg/hgrc
 hg clone a c
 rm -rf c
 
 # preoutgoing hook can prevent outgoing changes for local clones
 echo 'preoutgoing.forbid = python ../printenv.py preoutgoing.forbid 1' >> a/.hg/hgrc
 hg clone a zzz
 cd b
 
 cat > hooktests.py <<EOF
 from mercurial import util
 
 uncallable = 0
 
 def printargs(args):
     args.pop('ui', None)
     args.pop('repo', None)
     a = list(args.items())
     a.sort()
     print 'hook args:'
     for k, v in a:
        print ' ', k, v
 
 def passhook(**args):
     printargs(args)
 
 def failhook(**args):
     printargs(args)
     return True
 
 class LocalException(Exception):
     pass
 
 def raisehook(**args):
     raise LocalException('exception from hook')
 
 def aborthook(**args):
     raise util.Abort('raise abort from hook')
 
 def brokenhook(**args):
     return 1 + {}
 
 class container:
     unreachable = 1
 EOF
 
 echo '# test python hooks'
 PYTHONPATH="`pwd`:$PYTHONPATH"
 export PYTHONPATH
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.broken = python:hooktests.brokenhook' >> ../a/.hg/hgrc
 hg pull ../a 2>&1 | grep 'raised an exception'
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.raise = python:hooktests.raisehook' >> ../a/.hg/hgrc
 hg pull ../a 2>&1 | grep 'raised an exception'
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.abort = python:hooktests.aborthook' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.fail = python:hooktests.failhook' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.uncallable = python:hooktests.uncallable' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.nohook = python:hooktests.nohook' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.nomodule = python:nomodule' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.badmodule = python:nomodule.nowhere' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.unreachable = python:hooktests.container.unreachable' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '[hooks]' > ../a/.hg/hgrc
 echo 'preoutgoing.pass = python:hooktests.passhook' >> ../a/.hg/hgrc
 hg pull ../a
 
 echo '# make sure --traceback works'
 echo '[hooks]' > .hg/hgrc
 echo 'commit.abort = python:hooktests.aborthook' >> .hg/hgrc
 
 echo a >> a
 hg --traceback commit -A -m a 2>&1 | grep '^Traceback'
 
 cd ..
 hg init c
 cd c
 
 cat > hookext.py <<EOF
 def autohook(**args):
     print "Automatically installed hook"
 
 def reposetup(ui, repo):
     repo.ui.setconfig("hooks", "commit.auto", autohook)
 EOF
 echo '[extensions]' >> .hg/hgrc
 echo 'hookext = hookext.py' >> .hg/hgrc
 
 touch foo
 hg add foo
 hg ci -m 'add foo'
 echo >> foo
 hg ci --debug -m 'change foo' | sed -e 's/ at .*>/>/'
 
 hg showconfig hooks | sed -e 's/ at .*>/>/'
 
 echo '# test python hook configured with python:[file]:[hook] syntax'
 cd ..
 mkdir d
 cd d
 hg init repo
 mkdir hooks
 
 cd hooks
 cat > testhooks.py <<EOF
 def testhook(**args):
     print 'hook works'
 EOF
 echo '[hooks]' > ../repo/.hg/hgrc
 echo "pre-commit.test = python:`pwd`/testhooks.py:testhook" >> ../repo/.hg/hgrc
 
 cd ../repo
 hg commit
 
+cd ../../b
+echo '# make sure --traceback works on hook import failure'
+cat > importfail.py <<EOF
+import somebogusmodule
+# dereference something in the module to force demandimport to load it
+somebogusmodule.whatever
+EOF
+
+echo '[hooks]' > .hg/hgrc
+echo 'precommit.importfail = python:importfail.whatever' >> .hg/hgrc
+
+echo a >> a
+hg --traceback commit -Ama 2>&1 | grep '^\(exception\|Traceback\|ImportError\)'
+
 exit 0

tests/test-hook.out

@@ -1,165 +1,173 b''
 precommit hook: HG_PARENT1=0000000000000000000000000000000000000000 
 pretxncommit hook: HG_NODE=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b HG_PARENT1=0000000000000000000000000000000000000000 HG_PENDING=$HGTMP/test-hook/a 
 0:29b62aeb769f
 commit hook: HG_NODE=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b HG_PARENT1=0000000000000000000000000000000000000000 
 commit.b hook: HG_NODE=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b HG_PARENT1=0000000000000000000000000000000000000000 
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 precommit hook: HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 pretxncommit hook: HG_NODE=b702efe9688826e3a91283852b328b84dbf37bc2 HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b HG_PENDING=$HGTMP/test-hook/a 
 1:b702efe96888
 commit hook: HG_NODE=b702efe9688826e3a91283852b328b84dbf37bc2 HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 commit.b hook: HG_NODE=b702efe9688826e3a91283852b328b84dbf37bc2 HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 precommit hook: HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 pretxncommit hook: HG_NODE=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b HG_PENDING=$HGTMP/test-hook/a 
 2:1324a5531bac
 commit hook: HG_NODE=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 commit.b hook: HG_NODE=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT1=29b62aeb769fdf78d8d9c5f28b017f76d7ef824b 
 created new head
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 precommit hook: HG_PARENT1=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT2=b702efe9688826e3a91283852b328b84dbf37bc2 
 pretxncommit hook: HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_PARENT1=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT2=b702efe9688826e3a91283852b328b84dbf37bc2 HG_PENDING=$HGTMP/test-hook/a 
 3:4c52fb2e4022
 commit hook: HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_PARENT1=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT2=b702efe9688826e3a91283852b328b84dbf37bc2 
 commit.b hook: HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_PARENT1=1324a5531bac09b329c3845d35ae6a7526874edb HG_PARENT2=b702efe9688826e3a91283852b328b84dbf37bc2 
 pre-identify hook: HG_ARGS=id 
 warning: pre-identify hook exited with status 1
 pre-cat hook: HG_ARGS=cat b 
 post-cat hook: HG_ARGS=cat b HG_RESULT=0 
 b
 prechangegroup hook: HG_SOURCE=pull HG_URL=file: 
 changegroup hook: HG_NODE=b702efe9688826e3a91283852b328b84dbf37bc2 HG_SOURCE=pull HG_URL=file: 
 incoming hook: HG_NODE=b702efe9688826e3a91283852b328b84dbf37bc2 HG_SOURCE=pull HG_URL=file: 
 incoming hook: HG_NODE=1324a5531bac09b329c3845d35ae6a7526874edb HG_SOURCE=pull HG_URL=file: 
 incoming hook: HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_SOURCE=pull HG_URL=file: 
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 3 changesets with 2 changes to 2 files
 (run 'hg update' to get a working copy)
 pretag hook: HG_LOCAL=0 HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_TAG=a 
 precommit hook: HG_PARENT1=4c52fb2e402287dd5dc052090682536c8406c321 
 pretxncommit hook: HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PARENT1=4c52fb2e402287dd5dc052090682536c8406c321 HG_PENDING=$HGTMP/test-hook/a 
 4:8ea2ef7ad3e8
 commit hook: HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PARENT1=4c52fb2e402287dd5dc052090682536c8406c321 
 commit.b hook: HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PARENT1=4c52fb2e402287dd5dc052090682536c8406c321 
 tag hook: HG_LOCAL=0 HG_NODE=4c52fb2e402287dd5dc052090682536c8406c321 HG_TAG=a 
 pretag hook: HG_LOCAL=1 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=la 
 tag hook: HG_LOCAL=1 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=la 
 pretag hook: HG_LOCAL=0 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=fa 
 pretag.forbid hook: HG_LOCAL=0 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=fa 
 abort: pretag.forbid hook exited with status 1
 pretag hook: HG_LOCAL=1 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=fla 
 pretag.forbid hook: HG_LOCAL=1 HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_TAG=fla 
 abort: pretag.forbid hook exited with status 1
 4:8ea2ef7ad3e8
 precommit hook: HG_PARENT1=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 
 pretxncommit hook: HG_NODE=fad284daf8c032148abaffcd745dafeceefceb61 HG_PARENT1=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PENDING=$HGTMP/test-hook/a 
 5:fad284daf8c0
 5:fad284daf8c0
 pretxncommit.forbid hook: HG_NODE=fad284daf8c032148abaffcd745dafeceefceb61 HG_PARENT1=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PENDING=$HGTMP/test-hook/a 
 transaction abort!
 rollback completed
 abort: pretxncommit.forbid1 hook exited with status 1
 4:8ea2ef7ad3e8
 precommit hook: HG_PARENT1=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 
 precommit.forbid hook: HG_PARENT1=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 
 abort: precommit.forbid hook exited with status 1
 4:8ea2ef7ad3e8
 preupdate hook: HG_PARENT1=b702efe96888 
 0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 preupdate hook: HG_PARENT1=8ea2ef7ad3e8 
 update hook: HG_ERROR=0 HG_PARENT1=8ea2ef7ad3e8 
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 3:4c52fb2e4022
 prechangegroup.forbid hook: HG_SOURCE=pull HG_URL=file: 
 pulling from ../a
 searching for changes
 abort: prechangegroup.forbid hook exited with status 1
 4:8ea2ef7ad3e8
 pretxnchangegroup.forbid hook: HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_PENDING=$HGTMP/test-hook/b HG_SOURCE=pull HG_URL=file: 
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 transaction abort!
 rollback completed
 abort: pretxnchangegroup.forbid1 hook exited with status 1
 3:4c52fb2e4022
 preoutgoing hook: HG_SOURCE=pull 
 outgoing hook: HG_NODE=8ea2ef7ad3e8cac946c72f1e0c79d6aebc301198 HG_SOURCE=pull 
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 (run 'hg update' to get a working copy)
 rolling back last transaction
 preoutgoing hook: HG_SOURCE=pull 
 preoutgoing.forbid hook: HG_SOURCE=pull 
 pulling from ../a
 searching for changes
 abort: preoutgoing.forbid hook exited with status 1
 preoutgoing hook: HG_SOURCE=clone 
 outgoing hook: HG_NODE=0000000000000000000000000000000000000000 HG_SOURCE=clone 
 updating to branch default
 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 preoutgoing hook: HG_SOURCE=clone 
 preoutgoing.forbid hook: HG_SOURCE=clone 
 abort: preoutgoing.forbid hook exited with status 1
 # test python hooks
 error: preoutgoing.broken hook raised an exception: unsupported operand type(s) for +: 'int' and 'dict'
 error: preoutgoing.raise hook raised an exception: exception from hook
 pulling from ../a
 searching for changes
 error: preoutgoing.abort hook failed: raise abort from hook
 abort: raise abort from hook
 pulling from ../a
 searching for changes
 hook args:
   hooktype preoutgoing
   source pull
 abort: preoutgoing.fail hook failed
 pulling from ../a
 searching for changes
 abort: preoutgoing.uncallable hook is invalid ("hooktests.uncallable" is not callable)
 pulling from ../a
 searching for changes
 abort: preoutgoing.nohook hook is invalid ("hooktests.nohook" is not defined)
 pulling from ../a
 searching for changes
 abort: preoutgoing.nomodule hook is invalid ("nomodule" not in a module)
 pulling from ../a
 searching for changes
 abort: preoutgoing.badmodule hook is invalid (import of "nomodule" failed)
 pulling from ../a
 searching for changes
 abort: preoutgoing.unreachable hook is invalid (import of "hooktests.container" failed)
 pulling from ../a
 searching for changes
 hook args:
   hooktype preoutgoing
   source pull
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 (run 'hg update' to get a working copy)
 # make sure --traceback works
 Traceback (most recent call last):
 Automatically installed hook
 foo
 calling hook commit.auto: <function autohook>
 Automatically installed hook
 committed changeset 1:52998019f6252a2b893452765fcb0a47351a5708
 hooks.commit.auto=<function autohook>
 # test python hook configured with python:[file]:[hook] syntax
 hook works
 nothing changed
+# make sure --traceback works on hook import failure
+exception from first failed import attempt:
+Traceback (most recent call last):
+ImportError: No module named somebogusmodule
+exception from second failed import attempt:
+Traceback (most recent call last):
+ImportError: No module named hgext_importfail
+Traceback (most recent call last):