vcsserver/remote/svn_remote.py

# RhodeCode VCSServer provides access to different vcs backends via network.
# Copyright (C) 2014-2023 RhodeCode GmbH
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA


import os
import subprocess
from urllib.error import URLError
import urllib.parse
import logging
import posixpath as vcspath
import io
import urllib.request
import urllib.parse
import urllib.error
import traceback


import svn.client  # noqa
import svn.core  # noqa
import svn.delta  # noqa
import svn.diff  # noqa
import svn.fs  # noqa
import svn.repos  # noqa

from vcsserver import svn_diff, exceptions, subprocessio, settings
from vcsserver.base import (
    RepoFactory,
    raise_from_original,
    ArchiveNode,
    store_archive_in_cache,
    BytesEnvelope,
    BinaryEnvelope,
)
from vcsserver.exceptions import NoContentException
from vcsserver.str_utils import safe_str, safe_bytes
from vcsserver.type_utils import assert_bytes
from vcsserver.vcs_base import RemoteBase
from vcsserver.lib.svnremoterepo import svnremoterepo

log = logging.getLogger(__name__)


svn_compatible_versions_map = {
    'pre-1.4-compatible': '1.3',
    'pre-1.5-compatible': '1.4',
    'pre-1.6-compatible': '1.5',
    'pre-1.8-compatible': '1.7',
    'pre-1.9-compatible': '1.8',
}

current_compatible_version = '1.14'


def reraise_safe_exceptions(func):
    """Decorator for converting svn exceptions to something neutral."""
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            if not hasattr(e, '_vcs_kind'):
                log.exception("Unhandled exception in svn remote call")
                raise_from_original(exceptions.UnhandledException(e), e)
            raise
    return wrapper


class SubversionFactory(RepoFactory):
    repo_type = 'svn'

    def _create_repo(self, wire, create, compatible_version):
        path = svn.core.svn_path_canonicalize(wire['path'])
        if create:
            fs_config = {'compatible-version': current_compatible_version}
            if compatible_version:

                compatible_version_string = \
                    svn_compatible_versions_map.get(compatible_version) \
                    or compatible_version
                fs_config['compatible-version'] = compatible_version_string

            log.debug('Create SVN repo with config `%s`', fs_config)
            repo = svn.repos.create(path, "", "", None, fs_config)
        else:
            repo = svn.repos.open(path)

        log.debug('repository created: got SVN object: %s', repo)
        return repo

    def repo(self, wire, create=False, compatible_version=None):
        """
        Get a repository instance for the given path.
        """
        return self._create_repo(wire, create, compatible_version)


NODE_TYPE_MAPPING = {
    svn.core.svn_node_file: 'file',
    svn.core.svn_node_dir: 'dir',
}


class SvnRemote(RemoteBase):

    def __init__(self, factory, hg_factory=None):
        self._factory = factory

        self._bulk_methods = {
            # NOT supported in SVN ATM...
        }
        self._bulk_file_methods = {
            "size": self.get_file_size,
            "data": self.get_file_content,
            "flags": self.get_node_type,
            "is_binary": self.is_binary,
            "md5": self.md5_hash
        }

    @reraise_safe_exceptions
    def bulk_file_request(self, wire, commit_id, path, pre_load):
        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        # since we use unified API, we need to cast from str to in for SVN
        commit_id = int(commit_id)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _bulk_file_request(_repo_id, _commit_id, _path, _pre_load):
            result = {}
            for attr in pre_load:
                try:
                    method = self._bulk_file_methods[attr]
                    wire.update({'cache': False})  # disable cache for bulk calls so we don't double cache
                    result[attr] = method(wire, _commit_id, _path)
                except KeyError as e:
                    raise exceptions.VcsException(e)(f'Unknown bulk attribute: "{attr}"')
            return result

        return BinaryEnvelope(_bulk_file_request(repo_id, commit_id, path, sorted(pre_load)))

    @reraise_safe_exceptions
    def discover_svn_version(self):
        try:
            import svn.core
            svn_ver = svn.core.SVN_VERSION
        except ImportError:
            svn_ver = None
        return safe_str(svn_ver)

    @reraise_safe_exceptions
    def is_empty(self, wire):
        try:
            return self.lookup(wire, -1) == 0
        except Exception:
            log.exception("failed to read object_store")
            return False

    def check_url(self, url, config):

        # uuid function gets only valid UUID from proper repo, else
        # throws exception
        username, password, src_url = self.get_url_and_credentials(url)
        try:
            svnremoterepo(safe_bytes(username), safe_bytes(password), safe_bytes(src_url)).svn().uuid
        except Exception:
            tb = traceback.format_exc()
            log.debug("Invalid Subversion url: `%s`, tb: %s", url, tb)
            raise URLError(f'"{url}" is not a valid Subversion source url.')
        return True

    def is_path_valid_repository(self, wire, path):
        # NOTE(marcink):  short circuit the check for SVN repo
        # the repos.open might be expensive to check, but we have one cheap
        # pre-condition that we can use, to check for 'format' file
        if not os.path.isfile(os.path.join(path, 'format')):
            return False

        try:
            svn.repos.open(path)
        except svn.core.SubversionException:
            tb = traceback.format_exc()
            log.debug("Invalid Subversion path `%s`, tb: %s", path, tb)
            return False
        return True

    @reraise_safe_exceptions
    def verify(self, wire,):
        repo_path = wire['path']
        if not self.is_path_valid_repository(wire, repo_path):
            raise Exception(
                f"Path {repo_path} is not a valid Subversion repository.")

        cmd = ['svnadmin', 'info', repo_path]
        stdout, stderr = subprocessio.run_command(cmd)
        return stdout

    @reraise_safe_exceptions
    def lookup(self, wire, revision):
        if revision not in [-1, None, 'HEAD']:
            raise NotImplementedError
        repo = self._factory.repo(wire)
        fs_ptr = svn.repos.fs(repo)
        head = svn.fs.youngest_rev(fs_ptr)
        return head

    @reraise_safe_exceptions
    def lookup_interval(self, wire, start_ts, end_ts):
        repo = self._factory.repo(wire)
        fsobj = svn.repos.fs(repo)
        start_rev = None
        end_rev = None
        if start_ts:
            start_ts_svn = apr_time_t(start_ts)
            start_rev = svn.repos.dated_revision(repo, start_ts_svn) + 1
        else:
            start_rev = 1
        if end_ts:
            end_ts_svn = apr_time_t(end_ts)
            end_rev = svn.repos.dated_revision(repo, end_ts_svn)
        else:
            end_rev = svn.fs.youngest_rev(fsobj)
        return start_rev, end_rev

    @reraise_safe_exceptions
    def revision_properties(self, wire, revision):

        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _revision_properties(_repo_id, _revision):
            repo = self._factory.repo(wire)
            fs_ptr = svn.repos.fs(repo)
            return svn.fs.revision_proplist(fs_ptr, revision)
        return _revision_properties(repo_id, revision)

    def revision_changes(self, wire, revision):

        repo = self._factory.repo(wire)
        fsobj = svn.repos.fs(repo)
        rev_root = svn.fs.revision_root(fsobj, revision)

        editor = svn.repos.ChangeCollector(fsobj, rev_root)
        editor_ptr, editor_baton = svn.delta.make_editor(editor)
        base_dir = ""
        send_deltas = False
        svn.repos.replay2(
            rev_root, base_dir, svn.core.SVN_INVALID_REVNUM, send_deltas,
            editor_ptr, editor_baton, None)

        added = []
        changed = []
        removed = []

        # TODO: CHANGE_ACTION_REPLACE: Figure out where it belongs
        for path, change in editor.changes.items():
            # TODO: Decide what to do with directory nodes. Subversion can add
            # empty directories.

            if change.item_kind == svn.core.svn_node_dir:
                continue
            if change.action in [svn.repos.CHANGE_ACTION_ADD]:
                added.append(path)
            elif change.action in [svn.repos.CHANGE_ACTION_MODIFY,
                                   svn.repos.CHANGE_ACTION_REPLACE]:
                changed.append(path)
            elif change.action in [svn.repos.CHANGE_ACTION_DELETE]:
                removed.append(path)
            else:
                raise NotImplementedError(
                    "Action {} not supported on path {}".format(
                        change.action, path))

        changes = {
            'added': added,
            'changed': changed,
            'removed': removed,
        }
        return changes

    @reraise_safe_exceptions
    def node_history(self, wire, path, revision, limit):
        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _assert_correct_path(_context_uid, _repo_id, _path, _revision, _limit):
            cross_copies = False
            repo = self._factory.repo(wire)
            fsobj = svn.repos.fs(repo)
            rev_root = svn.fs.revision_root(fsobj, revision)

            history_revisions = []
            history = svn.fs.node_history(rev_root, path)
            history = svn.fs.history_prev(history, cross_copies)
            while history:
                __, node_revision = svn.fs.history_location(history)
                history_revisions.append(node_revision)
                if limit and len(history_revisions) >= limit:
                    break
                history = svn.fs.history_prev(history, cross_copies)
            return history_revisions
        return _assert_correct_path(context_uid, repo_id, path, revision, limit)

    @reraise_safe_exceptions
    def node_properties(self, wire, path, revision):
        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _node_properties(_repo_id, _path, _revision):
            repo = self._factory.repo(wire)
            fsobj = svn.repos.fs(repo)
            rev_root = svn.fs.revision_root(fsobj, revision)
            return svn.fs.node_proplist(rev_root, path)
        return _node_properties(repo_id, path, revision)

    def file_annotate(self, wire, path, revision):
        abs_path = 'file://' + urllib.request.pathname2url(
            vcspath.join(wire['path'], path))
        file_uri = svn.core.svn_path_canonicalize(abs_path)

        start_rev = svn_opt_revision_value_t(0)
        peg_rev = svn_opt_revision_value_t(revision)
        end_rev = peg_rev

        annotations = []

        def receiver(line_no, revision, author, date, line, pool):
            annotations.append((line_no, revision, line))

        # TODO: Cannot use blame5, missing typemap function in the swig code
        try:
            svn.client.blame2(
                file_uri, peg_rev, start_rev, end_rev,
                receiver, svn.client.create_context())
        except svn.core.SubversionException as exc:
            log.exception("Error during blame operation.")
            raise Exception(
                f"Blame not supported or file does not exist at path {path}. "
                f"Error {exc}.")

        return BinaryEnvelope(annotations)

    @reraise_safe_exceptions
    def get_node_type(self, wire, revision=None, path=''):

        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _get_node_type(_repo_id, _revision, _path):
            repo = self._factory.repo(wire)
            fs_ptr = svn.repos.fs(repo)
            if _revision is None:
                _revision = svn.fs.youngest_rev(fs_ptr)
            root = svn.fs.revision_root(fs_ptr, _revision)
            node = svn.fs.check_path(root, path)
            return NODE_TYPE_MAPPING.get(node, None)
        return _get_node_type(repo_id, revision, path)

    @reraise_safe_exceptions
    def get_nodes(self, wire, revision=None, path=''):

        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _get_nodes(_repo_id, _path, _revision):
            repo = self._factory.repo(wire)
            fsobj = svn.repos.fs(repo)
            if _revision is None:
                _revision = svn.fs.youngest_rev(fsobj)
            root = svn.fs.revision_root(fsobj, _revision)
            entries = svn.fs.dir_entries(root, path)
            result = []
            for entry_path, entry_info in entries.items():
                result.append(
                    (entry_path, NODE_TYPE_MAPPING.get(entry_info.kind, None)))
            return result
        return _get_nodes(repo_id, path, revision)

    @reraise_safe_exceptions
    def get_file_content(self, wire, rev=None, path=''):
        repo = self._factory.repo(wire)
        fsobj = svn.repos.fs(repo)

        if rev is None:
            rev = svn.fs.youngest_rev(fsobj)

        root = svn.fs.revision_root(fsobj, rev)
        content = svn.core.Stream(svn.fs.file_contents(root, path))
        return BytesEnvelope(content.read())

    @reraise_safe_exceptions
    def get_file_size(self, wire, revision=None, path=''):

        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _get_file_size(_repo_id, _revision, _path):
            repo = self._factory.repo(wire)
            fsobj = svn.repos.fs(repo)
            if _revision is None:
                _revision = svn.fs.youngest_revision(fsobj)
            root = svn.fs.revision_root(fsobj, _revision)
            size = svn.fs.file_length(root, path)
            return size
        return _get_file_size(repo_id, revision, path)

    def create_repository(self, wire, compatible_version=None):
        log.info('Creating Subversion repository in path "%s"', wire['path'])
        self._factory.repo(wire, create=True,
                           compatible_version=compatible_version)

    def get_url_and_credentials(self, src_url) -> tuple[str, str, str]:
        obj = urllib.parse.urlparse(src_url)
        username = obj.username or ''
        password = obj.password or ''
        return username, password, src_url

    def import_remote_repository(self, wire, src_url):
        repo_path = wire['path']
        if not self.is_path_valid_repository(wire, repo_path):
            raise Exception(
                f"Path {repo_path} is not a valid Subversion repository.")

        username, password, src_url = self.get_url_and_credentials(src_url)
        rdump_cmd = ['svnrdump', 'dump', '--non-interactive',
                     '--trust-server-cert-failures=unknown-ca']
        if username and password:
            rdump_cmd += ['--username', username, '--password', password]
        rdump_cmd += [src_url]

        rdump = subprocess.Popen(
            rdump_cmd,
            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        load = subprocess.Popen(
            ['svnadmin', 'load', repo_path], stdin=rdump.stdout)

        # TODO: johbo: This can be a very long operation, might be better
        # to track some kind of status and provide an api to check if the
        # import is done.
        rdump.wait()
        load.wait()

        log.debug('Return process ended with code: %s', rdump.returncode)
        if rdump.returncode != 0:
            errors = rdump.stderr.read()
            log.error('svnrdump dump failed: statuscode %s: message: %s', rdump.returncode, errors)

            reason = 'UNKNOWN'
            if b'svnrdump: E230001:' in errors:
                reason = 'INVALID_CERTIFICATE'

            if reason == 'UNKNOWN':
                reason = f'UNKNOWN:{safe_str(errors)}'

            raise Exception(
                'Failed to dump the remote repository from {}. Reason:{}'.format(
                    src_url, reason))
        if load.returncode != 0:
            raise Exception(
                f'Failed to load the dump of remote repository from {src_url}.')

    def commit(self, wire, message, author, timestamp, updated, removed):

        message = safe_bytes(message)
        author = safe_bytes(author)

        repo = self._factory.repo(wire)
        fsobj = svn.repos.fs(repo)

        rev = svn.fs.youngest_rev(fsobj)
        txn = svn.repos.fs_begin_txn_for_commit(repo, rev, author, message)
        txn_root = svn.fs.txn_root(txn)

        for node in updated:
            TxnNodeProcessor(node, txn_root).update()
        for node in removed:
            TxnNodeProcessor(node, txn_root).remove()

        commit_id = svn.repos.fs_commit_txn(repo, txn)

        if timestamp:
            apr_time = apr_time_t(timestamp)
            ts_formatted = svn.core.svn_time_to_cstring(apr_time)
            svn.fs.change_rev_prop(fsobj, commit_id, 'svn:date', ts_formatted)

        log.debug('Committed revision "%s" to "%s".', commit_id, wire['path'])
        return commit_id

    @reraise_safe_exceptions
    def diff(self, wire, rev1, rev2, path1=None, path2=None,
             ignore_whitespace=False, context=3):

        wire.update(cache=False)
        repo = self._factory.repo(wire)
        diff_creator = SvnDiffer(
            repo, rev1, path1, rev2, path2, ignore_whitespace, context)
        try:
            return BytesEnvelope(diff_creator.generate_diff())
        except svn.core.SubversionException as e:
            log.exception(
                "Error during diff operation operation. "
                "Path might not exist %s, %s", path1, path2)
            return BytesEnvelope(b'')

    @reraise_safe_exceptions
    def is_large_file(self, wire, path):
        return False

    @reraise_safe_exceptions
    def is_binary(self, wire, rev, path):
        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _is_binary(_repo_id, _rev, _path):
            raw_bytes = self.get_file_content(wire, rev, path)
            if not raw_bytes:
                return False
            return b'\0' in raw_bytes

        return _is_binary(repo_id, rev, path)

    @reraise_safe_exceptions
    def md5_hash(self, wire, rev, path):
        cache_on, context_uid, repo_id = self._cache_on(wire)
        region = self._region(wire)

        @region.conditional_cache_on_arguments(condition=cache_on)
        def _md5_hash(_repo_id, _rev, _path):
            return ''

        return _md5_hash(repo_id, rev, path)

    @reraise_safe_exceptions
    def run_svn_command(self, wire, cmd, **opts):
        path = wire.get('path', None)

        if path and os.path.isdir(path):
            opts['cwd'] = path

        safe_call = opts.pop('_safe', False)

        svnenv = os.environ.copy()
        svnenv.update(opts.pop('extra_env', {}))

        _opts = {'env': svnenv, 'shell': False}

        try:
            _opts.update(opts)
            proc = subprocessio.SubprocessIOChunker(cmd, **_opts)

            return b''.join(proc), b''.join(proc.stderr)
        except OSError as err:
            if safe_call:
                return '', safe_str(err).strip()
            else:
                cmd = ' '.join(map(safe_str, cmd))  # human friendly CMD
                tb_err = ("Couldn't run svn command (%s).\n"
                          "Original error was:%s\n"
                          "Call options:%s\n"
                          % (cmd, err, _opts))
                log.exception(tb_err)
                raise exceptions.VcsException()(tb_err)

    @reraise_safe_exceptions
    def install_hooks(self, wire, force=False):
        from vcsserver.hook_utils import install_svn_hooks
        repo_path = wire['path']
        binary_dir = settings.BINARY_DIR
        executable = None
        if binary_dir:
            executable = os.path.join(binary_dir, 'python3')
        return install_svn_hooks(repo_path, force_create=force)

    @reraise_safe_exceptions
    def get_hooks_info(self, wire):
        from vcsserver.hook_utils import (
            get_svn_pre_hook_version, get_svn_post_hook_version)
        repo_path = wire['path']
        return {
            'pre_version': get_svn_pre_hook_version(repo_path),
            'post_version': get_svn_post_hook_version(repo_path),
        }

    @reraise_safe_exceptions
    def set_head_ref(self, wire, head_name):
        pass

    @reraise_safe_exceptions
    def archive_repo(self, wire, archive_name_key, kind, mtime, archive_at_path,
                     archive_dir_name, commit_id, cache_config):

        def walk_tree(root, root_dir, _commit_id):
            """
            Special recursive svn repo walker
            """
            root_dir = safe_bytes(root_dir)

            filemode_default = 0o100644
            filemode_executable = 0o100755

            file_iter = svn.fs.dir_entries(root, root_dir)
            for f_name in file_iter:
                f_type = NODE_TYPE_MAPPING.get(file_iter[f_name].kind, None)

                if f_type == 'dir':
                    # return only DIR, and then all entries in that dir
                    yield os.path.join(root_dir, f_name), {'mode': filemode_default}, f_type
                    new_root = os.path.join(root_dir, f_name)
                    yield from walk_tree(root, new_root, _commit_id)
                else:

                    f_path = os.path.join(root_dir, f_name).rstrip(b'/')
                    prop_list = svn.fs.node_proplist(root, f_path)

                    f_mode = filemode_default
                    if prop_list.get('svn:executable'):
                        f_mode = filemode_executable

                    f_is_link = False
                    if prop_list.get('svn:special'):
                        f_is_link = True

                    data = {
                        'is_link': f_is_link,
                        'mode': f_mode,
                        'content_stream': svn.core.Stream(svn.fs.file_contents(root, f_path)).read
                    }

                    yield f_path, data, f_type

        def file_walker(_commit_id, path):
            repo = self._factory.repo(wire)
            root = svn.fs.revision_root(svn.repos.fs(repo), int(commit_id))

            def no_content():
                raise NoContentException()

            for f_name, f_data, f_type in walk_tree(root, path, _commit_id):
                file_path = f_name

                if f_type == 'dir':
                    mode = f_data['mode']
                    yield ArchiveNode(file_path, mode, False, no_content)
                else:
                    mode = f_data['mode']
                    is_link = f_data['is_link']
                    data_stream = f_data['content_stream']
                    yield ArchiveNode(file_path, mode, is_link, data_stream)

        return store_archive_in_cache(
            file_walker, archive_name_key, kind, mtime, archive_at_path, archive_dir_name, commit_id, cache_config=cache_config)


class SvnDiffer:
    """
    Utility to create diffs based on difflib and the Subversion api
    """

    binary_content = False

    def __init__(
            self, repo, src_rev, src_path, tgt_rev, tgt_path,
            ignore_whitespace, context):
        self.repo = repo
        self.ignore_whitespace = ignore_whitespace
        self.context = context

        fsobj = svn.repos.fs(repo)

        self.tgt_rev = tgt_rev
        self.tgt_path = tgt_path or ''
        self.tgt_root = svn.fs.revision_root(fsobj, tgt_rev)
        self.tgt_kind = svn.fs.check_path(self.tgt_root, self.tgt_path)

        self.src_rev = src_rev
        self.src_path = src_path or self.tgt_path
        self.src_root = svn.fs.revision_root(fsobj, src_rev)
        self.src_kind = svn.fs.check_path(self.src_root, self.src_path)

        self._validate()

    def _validate(self):
        if (self.tgt_kind != svn.core.svn_node_none and
                self.src_kind != svn.core.svn_node_none and
                self.src_kind != self.tgt_kind):
            # TODO: johbo: proper error handling
            raise Exception(
                "Source and target are not compatible for diff generation. "
                "Source type: %s, target type: %s" %
                (self.src_kind, self.tgt_kind))

    def generate_diff(self) -> bytes:
        buf = io.BytesIO()
        if self.tgt_kind == svn.core.svn_node_dir:
            self._generate_dir_diff(buf)
        else:
            self._generate_file_diff(buf)
        return buf.getvalue()

    def _generate_dir_diff(self, buf: io.BytesIO):
        editor = DiffChangeEditor()
        editor_ptr, editor_baton = svn.delta.make_editor(editor)
        svn.repos.dir_delta2(
            self.src_root,
            self.src_path,
            '',  # src_entry
            self.tgt_root,
            self.tgt_path,
            editor_ptr, editor_baton,
            authorization_callback_allow_all,
            False,  # text_deltas
            svn.core.svn_depth_infinity,  # depth
            False,  # entry_props
            False,  # ignore_ancestry
        )

        for path, __, change in sorted(editor.changes):
            self._generate_node_diff(
                buf, change, path, self.tgt_path, path, self.src_path)

    def _generate_file_diff(self, buf: io.BytesIO):
        change = None
        if self.src_kind == svn.core.svn_node_none:
            change = "add"
        elif self.tgt_kind == svn.core.svn_node_none:
            change = "delete"
        tgt_base, tgt_path = vcspath.split(self.tgt_path)
        src_base, src_path = vcspath.split(self.src_path)
        self._generate_node_diff(
            buf, change, tgt_path, tgt_base, src_path, src_base)

    def _generate_node_diff(
            self, buf: io.BytesIO, change, tgt_path, tgt_base, src_path, src_base):

        tgt_path_bytes = safe_bytes(tgt_path)
        tgt_path = safe_str(tgt_path)

        src_path_bytes = safe_bytes(src_path)
        src_path = safe_str(src_path)

        if self.src_rev == self.tgt_rev and tgt_base == src_base:
            # makes consistent behaviour with git/hg to return empty diff if
            # we compare same revisions
            return

        tgt_full_path = vcspath.join(tgt_base, tgt_path)
        src_full_path = vcspath.join(src_base, src_path)

        self.binary_content = False
        mime_type = self._get_mime_type(tgt_full_path)

        if mime_type and not mime_type.startswith(b'text'):
            self.binary_content = True
            buf.write(b"=" * 67 + b'\n')
            buf.write(b"Cannot display: file marked as a binary type.\n")
            buf.write(b"svn:mime-type = %s\n" % mime_type)
        buf.write(b"Index: %b\n" % tgt_path_bytes)
        buf.write(b"=" * 67 + b'\n')
        buf.write(b"diff --git a/%b b/%b\n" % (tgt_path_bytes, tgt_path_bytes))

        if change == 'add':
            # TODO: johbo: SVN is missing a zero here compared to git
            buf.write(b"new file mode 10644\n")

            # TODO(marcink): intro to binary detection of svn patches
            # if self.binary_content:
            #     buf.write(b'GIT binary patch\n')

            buf.write(b"--- /dev/null\t(revision 0)\n")
            src_lines = []
        else:
            if change == 'delete':
                buf.write(b"deleted file mode 10644\n")

            # TODO(marcink): intro to binary detection of svn patches
            # if self.binary_content:
            #     buf.write('GIT binary patch\n')

            buf.write(b"--- a/%b\t(revision %d)\n" % (src_path_bytes, self.src_rev))
            src_lines = self._svn_readlines(self.src_root, src_full_path)

        if change == 'delete':
            buf.write(b"+++ /dev/null\t(revision %d)\n" % self.tgt_rev)
            tgt_lines = []
        else:
            buf.write(b"+++ b/%b\t(revision %d)\n" % (tgt_path_bytes, self.tgt_rev))
            tgt_lines = self._svn_readlines(self.tgt_root, tgt_full_path)

        # we made our diff header, time to generate the diff content into our buffer

        if not self.binary_content:
            udiff = svn_diff.unified_diff(
                src_lines, tgt_lines, context=self.context,
                ignore_blank_lines=self.ignore_whitespace,
                ignore_case=False,
                ignore_space_changes=self.ignore_whitespace)

            buf.writelines(udiff)

    def _get_mime_type(self, path) -> bytes:
        try:
            mime_type = svn.fs.node_prop(
                self.tgt_root, path, svn.core.SVN_PROP_MIME_TYPE)
        except svn.core.SubversionException:
            mime_type = svn.fs.node_prop(
                self.src_root, path, svn.core.SVN_PROP_MIME_TYPE)
        return mime_type

    def _svn_readlines(self, fs_root, node_path):
        if self.binary_content:
            return []
        node_kind = svn.fs.check_path(fs_root, node_path)
        if node_kind not in (
                svn.core.svn_node_file, svn.core.svn_node_symlink):
            return []
        content = svn.core.Stream(
            svn.fs.file_contents(fs_root, node_path)).read()

        return content.splitlines(True)


class DiffChangeEditor(svn.delta.Editor):
    """
    Records changes between two given revisions
    """

    def __init__(self):
        self.changes = []

    def delete_entry(self, path, revision, parent_baton, pool=None):
        self.changes.append((path, None, 'delete'))

    def add_file(
            self, path, parent_baton, copyfrom_path, copyfrom_revision,
            file_pool=None):
        self.changes.append((path, 'file', 'add'))

    def open_file(self, path, parent_baton, base_revision, file_pool=None):
        self.changes.append((path, 'file', 'change'))


def authorization_callback_allow_all(root, path, pool):
    return True


class TxnNodeProcessor:
    """
    Utility to process the change of one node within a transaction root.

    It encapsulates the knowledge of how to add, update or remove
    a node for a given transaction root. The purpose is to support the method
    `SvnRemote.commit`.
    """

    def __init__(self, node, txn_root):
        assert_bytes(node['path'])

        self.node = node
        self.txn_root = txn_root

    def update(self):
        self._ensure_parent_dirs()
        self._add_file_if_node_does_not_exist()
        self._update_file_content()
        self._update_file_properties()

    def remove(self):
        svn.fs.delete(self.txn_root, self.node['path'])
        # TODO: Clean up directory if empty

    def _ensure_parent_dirs(self):
        curdir = vcspath.dirname(self.node['path'])
        dirs_to_create = []
        while not self._svn_path_exists(curdir):
            dirs_to_create.append(curdir)
            curdir = vcspath.dirname(curdir)

        for curdir in reversed(dirs_to_create):
            log.debug('Creating missing directory "%s"', curdir)
            svn.fs.make_dir(self.txn_root, curdir)

    def _svn_path_exists(self, path):
        path_status = svn.fs.check_path(self.txn_root, path)
        return path_status != svn.core.svn_node_none

    def _add_file_if_node_does_not_exist(self):
        kind = svn.fs.check_path(self.txn_root, self.node['path'])
        if kind == svn.core.svn_node_none:
            svn.fs.make_file(self.txn_root, self.node['path'])

    def _update_file_content(self):
        assert_bytes(self.node['content'])

        handler, baton = svn.fs.apply_textdelta(
            self.txn_root, self.node['path'], None, None)
        svn.delta.svn_txdelta_send_string(self.node['content'], handler, baton)

    def _update_file_properties(self):
        properties = self.node.get('properties', {})
        for key, value in properties.items():
            svn.fs.change_node_prop(
                self.txn_root, self.node['path'], safe_bytes(key), safe_bytes(value))


def apr_time_t(timestamp):
    """
    Convert a Python timestamp into APR timestamp type apr_time_t
    """
    return int(timestamp * 1E6)


def svn_opt_revision_value_t(num):
    """
    Put `num` into a `svn_opt_revision_value_t` structure.
    """
    value = svn.core.svn_opt_revision_value_t()
    value.number = num
    revision = svn.core.svn_opt_revision_t()
    revision.kind = svn.core.svn_opt_revision_number
    revision.value = value
    return revision