hook.py
279 lines
| 9.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / hook.py
|
r4622 | # hook.py - hook support for mercurial | ||
# | ||||
# Copyright 2007 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r4622 | |||
|
r25953 | from __future__ import absolute_import | ||
import os | ||||
import sys | ||||
from .i18n import _ | ||||
from . import ( | ||||
demandimport, | ||||
|
r32642 | encoding, | ||
|
r25953 | error, | ||
extensions, | ||||
|
r30519 | pycompat, | ||
|
r25953 | util, | ||
) | ||||
|
r4622 | |||
|
r31742 | def _pythonhook(ui, repo, htype, hname, funcname, args, throw): | ||
|
r4622 | '''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.''' | ||||
|
r21797 | if callable(funcname): | ||
|
r20548 | obj = funcname | ||
|
r32614 | funcname = pycompat.sysbytes(obj.__module__ + r"." + obj.__name__) | ||
|
r20548 | else: | ||
|
r4622 | d = funcname.rfind('.') | ||
if d == -1: | ||||
|
r26692 | raise error.HookLoadError( | ||
|
r28106 | _('%s hook is invalid: "%s" not in a module') | ||
|
r26692 | % (hname, funcname)) | ||
|
r4622 | modname = funcname[:d] | ||
|
r10103 | oldpaths = sys.path | ||
|
r14941 | if util.mainfrozen(): | ||
|
r9332 | # binary installs require sys.path manipulation | ||
|
r10103 | modpath, modfile = os.path.split(modname) | ||
if modpath and modfile: | ||||
sys.path = sys.path[:] + [modpath] | ||||
modname = modfile | ||||
|
r25328 | with demandimport.deactivated(): | ||
|
r4622 | try: | ||
|
r25328 | obj = __import__(modname) | ||
|
r28109 | except (ImportError, SyntaxError): | ||
|
r28078 | e1 = sys.exc_info() | ||
|
r25328 | try: | ||
# extensions are loaded with hgext_ prefix | ||||
obj = __import__("hgext_%s" % modname) | ||||
|
r28109 | except (ImportError, SyntaxError): | ||
|
r28078 | e2 = sys.exc_info() | ||
|
r25328 | 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) | ||||
|
r28080 | |||
if not ui.tracebackflag: | ||||
tracebackhint = _( | ||||
'run with --traceback for stack trace') | ||||
else: | ||||
tracebackhint = None | ||||
|
r26692 | raise error.HookLoadError( | ||
|
r28079 | _('%s hook is invalid: import of "%s" failed') % | ||
|
r28080 | (hname, modname), hint=tracebackhint) | ||
|
r9332 | sys.path = oldpaths | ||
|
r4622 | try: | ||
for p in funcname.split('.')[1:]: | ||||
obj = getattr(obj, p) | ||||
|
r7280 | except AttributeError: | ||
|
r26692 | raise error.HookLoadError( | ||
|
r28079 | _('%s hook is invalid: "%s" is not defined') | ||
|
r26692 | % (hname, funcname)) | ||
|
r21797 | if not callable(obj): | ||
|
r26692 | raise error.HookLoadError( | ||
|
r28079 | _('%s hook is invalid: "%s" is not callable') | ||
|
r26692 | % (hname, funcname)) | ||
|
r20547 | |||
ui.note(_("calling hook %s: %s\n") % (hname, funcname)) | ||||
|
r30975 | starttime = util.timer() | ||
|
r20547 | |||
|
r4622 | try: | ||
|
r31742 | r = obj(ui=ui, repo=repo, hooktype=htype, **args) | ||
|
r25660 | except Exception as exc: | ||
|
r26587 | if isinstance(exc, error.Abort): | ||
|
r25084 | ui.warn(_('error: %s hook failed: %s\n') % | ||
(hname, exc.args[0])) | ||||
else: | ||||
ui.warn(_('error: %s hook raised an exception: ' | ||||
|
r32642 | '%s\n') % (hname, encoding.strtolocal(str(exc)))) | ||
|
r25084 | if throw: | ||
|
r4622 | raise | ||
|
r28108 | if not ui.tracebackflag: | ||
ui.warn(_('(run with --traceback for stack trace)\n')) | ||||
|
r25084 | ui.traceback() | ||
|
r26739 | return True, True | ||
|
r14889 | finally: | ||
|
r30975 | duration = util.timer() - starttime | ||
|
r18691 | ui.log('pythonhook', 'pythonhook-%s: %s finished in %0.2f seconds\n', | ||
|
r31742 | htype, funcname, duration) | ||
|
r4622 | if r: | ||
if throw: | ||||
|
r23415 | raise error.HookAbort(_('%s hook failed') % hname) | ||
|
r4622 | ui.warn(_('warning: %s hook failed\n') % hname) | ||
|
r26739 | return r, False | ||
|
r4622 | |||
|
r31746 | def _exthook(ui, repo, htype, name, cmd, args, throw): | ||
|
r4622 | ui.note(_("running hook %s: %s\n") % (name, cmd)) | ||
|
r7787 | |||
|
r30975 | starttime = util.timer() | ||
|
r7787 | env = {} | ||
|
r26751 | |||
# make in-memory changes visible to external process | ||||
|
r27228 | if repo is not None: | ||
tr = repo.currenttransaction() | ||||
repo.dirstate.write(tr) | ||||
if tr and tr.writepending(): | ||||
env['HG_PENDING'] = repo.root | ||||
|
r31746 | env['HG_HOOKTYPE'] = htype | ||
|
r31747 | env['HG_HOOKNAME'] = name | ||
|
r26751 | |||
|
r7787 | for k, v in args.iteritems(): | ||
|
r21797 | if callable(v): | ||
|
r7787 | v = v() | ||
|
r13207 | if isinstance(v, dict): | ||
# make the dictionary element order stable across Python | ||||
# implementations | ||||
v = ('{' + | ||||
', '.join('%r: %r' % i for i in sorted(v.iteritems())) + | ||||
'}') | ||||
|
r7787 | env['HG_' + k.upper()] = v | ||
|
r5869 | if repo: | ||
cwd = repo.root | ||||
else: | ||||
|
r30519 | cwd = pycompat.getcwd() | ||
|
r31205 | r = ui.system(cmd, environ=env, cwd=cwd, blockedtag='exthook-%s' % (name,)) | ||
|
r18671 | |||
|
r30975 | duration = util.timer() - starttime | ||
|
r18691 | ui.log('exthook', 'exthook-%s: %s finished in %0.2f seconds\n', | ||
|
r18671 | name, cmd, duration) | ||
|
r4622 | if r: | ||
|
r14234 | desc, r = util.explainexit(r) | ||
|
r4622 | if throw: | ||
|
r23415 | raise error.HookAbort(_('%s hook %s') % (name, desc)) | ||
|
r4622 | ui.warn(_('warning: %s hook %s\n') % (name, desc)) | ||
return r | ||||
|
r28938 | # represent an untrusted hook command | ||
_fromuntrusted = object() | ||||
|
r15896 | def _allhooks(ui): | ||
|
r28937 | """return a list of (hook-id, cmd) pairs sorted by priority""" | ||
hooks = _hookitems(ui) | ||||
|
r28938 | # Be careful in this section, propagating the real commands from untrusted | ||
# sources would create a security vulnerability, make sure anything altered | ||||
# in that section uses "_fromuntrusted" as its command. | ||||
untrustedhooks = _hookitems(ui, _untrusted=True) | ||||
for name, value in untrustedhooks.items(): | ||||
trustedvalue = hooks.get(name, (None, None, name, _fromuntrusted)) | ||||
if value != trustedvalue: | ||||
(lp, lo, lk, lv) = trustedvalue | ||||
hooks[name] = (lp, lo, lk, _fromuntrusted) | ||||
# (end of the security sensitive section) | ||||
|
r28937 | return [(k, v) for p, o, k, v in sorted(hooks.values())] | ||
|
r28938 | def _hookitems(ui, _untrusted=False): | ||
|
r28937 | """return all hooks items ready to be sorted""" | ||
|
r28936 | hooks = {} | ||
|
r28938 | for name, cmd in ui.configitems('hooks', untrusted=_untrusted): | ||
|
r15896 | if not name.startswith('priority'): | ||
priority = ui.configint('hooks', 'priority.%s' % name, 0) | ||||
|
r28936 | hooks[name] = (-priority, len(hooks), name, cmd) | ||
|
r28937 | return hooks | ||
|
r15896 | |||
|
r5833 | _redirect = False | ||
def redirect(state): | ||||
|
r6266 | global _redirect | ||
|
r5833 | _redirect = state | ||
|
r34688 | def hashook(ui, htype): | ||
"""return True if a hook is configured for 'htype'""" | ||||
if not ui.callhooks: | ||||
return False | ||||
for hname, cmd in _allhooks(ui): | ||||
if hname.split('.')[0] == htype and cmd: | ||||
return True | ||||
return False | ||||
|
r31745 | def hook(ui, repo, htype, throw=False, **args): | ||
|
r17048 | if not ui.callhooks: | ||
return False | ||||
|
r26737 | hooks = [] | ||
for hname, cmd in _allhooks(ui): | ||||
|
r31745 | if hname.split('.')[0] == htype and cmd: | ||
|
r26737 | hooks.append((hname, cmd)) | ||
|
r31745 | res = runhooks(ui, repo, htype, hooks, throw=throw, **args) | ||
|
r26738 | r = False | ||
for hname, cmd in hooks: | ||||
|
r26739 | r = res[hname][0] or r | ||
|
r26738 | return r | ||
|
r26737 | |||
|
r31744 | def runhooks(ui, repo, htype, hooks, throw=False, **args): | ||
|
r32897 | args = pycompat.byteskwargs(args) | ||
|
r26738 | res = {} | ||
|
r9658 | oldstdout = -1 | ||
|
r5833 | |||
|
r7416 | try: | ||
|
r26737 | for hname, cmd in hooks: | ||
|
r17963 | if oldstdout == -1 and _redirect: | ||
try: | ||||
|
r30473 | stdoutno = util.stdout.fileno() | ||
stderrno = util.stderr.fileno() | ||||
|
r17963 | # temporarily redirect stdout to stderr, if possible | ||
if stdoutno >= 0 and stderrno >= 0: | ||||
|
r30473 | util.stdout.flush() | ||
|
r17963 | oldstdout = os.dup(stdoutno) | ||
os.dup2(stderrno, stdoutno) | ||||
|
r17964 | except (OSError, AttributeError): | ||
# files seem to be bogus, give up on redirecting (WSGI, etc) | ||||
|
r17963 | pass | ||
|
r28938 | if cmd is _fromuntrusted: | ||
if throw: | ||||
raise error.HookAbort( | ||||
|
r31743 | _('untrusted hook %s not executed') % hname, | ||
|
r28938 | hint = _("see 'hg help config.trusted'")) | ||
|
r31743 | ui.warn(_('warning: untrusted hook %s not executed\n') % hname) | ||
|
r28938 | r = 1 | ||
raised = False | ||||
elif callable(cmd): | ||||
|
r31744 | r, raised = _pythonhook(ui, repo, htype, hname, cmd, args, | ||
throw) | ||||
|
r7416 | elif cmd.startswith('python:'): | ||
|
r9332 | if cmd.count(':') >= 2: | ||
path, cmd = cmd[7:].rsplit(':', 1) | ||||
|
r13118 | path = util.expandpath(path) | ||
|
r13119 | if repo: | ||
path = os.path.join(repo.root, path) | ||||
|
r17217 | try: | ||
mod = extensions.loadpath(path, 'hghook.%s' % hname) | ||||
except Exception: | ||||
ui.write(_("loading %s hook failed:\n") % hname) | ||||
raise | ||||
|
r7916 | hookfn = getattr(mod, cmd) | ||
else: | ||||
hookfn = cmd[7:].strip() | ||||
|
r31744 | r, raised = _pythonhook(ui, repo, htype, hname, hookfn, args, | ||
|
r26739 | throw) | ||
|
r7416 | else: | ||
|
r31746 | r = _exthook(ui, repo, htype, hname, cmd, args, throw) | ||
|
r26739 | raised = False | ||
|
r26738 | |||
|
r26739 | res[hname] = r, raised | ||
|
r24716 | |||
# The stderr is fully buffered on Windows when connected to a pipe. | ||||
# A forcible flush is required to make small stderr data in the | ||||
# remote side available to the client immediately. | ||||
|
r30473 | util.stderr.flush() | ||
|
r7416 | finally: | ||
|
r9658 | if _redirect and oldstdout >= 0: | ||
|
r30473 | util.stdout.flush() # write hook output to stderr fd | ||
|
r9658 | os.dup2(oldstdout, stdoutno) | ||
|
r7416 | os.close(oldstdout) | ||
|
r6266 | |||
|
r26738 | return res | ||