# 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 hgdemandimport import tracing

from . import (

    cmdutil,

    color,

    commands,

    demandimport,

    encoding,

    error,

    extensions,

    fancyopts,

    help,

    hg,

    hook,

    profiling,

    pycompat,

    registrar,

    scmutil,

    ui as uimod,

    util,

)

from .utils import (

    procutil,

    stringutil,

)

class request(object):

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

                 ferr=None, fmsg=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

        # separate stream for status/error messages

        self.fmsg = fmsg

        # remember options pre-parsed by _earlyparseopts()

        self.earlyoptions = {}

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

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

        self.prereposetups = prereposetups or []

        # store the parsed and canonical command

        self.canonical_command = None

    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()

    with tracing.log('parse args into request'):

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

    err = None

    try:

        status = dispatch(req)

    except error.StdioError as e:

        err = e

        status = -1

    # In all cases we try to flush stdio streams.

    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'):

        try:

            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()

        # 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

    _silencestdio()

    sys.exit(status & 255)

if pycompat.ispy3:

    def initstdio():

        pass

    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

            # not close procutil.stdout, which may be a fdopen-ed file object

            # and its close() actually closes the underlying file descriptor.

            try:

                fp.close()

            except IOError:

                pass

else:

    def initstdio():

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

            procutil.setbinary(fp)

    def _silencestdio():

        pass

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") %

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

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

            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(procutil.shellquote(a) for a in args)

def dispatch(req):

    """run the command specified in req.args; returns an integer status code"""

    with tracing.log('dispatch.dispatch'):

        if req.ferr:

            ferr = req.ferr

        elif req.ui:

            ferr = req.ui.ferr

        else:

            ferr = procutil.stderr

        try:

            if not req.ui:

                req.ui = uimod.ui.load()

            req.earlyoptions.update(_earlyparseopts(req.ui, req.args))

            if req.earlyoptions['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

            if req.fmsg:

                req.ui.fmsg = req.fmsg

        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 = 1  # default of Python exit code on unhandled exception

        try:

            ret = _runcatch(req) or 0

        except error.ProgrammingError as inst:

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

            if inst.hint:

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

            raise

        except KeyboardInterrupt as inst:

            try:

                if isinstance(inst, error.SignalInterrupt):

                    msg = _("killed!\n")

                else:

                    msg = _("interrupted!\n")

                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:

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

                           **pycompat.strkwargs(req.ui._blockedtimes))

            return_code = ret & 255

            req.ui.log(

                "commandfinish",

                "%s exited %d after %0.2f seconds\n",

                msg,

                return_code,

                duration,

                return_code=return_code,

                duration=duration,

                canonical_command=req.canonical_command,

            )

            try:

                req._runexithandlers()

            except: # exiting, so no re-raises

                ret = ret or -1

        return ret

def _runcatch(req):

    with tracing.log('dispatch._runcatch'):

        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: %s') %

                        (stringutil.pprint(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, req.earlyoptions['config'])

                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 req.earlyoptions['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 req.earlyoptions['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 req.earlyoptions['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