def test_zmsg():
m = zmsg.new()
foo = zframe.new('foo')
zmsg.push(m, foo)
assert zmsg.first(m) == foo
bar = zframe.new('bar')
zmsg.push(m, bar)
assert zmsg.first(m) == bar
assert zmsg.last(m) == foo
zmsg.append(m, zframe.new('ding'))
assert zframe.data(zmsg.last(m)) == 'ding'
ctx = zctx.new()
p = zsocket.new(ctx, zmq.PUB)
u = zsocket.new(ctx, zmq.SUB)
zsockopt.set_subscribe(u, '')
zsocket.bind(p, 'inproc://qer')
zsocket.connect(u, 'inproc://qer')
zmsg.send(m, p)
zsocket.poll(u, 1)
n = zmsg.recv(u)
assert zmsg.size(n) == 3
assert zframe.data(zmsg.next(n)) == 'bar'
assert zframe.data(zmsg.next(n)) == 'foo'
assert zframe.data(zmsg.next(n)) == 'ding'
assert zmsg.next(n) is None
def test_zsocket():
ctx = zctx.new()
push = zsocket.new(ctx, zmq.PUSH)
pull = zsocket.new(ctx, zmq.PULL)
zsocket.bind(push, 'inproc://test')
zsocket.connect(pull, 'inproc://test')
zstr.send(push, 'foo')
assert zstr.recv(pull) == 'foo'
zstr.send(push, 'foo')
zsocket.poll(pull, 1)
assert zstr.recv_nowait(pull) == 'foo'
def test_zbeacon():
ctx = zctx.new()
# Create a service socket and bind to an ephemeral port
service = zsocket.new(ctx, zmq.PUB)
port_nbr = zsocket.bind(service, "tcp:#*:*")
# Create beacon to broadcast our service
announcement = str(port_nbr)
service_beacon = zbeacon.new(9999)
zbeacon.set_interval(service_beacon, 100)
zbeacon.publish(service_beacon, announcement)
# Create beacon to lookup service
client_beacon = zbeacon.new (9999)
zbeacon.subscribe(client_beacon, '')
# Wait for at most 1/2 second if there's no broadcast networking
zsockopt.set_rcvtimeo(zbeacon.socket(client_beacon), 500)
ipaddress = zstr.recv(zbeacon.socket(client_beacon))
if ipaddress:
content = zframe.recv(zbeacon.socket(client_beacon))
received_port = int(zframe.data(content))
assert received_port == port_nbr
zframe.destroy(content)
def test_shadow_pyczmq(self):
try:
from pyczmq import zctx, zsocket, zstr
except Exception:
raise SkipTest("Requires pyczmq")
ctx = zctx.new()
a = zsocket.new(ctx, zmq.PUSH)
zsocket.bind(a, "inproc://a")
ctx2 = self.Context.shadow_pyczmq(ctx)
b = ctx2.socket(zmq.PULL)
b.connect("inproc://a")
zstr.send(a, b'hi')
rcvd = self.recv(b)
self.assertEqual(rcvd, b'hi')
b.close()
def test_zpoller(verbose=False):
ctx = zctx.new()
# Create a few sockets
vent = zsocket.new(ctx, zmq.PUSH);
rc = zsocket.bind(vent, "tcp://*:9000")
assert rc != -1, "vent bind error"
sink = zsocket.new(ctx, zmq.PULL)
rc = zsocket.connect(sink, "tcp://localhost:9000");
assert rc != -1, "sink connect error"
bowl = zsocket.new(ctx, zmq.PULL)
dish = zsocket.new(ctx, zmq.PULL)
# Set-up poller
poller = zpoller.new(bowl, sink, dish)
assert poller, "poller create error"
zstr.send(vent, "Hello, World")
# We expect a message only on the sink
which = zpoller.wait(poller, 1000)
assert which == sink, "expected message on sink only"
assert not zpoller.expired(poller), "unexpected poll timer exipiry"
assert not zpoller.terminated(poller), "unexpected poller termination (interrupted)"
message = zstr.recv(which)
assert message == "Hello, World", "unexpected message recevied"
# Destroy poller and context
del poller
del ctx
def test_shadow_pyczmq(self):
try:
from pyczmq import zctx, zsocket, zstr
except Exception:
raise SkipTest("Requires pyczmq")
ctx = zctx.new()
a = zsocket.new(ctx, zmq.PUSH)
zsocket.bind(a, "inproc://a")
ctx2 = self.Context.shadow_pyczmq(ctx)
b = ctx2.socket(zmq.PULL)
b.connect("inproc://a")
zstr.send(a, b'hi')
rcvd = self.recv(b)
self.assertEqual(rcvd, b'hi')
b.close()
def test_zbeacon():
ctx = zctx.new()
# Create a service socket and bind to an ephemeral port
service = zsocket.new(ctx, zmq.PUSH)
port_nbr = zsocket.bind(service, "inproc://foo")
# Create beacon to broadcast our service
announcement = str(port_nbr)
service_beacon = zbeacon.new(ctx, 9999)
zbeacon.set_interval(service_beacon, 100)
zbeacon.publish(service_beacon, announcement)
# Create beacon to lookup service
client_beacon = zbeacon.new(ctx, 9999)
zbeacon.subscribe(client_beacon, '')
# Wait for at most 1/2 second if there's no broadcast networking
beacon_socket = zbeacon.socket(client_beacon)
zsocket.set_rcvtimeo(beacon_socket, 500)
ipaddress = zstr.recv(beacon_socket)
content = zframe.recv(beacon_socket)
received_port = int(zframe.data(content))
assert received_port == port_nbr
zframe.destroy(content)
del service_beacon
del ctx
def test_zpoller():
ctx = zctx.new()
p = zsocket.new(ctx, zmq.PUB)
zsocket.bind(p, 'inproc://sdf')
s = zsocket.new(ctx, zmq.SUB)
zsockopt.set_subscribe(s, '')
zsocket.connect(s, 'inproc://sdf')
s2 = zsocket.new(ctx, zmq.SUB)
zsockopt.set_subscribe(s2, '')
zsocket.connect(s2, 'inproc://sdf')
zstr.send(p, 'foo')
z = zpoller.new(s)
def test_zloop(verbose=False):
ctx = zctx.new()
output_s = zsocket.new(ctx, zmq.PAIR)
input_s = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output_s, 'inproc://lkj')
zsocket.connect(input_s, 'inproc://lkj')
@zloop.poll_callback
def on_socket_event(loop, item, arg):
assert zstr.recv(item.socket) == 'PING'
assert arg == 3
return -1
@zloop.timer_callback
def on_timer_event(loop, item, arg):
zstr.send(arg, 'PING')
return 0
@zloop.timer_callback
def on_cancel_timer_event(loop, item, arg):
cancel_timer_id = arg
rc = zloop.timer_end(loop, cancel_timer_id)
assert (rc == 0)
return 0
@zloop.reader_callback
def on_reader_event(loop, reader, arg):
assert arg is None
return -1
l = zloop.new()
zloop.set_verbose(l, verbose)
# create a timer that will be cancelled
cancel_timer_id = zloop.timer(l, 1000, 1, on_timer_event, None)
zloop.timer(l, 5, 1, on_cancel_timer_event, cancel_timer_id)
# After 10 msecs, send a ping message to output
zloop.timer(l, 20, 1, on_timer_event, output_s)
# When we get the ping message, end the reactor
rc = zloop.reader(l, input_s, on_reader_event, None)
zloop.reader_set_tolerant (l, input_s);
zloop.start (l);
def test_zloop(verbose=False):
ctx = zctx.new()
output_s = zsocket.new(ctx, zmq.PAIR)
input_s = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output_s, "inproc://lkj")
zsocket.connect(input_s, "inproc://lkj")
@zloop.poll_callback
def on_socket_event(loop, item, arg):
assert zstr.recv(item.socket) == "PING"
assert arg == 3
return -1
@zloop.timer_callback
def on_timer_event(loop, item, arg):
zstr.send(arg, "PING")
return 0
@zloop.timer_callback
def on_cancel_timer_event(loop, item, arg):
cancel_timer_id = arg
rc = zloop.timer_end(loop, cancel_timer_id)
assert rc == 0
return 0
l = zloop.new()
zloop.set_verbose(l, verbose)
# create a timer that will be cancelled
cancel_timer_id = zloop.timer(l, 1000, 1, on_timer_event, None)
zloop.timer(l, 5, 1, on_cancel_timer_event, cancel_timer_id)
# After 10 msecs, send a ping message to output
zloop.timer(l, 20, 1, on_timer_event, output_s)
# When we get the ping message, end the reactor
poll_input = zmq.pollitem(socket=input_s, events=zmq.POLLIN)
zloop.poller(l, poll_input, on_socket_event, 3)
zloop.set_tolerant(l, poll_input)
zloop.start(l)
del l
del ctx
def test_zloop(verbose=False):
ctx = zctx.new()
output_s = zsocket.new(ctx, zmq.PAIR)
input_s = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output_s, 'inproc://lkj')
zsocket.connect(input_s, 'inproc://lkj')
@zloop.poll_callback
def on_socket_event(loop, item, arg):
assert zstr.recv(item.socket) == 'PING'
assert arg == 3
return -1
@zloop.timer_callback
def on_timer_event(loop, item, arg):
zstr.send(arg, 'PING')
return 0
@zloop.timer_callback
def on_cancel_timer_event(loop, item, arg):
cancel_timer_id = arg
rc = zloop.timer_end(loop, cancel_timer_id)
assert (rc == 0)
return 0
l = zloop.new()
zloop.set_verbose(l, verbose)
# create a timer that will be cancelled
cancel_timer_id = zloop.timer(l, 1000, 1, on_timer_event, None)
zloop.timer(l, 5, 1, on_cancel_timer_event, cancel_timer_id)
# After 10 msecs, send a ping message to output
zloop.timer(l, 20, 1, on_timer_event, output_s)
# When we get the ping message, end the reactor
poll_input = zmq.pollitem(socket=input_s, events=zmq.POLLIN)
zloop.poller(l, poll_input, on_socket_event, 3)
zloop.set_tolerant(l, poll_input)
zloop.start(l)
del l
del ctx
def test_zstr():
ctx = zctx.new()
test_endpoint = 'inproc://zstr.test'
output_s = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output_s, test_endpoint)
input_s = zsocket.new(ctx, zmq.PAIR)
zsocket.connect(input_s, test_endpoint)
# Send ten strings, five strings with MORE flag and then END
for i in range(0, 10):
rc = zstr.send(output_s, "this is string {}".format(i))
assert(rc == 0)
zstr.sendx(output_s, "This", "is", "almost", "the", "very", "END")
# Read and count until we receive END
string_nbr = 0
while True:
string = zstr.recv(input_s)
if string == "END":
break
string_nbr += 1
assert(string_nbr == 15)
def test_zstr():
ctx = zctx.new()
test_endpoint = 'inproc://zstr.test'
output_s = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output_s, test_endpoint)
input_s = zsocket.new(ctx, zmq.PAIR)
zsocket.connect(input_s, test_endpoint)
# Send ten strings, five strings with MORE flag and then END
for i in range(0, 10):
rc = zstr.send(output_s, "this is string {0}".format(i))
assert (rc == 0)
zstr.sendx(output_s, "This", "is", "almost", "the", "very", "END")
# Read and count until we receive END
string_nbr = 0
while True:
string = zstr.recv(input_s)
if string == "END":
break
string_nbr += 1
assert (string_nbr == 15)
def test_zloop():
ctx = zctx.new()
output = zsocket.new(ctx, zmq.PAIR)
input = zsocket.new(ctx, zmq.PAIR)
zsocket.bind(output, 'inproc://lkj')
zsocket.connect(input, 'inproc://lkj')
@ffi.callback('zloop_fn')
def item_handler(loop, item, arg):
assert zstr.recv(item.socket) == 'PING'
assert ffi.from_handle(arg) == 3
return -1
@ffi.callback('zloop_fn')
def timer_handler(loop, item, arg):
zstr.send(arg, 'PING')
return 0
l = zloop.new()
zloop.timer(l, 10, 1, timer_handler, output)
zloop.poller(
l, zmq.pollitem(socket=input, events=zmq.POLLIN), item_handler, 3)
zloop.start(l)
def test_zmsg():
m = zmsg.new()
foo = zframe.new('foo')
zmsg.push(m, foo)
assert zmsg.first(m) == foo
bar = zframe.new('bar')
zmsg.push(m, bar)
assert zmsg.first(m) == bar
assert zmsg.last(m) == foo
zmsg.append(m, zframe.new('ding'))
# dup and mutate the buffer view
d = zframe.dup(zmsg.last(m))
assert zframe.data(d)[:] == 'ding'
zframe.data(d)[1] = 'o'
assert zframe.data(d)[:] == 'dong'
assert zframe.size(d) == 4
zmsg.append(m, d)
ctx = zctx.new()
p = zsocket.new(ctx, zmq.PUB)
u = zsocket.new(ctx, zmq.SUB)
zsocket.set_subscribe(u, '')
zsocket.bind(p, 'inproc://qer')
zsocket.connect(u, 'inproc://qer')
zmsg.send(m, p)
zsocket.poll(u, 1)
n = zmsg.recv(u)
assert zmsg.size(n) == 4
assert zframe.data(zmsg.next(n))[:] == 'bar'
assert zframe.data(zmsg.next(n))[:] == 'foo'
assert zframe.data(zmsg.next(n))[:] == 'ding'
assert zframe.data(zmsg.next(n))[:] == 'dong'
assert zmsg.next(n) is None
zmsg.destroy(n)
def s_can_connect(server, client):
global PORT_NBR
rc = zsocket.bind(server, "tcp://*:{0}".format(PORT_NBR))
assert rc == PORT_NBR
rc = zsocket.connect(client, "tcp://127.0.0.1:{0}".format(PORT_NBR))
assert rc == 0
zstr.send(server, "Hello World")
poller = zpoller.new(client)
success = zpoller.wait(poller, 100) == client
del poller
rc = zsocket.unbind(server, "tcp://*:{0}".format(PORT_NBR))
assert rc != -1
rc = zsocket.disconnect(client, "tcp://127.0.0.1:{0}".format(PORT_NBR))
assert rc != -1
PORT_NBR += 1
return success
def s_can_connect(server, client):
global PORT_NBR
rc = zsocket.bind(server, "tcp://*:{}".format(PORT_NBR))
assert rc == PORT_NBR
rc = zsocket.connect(client, "tcp://127.0.0.1:{}".format(PORT_NBR))
assert rc == 0
zstr.send(server, "Hello World")
poller = zpoller.new(client)
success = zpoller.wait(poller, 100) == client
del poller
rc = zsocket.unbind(server, "tcp://*:{}".format(PORT_NBR))
assert rc != -1
rc = zsocket.disconnect(client, "tcp://127.0.0.1:{}".format(PORT_NBR))
assert rc != -1
PORT_NBR += 1
return success
def bind(self, endpoint):
return zsocket.bind(self.sock, endpoint)
def test_zsocket():
ctx = zctx.new()
# Create a detached thread, let it run
interf = "*"
domain = "localhost"
service = 5560
writer = zsocket.new(ctx, zmq.PUSH)
assert (writer)
reader = zsocket.new(ctx, zmq.PULL)
assert (reader)
assert zsocket.type_str(writer) == "PUSH"
assert zsocket.type_str(reader) == "PULL"
rc = zsocket.bind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == service
# Check unbind
rc = zsocket.unbind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == 0
# In some cases and especially when running under Valgrind, doing
# a bind immediately after an unbind causes an EADDRINUSE error.
# Even a short sleep allows the OS to release the port for reuse.
time.sleep(0.1)
# Bind again
rc = zsocket.bind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == service
rc = zsocket.connect(reader, "tcp://{0}:{1}".format(domain, service))
assert rc == 0
zstr.send(writer, "HELLO")
message = zstr.recv(reader)
assert message
assert message == "HELLO"
# Test binding to ports
port = zsocket.bind(writer, "tcp://{0}:*".format(interf))
assert (port >= zsocket.DYNFROM and port <= zsocket.DYNTO)
assert zsocket.poll(writer, 100) == False
rc = zsocket.connect(reader, "txp://{0}:{1}".format(domain, service))
assert rc == -1
# Test sending frames to socket
frame = zframe.new("ABC")
rc = zframe.send(frame, writer, zframe.MORE)
assert rc == 0
frame = zframe.new("DEFG")
rc = zframe.send(frame, writer, 0)
assert rc == 0
frame = zframe.recv(reader)
assert zframe.streq(frame, "ABC")
assert zframe.more(frame)
zframe.destroy(frame)
frame = zframe.recv(reader)
assert zframe.streq(frame, "DEFG")
assert not zframe.more(frame)
zframe.destroy(frame)
del writer
del ctx
def test_zsocket():
ctx = zctx.new()
# Create a detached thread, let it run
interf = "*"
domain = "localhost"
service = 5560
writer = zsocket.new(ctx, zmq.PUSH)
assert (writer)
reader = zsocket.new(ctx, zmq.PULL)
assert (reader)
assert zsocket.type_str(writer) == "PUSH"
assert zsocket.type_str(reader) == "PULL"
rc = zsocket.bind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == service
# Check unbind
rc = zsocket.unbind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == 0
# In some cases and especially when running under Valgrind, doing
# a bind immediately after an unbind causes an EADDRINUSE error.
# Even a short sleep allows the OS to release the port for reuse.
time.sleep(0.1)
# Bind again
rc = zsocket.bind(writer, "tcp://{0}:{1}".format(interf, service))
assert rc == service
rc = zsocket.connect(reader, "tcp://{0}:{1}".format(domain, service))
assert rc == 0
zstr.send(writer, "HELLO")
message = zstr.recv(reader)
assert message
assert message == "HELLO"
# Test binding to ports
port = zsocket.bind(writer, "tcp://{0}:*".format(interf))
assert (port >= zsocket.DYNFROM and port <= zsocket.DYNTO)
assert zsocket.poll(writer, 100) == False
rc = zsocket.connect(reader, "txp://{0}:{1}".format(domain, service))
assert rc == -1
# Test sending frames to socket
frame = zframe.new("ABC")
rc = zframe.send(frame, writer, zframe.MORE)
assert rc == 0
frame = zframe.new("DEFG")
rc = zframe.send(frame, writer, 0)
assert rc == 0
frame = zframe.recv(reader)
assert zframe.streq(frame, "ABC")
assert zframe.more(frame)
zframe.destroy(frame)
frame = zframe.recv(reader)
assert zframe.streq(frame, "DEFG")
assert not zframe.more(frame)
zframe.destroy(frame)
del writer
del ctx
def bind(self, endpoint):
return zsocket.bind(self.sock, endpoint)
