# exchange.py - utility to exchange data between repos.

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.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 collections

import hashlib

from .i18n import _

from .node import (

    hex,

    nullid,

    nullrev,

)

from .thirdparty import attr

from . import (

    bookmarks as bookmod,

    bundle2,

    changegroup,

    discovery,

    error,

    exchangev2,

    lock as lockmod,

    logexchange,

    narrowspec,

    obsolete,

    phases,

    pushkey,

    pycompat,

    scmutil,

    sslutil,

    streamclone,

    url as urlmod,

    util,

    wireprototypes,

)

from .interfaces import repository

from .utils import stringutil

urlerr = util.urlerr

urlreq = util.urlreq

_NARROWACL_SECTION = b'narrowacl'

# Maps bundle version human names to changegroup versions.

_bundlespeccgversions = {

    b'v1': b'01',

    b'v2': b'02',

    b'packed1': b's1',

    b'bundle2': b'02',  # legacy

}

# Maps bundle version with content opts to choose which part to bundle

_bundlespeccontentopts = {

    b'v1': {

        b'changegroup': True,

        b'cg.version': b'01',

        b'obsolescence': False,

        b'phases': False,

        b'tagsfnodescache': False,

        b'revbranchcache': False,

    },

    b'v2': {

        b'changegroup': True,

        b'cg.version': b'02',

        b'obsolescence': False,

        b'phases': False,

        b'tagsfnodescache': True,

        b'revbranchcache': True,

    },

    b'packed1': {b'cg.version': b's1'},

}

_bundlespeccontentopts[b'bundle2'] = _bundlespeccontentopts[b'v2']

_bundlespecvariants = {

    b"streamv2": {

        b"changegroup": False,

        b"streamv2": True,

        b"tagsfnodescache": False,

        b"revbranchcache": False,

    }

}

# Compression engines allowed in version 1. THIS SHOULD NEVER CHANGE.

_bundlespecv1compengines = {b'gzip', b'bzip2', b'none'}

@attr.s

class bundlespec(object):

    compression = attr.ib()

    wirecompression = attr.ib()

    version = attr.ib()

    wireversion = attr.ib()

    params = attr.ib()

    contentopts = attr.ib()

def parsebundlespec(repo, spec, strict=True):

    """Parse a bundle string specification into parts.

    Bundle specifications denote a well-defined bundle/exchange format.

    The content of a given specification should not change over time in

    order to ensure that bundles produced by a newer version of Mercurial are

    readable from an older version.

    The string currently has the form:

       <compression>-<type>[;<parameter0>[;<parameter1>]]

    Where <compression> is one of the supported compression formats

    and <type> is (currently) a version string. A ";" can follow the type and

    all text afterwards is interpreted as URI encoded, ";" delimited key=value

    pairs.

    If ``strict`` is True (the default) <compression> is required. Otherwise,

    it is optional.

    Returns a bundlespec object of (compression, version, parameters).

    Compression will be ``None`` if not in strict mode and a compression isn't

    defined.

    An ``InvalidBundleSpecification`` is raised when the specification is

    not syntactically well formed.

    An ``UnsupportedBundleSpecification`` is raised when the compression or

    bundle type/version is not recognized.

    Note: this function will likely eventually return a more complex data

    structure, including bundle2 part information.

    """

    def parseparams(s):

        if b';' not in s:

            return s, {}

        params = {}

        version, paramstr = s.split(b';', 1)

        for p in paramstr.split(b';'):

            if b'=' not in p:

                raise error.InvalidBundleSpecification(

                    _(

                        b'invalid bundle specification: '

                        b'missing "=" in parameter: %s'

                    )

                    % p

                )

            key, value = p.split(b'=', 1)

            key = urlreq.unquote(key)

            value = urlreq.unquote(value)

            params[key] = value

        return version, params

    if strict and b'-' not in spec:

        raise error.InvalidBundleSpecification(

            _(

                b'invalid bundle specification; '

                b'must be prefixed with compression: %s'

            )

            % spec

        )

    if b'-' in spec:

        compression, version = spec.split(b'-', 1)

        if compression not in util.compengines.supportedbundlenames:

            raise error.UnsupportedBundleSpecification(

                _(b'%s compression is not supported') % compression

            )

        version, params = parseparams(version)

        if version not in _bundlespeccgversions:

            raise error.UnsupportedBundleSpecification(

                _(b'%s is not a recognized bundle version') % version

            )

    else:

        # Value could be just the compression or just the version, in which

        # case some defaults are assumed (but only when not in strict mode).

        assert not strict

        spec, params = parseparams(spec)

        if spec in util.compengines.supportedbundlenames:

            compression = spec

            version = b'v1'

            # Generaldelta repos require v2.

            if b'generaldelta' in repo.requirements:

                version = b'v2'

            # Modern compression engines require v2.

            if compression not in _bundlespecv1compengines:

                version = b'v2'

        elif spec in _bundlespeccgversions:

            if spec == b'packed1':

                compression = b'none'

            else:

                compression = b'bzip2'

            version = spec

        else:

            raise error.UnsupportedBundleSpecification(

                _(b'%s is not a recognized bundle specification') % spec

            )

    # Bundle version 1 only supports a known set of compression engines.

    if version == b'v1' and compression not in _bundlespecv1compengines:

        raise error.UnsupportedBundleSpecification(

            _(b'compression engine %s is not supported on v1 bundles')

            % compression

        )

    # The specification for packed1 can optionally declare the data formats

    # required to apply it. If we see this metadata, compare against what the

    # repo supports and error if the bundle isn't compatible.

    if version == b'packed1' and b'requirements' in params:

        requirements = set(params[b'requirements'].split(b','))

        missingreqs = requirements - repo.supportedformats

        if missingreqs:

            raise error.UnsupportedBundleSpecification(

                _(b'missing support for repository features: %s')

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

            )

    # Compute contentopts based on the version

    contentopts = _bundlespeccontentopts.get(version, {}).copy()

    # Process the variants

    if b"stream" in params and params[b"stream"] == b"v2":

        variant = _bundlespecvariants[b"streamv2"]

        contentopts.update(variant)

    engine = util.compengines.forbundlename(compression)

    compression, wirecompression = engine.bundletype()

    wireversion = _bundlespeccgversions[version]

    return bundlespec(

        compression, wirecompression, version, wireversion, params, contentopts

    )

def readbundle(ui, fh, fname, vfs=None):

    header = changegroup.readexactly(fh, 4)

    alg = None

    if not fname:

        fname = b"stream"

        if not header.startswith(b'HG') and header.startswith(b'\0'):

            fh = changegroup.headerlessfixup(fh, header)

            header = b"HG10"

            alg = b'UN'

    elif vfs:

        fname = vfs.join(fname)

    magic, version = header[0:2], header[2:4]

    if magic != b'HG':

        raise error.Abort(_(b'%s: not a Mercurial bundle') % fname)

    if version == b'10':

        if alg is None:

            alg = changegroup.readexactly(fh, 2)

        return changegroup.cg1unpacker(fh, alg)

    elif version.startswith(b'2'):

        return bundle2.getunbundler(ui, fh, magicstring=magic + version)

    elif version == b'S1':

        return streamclone.streamcloneapplier(fh)

    else:

        raise error.Abort(

            _(b'%s: unknown bundle version %s') % (fname, version)

        )

def getbundlespec(ui, fh):

    """Infer the bundlespec from a bundle file handle.

    The input file handle is seeked and the original seek position is not

    restored.

    """

    def speccompression(alg):

        try:

            return util.compengines.forbundletype(alg).bundletype()[0]

        except KeyError:

            return None

    b = readbundle(ui, fh, None)

    if isinstance(b, changegroup.cg1unpacker):

        alg = b._type

        if alg == b'_truncatedBZ':

            alg = b'BZ'

        comp = speccompression(alg)

        if not comp:

            raise error.Abort(_(b'unknown compression algorithm: %s') % alg)

        return b'%s-v1' % comp

    elif isinstance(b, bundle2.unbundle20):

        if b'Compression' in b.params:

            comp = speccompression(b.params[b'Compression'])

            if not comp:

                raise error.Abort(

                    _(b'unknown compression algorithm: %s') % comp

                )

        else:

            comp = b'none'

        version = None

        for part in b.iterparts():

            if part.type == b'changegroup':

                version = part.params[b'version']

                if version in (b'01', b'02'):

                    version = b'v2'

                else:

                    raise error.Abort(

                        _(

                            b'changegroup version %s does not have '

                            b'a known bundlespec'

                        )

                        % version,

                        hint=_(b'try upgrading your Mercurial client'),

                    )

            elif part.type == b'stream2' and version is None:

                # A stream2 part requires to be part of a v2 bundle

                requirements = urlreq.unquote(part.params[b'requirements'])

                splitted = requirements.split()

                params = bundle2._formatrequirementsparams(splitted)

                return b'none-v2;stream=v2;%s' % params

        if not version:

            raise error.Abort(

                _(b'could not identify changegroup version in bundle')

            )

        return b'%s-%s' % (comp, version)

    elif isinstance(b, streamclone.streamcloneapplier):

        requirements = streamclone.readbundle1header(fh)[2]

        formatted = bundle2._formatrequirementsparams(requirements)

        return b'none-packed1;%s' % formatted

    else:

        raise error.Abort(_(b'unknown bundle type: %s') % b)

def _computeoutgoing(repo, heads, common):

    """Computes which revs are outgoing given a set of common

    and a set of heads.

    This is a separate function so extensions can have access to

    the logic.

    Returns a discovery.outgoing object.

    """

    cl = repo.changelog

    if common:

        hasnode = cl.hasnode

        common = [n for n in common if hasnode(n)]

    else:

        common = [nullid]

    if not heads:

        heads = cl.heads()

    return discovery.outgoing(repo, common, heads)

def _checkpublish(pushop):

    repo = pushop.repo

    ui = repo.ui

    behavior = ui.config(b'experimental', b'auto-publish')

    if pushop.publish or behavior not in (b'warn', b'confirm', b'abort'):

        return

    remotephases = listkeys(pushop.remote, b'phases')

    if not remotephases.get(b'publishing', False):

        return

    if pushop.revs is None:

        published = repo.filtered(b'served').revs(b'not public()')

    else:

        published = repo.revs(b'::%ln - public()', pushop.revs)

    if published:

        if behavior == b'warn':

            ui.warn(

                _(b'%i changesets about to be published\n') % len(published)