# test-batching.py - tests for transparent command batching

#

# Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch>

#

# 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, print_function

import contextlib

from mercurial import (

    localrepo,

    wireprotov1peer,

# equivalent of repo.repository

class thing(object):

    def hello(self):

# equivalent of localrepo.localrepository

class localthing(thing):

    def foo(self, one, two=None):

        if one:

    def bar(self, b, a):

    def greet(self, name=None):

    @contextlib.contextmanager

    def commandexecutor(self):

        e = localrepo.localcommandexecutor(self)

        try:

            yield e

        finally:

            e.close()

# usage of "thing" interface

def use(it):

    # Direct call to base method shared between client and server.

    # Direct calls to proxied methods. They cause individual roundtrips.

    # Batched call to a couple of proxied methods.

    with it.commandexecutor() as e:

# local usage

mylocal = localthing()

print()

use(mylocal)

# demo remoting; mimicks what wireproto and HTTP/SSH do

# shared

def escapearg(plain):

    return (plain

def unescapearg(escaped):

    return (escaped

# server side

# equivalent of wireproto's global functions

class server(object):

    def __init__(self, local):

        self.local = local

    def _call(self, name, args):

        return getattr(self, name)(**args)

    def perform(self, req):

        return res

    def batch(self, cmds):

        res = []

            vals = {}

                if a:

                    vals[n] = unescapearg(v)

    def foo(self, one, two):

        return mangle(self.local.foo(unmangle(one), unmangle(two)))

    def bar(self, b, a):

        return mangle(self.local.bar(unmangle(b), unmangle(a)))

    def greet(self, name):

        return mangle(self.local.greet(unmangle(name)))

myserver = server(mylocal)

# local side

# equivalent of wireproto.encode/decodelist, that is, type-specific marshalling

# here we just transform the strings a bit to check we're properly en-/decoding

def mangle(s):

def unmangle(s):

# equivalent of wireproto.wirerepository and something like http's wire format

class remotething(thing):

    def __init__(self, server):

        self.server = server

    def _submitone(self, name, args):

        return self.server.perform(req)

    def _submitbatch(self, cmds):

        req = []

        for name, args in cmds:

            yield r

    @contextlib.contextmanager

    def commandexecutor(self):

        e = wireprotov1peer.peerexecutor(self)

        try:

            yield e

        finally:

            e.close()

    @wireprotov1peer.batchable

    def foo(self, one, two=None):

        encresref = wireprotov1peer.future()

        yield encargs, encresref

        yield unmangle(encresref.value)

    @wireprotov1peer.batchable

    def bar(self, b, a):

        encresref = wireprotov1peer.future()

        yield unmangle(encresref.value)

    # greet is coded directly. It therefore does not support batching. If it

    # does appear in a batch, the batch is split around greet, and the call to

    # greet is done in its own roundtrip.

    def greet(self, name=None):

# demo remote usage

myproxy = remotething(myserver)

print()

use(myproxy)