# dispatch.py - command dispatching for mercurial

#

# Copyright 2005-2007 Olivia Mackall <olivia@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 annotations

import errno

import getopt

import io

import os

import pdb

import re

import signal

import sys

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 .configuration import rcutil

from .utils import (

    procutil,

    stringutil,

    urlutil,

)

class request:

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

        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 _flushstdio(ui, err):

    status = None

    # In all cases we try to flush stdio streams.

    if hasattr(ui, 'fout'):

        assert ui is not None  # help pytype

        assert ui.fout is not None  # help pytype

        try:

            ui.fout.flush()

        except OSError as e:

            err = e

            status = -1

    if hasattr(ui, 'ferr'):

        assert ui is not None  # help pytype

        assert ui.ferr is not None  # help pytype

        try:

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

                ui.ferr.write(

                    b'abort: %s\n' % encoding.strtolocal(err.strerror)

                )

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

            status = -1

    return status

def run():

    """run the command in sys.argv"""

    try:

        initstdio()

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

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

        status = dispatch(req)

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

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.

    if sys.stdout is not None:

        # write_through is new in Python 3.7.

        kwargs = {

            "newline": "\n",

            "line_buffering": sys.stdout.line_buffering,

        }

        if hasattr(sys.stdout, "write_through"):

            # pytype: disable=attribute-error

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

            # pytype: enable=attribute-error

        sys.stdout = io.TextIOWrapper(

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

        )

    if sys.stderr is not None:

        kwargs = {

            "newline": "\n",

            "line_buffering": sys.stderr.line_buffering,

        }

        if hasattr(sys.stderr, "write_through"):

            # pytype: disable=attribute-error

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

            # pytype: enable=attribute-error

        sys.stderr = io.TextIOWrapper(

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

        )

    if sys.stdin is not None:

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

        if fp is None:

            continue

        # Check if the file is okay

        try:

            fp.flush()

            continue

        except OSError:

            pass

        # Otherwise mark it as closed to silence "Exception ignored in"

        # message emitted by the interpreter finalizer.

        try:

            fp.close()

        except OSError:

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

    err = None

    try:

        status = _rundispatch(req)

    except error.StdioError as e:

        err = e

        status = -1

    ret = _flushstdio(req.ui, err)

    if ret and not status:

        status = ret

    return status

def _rundispatch(req) -> int:

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

        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

        formattedargs = _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 BrokenPipeError:

                pass

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

                formattedargs,

                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 '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 == 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.

                nbargs = 4

                hashiddenaccess = b'--hidden' in cmdargs

                if hashiddenaccess:

                    nbargs += 1

                if (

                    len(req.args) != nbargs

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

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

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

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

                    or hashiddenaccess

                    and req.args[4] != b'--hidden'

                ):

                    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}

                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__(pycompat.sysstr(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.

    """

    detailed_exit_code = -1

    try:

        return scmutil.callcatch(ui, func)

    except error.AmbiguousCommand as inst:

        detailed_exit_code = 10

        ui.warn(

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