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_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_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 {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_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_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://*:{}".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 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 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 connect(self, endpoint): return zsocket.connect(self.sock, endpoint)
def test_zctx(): # Create and destroy a context without using it ctx = zctx.new() assert ctx del ctx # Create a context with many busy sockets, destroy it ctx = zctx.new() assert ctx # call API functions zctx.set_iothreads(ctx, 1) zctx.set_linger(ctx, 5) # 5 msecs zctx.set_pipehwm(ctx, 500) zctx.set_sndhwm(ctx, 500) zctx.set_rcvhwm(ctx, 500) s1 = zsocket.new(ctx, zmq.PAIR) s2 = zsocket.new(ctx, zmq.PULL) # zmq.XREQ ? s3 = zsocket.new(ctx, zmq.REQ) s4 = zsocket.new(ctx, zmq.REP) s5 = zsocket.new(ctx, zmq.PUB) s6 = zsocket.new(ctx, zmq.SUB) zsocket.connect(s1, "tcp://127.0.0.1:5555") zsocket.connect(s2, "tcp://127.0.0.1:5555") zsocket.connect(s3, "tcp://127.0.0.1:5555") zsocket.connect(s4, "tcp://127.0.0.1:5555") zsocket.connect(s5, "tcp://127.0.0.1:5555") zsocket.connect(s6, "tcp://127.0.0.1:5555") assert zctx.underlying(ctx); del ctx