def test_task_context_relay_fork(): endpoint1 = random_ipc_endpoint() endpoint2 = random_ipc_endpoint() srv_ctx = zerorpc.Context() srv_relay_ctx = zerorpc.Context() cli_ctx = zerorpc.Context() srv_tracer = Tracer("[server]") srv_ctx.register_middleware(srv_tracer) srv_relay_tracer = Tracer("[server_relay]") srv_relay_ctx.register_middleware(srv_relay_tracer) cli_tracer = Tracer("[client]") cli_ctx.register_middleware(cli_tracer) class Srv: def echo(self, msg): return msg srv = zerorpc.Server(Srv(), context=srv_ctx) srv.bind(endpoint1) srv_task = gevent.spawn(srv.run) c_relay = zerorpc.Client(context=srv_relay_ctx) c_relay.connect(endpoint1) class SrvRelay: def echo(self, msg): def dothework(msg): return c_relay.echo(msg) + "relayed" g = gevent.spawn(zerorpc.fork_task_context(dothework, srv_relay_ctx), "relay" + msg) print "relaying in separate task:", g r = g.get() print "back to main task" return r srv_relay = zerorpc.Server(SrvRelay(), context=srv_relay_ctx) srv_relay.bind(endpoint2) srv_relay_task = gevent.spawn(srv_relay.run) c = zerorpc.Client(context=cli_ctx) c.connect(endpoint2) assert c.echo("hello") == "relayhellorelayed" srv_relay.stop() srv.stop() srv_relay_task.join() srv_task.join() assert cli_tracer._log == [("new", cli_tracer.trace_id)] assert srv_relay_tracer._log == [ ("load", cli_tracer.trace_id), ("reuse", cli_tracer.trace_id), ("load", cli_tracer.trace_id), ("reuse", cli_tracer.trace_id), ("reuse", cli_tracer.trace_id), ] assert srv_tracer._log == [("load", cli_tracer.trace_id), ("reuse", cli_tracer.trace_id)]
def test_task_context_relay(): endpoint1 = random_ipc_endpoint() endpoint2 = random_ipc_endpoint() srv_ctx = zerorpc.Context() srv_relay_ctx = zerorpc.Context() cli_ctx = zerorpc.Context() srv_tracer = Tracer('[server]') srv_ctx.register_middleware(srv_tracer) srv_relay_tracer = Tracer('[server_relay]') srv_relay_ctx.register_middleware(srv_relay_tracer) cli_tracer = Tracer('[client]') cli_ctx.register_middleware(cli_tracer) class Srv: def echo(self, msg): return msg srv = zerorpc.Server(Srv(), context=srv_ctx) srv.bind(endpoint1) srv_task = gevent.spawn(srv.run) c_relay = zerorpc.Client(context=srv_relay_ctx) c_relay.connect(endpoint1) class SrvRelay: def echo(self, msg): return c_relay.echo('relay' + msg) + 'relayed' srv_relay = zerorpc.Server(SrvRelay(), context=srv_relay_ctx) srv_relay.bind(endpoint2) srv_relay_task = gevent.spawn(srv_relay.run) c = zerorpc.Client(context=cli_ctx) c.connect(endpoint2) assert c.echo('hello') == 'relayhellorelayed' srv_relay.stop() srv.stop() srv_relay_task.join() srv_task.join() assert cli_tracer._log == [ ('new', cli_tracer.trace_id), ] assert srv_relay_tracer._log == [ ('load', cli_tracer.trace_id), ('reuse', cli_tracer.trace_id), ('reuse', cli_tracer.trace_id), ] assert srv_tracer._log == [ ('load', cli_tracer.trace_id), ('reuse', cli_tracer.trace_id), ]
def test_config_multiple_endpoints(): app = Zask(__name__) endpoint = random_ipc_endpoint() another_endpoint = random_ipc_endpoint() app.config['ZERORPC_SOME_SERVICE'] = { '1.0': endpoint, } app.config['ZERORPC_SOME_SERVICE_2'] = { '1.0': another_endpoint } app.config['ZERORPC_SOME_SERVICE_CLIENT'] = { '1.0': [ endpoint, another_endpoint ], 'default': '1.0' } rpc = ZeroRPC(app, middlewares=[CONFIG_ENDPOINT_MIDDLEWARE]) class Srv(object): __version__ = "1.0" __service_name__ = "some_service" def hello(self): return 'i am server 1' class AnotherSrv(object): __version__ = "1.0" __service_name__ = "some_service_2" def hello(self): return 'i am server 2' srv = rpc.Server(Srv()) another_srv = rpc.Server(AnotherSrv()) gevent.spawn(srv.run) gevent.spawn(another_srv.run) client = rpc.Client('some_service_client') for i in range(5): who_i_am = client.hello() app.logger.debug(who_i_am) assert who_i_am == 'i am server 1' or who_i_am == 'i am server 2' with pytest.raises(MissingConfigException): client = rpc.Client('some_service_client', version='2.0') client.close() srv.close() another_srv.close()
def test_client_server_detailed_exception(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def raise_error(self): raise RuntimeError('oops!') srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=2) client.connect(endpoint) with assert_raises(zerorpc.RemoteError): print client.raise_error() try: client.raise_error() except zerorpc.RemoteError as e: print 'got that:', e print 'name', e.name print 'msg', e.msg assert e.name == 'RuntimeError' assert e.msg == 'oops!' client.close() srv.close()
def test_server_manual(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_channel.emit('lolita', tuple()) event = client_channel.recv() assert event.args == (42,) client_channel.close() client_channel = client.channel() client_channel.emit('add', (1, 2)) event = client_channel.recv() assert event.args == (3,) client_channel.close() srv.stop()
def test_heartbeat_can_open_channel_server_close(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=1) server_bufchan = zerorpc.BufferedChannel(server_hbchan) gevent.sleep(3) print "CLOSE SERVER SOCKET!!!" server_bufchan.close() with assert_raises(zerorpc.LostRemote): client_bufchan.recv() print "CLIENT LOST SERVER :)" client_bufchan.close() server.close() client.close()
def test_events_channel_both_side(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit("openthat", (42,)) event = server.recv() print event assert event.args == (42,) assert event.name == "openthat" server_channel = server.channel(event) server_channel.emit("test", (21,)) event = client_channel.recv() assert event.args == (21,) assert event.name == "test" server_channel.emit("test", (22,)) event = client_channel.recv() assert event.args == (22,) assert event.name == "test" server_events.close() server_channel.close() client_channel.close() client_events.close()
def test_close_client_bufchan(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) client_bufchan.emit('openthat', None) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=1) server_bufchan = zerorpc.BufferedChannel(server_hbchan) server_bufchan.recv() gevent.sleep(3) print 'CLOSE CLIENT SOCKET!!!' client_bufchan.close() with assert_raises(zerorpc.LostRemote): server_bufchan.recv() print 'SERVER LOST CLIENT :)' server_bufchan.close() server.close() client.close()
def test1(): endpoint = random_ipc_endpoint() def server(): c = zmq.Context() s = c.socket(zmq.REP) s.bind(endpoint) while True: print 'srv recving...' r = s.recv() print 'srv', r print 'srv sending...' s.send('world') s.close() c.term() def client(): c = zmq.Context() s = c.socket(zmq.REQ) s.connect(endpoint) print 'cli sending...' s.send('hello') print 'cli recving...' r = s.recv() print 'cli', r s.close() c.term() s = gevent.spawn(server) c = gevent.spawn(client) c.join()
def test_events_channel_both_side(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('openthat', (42,)) event = server.recv() print event assert list(event.args) == [42] assert event.name == 'openthat' server_channel = server.channel(event) server_channel.emit('test', (21,)) event = client_channel.recv() assert list(event.args) == [21] assert event.name == 'test' server_channel.emit('test', (22,)) event = client_channel.recv() assert list(event.args) == [22] assert event.name == 'test' server_events.close() server_channel.close() client_channel.close() client_events.close()
def test_hook_client_handle_remote_error_inspect(): class ClientHandleRemoteErrorMiddleware(object): def __init__(self): self.called = False def client_handle_remote_error(self, event): self.called = True test_middleware = ClientHandleRemoteErrorMiddleware() zero_ctx = zerorpc.Context() zero_ctx.register_middleware(test_middleware) endpoint = random_ipc_endpoint() test_server = zerorpc.Server(EchoModule(), context=zero_ctx) test_server.bind(endpoint) test_server_task = gevent.spawn(test_server.run) test_client = zerorpc.Client(context=zero_ctx) test_client.connect(endpoint) assert test_middleware.called == False try: test_client.crash("test") except zerorpc.RemoteError as ex: assert test_middleware.called == True assert ex.name == "RuntimeError" test_server.stop() test_server_task.join()
def test_close_client_hbchan(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_hbchan.emit('openthat', None) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_hbchan.recv() gevent.sleep(TIME_FACTOR * 3) print 'CLOSE CLIENT SOCKET!!!' client_hbchan.close() if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, server_hbchan.recv) else: with assert_raises(zerorpc.LostRemote): server_hbchan.recv() print 'SERVER LOST CLIENT :)' server_hbchan.close() server.close() client.close()
def test_events_channel_client_side_server_send_many(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('giveme', (10,)) event = server.recv() print event assert list(event.args) == [10] assert event.header.get('zmqid', None) is not None for x in xrange(10): server.emit('someanswer', (x,), xheader=dict(response_to=event.header['message_id'], zmqid=event.header['zmqid'])) for x in xrange(10): event = client_channel.recv() assert list(event.args) == [x]
def test_client_server_client_timeout(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): gevent.sleep(TIME_FACTOR * 10) return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=TIME_FACTOR * 2) client.connect(endpoint) if sys.version_info < (2, 7): assert_raises(zerorpc.TimeoutExpired, client.add, 1, 4) else: with assert_raises(zerorpc.TimeoutExpired): print client.add(1, 4) client.close() srv.close()
def test_client_server_exception(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def raise_something(self, a): return a[4] srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=TIME_FACTOR * 2) client.connect(endpoint) if sys.version_info < (2, 7): def _do_with_assert_raises(): print client.raise_something(42) assert_raises(zerorpc.RemoteError, _do_with_assert_raises) else: with assert_raises(zerorpc.RemoteError): print client.raise_something(42) assert client.raise_something(range(5)) == 4 client.close() srv.close()
def test_pubsub_inheritance(): endpoint = random_ipc_endpoint() publisher = zerorpc.Publisher() publisher.bind(endpoint) trigger = gevent.event.Event() class Subscriber(zerorpc.Subscriber): def lolita(self, a, b): print "lolita", a, b assert a + b == 3 trigger.set() subscriber = Subscriber() subscriber.connect(endpoint) gevent.spawn(subscriber.run) trigger.clear() # We need this retry logic to wait that the subscriber.run coroutine starts # reading (the published messages will go to /dev/null until then). for attempt in xrange(0, 10): publisher.lolita(1, 2) if trigger.wait(0.2): print "done" return raise RuntimeError("The subscriber didn't receive any published message")
def test_events_channel_client_side_server_send_many(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('giveme', (10, )) # 客户端发送Event, Server接受event, 并且验证 event = server.recv() print event assert list(event.args) == [10] assert event.header.get('zmqid', None) is not None # 服务器批量发送消息,客户端批量接受信息 print "message_id: ", event.header['message_id'] print "zmqid: ", event.header['zmqid'] for x in xrange(10): server.emit('someanswer', (x, ), xheader=dict(response_to=event.header['message_id'], zmqid=event.header['zmqid'])) for x in xrange(10): event = client_channel.recv() assert list(event.args) == [x]
def test_close_client_hbchan(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=2) client_hbchan.emit('openthat', None) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=2) server_hbchan.recv() gevent.sleep(3) print 'CLOSE CLIENT SOCKET!!!' client_hbchan.close() if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, server_hbchan.recv) else: with assert_raises(zerorpc.LostRemote): server_hbchan.recv() print 'SERVER LOST CLIENT :)' server_hbchan.close() server.close() client.close()
def test_hook_client_after_request_stream(): zero_ctx = zerorpc.Context() endpoint = random_ipc_endpoint() test_server = zerorpc.Server(EchoModule(), context=zero_ctx) test_server.bind(endpoint) test_server_task = gevent.spawn(test_server.run) test_client = zerorpc.Client(context=zero_ctx) test_client.connect(endpoint) it = test_client.echoes("test") assert next(it) == "echo: test" for echo in it: assert echo == "echo: test" test_middleware = ClientAfterRequestMiddleware() zero_ctx.register_middleware(test_middleware) assert test_middleware.called == False it = test_client.echoes("test") assert next(it) == "echo: test" assert test_middleware.called == False for echo in it: assert echo == "echo: test" assert test_middleware.called == True assert test_middleware.retcode == 'STREAM_DONE' test_server.stop() test_server_task.join()
def test_rcp_streaming(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): @zerorpc.rep def range(self, max): return xrange(max) @zerorpc.stream def xrange(self, max): return xrange(max) srv = MySrv(heartbeat=2) srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(heartbeat=2) client.connect(endpoint) r = client.range(10) assert r == tuple(range(10)) r = client.xrange(10) assert getattr(r, 'next', None) is not None l = [] print 'wait 4s for fun' gevent.sleep(4) for x in r: l.append(x) assert l == range(10)
def test_config_endpoint_1(): app = Zask(__name__) endpoint = random_ipc_endpoint() app.config['ZERORPC_SOME_SERVICE'] = { '1.0': endpoint, } rpc = ZeroRPC(app, middlewares=[CONFIG_ENDPOINT_MIDDLEWARE]) class Srv(rpc.Server): __version__ = "1.0" __service_name__ = "some_service" def hello(self): return 'world' srv = Srv() gevent.spawn(srv.run) client = rpc.Client('some_service', version='1.0') assert client.hello() == 'world' with pytest.raises(ClientMissingVersionException): client = rpc.Client('some_service') client.close() srv.close()
def test_events_channel_client_side(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('someevent', (42, )) event = server.recv() print event assert list(event.args) == [42] assert event.identity is not None reply_event = server.new_event( 'someanswer', (21, ), xheader=dict(response_to=event.header['message_id'])) reply_event.identity = event.identity server.emit_event(reply_event) event = client_channel.recv() assert list(event.args) == [21]
def test_pubsub_inheritance(): endpoint = random_ipc_endpoint() publisher = zerorpc.Publisher() publisher.bind(endpoint) trigger = gevent.event.Event() class Subscriber(zerorpc.Subscriber): def lolita(self, a, b): print 'lolita', a, b assert a + b == 3 trigger.set() subscriber = Subscriber() subscriber.connect(endpoint) gevent.spawn(subscriber.run) trigger.clear() # We need this retry logic to wait that the subscriber.run coroutine starts # reading (the published messages will go to /dev/null until then). for attempt in xrange(0, 10): publisher.lolita(1, 2) if trigger.wait(0.2): print 'done' return raise RuntimeError("The subscriber didn't receive any published message")
def test_exception_compat_v1(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): pass srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) rpccall = client.channel() rpccall.emit('donotexist', tuple()) event = rpccall.recv() print event assert event.name == 'ERR' (name, msg, tb) = event.args print 'detailed error', name, msg, tb assert name == 'NameError' assert msg == 'donotexist' rpccall = client.channel() rpccall.emit('donotexist', tuple(), xheader=dict(v=1)) event = rpccall.recv() print event assert event.name == 'ERR' (msg, ) = event.args print 'msg only', msg assert msg == "NameError('donotexist',)" client_events.close() srv.close()
def test_hook_server_after_exec_stream(): zero_ctx = zerorpc.Context() endpoint = random_ipc_endpoint() test_server = zerorpc.Server(EchoModule(), context=zero_ctx) test_server.bind(endpoint) test_server_task = gevent.spawn(test_server.run) test_client = zerorpc.Client() test_client.connect(endpoint) # Test without a middleware for echo in test_client.echoes("test"): assert echo == "echo: test" # Test with a middleware test_middleware = ServerAfterExecMiddleware() zero_ctx.register_middleware(test_middleware) assert test_middleware.called == False it = test_client.echoes("test") assert next(it) == "echo: test" assert test_middleware.called == False for echo in it: assert echo == "echo: test" assert test_middleware.called == True assert test_middleware.request_event_name == 'echoes' assert test_middleware.reply_event_name == 'STREAM_DONE' test_server.stop() test_server_task.join()
def test_events_channel_client_side_server_send_many(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('giveme', (10,)) event = server.recv() print event assert event.args == (10,) assert event.header.get('zmqid', None) is not None for x in xrange(10): server.emit('someanswer', (x,), xheader=dict(response_to=event.header['message_id'], zmqid=event.header['zmqid'])) for x in xrange(10): event = client_channel.recv() assert event.args == (x,)
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=TIME_FACTOR * 2) except zerorpc.RemoteError: pass assert echo_module.last_msg == "Raise" assert test_middleware.called == False test_server.stop() test_server_task.join()
def testing_scope_session(): app = Zask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://' app.config['DEBUG'] = False db = sqlalchemy.SQLAlchemy(app) endpoint = random_ipc_endpoint() rpc = ZeroRPC(app, middlewares=None) rpc.register_middleware(sqlalchemy.SessionMiddleware(db)) class Foo(object): def create_foo(self, ctx): ctx2 = _request_ctx.get_request_cxt() assert ctx == ctx2 class Srv(rpc.Server): def get_session(self): ctx = _request_ctx.get_request_cxt() foo = Foo() foo.create_foo(ctx) return str(db.session()) srv = Srv(pool_size=1) srv.bind(endpoint) gevent.spawn(srv.run) client = rpc.Client(endpoint) session1 = client.get_session(async=True) session2 = client.get_session(async=True) assert session1.get() != session2.get()
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=TIME_FACTOR * 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=TIME_FACTOR * 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_events_channel_client_side_server_send_many(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit("giveme", (10,)) event = server.recv() print event assert event.args == (10,) assert event.header.get("zmqid", None) is not None for x in xrange(10): server.emit( "someanswer", (x,), xheader=dict(response_to=event.header["message_id"], zmqid=event.header["zmqid"]) ) for x in xrange(10): event = client_channel.recv() assert event.args == (x,)
def test_heartbeat_can_open_channel_server_close(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) gevent.sleep(TIME_FACTOR * 3) print 'CLOSE SERVER SOCKET!!!' server_bufchan.close() if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, client_bufchan.recv) else: with assert_raises(zerorpc.LostRemote): client_bufchan.recv() print 'CLIENT LOST SERVER :)' client_bufchan.close() server.close() client.close()
def test_hook_client_after_request_timeout(): class ClientAfterRequestMiddleware(object): def __init__(self): self.called = False def client_after_request(self, req_event, rep_event, exception): self.called = True assert req_event is not None assert req_event.name == "timeout" assert rep_event is None zero_ctx = zerorpc.Context() test_middleware = ClientAfterRequestMiddleware() zero_ctx.register_middleware(test_middleware) endpoint = random_ipc_endpoint() test_server = zerorpc.Server(EchoModule(), context=zero_ctx) test_server.bind(endpoint) test_server_task = gevent.spawn(test_server.run) test_client = zerorpc.Client(timeout=TIME_FACTOR * 1, context=zero_ctx) test_client.connect(endpoint) assert test_middleware.called == False try: test_client.timeout("test") except zerorpc.TimeoutExpired as ex: assert test_middleware.called == True assert "timeout" in ex.args[0] test_server.stop() test_server_task.join()
def test_exception_compat_v1(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): pass srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) rpccall = client.channel() rpccall.emit('donotexist', tuple()) event = rpccall.recv() print event assert event.name == 'ERR' (name, msg, tb) = event.args print 'detailed error', name, msg, tb assert name == 'NameError' assert msg == 'donotexist' rpccall = client.channel() rpccall.emit('donotexist', tuple(), xheader=dict(v=1)) event = rpccall.recv() print event assert event.name == 'ERR' (msg,) = event.args print 'msg only', msg assert msg == "NameError('donotexist',)" client_events.close() srv.close()
def test_rcp_streaming(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): @zerorpc.rep def range(self, max): return range(max) @zerorpc.stream def xrange(self, max): return xrange(max) srv = MySrv(heartbeat=TIME_FACTOR * 4) srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(heartbeat=TIME_FACTOR * 4) client.connect(endpoint) r = client.range(10) assert list(r) == list(range(10)) r = client.xrange(10) assert getattr(r, 'next', None) is not None l = [] print 'wait 4s for fun' gevent.sleep(TIME_FACTOR * 4) for x in r: l.append(x) assert l == range(10)
def test_hook_client_before_request(): class ClientBeforeRequestMiddleware(object): def __init__(self): self.called = False def client_before_request(self, event): self.called = True self.method = event.name zero_ctx = zerorpc.Context() endpoint = random_ipc_endpoint() test_server = zerorpc.Server(EchoModule(), context=zero_ctx) test_server.bind(endpoint) test_server_task = gevent.spawn(test_server.run) test_client = zerorpc.Client(context=zero_ctx) test_client.connect(endpoint) assert test_client.echo("test") == "echo: test" test_middleware = ClientBeforeRequestMiddleware() zero_ctx.register_middleware(test_middleware) assert test_middleware.called == False assert test_client.echo("test") == "echo: test" assert test_middleware.called == True assert test_middleware.method == 'echo' test_server.stop() test_server_task.join()
def test_resolve_endpoint_events(): test_endpoint = random_ipc_endpoint() c = zerorpc.Context() class Resolver(): def resolve_endpoint(self, endpoint): if endpoint == 'some_service': return test_endpoint return endpoint class Srv(zerorpc.Server): def hello(self): print 'heee' return 'world' srv = Srv(heartbeat=TIME_FACTOR * 1, context=c) if sys.version_info < (2, 7): assert_raises(zmq.ZMQError, srv.bind, 'some_service') else: with assert_raises(zmq.ZMQError): srv.bind('some_service') cnt = c.register_middleware(Resolver()) assert cnt == 1 srv.bind('some_service') gevent.spawn(srv.run) client = zerorpc.Client(heartbeat=TIME_FACTOR * 1, context=c) client.connect('some_service') assert client.hello() == 'world' client.close() srv.close()
def test_sub_events(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_channel_events = zerorpc.WrappedEvents(client_channel) client_channel_events.emit("coucou", 42) event = server.recv() print event assert type(event.args) is tuple assert event.name == "w" subevent = event.args print "subevent:", subevent server_channel = server.channel(event) server_channel_events = zerorpc.WrappedEvents(server_channel) server_channel_channel = zerorpc.ChannelMultiplexer(server_channel_events) event = server_channel_channel.recv() print event assert event.name == "coucou" assert event.args == 42 server_events.close() client_events.close()
def test_client_server_exception(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def raise_something(self, a): return a[4] srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=2) client.connect(endpoint) if sys.version_info < (2, 7): def _do_with_assert_raises(): print client.raise_something(42) assert_raises(zerorpc.RemoteError, _do_with_assert_raises) else: with assert_raises(zerorpc.RemoteError): print client.raise_something(42) assert client.raise_something(range(5)) == 4 client.close() srv.close()
def test_client_server_client_timeout(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): gevent.sleep(10) return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=2) client.connect(endpoint) if sys.version_info < (2, 7): assert_raises(zerorpc.TimeoutExpired, client.add, 1, 4) else: with assert_raises(zerorpc.TimeoutExpired): print client.add(1, 4) client.close() srv.close()
def test_sub_events(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_channel_events = zerorpc.WrappedEvents(client_channel) client_channel_events.emit('coucou', 42) event = server.recv() print event assert type(event.args) is tuple assert event.name == 'w' subevent = event.args print 'subevent:', subevent server_channel = server.channel(event) server_channel_events = zerorpc.WrappedEvents(server_channel) server_channel_channel = zerorpc.ChannelMultiplexer(server_channel_events) event = server_channel_channel.recv() print event assert event.name == 'coucou' assert event.args == 42 server_events.close() client_events.close()
def test_client_server_client_timeout_with_async(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): gevent.sleep(10) return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(timeout=2) client.connect(endpoint) # 异步和同步的差别? async_result = client.add(1, 4, async=True) if sys.version_info < (2, 7): def _do_with_assert_raises(): print async_result.get() assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises) else: with assert_raises(zerorpc.TimeoutExpired): print async_result.get() client.close() srv.close()
def test_close_client_bufchan(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) client_bufchan.emit('openthat', None) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=1) server_bufchan = zerorpc.BufferedChannel(server_hbchan) server_bufchan.recv() gevent.sleep(3) print 'CLOSE CLIENT SOCKET!!!' client_bufchan.close() server_hbchan.close() client_channel.close() with assert_raises(zerorpc.LostRemote): server_bufchan.recv() print 'SERVER LOST CLIENT :)' server_bufchan.close() client_hbchan.close() server_channel.close() server.close() client.close()
def test_client_server_with_async(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client() client.connect(endpoint) async_result = client.lolita(async=True) # 没有timeout, 一直等待结果 assert async_result.get() == 42 async_result = client.add(1, 4, async=True) assert async_result.get() == 5
def test_events_channel_client_side_server_send_many(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('giveme', (10, )) event = server.recv() print event assert list(event.args) == [10] assert event.identity is not None for x in xrange(10): reply_event = server.new_event( 'someanswer', (x, ), xheader=dict(response_to=event.header['message_id'])) reply_event.identity = event.identity server.emit_event(reply_event) for x in xrange(10): event = client_channel.recv() assert list(event.args) == [x]
def test_config_endpoint_2(): app = Zask(__name__) endpoint = random_ipc_endpoint() app.config['ZERORPC_SOME_SERVICE'] = { '1.0': endpoint, 'default': '1.0' } rpc = ZeroRPC(app, middlewares=[CONFIG_ENDPOINT_MIDDLEWARE]) class Srv(object): __version__ = "1.0" __service_name__ = "some_service" def hello(self): return 'world' srv = rpc.Server(Srv()) gevent.spawn(srv.run) client = rpc.Client('some_service') assert client.hello() == 'world' with pytest.raises(MissingConfigException): client = rpc.Client('some_service', version='2.0') client.close() srv.close()
def test_server_manual(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): def lolita(self): return 42 def add(self, a, b): return a + b srv = MySrv() srv.bind(endpoint) gevent.spawn(srv.run) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_channel.emit('lolita', tuple()) event = client_channel.recv() assert event.args == (42, ) client_channel.close() client_channel = client.channel() client_channel.emit('add', (1, 2)) event = client_channel.recv() assert event.args == (3, ) client_channel.close() srv.stop()
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_heartbeat_can_open_channel_server_close(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=2) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=2) gevent.sleep(3) print 'CLOSE SERVER SOCKET!!!' server_hbchan.close() with assert_raises(zerorpc.LostRemote): client_hbchan.recv() print 'CLIENT LOST SERVER :)' client_hbchan.close() server.close() client.close()
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_events_channel_both_side(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.XREP) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.XREQ) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events) client_channel = client.channel() client_channel.emit('openthat', (42,)) event = server.recv() print event assert event.args == (42,) assert event.name == 'openthat' server_channel = server.channel(event) server_channel.emit('test', (21,)) event = client_channel.recv() assert event.args == (21,) assert event.name == 'test' server_channel.emit('test', (22,)) event = client_channel.recv() assert event.args == (22,) assert event.name == 'test' server_events.close() server_channel.close() client_channel.close() client_events.close()
def test_heartbeat_can_open_channel_client_close(): endpoint = random_ipc_endpoint() server_events = zerorpc.Events(zmq.ROUTER) server_events.bind(endpoint) server = zerorpc.ChannelMultiplexer(server_events) client_events = zerorpc.Events(zmq.DEALER) client_events.connect(endpoint) client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True) client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=2) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=2) gevent.sleep(3) print 'CLOSE CLIENT SOCKET!!!' client_hbchan.close() client.close() with assert_raises(zerorpc.LostRemote): server_hbchan.recv() print 'SERVER LOST CLIENT :)' server_hbchan.close() server.close()