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_close_client_bufchan(): 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_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=2) 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 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_close_client_bufchan(): 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) client_bufchan.emit('openthat', None) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) server_bufchan.recv() gevent.sleep(TIME_FACTOR * 3) print('CLOSE CLIENT SOCKET!!!') client_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('SERVER LOST CLIENT :)') server_bufchan.close() server.close() client.close()
def test_multiple_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_channel1 = client.channel() client_channel_events1 = zerorpc.WrappedEvents(client_channel1) client_channel2 = zerorpc.BufferedChannel(client.channel()) client_channel_events2 = zerorpc.WrappedEvents(client_channel2) def emitstuff(): client_channel_events1.emit('coucou1', 43) client_channel_events2.emit('coucou2', 44) client_channel_events2.emit('another', 42) gevent.spawn(emitstuff) event = server.recv() print event assert isinstance(event.args, (list, tuple)) assert event.name == 'w' subevent = event.args print 'subevent:', subevent server_channel = server.channel(event) server_channel_events = zerorpc.WrappedEvents(server_channel) event = server_channel_events.recv() print 'ch1:', event assert event.name == 'coucou1' assert event.args == 43 event = server.recv() print event assert isinstance(event.args, (list, tuple)) assert event.name == 'w' subevent = event.args print 'subevent:', subevent server_channel = server.channel(event) server_channel_events = zerorpc.BufferedChannel(server_channel) server_channel_events = zerorpc.WrappedEvents(server_channel_events) event = server_channel_events.recv() print 'ch2:', event assert event.name == 'coucou2' assert event.args == 44 event = server_channel_events.recv() print 'ch2:', event assert event.name == 'another' assert event.args == 42 server_events.close() client_events.close()
def test_on_close_if(): """ Test that the on_close_if method does not cause exceptions when the client is slow to recv() data. """ 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_bufchan = zerorpc.BufferedChannel(client_hbchan, inqueue_size=10) event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=2) server_bufchan = zerorpc.BufferedChannel(server_hbchan, inqueue_size=10) seen = [] def is_stream_done(event): return event.name == 'done' def client_do(): while True: event = client_bufchan.recv() if event.name == 'done': return seen.append(event.args) gevent.sleep(0.1) def server_do(): for i in range(0, 10): server_bufchan.emit('blah', (i)) server_bufchan.emit('done', ('bye')) client_bufchan.on_close_if = is_stream_done coro_pool = gevent.pool.Pool() g1 = coro_pool.spawn(client_do) g2 = coro_pool.spawn(server_do) g1.get() # Re-raise any exceptions... g2.get() assert seen == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] client_bufchan.close() server_bufchan.close() client.close() server.close()
def test_congestion_control_server_pushing(): 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) def client_do(): for x in xrange(200): event = client_bufchan.recv() assert event.name == 'coucou' assert event.args == x client_task = gevent.spawn(client_do) def server_do(): with assert_raises(CongestionError): for x in xrange(200): if server_bufchan.emit('coucou', x, block=False) == False: raise CongestionError() # will fail when x == 1 server_bufchan.emit('coucou', 1) # block until receiver is ready with assert_raises(CongestionError): for x in xrange(2, 200): if server_bufchan.emit('coucou', x, block=False) == False: raise CongestionError() # will fail when x == 100 for x in xrange(101, 200): server_bufchan.emit('coucou', x) # block until receiver is ready server_task = gevent.spawn(server_do) server_task.get() client_task.get() client_bufchan.close() client.close() server_task.get() server_bufchan.close() server.close()
def _async_task(self, initial_event): # We had to replace zerorpc's _async_task implementation due to two reasons: # 1. Original implementation doesn't handle exceptions like we want, specifically in its response-builder # code. # 2. We don't want heartbeats because zerorpc's heartbeat implementation may cause active requests in the server # to get killed (they are greenlets) in middle of processing if the heartbeat detects a lost peer. channel = self._multiplexer.channel(initial_event) bufchan = zerorpc.BufferedChannel(channel) event = bufchan.recv() try: self._context.hook_load_task_context(event.header) functor = self._methods.get(event.name, None) if functor is not None: functor.pattern.process_call(self._context, bufchan, event, functor) else: self.log_debug("invalid RPC method received: {}".format(event.name)) result = base.encode_rpc_result_invalid_rpc_method_exc_info(event.name) if hasattr(bufchan, 'new_event'): reply_event = bufchan.new_event('OK', (result,), self._context.hook_get_task_context()) else: reply_event = bufchan.create_event('OK', (result,), self._context.hook_get_task_context()) self._context.hook_server_after_exec(event, reply_event) bufchan.emit_event(reply_event) except: self.log_exception("unhandled exception in zerorpc transport while handling event {}".format(event)) raise finally: bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) if sys.version_info < (2, 7): def _do_with_assert_raises(): for x in range(20): event = server_bufchan.recv() assert event.name == 'sleep' gevent.sleep(TIME_FACTOR * event.args[0]) server_bufchan.emit('OK', event.args) assert_raises(zerorpc.LostRemote, _do_with_assert_raises) else: with assert_raises(zerorpc.LostRemote): for x in range(20): event = server_bufchan.recv() assert event.name == 'sleep' gevent.sleep(TIME_FACTOR * event.args[0]) server_bufchan.emit('OK', event.args) server_bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan, inqueue_size=100) if sys.version_info < (2, 7): def _do_with_assert_raises(): for x in range(200): server_bufchan.emit('coucou', x, timeout=0) # will fail when x == 1 assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises) else: with assert_raises(zerorpc.TimeoutExpired): for x in range(200): server_bufchan.emit('coucou', x, timeout=0) # will fail when x == 1 server_bufchan.emit('coucou', 1) # block until receiver is ready if sys.version_info < (2, 7): def _do_with_assert_raises(): for x in range(2, 200): server_bufchan.emit('coucou', x, timeout=0) # will fail when x == 100 assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises) else: with assert_raises(zerorpc.TimeoutExpired): for x in range(2, 200): server_bufchan.emit('coucou', x, timeout=0) # will fail when x == 100 for x in range(read_cnt.value, 200): server_bufchan.emit('coucou', x) # block until receiver is ready server_bufchan.close()
def client_do(): client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan) for x in range(20): client_bufchan.emit('add', (x, x * x)) event = client_bufchan.recv() assert event.name == 'OK' assert list(event.args) == [x + x * x] client_bufchan.close()
def server_fn(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) try: while True: gevent.sleep(1) finally: server_bufchan.close()
def client_do(): client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan, inqueue_size=100) for x in range(200): event = client_bufchan.recv() assert event.name == 'coucou' assert event.args == x read_cnt.value += 1 client_bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) for x in range(10): event = server_bufchan.recv() assert event.name == 'add' server_bufchan.emit('OK', (sum(event.args),)) server_bufchan.close()
def test_do_some_req_rep(): 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) def client_do(): for x in xrange(20): client_bufchan.emit('add', (x, x * x)) event = client_bufchan.recv() assert event.name == 'OK' assert event.args == (x + x * x, ) client_bufchan.close() client_task = gevent.spawn(client_do) def server_do(): for x in xrange(20): event = server_bufchan.recv() assert event.name == 'add' server_bufchan.emit('OK', (sum(event.args), )) server_bufchan.close() server_task = gevent.spawn(server_do) server_task.get() client_task.get() client.close() server.close()
def client_do(): client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) for x in xrange(10): client_bufchan.emit('add', (x, x * x)) event = client_bufchan.recv() assert event.name == 'OK' assert event.args == (x + x * x, ) client_bufchan.close()
def client_do(): client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) with assert_raises(zerorpc.TimeoutExpired): for x in xrange(10): client_bufchan.emit('sleep', (x, )) event = client_bufchan.recv(timeout=3) assert event.name == 'OK' assert event.args == (x, ) client_bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=1) server_bufchan = zerorpc.BufferedChannel(server_hbchan) with assert_raises(zerorpc.LostRemote): for x in xrange(20): event = server_bufchan.recv() assert event.name == 'sleep' gevent.sleep(event.args[0]) server_bufchan.emit('OK', event.args) server_bufchan.close()
def client_do(): print 'running' client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=1) client_bufchan = zerorpc.BufferedChannel(client_hbchan) for x in xrange(10): client_bufchan.emit('add', (x, x * x)) event = client_bufchan.recv() assert event.name == 'OK' assert event.args == (x + x * x, ) client_bufchan.emit('add', (x, x * x)) with assert_raises(zerorpc.LostRemote): event = client_bufchan.recv() client_bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=1) server_bufchan = zerorpc.BufferedChannel(server_hbchan) for x in xrange(10): event = server_bufchan.recv() assert event.name == 'add' server_bufchan.emit('OK', (sum(event.args), )) with assert_raises(zerorpc.LostRemote): event = server_bufchan.recv() server_bufchan.close()
def server_do(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) for x in range(10): event = server_bufchan.recv() assert event.name == 'add' server_bufchan.emit('OK', (sum(event.args),)) if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, server_bufchan.recv) else: with assert_raises(zerorpc.LostRemote): server_bufchan.recv() server_bufchan.close()
def client_do(): print('running') client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan) for x in range(10): client_bufchan.emit('add', (x, x * x)) event = client_bufchan.recv() assert event.name == 'OK' assert list(event.args) == [x + x * x] client_bufchan.emit('add', (x, x * x)) if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, client_bufchan.recv) else: with assert_raises(zerorpc.LostRemote): client_bufchan.recv() client_bufchan.close()
def client_do(): client_channel = client.channel() client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan) if sys.version_info < (2, 7): def _do_with_assert_raises(): for x in range(10): client_bufchan.emit('sleep', (x,)) event = client_bufchan.recv(timeout=TIME_FACTOR * 3) assert event.name == 'OK' assert list(event.args) == [x] assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises) else: with assert_raises(zerorpc.TimeoutExpired): for x in range(10): client_bufchan.emit('sleep', (x,)) event = client_bufchan.recv(timeout=TIME_FACTOR * 3) assert event.name == 'OK' assert list(event.args) == [x] client_bufchan.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=TIME_FACTOR * 2) client_bufchan = zerorpc.BufferedChannel(client_hbchan) def server_fn(): event = server.recv() server_channel = server.channel(event) server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2) server_bufchan = zerorpc.BufferedChannel(server_hbchan) try: while True: gevent.sleep(1) finally: server_bufchan.close() server_coro = gevent.spawn(server_fn) gevent.sleep(TIME_FACTOR * 3) print('CLOSE CLIENT SOCKET!!!') client_bufchan.close() client.close() if sys.version_info < (2, 7): assert_raises(zerorpc.LostRemote, server_coro.get) else: with assert_raises(zerorpc.LostRemote): server_coro.get() print('SERVER LOST CLIENT :)') server.close()