def test_direct_xpub_xsub(socket, addr, reply_sockets):
worker_sock = socket(zmq.XSUB)
worker_sock.bind(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
xpub = socket(zmq.XPUB)
xpub.connect(addr)
# logic
app = Application()
worker = zeronimo.Worker(app, [worker_sock], reply_sock)
collector = zeronimo.Collector(collector_sock, reply_topic)
fanout = zeronimo.Fanout(xpub, collector)
with running([worker, collector]):
assert fanout.emit('', 'zeronimo') == []
# subscribe ''
worker_sock.send(b'\x01')
assert xpub.recv() == b'\x01'
assert get_results(fanout.emit(b'', 'zeronimo')) == ['zeronimo']
# unsubscribe ''
worker_sock.send(b'\x00')
assert xpub.recv() == b'\x00'
assert fanout.emit(b'', 'zeronimo') == []
# subscribe 'zeronimo'
worker_sock.send(b'\x01zeronimo')
assert xpub.recv() == b'\x01zeronimo'
assert \
get_results(fanout.emit(b'zeronimo', 'zeronimo')) == ['zeronimo']
def test_proxied_fanout(collector, worker_pub, socket, device,
topic, addr1, addr2):
# customer |----| forwarder with XPUB/XSUB |---> | worker
# collector | <-----------------------------------|
# run forwarder
forwarder_in_addr, forwarder_out_addr = addr1, addr2
device(socket(zmq.XSUB), socket(zmq.XPUB),
forwarder_in_addr, forwarder_out_addr)
# connect to the devices
worker_sub1 = socket(zmq.SUB)
worker_sub2 = socket(zmq.SUB)
worker_sub1.set(zmq.SUBSCRIBE, topic)
worker_sub2.set(zmq.SUBSCRIBE, topic)
worker_sub1.connect(forwarder_out_addr)
worker_sub2.connect(forwarder_out_addr)
pub = socket(zmq.PUB)
pub.connect(forwarder_in_addr)
sync_pubsub(pub, [worker_sub1, worker_sub2], topic)
# make and start workers
app = Application()
worker1 = zeronimo.Worker(app, [worker_sub1], worker_pub)
worker2 = zeronimo.Worker(app, [worker_sub2], worker_pub)
fanout = zeronimo.Fanout(pub, collector)
with running([worker1, worker2, collector]):
# zeronimo!
results = fanout.emit(topic, 'zeronimo')
assert get_results(results) == ['zeronimo', 'zeronimo']
def _test_duplex(socket, worker_socket, customer_and_collector_socket):
worker = zeronimo.Worker(Application(), [worker_socket])
collector = zeronimo.Collector(customer_and_collector_socket)
customer = zeronimo.Customer(customer_and_collector_socket, collector)
with running([worker, collector]):
assert customer.call('zeronimo').get() == 'zeronimo'
assert ' '.join(customer.call('rycbar123').get()) == \
'run, you clever boy; and remember.'
with pytest.raises(ZeroDivisionError):
customer.call('zero_div').get()
def test_collector_without_topic(socket, addr, worker, push,
left_type, right_type):
left = socket(left_type)
right = socket(right_type)
right.bind(addr)
left.connect(addr)
worker.reply_socket = right
collector = zeronimo.Collector(left) # topic is not required.
customer = zeronimo.Customer(push, collector)
with running([collector]):
assert customer.call('zeronimo').get() == 'zeronimo'
def test_pair_with_collector(socket, addr, reply_sockets):
# Failed at 0.3.0.
left = socket(zmq.PAIR)
right = socket(zmq.PAIR)
left.bind(addr)
right.connect(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
worker = zeronimo.Worker(Application(), [left], reply_sock)
sync_pubsub(reply_sock, [collector_sock], reply_topic)
collector = zeronimo.Collector(collector_sock, reply_topic)
customer = zeronimo.Customer(right, collector)
with running([worker, collector]):
assert customer.call('zeronimo').get() == 'zeronimo'
def test_fanout_by_other_types(left_type, right_type, socket, addr1, addr2):
fanout_sock = socket(left_type)
worker_sock = socket(right_type)
worker_sock.bind(addr1)
fanout_sock.connect(addr1)
worker_pub, collector_sub = socket(zmq.PUB), socket(zmq.SUB)
worker_pub.bind(addr2)
collector_sub.connect(addr2)
collector_sub.set(zmq.SUBSCRIBE, 'xxx')
sync_pubsub(worker_pub, [collector_sub], 'xxx')
worker = zeronimo.Worker(Application(), [worker_sock], worker_pub)
collector = zeronimo.Collector(collector_sub, 'xxx')
fanout = zeronimo.Fanout(fanout_sock, collector)
with running([worker]):
assert get_results(fanout.emit('anything', 'zeronimo')) == ['zeronimo']
def test_from_socket(socket, addr, reply_sockets):
# sockets
worker_sock = socket(zmq.PULL)
worker_sock.bind(addr)
push = socket(zmq.PUSH)
push.connect(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
# logic
app = Application()
worker = zeronimo.Worker(app, [worker_sock], reply_sock)
collector = zeronimo.Collector(collector_sock, reply_topic)
customer = zeronimo.Customer(push, collector)
with running([worker, collector]):
# test
result = customer.call('zeronimo')
assert result.get() == 'zeronimo'
def test_xpub_sub(socket, addr, reply_sockets, topic):
worker_sub = socket(zmq.SUB)
worker_sub.set(zmq.SUBSCRIBE, topic)
worker_sub.bind(addr)
customer_xpub = socket(zmq.XPUB)
customer_xpub.connect(addr)
assert customer_xpub.recv() == b'\x01' + topic
reply_sock, (collector_sock, reply_topic) = reply_sockets()
worker = zeronimo.Worker(Application(), [worker_sub], reply_sock)
collector = zeronimo.Collector(collector_sock, reply_topic)
fanout = zeronimo.Fanout(customer_xpub, collector)
with running([worker, collector]):
took = False
for r in fanout.emit(topic, 'zeronimo'):
assert r.get() == 'zeronimo'
took = True
assert took
def test_marshal_message(socket, addr, reply_sockets):
import marshal
pack = marshal.dumps
unpack = marshal.loads
# sockets
worker_sock = socket(zmq.PULL)
worker_sock.bind(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
customer_sock = socket(zmq.PUSH)
customer_sock.connect(addr)
# logic
app = Application()
worker = zeronimo.Worker(app, [worker_sock], reply_sock,
pack=pack, unpack=unpack)
collector = zeronimo.Collector(collector_sock, reply_topic, unpack=unpack)
customer = zeronimo.Customer(customer_sock, collector, pack=pack)
with running([worker, collector]):
assert customer.call('zeronimo').get() == 'zeronimo'
def test_only_workers_bind(socket, addr1, addr2):
pub1, pub2 = socket(zmq.PUB), socket(zmq.PUB)
sub1, sub2 = socket(zmq.SUB), socket(zmq.SUB)
pub1.bind(addr1)
sub1.bind(addr2)
pub2.connect(addr2)
sub2.connect(addr1)
topic1, topic2 = rand_str(), rand_str()
sub1.set(zmq.SUBSCRIBE, topic1)
sub2.set(zmq.SUBSCRIBE, topic2)
gevent.sleep(0.1)
worker = zeronimo.Worker(Application(), [sub1], pub1)
collector = zeronimo.Collector(sub2, topic=topic2)
fanout = zeronimo.Fanout(pub2, collector)
with running([worker, collector]):
took = False
for r in fanout.emit(topic1, 'zeronimo'):
assert r.get() == 'zeronimo'
took = True
assert took
def test_worker_info(socket, addr, reply_sockets):
# sockets
worker_sock = socket(zmq.PULL)
worker_sock.bind(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
customer_sock = socket(zmq.PUSH)
customer_sock.connect(addr)
# logic
app = Application()
worker = zeronimo.Worker(app, [worker_sock], reply_sock)
collector = zeronimo.Collector(collector_sock, reply_topic)
customer = zeronimo.Customer(customer_sock, collector)
with running([worker, collector]):
r = customer.call('zeronimo')
assert r.get() == 'zeronimo'
assert r.worker_info is None
worker.info = b'zeronimo'
r = customer.call('zeronimo')
assert r.get() == 'zeronimo'
assert r.worker_info == b'zeronimo'
assert isinstance(r.worker_info, bytes)
def test_exception_state(socket, addr, reply_sockets):
# sockets
worker_sock = socket(zmq.PULL)
worker_sock.bind(addr)
push = socket(zmq.PUSH)
push.connect(addr)
reply_sock, (collector_sock, reply_topic) = reply_sockets()
# logic
app = ExampleExceptionRaiser()
worker = zeronimo.Worker(app, [worker_sock], reply_sock)
collector = zeronimo.Collector(collector_sock, reply_topic)
customer = zeronimo.Customer(push, collector)
with running([worker, collector]):
result = customer.call('throw', 2007)
try:
result.get()
except BaseException as exc:
assert isinstance(exc, zeronimo.RemoteException)
assert isinstance(exc, ExampleException)
assert exc.errno == 2007
assert not exc.initialized
else:
assert False
