# wireprotov1server.py - Wire protocol version 1 server functionality

#

# Copyright 2005-2010 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 binascii

import os

from .i18n import _

from .node import (

    hex,

    nullid,

)

from . import (

    bundle2,

    changegroup as changegroupmod,

    discovery,

    encoding,

    error,

    exchange,

    pushkey as pushkeymod,

    pycompat,

    streamclone,

    util,

    wireprototypes,

)

from .utils import (

    procutil,

    stringutil,

)

urlerr = util.urlerr

urlreq = util.urlreq

bundle2requiredmain = _('incompatible Mercurial client; bundle2 required')

bundle2requiredhint = _('see https://www.mercurial-scm.org/wiki/'

                        'IncompatibleClient')

bundle2required = '%s\n(%s)\n' % (bundle2requiredmain, bundle2requiredhint)

def clientcompressionsupport(proto):

    """Returns a list of compression methods supported by the client.

    Returns a list of the compression methods supported by the client

    according to the protocol capabilities. If no such capability has

    been announced, fallback to the default of zlib and uncompressed.

    """

    for cap in proto.getprotocaps():

        if cap.startswith('comp='):

            return cap[5:].split(',')

    return ['zlib', 'none']

# wire protocol command can either return a string or one of these classes.

def getdispatchrepo(repo, proto, command):

    """Obtain the repo used for processing wire protocol commands.

    The intent of this function is to serve as a monkeypatch point for

    extensions that need commands to operate on different repo views under

    specialized circumstances.

    """

    viewconfig = repo.ui.config('server', 'view')

    return repo.filtered(viewconfig)

def dispatch(repo, proto, command):

    repo = getdispatchrepo(repo, proto, command)

    func, spec = commands[command]

    args = proto.getargs(spec)

    return func(repo, proto, *args)

def options(cmd, keys, others):

    opts = {}

    for k in keys:

        if k in others:

            opts[k] = others[k]

            del others[k]

    if others:

        procutil.stderr.write("warning: %s ignored unexpected arguments %s\n"

                              % (cmd, ",".join(others)))

    return opts

def bundle1allowed(repo, action):

    """Whether a bundle1 operation is allowed from the server.

    Priority is:

    1. server.bundle1gd.<action> (if generaldelta active)

    2. server.bundle1.<action>

    3. server.bundle1gd (if generaldelta active)

    4. server.bundle1

    """

    ui = repo.ui

    gd = 'generaldelta' in repo.requirements

    if gd:

        v = ui.configbool('server', 'bundle1gd.%s' % action)

        if v is not None:

            return v

    v = ui.configbool('server', 'bundle1.%s' % action)

    if v is not None:

        return v

    if gd:

        v = ui.configbool('server', 'bundle1gd')

        if v is not None:

            return v

    return ui.configbool('server', 'bundle1')

commands = wireprototypes.commanddict()

def wireprotocommand(name, args=None, permission='push'):

    """Decorator to declare a wire protocol command.

    ``name`` is the name of the wire protocol command being provided.

    ``args`` defines the named arguments accepted by the command. It is

    a space-delimited list of argument names. ``*`` denotes a special value

    that says to accept all named arguments.

    ``permission`` defines the permission type needed to run this command.

    Can be ``push`` or ``pull``. These roughly map to read-write and read-only,

    respectively. Default is to assume command requires ``push`` permissions

    because otherwise commands not declaring their permissions could modify

    a repository that is supposed to be read-only.

    """

    transports = {k for k, v in wireprototypes.TRANSPORTS.items()

                  if v['version'] == 1}

    # Because SSHv2 is a mirror of SSHv1, we allow "batch" commands through to

    # SSHv2.

    # TODO undo this hack when SSH is using the unified frame protocol.

    if name == b'batch':

        transports.add(wireprototypes.SSHV2)

    if permission not in ('push', 'pull'):

        raise error.ProgrammingError('invalid wire protocol permission; '

                                     'got %s; expected "push" or "pull"' %

                                     permission)

    if args is None:

        args = ''

    if not isinstance(args, bytes):

        raise error.ProgrammingError('arguments for version 1 commands '

                                     'must be declared as bytes')

    def register(func):

        if name in commands:

            raise error.ProgrammingError('%s command already registered '

                                         'for version 1' % name)

        commands[name] = wireprototypes.commandentry(

            func, args=args, transports=transports, permission=permission)

        return func

    return register

# TODO define a more appropriate permissions type to use for this.

@wireprotocommand('batch', 'cmds *', permission='pull')

def batch(repo, proto, cmds, others):

    unescapearg = wireprototypes.unescapebatcharg

    res = []

    for pair in cmds.split(';'):

        op, args = pair.split(' ', 1)

        vals = {}

        for a in args.split(','):

            if a:

                n, v = a.split('=')

                vals[unescapearg(n)] = unescapearg(v)

        func, spec = commands[op]

        # Validate that client has permissions to perform this command.

        perm = commands[op].permission

        assert perm in ('push', 'pull')

        proto.checkperm(perm)

        if spec:

            keys = spec.split()

            data = {}

            for k in keys:

                if k == '*':

                    star = {}

                    for key in vals.keys():

                        if key not in keys:

                            star[key] = vals[key]

                    data['*'] = star

                else:

                    data[k] = vals[k]

            result = func(repo, proto, *[data[k] for k in keys])

        else:

            result = func(repo, proto)

        if isinstance(result, wireprototypes.ooberror):

            return result

        # For now, all batchable commands must return bytesresponse or

        # raw bytes (for backwards compatibility).

        assert isinstance(result, (wireprototypes.bytesresponse, bytes))

        if isinstance(result, wireprototypes.bytesresponse):

            result = result.data

        res.append(wireprototypes.escapebatcharg(result))

    return wireprototypes.bytesresponse(';'.join(res))

@wireprotocommand('between', 'pairs', permission='pull')

def between(repo, proto, pairs):

    pairs = [wireprototypes.decodelist(p, '-') for p in pairs.split(" ")]

    r = []

    for b in repo.between(pairs):

        r.append(wireprototypes.encodelist(b) + "\n")

    return wireprototypes.bytesresponse(''.join(r))

@wireprotocommand('branchmap', permission='pull')

def branchmap(repo, proto):

    branchmap = repo.branchmap()

    heads = []

    for branch, nodes in branchmap.iteritems():

        branchname = urlreq.quote(encoding.fromlocal(branch))

        branchnodes = wireprototypes.encodelist(nodes)

        heads.append('%s %s' % (branchname, branchnodes))

    return wireprototypes.bytesresponse('\n'.join(heads))

@wireprotocommand('branches', 'nodes', permission='pull')

def branches(repo, proto, nodes):

    nodes = wireprototypes.decodelist(nodes)

    r = []

    for b in repo.branches(nodes):

        r.append(wireprototypes.encodelist(b) + "\n")

    return wireprototypes.bytesresponse(''.join(r))

@wireprotocommand('clonebundles', '', permission='pull')

def clonebundles(repo, proto):

    """Server command for returning info for available bundles to seed clones.

    Clients will parse this response and determine what bundle to fetch.

    Extensions may wrap this command to filter or dynamically emit data

    depending on the request. e.g. you could advertise URLs for the closest

    data center given the client's IP address.

    """

    return wireprototypes.bytesresponse(

        repo.vfs.tryread('clonebundles.manifest'))

wireprotocaps = ['lookup', 'branchmap', 'pushkey',

                 'known', 'getbundle', 'unbundlehash']

def _capabilities(repo, proto):

    """return a list of capabilities for a repo

    This function exists to allow extensions to easily wrap capabilities

    computation

    - returns a lists: easy to alter

    - change done here will be propagated to both `capabilities` and `hello`

      command without any other action needed.

    """

    # copy to prevent modification of the global list

    caps = list(wireprotocaps)

    # Command of same name as capability isn't exposed to version 1 of

    # transports. So conditionally add it.

    if commands.commandavailable('changegroupsubset', proto):

        caps.append('changegroupsubset')

    if streamclone.allowservergeneration(repo):

        if repo.ui.configbool('server', 'preferuncompressed'):

            caps.append('stream-preferred')

        requiredformats = repo.requirements & repo.supportedformats

        # if our local revlogs are just revlogv1, add 'stream' cap

        if not requiredformats - {'revlogv1'}:

            caps.append('stream')

        # otherwise, add 'streamreqs' detailing our local revlog format

        else:

            caps.append('streamreqs=%s' % ','.join(sorted(requiredformats)))

    if repo.ui.configbool('experimental', 'bundle2-advertise'):

        capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo, role='server'))

        caps.append('bundle2=' + urlreq.quote(capsblob))

    caps.append('unbundle=%s' % ','.join(bundle2.bundlepriority))

    if repo.ui.configbool('experimental', 'narrow'):

        caps.append(wireprototypes.NARROWCAP)

        if repo.ui.configbool('experimental', 'narrowservebrokenellipses'):

            caps.append(wireprototypes.ELLIPSESCAP)

    return proto.addcapabilities(repo, caps)

# If you are writing an extension and consider wrapping this function. Wrap

# `_capabilities` instead.

@wireprotocommand('capabilities', permission='pull')

def capabilities(repo, proto):

    caps = _capabilities(repo, proto)

    return wireprototypes.bytesresponse(' '.join(sorted(caps)))

@wireprotocommand('changegroup', 'roots', permission='pull')

def changegroup(repo, proto, roots):

    nodes = wireprototypes.decodelist(roots)

    outgoing = discovery.outgoing(repo, missingroots=nodes,

                                  missingheads=repo.heads())

    cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')

    gen = iter(lambda: cg.read(32768), '')

    return wireprototypes.streamres(gen=gen)

@wireprotocommand('changegroupsubset', 'bases heads',

                  permission='pull')

def changegroupsubset(repo, proto, bases, heads):

    bases = wireprototypes.decodelist(bases)

    heads = wireprototypes.decodelist(heads)

    outgoing = discovery.outgoing(repo, missingroots=bases,

                                  missingheads=heads)

    cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')

    gen = iter(lambda: cg.read(32768), '')

    return wireprototypes.streamres(gen=gen)

@wireprotocommand('debugwireargs', 'one two *',

                  permission='pull')

def debugwireargs(repo, proto, one, two, others):

    # only accept optional args from the known set

    opts = options('debugwireargs', ['three', 'four'], others)

    return wireprototypes.bytesresponse(repo.debugwireargs(

        one, two, **pycompat.strkwargs(opts)))

def find_pullbundle(repo, proto, opts, clheads, heads, common):

    """Return a file object for the first matching pullbundle.

    Pullbundles are specified in .hg/pullbundles.manifest similar to

    clonebundles.

    For each entry, the bundle specification is checked for compatibility:

    - Client features vs the BUNDLESPEC.

    - Revisions shared with the clients vs base revisions of the bundle.

      A bundle can be applied only if all its base revisions are known by

      the client.

    - At least one leaf of the bundle's DAG is missing on the client.

    - Every leaf of the bundle's DAG is part of node set the client wants.

      E.g. do not send a bundle of all changes if the client wants only

      one specific branch of many.

    """

    def decodehexstring(s):

    manifest = repo.vfs.tryread('pullbundles.manifest')

    if not manifest:

        return None

    res = exchange.parseclonebundlesmanifest(repo, manifest)

    res = exchange.filterclonebundleentries(repo, res)

    if not res:

        return None

    cl = repo.changelog

    heads_anc = cl.ancestors([cl.rev(rev) for rev in heads], inclusive=True)

    common_anc = cl.ancestors([cl.rev(rev) for rev in common], inclusive=True)

    compformats = clientcompressionsupport(proto)

    for entry in res:

        comp = entry.get('COMPRESSION')

        altcomp = util.compengines._bundlenames.get(comp)

        if comp and comp not in compformats and altcomp not in compformats:

            continue

        # No test yet for VERSION, since V2 is supported by any client

        # that advertises partial pulls

        if 'heads' in entry:

            try:

                bundle_heads = decodehexstring(entry['heads'])

            except TypeError:

                # Bad heads entry

                continue

            if bundle_heads.issubset(common):