def go():
port = find_unused_port()
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
bind='tcp://127.0.0.1:{}'.format(port))
client = yield from aiozmq.rpc.connect_rpc(
connect='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([struct.pack('=HHLd?', 1, 2, 3, 4, True),
b'bad_answer'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, b'bad_answer'],),
ret.args)
self.assertIsNotNone(ret.exc_info)
client.close()
tr.close()
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(asyncio.TimeoutError):
t0 = time.monotonic()
with client.with_timeout(0.1) as timedout:
yield from timedout.call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1 - t0 <= 0.12, t1 - t0)
t0 = time.monotonic()
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1 - t0 <= 0.12, t1 - t0)
ret = yield from self.err_queue.get()
# TODO: make a test for several unexpected calls
# This test should to do that but result is a bit suspicious
# self.assertEqual(1, self.err_queue.qsize())
self.assertEqual(logging.DEBUG, ret.levelno)
self.assertEqual(
"The future for request #%08x "
"has been cancelled, "
"skip the received result.", ret.msg)
self.assertEqual((1, ), ret.args)
self.assertIsNone(ret.exc_info)
def go():
port = find_unused_port()
tr, pr = yield from create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
client = yield from aiozmq.rpc.connect_rpc(
connect='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([struct.pack('=HHLd?', 1, 2, 3, 4, True),
b'bad_answer'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, b'bad_answer'],),
ret.args)
self.assertIsNotNone(ret.exc_info)
client.close()
tr.close()
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(asyncio.TimeoutError):
t0 = time.monotonic()
with client.with_timeout(0.1) as timedout:
yield from timedout.call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1-t0 <= 0.12, t1-t0)
t0 = time.monotonic()
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1-t0 <= 0.12, t1-t0)
ret = yield from self.err_queue.get()
# TODO: make a test for several unexpected calls
# This test should to do that but result is a bit suspicious
# self.assertEqual(1, self.err_queue.qsize())
self.assertEqual(logging.DEBUG, ret.levelno)
self.assertEqual("The future for request #%08x "
"has been cancelled, "
"skip the received result.", ret.msg)
self.assertEqual((1,), ret.args)
self.assertIsNone(ret.exc_info)
def go():
port = find_unused_port()
server = yield from aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
tr, pr = yield from create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
connect='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([
struct.pack('=HHLd', 1, 2, 3, 4),
msgpack.packb((1, 2)), b'bad_kwargs'
])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, mock.ANY, mock.ANY, b'bad_kwargs'], ),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
def go():
port = find_unused_port()
tr, pr = yield from create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
client = yield from aiozmq.rpc.connect_rpc(
connect='tcp://127.0.0.1:{}'.format(port), loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([
struct.pack('=HHLd?', 1, 2, 34435, 4, True),
msgpack.packb((1, 2))
])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Unknown answer id: %d (%d %d %f %d) -> %s",
ret.msg)
self.assertEqual((mock.ANY, 1, 2, 4.0, True, (1, 2)), ret.args)
self.assertIsNone(ret.exc_info)
client.close()
def go():
port = find_unused_port()
tr, pr = yield from create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
client = yield from aiozmq.rpc.connect_rpc(
connect='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([struct.pack('=HHLd?', 1, 2, 34435, 4, True),
msgpack.packb((1, 2))])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Unknown answer id: %d (%d %d %f %d) -> %s",
ret.msg)
self.assertEqual(
(mock.ANY, 1, 2, 4.0, True, (1, 2)),
ret.args)
self.assertIsNone(ret.exc_info)
client.close()
def go():
port = find_unused_port()
server = yield from aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
tr, pr = yield from create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
connect='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([struct.pack('=HHLd', 1, 2, 3, 4),
msgpack.packb((1, 2)), b'bad_kwargs'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, mock.ANY, mock.ANY, b'bad_kwargs'],),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
async def go():
port = find_unused_port()
server = await aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind="tcp://127.0.0.1:{}".format(port),
)
tr, pr = await create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
connect="tcp://127.0.0.1:{}".format(port),
)
with log_hook("aiozmq.rpc", self.err_queue):
tr.write([
struct.pack("=HHLd", 1, 2, 3, 4),
msgpack.packb((1, 2)),
b"bad_kwargs",
])
ret = await self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, mock.ANY, mock.ANY, b"bad_kwargs"], ),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
yield from client.notify.bad_handler()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(("bad_handler", mock.ANY), ret.args)
self.assertIsNotNone(ret.exc_info)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
await client.publish("my-topic").bad.method(1, 2)
ret = await self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(("bad.method", mock.ANY), ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.notify.bad_handler()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(('bad_handler', mock.ANY), ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
yield from client.notify.func_error()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("An exception from method %r " "call occurred.\n" "args = %s\nkwargs = %s\n", ret.msg)
self.assertEqual(("func_error", "()", "{}"), ret.args)
self.assertIsNotNone(ret.exc_info)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
await client.notify.bad_handler()
ret = await self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(("bad_handler", mock.ANY), ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.publish('my-topic').bad.method(1, 2)
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(('bad.method', mock.ANY),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.publish('my-topic').bad.method(1, 2)
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("Call to %r caused error: %r", ret.msg)
self.assertEqual(('bad.method', mock.ANY),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
yield from client.notify.suspicious(1)
ret = yield from self.queue.get()
self.assertEqual(1, ret)
ret = yield from self.err_queue.get()
self.assertEqual(logging.WARNING, ret.levelno)
self.assertEqual("Pipeline handler %r returned not None", ret.msg)
self.assertEqual(("suspicious",), ret.args)
self.assertIsNone(ret.exc_info)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
await client.notify.suspicious(1)
ret = await self.queue.get()
self.assertEqual(1, ret)
ret = await self.err_queue.get()
self.assertEqual(logging.WARNING, ret.levelno)
self.assertEqual("Pipeline handler %r returned not None", ret.msg)
self.assertEqual(("suspicious",), ret.args)
self.assertIsNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(asyncio.TimeoutError):
with client.with_timeout(0.1) as timedout:
yield from timedout.call.slow_call()
t0 = time.monotonic()
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1-t0 <= 0.12, t1-t0)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.publish('my-topic').func_raise_error()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual('An exception from method %r call occurred.\n'
'args = %s\nkwargs = %s\n', ret.msg)
self.assertEqual(('func_raise_error', '()', '{}'),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(asyncio.TimeoutError):
with client.with_timeout(0.1) as timedout:
yield from timedout.call.slow_call()
t0 = time.monotonic()
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
t1 = time.monotonic()
self.assertTrue(0.08 <= t1 - t0 <= 0.12, t1 - t0)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.publish('my-topic').func_raise_error()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual('An exception from method %r call occurred.\n'
'args = %s\nkwargs = %s\n', ret.msg)
self.assertEqual(('func_raise_error', '()', '{}'),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.notify.suspicious(1)
ret = yield from self.queue.get()
self.assertEqual(1, ret)
ret = yield from self.err_queue.get()
self.assertEqual(logging.WARNING, ret.levelno)
self.assertEqual('Pipeline handler %r returned not None',
ret.msg)
self.assertEqual(('suspicious',), ret.args)
self.assertIsNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.notify.func_error()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("An exception from method %r "
"call has been occurred.\n"
"args = %s\nkwargs = %s\n", ret.msg)
self.assertEqual(('func_error', '()', '{}'),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.publish('topic').suspicious(1)
ret = yield from self.queue.get()
self.assertEqual(2, ret)
ret = yield from self.err_queue.get()
self.assertEqual(logging.WARNING, ret.levelno)
self.assertEqual('PubSub handler %r returned not None',
ret.msg)
self.assertEqual(('suspicious',), ret.args)
self.assertIsNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
yield from client.notify.func_error()
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual("An exception %r from method %r "
"call occurred.\n"
"args = %s\nkwargs = %s\n", ret.msg)
self.assertEqual((mock.ANY, 'func_error', '()', '{}'),
ret.args)
self.assertIsNotNone(ret.exc_info)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
await client.publish("my-topic").func_raise_error()
ret = await self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual(
"An exception %r from method %r call occurred.\n"
"args = %s\nkwargs = %s\n",
ret.msg,
)
self.assertEqual((mock.ANY, "func_raise_error", "()", "{}"),
ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(RuntimeError) as exc:
yield from client.call.exc(1)
self.assertEqual(('bad arg', 1), exc.exception.args)
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual(
'An exception %r from method %r '
'call occurred.\n'
'args = %s\nkwargs = %s\n', ret.msg)
self.assertEqual((mock.ANY, 'exc', '(1,)', '{}'), ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
with self.assertRaises(RuntimeError) as exc:
yield from client.call.exc(1)
self.assertEqual(('bad arg', 1), exc.exception.args)
ret = yield from self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual('An exception %r from method %r '
'call occurred.\n'
'args = %s\nkwargs = %s\n', ret.msg)
self.assertEqual(
(mock.ANY, 'exc', '(1,)', '{}'),
ret.args)
self.assertIsNotNone(ret.exc_info)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
with self.assertRaises(RuntimeError) as exc:
await client.call.exc(1)
self.assertEqual(("bad arg", 1), exc.exception.args)
ret = await self.err_queue.get()
self.assertEqual(logging.ERROR, ret.levelno)
self.assertEqual(
"An exception %r from method %r "
"call occurred.\n"
"args = %s\nkwargs = %s\n",
ret.msg,
)
self.assertEqual((mock.ANY, "exc", "(1,)", "{}"), ret.args)
self.assertIsNotNone(ret.exc_info)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
ret = yield from client.call.func(1)
self.assertEqual(2, ret)
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
ret = yield from client.call.func(2)
self.assertEqual(3, ret)
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
ret = yield from client.call.func(3)
self.assertEqual(4, ret)
def communicate():
with log_hook('aiozmq.rpc', self.err_queue):
ret = yield from client.call.func(1)
self.assertEqual(2, ret)
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
ret = yield from client.call.func(2)
self.assertEqual(3, ret)
with self.assertRaises(asyncio.TimeoutError):
yield from client.with_timeout(0.1).call.slow_call()
ret = yield from client.call.func(3)
self.assertEqual(4, ret)
async def communicate():
with log_hook("aiozmq.rpc", self.err_queue):
ret = await client.call.func(1)
self.assertEqual(2, ret)
with self.assertRaises(asyncio.TimeoutError):
await client.with_timeout(0.1).call.slow_call()
await asyncio.sleep(0.3)
ret = await client.call.func(2)
self.assertEqual(3, ret)
with self.assertRaises(asyncio.TimeoutError):
await client.with_timeout(0.1).call.slow_call()
ret = await client.call.func(3)
self.assertEqual(4, ret)
def go():
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
bind='tcp://127.0.0.1:{}'.format(port))
client = yield from aiozmq.rpc.connect_rpc(
connect='tcp://127.0.0.1:{}'.format(port), loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([b'invalid', b'structure'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(((b'invalid', b'structure'), ), ret.args)
self.assertIsNotNone(ret.exc_info)
client.close()
async def go():
port = find_unused_port()
tr, pr = await create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
bind="tcp://127.0.0.1:{}".format(port),
)
client = await aiozmq.rpc.connect_rpc(
connect="tcp://127.0.0.1:{}".format(port))
with log_hook("aiozmq.rpc", self.err_queue):
tr.write([b"invalid", b"structure"])
ret = await self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(([b"invalid", b"structure"], ), ret.args)
self.assertIsNotNone(ret.exc_info)
client.close()
def go():
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
bind='inproc://test')
client = yield from aiozmq.rpc.connect_rpc(
connect='inproc://test',
loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([b'invalid', b'structure'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([b'invalid', b'structure'],),
ret.args)
self.assertIsNotNone(ret.exc_info)
client.close()
def go():
server = yield from aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
connect='tcp://127.0.0.1:{}'.format(port))
yield from asyncio.sleep(0.001, loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([b'invalid', b'structure'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(((mock.ANY, b'invalid', b'structure'),),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
def go():
server = yield from aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind='inproc://test',
loop=self.loop)
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop), zmq.DEALER,
connect='inproc://test')
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([struct.pack('=HHLd', 1, 2, 3, 4),
b'bad args', b'bad_kwargs'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(
([mock.ANY, mock.ANY, b'bad args', b'bad_kwargs'],),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
def go():
server = yield from aiozmq.rpc.serve_rpc(
MyHandler(self.loop),
bind='tcp://127.0.0.1:{}'.format(port),
loop=self.loop)
tr, pr = yield from self.loop.create_zmq_connection(
lambda: Protocol(self.loop),
zmq.DEALER,
connect='tcp://127.0.0.1:{}'.format(port))
yield from asyncio.sleep(0.001, loop=self.loop)
with log_hook('aiozmq.rpc', self.err_queue):
tr.write([b'invalid', b'structure'])
ret = yield from self.err_queue.get()
self.assertEqual(logging.CRITICAL, ret.levelno)
self.assertEqual("Cannot unpack %r", ret.msg)
self.assertEqual(((mock.ANY, b'invalid', b'structure'), ),
ret.args)
self.assertIsNotNone(ret.exc_info)
self.assertTrue(pr.received.empty())
server.close()
