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()
