def test_send_recv_multiple_endpoints(self):
r = ZmqTestSubConnection(
self.factory,
ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5556"))
r.addEndpoints(
[ZmqEndpoint(ZmqEndpointType.bind, "inproc://endpoint")])
s1 = ZmqPubConnection(
self.factory,
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556"))
s2 = ZmqPubConnection(
self.factory,
ZmqEndpoint(ZmqEndpointType.connect, "inproc://endpoint"))
r.subscribe('')
def publish(ignore):
s1.publish('111', 'tag1')
s2.publish('222', 'tag2')
def check(ignore):
result = getattr(r, 'messages', [])
expected = [['tag1', '111'], ['tag2', '222']]
self.failUnlessEqual(sorted(result), expected,
"Message should have been received")
return _wait(0.1).addCallback(publish) \
.addCallback(lambda _: _wait(0.1)).addCallback(check)
def test_send_recv_pgm(self):
r = ZmqTestSubConnection(
self.factory,
ZmqEndpoint(ZmqEndpointType.bind,
"epgm://127.0.0.1;239.192.1.1:5556"))
s = ZmqPubConnection(
self.factory,
ZmqEndpoint(ZmqEndpointType.connect,
"epgm://127.0.0.1;239.192.1.1:5556"))
r.subscribe('tag')
def publish(ignore):
s.publish('xyz', 'different-tag')
s.publish('abcd', 'tag1')
def check(ignore):
result = getattr(r, 'messages', [])
expected = [['tag1', 'abcd']]
self.failUnlessEqual(result, expected,
"Message should have been received")
return _wait(0.2).addCallback(publish) \
.addCallback(lambda _: _wait(0.2)).addCallback(check)
def setUp(self):
self.factory1 = ZmqFactory()
self.factory2 = ZmqFactory()
c = ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:7859")
self.c1 = ZmqRequestConnection(self.factory1, c, identity=b'master')
b = ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:7859")
self.c2 = ZmqReplyConnection(self.factory2, b, identity=b'slave')
self.c1.d = defer.Deferred()
def test_send_timeout_fail(self):
b = ZmqEndpoint(ZmqEndpointType.bind, "ipc://#4")
ZmqSlowREPConnection(self.factory, b)
c = ZmqEndpoint(ZmqEndpointType.connect, "ipc://#4")
s = ZmqREQConnection(self.factory, c, identity=b'client2')
return s.sendMsg(b'aaa', timeout=0.05) \
.addCallbacks(lambda _: self.fail("Should timeout"),
lambda fail: fail.trap(ZmqRequestTimeoutError)) \
.addCallback(lambda _: _wait(0.1))
def setUp(self):
self.factory1 = ZmqFactory()
dealer_endpoint = ZmqEndpoint(ZmqEndpointType.connect, "ipc://#7")
self.dealer = ZmqTestDealerConnection(self.factory1,
dealer_endpoint,
identity='dealer')
self.dealer.d = defer.Deferred()
self.factory2 = ZmqFactory()
router_endpoint = ZmqEndpoint(ZmqEndpointType.bind, "ipc://#7")
self.router = ZmqTestRouterConnection(self.factory2,
router_endpoint,
identity='router')
def test_send_recv(self):
r = ZmqTestReceiver(self.factory,
ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
s = ZmqTestSender(self.factory,
ZmqEndpoint(ZmqEndpointType.connect, "inproc://#1"))
s.send('abcd')
def check(ignore):
result = getattr(r, 'messages', [])
expected = [['abcd']]
self.failUnlessEqual(result, expected,
"Message should have been received")
return _wait(0.01).addCallback(check)
def test_send_recv_tcp_large(self):
r = ZmqTestReceiver(
ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555"))
r.listen(self.factory)
s = ZmqTestSender(
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555"))
s.connect(self.factory)
s.send(["0" * 10000, "1" * 10000])
def check(ignore):
result = getattr(r, 'messages', [])
expected = [["0" * 10000, "1" * 10000]]
self.failUnlessEqual(result, expected,
"Messages should have been received")
return _wait(0.01).addCallback(check)
def _zmq_connect(self, connClass, address):
"""
Connect to an address.
:param connClass: The connection class to be used.
:type connClass: txzmq.ZmqConnection
:param address: The address to connect to.
:type address: str
:return: The binded connection.
:rtype: txzmq.ZmqConnection
"""
endpoint = ZmqEndpoint(ZmqEndpointType.connect, address)
connection = connClass(self._factory)
if self.use_curve:
socket = connection.socket
public, secret = maybe_create_and_get_certificates(
self._config_prefix, self.component_type)
server_public_file = os.path.join(
self._config_prefix, PUBLIC_KEYS_PREFIX, "server.key")
server_public, _ = zmq.auth.load_certificate(server_public_file)
socket.curve_publickey = public
socket.curve_secretkey = secret
socket.curve_serverkey = server_public
connection.addEndpoints([endpoint])
return connection
def setUp(self):
self.factory = ZmqFactory()
ZmqXREQConnection.identity = 'client'
self.r = ZmqTestXREPConnection(
ZmqEndpoint(ZmqEndpointType.bind, "ipc://#3"))
self.r.listen(self.factory)
self.s = ZmqXREQConnection(
ZmqEndpoint(ZmqEndpointType.connect, "ipc://#3"))
self.s.connect(self.factory)
self.count = 0
def get_next_id():
self.count += 1
return 'msg_id_%d' % (self.count,)
self.s._getNextId = get_next_id
def _zmq_bind(self, connClass, address):
"""
Bind to an address.
:param connClass: The connection class to be used.
:type connClass: txzmq.ZmqConnection
:param address: The address to bind to.
:type address: str
:return: The binded connection and port.
:rtype: (txzmq.ZmqConnection, int)
"""
proto, addr, port = ADDRESS_RE.search(address).groups()
endpoint = ZmqEndpoint(ZmqEndpointType.bind, address)
connection = connClass(self._factory)
if self.use_curve:
socket = connection.socket
public, secret = maybe_create_and_get_certificates(
self._config_prefix, self.component_type)
socket.curve_publickey = public
socket.curve_secretkey = secret
self._start_authentication(connection.socket)
if proto == 'tcp' and int(port) == 0:
connection.endpoints.extend([endpoint])
port = connection.socket.bind_to_random_port('tcp://%s' % addr)
else:
connection.addEndpoints([endpoint])
return connection, int(port)
def test_send_recv_tcp(self):
r = ZmqTestReceiver(
self.factory,
ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555"))
s = ZmqTestSender(
self.factory,
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555"))
for i in xrange(100):
s.send(str(i))
def check(ignore):
result = getattr(r, 'messages', [])
expected = map(lambda i: [str(i)], xrange(100))
self.failUnlessEqual(result, expected,
"Messages should have been received")
return _wait(0.01).addCallback(check)
def test_send_recv(self):
r = ZmqTestSubConnection(
ZmqEndpoint(ZmqEndpointType.bind, "ipc://test-sock"))
r.listen(self.factory)
s = ZmqPubConnection(
ZmqEndpoint(ZmqEndpointType.connect, "ipc://test-sock"))
s.connect(self.factory)
r.subscribe('tag')
s.publish('xyz', 'different-tag')
s.publish('abcd', 'tag1')
s.publish('efgh', 'tag2')
def check(ignore):
result = getattr(r, 'messages', [])
expected = [['tag1', 'abcd'], ['tag2', 'efgh']]
self.failUnlessEqual(result, expected,
"Message should have been received")
return _wait(0.01).addCallback(check)
def test_listen_success(self):
def fakeConnectOrBind(ignored):
self.factory.testMessage = "Fake success!"
def check(ignored):
self.assertEqual(self.factory.testMessage, "Fake success!")
s = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
self.patch(s, '_connectOrBind', fakeConnectOrBind)
d = s.listen(self.factory)
d.addCallback(check)
return d
def test_listen_fail(self):
def fakeConnectOrBind(factory):
raise Exception("ohnoz!")
def check(error):
self.assertEqual(str(error), "exceptions.Exception: ohnoz!")
s = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
self.patch(s, '_connectOrBind', fakeConnectOrBind)
failure = s.listen(self.factory)
d = self.assertFailure(failure, exceptions.ListenError)
d.addCallback(check)
return d
def test_subscribe_success(self):
def checkSubscribe(ignored):
self.assertEqual(self.factory.testMessage, "Fake success!")
def checkConnect(client):
self.assertEqual(self.factory.testMessage, "")
d = client.subscribe("tag")
d.addCallback(checkSubscribe)
s = ZmqSubConnection(
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556"))
self.patchSocket(TestSocketSuccess, s)
d = s.connect(self.factory)
d.addCallback(checkConnect)
return d
def test_subscribe_fail(self):
def checkSubscribe(error):
self.assertEqual(str(error), "exceptions.Exception: ohnoz!")
def checkConnect(client):
self.assertEqual(self.factory.testMessage, "")
failure = client.subscribe("tag")
d = self.assertFailure(failure, exceptions.SubscribingError)
d.addCallback(checkSubscribe)
s = ZmqSubConnection(
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556"))
self.patchSocket(TestSocketFailure, s)
d = s.connect(self.factory)
d.addCallback(checkConnect)
return d
def test_publish_fail(self):
def fakeSend(factory):
raise Exception("ohnoz!")
def checkPublish(error):
self.assertEqual(str(error), "exceptions.Exception: ohnoz!")
def checkListen(server):
self.assertEqual(self.factory.testMessage, "")
failure = server.publish("a really special message")
d = self.assertFailure(failure, exceptions.PublishingError)
d.addCallback(checkPublish)
s = ZmqPubConnection(ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
self.patch(s, 'send', fakeSend)
d = s.listen(self.factory)
d.addCallback(checkListen)
return d
def test_publish_success(self):
def fakeSend(message):
self.factory.testMessage = message
def checkPublish(server):
expected = "\x00a really special message"
self.assertEqual(self.factory.testMessage, expected)
def checkListen(server):
self.assertEqual(self.factory.testMessage, "")
d = server.publish("a really special message")
d.addCallback(checkPublish)
s = ZmqPubConnection(ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
self.patch(s, 'send', fakeSend)
d = s.listen(self.factory)
d.addCallback(checkListen)
return d
def start(self):
endpoint = ZmqEndpoint(ZmqEndpointType.bind, self.address)
self.addEndpoints([endpoint])
def test_repr(self):
expected = ("ZmqTestReceiver(ZmqFactory(), "
"[ZmqEndpoint(type='bind', address='inproc://#1')])")
result = ZmqTestReceiver(
self.factory, ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
self.failUnlessEqual(expected, repr(result))
def test_init(self):
ZmqTestReceiver(self.factory,
ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
ZmqTestSender(self.factory,
ZmqEndpoint(ZmqEndpointType.connect, "inproc://#1"))
def start(self):
endpoint = ZmqEndpoint(ZmqEndpointType.connect, self.address)
self.addEndpoints([endpoint])
def setUp(self):
self.factory = ZmqFactory()
b = ZmqEndpoint(ZmqEndpointType.bind, "ipc://#3")
self.r = ZmqTestREPConnection(self.factory, b)
c = ZmqEndpoint(ZmqEndpointType.connect, "ipc://#3")
self.s = ZmqREQConnection(self.factory, c, identity=b'client')
def test_repr(self):
expected = ("ZmqTestReceiver(ZmqFactory(), "
"(ZmqEndpoint(type='bind', address='inproc://#1'),))")
r = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1"))
r.connect(self.factory)
self.failUnlessEqual(expected, repr(r))