# procutil.py - utility for managing processes and executable environment

#

#  Copyright 2005 K. Thananchayan <thananck@yahoo.com>

#  Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#  Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.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

import contextlib

import errno

import io

import os

import signal

import subprocess

import sys

import threading

import time

from ..i18n import _

from ..pycompat import (

    getattr,

    open,

)

from .. import (

    encoding,

    error,

    policy,

    pycompat,

)

# Import like this to keep import-checker happy

from ..utils import resourceutil

osutil = policy.importmod('osutil')

if pycompat.iswindows:

    from .. import windows as platform

else:

    from .. import posix as platform

def isatty(fp):

    try:

        return fp.isatty()

    except AttributeError:

        return False

class LineBufferedWrapper(object):

    def __init__(self, orig):

        self.orig = orig

    def __getattr__(self, attr):

        return getattr(self.orig, attr)

    def write(self, s):

        orig = self.orig

        res = orig.write(s)

        if s.endswith(b'\n'):

            orig.flush()

        return res

io.BufferedIOBase.register(LineBufferedWrapper)

def make_line_buffered(stream):

    if pycompat.ispy3 and not isinstance(stream, io.BufferedIOBase):

        # On Python 3, buffered streams can be expected to subclass

        # BufferedIOBase. This is definitively the case for the streams

        # initialized by the interpreter. For unbuffered streams, we don't need

        # to emulate line buffering.

        return stream

    if isinstance(stream, LineBufferedWrapper):

        return stream

    return LineBufferedWrapper(stream)

def unwrap_line_buffered(stream):

    if isinstance(stream, LineBufferedWrapper):

        assert not isinstance(stream.orig, LineBufferedWrapper)

        return stream.orig

    return stream

class WriteAllWrapper(object):

    def __init__(self, orig):

        self.orig = orig

    def __getattr__(self, attr):

        return getattr(self.orig, attr)

    def write(self, s):

        write1 = self.orig.write

        m = memoryview(s)

        total_to_write = len(s)

        total_written = 0

        while total_written < total_to_write:

            total_written += write1(m[total_written:])

        return total_written

io.IOBase.register(WriteAllWrapper)

def _make_write_all(stream):

    assert pycompat.ispy3

    if isinstance(stream, WriteAllWrapper):

        return stream

    if isinstance(stream, io.BufferedIOBase):

        # The io.BufferedIOBase.write() contract guarantees that all data is

        # written.

        return stream

    # In general, the write() method of streams is free to write only part of

    # the data.

    return WriteAllWrapper(stream)

if pycompat.ispy3:

    # Python 3 implements its own I/O streams.

    # TODO: .buffer might not exist if std streams were replaced; we'll need

    # a silly wrapper to make a bytes stream backed by a unicode one.

    # sys.stdin can be None

    if sys.stdin:

        stdin = sys.stdin.buffer

    else:

    stdout = _make_write_all(sys.stdout.buffer)

    stderr = _make_write_all(sys.stderr.buffer)

    if pycompat.iswindows:

        # Work around Windows bugs.

        stdout = platform.winstdout(stdout)

        stderr = platform.winstdout(stderr)

    if isatty(stdout):

        # The standard library doesn't offer line-buffered binary streams.

        stdout = make_line_buffered(stdout)

else:

    # Python 2 uses the I/O streams provided by the C library.

    stdin = sys.stdin

    stdout = sys.stdout

    stderr = sys.stderr

    if pycompat.iswindows:

        # Work around Windows bugs.

        stdout = platform.winstdout(stdout)

        stderr = platform.winstdout(stderr)

    if isatty(stdout):

        if pycompat.iswindows:

            # The Windows C runtime library doesn't support line buffering.

            stdout = make_line_buffered(stdout)

        else:

            # glibc determines buffering on first write to stdout - if we

            # replace a TTY destined stdout with a pipe destined stdout (e.g.

            # pager), we want line buffering.

            stdout = os.fdopen(stdout.fileno(), 'wb', 1)

findexe = platform.findexe

_gethgcmd = platform.gethgcmd

getuser = platform.getuser

getpid = os.getpid

hidewindow = platform.hidewindow

readpipe = platform.readpipe

setbinary = platform.setbinary

setsignalhandler = platform.setsignalhandler

shellquote = platform.shellquote

shellsplit = platform.shellsplit

spawndetached = platform.spawndetached

sshargs = platform.sshargs

testpid = platform.testpid

try:

    setprocname = osutil.setprocname

except AttributeError:

    pass

try:

    unblocksignal = osutil.unblocksignal

except AttributeError:

    pass

closefds = pycompat.isposix

def explainexit(code):

    """return a message describing a subprocess status

    (codes from kill are negative - not os.system/wait encoding)"""

    if code >= 0:

        return _(b"exited with status %d") % code

    return _(b"killed by signal %d") % -code

class _pfile(object):

    """File-like wrapper for a stream opened by subprocess.Popen()"""

    def __init__(self, proc, fp):

        self._proc = proc

        self._fp = fp

    def close(self):

        # unlike os.popen(), this returns an integer in subprocess coding

        self._fp.close()

        return self._proc.wait()

    def __iter__(self):

        return iter(self._fp)

    def __getattr__(self, attr):

        return getattr(self._fp, attr)

    def __enter__(self):

        return self

    def __exit__(self, exc_type, exc_value, exc_tb):

        self.close()

def popen(cmd, mode=b'rb', bufsize=-1):

    if mode == b'rb':

        return _popenreader(cmd, bufsize)

    elif mode == b'wb':

        return _popenwriter(cmd, bufsize)

    raise error.ProgrammingError(b'unsupported mode: %r' % mode)

def _popenreader(cmd, bufsize):

    p = subprocess.Popen(

        tonativestr(cmd),

        shell=True,

        bufsize=bufsize,

        close_fds=closefds,

        stdout=subprocess.PIPE,

    )

    return _pfile(p, p.stdout)

def _popenwriter(cmd, bufsize):

    p = subprocess.Popen(

        tonativestr(cmd),

        shell=True,

        bufsize=bufsize,

        close_fds=closefds,

        stdin=subprocess.PIPE,

    )

    return _pfile(p, p.stdin)

def popen2(cmd, env=None):

    # Setting bufsize to -1 lets the system decide the buffer size.

    # The default for bufsize is 0, meaning unbuffered. This leads to

    # poor performance on Mac OS X: http://bugs.python.org/issue4194

    p = subprocess.Popen(

        tonativestr(cmd),

        shell=True,

        bufsize=-1,

        close_fds=closefds,

        stdin=subprocess.PIPE,

        stdout=subprocess.PIPE,

        env=tonativeenv(env),

    )

    return p.stdin, p.stdout

def popen3(cmd, env=None):

    stdin, stdout, stderr, p = popen4(cmd, env)

    return stdin, stdout, stderr

def popen4(cmd, env=None, bufsize=-1):

    p = subprocess.Popen(

        tonativestr(cmd),

        shell=True,

        bufsize=bufsize,

        close_fds=closefds,

        stdin=subprocess.PIPE,

        stdout=subprocess.PIPE,

        stderr=subprocess.PIPE,

        env=tonativeenv(env),

    )

    return p.stdin, p.stdout, p.stderr, p

def pipefilter(s, cmd):

    '''filter string S through command CMD, returning its output'''

    p = subprocess.Popen(

        tonativestr(cmd),

        shell=True,

        close_fds=closefds,

        stdin=subprocess.PIPE,

        stdout=subprocess.PIPE,

    )

    pout, perr = p.communicate(s)

    return pout

def tempfilter(s, cmd):

    """filter string S through a pair of temporary files with CMD.

    CMD is used as a template to create the real command to be run,

    with the strings INFILE and OUTFILE replaced by the real names of

    the temporary files generated."""

    inname, outname = None, None

    try:

        infd, inname = pycompat.mkstemp(prefix=b'hg-filter-in-')

        fp = os.fdopen(infd, 'wb')

        fp.write(s)

        fp.close()

        outfd, outname = pycompat.mkstemp(prefix=b'hg-filter-out-')

        os.close(outfd)

        cmd = cmd.replace(b'INFILE', inname)

        cmd = cmd.replace(b'OUTFILE', outname)

        code = system(cmd)

        if pycompat.sysplatform == b'OpenVMS' and code & 1:

            code = 0

        if code:

            raise error.Abort(

                _(b"command '%s' failed: %s") % (cmd, explainexit(code))

            )

        with open(outname, b'rb') as fp:

            return fp.read()

    finally:

        try:

            if inname:

                os.unlink(inname)

        except OSError:

            pass

        try:

            if outname:

                os.unlink(outname)

        except OSError:

            pass

_filtertable = {

    b'tempfile:': tempfilter,

    b'pipe:': pipefilter,

}

def filter(s, cmd):

    """filter a string through a command that transforms its input to its

    output"""

    for name, fn in pycompat.iteritems(_filtertable):

        if cmd.startswith(name):

            return fn(s, cmd[len(name) :].lstrip())

    return pipefilter(s, cmd)

_hgexecutable = None

def hgexecutable():

    """return location of the 'hg' executable.

    Defaults to $HG or 'hg' in the search path.

    """

    if _hgexecutable is None:

        hg = encoding.environ.get(b'HG')

        mainmod = sys.modules['__main__']

        if hg:

            _sethgexecutable(hg)

        elif resourceutil.mainfrozen():

            if getattr(sys, 'frozen', None) == 'macosx_app':

                # Env variable set by py2app

                _sethgexecutable(encoding.environ[b'EXECUTABLEPATH'])

            else:

                _sethgexecutable(pycompat.sysexecutable)

        elif (

            not pycompat.iswindows

            and os.path.basename(getattr(mainmod, '__file__', '')) == 'hg'

        ):

            _sethgexecutable(pycompat.fsencode(mainmod.__file__))

        else:

            _sethgexecutable(

                findexe(b'hg') or os.path.basename(pycompat.sysargv[0])

            )

    return _hgexecutable