# Subversion 1.4/1.5 Python API backend

#

# Copyright(C) 2007 Daniel Holth et al

from __future__ import absolute_import

import os

import re

import xml.dom.minidom

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial import (

    encoding,

    error,

    pycompat,

    util,

    vfs as vfsmod,

)

from mercurial.utils import (

    dateutil,

    procutil,

    stringutil,

)

from . import common

pickle = util.pickle

stringio = util.stringio

propertycache = util.propertycache

urlerr = util.urlerr

urlreq = util.urlreq

commandline = common.commandline

commit = common.commit

converter_sink = common.converter_sink

converter_source = common.converter_source

decodeargs = common.decodeargs

encodeargs = common.encodeargs

makedatetimestamp = common.makedatetimestamp

mapfile = common.mapfile

MissingTool = common.MissingTool

NoRepo = common.NoRepo

# Subversion stuff. Works best with very recent Python SVN bindings

# e.g. SVN 1.5 or backports. Thanks to the bzr folks for enhancing

# these bindings.

try:

    import svn

    import svn.client

    import svn.core

    import svn.ra

    import svn.delta

    from . import transport

    import warnings

    warnings.filterwarnings(

        b'ignore', module=b'svn.core', category=DeprecationWarning

    )

    svn.core.SubversionException  # trigger import to catch error

except ImportError:

    svn = None

class SvnPathNotFound(Exception):

    pass

def revsplit(rev):

    """Parse a revision string and return (uuid, path, revnum).

    >>> revsplit(b'svn:a2147622-4a9f-4db4-a8d3-13562ff547b2'

    ...          b'/proj%20B/mytrunk/mytrunk@1')

    ('a2147622-4a9f-4db4-a8d3-13562ff547b2', '/proj%20B/mytrunk/mytrunk', 1)

    >>> revsplit(b'svn:8af66a51-67f5-4354-b62c-98d67cc7be1d@1')

    ('', '', 1)

    >>> revsplit(b'@7')

    ('', '', 7)

    >>> revsplit(b'7')

    ('', '', 0)

    >>> revsplit(b'bad')

    ('', '', 0)

    """

    parts = rev.rsplit(b'@', 1)

    revnum = 0

    if len(parts) > 1:

        revnum = int(parts[1])

    parts = parts[0].split(b'/', 1)

    uuid = b''

    mod = b''

    if len(parts) > 1 and parts[0].startswith(b'svn:'):

        uuid = parts[0][4:]

        mod = b'/' + parts[1]

    return uuid, mod, revnum

def quote(s):

    # As of svn 1.7, many svn calls expect "canonical" paths. In

    # theory, we should call svn.core.*canonicalize() on all paths

    # before passing them to the API.  Instead, we assume the base url

    # is canonical and copy the behaviour of svn URL encoding function

    # so we can extend it safely with new components. The "safe"

    # characters were taken from the "svn_uri__char_validity" table in

    # libsvn_subr/path.c.

    return urlreq.quote(s, b"!$&'()*+,-./:=@_~")

def geturl(path):

    try:

        return svn.client.url_from_path(svn.core.svn_path_canonicalize(path))

    except svn.core.SubversionException:

        # svn.client.url_from_path() fails with local repositories

        pass

    if os.path.isdir(path):

        path = os.path.normpath(os.path.abspath(path))

        if pycompat.iswindows:

            path = b'/' + util.normpath(path)

        # Module URL is later compared with the repository URL returned

        # by svn API, which is UTF-8.

        path = encoding.tolocal(path)

        path = b'file://%s' % quote(path)

    return svn.core.svn_path_canonicalize(path)

def optrev(number):

    optrev = svn.core.svn_opt_revision_t()

    optrev.kind = svn.core.svn_opt_revision_number

    optrev.value.number = number

    return optrev

class changedpath(object):

    def __init__(self, p):

        self.copyfrom_path = p.copyfrom_path

        self.copyfrom_rev = p.copyfrom_rev

        self.action = p.action

def get_log_child(

    fp,

    url,

    paths,

    start,

    end,

    limit=0,

    discover_changed_paths=True,

    strict_node_history=False,

):

    protocol = -1

    def receiver(orig_paths, revnum, author, date, message, pool):

        paths = {}

        if orig_paths is not None:

            for k, v in pycompat.iteritems(orig_paths):

                paths[k] = changedpath(v)

        pickle.dump((paths, revnum, author, date, message), fp, protocol)

    try:

        # Use an ra of our own so that our parent can consume

        # our results without confusing the server.

        t = transport.SvnRaTransport(url=url)

        svn.ra.get_log(

            t.ra,

            paths,

            start,

            end,

            limit,

            discover_changed_paths,

            strict_node_history,

            receiver,

        )

    except IOError:

        # Caller may interrupt the iteration

        pickle.dump(None, fp, protocol)

    except Exception as inst:

        pickle.dump(stringutil.forcebytestr(inst), fp, protocol)

    else:

        pickle.dump(None, fp, protocol)

    fp.flush()

    # With large history, cleanup process goes crazy and suddenly

    # consumes *huge* amount of memory. The output file being closed,

    # there is no need for clean termination.

    os._exit(0)

def debugsvnlog(ui, **opts):

    """Fetch SVN log in a subprocess and channel them back to parent to

    avoid memory collection issues.

    """

    if svn is None:

        raise error.Abort(

        )

    args = decodeargs(ui.fin.read())

    get_log_child(ui.fout, *args)

class logstream(object):

    """Interruptible revision log iterator."""

    def __init__(self, stdout):

        self._stdout = stdout

    def __iter__(self):

        while True:

            try:

                entry = pickle.load(self._stdout)

            except EOFError:

                raise error.Abort(

                    _(

                        b'Mercurial failed to run itself, check'

                        b' hg executable is in PATH'

                    )

                )

            try:

                orig_paths, revnum, author, date, message = entry

            except (TypeError, ValueError):

                if entry is None:

                    break

                raise error.Abort(_(b"log stream exception '%s'") % entry)

            yield entry

    def close(self):

        if self._stdout:

            self._stdout.close()

            self._stdout = None

class directlogstream(list):

    """Direct revision log iterator.

    This can be used for debugging and development but it will probably leak

    memory and is not suitable for real conversions."""

    def __init__(

        self,

        url,

        paths,

        start,

        end,

        limit=0,

        discover_changed_paths=True,

        strict_node_history=False,

    ):

        def receiver(orig_paths, revnum, author, date, message, pool):

            paths = {}

            if orig_paths is not None:

                for k, v in pycompat.iteritems(orig_paths):

                    paths[k] = changedpath(v)

            self.append((paths, revnum, author, date, message))

        # Use an ra of our own so that our parent can consume

        # our results without confusing the server.

        t = transport.SvnRaTransport(url=url)

        svn.ra.get_log(

            t.ra,

            paths,

            start,

            end,

            limit,

            discover_changed_paths,

            strict_node_history,

            receiver,

        )

    def close(self):

        pass

# Check to see if the given path is a local Subversion repo. Verify this by

# looking for several svn-specific files and directories in the given

# directory.

def filecheck(ui, path, proto):

    for x in (b'locks', b'hooks', b'format', b'db'):

        if not os.path.exists(os.path.join(path, x)):

            return False

    return True

# Check to see if a given path is the root of an svn repo over http. We verify

# this by requesting a version-controlled URL we know can't exist and looking

# for the svn-specific "not found" XML.

def httpcheck(ui, path, proto):

    try:

        opener = urlreq.buildopener()

        rsp = opener.open(b'%s://%s/!svn/ver/0/.svn' % (proto, path), b'rb')

        data = rsp.read()

    except urlerr.httperror as inst:

        if inst.code != 404:

            # Except for 404 we cannot know for sure this is not an svn repo

            ui.warn(

                _(

                    b'svn: cannot probe remote repository, assume it could '

                    b'be a subversion repository. Use --source-type if you '

                    b'know better.\n'

                )

            )

            return True

        data = inst.fp.read()

    except Exception:

        # Could be urlerr.urlerror if the URL is invalid or anything else.

        return False

    return b'<m:human-readable errcode="160013">' in data

protomap = {

    b'http': httpcheck,

    b'https': httpcheck,

    b'file': filecheck,

}

def issvnurl(ui, url):

    try:

        proto, path = url.split(b'://', 1)

        if proto == b'file':

            if (

                pycompat.iswindows

                and path[:1] == b'/'

                and path[1:2].isalpha()

                and path[2:6].lower() == b'%3a/'

            ):

                path = path[:2] + b':/' + path[6:]

            path = urlreq.url2pathname(path)

    except ValueError:

        proto = b'file'

        path = os.path.abspath(url)

    if proto == b'file':

        path = util.pconvert(path)

    check = protomap.get(proto, lambda *args: False)

    while b'/' in path:

        if check(ui, path, proto):

            return True

        path = path.rsplit(b'/', 1)[0]

    return False

# SVN conversion code stolen from bzr-svn and tailor

#

# Subversion looks like a versioned filesystem, branches structures

# are defined by conventions and not enforced by the tool. First,

# we define the potential branches (modules) as "trunk" and "branches"

# children directories. Revisions are then identified by their

# module and revision number (and a repository identifier).

#

# The revision graph is really a tree (or a forest). By default, a

# revision parent is the previous revision in the same module. If the

# module directory is copied/moved from another module then the

# revision is the module root and its parent the source revision in

# the parent module. A revision has at most one parent.

#

class svn_source(converter_source):

    def __init__(self, ui, repotype, url, revs=None):

        super(svn_source, self).__init__(ui, repotype, url, revs=revs)

        if not (

            url.startswith(b'svn://')

            or url.startswith(b'svn+ssh://')

            or (

                os.path.exists(url)

                and os.path.exists(os.path.join(url, b'.svn'))

            )

            or issvnurl(ui, url)

        ):

            raise NoRepo(

                _(b"%s does not look like a Subversion repository") % url

            )

        if svn is None:

            raise MissingTool(_(b'could not load Subversion python bindings'))

        try:

            version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR

            if version < (1, 4):

                raise MissingTool(

                    _(

                        b'Subversion python bindings %d.%d found, '

                        b'1.4 or later required'

                    )

                    % version

                )

        except AttributeError:

            raise MissingTool(

                _(

                    b'Subversion python bindings are too old, 1.4 '

                    b'or later required'

                )

            )

        self.lastrevs = {}