# dispatch.py - command dispatching for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import, print_function

import difflib

import errno

import getopt

import os

import pdb

import re

import signal

import sys

import time

import traceback

from .i18n import _

from . import (

    cmdutil,

    color,

    commands,

    demandimport,

    encoding,

    error,

    extensions,

    fancyopts,

    help,

    hg,

    hook,

    profiling,

    pycompat,

    registrar,

    scmutil,

    ui as uimod,

    util,

)

unrecoverablewrite = registrar.command.unrecoverablewrite

class request(object):

    def __init__(self, args, ui=None, repo=None, fin=None, fout=None,

                 ferr=None, prereposetups=None):

        self.args = args

        self.ui = ui

        self.repo = repo

        # input/output/error streams

        self.fin = fin

        self.fout = fout

        self.ferr = ferr

        # reposetups which run before extensions, useful for chg to pre-fill

        # low-level repo state (for example, changelog) before extensions.

        self.prereposetups = prereposetups or []

    def _runexithandlers(self):

        exc = None

        handlers = self.ui._exithandlers

        try:

            while handlers:

                func, args, kwargs = handlers.pop()

                try:

                    func(*args, **kwargs)

                except: # re-raises below

                    if exc is None:

                        exc = sys.exc_info()[1]

                    self.ui.warn(('error in exit handlers:\n'))

                    self.ui.traceback(force=True)

        finally:

            if exc is not None:

                raise exc

def run():

    "run the command in sys.argv"

    _initstdio()

    req = request(pycompat.sysargv[1:])

    err = None

    try:

        status = (dispatch(req) or 0) & 255

    except error.StdioError as e:

        err = e

        status = -1

    if util.safehasattr(req.ui, 'fout'):

        try:

            req.ui.fout.flush()

        except IOError as e:

            err = e

            status = -1

    if util.safehasattr(req.ui, 'ferr'):

        if err is not None and err.errno != errno.EPIPE:

            req.ui.ferr.write('abort: %s\n' %

                              encoding.strtolocal(err.strerror))

        req.ui.ferr.flush()

    sys.exit(status & 255)

def _initstdio():

    for fp in (sys.stdin, sys.stdout, sys.stderr):

        util.setbinary(fp)

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]

def _reportsimilar(write, similar):

    if len(similar) == 1:

        write(_("(did you mean %s?)\n") % similar[0])

    elif similar:

        ss = ", ".join(sorted(similar))

        write(_("(did you mean one of %s?)\n") % ss)

def _formatparse(write, inst):

    similar = []

    if isinstance(inst, error.UnknownIdentifier):

        # make sure to check fileset first, as revset can invoke fileset

        similar = _getsimilar(inst.symbols, inst.function)

    if len(inst.args) > 1:

        write(_("hg: parse error at %s: %s\n") %

                         (inst.args[1], inst.args[0]))

        if (inst.args[0][0] == ' '):

            write(_("unexpected leading whitespace\n"))

    else:

        write(_("hg: parse error: %s\n") % inst.args[0])

        _reportsimilar(write, similar)

    if inst.hint:

        write(_("(%s)\n") % inst.hint)

def _formatargs(args):

    return ' '.join(util.shellquote(a) for a in args)

def dispatch(req):

    "run the command specified in req.args"

    if req.ferr:

        ferr = req.ferr

    elif req.ui:

        ferr = req.ui.ferr

    else:

        ferr = util.stderr

    try:

        if not req.ui:

            req.ui = uimod.ui.load()

        if _earlyreqoptbool(req, 'traceback', ['--traceback']):

            req.ui.setconfig('ui', 'traceback', 'on', '--traceback')

        # 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

    except error.Abort as inst:

        ferr.write(_("abort: %s\n") % inst)

        if inst.hint:

            ferr.write(_("(%s)\n") % inst.hint)

        return -1

    except error.ParseError as inst:

        _formatparse(ferr.write, inst)

        return -1

    msg = _formatargs(req.args)

    starttime = util.timer()

    ret = None

    try:

        ret = _runcatch(req)

    except error.ProgrammingError as inst:

        req.ui.warn(_('** ProgrammingError: %s\n') % inst)

        if inst.hint:

            req.ui.warn(_('** (%s)\n') % inst.hint)

        raise

    except KeyboardInterrupt as inst:

        try:

            if isinstance(inst, error.SignalInterrupt):

                msg = _("killed!\n")

            else:

                msg = _("interrupted!\n")

            req.ui.warn(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:

            req.ui._blockedtimes['command_duration'] = duration * 1000

            req.ui.log('uiblocked', 'ui blocked ms', **req.ui._blockedtimes)

        req.ui.log("commandfinish", "%s exited %d after %0.2f seconds\n",

                   msg, ret or 0, duration)

        try:

            req._runexithandlers()

        except: # exiting, so no re-raises

            ret = ret or -1

    return ret

def _runcatch(req):

    def catchterm(*args):

        raise error.SignalInterrupt

    ui = req.ui

    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

    def _runcatchfunc():

        realcmd = None

        try:

            cmdargs = fancyopts.fancyopts(req.args[:], commands.globalopts, {})

            cmd = cmdargs[0]

            aliases, entry = cmdutil.findcmd(cmd, commands.table, False)

            realcmd = aliases[0]

        except (error.UnknownCommand, error.AmbiguousCommand,

                IndexError, getopt.GetoptError):

            # 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

        if realcmd == 'serve' and '--stdio' in cmdargs:

            # 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.

            if (len(req.args) != 4 or

                req.args[0] != '-R' or

                req.args[1].startswith('--') or

                req.args[2] != 'serve' or

                req.args[3] != '--stdio'):

                raise error.Abort(

                    _('potentially unsafe serve --stdio invocation: %r') %

                    (req.args,))

        try:

            debugger = 'pdb'

            debugtrace = {

                'pdb': pdb.set_trace

            }

            debugmortem = {

                'pdb': pdb.post_mortem

            }

            # read --config before doing anything else

            # (e.g. to change trust settings for reading .hg/hgrc)

            cfgs = _parseconfig(req.ui, _earlygetopt(['--config'], req.args))

            if req.repo:

                # copy configs that were passed on the cmdline (--config) to

                # the repo ui

                for sec, name, val in cfgs:

                    req.repo.ui.setconfig(sec, name, val, source='--config')

            # developer config: ui.debugger

            debugger = ui.config("ui", "debugger")

            debugmod = pdb

            if not debugger or ui.plain():

                # if we are in HGPLAIN mode, then disable custom debugging

                debugger = 'pdb'

            elif _earlyreqoptbool(req, 'debugger', ['--debugger']):

                # 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:

                        pass # Leave debugmod = pdb

            debugtrace[debugger] = debugmod.set_trace

            debugmortem[debugger] = debugmod.post_mortem

            # enter the debugger before command execution

            if _earlyreqoptbool(req, 'debugger', ['--debugger']):

                ui.warn(_("entering debugger - "

                        "type c to continue starting hg or h for help\n"))

                if (debugger != 'pdb' and

                    debugtrace[debugger] == debugtrace['pdb']):

                    ui.warn(_("%s debugger specified "

                              "but its module was not found\n") % debugger)

                with demandimport.deactivated():

                    debugtrace[debugger]()

            try:

                return _dispatch(req)

            finally:

                ui.flush()

        except: # re-raises

            # enter the debugger when we hit an exception

            if _earlyreqoptbool(req, 'debugger', ['--debugger']):

                traceback.print_exc()

                debugmortem[debugger](sys.exc_info()[2])

            raise

    return _callcatch(ui, _runcatchfunc)

def _callcatch(ui, func):

    """like scmutil.callcatch but handles more high-level exceptions about

    config parsing and commands. besides, use handlecommandexception to handle

    uncaught exceptions.

    """

    try:

        return scmutil.callcatch(ui, func)

    except error.AmbiguousCommand as inst:

        ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %

                (inst.args[0], " ".join(inst.args[1])))

    except error.CommandError as inst:

        if inst.args[0]:

            ui.pager('help')

            msgbytes = pycompat.bytestr(inst.args[1])

            ui.warn(_("hg %s: %s\n") % (inst.args[0], msgbytes))

            commands.help_(ui, inst.args[0], full=False, command=True)

        else:

            ui.pager('help')

            ui.warn(_("hg: %s\n") % inst.args[1])

            commands.help_(ui, 'shortlist')

    except error.ParseError as inst:

        _formatparse(ui.warn, inst)

        return -1

    except error.UnknownCommand as inst:

        nocmdmsg = _("hg: unknown command '%s'\n") % inst.args[0]

        try:

            # check if the command is in a disabled extension

            # (but don't check for extensions themselves)

            formatted = help.formattedhelp(ui, commands, inst.args[0],

                                           unknowncmd=True)

            ui.warn(nocmdmsg)

            ui.write(formatted)

        except (error.UnknownCommand, error.Abort):

            suggested = False

            if len(inst.args) == 2:

                sim = _getsimilar(inst.args[1], inst.args[0])

                if sim:

                    ui.warn(nocmdmsg)

                    _reportsimilar(ui.warn, sim)

                    suggested = True

            if not suggested:

                ui.pager('help')

                ui.warn(nocmdmsg)

                commands.help_(ui, 'shortlist')

    except IOError:

        raise

    except KeyboardInterrupt:

        raise

    except:  # probably re-raises

        if not handlecommandexception(ui):

            raise

    return -1