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

import os

import pdb

import re

import signal

import sys

import traceback

from .i18n import _

from .pycompat import getattr

from hgdemandimport import tracing

from . import (

    cmdutil,

    color,

    commands,

    demandimport,

    encoding,

    error,

    extensions,

    fancyopts,

    help,

    hg,

    hook,

    profiling,

    pycompat,

    rcutil,

    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.warnnoi18n(b'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"""

    try:

        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, b'fout'):

            assert req.ui is not None  # help pytype

            assert req.ui.fout is not None  # help pytype

            try:

                req.ui.fout.flush()

            except IOError as e:

                err = e

                status = -1

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

            assert req.ui is not None  # help pytype

            assert req.ui.ferr is not None  # help pytype

            try:

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

                    req.ui.ferr.write(

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

    except KeyboardInterrupt:

        # Catch early/late KeyboardInterrupt as last ditch. Here nothing will

        # be printed to console to avoid another IOError/KeyboardInterrupt.

        status = -1

    sys.exit(status & 255)

if pycompat.ispy3:

    def initstdio():

        # stdio streams on Python 3 are io.TextIOWrapper instances proxying another

        # buffer. These streams will normalize \n to \r\n by default. Mercurial's

        # preferred mechanism for writing output (ui.write()) uses io.BufferedWriter

        # instances, which write to the underlying stdio file descriptor in binary

        # mode. ui.write() uses \n for line endings and no line ending normalization

        # is attempted through this interface. This "just works," even if the system

        # preferred line ending is not \n.

        #

        # But some parts of Mercurial (e.g. hooks) can still send data to sys.stdout

        # and sys.stderr. They will inherit the line ending normalization settings,

        # potentially causing e.g. \r\n to be emitted. Since emitting \n should

        # "just work," here we change the sys.* streams to disable line ending

        # normalization, ensuring compatibility with our ui type.

        # write_through is new in Python 3.7.

        kwargs = {

            "newline": "\n",

            "line_buffering": sys.stdout.line_buffering,

        }

        if util.safehasattr(sys.stdout, "write_through"):

            kwargs["write_through"] = sys.stdout.write_through

        sys.stdout = io.TextIOWrapper(

            sys.stdout.buffer, sys.stdout.encoding, sys.stdout.errors, **kwargs

        )

        kwargs = {

            "newline": "\n",

            "line_buffering": sys.stderr.line_buffering,

        }

        if util.safehasattr(sys.stderr, "write_through"):

            kwargs["write_through"] = sys.stderr.write_through

        sys.stderr = io.TextIOWrapper(

            sys.stderr.buffer, sys.stderr.encoding, sys.stderr.errors, **kwargs

        )

        # No write_through on read-only stream.

        sys.stdin = io.TextIOWrapper(

            sys.stdin.buffer,

            sys.stdin.encoding,

            sys.stdin.errors,

            # None is universal newlines mode.

            newline=None,

            line_buffering=sys.stdin.line_buffering,

        )

    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(_(b"(did you mean %s?)\n") % similar[0])

    elif similar:

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

        write(_(b"(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(

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

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

        )

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

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

    else:

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

        _reportsimilar(write, similar)

    if inst.hint:

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

def _formatargs(args):

    return b' '.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[b'traceback']:

                req.ui.setconfig(b'ui', b'traceback', b'on', b'--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(_(b"abort: %s\n") % inst)

            if inst.hint:

                ferr.write(_(b"(%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(_(b'** ProgrammingError: %s\n') % inst)

            if inst.hint:

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

            raise

        except KeyboardInterrupt as inst:

            try:

                if isinstance(inst, error.SignalInterrupt):

                    msg = _(b"killed!\n")

                else:

                    msg = _(b"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[b'command_duration'] = duration * 1000

                req.ui.log(

                    b'uiblocked',

                    b'ui blocked ms\n',

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

                )

            return_code = ret & 255

            req.ui.log(

                b"commandfinish",

                b"%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 b'SIGBREAK', b'SIGHUP', b'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