# util.py - Mercurial utility functions and platform specific implementations

#

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

"""Mercurial utility functions and platform specific implementations.

This contains helper routines that are independent of the SCM core and

hide platform-specific details from the core.

"""

from __future__ import absolute_import

import bz2

import calendar

import collections

import datetime

import errno

import gc

import hashlib

import imp

import os

import re as remod

import shutil

import signal

import socket

import subprocess

import sys

import tempfile

import textwrap

import time

import traceback

import zlib

from . import (

    encoding,

    error,

    i18n,

    osutil,

    parsers,

    pycompat,

)

for attr in (

    'empty',

    'pickle',

    'queue',

    'urlerr',

    # we do import urlreq, but we do it outside the loop

    #'urlreq',

    'stringio',

):

    globals()[attr] = getattr(pycompat, attr)

# This line is to make pyflakes happy:

urlreq = pycompat.urlreq

if os.name == 'nt':

    from . import windows as platform

else:

    from . import posix as platform

_ = i18n._

cachestat = platform.cachestat

checkexec = platform.checkexec

checklink = platform.checklink

copymode = platform.copymode

executablepath = platform.executablepath

expandglobs = platform.expandglobs

explainexit = platform.explainexit

findexe = platform.findexe

gethgcmd = platform.gethgcmd

getuser = platform.getuser

getpid = os.getpid

groupmembers = platform.groupmembers

groupname = platform.groupname

hidewindow = platform.hidewindow

isexec = platform.isexec

isowner = platform.isowner

localpath = platform.localpath

lookupreg = platform.lookupreg

makedir = platform.makedir

nlinks = platform.nlinks

normpath = platform.normpath

normcase = platform.normcase

normcasespec = platform.normcasespec

normcasefallback = platform.normcasefallback

openhardlinks = platform.openhardlinks

oslink = platform.oslink

parsepatchoutput = platform.parsepatchoutput

pconvert = platform.pconvert

poll = platform.poll

popen = platform.popen

posixfile = platform.posixfile

quotecommand = platform.quotecommand

readpipe = platform.readpipe

rename = platform.rename

removedirs = platform.removedirs

samedevice = platform.samedevice

samefile = platform.samefile

samestat = platform.samestat

setbinary = platform.setbinary

setflags = platform.setflags

setsignalhandler = platform.setsignalhandler

shellquote = platform.shellquote

spawndetached = platform.spawndetached

split = platform.split

sshargs = platform.sshargs

statfiles = getattr(osutil, 'statfiles', platform.statfiles)

statisexec = platform.statisexec

statislink = platform.statislink

termwidth = platform.termwidth

testpid = platform.testpid

umask = platform.umask

unlink = platform.unlink

unlinkpath = platform.unlinkpath

username = platform.username

# Python compatibility

_notset = object()

# disable Python's problematic floating point timestamps (issue4836)

# (Python hypocritically says you shouldn't change this behavior in

# libraries, and sure enough Mercurial is not a library.)

os.stat_float_times(False)

def safehasattr(thing, attr):

    return getattr(thing, attr, _notset) is not _notset

DIGESTS = {

    'md5': hashlib.md5,

    'sha1': hashlib.sha1,

    'sha512': hashlib.sha512,

}

# List of digest types from strongest to weakest

DIGESTS_BY_STRENGTH = ['sha512', 'sha1', 'md5']

for k in DIGESTS_BY_STRENGTH:

    assert k in DIGESTS

class digester(object):

    """helper to compute digests.

    This helper can be used to compute one or more digests given their name.

    >>> d = digester(['md5', 'sha1'])

    >>> d.update('foo')

    >>> [k for k in sorted(d)]

    ['md5', 'sha1']

    >>> d['md5']

    'acbd18db4cc2f85cedef654fccc4a4d8'

    >>> d['sha1']

    '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33'

    >>> digester.preferred(['md5', 'sha1'])

    'sha1'

    """

    def __init__(self, digests, s=''):

        self._hashes = {}

        for k in digests:

            if k not in DIGESTS:

                raise Abort(_('unknown digest type: %s') % k)

            self._hashes[k] = DIGESTS[k]()

        if s:

            self.update(s)

    def update(self, data):

        for h in self._hashes.values():

            h.update(data)

    def __getitem__(self, key):

        if key not in DIGESTS:

            raise Abort(_('unknown digest type: %s') % k)

        return self._hashes[key].hexdigest()

    def __iter__(self):

        return iter(self._hashes)

    @staticmethod

    def preferred(supported):

        """returns the strongest digest type in both supported and DIGESTS."""

        for k in DIGESTS_BY_STRENGTH:

            if k in supported:

                return k

        return None

class digestchecker(object):

    """file handle wrapper that additionally checks content against a given

    size and digests.

        d = digestchecker(fh, size, {'md5': '...'})

    When multiple digests are given, all of them are validated.

    """

    def __init__(self, fh, size, digests):

        self._fh = fh

        self._size = size

        self._got = 0

        self._digests = dict(digests)

        self._digester = digester(self._digests.keys())

    def read(self, length=-1):

        content = self._fh.read(length)

        self._digester.update(content)

        self._got += len(content)

        return content

    def validate(self):

        if self._size != self._got:

            raise Abort(_('size mismatch: expected %d, got %d') %

                (self._size, self._got))

        for k, v in self._digests.items():

            if v != self._digester[k]:

                # i18n: first parameter is a digest name

                raise Abort(_('%s mismatch: expected %s, got %s') %

                    (k, v, self._digester[k]))

try:

    buffer = buffer

except NameError:

    if sys.version_info[0] < 3:

        def buffer(sliceable, offset=0):

            return sliceable[offset:]

    else:

        def buffer(sliceable, offset=0):

            return memoryview(sliceable)[offset:]

closefds = os.name == 'posix'

_chunksize = 4096

class bufferedinputpipe(object):

    """a manually buffered input pipe

    Python will not let us use buffered IO and lazy reading with 'polling' at

    the same time. We cannot probe the buffer state and select will not detect

    that data are ready to read if they are already buffered.

    This class let us work around that by implementing its own buffering

    (allowing efficient readline) while offering a way to know if the buffer is

    empty from the output (allowing collaboration of the buffer with polling).

    This class lives in the 'util' module because it makes use of the 'os'

    module from the python stdlib.

    """

    def __init__(self, input):

        self._input = input

        self._buffer = []

        self._eof = False

        self._lenbuf = 0

    @property

    def hasbuffer(self):

        """True is any data is currently buffered

        This will be used externally a pre-step for polling IO. If there is

        already data then no polling should be set in place."""

        return bool(self._buffer)

    @property

    def closed(self):

        return self._input.closed

    def fileno(self):

        return self._input.fileno()

    def close(self):

        return self._input.close()

    def read(self, size):

        while (not self._eof) and (self._lenbuf < size):

            self._fillbuffer()

        return self._frombuffer(size)

    def readline(self, *args, **kwargs):

        if 1 < len(self._buffer):

            # this should not happen because both read and readline end with a

            # _frombuffer call that collapse it.

            self._buffer = [''.join(self._buffer)]

            self._lenbuf = len(self._buffer[0])

        lfi = -1

        if self._buffer:

            lfi = self._buffer[-1].find('\n')

        while (not self._eof) and lfi < 0:

            self._fillbuffer()

            if self._buffer:

                lfi = self._buffer[-1].find('\n')

        size = lfi + 1

        if lfi < 0: # end of file

            size = self._lenbuf

        elif 1 < len(self._buffer):

            # we need to take previous chunks into account

            size += self._lenbuf - len(self._buffer[-1])

        return self._frombuffer(size)

    def _frombuffer(self, size):

        """return at most 'size' data from the buffer

        The data are removed from the buffer."""

        if size == 0 or not self._buffer:

            return ''

        buf = self._buffer[0]

        if 1 < len(self._buffer):

            buf = ''.join(self._buffer)

        data = buf[:size]

        buf = buf[len(data):]

        if buf:

            self._buffer = [buf]

            self._lenbuf = len(buf)

        else:

            self._buffer = []

            self._lenbuf = 0

        return data

    def _fillbuffer(self):

        """read data to the buffer"""

        data = os.read(self._input.fileno(), _chunksize)

        if not data:

            self._eof = True

        else:

            self._lenbuf += len(data)

            self._buffer.append(data)

def popen2(cmd, env=None, newlines=False):

    # 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(cmd, shell=True, bufsize=-1,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         universal_newlines=newlines,

                         env=env)

    return p.stdin, p.stdout

def popen3(cmd, env=None, newlines=False):

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

    return stdin, stdout, stderr

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

    p = subprocess.Popen(cmd, shell=True, bufsize=bufsize,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         stderr=subprocess.PIPE,

                         universal_newlines=newlines,

                         env=env)

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

def version():

    """Return version information if available."""

    try:

        from . import __version__

        return __version__.version

    except ImportError:

        return 'unknown'

def versiontuple(v=None, n=4):

    """Parses a Mercurial version string into an N-tuple.

    The version string to be parsed is specified with the ``v`` argument.

    If it isn't defined, the current Mercurial version string will be parsed.

    ``n`` can be 2, 3, or 4. Here is how some version strings map to

    returned values:

    >>> v = '3.6.1+190-df9b73d2d444'

    >>> versiontuple(v, 2)

    (3, 6)

    >>> versiontuple(v, 3)

    (3, 6, 1)

    >>> versiontuple(v, 4)

    (3, 6, 1, '190-df9b73d2d444')

    >>> versiontuple('3.6.1+190-df9b73d2d444+20151118')

    (3, 6, 1, '190-df9b73d2d444+20151118')

    >>> v = '3.6'

    >>> versiontuple(v, 2)

    (3, 6)

    >>> versiontuple(v, 3)

    (3, 6, None)

    >>> versiontuple(v, 4)

    (3, 6, None, None)