# streamclone.py - producing and consuming streaming repository data

#

# Copyright 2015 Gregory Szorc <gregory.szorc@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 annotations

import contextlib

import errno

import os

import struct

from typing import (

    Iterable,

    Iterator,

    Optional,

    Set,

    Tuple,

    Type,

)

from .i18n import _

from .interfaces import repository

from . import (

    bookmarks,

    bundle2 as bundle2mod,

    cacheutil,

    error,

    narrowspec,

    phases,

    pycompat,

    requirements as requirementsmod,

    scmutil,

    store,

    transaction,

    util,

)

from .revlogutils import (

    nodemap,

)

def new_stream_clone_requirements(

    default_requirements: Iterable[bytes],

    streamed_requirements: Iterable[bytes],

) -> Set[bytes]:

    """determine the final set of requirement for a new stream clone

    this method combine the "default" requirements that a new repository would

    use with the constaint we get from the stream clone content. We keep local

    configuration choice when possible.

    """

    requirements = set(default_requirements)

    requirements -= requirementsmod.STREAM_FIXED_REQUIREMENTS

    requirements.update(streamed_requirements)

    return requirements

def streamed_requirements(repo) -> Set[bytes]:

    """the set of requirement the new clone will have to support

    This is used for advertising the stream options and to generate the actual

    stream content."""

    requiredformats = (

        repo.requirements & requirementsmod.STREAM_FIXED_REQUIREMENTS

    )

    return requiredformats

def canperformstreamclone(pullop, bundle2: bool = False):

    """Whether it is possible to perform a streaming clone as part of pull.

    ``bundle2`` will cause the function to consider stream clone through

    bundle2 and only through bundle2.

    Returns a tuple of (supported, requirements). ``supported`` is True if

    streaming clone is supported and False otherwise. ``requirements`` is

    a set of repo requirements from the remote, or ``None`` if stream clone

    isn't supported.

    """

    repo = pullop.repo

    remote = pullop.remote

    # should we consider streaming clone at all ?

    streamrequested = pullop.streamclonerequested

    # If we don't have a preference, let the server decide for us. This

    # likely only comes into play in LANs.

    if streamrequested is None:

        # The server can advertise whether to prefer streaming clone.

        streamrequested = remote.capable(b'stream-preferred')

    if not streamrequested:

        return False, None

    # Streaming clone only works on an empty destination repository

    if len(repo):

        return False, None

    # Streaming clone only works if all data is being requested.

    if pullop.heads:

        return False, None

    bundle2supported = False

    if pullop.canusebundle2:

        local_caps = bundle2mod.getrepocaps(repo, role=b'client')

        local_supported = set(local_caps.get(b'stream', []))

        remote_supported = set(pullop.remotebundle2caps.get(b'stream', []))

        bundle2supported = bool(local_supported & remote_supported)

        # else

        # Server doesn't support bundle2 stream clone or doesn't support

        # the versions we support. Fall back and possibly allow legacy.

    # Ensures legacy code path uses available bundle2.

    if bundle2supported and not bundle2:

        return False, None

    # Ensures bundle2 doesn't try to do a stream clone if it isn't supported.

    elif bundle2 and not bundle2supported:

        return False, None

    # In order for stream clone to work, the client has to support all the

    # requirements advertised by the server.

    #

    # The server advertises its requirements via the "stream" and "streamreqs"

    # capability. "stream" (a value-less capability) is advertised if and only

    # if the only requirement is "revlogv1." Else, the "streamreqs" capability

    # is advertised and contains a comma-delimited list of requirements.

    requirements = set()

    if remote.capable(b'stream'):

        requirements.add(requirementsmod.REVLOGV1_REQUIREMENT)

    else:

        streamreqs = remote.capable(b'streamreqs')

        # This is weird and shouldn't happen with modern servers.

        if not streamreqs:

            pullop.repo.ui.warn(

                _(

                    b'warning: stream clone requested but server has them '

                    b'disabled\n'

                )

            )

            return False, None

        streamreqs = set(streamreqs.split(b','))

        # Server requires something we don't support. Bail.

        missingreqs = streamreqs - repo.supported

        if missingreqs:

            pullop.repo.ui.warn(

                _(

                    b'warning: stream clone requested but client is missing '

                    b'requirements: %s\n'

                )

                % b', '.join(sorted(missingreqs))

            )

            pullop.repo.ui.warn(

                _(

                    b'(see https://www.mercurial-scm.org/wiki/MissingRequirement '

                    b'for more information)\n'

                )

            )

            return False, None

        requirements = streamreqs

    return True, requirements

def maybeperformlegacystreamclone(pullop) -> None:

    """Possibly perform a legacy stream clone operation.

    Legacy stream clones are performed as part of pull but before all other

    operations.

    A legacy stream clone will not be performed if a bundle2 stream clone is

    supported.

    """

    from . import localrepo

    supported, requirements = canperformstreamclone(pullop)

    if not supported:

        return

    repo = pullop.repo

    remote = pullop.remote

    # Save remote branchmap. We will use it later to speed up branchcache

    # creation.

    rbranchmap = None

    if remote.capable(b'branchmap'):

        with remote.commandexecutor() as e:

            rbranchmap = e.callcommand(b'branchmap', {}).result()

    repo.ui.status(_(b'streaming all changes\n'))

    with remote.commandexecutor() as e:

        fp = e.callcommand(b'stream_out', {}).result()

    # TODO strictly speaking, this code should all be inside the context

    # manager because the context manager is supposed to ensure all wire state

    # is flushed when exiting. But the legacy peers don't do this, so it

    # doesn't matter.

    l = fp.readline()

    try:

        resp = int(l)

    except ValueError:

        raise error.ResponseError(

            _(b'unexpected response from remote server:'), l

        )

    if resp == 1:

        raise error.Abort(_(b'operation forbidden by server'))

    elif resp == 2:

        raise error.Abort(_(b'locking the remote repository failed'))

    elif resp != 0:

        raise error.Abort(_(b'the server sent an unknown error code'))

    l = fp.readline()

    try:

        filecount, bytecount = map(int, l.split(b' ', 1))

    except (ValueError, TypeError):

        raise error.ResponseError(

            _(b'unexpected response from remote server:'), l

        )

    with repo.lock():

        consumev1(repo, fp, filecount, bytecount)

        repo.requirements = new_stream_clone_requirements(

            repo.requirements,

            requirements,

        )

        repo.svfs.options = localrepo.resolvestorevfsoptions(

            repo.ui, repo.requirements, repo.features

        )

        scmutil.writereporequirements(repo)

        nodemap.post_stream_cleanup(repo)

        if rbranchmap:

            repo._branchcaches.replace(repo, rbranchmap)

        repo.invalidate()

def allowservergeneration(repo) -> bool:

    """Whether streaming clones are allowed from the server."""

    if repository.REPO_FEATURE_STREAM_CLONE not in repo.features:

        return False

    if not repo.ui.configbool(b'server', b'uncompressed', untrusted=True):

        return False

    # The way stream clone works makes it impossible to hide secret changesets.

    # So don't allow this by default.

    secret = phases.hassecret(repo)

    if secret:

        return repo.ui.configbool(b'server', b'uncompressedallowsecret')

    return True

# This is it's own function so extensions can override it.

def _walkstreamfiles(

    repo, matcher=None, phase: bool = False, obsolescence: bool = False

):

    return repo.store.walk(matcher, phase=phase, obsolescence=obsolescence)

def _report_transferred(

    repo, start_time: float, file_count: int, byte_count: int

):

    """common utility to report time it took to apply the stream bundle"""

    elapsed = util.timer() - start_time

    if elapsed <= 0:

        elapsed = 0.001

    m = _(b'stream-cloned %d files / %s in %.1f seconds (%s/sec)\n')

    m %= (

        file_count,

        util.bytecount(byte_count),

        elapsed,

        util.bytecount(byte_count / elapsed),

    )

    repo.ui.status(m)

def generatev1(repo) -> tuple[int, int, Iterator[bytes]]:

    """Emit content for version 1 of a streaming clone.

    This returns a 3-tuple of (file count, byte size, data iterator).

    The data iterator consists of N entries for each file being transferred.

    Each file entry starts as a line with the file name and integer size

    delimited by a null byte.

    The raw file data follows. Following the raw file data is the next file

    entry, or EOF.

    When used on the wire protocol, an additional line indicating protocol

    success will be prepended to the stream. This function is not responsible

    for adding it.

    This function will obtain a repository lock to ensure a consistent view of

    the store is captured. It therefore may raise LockError.

    """

    entries = []

    total_bytes = 0

    # Get consistent snapshot of repo, lock during scan.

    with repo.lock():

        repo.ui.debug(b'scanning\n')

        _test_sync_point_walk_1_2(repo)

        for entry in _walkstreamfiles(repo):

            for f in entry.files():

                file_size = f.file_size(repo.store.vfs)

                if file_size:

                    entries.append((f.unencoded_path, file_size))

                    total_bytes += file_size

        _test_sync_point_walk_3(repo)

    _test_sync_point_walk_4(repo)

    repo.ui.debug(

        b'%d files, %d bytes to transfer\n' % (len(entries), total_bytes)

    )

    svfs = repo.svfs

    debugflag = repo.ui.debugflag

    def emitrevlogdata() -> Iterator[bytes]:

        for name, size in entries:

            if debugflag:

                repo.ui.debug(b'sending %s (%d bytes)\n' % (name, size))

            # partially encode name over the wire for backwards compat

            yield b'%s\0%d\n' % (store.encodedir(name), size)

            # auditing at this stage is both pointless (paths are already

            # trusted by the local repo) and expensive

            with svfs(name, b'rb', auditpath=False) as fp:

                if size <= 65536:

                    yield fp.read(size)

                else:

                    yield from util.filechunkiter(fp, limit=size)

    return len(entries), total_bytes, emitrevlogdata()

def generatev1wireproto(repo) -> Iterator[bytes]:

    """Emit content for version 1 of streaming clone suitable for the wire.

    This is the data output from ``generatev1()`` with 2 header lines. The

    first line indicates overall success. The 2nd contains the file count and

    byte size of payload.

    The success line contains "0" for success, "1" for stream generation not

    allowed, and "2" for error locking the repository (possibly indicating

    a permissions error for the server process).

    """

    if not allowservergeneration(repo):

        yield b'1\n'

        return

    try:

        filecount, bytecount, it = generatev1(repo)

    except error.LockError:

        yield b'2\n'

        return

    # Indicates successful response.

    yield b'0\n'

    yield b'%d %d\n' % (filecount, bytecount)

    yield from it

def generatebundlev1(

    repo, compression: bytes = b'UN'

) -> tuple[Set[bytes], Iterator[bytes]]:

    """Emit content for version 1 of a stream clone bundle.

    The first 4 bytes of the output ("HGS1") denote this as stream clone

    bundle version 1.

    The next 2 bytes indicate the compression type. Only "UN" is currently

    supported.

    The next 16 bytes are two 64-bit big endian unsigned integers indicating

    file count and byte count, respectively.

    The next 2 bytes is a 16-bit big endian unsigned short declaring the length

    of the requirements string, including a trailing \0. The following N bytes

    are the requirements string, which is ASCII containing a comma-delimited

    list of repo requirements that are needed to support the data.

    The remaining content is the output of ``generatev1()`` (which may be

    compressed in the future).

    Returns a tuple of (requirements, data generator).

    """

    if compression != b'UN':

        raise ValueError('we do not support the compression argument yet')

    requirements = streamed_requirements(repo)

    requires = b','.join(sorted(requirements))

    def gen() -> Iterator[bytes]:

        yield b'HGS1'

        yield compression

        filecount, bytecount, it = generatev1(repo)

        repo.ui.status(

            _(b'writing %d bytes for %d files\n') % (bytecount, filecount)

        )

        yield struct.pack(b'>QQ', filecount, bytecount)

        yield struct.pack(b'>H', len(requires) + 1)

        yield requires + b'\0'

        # This is where we'll add compression in the future.

        assert compression == b'UN'

        progress = repo.ui.makeprogress(

            _(b'bundle'), total=bytecount, unit=_(b'bytes')

        )

        progress.update(0)

        for chunk in it:

            progress.increment(step=len(chunk))

            yield chunk

        progress.complete()

    return requirements, gen()

def consumev1(repo, fp, filecount: int, bytecount: int) -> None:

    """Apply the contents from version 1 of a streaming clone file handle.

    This takes the output from "stream_out" and applies it to the specified

    repository.

    Like "stream_out," the status line added by the wire protocol is not

    handled by this function.

    """

    with repo.lock():

        repo.ui.status(

            _(b'%d files to transfer, %s of data\n')

            % (filecount, util.bytecount(bytecount))

        )

        progress = repo.ui.makeprogress(

            _(b'clone'), total=bytecount, unit=_(b'bytes')

        )

        progress.update(0)

        start = util.timer()

        # TODO: get rid of (potential) inconsistency

        #

        # If transaction is started and any @filecache property is

        # changed at this point, it causes inconsistency between

        # in-memory cached property and streamclone-ed file on the

        # disk. Nested transaction prevents transaction scope "clone"

        # below from writing in-memory changes out at the end of it,

        # even though in-memory changes are discarded at the end of it

        # regardless of transaction nesting.

        #

        # But transaction nesting can't be simply prohibited, because

        # nesting occurs also in ordinary case (e.g. enabling

        # clonebundles).

        total_file_count = 0

        with repo.transaction(b'clone'):

            with repo.svfs.backgroundclosing(repo.ui, expectedcount=filecount):

                for i in range(filecount):

                    # XXX doesn't support '\n' or '\r' in filenames

                    if hasattr(fp, 'readline'):

                        l = fp.readline()

                    else:

                        # inline clonebundles use a chunkbuffer, so no readline

                        # --> this should be small anyway, the first line

                        # only contains the size of the bundle

                        l_buf = []

                        while not (l_buf and l_buf[-1] == b'\n'):

                            l_buf.append(fp.read(1))

                        l = b''.join(l_buf)

                    try:

                        name, size = l.split(b'\0', 1)

                        size = int(size)