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

    urlutil,

)

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

    status = None

    # In all cases we try to flush stdio streams.

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

        assert ui is not None  # help pytype

        assert ui.fout is not None  # help pytype

        try:

            ui.fout.flush()

        except IOError as e:

            err = e

            status = -1

    if util.safehasattr(ui, b'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 IOError:

            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)

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.

        if sys.stdout is not None:

            # write_through is new in Python 3.7.

            kwargs = {

                "newline": "\n",

                "line_buffering": sys.stdout.line_buffering,

            }

            if util.safehasattr(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 util.safehasattr(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 IOError:

                pass

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

            # message emitted by the interpreter finalizer.

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

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

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

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