def setUp(self):
kwargs_fwdr = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"full_content": True,
"skip_decoding": True,
"skip_encoding": True,
}
self.forwarder = AmqpReconnectingFactory(self, **kwargs_fwdr)
self.forwarder.setup_read_queue(
EXC, RK2, self.fwdr_handle, queue_name="forwarder", durable=False, auto_delete=True
)
self.backwarder = AmqpReconnectingFactory(self, **kwargs_fwdr)
self.backwarder.setup_read_queue(
EXC, RK3, self.fwdr_handle, queue_name="backwarder", durable=False, auto_delete=True
)
kwargs_common = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"exchange": EXC,
"serialization": "content_based",
"rk": RK2,
}
kwargs_json = copy(kwargs_common)
kwargs_json["default_content_type"] = "application/json"
self.push_json = AmqpSynFactory(self, **kwargs_json)
self.push_json.setup_read_queue(EXC, "route_json", durable=False, auto_delete=True)
kwargs_pickle = copy(kwargs_common)
kwargs_pickle["default_content_type"] = "application/x-pickle"
self.push_pickle = AmqpSynFactory(self, **kwargs_pickle)
self.push_pickle.setup_read_queue(EXC, "route_pickle", durable=False, auto_delete=True)
kwargs_responder = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"push_back": True,
"full_content": True,
"serialization": "content_based",
"default_content_type": "application/json",
}
self.responder = AmqpReconnectingFactory(self, **kwargs_responder)
self.responder.setup_read_queue(
EXC, RK, self.msg_handle, queue_name="responder", durable=False, auto_delete=True
)
return DeferredList(
[
self.forwarder.connected,
self.backwarder.connected,
self.push_json.connected,
self.push_pickle.connected,
self.responder.connected,
]
)
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False}
self.f = AmqpReconnectingFactory(self, **kwargs)
self.f.declare([{'type':'exchange',
'kwargs': {'exchange': EXC,
'durable': True,
'type': 'topic'}},
])
def setUp(self):
kwargs = {
"spec": "file:../txamqp_ext/spec/amqp0-8.xml",
"parallel": False,
"serialization": "cPickle",
"full_content": True,
"skip_decoding": True,
}
self.f = AmqpReconnectingFactory(self, **kwargs)
class FactoryB(TestCase):
timeout = 10
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False}
self.f = AmqpReconnectingFactory(self, **kwargs)
def test_01_basic_setup_receive(self):
def message_get(msg):
print msg
d = self.f.setup_read_queue(EXC, RK, message_get,
queue_name=QUE,
durable=True,
auto_delete=False)
return d
def test_02_basic_send_and_receive(self):
d1 = Deferred()
txt = 'test_message'
def message_get(msg):
assert msg==txt, 'MSG: %r TXT: %r'%(msg, txt)
d1.callback(msg)
d = self.f.setup_read_queue(EXC, RK, message_get,
no_ack=False,
auto_delete=True,
durable=False)
def send_msg(_none):
c = txt
self.f.send_message(EXC, RK, c)
def rloop_started(_none):
d2 = self.f.client.on_read_loop_started()
d2.addCallback(send_msg)
return d2
d.addCallback(rloop_started)
return DeferredList([d, d1])
def tearDown(self):
return self.f.shutdown_factory()
class FactoryF(FactoryD):
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'exchange': EXC,
'full_content': True,
'delivery_mode': 1,
'serialization': 'cPickle',
'parallel': False,
'rk': RK2 }
kwargs2 = copy(kwargs)
kwargs2['push_back'] = True
self.f = AmqpSynFactory(self, **kwargs)
self.f.setup_read_queue(EXC,
durable=False,
auto_delete=True,
exclusive=True)
self.f2 = AmqpReconnectingFactory(self, **kwargs2)
self.f2.setup_read_queue(EXC, RK2, self._test_echoer,
durable=False,
auto_delete=True,
exclusive=True)
dl = DeferredList([self.f.connected, self.f2.connected])
return dl
class TestEncoding(TestCase):
timeout = 3
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False,
'serialization': 'cjson'}
self.f = AmqpReconnectingFactory(self, **kwargs)
return self.f.connected
def test_001_fail_encoding(self):
d = Deferred()
d1 = Deferred()
def _failed(failure):
failure.trap(cjson.EncodeError)
d.callback(True)
self.f.send_message(EXC, RK, {1: self}, callback=d1).addErrback(_failed)
return DeferredList([d])
def test_002_skip_encoding(self):
d = Deferred()
d1 = Deferred()
d2 = Deferred()
def _ok(_any):
d.callback(True)
def _ok_msg(_any):
pass
def _err_msg(_any, msg):
d2.callback(True)
self.f.setup_read_queue(EXC, RK, _ok_msg,
queue_name=QUE, durable=True,
auto_delete=False,
requeue_on_error=False,
read_error_handler=_err_msg)
self.f.send_message(EXC, RK, {1: self}, callback=d1,
skip_encoding=True).addCallback(_ok)
return DeferredList([d, d2])
def tearDown(self):
return self.f.shutdown_factory()
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False,
'exchange': EXC,
'full_content': True,
'delivery_mode': 1,
'timeout': 10,
'rk': RK2 }
self.f = AmqpSynFactory(self, **kwargs)
self.f.setup_read_queue(EXC, RK3,
durable=False,
auto_delete=True,
exclusive=True)
self.f2 = AmqpReconnectingFactory(self, **kwargs)
d = self.f2.setup_read_queue(EXC, RK2, self._test_echoer,
durable=False,
auto_delete=True,
exclusive=True)
return DeferredList([self.f.connected, self.f2.connected])
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False}
self.f = AmqpReconnectingFactory(self, **kwargs)
class FactoryD(TestCase):
timeout = 10
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False,
'exchange': EXC,
'full_content': True,
'timeout': 1,
'delivery_mode': 1,
'rk': RK2 }
kwargs2 = copy(kwargs)
kwargs2['push_back'] = True
self.f = AmqpSynFactory(self, **kwargs)
self.f.setup_read_queue(EXC,
durable=False,
auto_delete=True,
exclusive=True)
self.f2 = AmqpReconnectingFactory(self, **kwargs2)
d = self.f2.setup_read_queue(EXC, RK2, self._test_echoer,
durable=False,
auto_delete=True,
exclusive=True)
dl = DeferredList([self.f.connected, self.f2.connected])
return dl
def _test_echoer(self, msg, d):
tid=msg['headers'].get('tid')
return d.callback(tid)
def test_01_pb_basic_start(self):
pass
def test_02_pb_send_rec(self):
d1 = Deferred()
def _get_result(result):
print 'GOT RESULT: %r'%result
d1.callback(True)
def _push_msg():
print 'PUSH MESSAGE'
d = self.f.push_message('test')
d.addCallback(_get_result)
reactor.callLater(0.05, _push_msg)
return DeferredList([d1])
def test_03_pb_send_rec_many(self):
d = {}
def _get_result(result):
tid = result['headers'][self.f.tid_name]
assert result.body == tid, 'body: %r'%result.body
d[tid].callback(True)
for i in xrange(250):
tid = str(int(time.time()*1e7))
d[tid] = Deferred()
d1 = self.f.push_message(tid, tid=tid)
d1.addCallback(_get_result)
d1.addErrback(self._err)
return DeferredList(d.values())
def test_04_reconnect(self):
d = Deferred()
def _sleep(n):
s = Deferred()
reactor.callLater(n, s.callback, True)
return s
def _get_result(result):
d.callback(True)
def _no_result(failure):
print '%s'%failure.getTraceback()
raise Exception('No result')
def _resend(failure):
d1 = self.f.push_message('test', timeout_sec=5)
d1.addCallbacks(_get_result, _no_result)
def sl(failure):
s = _sleep(3)
print 'Resend. %s'%failure.getTraceback()
s.addCallback(_resend)
def _ecb(*_any):
raise Exception('ERR: %r'%(_any))
def push_first():
d1 = self.f.push_message('test', timeout_sec=0.5)
d1.addCallback(_ecb)
d1.addErrback(sl)
self.f.client.shutdown_protocol()
push_first()
return d
def _err(self, failure):
raise failure
def tearDown(self):
dl = []
dl.append(self.f.shutdown_factory())
dl.append(self.f2.shutdown_factory())
return DeferredList(dl)
class FactoryA(TestCase):
timeout = 10
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False}
self.f = AmqpReconnectingFactory(self, **kwargs)
self.f.declare([{'type':'exchange',
'kwargs': {'exchange': EXC,
'durable': True,
'type': 'topic'}},
])
def test_001_basic_connect(self):
return self.f.connected
def test_002_reconnect_test(self):
d = self.f.connected
c = 'test_one'
self.f.send_message(EXC, RK, c)
def _analyze(_none):
c = 'test_line'
self.f.send_message(EXC, RK, c)
print 'RETRIES: %r'%self.f.retries
print 'CURR: %r'%self.f.processing_send
assert len(self.f.dropped_send_messages.pending) == 1,\
'Dropped size: %r'%len(self.f.dropped_send_messages.pending)
def p(_none):
self.f.add_trap(self.f.client._trap_closed)
c = Content({'body':'one'})
self.f.send_message(EXC, RK, c, tx=True)
dl = []
for i in xrange(2):
c = 'test_line'
cb = Deferred()
dl.append(cb)
self.f.send_message(EXC, RK, c, callback=cb)
return DeferredList(dl)
return d.addCallback(p)
def test_003_close_client(self):
d = self.f.connected
def _sd(_none):
d2 = Deferred()
reactor.callLater(5, d2.callback, None)
d1 = self.f.client.shutdown_protocol()
return DeferredList([d1, d2])
d.addCallback(_sd)
return d
def test_004_declare(self):
self.f.declare([{'kwargs': {'exchange': 'test2',
'auto_delete': False,
'durable': True,
'type': 'topic',},
'type': 'exchange'}])
return self.f.connected
def _err(self, failure):
print failure.getTraceback()
def tearDown(self):
return self.f.shutdown_factory()
class FactoryC(TestCase):
timeout = 10
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False,
'exchange': EXC,
'full_content': True,
'delivery_mode': 1,
'timeout': 10,
'rk': RK2 }
self.f = AmqpSynFactory(self, **kwargs)
self.f.setup_read_queue(EXC, RK3,
durable=False,
auto_delete=True,
exclusive=True)
self.f2 = AmqpReconnectingFactory(self, **kwargs)
d = self.f2.setup_read_queue(EXC, RK2, self._test_echoer,
durable=False,
auto_delete=True,
exclusive=True)
return DeferredList([self.f.connected, self.f2.connected])
def _test_echoer(self, msg):
c = Content(msg.body)
c['headers'] = {'tid': msg['headers'].get('tid')}
c['tid'] = msg['headers'].get('tid')
#c['tid'] = msg['tid']
self.f2.send_message(EXC, RK3, c, tid=msg['headers'].get('tid'))
def test_01_basic_start(self):
pass
def test_02_send_rec(self):
d1 = Deferred()
def _get_result(result):
print 'GOT RESULT: %r'%result
d1.callback(True)
d = self.f.push_message('test')
d.addCallback(_get_result)
return DeferredList([d1, d])
def test_03_send_rec_many(self):
d = {}
def _get_result(result):
tid = result['headers']['tid']
assert result.body == tid, 'body: %r'%result.body
d[tid].callback(True)
for i in xrange(500):
tid = str(int(time.time()*1e7))
d[tid] = Deferred()
d1 = self.f.push_message(tid, tid=tid)
d1.addCallback(_get_result)
d1.addErrback(self._err)
return DeferredList(d.values())
def _err(self, failure):
raise failure
def tearDown(self):
dl = []
dl.append(self.f.shutdown_factory())
dl.append(self.f2.shutdown_factory())
return DeferredList(dl)
class TestContentTypes(TestCase):
timeout = 4
def setUp(self):
kwargs_fwdr = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"full_content": True,
"skip_decoding": True,
"skip_encoding": True,
}
self.forwarder = AmqpReconnectingFactory(self, **kwargs_fwdr)
self.forwarder.setup_read_queue(
EXC, RK2, self.fwdr_handle, queue_name="forwarder", durable=False, auto_delete=True
)
self.backwarder = AmqpReconnectingFactory(self, **kwargs_fwdr)
self.backwarder.setup_read_queue(
EXC, RK3, self.fwdr_handle, queue_name="backwarder", durable=False, auto_delete=True
)
kwargs_common = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"exchange": EXC,
"serialization": "content_based",
"rk": RK2,
}
kwargs_json = copy(kwargs_common)
kwargs_json["default_content_type"] = "application/json"
self.push_json = AmqpSynFactory(self, **kwargs_json)
self.push_json.setup_read_queue(EXC, "route_json", durable=False, auto_delete=True)
kwargs_pickle = copy(kwargs_common)
kwargs_pickle["default_content_type"] = "application/x-pickle"
self.push_pickle = AmqpSynFactory(self, **kwargs_pickle)
self.push_pickle.setup_read_queue(EXC, "route_pickle", durable=False, auto_delete=True)
kwargs_responder = {
"spec": "file:../txamqp_ext/spec/amqp0-9-1.xml",
"parallel": True,
"push_back": True,
"full_content": True,
"serialization": "content_based",
"default_content_type": "application/json",
}
self.responder = AmqpReconnectingFactory(self, **kwargs_responder)
self.responder.setup_read_queue(
EXC, RK, self.msg_handle, queue_name="responder", durable=False, auto_delete=True
)
return DeferredList(
[
self.forwarder.connected,
self.backwarder.connected,
self.push_json.connected,
self.push_pickle.connected,
self.responder.connected,
]
)
def tearDown(self):
return DeferredList(
[
self.forwarder.shutdown_factory(),
self.backwarder.shutdown_factory(),
self.push_json.shutdown_factory(),
self.push_pickle.shutdown_factory(),
self.responder.shutdown_factory(),
]
)
@inlineCallbacks
def msg_handle(self, full_msg, d):
yield d.callback(full_msg)
@inlineCallbacks
def fwdr_handle(self, msg):
real_back = msg["headers"].get("real_rb")
if not real_back:
msg["headers"]["real_rb"] = msg["headers"]["route_back"]
msg["headers"]["route_back"] = RK3
yield self.forwarder.send_message(EXC, RK, msg)
else:
yield self.backwarder.send_message(EXC, msg["headers"]["real_rb"], msg)
def test_0000(self):
return
def test_0001(self):
d_json = Deferred()
d_pickle = Deferred()
@inlineCallbacks
def run_json():
yield self.push_json.push_message({"test_message": 1})
d_json.callback(True)
@inlineCallbacks
def run_pickle():
yield self.push_pickle.push_message({"test_message": 1})
d_pickle.callback(True)
run_json()
run_pickle()
return DeferredList([d_json, d_pickle])
class TestEncoding(TestCase):
timeout = 4
def setUp(self):
kwargs = {
"spec": "file:../txamqp_ext/spec/amqp0-8.xml",
"parallel": False,
"serialization": "cPickle",
"full_content": True,
"skip_decoding": True,
}
self.f = AmqpReconnectingFactory(self, **kwargs)
def test_001_fail_encoding(self):
d = Deferred()
d1 = Deferred()
def _failed(failure):
failure.trap(TypeError)
d.callback(True)
self.f.send_message(EXC, RK, {1: self}, callback=d1).addErrback(_failed)
return DeferredList([d, self.f.connected])
@inlineCallbacks
def test_002_skip_encoding(self):
d = Deferred()
d1 = Deferred()
d2 = Deferred()
encoded_body = json.dumps({"test_message": "asdf"})
encoded = Content(encoded_body)
encoded["content type"] = "application/json"
def _ok(_any):
d.callback(True)
def _ok_msg(_any):
assert _any["content type"] == "application/json", _any
assert encoded_body == _any.body, "Got %r" % _any.body
d2.callback(True)
def _err_msg(_any, msg):
print "Fail002: %r" % msg
d2.errback(True)
return {}
yield self.f.setup_read_queue(
EXC,
RK,
_ok_msg,
queue_name=EQUE,
durable=False,
auto_delete=True,
requeue_on_error=False,
read_error_handler=_err_msg,
)
yield self.f.client.on_read_loop_started()
self.f.send_message(EXC, RK, encoded, callback=d1, skip_encoding=True).addCallback(_ok)
yield DeferredList([d, d2])
@inlineCallbacks
def test_003_set_content_type(self):
d = Deferred()
d1 = Deferred()
d2 = Deferred()
encoded = {"test_message": "asdf"}
def _ok(_any):
d.callback(True)
def _ok_msg(_any):
assert _any["content type"] == "application/x-pickle", _any
assert encoded == cPickle.loads(_any.body), "Got %r" % _any.body
d2.callback(True)
def _err_msg(_any, msg):
print "REJ: %r" % msg
d2.errback(True)
return {}
yield self.f.setup_read_queue(
EXC,
RK,
_ok_msg,
queue_name=EQUE,
durable=False,
auto_delete=True,
requeue_on_error=False,
read_error_handler=_err_msg,
)
yield self.f.client.on_read_loop_started()
self.f.send_message(EXC, RK, encoded, callback=d1, skip_encoding=False).addCallback(_ok)
yield DeferredList([d, d2])
@inlineCallbacks
def test_004_msgpack(self):
d = Deferred()
d1 = Deferred()
d2 = Deferred()
msg_body = {"test_message": "asdf"}
encoded_body = msgpack.dumps(msg_body)
encoded_msg = Content(encoded_body)
encoded_msg["content type"] = "application/x-msgpack"
self.f.skip_decoding = False
self.f.serialization = "content_based"
def _ok(_any):
d.callback(True)
def _ok_msg(_any):
assert _any["content type"] == "application/x-msgpack", _any
assert msg_body == _any.body, "Got %r" % _any.body
d2.callback(True)
def _err_msg(_any, msg):
print "Fail002: %r" % msg
d2.errback(True)
return {}
yield self.f.setup_read_queue(
EXC,
RK,
_ok_msg,
queue_name=EQUE,
durable=False,
auto_delete=True,
requeue_on_error=False,
read_error_handler=_err_msg,
)
yield self.f.client.on_read_loop_started()
self.f.send_message(EXC, RK, encoded_msg, callback=d1, skip_encoding=True).addCallback(_ok)
yield DeferredList([d, d2])
@inlineCallbacks
def tearDown(self):
if hasattr(self.f.protocol, "read_chan"):
yield self.f.protocol.read_chan.queue_delete(queue=EQUE)
yield self.f.shutdown_factory()
def setUp(self):
kwargs = {'spec': 'file:../txamqp_ext/spec/amqp0-8.xml',
'parallel': False,
'serialization': 'cjson'}
self.f = AmqpReconnectingFactory(self, **kwargs)
return self.f.connected
