dispatch.py
869 lines
| 30.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / dispatch.py
Matt Mackall
|
r5178 | # dispatch.py - command dispatching for mercurial | ||
# | ||||
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
Martin Geisler
|
r8225 | # This software may be used and distributed according to the terms of the | ||
Matt Mackall
|
r10263 | # GNU General Public License version 2 or any later version. | ||
Matt Mackall
|
r5178 | |||
from i18n import _ | ||||
Steve Losh
|
r11989 | import os, sys, atexit, signal, pdb, socket, errno, shlex, time, traceback, re | ||
Peter Arrenbrecht
|
r7873 | import util, commands, hg, fancyopts, extensions, hook, error | ||
Matt Mackall
|
r7948 | import cmdutil, encoding | ||
Benoit Boissinot
|
r10651 | import ui as uimod | ||
Matt Mackall
|
r5178 | |||
Idan Kamara
|
r14438 | class request(object): | ||
Brodie Rao
|
r16683 | def __init__(self, args, ui=None, repo=None, fin=None, fout=None, | ||
ferr=None): | ||||
Idan Kamara
|
r14438 | self.args = args | ||
Idan Kamara
|
r14439 | self.ui = ui | ||
Idan Kamara
|
r14510 | self.repo = repo | ||
Idan Kamara
|
r14438 | |||
Idan Kamara
|
r14613 | # input/output/error streams | ||
self.fin = fin | ||||
self.fout = fout | ||||
self.ferr = ferr | ||||
Matt Mackall
|
r5178 | def run(): | ||
"run the command in sys.argv" | ||||
Mads Kiilerich
|
r15439 | sys.exit((dispatch(request(sys.argv[1:])) or 0) & 255) | ||
Matt Mackall
|
r5178 | |||
Idan Kamara
|
r14438 | def dispatch(req): | ||
"run the command specified in req.args" | ||||
Idan Kamara
|
r14615 | if req.ferr: | ||
ferr = req.ferr | ||||
elif req.ui: | ||||
ferr = req.ui.ferr | ||||
else: | ||||
ferr = sys.stderr | ||||
Matt Mackall
|
r5178 | try: | ||
Idan Kamara
|
r14439 | if not req.ui: | ||
req.ui = uimod.ui() | ||||
Idan Kamara
|
r14438 | if '--traceback' in req.args: | ||
Idan Kamara
|
r14439 | req.ui.setconfig('ui', 'traceback', 'on') | ||
Idan Kamara
|
r14615 | |||
# 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 | ||||
Matt Mackall
|
r5178 | except util.Abort, inst: | ||
Idan Kamara
|
r14615 | ferr.write(_("abort: %s\n") % inst) | ||
Benoit Boissinot
|
r11574 | if inst.hint: | ||
Idan Kamara
|
r14615 | ferr.write(_("(%s)\n") % inst.hint) | ||
Matt Mackall
|
r5178 | return -1 | ||
Matt Mackall
|
r11288 | except error.ParseError, inst: | ||
if len(inst.args) > 1: | ||||
Idan Kamara
|
r14615 | ferr.write(_("hg: parse error at %s: %s\n") % | ||
Matt Mackall
|
r11288 | (inst.args[1], inst.args[0])) | ||
else: | ||||
Idan Kamara
|
r14615 | ferr.write(_("hg: parse error: %s\n") % inst.args[0]) | ||
Martin Geisler
|
r9470 | return -1 | ||
Idan Kamara
|
r14615 | |||
Durham Goode
|
r19229 | msg = ' '.join(' ' in a and repr(a) or a for a in req.args) | ||
starttime = time.time() | ||||
ret = None | ||||
try: | ||||
ret = _runcatch(req) | ||||
return ret | ||||
finally: | ||||
duration = time.time() - starttime | ||||
req.ui.log("commandfinish", "%s exited %s after %0.2f seconds\n", | ||||
msg, ret or 0, duration) | ||||
Matt Mackall
|
r5178 | |||
Idan Kamara
|
r14439 | def _runcatch(req): | ||
Matt Mackall
|
r5178 | def catchterm(*args): | ||
Matt Mackall
|
r7644 | raise error.SignalInterrupt | ||
Matt Mackall
|
r5178 | |||
Idan Kamara
|
r14439 | ui = req.ui | ||
Simon Heimberg
|
r10952 | try: | ||
for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM': | ||||
num = getattr(signal, name, None) | ||||
if num: | ||||
signal.signal(num, catchterm) | ||||
except ValueError: | ||||
pass # happens if called in a thread | ||||
Matt Mackall
|
r5178 | |||
try: | ||||
try: | ||||
# enter the debugger before command execution | ||||
Idan Kamara
|
r14438 | if '--debugger' in req.args: | ||
Mads Kiilerich
|
r11495 | ui.warn(_("entering debugger - " | ||
"type c to continue starting hg or h for help\n")) | ||||
Matt Mackall
|
r5178 | pdb.set_trace() | ||
try: | ||||
Idan Kamara
|
r14439 | return _dispatch(req) | ||
Matt Mackall
|
r5178 | finally: | ||
ui.flush() | ||||
Brodie Rao
|
r16705 | except: # re-raises | ||
Matt Mackall
|
r5178 | # enter the debugger when we hit an exception | ||
Idan Kamara
|
r14438 | if '--debugger' in req.args: | ||
Mads Kiilerich
|
r11494 | traceback.print_exc() | ||
Matt Mackall
|
r5178 | pdb.post_mortem(sys.exc_info()[2]) | ||
Matt Mackall
|
r8206 | ui.traceback() | ||
Matt Mackall
|
r5178 | raise | ||
Matt Mackall
|
r7645 | # Global exception handling, alphabetically | ||
# Mercurial-specific first, followed by built-in and library exceptions | ||||
Matt Mackall
|
r7643 | except error.AmbiguousCommand, inst: | ||
Matt Mackall
|
r5178 | ui.warn(_("hg: command '%s' is ambiguous:\n %s\n") % | ||
(inst.args[0], " ".join(inst.args[1]))) | ||||
Matt Mackall
|
r11288 | except error.ParseError, inst: | ||
if len(inst.args) > 1: | ||||
ui.warn(_("hg: parse error at %s: %s\n") % | ||||
(inst.args[1], inst.args[0])) | ||||
else: | ||||
ui.warn(_("hg: parse error: %s\n") % inst.args[0]) | ||||
return -1 | ||||
Matt Mackall
|
r7640 | except error.LockHeld, inst: | ||
Matt Mackall
|
r5178 | if inst.errno == errno.ETIMEDOUT: | ||
reason = _('timed out waiting for lock held by %s') % inst.locker | ||||
else: | ||||
reason = _('lock held by %s') % inst.locker | ||||
ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason)) | ||||
Matt Mackall
|
r7640 | except error.LockUnavailable, inst: | ||
Matt Mackall
|
r5178 | ui.warn(_("abort: could not lock %s: %s\n") % | ||
(inst.desc or inst.filename, inst.strerror)) | ||||
Matt Mackall
|
r11287 | except error.CommandError, inst: | ||
Matt Mackall
|
r7645 | if inst.args[0]: | ||
ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1])) | ||||
Martin Geisler
|
r14286 | commands.help_(ui, inst.args[0], full=False, command=True) | ||
Matt Mackall
|
r7645 | else: | ||
ui.warn(_("hg: %s\n") % inst.args[1]) | ||||
commands.help_(ui, 'shortlist') | ||||
Andrew Pritchard
|
r15017 | except error.OutOfBandError, inst: | ||
Mads Kiilerich
|
r15497 | ui.warn(_("abort: remote error:\n")) | ||
Andrew Pritchard
|
r15017 | ui.warn(''.join(inst.args)) | ||
Matt Mackall
|
r7645 | except error.RepoError, inst: | ||
ui.warn(_("abort: %s!\n") % inst) | ||||
Pierre-Yves David
|
r14761 | if inst.hint: | ||
ui.warn(_("(%s)\n") % inst.hint) | ||||
Matt Mackall
|
r7645 | except error.ResponseError, inst: | ||
ui.warn(_("abort: %s") % inst.args[0]) | ||||
if not isinstance(inst.args[1], basestring): | ||||
ui.warn(" %r\n" % (inst.args[1],)) | ||||
elif not inst.args[1]: | ||||
ui.warn(_(" empty string\n")) | ||||
else: | ||||
ui.warn("\n%r\n" % util.ellipsis(inst.args[1])) | ||||
Matt Mackall
|
r7633 | except error.RevlogError, inst: | ||
Matt Mackall
|
r5178 | ui.warn(_("abort: %s!\n") % inst) | ||
Matt Mackall
|
r7644 | except error.SignalInterrupt: | ||
Matt Mackall
|
r5178 | ui.warn(_("killed!\n")) | ||
Matt Mackall
|
r7645 | except error.UnknownCommand, inst: | ||
ui.warn(_("hg: unknown command '%s'\n") % inst.args[0]) | ||||
Brodie Rao
|
r10364 | try: | ||
# check if the command is in a disabled extension | ||||
# (but don't check for extensions themselves) | ||||
commands.help_(ui, inst.args[0], unknowncmd=True) | ||||
except error.UnknownCommand: | ||||
commands.help_(ui, 'shortlist') | ||||
Augie Fackler
|
r18932 | except error.InterventionRequired, inst: | ||
ui.warn("%s\n" % inst) | ||||
Augie Fackler
|
r18935 | return 1 | ||
Matt Mackall
|
r7645 | except util.Abort, inst: | ||
ui.warn(_("abort: %s\n") % inst) | ||||
Benoit Boissinot
|
r11574 | if inst.hint: | ||
Patrick Mezard
|
r11683 | ui.warn(_("(%s)\n") % inst.hint) | ||
Matt Mackall
|
r7645 | except ImportError, inst: | ||
Dan Villiom Podlaski Christiansen
|
r11053 | ui.warn(_("abort: %s!\n") % inst) | ||
Matt Mackall
|
r7645 | m = str(inst).split()[-1] | ||
if m in "mpatch bdiff".split(): | ||||
ui.warn(_("(did you forget to compile extensions?)\n")) | ||||
elif m in "zlib".split(): | ||||
ui.warn(_("(is your Python install correct?)\n")) | ||||
Matt Mackall
|
r5178 | except IOError, inst: | ||
Augie Fackler
|
r14950 | if util.safehasattr(inst, "code"): | ||
Matt Mackall
|
r5178 | ui.warn(_("abort: %s\n") % inst) | ||
Augie Fackler
|
r14950 | elif util.safehasattr(inst, "reason"): | ||
Matt Mackall
|
r5178 | try: # usually it is in the form (errno, strerror) | ||
reason = inst.reason.args[1] | ||||
Dan Villiom Podlaski Christiansen
|
r14096 | except (AttributeError, IndexError): | ||
Mads Kiilerich
|
r17299 | # it might be anything, for example a string | ||
Matt Mackall
|
r5178 | reason = inst.reason | ||
ui.warn(_("abort: error: %s\n") % reason) | ||||
Augie Fackler
|
r14950 | elif util.safehasattr(inst, "args") and inst.args[0] == errno.EPIPE: | ||
Matt Mackall
|
r5178 | if ui.debugflag: | ||
ui.warn(_("broken pipe\n")) | ||||
elif getattr(inst, "strerror", None): | ||||
if getattr(inst, "filename", None): | ||||
ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename)) | ||||
else: | ||||
ui.warn(_("abort: %s\n") % inst.strerror) | ||||
else: | ||||
raise | ||||
except OSError, inst: | ||||
Mads Kiilerich
|
r18227 | if getattr(inst, "filename", None) is not None: | ||
ui.warn(_("abort: %s: '%s'\n") % (inst.strerror, inst.filename)) | ||||
Matt Mackall
|
r5178 | else: | ||
ui.warn(_("abort: %s\n") % inst.strerror) | ||||
Matt Mackall
|
r7645 | except KeyboardInterrupt: | ||
try: | ||||
ui.warn(_("interrupted!\n")) | ||||
except IOError, inst: | ||||
if inst.errno == errno.EPIPE: | ||||
if ui.debugflag: | ||||
ui.warn(_("\nbroken pipe\n")) | ||||
else: | ||||
raise | ||||
Matt Mackall
|
r5633 | except MemoryError: | ||
ui.warn(_("abort: out of memory\n")) | ||||
Matt Mackall
|
r5178 | except SystemExit, inst: | ||
# Commands shouldn't sys.exit directly, but give a return code. | ||||
# Just in case catch this and and pass exit code to caller. | ||||
return inst.code | ||||
Matt Mackall
|
r7645 | except socket.error, inst: | ||
ui.warn(_("abort: %s\n") % inst.args[-1]) | ||||
Brodie Rao
|
r16705 | except: # re-raises | ||
Augie Fackler
|
r16744 | myver = util.version() | ||
# 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. | ||||
compare = myver.split('+')[0] | ||||
ct = tuplever(compare) | ||||
worst = None, ct, '' | ||||
for name, mod in extensions.extensions(): | ||||
Pierre-Yves David
|
r18224 | testedwith = getattr(mod, 'testedwith', '') | ||
Augie Fackler
|
r16744 | report = getattr(mod, 'buglink', _('the extension author.')) | ||
Pierre-Yves David
|
r18224 | if not testedwith.strip(): | ||
Augie Fackler
|
r16744 | # We found an untested extension. It's likely the culprit. | ||
Pierre-Yves David
|
r18224 | worst = name, 'unknown', report | ||
Augie Fackler
|
r16744 | break | ||
if compare not in testedwith.split() and testedwith != 'internal': | ||||
tested = [tuplever(v) for v in testedwith.split()] | ||||
Thomas Arendsen Hein
|
r17228 | lower = [t for t in tested if t < ct] | ||
nearest = max(lower or tested) | ||||
if worst[0] is None or nearest < worst[1]: | ||||
Augie Fackler
|
r16744 | worst = name, nearest, report | ||
if worst[0] is not None: | ||||
name, testedwith, report = worst | ||||
if not isinstance(testedwith, str): | ||||
testedwith = '.'.join([str(c) for c in testedwith]) | ||||
warning = (_('** Unknown exception encountered with ' | ||||
'possibly-broken third-party extension %s\n' | ||||
'** which supports versions %s of Mercurial.\n' | ||||
'** Please disable %s and try your action again.\n' | ||||
'** If that fixes the bug please report it to %s\n') | ||||
% (name, testedwith, name, report)) | ||||
else: | ||||
warning = (_("** unknown exception encountered, " | ||||
"please report by visiting\n") + | ||||
_("** http://mercurial.selenic.com/wiki/BugTracker\n")) | ||||
warning += ((_("** Python %s\n") % sys.version.replace('\n', '')) + | ||||
(_("** Mercurial Distributed SCM (version %s)\n") % myver) + | ||||
(_("** Extensions loaded: %s\n") % | ||||
", ".join([x[0] for x in extensions.extensions()]))) | ||||
Durham Goode
|
r18670 | ui.log("commandexception", "%s\n%s\n", warning, traceback.format_exc()) | ||
Augie Fackler
|
r16744 | ui.warn(warning) | ||
Matt Mackall
|
r5178 | raise | ||
return -1 | ||||
Augie Fackler
|
r16744 | def tuplever(v): | ||
Adrian Buehlmann
|
r16839 | try: | ||
return tuple([int(i) for i in v.split('.')]) | ||||
except ValueError: | ||||
return tuple() | ||||
Augie Fackler
|
r16744 | |||
Alexander Solovyov
|
r14265 | def aliasargs(fn, givenargs): | ||
args = getattr(fn, 'args', []) | ||||
Matt Mackall
|
r16294 | if args: | ||
Alexander Solovyov
|
r14265 | cmd = ' '.join(map(util.shellquote, args)) | ||
nums = [] | ||||
def replacer(m): | ||||
num = int(m.group(1)) - 1 | ||||
nums.append(num) | ||||
Matt Mackall
|
r16277 | if num < len(givenargs): | ||
return givenargs[num] | ||||
Matt Mackall
|
r16294 | raise util.Abort(_('too few arguments for command alias')) | ||
Alexander Solovyov
|
r14265 | cmd = re.sub(r'\$(\d+|\$)', replacer, cmd) | ||
givenargs = [x for i, x in enumerate(givenargs) | ||||
if i not in nums] | ||||
args = shlex.split(cmd) | ||||
return args + givenargs | ||||
Brendan Cully
|
r8655 | |||
class cmdalias(object): | ||||
def __init__(self, name, definition, cmdtable): | ||||
Brodie Rao
|
r12039 | self.name = self.cmd = name | ||
Brodie Rao
|
r12092 | self.cmdname = '' | ||
Brendan Cully
|
r8655 | self.definition = definition | ||
self.args = [] | ||||
self.opts = [] | ||||
self.help = '' | ||||
self.norepo = True | ||||
Patrick Mezard
|
r16609 | self.optionalrepo = False | ||
Brodie Rao
|
r10021 | self.badalias = False | ||
Brendan Cully
|
r8655 | |||
try: | ||||
Brodie Rao
|
r12039 | aliases, entry = cmdutil.findcmd(self.name, cmdtable) | ||
for alias, e in cmdtable.iteritems(): | ||||
if e is entry: | ||||
self.cmd = alias | ||||
break | ||||
Brendan Cully
|
r8655 | self.shadows = True | ||
except error.UnknownCommand: | ||||
self.shadows = False | ||||
if not self.definition: | ||||
def fn(ui, *args): | ||||
ui.warn(_("no definition for alias '%s'\n") % self.name) | ||||
return 1 | ||||
self.fn = fn | ||||
Brodie Rao
|
r10021 | self.badalias = True | ||
Brendan Cully
|
r8655 | return | ||
Steve Losh
|
r11524 | if self.definition.startswith('!'): | ||
Steve Losh
|
r12536 | self.shell = True | ||
Steve Losh
|
r11524 | def fn(ui, *args): | ||
Steve Losh
|
r11989 | env = {'HG_ARGS': ' '.join((self.name,) + args)} | ||
def _checkvar(m): | ||||
Roman Sokolov
|
r13392 | if m.groups()[0] == '$': | ||
return m.group() | ||||
elif int(m.groups()[0]) <= len(args): | ||||
Steve Losh
|
r11989 | return m.group() | ||
else: | ||||
David Soria Parra
|
r14708 | ui.debug("No argument found for substitution " | ||
"of %i variable in alias '%s' definition." | ||||
Roman Sokolov
|
r13393 | % (int(m.groups()[0]), self.name)) | ||
Steve Losh
|
r11989 | return '' | ||
Roman Sokolov
|
r13392 | cmd = re.sub(r'\$(\d+|\$)', _checkvar, self.definition[1:]) | ||
Steve Losh
|
r11989 | replace = dict((str(i + 1), arg) for i, arg in enumerate(args)) | ||
replace['0'] = self.name | ||||
replace['@'] = ' '.join(args) | ||||
Roman Sokolov
|
r13392 | cmd = util.interpolate(r'\$', replace, cmd, escape_prefix=True) | ||
Idan Kamara
|
r14640 | return util.system(cmd, environ=env, out=ui.fout) | ||
Steve Losh
|
r11524 | self.fn = fn | ||
return | ||||
Brendan Cully
|
r8655 | args = shlex.split(self.definition) | ||
Brodie Rao
|
r12092 | self.cmdname = cmd = args.pop(0) | ||
Alexander Solovyov
|
r10793 | args = map(util.expandpath, args) | ||
Brendan Cully
|
r8655 | |||
Simon Heimberg
|
r18693 | for invalidarg in ("--cwd", "-R", "--repository", "--repo", "--config"): | ||
Dan Villiom Podlaski Christiansen
|
r11695 | if _earlygetopt([invalidarg], args): | ||
def fn(ui, *args): | ||||
ui.warn(_("error in definition for alias '%s': %s may only " | ||||
"be given on the command line\n") | ||||
% (self.name, invalidarg)) | ||||
return 1 | ||||
self.fn = fn | ||||
self.badalias = True | ||||
return | ||||
Brendan Cully
|
r8655 | try: | ||
Nicolas Dumazet
|
r9993 | tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1] | ||
if len(tableentry) > 2: | ||||
self.fn, self.opts, self.help = tableentry | ||||
else: | ||||
self.fn, self.opts = tableentry | ||||
Alexander Solovyov
|
r14265 | self.args = aliasargs(self.fn, args) | ||
Brendan Cully
|
r8655 | if cmd not in commands.norepo.split(' '): | ||
self.norepo = False | ||||
Patrick Mezard
|
r16609 | if cmd in commands.optionalrepo.split(' '): | ||
self.optionalrepo = True | ||||
Peter Arrenbrecht
|
r9876 | if self.help.startswith("hg " + cmd): | ||
# drop prefix in old-style help lines so hg shows the alias | ||||
self.help = self.help[4 + len(cmd):] | ||||
Yuya Nishihara
|
r10564 | self.__doc__ = self.fn.__doc__ | ||
Peter Arrenbrecht
|
r9876 | |||
Brendan Cully
|
r8655 | except error.UnknownCommand: | ||
def fn(ui, *args): | ||||
ui.warn(_("alias '%s' resolves to unknown command '%s'\n") \ | ||||
% (self.name, cmd)) | ||||
Brodie Rao
|
r10364 | try: | ||
# check if the command is in a disabled extension | ||||
commands.help_(ui, cmd, unknowncmd=True) | ||||
except error.UnknownCommand: | ||||
pass | ||||
Brendan Cully
|
r8655 | return 1 | ||
self.fn = fn | ||||
Brodie Rao
|
r10021 | self.badalias = True | ||
Brendan Cully
|
r8655 | except error.AmbiguousCommand: | ||
def fn(ui, *args): | ||||
ui.warn(_("alias '%s' resolves to ambiguous command '%s'\n") \ | ||||
% (self.name, cmd)) | ||||
return 1 | ||||
self.fn = fn | ||||
Brodie Rao
|
r10021 | self.badalias = True | ||
Brendan Cully
|
r8655 | |||
def __call__(self, ui, *args, **opts): | ||||
if self.shadows: | ||||
Martin Geisler
|
r14704 | ui.debug("alias '%s' shadows command '%s'\n" % | ||
Brodie Rao
|
r12092 | (self.name, self.cmdname)) | ||
Brendan Cully
|
r8655 | |||
Augie Fackler
|
r14950 | if util.safehasattr(self, 'shell'): | ||
Steve Losh
|
r11989 | return self.fn(ui, *args, **opts) | ||
else: | ||||
Brodie Rao
|
r12093 | try: | ||
util.checksignature(self.fn)(ui, *args, **opts) | ||||
except error.SignatureError: | ||||
args = ' '.join([self.cmdname] + self.args) | ||||
Martin Geisler
|
r14704 | ui.debug("alias '%s' expands to '%s'\n" % (self.name, args)) | ||
Brodie Rao
|
r12093 | raise | ||
Brendan Cully
|
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. | ||||
for alias, definition in ui.configitems('alias'): | ||||
aliasdef = cmdalias(alias, definition, cmdtable) | ||||
Idan Kamara
|
r15019 | |||
try: | ||||
olddef = cmdtable[aliasdef.cmd][0] | ||||
if olddef.definition == aliasdef.definition: | ||||
continue | ||||
except (KeyError, AttributeError): | ||||
# definition might not exist or it might not be a cmdalias | ||||
pass | ||||
Augie Fackler
|
r15233 | cmdtable[aliasdef.name] = (aliasdef, aliasdef.opts, aliasdef.help) | ||
Brendan Cully
|
r8655 | if aliasdef.norepo: | ||
commands.norepo += ' %s' % alias | ||||
Patrick Mezard
|
r16609 | if aliasdef.optionalrepo: | ||
commands.optionalrepo += ' %s' % alias | ||||
Brendan Cully
|
r8655 | |||
Matt Mackall
|
r5178 | def _parse(ui, args): | ||
options = {} | ||||
cmdoptions = {} | ||||
try: | ||||
args = fancyopts.fancyopts(args, commands.globalopts, options) | ||||
except fancyopts.getopt.GetoptError, inst: | ||||
Matt Mackall
|
r11287 | raise error.CommandError(None, inst) | ||
Matt Mackall
|
r5178 | |||
if args: | ||||
cmd, args = args[0], args[1:] | ||||
Henri Wiechers
|
r9875 | aliases, entry = cmdutil.findcmd(cmd, commands.table, | ||
Yuya Nishihara
|
r16591 | ui.configbool("ui", "strict")) | ||
Matt Mackall
|
r5178 | cmd = aliases[0] | ||
Alexander Solovyov
|
r14265 | args = aliasargs(entry[0], args) | ||
Matt Mackall
|
r5178 | defaults = ui.config("defaults", cmd) | ||
if defaults: | ||||
Alexander Solovyov
|
r9610 | args = map(util.expandpath, shlex.split(defaults)) + args | ||
Henri Wiechers
|
r9875 | c = list(entry[1]) | ||
Matt Mackall
|
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: | ||||
Augie Fackler
|
r7772 | args = fancyopts.fancyopts(args, c, cmdoptions, True) | ||
Matt Mackall
|
r5178 | except fancyopts.getopt.GetoptError, inst: | ||
Matt Mackall
|
r11287 | raise error.CommandError(cmd, inst) | ||
Matt Mackall
|
r5178 | |||
# separate global options back out | ||||
for o in commands.globalopts: | ||||
n = o[1] | ||||
options[n] = cmdoptions[n] | ||||
del cmdoptions[n] | ||||
Henri Wiechers
|
r9875 | return (cmd, cmd and entry[0] or None, args, options, cmdoptions) | ||
Matt Mackall
|
r5178 | |||
Matt Mackall
|
r8137 | def _parseconfig(ui, config): | ||
Matt Mackall
|
r5178 | """parse the --config options from the command line""" | ||
Idan Kamara
|
r14753 | configs = [] | ||
Matt Mackall
|
r5178 | for cfg in config: | ||
try: | ||||
name, value = cfg.split('=', 1) | ||||
section, name = name.split('.', 1) | ||||
if not section or not name: | ||||
raise IndexError | ||||
Matt Mackall
|
r8137 | ui.setconfig(section, name, value) | ||
Idan Kamara
|
r14753 | configs.append((section, name, value)) | ||
Matt Mackall
|
r5178 | except (IndexError, ValueError): | ||
Bill Schroeder
|
r9825 | raise util.Abort(_('malformed --config option: %r ' | ||
'(use --config section.name=value)') % cfg) | ||||
Matt Mackall
|
r5178 | |||
Idan Kamara
|
r14753 | return configs | ||
Matt Mackall
|
r5178 | def _earlygetopt(aliases, args): | ||
"""Return list of values for an option (or aliases). | ||||
The values are listed in the order they appear in args. | ||||
The options and values are removed from args. | ||||
Bryan O'Sullivan
|
r19098 | |||
>>> args = ['x', '--cwd', 'foo', 'y'] | ||||
>>> _earlygetopt(['--cwd'], args), args | ||||
(['foo'], ['x', 'y']) | ||||
Bryan O'Sullivan
|
r19099 | >>> args = ['x', '--cwd=bar', 'y'] | ||
>>> _earlygetopt(['--cwd'], args), args | ||||
(['bar'], ['x', 'y']) | ||||
Bryan O'Sullivan
|
r19098 | >>> args = ['x', '-R', 'foo', 'y'] | ||
>>> _earlygetopt(['-R'], args), args | ||||
(['foo'], ['x', 'y']) | ||||
>>> args = ['x', '-Rbar', 'y'] | ||||
>>> _earlygetopt(['-R'], args), args | ||||
(['bar'], ['x', 'y']) | ||||
Matt Mackall
|
r5178 | """ | ||
try: | ||||
argcount = args.index("--") | ||||
except ValueError: | ||||
argcount = len(args) | ||||
shortopts = [opt for opt in aliases if len(opt) == 2] | ||||
values = [] | ||||
pos = 0 | ||||
while pos < argcount: | ||||
Bryan O'Sullivan
|
r19099 | fullarg = arg = args[pos] | ||
equals = arg.find('=') | ||||
if equals > -1: | ||||
arg = arg[:equals] | ||||
if arg in aliases: | ||||
Matt Mackall
|
r5178 | del args[pos] | ||
Bryan O'Sullivan
|
r19099 | if equals > -1: | ||
values.append(fullarg[equals + 1:]) | ||||
argcount -= 1 | ||||
else: | ||||
if pos + 1 >= argcount: | ||||
# ignore and let getopt report an error if there is no value | ||||
break | ||||
values.append(args.pop(pos)) | ||||
argcount -= 2 | ||||
elif arg[:2] in shortopts: | ||||
Matt Mackall
|
r5178 | # short option can have no following space, e.g. hg log -Rfoo | ||
values.append(args.pop(pos)[2:]) | ||||
argcount -= 1 | ||||
else: | ||||
pos += 1 | ||||
return values | ||||
Chad Dombrova
|
r11330 | def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions): | ||
Bill Barry
|
r7819 | # run pre-hook, and abort if it fails | ||
Siddharth Agarwal
|
r19011 | hook.hook(lui, repo, "pre-%s" % cmd, True, args=" ".join(fullargs), | ||
pats=cmdpats, opts=cmdoptions) | ||||
Bill Barry
|
r7819 | ret = _runcommand(ui, options, cmd, d) | ||
# run post-hook, passing command result | ||||
hook.hook(lui, repo, "post-%s" % cmd, False, args=" ".join(fullargs), | ||||
Chad Dombrova
|
r11330 | result=ret, pats=cmdpats, opts=cmdoptions) | ||
Bill Barry
|
r7819 | return ret | ||
Steve Losh
|
r12536 | def _getlocal(ui, rpath): | ||
"""Return (path, local ui object) for the given target path. | ||||
Martin Geisler
|
r12770 | |||
Steve Losh
|
r12536 | Takes paths in [cwd]/.hg/hgrc into account." | ||
""" | ||||
Mads Kiilerich
|
r11675 | try: | ||
wd = os.getcwd() | ||||
except OSError, e: | ||||
Nicolas Dumazet
|
r11712 | raise util.Abort(_("error getting current working directory: %s") % | ||
Mads Kiilerich
|
r11675 | e.strerror) | ||
path = cmdutil.findrepo(wd) or "" | ||||
Matt Mackall
|
r5178 | if not path: | ||
lui = ui | ||||
Andrey Somov
|
r9436 | else: | ||
Brodie Rao
|
r12636 | lui = ui.copy() | ||
Brodie Rao
|
r12637 | lui.readconfig(os.path.join(path, ".hg", "hgrc"), path) | ||
Matt Mackall
|
r5178 | |||
Matt Mackall
|
r14860 | if rpath and rpath[-1]: | ||
Matt Mackall
|
r5178 | path = lui.expandpath(rpath[-1]) | ||
Matt Mackall
|
r8190 | lui = ui.copy() | ||
Brodie Rao
|
r12637 | lui.readconfig(os.path.join(path, ".hg", "hgrc"), path) | ||
Matt Mackall
|
r5178 | |||
Steve Losh
|
r12536 | return path, lui | ||
Matt Mackall
|
r14888 | def _checkshellalias(lui, ui, args): | ||
Steve Losh
|
r12536 | options = {} | ||
Steve Losh
|
r12748 | |||
try: | ||||
args = fancyopts.fancyopts(args, commands.globalopts, options) | ||||
except fancyopts.getopt.GetoptError: | ||||
return | ||||
Steve Losh
|
r12536 | |||
if not args: | ||||
return | ||||
Patrick Mezard
|
r16609 | norepo = commands.norepo | ||
optionalrepo = commands.optionalrepo | ||||
def restorecommands(): | ||||
commands.norepo = norepo | ||||
commands.optionalrepo = optionalrepo | ||||
Steve Losh
|
r12536 | cmdtable = commands.table.copy() | ||
addaliases(lui, cmdtable) | ||||
cmd = args[0] | ||||
try: | ||||
Yuya Nishihara
|
r16591 | aliases, entry = cmdutil.findcmd(cmd, cmdtable, | ||
lui.configbool("ui", "strict")) | ||||
Steve Losh
|
r12932 | except (error.AmbiguousCommand, error.UnknownCommand): | ||
Patrick Mezard
|
r16609 | restorecommands() | ||
Steve Losh
|
r12536 | return | ||
cmd = aliases[0] | ||||
fn = entry[0] | ||||
Augie Fackler
|
r14950 | if cmd and util.safehasattr(fn, 'shell'): | ||
Steve Losh
|
r12536 | d = lambda: fn(ui, *args[1:]) | ||
Brodie Rao
|
r16683 | return lambda: runcommand(lui, None, cmd, args[:1], ui, options, d, | ||
[], {}) | ||||
Steve Losh
|
r12536 | |||
Patrick Mezard
|
r16609 | restorecommands() | ||
Steve Losh
|
r12536 | |||
_loaded = set() | ||||
Idan Kamara
|
r14439 | def _dispatch(req): | ||
Idan Kamara
|
r14438 | args = req.args | ||
Idan Kamara
|
r14439 | ui = req.ui | ||
Steve Losh
|
r12536 | # read --config before doing anything else | ||
# (e.g. to change trust settings for reading .hg/hgrc) | ||||
Idan Kamara
|
r14754 | cfgs = _parseconfig(ui, _earlygetopt(['--config'], args)) | ||
Steve Losh
|
r12536 | |||
# check for cwd | ||||
cwd = _earlygetopt(['--cwd'], args) | ||||
if cwd: | ||||
os.chdir(cwd[-1]) | ||||
rpath = _earlygetopt(["-R", "--repository", "--repo"], args) | ||||
path, lui = _getlocal(ui, rpath) | ||||
Matt Mackall
|
r14886 | # Now that we're operating in the right directory/repository with | ||
# the right config settings, check for shell aliases | ||||
Matt Mackall
|
r14888 | shellaliasfn = _checkshellalias(lui, ui, args) | ||
Matt Mackall
|
r14886 | if shellaliasfn: | ||
return shellaliasfn() | ||||
Martin Geisler
|
r9410 | # Configure extensions in phases: uisetup, extsetup, cmdtable, and | ||
# reposetup. Programs like TortoiseHg will call _dispatch several | ||||
# times so we keep track of configured extensions in _loaded. | ||||
Matt Mackall
|
r5178 | extensions.loadall(lui) | ||
Martin Geisler
|
r9410 | exts = [ext for ext in extensions.extensions() if ext[0] not in _loaded] | ||
Brodie Rao
|
r11555 | # Propagate any changes to lui.__class__ by extensions | ||
ui.__class__ = lui.__class__ | ||||
Kirill Smelkov
|
r5828 | |||
Yuya Nishihara
|
r9660 | # (uisetup and extsetup are handled in extensions.loadall) | ||
Kirill Smelkov
|
r5828 | |||
Martin Geisler
|
r9410 | for name, module in exts: | ||
Alexis S. L. Carvalho
|
r5192 | cmdtable = getattr(module, 'cmdtable', {}) | ||
overrides = [cmd for cmd in cmdtable if cmd in commands.table] | ||||
if overrides: | ||||
ui.warn(_("extension '%s' overrides commands: %s\n") | ||||
% (name, " ".join(overrides))) | ||||
commands.table.update(cmdtable) | ||||
Martin Geisler
|
r8304 | _loaded.add(name) | ||
Brendan Cully
|
r8655 | |||
Martin Geisler
|
r9410 | # (reposetup is handled in hg.repository) | ||
Brendan Cully
|
r8655 | addaliases(lui, commands.table) | ||
Matt Mackall
|
r5178 | # check for fallback encoding | ||
fallback = lui.config('ui', 'fallbackencoding') | ||||
if fallback: | ||||
Matt Mackall
|
r7948 | encoding.fallbackencoding = fallback | ||
Matt Mackall
|
r5178 | |||
fullargs = args | ||||
cmd, func, args, options, cmdoptions = _parse(lui, args) | ||||
if options["config"]: | ||||
Martin Geisler
|
r12067 | raise util.Abort(_("option --config may not be abbreviated!")) | ||
Matt Mackall
|
r5178 | if options["cwd"]: | ||
Martin Geisler
|
r12067 | raise util.Abort(_("option --cwd may not be abbreviated!")) | ||
Matt Mackall
|
r5178 | if options["repository"]: | ||
raise util.Abort(_( | ||||
Martin Geisler
|
r15781 | "option -R has to be separated from other options (e.g. not -qR) " | ||
Matt Mackall
|
r5178 | "and --repository may only be abbreviated as --repo!")) | ||
if options["encoding"]: | ||||
Matt Mackall
|
r7948 | encoding.encoding = options["encoding"] | ||
Matt Mackall
|
r5178 | if options["encodingmode"]: | ||
Matt Mackall
|
r7948 | encoding.encodingmode = options["encodingmode"] | ||
Matt Mackall
|
r5178 | if options["time"]: | ||
def get_times(): | ||||
t = os.times() | ||||
if t[4] == 0.0: # Windows leaves this as zero, so use time.clock() | ||||
t = (t[0], t[1], t[2], t[3], time.clock()) | ||||
return t | ||||
s = get_times() | ||||
def print_time(): | ||||
t = get_times() | ||||
Martin Geisler
|
r16933 | ui.warn(_("time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") % | ||
Matt Mackall
|
r5178 | (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3])) | ||
atexit.register(print_time) | ||||
Idan Kamara
|
r14752 | uis = set([ui, lui]) | ||
if req.repo: | ||||
uis.add(req.repo.ui) | ||||
Idan Kamara
|
r14754 | # copy configs that were passed on the cmdline (--config) to the repo ui | ||
for cfg in cfgs: | ||||
req.repo.ui.setconfig(*cfg) | ||||
Idan Kamara
|
r14992 | if options['verbose'] or options['debug'] or options['quiet']: | ||
for opt in ('verbose', 'debug', 'quiet'): | ||||
val = str(bool(options[opt])) | ||||
Idan Kamara
|
r14752 | for ui_ in uis: | ||
Idan Kamara
|
r14992 | ui_.setconfig('ui', opt, val) | ||
if options['traceback']: | ||||
for ui_ in uis: | ||||
ui_.setconfig('ui', 'traceback', 'on') | ||||
Idan Kamara
|
r14748 | |||
Matt Mackall
|
r8136 | if options['noninteractive']: | ||
Idan Kamara
|
r14752 | for ui_ in uis: | ||
Idan Kamara
|
r14618 | ui_.setconfig('ui', 'interactive', 'off') | ||
Matt Mackall
|
r5178 | |||
Yuya Nishihara
|
r13328 | if cmdoptions.get('insecure', False): | ||
Idan Kamara
|
r14752 | for ui_ in uis: | ||
Idan Kamara
|
r14618 | ui_.setconfig('web', 'cacerts', '') | ||
Yuya Nishihara
|
r13328 | |||
Matt Mackall
|
r15020 | if options['version']: | ||
return commands.version_(ui) | ||||
Matt Mackall
|
r5178 | if options['help']: | ||
Matt Mackall
|
r15020 | return commands.help_(ui, cmd) | ||
Matt Mackall
|
r5178 | elif not cmd: | ||
return commands.help_(ui, 'shortlist') | ||||
repo = None | ||||
Chad Dombrova
|
r11330 | cmdpats = args[:] | ||
Matt Mackall
|
r5178 | if cmd not in commands.norepo.split(): | ||
Idan Kamara
|
r14510 | # use the repo from the request only if we don't have -R | ||
Idan Kamara
|
r14863 | if not rpath and not cwd: | ||
Idan Kamara
|
r14510 | repo = req.repo | ||
Idan Kamara
|
r14744 | 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 | ||||
else: | ||||
Idan Kamara
|
r14510 | try: | ||
repo = hg.repository(ui, path=path) | ||||
if not repo.local(): | ||||
raise util.Abort(_("repository '%s' is not local") % path) | ||||
Pierre-Yves David
|
r18303 | if options['hidden']: | ||
Pierre-Yves David
|
r18267 | repo = repo.unfiltered() | ||
Idan Kamara
|
r14743 | repo.ui.setconfig("bundle", "mainreporoot", repo.root) | ||
Idan Kamara
|
r14510 | except error.RequirementError: | ||
Matt Mackall
|
r5178 | raise | ||
Idan Kamara
|
r14510 | except error.RepoError: | ||
if cmd not in commands.optionalrepo.split(): | ||||
Siddharth Agarwal
|
r17773 | if (cmd in commands.inferrepo.split() and | ||
args and not path): # try to infer -R from command args | ||||
Idan Kamara
|
r14510 | repos = map(cmdutil.findrepo, args) | ||
guess = repos[0] | ||||
if guess and repos.count(guess) == len(repos): | ||||
req.args = ['--repository', guess] + fullargs | ||||
return _dispatch(req) | ||||
if not path: | ||||
David Golub
|
r14914 | raise error.RepoError(_("no repository found in '%s'" | ||
Brodie Rao
|
r16683 | " (.hg not found)") | ||
% os.getcwd()) | ||||
Idan Kamara
|
r14510 | raise | ||
Idan Kamara
|
r14743 | if repo: | ||
ui = repo.ui | ||||
Matt Mackall
|
r7388 | args.insert(0, repo) | ||
Matt Mackall
|
r7733 | elif rpath: | ||
Martin Geisler
|
r11600 | ui.warn(_("warning: --repository ignored\n")) | ||
Matt Mackall
|
r7388 | |||
Matt Mackall
|
r11985 | msg = ' '.join(' ' in a and repr(a) or a for a in fullargs) | ||
Durham Goode
|
r18758 | ui.log("command", '%s\n', msg) | ||
Matt Mackall
|
r7388 | d = lambda: util.checksignature(func)(ui, *args, **cmdoptions) | ||
Adrian Buehlmann
|
r13382 | try: | ||
Durham Goode
|
r19229 | return runcommand(lui, repo, cmd, fullargs, ui, options, d, | ||
cmdpats, cmdoptions) | ||||
Adrian Buehlmann
|
r13382 | finally: | ||
Idan Kamara
|
r14727 | if repo and repo != req.repo: | ||
Adrian Buehlmann
|
r13382 | repo.close() | ||
Matt Mackall
|
r5178 | |||
Bryan O'Sullivan
|
r16392 | def lsprofile(ui, func, fp): | ||
format = ui.config('profiling', 'format', default='text') | ||||
field = ui.config('profiling', 'sort', default='inlinetime') | ||||
Mads Kiilerich
|
r18548 | limit = ui.configint('profiling', 'limit', default=30) | ||
Bryan O'Sullivan
|
r16392 | climit = ui.configint('profiling', 'nested', default=5) | ||
Brodie Rao
|
r16686 | if format not in ['text', 'kcachegrind']: | ||
Bryan O'Sullivan
|
r16392 | ui.warn(_("unrecognized profiling format '%s'" | ||
" - Ignored\n") % format) | ||||
format = 'text' | ||||
try: | ||||
from mercurial import lsprof | ||||
except ImportError: | ||||
raise util.Abort(_( | ||||
'lsprof not available - install from ' | ||||
'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/')) | ||||
p = lsprof.Profiler() | ||||
p.enable(subcalls=True) | ||||
try: | ||||
return func() | ||||
finally: | ||||
p.disable() | ||||
if format == 'kcachegrind': | ||||
import lsprofcalltree | ||||
calltree = lsprofcalltree.KCacheGrind(p) | ||||
calltree.output(fp) | ||||
else: | ||||
# format == 'text' | ||||
stats = lsprof.Stats(p.getstats()) | ||||
stats.sort(field) | ||||
Mads Kiilerich
|
r18548 | stats.pprint(limit=limit, file=fp, climit=climit) | ||
Bryan O'Sullivan
|
r16392 | |||
def statprofile(ui, func, fp): | ||||
try: | ||||
import statprof | ||||
except ImportError: | ||||
raise util.Abort(_( | ||||
'statprof not available - install using "easy_install statprof"')) | ||||
freq = ui.configint('profiling', 'freq', default=1000) | ||||
if freq > 0: | ||||
statprof.reset(freq) | ||||
else: | ||||
ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq) | ||||
statprof.start() | ||||
try: | ||||
return func() | ||||
finally: | ||||
statprof.stop() | ||||
statprof.display(fp) | ||||
Matt Mackall
|
r5178 | def _runcommand(ui, options, cmd, cmdfunc): | ||
def checkargs(): | ||||
try: | ||||
return cmdfunc() | ||||
Matt Mackall
|
r7646 | except error.SignatureError: | ||
Matt Mackall
|
r11287 | raise error.CommandError(cmd, _("invalid arguments")) | ||
Matt Mackall
|
r5178 | |||
Thomas Arendsen Hein
|
r6141 | if options['profile']: | ||
Bryan O'Sullivan
|
r16392 | profiler = os.getenv('HGPROF') | ||
if profiler is None: | ||||
profiler = ui.config('profiling', 'type', default='ls') | ||||
if profiler not in ('ls', 'stat'): | ||||
ui.warn(_("unrecognized profiler '%s' - ignored\n") % profiler) | ||||
profiler = 'ls' | ||||
Nicolas Dumazet
|
r8023 | |||
Nicolas Dumazet
|
r8022 | output = ui.config('profiling', 'output') | ||
if output: | ||||
Alexander Solovyov
|
r9610 | path = ui.expandpath(output) | ||
Bryan O'Sullivan
|
r16392 | fp = open(path, 'wb') | ||
Nicolas Dumazet
|
r8022 | else: | ||
Bryan O'Sullivan
|
r16392 | fp = sys.stderr | ||
Nicolas Dumazet
|
r8022 | |||
Matt Mackall
|
r5178 | try: | ||
Bryan O'Sullivan
|
r16392 | if profiler == 'ls': | ||
return lsprofile(ui, checkargs, fp) | ||||
else: | ||||
return statprofile(ui, checkargs, fp) | ||||
Matt Mackall
|
r5178 | finally: | ||
Nicolas Dumazet
|
r8022 | if output: | ||
Bryan O'Sullivan
|
r16392 | fp.close() | ||
Matt Mackall
|
r5178 | else: | ||
Thomas Arendsen Hein
|
r6141 | return checkargs() | ||