def test_hook_server_before_exec_puller():
zero_ctx = zerorpc.Context()
trigger = gevent.event.Event()
endpoint = random_ipc_endpoint()
echo_module = EchoModule(trigger)
test_server = zerorpc.Puller(echo_module, context=zero_ctx)
test_server.bind(endpoint)
test_server_task = gevent.spawn(test_server.run)
test_client = zerorpc.Pusher()
test_client.connect(endpoint)
# Test without a middleware
test_client.echo("test")
trigger.wait(timeout=2)
assert echo_module.last_msg == "echo: test"
trigger.clear()
# Test with a middleware
test_middleware = ServerBeforeExecMiddleware()
zero_ctx.register_middleware(test_middleware)
assert test_middleware.called == False
test_client.echo("test with a middleware")
trigger.wait(timeout=2)
assert echo_module.last_msg == "echo: test with a middleware"
assert test_middleware.called == True
test_server.stop()
test_server_task.join()
def test_server_inspect_exception_middleware_puller():
endpoint = random_ipc_endpoint()
barrier = gevent.event.Event()
middleware = InspectExceptionMiddleware(barrier)
ctx = zerorpc.Context()
ctx.register_middleware(middleware)
module = Srv()
server = zerorpc.Puller(module, context=ctx)
server.bind(endpoint)
gevent.spawn(server.run)
client = zerorpc.Pusher()
client.connect(endpoint)
barrier.clear()
client.echo(
'This is a test which should call the InspectExceptionMiddleware')
barrier.wait(timeout=2)
client.close()
server.close()
assert middleware.called is True
def test_hook_server_after_exec_on_error_puller():
zero_ctx = zerorpc.Context()
trigger = gevent.event.Event()
endpoint = random_ipc_endpoint()
echo_module = BrokenEchoModule(trigger)
test_server = zerorpc.Puller(echo_module, context=zero_ctx)
test_server.bind(endpoint)
test_server_task = gevent.spawn(test_server.run)
test_client = zerorpc.Pusher()
test_client.connect(endpoint)
test_middleware = ServerAfterExecMiddleware()
zero_ctx.register_middleware(test_middleware)
assert test_middleware.called == False
try:
test_client.echo("test with a middleware")
trigger.wait(timeout=2)
except zerorpc.RemoteError:
pass
assert echo_module.last_msg == "Raise"
assert test_middleware.called == False
test_server.stop()
test_server_task.join()
def test_hook_server_after_exec_puller():
zero_ctx = zerorpc.Context()
trigger = gevent.event.Event()
echo_module = EchoModule(trigger)
test_server = zerorpc.Puller(echo_module, context=zero_ctx)
test_server.bind(endpoint)
test_server_task = gevent.spawn(test_server.run)
test_client = zerorpc.Pusher()
test_client.connect(endpoint)
# Test without a middleware
test_client.echo("test")
trigger.wait(timeout=TIME_FACTOR * 2)
assert echo_module.last_msg == "echo: test"
trigger.clear()
# Test with a middleware
test_middleware = ServerAfterExecMiddleware()
zero_ctx.register_middleware(test_middleware)
assert test_middleware.called == False
test_client.echo("test with a middleware")
trigger.wait(timeout=TIME_FACTOR * 2)
assert echo_module.last_msg == "echo: test with a middleware"
assert test_middleware.called == True
assert test_middleware.request_event_name == 'echo'
assert test_middleware.reply_event_name is None
test_server.stop()
test_server_task.join()
def test_pushpull_inheritance():
'''
推拉 接口
用于平峰
Pusher 推, 放入数据
Puller 拉, 主动拉取数据
:return:
'''
pusher = zerorpc.Pusher()
pusher.bind(endpoint)
trigger = gevent.event.Event()
class Puller(zerorpc.Puller):
def lolita(self, a, b):
print('lolita', a, b)
assert a + b == 3
trigger.set()
puller = Puller()
puller.connect(endpoint)
gevent.spawn(puller.run)
trigger.clear()
pusher.lolita(1, 2)
trigger.wait()
print('done')
def test_task_context_pushpull():
puller_ctx = zerorpc.Context()
pusher_ctx = zerorpc.Context()
puller_tracer = Tracer('[puller]')
puller_ctx.register_middleware(puller_tracer)
pusher_tracer = Tracer('[pusher]')
pusher_ctx.register_middleware(pusher_tracer)
trigger = gevent.event.Event()
class Puller(object):
def echo(self, msg):
trigger.set()
puller = zerorpc.Puller(Puller(), context=puller_ctx)
puller.bind(endpoint)
puller_task = gevent.spawn(puller.run)
c = zerorpc.Pusher(context=pusher_ctx)
c.connect(endpoint)
trigger.clear()
c.echo('hello')
trigger.wait()
puller.stop()
puller_task.join()
assert pusher_tracer._log == [
('new', pusher_tracer.trace_id),
]
assert puller_tracer._log == [
('load', pusher_tracer.trace_id),
]
def test_pushpull_inheritance():
endpoint = random_ipc_endpoint()
pusher = zerorpc.Pusher()
pusher.bind(endpoint)
trigger = gevent.event.Event()
class Puller(zerorpc.Puller):
def lolita(self, a, b):
print 'lolita', a, b
assert a + b == 3
trigger.set()
puller = Puller()
puller.connect(endpoint)
gevent.spawn(puller.run)
trigger.clear()
pusher.lolita(1, 2)
trigger.wait()
print 'done'
def test_inspect_error_middleware_puller():
class InspectErrorMiddleware(Tracer):
def __init__(self, barrier):
self.called = False
self._barrier = barrier
Tracer.__init__(self, identity='[server]')
def inspect_error(self, task_context, exc_info):
assert 'trace_id' in task_context
exc_type, exc_value, exc_traceback = exc_info
self.called = True
self._barrier.set()
class Srv(object):
def echo(self, msg):
raise RuntimeError(msg)
endpoint = random_ipc_endpoint()
barrier = gevent.event.Event()
middleware = InspectErrorMiddleware(barrier)
ctx = zerorpc.Context()
ctx.register_middleware(middleware)
module = Srv()
server = zerorpc.Puller(module, context=ctx)
server.bind(endpoint)
gevent.spawn(server.run)
client = zerorpc.Pusher()
client.connect(endpoint)
barrier.clear()
client.echo('This is a test which should call the InspectErrorMiddleware')
barrier.wait()
client.close()
server.close()
assert middleware.called is True
def test_pushpull_composite():
endpoint = random_ipc_endpoint()
trigger = gevent.event.Event()
class Puller(object):
def lolita(self, a, b):
print('lolita', a, b)
assert a + b == 3
trigger.set()
pusher = zerorpc.Pusher()
pusher.bind(endpoint)
service = Puller()
puller = zerorpc.Puller(service)
puller.connect(endpoint)
gevent.spawn(puller.run)
trigger.clear()
pusher.lolita(1, 2)
trigger.wait()
print('done')
# coding: utf-8
# __author__: ""
import zerorpc
from gevent import event
endpoint = "tcp://0.0.0.0:4243"
pusher = zerorpc.Pusher()
pusher.bind(endpoint)
trigger = event.Event()
trigger.clear()
pusher.lolita(1, 4)
trigger.wait()
print('done')
def test_call_procedure():
c = zerorpc.Context()
def test(argument):
return 'ret_real:' + argument
assert c.middleware_call_procedure(test, 'dummy') == 'ret_real:dummy'
def middleware_1(procedure, *args, **kwargs):
return 'ret_middleware_1:' + procedure(*args, **kwargs)
cnt = c.register_middleware({'call_procedure': middleware_1})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_1:ret_real:dummy'
def middleware_2(procedure, *args, **kwargs):
return 'ret_middleware_2:' + procedure(*args, **kwargs)
cnt = c.register_middleware({'call_procedure': middleware_2})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:dummy'
def mangle_arguments(procedure, *args, **kwargs):
return procedure(args[0].upper())
cnt = c.register_middleware({'call_procedure': mangle_arguments})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:DUMMY'
endpoint = random_ipc_endpoint()
# client/server
class Server(zerorpc.Server):
def test(self, argument):
return 'ret_real:' + argument
server = Server(heartbeat=1, context=c)
server.bind(endpoint)
gevent.spawn(server.run)
client = zerorpc.Client(heartbeat=1, context=c)
client.connect(endpoint)
assert client.test('dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:DUMMY'
client.close()
server.close()
# push/pull
trigger = gevent.event.Event()
class Puller(zerorpc.Puller):
argument = None
def test(self, argument):
self.argument = argument
trigger.set()
return self.argument
puller = Puller(context=c)
puller.bind(endpoint)
gevent.spawn(puller.run)
pusher = zerorpc.Pusher(context=c)
pusher.connect(endpoint)
trigger.clear()
pusher.test('dummy')
trigger.wait()
assert puller.argument == 'DUMMY'
#FIXME: These seems to be broken
# pusher.close()
# puller.close()
# pub/sub
trigger = gevent.event.Event()
class Subscriber(zerorpc.Subscriber):
argument = None
def test(self, argument):
self.argument = argument
trigger.set()
return self.argument
subscriber = Subscriber(context=c)
subscriber.bind(endpoint)
gevent.spawn(subscriber.run)
publisher = zerorpc.Publisher(context=c)
publisher.connect(endpoint)
trigger.clear()
publisher.test('dummy')
trigger.wait()
assert subscriber.argument == 'DUMMY'
def __init__(self, connect_to):
super(Client, self).__init__(connect_to)
self.client = zerorpc.Pusher()
self.client.connect(connect_to)
