dispatch.py
1286 lines
| 42.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / dispatch.py
|
r5178 | # dispatch.py - command dispatching for mercurial | ||
# | ||||
# Copyright 2005-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. | ||
|
r5178 | |||
|
r27615 | from __future__ import absolute_import, print_function | ||
|
r25932 | |||
|
r24221 | import difflib | ||
|
r25932 | import errno | ||
|
r30576 | import getopt | ||
|
r25932 | import os | ||
import pdb | ||||
import re | ||||
import signal | ||||
import sys | ||||
import traceback | ||||
from .i18n import _ | ||||
|
r43359 | from .pycompat import getattr | ||
|
r25932 | |||
|
r39291 | from hgdemandimport import tracing | ||
|
r25932 | from . import ( | ||
cmdutil, | ||||
|
r30653 | color, | ||
|
r25932 | commands, | ||
demandimport, | ||||
encoding, | ||||
error, | ||||
extensions, | ||||
fancyopts, | ||||
|
r31060 | help, | ||
|
r25932 | hg, | ||
hook, | ||||
|
r29781 | profiling, | ||
|
r30468 | pycompat, | ||
r44728 | rcutil, | |||
|
r40450 | registrar, | ||
|
r30520 | scmutil, | ||
|
r25932 | ui as uimod, | ||
util, | ||||
) | ||||
|
r5178 | |||
|
r37102 | from .utils import ( | ||
|
r37137 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r43346 | |||
|
r14438 | class request(object): | ||
|
r43346 | def __init__( | ||
self, | ||||
args, | ||||
ui=None, | ||||
repo=None, | ||||
fin=None, | ||||
fout=None, | ||||
ferr=None, | ||||
fmsg=None, | ||||
prereposetups=None, | ||||
): | ||||
|
r14438 | self.args = args | ||
|
r14439 | self.ui = ui | ||
|
r14510 | self.repo = repo | ||
|
r14438 | |||
|
r14613 | # input/output/error streams | ||
self.fin = fin | ||||
self.fout = fout | ||||
self.ferr = ferr | ||||
|
r40623 | # separate stream for status/error messages | ||
self.fmsg = fmsg | ||||
|
r14613 | |||
|
r35224 | # remember options pre-parsed by _earlyparseopts() | ||
|
r35059 | self.earlyoptions = {} | ||
|
r32379 | # reposetups which run before extensions, useful for chg to pre-fill | ||
# low-level repo state (for example, changelog) before extensions. | ||||
self.prereposetups = prereposetups or [] | ||||
|
r40438 | # store the parsed and canonical command | ||
self.canonical_command = None | ||||
|
r31956 | def _runexithandlers(self): | ||
exc = None | ||||
handlers = self.ui._exithandlers | ||||
try: | ||||
while handlers: | ||||
func, args, kwargs = handlers.pop() | ||||
try: | ||||
func(*args, **kwargs) | ||||
|
r43346 | except: # re-raises below | ||
|
r31956 | if exc is None: | ||
exc = sys.exc_info()[1] | ||||
|
r43350 | self.ui.warnnoi18n(b'error in exit handlers:\n') | ||
|
r31956 | self.ui.traceback(force=True) | ||
finally: | ||||
if exc is not None: | ||||
raise exc | ||||
|
r43346 | |||
|
r5178 | def run(): | ||
|
r44226 | """run the command in sys.argv""" | ||
|
r37963 | initstdio() | ||
|
r43532 | with tracing.log('parse args into request'): | ||
|
r39291 | req = request(pycompat.sysargv[1:]) | ||
|
r31960 | err = None | ||
try: | ||||
|
r38015 | status = dispatch(req) | ||
|
r34533 | except error.StdioError as e: | ||
err = e | ||||
|
r31960 | status = -1 | ||
|
r38014 | |||
# In all cases we try to flush stdio streams. | ||||
|
r43347 | if util.safehasattr(req.ui, b'fout'): | ||
|
r44105 | assert req.ui is not None # help pytype | ||
assert req.ui.fout is not None # help pytype | ||||
|
r31960 | try: | ||
|
r32687 | req.ui.fout.flush() | ||
|
r34533 | except IOError as e: | ||
err = e | ||||
|
r31960 | status = -1 | ||
|
r38014 | |||
|
r43347 | if util.safehasattr(req.ui, b'ferr'): | ||
|
r44105 | assert req.ui is not None # help pytype | ||
assert req.ui.ferr is not None # help pytype | ||||
|
r35671 | try: | ||
if err is not None and err.errno != errno.EPIPE: | ||||
|
r43346 | req.ui.ferr.write( | ||
|
r43347 | b'abort: %s\n' % encoding.strtolocal(err.strerror) | ||
|
r43346 | ) | ||
|
r35671 | req.ui.ferr.flush() | ||
# There's not much we can do about an I/O error here. So (possibly) | ||||
# change the status code and move on. | ||||
except IOError: | ||||
status = -1 | ||||
|
r36655 | |||
_silencestdio() | ||||
|
r31960 | sys.exit(status & 255) | ||
|
r5178 | |||
|
r43346 | |||
|
r36654 | if pycompat.ispy3: | ||
|
r43346 | |||
|
r37963 | def initstdio(): | ||
|
r36654 | pass | ||
|
r36655 | |||
def _silencestdio(): | ||||
for fp in (sys.stdout, sys.stderr): | ||||
# Check if the file is okay | ||||
try: | ||||
fp.flush() | ||||
continue | ||||
except IOError: | ||||
pass | ||||
# Otherwise mark it as closed to silence "Exception ignored in" | ||||
# message emitted by the interpreter finalizer. Be careful to | ||||
|
r37137 | # not close procutil.stdout, which may be a fdopen-ed file object | ||
# and its close() actually closes the underlying file descriptor. | ||||
|
r36655 | try: | ||
fp.close() | ||||
except IOError: | ||||
pass | ||||
|
r43346 | |||
|
r36654 | else: | ||
|
r43346 | |||
|
r37963 | def initstdio(): | ||
|
r36654 | for fp in (sys.stdin, sys.stdout, sys.stderr): | ||
|
r37138 | procutil.setbinary(fp) | ||
|
r34534 | |||
|
r36655 | def _silencestdio(): | ||
pass | ||||
|
r43346 | |||
|
r24221 | def _getsimilar(symbols, value): | ||
sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio() | ||||
# The cutoff for similarity here is pretty arbitrary. It should | ||||
# probably be investigated and tweaked. | ||||
return [s for s in symbols if sim(s) > 0.6] | ||||
|
r43346 | |||
|
r27623 | def _reportsimilar(write, similar): | ||
if len(similar) == 1: | ||||
|
r43347 | write(_(b"(did you mean %s?)\n") % similar[0]) | ||
|
r27623 | elif similar: | ||
|
r43347 | ss = b", ".join(sorted(similar)) | ||
write(_(b"(did you mean one of %s?)\n") % ss) | ||||
|
r27623 | |||
|
r43346 | |||
|
r24039 | def _formatparse(write, inst): | ||
|
r24221 | similar = [] | ||
if isinstance(inst, error.UnknownIdentifier): | ||||
# make sure to check fileset first, as revset can invoke fileset | ||||
similar = _getsimilar(inst.symbols, inst.function) | ||||
|
r24039 | if len(inst.args) > 1: | ||
|
r43346 | write( | ||
|
r43347 | _(b"hg: parse error at %s: %s\n") | ||
|
r43346 | % (pycompat.bytestr(inst.args[1]), inst.args[0]) | ||
) | ||||
|
r43347 | if inst.args[0].startswith(b' '): | ||
write(_(b"unexpected leading whitespace\n")) | ||||
|
r24039 | else: | ||
|
r43347 | write(_(b"hg: parse error: %s\n") % inst.args[0]) | ||
|
r27623 | _reportsimilar(write, similar) | ||
|
r28515 | if inst.hint: | ||
|
r43347 | write(_(b"(%s)\n") % inst.hint) | ||
|
r24039 | |||
|
r43346 | |||
|
r31492 | def _formatargs(args): | ||
|
r43347 | return b' '.join(procutil.shellquote(a) for a in args) | ||
|
r31492 | |||
|
r43346 | |||
|
r14438 | def dispatch(req): | ||
|
r38015 | """run the command specified in req.args; returns an integer status code""" | ||
|
r43532 | with tracing.log('dispatch.dispatch'): | ||
|
r39291 | if req.ferr: | ||
ferr = req.ferr | ||||
elif req.ui: | ||||
ferr = req.ui.ferr | ||||
else: | ||||
ferr = procutil.stderr | ||||
|
r14615 | |||
|
r39291 | try: | ||
if not req.ui: | ||||
req.ui = uimod.ui.load() | ||||
req.earlyoptions.update(_earlyparseopts(req.ui, req.args)) | ||||
|
r43347 | if req.earlyoptions[b'traceback']: | ||
req.ui.setconfig(b'ui', b'traceback', b'on', b'--traceback') | ||||
|
r14615 | |||
|
r39291 | # set ui streams from the request | ||
if req.fin: | ||||
req.ui.fin = req.fin | ||||
if req.fout: | ||||
req.ui.fout = req.fout | ||||
if req.ferr: | ||||
req.ui.ferr = req.ferr | ||||
|
r40623 | if req.fmsg: | ||
req.ui.fmsg = req.fmsg | ||||
|
r39291 | except error.Abort as inst: | ||
|
r43347 | ferr.write(_(b"abort: %s\n") % inst) | ||
|
r39291 | if inst.hint: | ||
|
r43347 | ferr.write(_(b"(%s)\n") % inst.hint) | ||
|
r39291 | return -1 | ||
except error.ParseError as inst: | ||||
_formatparse(ferr.write, inst) | ||||
return -1 | ||||
|
r14615 | |||
|
r39291 | msg = _formatargs(req.args) | ||
starttime = util.timer() | ||||
ret = 1 # default of Python exit code on unhandled exception | ||||
|
r28520 | try: | ||
|
r39291 | ret = _runcatch(req) or 0 | ||
except error.ProgrammingError as inst: | ||||
|
r43347 | req.ui.error(_(b'** ProgrammingError: %s\n') % inst) | ||
|
r39291 | if inst.hint: | ||
|
r43347 | req.ui.error(_(b'** (%s)\n') % inst.hint) | ||
|
r39291 | raise | ||
except KeyboardInterrupt as inst: | ||||
try: | ||||
if isinstance(inst, error.SignalInterrupt): | ||||
|
r43347 | msg = _(b"killed!\n") | ||
|
r39291 | else: | ||
|
r43347 | msg = _(b"interrupted!\n") | ||
|
r39291 | req.ui.error(msg) | ||
except error.SignalInterrupt: | ||||
# maybe pager would quit without consuming all the output, and | ||||
# SIGPIPE was raised. we cannot print anything in this case. | ||||
pass | ||||
except IOError as inst: | ||||
if inst.errno != errno.EPIPE: | ||||
raise | ||||
ret = -1 | ||||
finally: | ||||
duration = util.timer() - starttime | ||||
req.ui.flush() | ||||
if req.ui.logblockedtimes: | ||||
|
r43347 | req.ui._blockedtimes[b'command_duration'] = duration * 1000 | ||
|
r43346 | req.ui.log( | ||
|
r43347 | b'uiblocked', | ||
b'ui blocked ms\n', | ||||
|
r43346 | **pycompat.strkwargs(req.ui._blockedtimes) | ||
) | ||||
|
r40687 | return_code = ret & 255 | ||
req.ui.log( | ||||
|
r43347 | b"commandfinish", | ||
b"%s exited %d after %0.2f seconds\n", | ||||
|
r40687 | msg, | ||
return_code, | ||||
duration, | ||||
return_code=return_code, | ||||
duration=duration, | ||||
canonical_command=req.canonical_command, | ||||
) | ||||
|
r39291 | try: | ||
req._runexithandlers() | ||||
|
r43346 | except: # exiting, so no re-raises | ||
|
r39291 | ret = ret or -1 | ||
return ret | ||||
|
r5178 | |||
|
r43346 | |||
|
r14439 | def _runcatch(req): | ||
|
r43532 | with tracing.log('dispatch._runcatch'): | ||
|
r43346 | |||
|
r39291 | def catchterm(*args): | ||
raise error.SignalInterrupt | ||||
|
r5178 | |||
|
r39291 | ui = req.ui | ||
|
r32050 | try: | ||
|
r43347 | for name in b'SIGBREAK', b'SIGHUP', b'SIGTERM': | ||
|
r39291 | num = getattr(signal, name, None) | ||
if num: | ||||
signal.signal(num, catchterm) | ||||
except ValueError: | ||||
|
r43346 | pass # happens if called in a thread | ||
|
r32050 | |||
|
r39291 | def _runcatchfunc(): | ||
realcmd = None | ||||
try: | ||||
cmdargs = fancyopts.fancyopts( | ||||
|
r43346 | req.args[:], commands.globalopts, {} | ||
) | ||||
|
r39291 | cmd = cmdargs[0] | ||
aliases, entry = cmdutil.findcmd(cmd, commands.table, False) | ||||
realcmd = aliases[0] | ||||
|
r43346 | except ( | ||
error.UnknownCommand, | ||||
error.AmbiguousCommand, | ||||
IndexError, | ||||
getopt.GetoptError, | ||||
): | ||||
|
r39291 | # Don't handle this here. We know the command is | ||
# invalid, but all we're worried about for now is that | ||||
# it's not a command that server operators expect to | ||||
# be safe to offer to users in a sandbox. | ||||
pass | ||||
|
r43347 | if realcmd == b'serve' and b'--stdio' in cmdargs: | ||
|
r39291 | # We want to constrain 'hg serve --stdio' instances pretty | ||
# closely, as many shared-ssh access tools want to grant | ||||
# access to run *only* 'hg -R $repo serve --stdio'. We | ||||
# restrict to exactly that set of arguments, and prohibit | ||||
# any repo name that starts with '--' to prevent | ||||
# shenanigans wherein a user does something like pass | ||||
# --debugger or --config=ui.debugger=1 as a repo | ||||
# name. This used to actually run the debugger. | ||||
|
r43346 | if ( | ||
len(req.args) != 4 | ||||
|
r43347 | or req.args[0] != b'-R' | ||
or req.args[1].startswith(b'--') | ||||
or req.args[2] != b'serve' | ||||
or req.args[3] != b'--stdio' | ||||
|
r43346 | ): | ||
|
r39291 | raise error.Abort( | ||
|
r43347 | _(b'potentially unsafe serve --stdio invocation: %s') | ||
|
r43346 | % (stringutil.pprint(req.args),) | ||
) | ||||
|
r19639 | |||
|
r39291 | try: | ||
|
r43347 | debugger = b'pdb' | ||
debugtrace = {b'pdb': pdb.set_trace} | ||||
debugmortem = {b'pdb': pdb.post_mortem} | ||||
|
r19639 | |||
|
r39291 | # read --config before doing anything else | ||
# (e.g. to change trust settings for reading .hg/hgrc) | ||||
|
r43347 | cfgs = _parseconfig(req.ui, req.earlyoptions[b'config']) | ||
|
r39291 | |||
if req.repo: | ||||
# copy configs that were passed on the cmdline (--config) to | ||||
# the repo ui | ||||
for sec, name, val in cfgs: | ||||
|
r43347 | req.repo.ui.setconfig( | ||
sec, name, val, source=b'--config' | ||||
) | ||||
|
r19640 | |||
|
r39291 | # developer config: ui.debugger | ||
|
r43347 | debugger = ui.config(b"ui", b"debugger") | ||
|
r39291 | debugmod = pdb | ||
if not debugger or ui.plain(): | ||||
# if we are in HGPLAIN mode, then disable custom debugging | ||||
|
r43347 | debugger = b'pdb' | ||
elif req.earlyoptions[b'debugger']: | ||||
|
r39291 | # This import can be slow for fancy debuggers, so only | ||
# do it when absolutely necessary, i.e. when actual | ||||
# debugging has been requested | ||||
with demandimport.deactivated(): | ||||
try: | ||||
debugmod = __import__(debugger) | ||||
except ImportError: | ||||
|
r43346 | pass # Leave debugmod = pdb | ||
|
r19640 | |||
|
r39291 | debugtrace[debugger] = debugmod.set_trace | ||
debugmortem[debugger] = debugmod.post_mortem | ||||
|
r19640 | |||
|
r39291 | # enter the debugger before command execution | ||
|
r43347 | if req.earlyoptions[b'debugger']: | ||
|
r43346 | ui.warn( | ||
_( | ||||
|
r43347 | b"entering debugger - " | ||
b"type c to continue starting hg or h for help\n" | ||||
|
r43346 | ) | ||
) | ||||
|
r5178 | |||
|
r43346 | if ( | ||
|
r43347 | debugger != b'pdb' | ||
and debugtrace[debugger] == debugtrace[b'pdb'] | ||||
|
r43346 | ): | ||
ui.warn( | ||||
_( | ||||
|
r43347 | b"%s debugger specified " | ||
b"but its module was not found\n" | ||||
|
r43346 | ) | ||
% debugger | ||||
) | ||||
|
r39291 | with demandimport.deactivated(): | ||
debugtrace[debugger]() | ||||
try: | ||||
return _dispatch(req) | ||||
finally: | ||||
ui.flush() | ||||
|
r43346 | except: # re-raises | ||
|
r39291 | # enter the debugger when we hit an exception | ||
|
r43347 | if req.earlyoptions[b'debugger']: | ||
|
r39291 | traceback.print_exc() | ||
debugmortem[debugger](sys.exc_info()[2]) | ||||
raise | ||||
|
r43346 | |||
|
r39291 | return _callcatch(ui, _runcatchfunc) | ||
|
r29761 | |||
|
r43346 | |||
|
r32040 | def _callcatch(ui, func): | ||
|
r30520 | """like scmutil.callcatch but handles more high-level exceptions about | ||
config parsing and commands. besides, use handlecommandexception to handle | ||||
uncaught exceptions. | ||||
|
r29761 | """ | ||
try: | ||||
|
r30520 | return scmutil.callcatch(ui, func) | ||
|
r25660 | except error.AmbiguousCommand as inst: | ||
|
r43346 | ui.warn( | ||
|
r43347 | _(b"hg: command '%s' is ambiguous:\n %s\n") | ||
% (inst.args[0], b" ".join(inst.args[1])) | ||||
|
r43346 | ) | ||
|
r25660 | except error.CommandError as inst: | ||
|
r7645 | if inst.args[0]: | ||
|
r43347 | ui.pager(b'help') | ||
|
r32620 | msgbytes = pycompat.bytestr(inst.args[1]) | ||
|
r43347 | ui.warn(_(b"hg %s: %s\n") % (inst.args[0], msgbytes)) | ||
|
r14286 | commands.help_(ui, inst.args[0], full=False, command=True) | ||
|
r7645 | else: | ||
|
r43347 | ui.warn(_(b"hg: %s\n") % inst.args[1]) | ||
ui.warn(_(b"(use 'hg help -v' for a list of global options)\n")) | ||||
|
r30520 | except error.ParseError as inst: | ||
_formatparse(ui.warn, inst) | ||||
return -1 | ||||
|
r25660 | except error.UnknownCommand as inst: | ||
|
r43347 | nocmdmsg = _(b"hg: unknown command '%s'\n") % inst.args[0] | ||
|
r10364 | try: | ||
# check if the command is in a disabled extension | ||||
# (but don't check for extensions themselves) | ||||
|
r43346 | formatted = help.formattedhelp( | ||
ui, commands, inst.args[0], unknowncmd=True | ||||
) | ||||
|
r31060 | ui.warn(nocmdmsg) | ||
ui.write(formatted) | ||||
|
r26587 | except (error.UnknownCommand, error.Abort): | ||
|
r24222 | suggested = False | ||
if len(inst.args) == 2: | ||||
sim = _getsimilar(inst.args[1], inst.args[0]) | ||||
if sim: | ||||
|
r31060 | ui.warn(nocmdmsg) | ||
|
r27623 | _reportsimilar(ui.warn, sim) | ||
|
r24222 | suggested = True | ||
if not suggested: | ||||
|
r31060 | ui.warn(nocmdmsg) | ||
|
r43347 | ui.warn(_(b"(use 'hg help' for a list of commands)\n")) | ||
|
r30520 | except IOError: | ||
raise | ||||
|
r7645 | except KeyboardInterrupt: | ||
|
r28520 | raise | ||
|
r30520 | except: # probably re-raises | ||
|
r28784 | if not handlecommandexception(ui): | ||
raise | ||||
|
r5178 | |||
return -1 | ||||
|
r43346 | |||
|
r14265 | def aliasargs(fn, givenargs): | ||
|
r34089 | args = [] | ||
# only care about alias 'args', ignore 'args' set by extensions.wrapfunction | ||||
|
r43347 | if not util.safehasattr(fn, b'_origfunc'): | ||
|
r34089 | args = getattr(fn, 'args', args) | ||
|
r16294 | if args: | ||
|
r43347 | cmd = b' '.join(map(procutil.shellquote, args)) | ||
|
r14265 | |||
nums = [] | ||||
|
r43346 | |||
|
r14265 | def replacer(m): | ||
num = int(m.group(1)) - 1 | ||||
nums.append(num) | ||||
|
r16277 | if num < len(givenargs): | ||
return givenargs[num] | ||||
|
r43347 | raise error.Abort(_(b'too few arguments for command alias')) | ||
|
r43346 | |||
|
r31491 | cmd = re.sub(br'\$(\d+|\$)', replacer, cmd) | ||
|
r43346 | givenargs = [x for i, x in enumerate(givenargs) if i not in nums] | ||
|
r30678 | args = pycompat.shlexsplit(cmd) | ||
|
r14265 | return args + givenargs | ||
|
r8655 | |||
|
r43346 | |||
|
r22158 | def aliasinterpolate(name, args, cmd): | ||
'''interpolate args into cmd for shell aliases | ||||
This also handles $0, $@ and "$@". | ||||
''' | ||||
# util.interpolate can't deal with "$@" (with quotes) because it's only | ||||
# built to match prefix + patterns. | ||||
|
r43347 | replacemap = dict((b'$%d' % (i + 1), arg) for i, arg in enumerate(args)) | ||
replacemap[b'$0'] = name | ||||
replacemap[b'$$'] = b'$' | ||||
replacemap[b'$@'] = b' '.join(args) | ||||
|
r22158 | # Typical Unix shells interpolate "$@" (with quotes) as all the positional | ||
# parameters, separated out into words. Emulate the same behavior here by | ||||
# quoting the arguments individually. POSIX shells will then typically | ||||
# tokenize each argument into exactly one word. | ||||
|
r43347 | replacemap[b'"$@"'] = b' '.join(procutil.shellquote(arg) for arg in args) | ||
|
r22158 | # escape '\$' for regex | ||
|
r43347 | regex = b'|'.join(replacemap.keys()).replace(b'$', br'\$') | ||
|
r22158 | r = re.compile(regex) | ||
return r.sub(lambda x: replacemap[x.group()], cmd) | ||||
|
r43346 | |||
|
r8655 | class cmdalias(object): | ||
|
r37152 | def __init__(self, ui, name, definition, cmdtable, source): | ||
|
r12039 | self.name = self.cmd = name | ||
|
r43347 | self.cmdname = b'' | ||
|
r8655 | self.definition = definition | ||
|
r22160 | self.fn = None | ||
|
r29087 | self.givenargs = [] | ||
|
r8655 | self.opts = [] | ||
|
r43347 | self.help = b'' | ||
|
r22160 | self.badalias = None | ||
|
r22161 | self.unknowncmd = False | ||
|
r28828 | self.source = source | ||
|
r8655 | |||
try: | ||||
|
r12039 | aliases, entry = cmdutil.findcmd(self.name, cmdtable) | ||
|
r43376 | for alias, e in pycompat.iteritems(cmdtable): | ||
|
r12039 | if e is entry: | ||
self.cmd = alias | ||||
break | ||||
|
r8655 | self.shadows = True | ||
except error.UnknownCommand: | ||||
self.shadows = False | ||||
if not self.definition: | ||||
|
r43347 | self.badalias = _(b"no definition for alias '%s'") % self.name | ||
|
r8655 | return | ||
|
r43347 | if self.definition.startswith(b'!'): | ||
|
r37152 | shdef = self.definition[1:] | ||
|
r12536 | self.shell = True | ||
|
r43346 | |||
|
r11524 | def fn(ui, *args): | ||
|
r43347 | env = {b'HG_ARGS': b' '.join((self.name,) + args)} | ||
|
r43346 | |||
|
r11989 | def _checkvar(m): | ||
|
r43347 | if m.groups()[0] == b'$': | ||
|
r13392 | return m.group() | ||
elif int(m.groups()[0]) <= len(args): | ||||
|
r11989 | return m.group() | ||
else: | ||||
|
r43346 | ui.debug( | ||
|
r43347 | b"No argument found for substitution " | ||
b"of %i variable in alias '%s' definition.\n" | ||||
|
r43346 | % (int(m.groups()[0]), self.name) | ||
) | ||||
|
r43347 | return b'' | ||
|
r43346 | |||
|
r37152 | cmd = re.sub(br'\$(\d+|\$)', _checkvar, shdef) | ||
|
r22158 | cmd = aliasinterpolate(self.name, args, cmd) | ||
|
r43346 | return ui.system( | ||
|
r43347 | cmd, environ=env, blockedtag=b'alias_%s' % self.name | ||
|
r43346 | ) | ||
|
r11524 | self.fn = fn | ||
|
r40450 | self.alias = True | ||
|
r37152 | self._populatehelp(ui, name, shdef, self.fn) | ||
|
r11524 | return | ||
|
r21569 | try: | ||
|
r30678 | args = pycompat.shlexsplit(self.definition) | ||
|
r25660 | except ValueError as inst: | ||
|
r43347 | self.badalias = _(b"error in definition for alias '%s': %s") % ( | ||
|
r43346 | self.name, | ||
stringutil.forcebytestr(inst), | ||||
) | ||||
|
r21569 | return | ||
|
r35225 | earlyopts, args = _earlysplitopts(args) | ||
if earlyopts: | ||||
|
r43346 | self.badalias = _( | ||
|
r43347 | b"error in definition for alias '%s': %s may " | ||
b"only be given on the command line" | ||||
) % (self.name, b'/'.join(pycompat.ziplist(*earlyopts)[0])) | ||||
|
r35225 | return | ||
|
r12092 | self.cmdname = cmd = args.pop(0) | ||
|
r29087 | self.givenargs = args | ||
|
r8655 | |||
try: | ||||
|
r9993 | tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1] | ||
if len(tableentry) > 2: | ||||
|
r37152 | self.fn, self.opts, cmdhelp = tableentry | ||
|
r9993 | else: | ||
self.fn, self.opts = tableentry | ||||
|
r37152 | cmdhelp = None | ||
|
r9993 | |||
|
r40450 | self.alias = True | ||
|
r37152 | self._populatehelp(ui, name, cmd, self.fn, cmdhelp) | ||
|
r9876 | |||
|
r8655 | except error.UnknownCommand: | ||
|
r43347 | self.badalias = _( | ||
b"alias '%s' resolves to unknown command '%s'" | ||||
) % (self.name, cmd,) | ||||
|
r22161 | self.unknowncmd = True | ||
|
r8655 | except error.AmbiguousCommand: | ||
|
r43346 | self.badalias = _( | ||
|
r43347 | b"alias '%s' resolves to ambiguous command '%s'" | ||
|
r44787 | ) % (self.name, cmd,) | ||
|
r8655 | |||
|
r37152 | def _populatehelp(self, ui, name, cmd, fn, defaulthelp=None): | ||
|
r37157 | # confine strings to be passed to i18n.gettext() | ||
cfg = {} | ||||
|
r43347 | for k in (b'doc', b'help', b'category'): | ||
v = ui.config(b'alias', b'%s:%s' % (name, k), None) | ||||
|
r37157 | if v is None: | ||
continue | ||||
if not encoding.isasciistr(v): | ||||
|
r43346 | self.badalias = _( | ||
|
r43387 | b"non-ASCII character in alias definition '%s:%s'" | ||
|
r43346 | ) % (name, k) | ||
|
r37157 | return | ||
cfg[k] = v | ||||
|
r43347 | self.help = cfg.get(b'help', defaulthelp or b'') | ||
if self.help and self.help.startswith(b"hg " + cmd): | ||||
|
r37152 | # drop prefix in old-style help lines so hg shows the alias | ||
|
r43346 | self.help = self.help[4 + len(cmd) :] | ||
|
r37152 | |||
|
r43347 | self.owndoc = b'doc' in cfg | ||
doc = cfg.get(b'doc', pycompat.getdoc(fn)) | ||||
|
r37158 | if doc is not None: | ||
doc = pycompat.sysstr(doc) | ||||
self.__doc__ = doc | ||||
|
r37152 | |||
|
r43347 | self.helpcategory = cfg.get( | ||
b'category', registrar.command.CATEGORY_NONE | ||||
) | ||||
|
r40450 | |||
|
r29087 | @property | ||
def args(self): | ||||
|
r31629 | args = pycompat.maplist(util.expandpath, self.givenargs) | ||
|
r29087 | return aliasargs(self.fn, args) | ||
|
r28621 | def __getattr__(self, name): | ||
|
r43346 | adefaults = { | ||
|
r43906 | 'norepo': True, | ||
'intents': set(), | ||||
'optionalrepo': False, | ||||
'inferrepo': False, | ||||
|
r43346 | } | ||
|
r28621 | if name not in adefaults: | ||
raise AttributeError(name) | ||||
|
r43347 | if self.badalias or util.safehasattr(self, b'shell'): | ||
|
r28621 | return adefaults[name] | ||
return getattr(self.fn, name) | ||||
|
r8655 | def __call__(self, ui, *args, **opts): | ||
|
r22160 | if self.badalias: | ||
|
r22164 | hint = None | ||
|
r22161 | if self.unknowncmd: | ||
|
r10364 | try: | ||
# check if the command is in a disabled extension | ||||
|
r22163 | cmd, ext = extensions.disabledcmd(ui, self.cmdname)[:2] | ||
|
r43347 | hint = _(b"'%s' is provided by '%s' extension") % (cmd, ext) | ||
|
r10364 | except error.UnknownCommand: | ||
pass | ||||
|
r26587 | raise error.Abort(self.badalias, hint=hint) | ||
|
r8655 | if self.shadows: | ||
|
r43346 | ui.debug( | ||
|
r43347 | b"alias '%s' shadows command '%s'\n" % (self.name, self.cmdname) | ||
|
r43346 | ) | ||
|
r8655 | |||
|
r43346 | ui.log( | ||
|
r43347 | b'commandalias', | ||
b"alias '%s' expands to '%s'\n", | ||||
|
r43346 | self.name, | ||
self.definition, | ||||
) | ||||
|
r43347 | if util.safehasattr(self, b'shell'): | ||
|
r11989 | return self.fn(ui, *args, **opts) | ||
else: | ||||
|
r12093 | try: | ||
|
r21556 | return util.checksignature(self.fn)(ui, *args, **opts) | ||
|
r12093 | except error.SignatureError: | ||
|
r43347 | args = b' '.join([self.cmdname] + self.args) | ||
ui.debug(b"alias '%s' expands to '%s'\n" % (self.name, args)) | ||||
|
r12093 | raise | ||
|
r8655 | |||
|
r43346 | |||
|
r34307 | class lazyaliasentry(object): | ||
"""like a typical command entry (func, opts, help), but is lazy""" | ||||
|
r37152 | def __init__(self, ui, name, definition, cmdtable, source): | ||
self.ui = ui | ||||
|
r34307 | self.name = name | ||
self.definition = definition | ||||
self.cmdtable = cmdtable.copy() | ||||
self.source = source | ||||
|
r40450 | self.alias = True | ||
|
r34307 | |||
@util.propertycache | ||||
def _aliasdef(self): | ||||
|
r43346 | return cmdalias( | ||
self.ui, self.name, self.definition, self.cmdtable, self.source | ||||
) | ||||
|
r34307 | |||
def __getitem__(self, n): | ||||
aliasdef = self._aliasdef | ||||
if n == 0: | ||||
return aliasdef | ||||
elif n == 1: | ||||
return aliasdef.opts | ||||
elif n == 2: | ||||
return aliasdef.help | ||||
else: | ||||
raise IndexError | ||||
def __iter__(self): | ||||
for i in range(3): | ||||
yield self[i] | ||||
def __len__(self): | ||||
return 3 | ||||
|
r43346 | |||
|
r8655 | def addaliases(ui, cmdtable): | ||
# aliases are processed after extensions have been loaded, so they | ||||
# may use extension commands. Aliases can also use other alias definitions, | ||||
# but only if they have been defined prior to the current definition. | ||||
|
r43347 | for alias, definition in ui.configitems(b'alias', ignoresub=True): | ||
|
r15019 | try: | ||
|
r34307 | if cmdtable[alias].definition == definition: | ||
|
r15019 | continue | ||
except (KeyError, AttributeError): | ||||
# definition might not exist or it might not be a cmdalias | ||||
pass | ||||
|
r43347 | source = ui.configsource(b'alias', alias) | ||
|
r37152 | entry = lazyaliasentry(ui, alias, definition, cmdtable, source) | ||
|
r34307 | cmdtable[alias] = entry | ||
|
r8655 | |||
|
r43346 | |||
|
r5178 | def _parse(ui, args): | ||
options = {} | ||||
cmdoptions = {} | ||||
try: | ||||
args = fancyopts.fancyopts(args, commands.globalopts, options) | ||||
|
r30576 | except getopt.GetoptError as inst: | ||
|
r37102 | raise error.CommandError(None, stringutil.forcebytestr(inst)) | ||
|
r5178 | |||
if args: | ||||
cmd, args = args[0], args[1:] | ||||
|
r43346 | aliases, entry = cmdutil.findcmd( | ||
|
r43347 | cmd, commands.table, ui.configbool(b"ui", b"strict") | ||
|
r43346 | ) | ||
|
r5178 | cmd = aliases[0] | ||
|
r14265 | args = aliasargs(entry[0], args) | ||
|
r43347 | defaults = ui.config(b"defaults", cmd) | ||
|
r5178 | if defaults: | ||
|
r43346 | args = ( | ||
pycompat.maplist(util.expandpath, pycompat.shlexsplit(defaults)) | ||||
+ args | ||||
) | ||||
|
r9875 | c = list(entry[1]) | ||
|
r5178 | else: | ||
cmd = None | ||||
c = [] | ||||
# combine global options into local | ||||
for o in commands.globalopts: | ||||
c.append((o[0], o[1], options[o[1]], o[3])) | ||||
try: | ||||
|
r29822 | args = fancyopts.fancyopts(args, c, cmdoptions, gnu=True) | ||
|
r30576 | except getopt.GetoptError as inst: | ||
|
r37102 | raise error.CommandError(cmd, stringutil.forcebytestr(inst)) | ||
|
r5178 | |||
# separate global options back out | ||||
for o in commands.globalopts: | ||||
n = o[1] | ||||
options[n] = cmdoptions[n] | ||||
del cmdoptions[n] | ||||
|
r9875 | return (cmd, cmd and entry[0] or None, args, options, cmdoptions) | ||
|
r5178 | |||
|
r43346 | |||
|
r8137 | def _parseconfig(ui, config): | ||
|
r5178 | """parse the --config options from the command line""" | ||
|
r14753 | configs = [] | ||
|
r5178 | for cfg in config: | ||
try: | ||||
|
r43347 | name, value = [cfgelem.strip() for cfgelem in cfg.split(b'=', 1)] | ||
section, name = name.split(b'.', 1) | ||||
|
r5178 | if not section or not name: | ||
raise IndexError | ||||
|
r43347 | ui.setconfig(section, name, value, b'--config') | ||
|
r14753 | configs.append((section, name, value)) | ||
|
r5178 | except (IndexError, ValueError): | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'malformed --config option: %r ' | ||
b'(use --config section.name=value)' | ||||
|
r43346 | ) | ||
% pycompat.bytestr(cfg) | ||||
) | ||||
|
r5178 | |||
|
r14753 | return configs | ||
|
r43346 | |||
|
r35224 | def _earlyparseopts(ui, args): | ||
|
r35180 | options = {} | ||
|
r43346 | fancyopts.fancyopts( | ||
args, | ||||
commands.globalopts, | ||||
options, | ||||
|
r43347 | gnu=not ui.plain(b'strictflags'), | ||
|
r43346 | early=True, | ||
|
r43347 | optaliases={b'repository': [b'repo']}, | ||
|
r43346 | ) | ||
|
r35180 | return options | ||
|
r43346 | |||
|
r35225 | def _earlysplitopts(args): | ||
"""Split args into a list of possible early options and remainder args""" | ||||
|
r43347 | shortoptions = b'R:' | ||
|
r35225 | # TODO: perhaps 'debugger' should be included | ||
|
r43347 | longoptions = [b'cwd=', b'repository=', b'repo=', b'config='] | ||
|
r43346 | return fancyopts.earlygetopt( | ||
args, shortoptions, longoptions, gnu=True, keepsep=True | ||||
) | ||||
|
r5178 | |||
|
r11330 | def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions): | ||
|
r7819 | # run pre-hook, and abort if it fails | ||
|
r43346 | hook.hook( | ||
lui, | ||||
repo, | ||||
|
r43347 | b"pre-%s" % cmd, | ||
|
r43346 | True, | ||
|
r43347 | args=b" ".join(fullargs), | ||
|
r43346 | pats=cmdpats, | ||
opts=cmdoptions, | ||||
) | ||||
|
r29129 | try: | ||
ret = _runcommand(ui, options, cmd, d) | ||||
# run post-hook, passing command result | ||||
|
r43346 | hook.hook( | ||
lui, | ||||
repo, | ||||
|
r43347 | b"post-%s" % cmd, | ||
|
r43346 | False, | ||
|
r43347 | args=b" ".join(fullargs), | ||
|
r43346 | result=ret, | ||
pats=cmdpats, | ||||
opts=cmdoptions, | ||||
) | ||||
|
r29129 | except Exception: | ||
# run failure hook and re-raise | ||||
|
r43346 | hook.hook( | ||
lui, | ||||
repo, | ||||
|
r43347 | b"fail-%s" % cmd, | ||
|
r43346 | False, | ||
|
r43347 | args=b" ".join(fullargs), | ||
|
r43346 | pats=cmdpats, | ||
opts=cmdoptions, | ||||
) | ||||
|
r29129 | raise | ||
|
r7819 | return ret | ||
|
r43346 | |||
|
r28263 | def _getlocal(ui, rpath, wd=None): | ||
|
r12536 | """Return (path, local ui object) for the given target path. | ||
|
r12770 | |||
|
r12536 | Takes paths in [cwd]/.hg/hgrc into account." | ||
""" | ||||
|
r28263 | if wd is None: | ||
try: | ||||
|
r39843 | wd = encoding.getcwd() | ||
|
r28263 | except OSError as e: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"error getting current working directory: %s") | ||
|
r43346 | % encoding.strtolocal(e.strerror) | ||
) | ||||
r44728 | ||||
|
r43347 | path = cmdutil.findrepo(wd) or b"" | ||
|
r5178 | if not path: | ||
lui = ui | ||||
|
r9436 | else: | ||
|
r12636 | lui = ui.copy() | ||
r44728 | if rcutil.use_repo_hgrc(): | |||
lui.readconfig(os.path.join(path, b".hg", b"hgrc"), path) | ||||
|
r5178 | |||
|
r35062 | if rpath: | ||
path = lui.expandpath(rpath) | ||||
|
r8190 | lui = ui.copy() | ||
r44728 | if rcutil.use_repo_hgrc(): | |||
lui.readconfig(os.path.join(path, b".hg", b"hgrc"), path) | ||||
|
r5178 | |||
|
r12536 | return path, lui | ||
|
r43346 | |||
|
r29132 | def _checkshellalias(lui, ui, args): | ||
"""Return the function to run the shell alias, if it is required""" | ||||
|
r12536 | options = {} | ||
|
r12748 | |||
try: | ||||
args = fancyopts.fancyopts(args, commands.globalopts, options) | ||||
|
r30576 | except getopt.GetoptError: | ||
|
r12748 | return | ||
|
r12536 | |||
if not args: | ||||
return | ||||
|
r29132 | cmdtable = commands.table | ||
|
r12536 | |||
cmd = args[0] | ||||
try: | ||||
|
r43347 | strict = ui.configbool(b"ui", b"strict") | ||
|
r22377 | aliases, entry = cmdutil.findcmd(cmd, cmdtable, strict) | ||
|
r12932 | except (error.AmbiguousCommand, error.UnknownCommand): | ||
|
r12536 | return | ||
cmd = aliases[0] | ||||
fn = entry[0] | ||||
|
r43347 | if cmd and util.safehasattr(fn, b'shell'): | ||
|
r35063 | # shell alias shouldn't receive early options which are consumed by hg | ||
|
r35225 | _earlyopts, args = _earlysplitopts(args) | ||
|
r12536 | d = lambda: fn(ui, *args[1:]) | ||
|
r43346 | return lambda: runcommand( | ||
lui, None, cmd, args[:1], ui, options, d, [], {} | ||||
) | ||||
|
r12536 | |||
|
r14439 | def _dispatch(req): | ||
|
r14438 | args = req.args | ||
|
r14439 | ui = req.ui | ||
|
r12536 | # check for cwd | ||
|
r43347 | cwd = req.earlyoptions[b'cwd'] | ||
|
r12536 | if cwd: | ||
|
r35062 | os.chdir(cwd) | ||
|
r12536 | |||
|
r43347 | rpath = req.earlyoptions[b'repository'] | ||
|
r12536 | path, lui = _getlocal(ui, rpath) | ||
|
r32291 | uis = {ui, lui} | ||
|
r30933 | |||
if req.repo: | ||||
uis.add(req.repo.ui) | ||||
|
r43346 | if ( | ||
|
r43347 | req.earlyoptions[b'verbose'] | ||
or req.earlyoptions[b'debug'] | ||||
or req.earlyoptions[b'quiet'] | ||||
|
r43346 | ): | ||
|
r43347 | for opt in (b'verbose', b'debug', b'quiet'): | ||
|
r38552 | val = pycompat.bytestr(bool(req.earlyoptions[opt])) | ||
for ui_ in uis: | ||||
|
r43347 | ui_.setconfig(b'ui', opt, val, b'--' + opt) | ||
|
r38552 | |||
|
r43347 | if req.earlyoptions[b'profile']: | ||
|
r30933 | for ui_ in uis: | ||
|
r43347 | ui_.setconfig(b'profiling', b'enabled', b'true', b'--profile') | ||
|
r30933 | |||
|
r43347 | profile = lui.configbool(b'profiling', b'enabled') | ||
r32788 | with profiling.profile(lui, enabled=profile) as profiler: | |||
|
r30934 | # Configure extensions in phases: uisetup, extsetup, cmdtable, and | ||
|
r33053 | # reposetup | ||
|
r30934 | extensions.loadall(lui) | ||
# Propagate any changes to lui.__class__ by extensions | ||||
ui.__class__ = lui.__class__ | ||||
|
r5828 | |||
|
r30934 | # (uisetup and extsetup are handled in extensions.loadall) | ||
|
r5828 | |||
|
r30934 | # (reposetup is handled in hg.repository) | ||
|
r9410 | |||
|
r30934 | addaliases(lui, commands.table) | ||
|
r8655 | |||
|
r30934 | # All aliases and commands are completely defined, now. | ||
# Check abbreviation/ambiguity of shell alias. | ||||
shellaliasfn = _checkshellalias(lui, ui, args) | ||||
if shellaliasfn: | ||||
|
r40760 | # no additional configs will be set, set up the ui instances | ||
for ui_ in uis: | ||||
extensions.populateui(ui_) | ||||
|
r30006 | return shellaliasfn() | ||
|
r22377 | |||
|
r30934 | # check for fallback encoding | ||
|
r43347 | fallback = lui.config(b'ui', b'fallbackencoding') | ||
|
r30934 | if fallback: | ||
encoding.fallbackencoding = fallback | ||||
|
r5178 | |||
|
r30934 | fullargs = args | ||
cmd, func, args, options, cmdoptions = _parse(lui, args) | ||||
|
r5178 | |||
|
r40438 | # store the canonical command name in request object for later access | ||
req.canonical_command = cmd | ||||
|
r43347 | if options[b"config"] != req.earlyoptions[b"config"]: | ||
raise error.Abort(_(b"option --config may not be abbreviated!")) | ||||
if options[b"cwd"] != req.earlyoptions[b"cwd"]: | ||||
raise error.Abort(_(b"option --cwd may not be abbreviated!")) | ||||
if options[b"repository"] != req.earlyoptions[b"repository"]: | ||||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b"option -R has to be separated from other options (e.g. not " | ||
b"-qR) and --repository may only be abbreviated as --repo!" | ||||
|
r43346 | ) | ||
) | ||||
|
r43347 | if options[b"debugger"] != req.earlyoptions[b"debugger"]: | ||
raise error.Abort(_(b"option --debugger may not be abbreviated!")) | ||||
|
r35059 | # don't validate --profile/--traceback, which can be enabled from now | ||
|
r5178 | |||
|
r43347 | if options[b"encoding"]: | ||
encoding.encoding = options[b"encoding"] | ||||
if options[b"encodingmode"]: | ||||
encoding.encodingmode = options[b"encodingmode"] | ||||
if options[b"time"]: | ||||
|
r43346 | |||
|
r30934 | def get_times(): | ||
t = os.times() | ||||
if t[4] == 0.0: | ||||
|
r44469 | # Windows leaves this as zero, so use time.perf_counter() | ||
t = (t[0], t[1], t[2], t[3], util.timer()) | ||||
|
r30934 | return t | ||
|
r43346 | |||
|
r30934 | s = get_times() | ||
|
r43346 | |||
|
r30934 | def print_time(): | ||
t = get_times() | ||||
ui.warn( | ||||
|
r43347 | _(b"time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") | ||
|
r43346 | % ( | ||
t[4] - s[4], | ||||
t[0] - s[0], | ||||
t[2] - s[2], | ||||
t[1] - s[1], | ||||
t[3] - s[3], | ||||
) | ||||
) | ||||
|
r31958 | ui.atexit(print_time) | ||
|
r43347 | if options[b"profile"]: | ||
r32787 | profiler.start() | |||
|
r5178 | |||
|
r38552 | # if abbreviated version of this were used, take them in account, now | ||
|
r43347 | if options[b'verbose'] or options[b'debug'] or options[b'quiet']: | ||
for opt in (b'verbose', b'debug', b'quiet'): | ||||
|
r38552 | if options[opt] == req.earlyoptions[opt]: | ||
continue | ||||
|
r35916 | val = pycompat.bytestr(bool(options[opt])) | ||
|
r30934 | for ui_ in uis: | ||
|
r43347 | ui_.setconfig(b'ui', opt, val, b'--' + opt) | ||
|
r30934 | |||
|
r43347 | if options[b'traceback']: | ||
|
r14752 | for ui_ in uis: | ||
|
r43347 | ui_.setconfig(b'ui', b'traceback', b'on', b'--traceback') | ||
|
r14992 | |||
|
r43347 | if options[b'noninteractive']: | ||
|
r30934 | for ui_ in uis: | ||
|
r43347 | ui_.setconfig(b'ui', b'interactive', b'off', b'-y') | ||
|
r5178 | |||
|
r43347 | if cmdoptions.get(b'insecure', False): | ||
|
r30934 | for ui_ in uis: | ||
ui_.insecureconnections = True | ||||
|
r13328 | |||
|
r32404 | # setup color handling before pager, because setting up pager | ||
# might cause incorrect console information | ||||
|
r43347 | coloropt = options[b'color'] | ||
|
r31105 | for ui_ in uis: | ||
|
r31110 | if coloropt: | ||
|
r43347 | ui_.setconfig(b'ui', b'color', coloropt, b'--color') | ||
|
r31110 | color.setup(ui_) | ||
|
r31105 | |||
|
r43347 | if stringutil.parsebool(options[b'pager']): | ||
|
r33622 | # ui.pager() expects 'internal-always-' prefix in this case | ||
|
r43347 | ui.pager(b'internal-always-' + cmd) | ||
elif options[b'pager'] != b'auto': | ||||
|
r34639 | for ui_ in uis: | ||
ui_.disablepager() | ||||
|
r32404 | |||
|
r40760 | # configs are fully loaded, set up the ui instances | ||
for ui_ in uis: | ||||
extensions.populateui(ui_) | ||||
|
r43347 | if options[b'version']: | ||
|
r30934 | return commands.version_(ui) | ||
|
r43347 | if options[b'help']: | ||
|
r30934 | return commands.help_(ui, cmd, command=cmd is not None) | ||
elif not cmd: | ||||
|
r43347 | return commands.help_(ui, b'shortlist') | ||
|
r5178 | |||
|
r30005 | repo = None | ||
cmdpats = args[:] | ||||
|
r44105 | assert func is not None # help out pytype | ||
|
r30485 | if not func.norepo: | ||
|
r30005 | # use the repo from the request only if we don't have -R | ||
if not rpath and not cwd: | ||||
repo = req.repo | ||||
|
r14510 | |||
|
r30005 | if repo: | ||
# set the descriptors of the repo ui to those of ui | ||||
repo.ui.fin = ui.fin | ||||
repo.ui.fout = ui.fout | ||||
repo.ui.ferr = ui.ferr | ||||
|
r40623 | repo.ui.fmsg = ui.fmsg | ||
|
r30005 | else: | ||
try: | ||||
|
r43346 | repo = hg.repository( | ||
ui, | ||||
path=path, | ||||
presetupfuncs=req.prereposetups, | ||||
intents=func.intents, | ||||
) | ||||
|
r30005 | if not repo.local(): | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"repository '%s' is not local") % path | ||
|
r43346 | ) | ||
repo.ui.setconfig( | ||||
|
r43347 | b"bundle", b"mainreporoot", repo.root, b'repo' | ||
|
r43346 | ) | ||
|
r30005 | except error.RequirementError: | ||
|
r26142 | raise | ||
|
r30005 | except error.RepoError: | ||
|
r43346 | if rpath: # invalid -R path | ||
|
r30005 | raise | ||
|
r30485 | if not func.optionalrepo: | ||
if func.inferrepo and args and not path: | ||||
|
r30005 | # try to infer -R from command args | ||
|
r35150 | repos = pycompat.maplist(cmdutil.findrepo, args) | ||
|
r30005 | guess = repos[0] | ||
if guess and repos.count(guess) == len(repos): | ||||
|
r43347 | req.args = [b'--repository', guess] + fullargs | ||
req.earlyoptions[b'repository'] = guess | ||||
|
r30005 | return _dispatch(req) | ||
if not path: | ||||
|
r43346 | raise error.RepoError( | ||
_( | ||||
|
r43347 | b"no repository found in" | ||
b" '%s' (.hg not found)" | ||||
|
r43346 | ) | ||
% encoding.getcwd() | ||||
) | ||||
|
r30005 | raise | ||
if repo: | ||||
ui = repo.ui | ||||
|
r43347 | if options[b'hidden']: | ||
|
r30005 | repo = repo.unfiltered() | ||
args.insert(0, repo) | ||||
elif rpath: | ||||
|
r43347 | ui.warn(_(b"warning: --repository ignored\n")) | ||
|
r7388 | |||
|
r31492 | msg = _formatargs(fullargs) | ||
|
r43347 | ui.log(b"command", b'%s\n', msg) | ||
|
r30586 | strcmdopt = pycompat.strkwargs(cmdoptions) | ||
d = lambda: util.checksignature(func)(ui, *args, **strcmdopt) | ||||
|
r30005 | try: | ||
|
r43346 | return runcommand( | ||
lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions | ||||
) | ||||
|
r30005 | finally: | ||
if repo and repo != req.repo: | ||||
repo.close() | ||||
|
r5178 | |||
|
r43346 | |||
|
r5178 | def _runcommand(ui, options, cmd, cmdfunc): | ||
|
r29784 | """Run a command function, possibly with profiling enabled.""" | ||
|
r30006 | try: | ||
|
r43532 | with tracing.log("Running %s command" % cmd): | ||
|
r39548 | return cmdfunc() | ||
|
r30006 | except error.SignatureError: | ||
|
r43347 | raise error.CommandError(cmd, _(b'invalid arguments')) | ||
|
r28784 | |||
|
r43346 | |||
|
r28821 | def _exceptionwarning(ui): | ||
"""Produce a warning message for the current active exception""" | ||||
|
r28784 | |||
# For compatibility checking, we discard the portion of the hg | ||||
# version after the + on the assumption that if a "normal | ||||
# user" is running a build with a + in it the packager | ||||
# probably built from fairly close to a tag and anyone with a | ||||
# 'make local' copy of hg (where the version number can be out | ||||
# of date) will be clueful enough to notice the implausible | ||||
# version number and try updating. | ||||
ct = util.versiontuple(n=2) | ||||
|
r43347 | worst = None, ct, b'' | ||
if ui.config(b'ui', b'supportcontact') is None: | ||||
|
r28784 | for name, mod in extensions.extensions(): | ||
|
r35917 | # 'testedwith' should be bytes, but not all extensions are ported | ||
# to py3 and we don't want UnicodeException because of that. | ||||
|
r43347 | testedwith = stringutil.forcebytestr( | ||
getattr(mod, 'testedwith', b'') | ||||
) | ||||
report = getattr(mod, 'buglink', _(b'the extension author.')) | ||||
|
r28784 | if not testedwith.strip(): | ||
# We found an untested extension. It's likely the culprit. | ||||
|
r43347 | worst = name, b'unknown', report | ||
|
r28784 | break | ||
# Never blame on extensions bundled with Mercurial. | ||||
|
r29884 | if extensions.ismoduleinternal(mod): | ||
|
r28784 | continue | ||
tested = [util.versiontuple(t, 2) for t in testedwith.split()] | ||||
if ct in tested: | ||||
continue | ||||
lower = [t for t in tested if t < ct] | ||||
nearest = max(lower or tested) | ||||
if worst[0] is None or nearest < worst[1]: | ||||
worst = name, nearest, report | ||||
if worst[0] is not None: | ||||
name, testedwith, report = worst | ||||
|
r31179 | if not isinstance(testedwith, (bytes, str)): | ||
|
r43347 | testedwith = b'.'.join( | ||
|
r43346 | [stringutil.forcebytestr(c) for c in testedwith] | ||
) | ||||
warning = _( | ||||
|
r43347 | b'** Unknown exception encountered with ' | ||
b'possibly-broken third-party extension %s\n' | ||||
b'** which supports versions %s of Mercurial.\n' | ||||
b'** Please disable %s and try your action again.\n' | ||||
b'** If that fixes the bug please report it to %s\n' | ||||
|
r43346 | ) % (name, testedwith, name, stringutil.forcebytestr(report)) | ||
|
r28784 | else: | ||
|
r43347 | bugtracker = ui.config(b'ui', b'supportcontact') | ||
|
r28784 | if bugtracker is None: | ||
|
r43347 | bugtracker = _(b"https://mercurial-scm.org/wiki/BugTracker") | ||
|
r43346 | warning = ( | ||
_( | ||||
|
r43347 | b"** unknown exception encountered, " | ||
b"please report by visiting\n** " | ||||
|
r43346 | ) | ||
+ bugtracker | ||||
|
r43347 | + b'\n' | ||
|
r43346 | ) | ||
|
r43347 | sysversion = pycompat.sysbytes(sys.version).replace(b'\n', b'') | ||
|
r43346 | warning += ( | ||
|
r43347 | (_(b"** Python %s\n") % sysversion) | ||
+ (_(b"** Mercurial Distributed SCM (version %s)\n") % util.version()) | ||||
|
r43346 | + ( | ||
|
r43347 | _(b"** Extensions loaded: %s\n") | ||
% b", ".join([x[0] for x in extensions.extensions()]) | ||||
|
r43346 | ) | ||
) | ||||
|
r28821 | return warning | ||
|
r43346 | |||
|
r28821 | def handlecommandexception(ui): | ||
"""Produce a warning message for broken commands | ||||
Called when handling an exception; the exception is reraised if | ||||
this function returns False, ignored otherwise. | ||||
""" | ||||
warning = _exceptionwarning(ui) | ||||
|
r43346 | ui.log( | ||
|
r43347 | b"commandexception", | ||
b"%s\n%s\n", | ||||
|
r43346 | warning, | ||
pycompat.sysbytes(traceback.format_exc()), | ||||
) | ||||
|
r28784 | ui.warn(warning) | ||
return False # re-raise the exception | ||||