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

    localrepo,

    profiling,

    pycompat,

    rcutil,

    registrar,

    requirements as requirementsmod,

    scmutil,

    ui as uimod,

    util,

    vfs,

)

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 _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(inst.format())

            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()  # record blocked times

            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

            # do flush again since ui.log() and exit handlers may write to ui

            req.ui.flush()

        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

                # 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 == b'serve' and b'--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] != b'-R'

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

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

                    or req.args[3] != b'--stdio'

                ):

                    raise error.Abort(

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

                        % (stringutil.pprint(req.args),)

                    )

            try:

                debugger = b'pdb'

                debugtrace = {b'pdb': pdb.set_trace}

                debugmortem = {b'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[b'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=b'--config'

                        )

                # developer config: ui.debugger

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

                debugmod = pdb

                if not debugger or ui.plain():

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

                    debugger = b'pdb'

                elif req.earlyoptions[b'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[b'debugger']:

                    ui.warn(

                        _(

                            b"entering debugger - "

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

                        )

                    )

                    if (

                        debugger != b'pdb'

                        and debugtrace[debugger] == debugtrace[b'pdb']

                    ):

                        ui.warn(

                            _(

                                b"%s debugger specified "

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

            _(b"hg: command '%s' is ambiguous:\n    %s\n")

            % (inst.prefix, b" ".join(inst.matches))

        )

    except error.CommandError as inst:

        if inst.command:

            ui.pager(b'help')

            msgbytes = pycompat.bytestr(inst.message)

            ui.warn(_(b"hg %s: %s\n") % (inst.command, msgbytes))

            commands.help_(ui, inst.command, full=False, command=True)

        else:

            ui.warn(_(b"hg: %s\n") % inst.message)

            ui.warn(_(b"(use 'hg help -v' for a list of global options)\n"))

    except error.UnknownCommand as inst:

        nocmdmsg = _(b"hg: unknown command '%s'\n") % inst.command

        try:

            # check if the command is in a disabled extension

            # (but don't check for extensions themselves)

            formatted = help.formattedhelp(

                ui, commands, inst.command, unknowncmd=True

            )

            ui.warn(nocmdmsg)

            ui.write(formatted)

        except (error.UnknownCommand, error.Abort):

            suggested = False

            if inst.all_commands:

                sim = error.getsimilar(inst.all_commands, inst.command)

                if sim:

                    ui.warn(nocmdmsg)

                    ui.warn(b"(%s)\n" % error.similarity_hint(sim))