| pulkit |
| hg-reviewers |
I used byteify-strings.py on this file, then manually added the
various pycompat and bprint bits as needed.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| test-audit-path.t | test-audit-path.t | ||||
| test-audit-subrepo.t | test-audit-subrepo.t | ||||
| test-automv.t | test-automv.t | ||||
| test-backout.t | test-backout.t | ||||
| test-backwards-remove.t | test-backwards-remove.t | ||||
| test-bad-extension.t | test-bad-extension.t | ||||
| test-bad-pull.t | test-bad-pull.t | ||||
| test-basic.t | test-basic.t | ||||
| test-batching.py | |||||
| test-bdiff.py | test-bdiff.py | ||||
| test-bheads.t | test-bheads.t | ||||
| test-bisect.t | test-bisect.t | ||||
| test-bisect2.t | test-bisect2.t | ||||
| test-bisect3.t | test-bisect3.t | ||||
| test-blackbox.t | test-blackbox.t | ||||
| test-bookflow.t | test-bookflow.t | ||||
| test-bookmarks-current.t | test-bookmarks-current.t | ||||
| # test-batching.py - tests for transparent command batching | # test-batching.py - tests for transparent command batching | ||||
| # | # | ||||
| # Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch> | # Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import contextlib | import contextlib | ||||
| from mercurial import ( | from mercurial import ( | ||||
| localrepo, | localrepo, | ||||
| pycompat, | |||||
| wireprotov1peer, | wireprotov1peer, | ||||
| ) | ) | ||||
| def bprint(*bs): | |||||
| print(*[pycompat.sysstr(b) for b in bs]) | |||||
| # equivalent of repo.repository | # equivalent of repo.repository | ||||
| class thing(object): | class thing(object): | ||||
| def hello(self): | def hello(self): | ||||
| return "Ready." | return b"Ready." | ||||
| # equivalent of localrepo.localrepository | # equivalent of localrepo.localrepository | ||||
| class localthing(thing): | class localthing(thing): | ||||
| def foo(self, one, two=None): | def foo(self, one, two=None): | ||||
| if one: | if one: | ||||
| return "%s and %s" % (one, two,) | return b"%s and %s" % (one, two,) | ||||
| return "Nope" | return b"Nope" | ||||
| def bar(self, b, a): | def bar(self, b, a): | ||||
| return "%s und %s" % (b, a,) | return b"%s und %s" % (b, a,) | ||||
| def greet(self, name=None): | def greet(self, name=None): | ||||
| return "Hello, %s" % name | return b"Hello, %s" % name | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def commandexecutor(self): | def commandexecutor(self): | ||||
| e = localrepo.localcommandexecutor(self) | e = localrepo.localcommandexecutor(self) | ||||
| try: | try: | ||||
| yield e | yield e | ||||
| finally: | finally: | ||||
| e.close() | e.close() | ||||
| # usage of "thing" interface | # usage of "thing" interface | ||||
| def use(it): | def use(it): | ||||
| # Direct call to base method shared between client and server. | # Direct call to base method shared between client and server. | ||||
| print(it.hello()) | bprint(it.hello()) | ||||
| # Direct calls to proxied methods. They cause individual roundtrips. | # Direct calls to proxied methods. They cause individual roundtrips. | ||||
| print(it.foo("Un", two="Deux")) | bprint(it.foo(b"Un", two=b"Deux")) | ||||
| print(it.bar("Eins", "Zwei")) | bprint(it.bar(b"Eins", b"Zwei")) | ||||
| # Batched call to a couple of proxied methods. | # Batched call to a couple of proxied methods. | ||||
| with it.commandexecutor() as e: | with it.commandexecutor() as e: | ||||
| ffoo = e.callcommand('foo', {'one': 'One', 'two': 'Two'}) | ffoo = e.callcommand(b'foo', {b'one': b'One', b'two': b'Two'}) | ||||
| fbar = e.callcommand('bar', {'b': 'Eins', 'a': 'Zwei'}) | fbar = e.callcommand(b'bar', {b'b': b'Eins', b'a': b'Zwei'}) | ||||
| fbar2 = e.callcommand('bar', {'b': 'Uno', 'a': 'Due'}) | fbar2 = e.callcommand(b'bar', {b'b': b'Uno', b'a': b'Due'}) | ||||
| print(ffoo.result()) | bprint(ffoo.result()) | ||||
| print(fbar.result()) | bprint(fbar.result()) | ||||
| print(fbar2.result()) | bprint(fbar2.result()) | ||||
| # local usage | # local usage | ||||
| mylocal = localthing() | mylocal = localthing() | ||||
| print() | print() | ||||
| print("== Local") | bprint(b"== Local") | ||||
| use(mylocal) | use(mylocal) | ||||
| # demo remoting; mimicks what wireproto and HTTP/SSH do | # demo remoting; mimicks what wireproto and HTTP/SSH do | ||||
| # shared | # shared | ||||
| def escapearg(plain): | def escapearg(plain): | ||||
| return (plain | return (plain | ||||
| .replace(':', '::') | .replace(b':', b'::') | ||||
| .replace(',', ':,') | .replace(b',', b':,') | ||||
| .replace(';', ':;') | .replace(b';', b':;') | ||||
| .replace('=', ':=')) | .replace(b'=', b':=')) | ||||
| def unescapearg(escaped): | def unescapearg(escaped): | ||||
| return (escaped | return (escaped | ||||
| .replace(':=', '=') | .replace(b':=', b'=') | ||||
| .replace(':;', ';') | .replace(b':;', b';') | ||||
| .replace(':,', ',') | .replace(b':,', b',') | ||||
| .replace('::', ':')) | .replace(b'::', b':')) | ||||
| # server side | # server side | ||||
| # equivalent of wireproto's global functions | # equivalent of wireproto's global functions | ||||
| class server(object): | class server(object): | ||||
| def __init__(self, local): | def __init__(self, local): | ||||
| self.local = local | self.local = local | ||||
| def _call(self, name, args): | def _call(self, name, args): | ||||
| args = dict(arg.split('=', 1) for arg in args) | args = dict(arg.split(b'=', 1) for arg in args) | ||||
| return getattr(self, name)(**args) | return getattr(self, name)(**args) | ||||
| def perform(self, req): | def perform(self, req): | ||||
| print("REQ:", req) | bprint(b"REQ:", req) | ||||
| name, args = req.split('?', 1) | name, args = req.split(b'?', 1) | ||||
| args = args.split('&') | args = args.split(b'&') | ||||
| vals = dict(arg.split('=', 1) for arg in args) | vals = dict(arg.split(b'=', 1) for arg in args) | ||||
| res = getattr(self, name)(**vals) | res = getattr(self, pycompat.sysstr(name))(**pycompat.strkwargs(vals)) | ||||
| print(" ->", res) | bprint(b" ->", res) | ||||
| return res | return res | ||||
| def batch(self, cmds): | def batch(self, cmds): | ||||
| res = [] | res = [] | ||||
| for pair in cmds.split(';'): | for pair in cmds.split(b';'): | ||||
| name, args = pair.split(':', 1) | name, args = pair.split(b':', 1) | ||||
| vals = {} | vals = {} | ||||
| for a in args.split(','): | for a in args.split(b','): | ||||
| if a: | if a: | ||||
| n, v = a.split('=') | n, v = a.split(b'=') | ||||
| vals[n] = unescapearg(v) | vals[n] = unescapearg(v) | ||||
| res.append(escapearg(getattr(self, name)(**vals))) | res.append(escapearg(getattr(self, pycompat.sysstr(name))( | ||||
| return ';'.join(res) | **pycompat.strkwargs(vals)))) | ||||
| return b';'.join(res) | |||||
| def foo(self, one, two): | def foo(self, one, two): | ||||
| return mangle(self.local.foo(unmangle(one), unmangle(two))) | return mangle(self.local.foo(unmangle(one), unmangle(two))) | ||||
| def bar(self, b, a): | def bar(self, b, a): | ||||
| return mangle(self.local.bar(unmangle(b), unmangle(a))) | return mangle(self.local.bar(unmangle(b), unmangle(a))) | ||||
| def greet(self, name): | def greet(self, name): | ||||
| return mangle(self.local.greet(unmangle(name))) | return mangle(self.local.greet(unmangle(name))) | ||||
| myserver = server(mylocal) | myserver = server(mylocal) | ||||
| # local side | # local side | ||||
| # equivalent of wireproto.encode/decodelist, that is, type-specific marshalling | # 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 | # here we just transform the strings a bit to check we're properly en-/decoding | ||||
| def mangle(s): | def mangle(s): | ||||
| return ''.join(chr(ord(c) + 1) for c in s) | return b''.join(pycompat.bytechr(ord(c) + 1) for c in pycompat.bytestr(s)) | ||||
| def unmangle(s): | def unmangle(s): | ||||
| return ''.join(chr(ord(c) - 1) for c in s) | return b''.join(pycompat.bytechr(ord(c) - 1) for c in pycompat.bytestr(s)) | ||||
| # equivalent of wireproto.wirerepository and something like http's wire format | # equivalent of wireproto.wirerepository and something like http's wire format | ||||
| class remotething(thing): | class remotething(thing): | ||||
| def __init__(self, server): | def __init__(self, server): | ||||
| self.server = server | self.server = server | ||||
| def _submitone(self, name, args): | def _submitone(self, name, args): | ||||
| req = name + '?' + '&'.join(['%s=%s' % (n, v) for n, v in args]) | req = name + b'?' + b'&'.join([b'%s=%s' % (n, v) for n, v in args]) | ||||
| return self.server.perform(req) | return self.server.perform(req) | ||||
| def _submitbatch(self, cmds): | def _submitbatch(self, cmds): | ||||
| req = [] | req = [] | ||||
| for name, args in cmds: | for name, args in cmds: | ||||
| args = ','.join(n + '=' + escapearg(v) for n, v in args) | args = b','.join(n + b'=' + escapearg(v) for n, v in args) | ||||
| req.append(name + ':' + args) | req.append(name + b':' + args) | ||||
| req = ';'.join(req) | req = b';'.join(req) | ||||
| res = self._submitone('batch', [('cmds', req,)]) | res = self._submitone(b'batch', [(b'cmds', req,)]) | ||||
| for r in res.split(';'): | for r in res.split(b';'): | ||||
| yield r | yield r | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def commandexecutor(self): | def commandexecutor(self): | ||||
| e = wireprotov1peer.peerexecutor(self) | e = wireprotov1peer.peerexecutor(self) | ||||
| try: | try: | ||||
| yield e | yield e | ||||
| finally: | finally: | ||||
| e.close() | e.close() | ||||
| @wireprotov1peer.batchable | @wireprotov1peer.batchable | ||||
| def foo(self, one, two=None): | def foo(self, one, two=None): | ||||
| encargs = [('one', mangle(one),), ('two', mangle(two),)] | encargs = [(b'one', mangle(one),), (b'two', mangle(two),)] | ||||
| encresref = wireprotov1peer.future() | encresref = wireprotov1peer.future() | ||||
| yield encargs, encresref | yield encargs, encresref | ||||
| yield unmangle(encresref.value) | yield unmangle(encresref.value) | ||||
| @wireprotov1peer.batchable | @wireprotov1peer.batchable | ||||
| def bar(self, b, a): | def bar(self, b, a): | ||||
| encresref = wireprotov1peer.future() | encresref = wireprotov1peer.future() | ||||
| yield [('b', mangle(b),), ('a', mangle(a),)], encresref | yield [(b'b', mangle(b),), (b'a', mangle(a),)], encresref | ||||
| yield unmangle(encresref.value) | yield unmangle(encresref.value) | ||||
| # greet is coded directly. It therefore does not support batching. If it | # 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 | # does appear in a batch, the batch is split around greet, and the call to | ||||
| # greet is done in its own roundtrip. | # greet is done in its own roundtrip. | ||||
| def greet(self, name=None): | def greet(self, name=None): | ||||
| return unmangle(self._submitone('greet', [('name', mangle(name),)])) | return unmangle(self._submitone(b'greet', [(b'name', mangle(name),)])) | ||||
| # demo remote usage | # demo remote usage | ||||
| myproxy = remotething(myserver) | myproxy = remotething(myserver) | ||||
| print() | print() | ||||
| print("== Remote") | bprint(b"== Remote") | ||||
| use(myproxy) | use(myproxy) | ||||