Python strtypes.asbytes函数代码示例

    def test_router_router(self):
        """test router-router MQ devices"""
        if zmq.zmq_version() >= "4.0.0":
            raise SkipTest("Only for libzmq < 4")
        dev = devices.ThreadMonitoredQueue(zmq.ROUTER, zmq.ROUTER, zmq.PUB, "in", "out")
        dev.setsockopt_in(zmq.LINGER, 0)
        dev.setsockopt_out(zmq.LINGER, 0)
        dev.setsockopt_mon(zmq.LINGER, 0)

        binder = self.context.socket(zmq.DEALER)
        porta = binder.bind_to_random_port("tcp://127.0.0.1")
        portb = binder.bind_to_random_port("tcp://127.0.0.1")
        binder.close()
        time.sleep(0.1)
        a = self.context.socket(zmq.DEALER)
        a.identity = asbytes("a")
        b = self.context.socket(zmq.DEALER)
        b.identity = asbytes("b")

        a.connect("tcp://127.0.0.1:%i" % porta)
        dev.bind_in("tcp://127.0.0.1:%i" % porta)
        b.connect("tcp://127.0.0.1:%i" % portb)
        dev.bind_out("tcp://127.0.0.1:%i" % portb)
        dev.start()
        time.sleep(0.2)
        msg = [asbytes(m) for m in ("hello", "there")]
        a.send_multipart(["b"] + msg)
        bmsg = self.recv_multipart(b)
        self.assertEquals(bmsg, ["a"] + msg)
        b.send_multipart(bmsg)
        amsg = self.recv_multipart(a)
        self.assertEquals(amsg, ["b"] + msg)

    def test_pubsub(self):
        s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
        s2.setsockopt(zmq.SUBSCRIBE, asbytes(''))

        # Sleep to allow sockets to connect.
        wait()

        poller = zmq.Poller()
        poller.register(s1, zmq.POLLIN|zmq.POLLOUT)
        poller.register(s2, zmq.POLLIN)

        # Now make sure that both are send ready.
        socks = dict(poller.poll())
        self.assertEquals(socks[s1], zmq.POLLOUT)
        self.assertEquals(s2 in socks, 0)
        # Make sure that s1 stays in POLLOUT after a send.
        s1.send(asbytes('msg1'))
        socks = dict(poller.poll())
        self.assertEquals(socks[s1], zmq.POLLOUT)

        # Make sure that s2 is POLLIN after waiting.
        wait()
        socks = dict(poller.poll())
        self.assertEquals(socks[s2], zmq.POLLIN)

        # Make sure that s2 goes into 0 after recv.
        s2.recv()
        socks = dict(poller.poll())
        self.assertEquals(s2 in socks, 0)

        poller.unregister(s1)
        poller.unregister(s2)

        # Wait for everything to finish.
        wait()

 def test_single_socket_forwarder_bind(self):
     dev = devices.ThreadDevice(zmq.FORWARDER, zmq.REP, -1)
     req = self.context.socket(zmq.REQ)
     port = 12345
     req.connect('tcp://127.0.0.1:%i'%port)
     dev.bind_in('tcp://127.0.0.1:%i'%port)
     dev.start()
     time.sleep(.25)
     msg = asbytes('hello')
     req.send(msg)
     self.assertEquals(msg, req.recv())
     del dev
     del req
     dev = devices.ThreadDevice(zmq.FORWARDER, zmq.REP, -1)
     req = self.context.socket(zmq.REQ)
     port = 12346
     req.connect('tcp://127.0.0.1:%i'%port)
     dev.bind_in('tcp://127.0.0.1:%i'%port)
     dev.start()
     time.sleep(.25)
     msg = asbytes('hello again')
     req.send(msg)
     self.assertEquals(msg, req.recv())
     del dev
     del req

 def test_init_iface(self):
     logger = self.logger
     ctx = self.context
     handler = handlers.PUBHandler(self.iface)
     self.assertFalse(handler.ctx is ctx)
     self.sockets.append(handler.socket)
     # handler.ctx.term()
     handler = handlers.PUBHandler(self.iface, self.context)
     self.sockets.append(handler.socket)
     self.assertTrue(handler.ctx is ctx)
     handler.setLevel(logging.DEBUG)
     handler.root_topic = self.topic
     logger.addHandler(handler)
     sub = ctx.socket(zmq.SUB)
     self.sockets.append(sub)
     sub.setsockopt(zmq.SUBSCRIBE, self.topic)
     sub.connect(self.iface)
     import time; time.sleep(0.25)
     msg1 = 'message'
     logger.info(msg1)
     
     (topic, msg2) = sub.recv_multipart()
     self.assertEquals(topic, asbytes('zmq.INFO'))
     self.assertEquals(msg2, asbytes(msg1+'\n'))
     logger.removeHandler(handler)

 def test_prefix(self):
     if zmq.zmq_version() < '3.0.0':
         raise SkipTest("Only applies to libzmq >= 3.0")
     xrep, xreq = self.create_bound_pair(zmq.XREP, zmq.XREQ)
     msg = [ asbytes(p) for p in 'hi there'.split() ]
     xreq.send_multipart(msg)
     recvd = xrep.recv_multipart()
     self.assertTrue(isinstance(recvd, tuple))
     self.assertEquals(len(recvd), 2)
     prefix, real = recvd
     self.assertTrue(isinstance(prefix, list))
     self.assertEquals(len(prefix), 1)
     self.assertEquals(real, msg)
     xrep.send_multipart(real, prefix=prefix)
     echo = xreq.recv_multipart()
     self.assertTrue(isinstance(echo, list))
     self.assertEquals(echo, real)
     extra = [asbytes('pre')]
     xrep.send_multipart(msg, prefix=prefix+extra)
     recvd = xreq.recv_multipart()
     self.assertTrue(isinstance(recvd, tuple))
     self.assertEquals(len(recvd), 2)
     prefix, real = recvd
     self.assertTrue(isinstance(prefix, list))
     self.assertEquals(len(prefix), 1)
     self.assertEquals(prefix, extra)
     self.assertEquals(real, msg)

 def test_single_socket_forwarder_bind(self):
     dev = devices.ThreadDevice(zmq.QUEUE, zmq.REP, -1)
     # select random port:
     binder = self.context.socket(zmq.REQ)
     port = binder.bind_to_random_port('tcp://127.0.0.1')
     binder.close()
     time.sleep(0.1)
     req = self.context.socket(zmq.REQ)
     req.connect('tcp://127.0.0.1:%i'%port)
     dev.bind_in('tcp://127.0.0.1:%i'%port)
     dev.start()
     time.sleep(.25)
     msg = asbytes('hello')
     req.send(msg)
     self.assertEquals(msg, self.recv(req))
     del dev
     req.close()
     dev = devices.ThreadDevice(zmq.QUEUE, zmq.REP, -1)
     # select random port:
     binder = self.context.socket(zmq.REQ)
     port = binder.bind_to_random_port('tcp://127.0.0.1')
     binder.close()
     time.sleep(0.1)
     req = self.context.socket(zmq.REQ)
     req.connect('tcp://127.0.0.1:%i'%port)
     dev.bind_in('tcp://127.0.0.1:%i'%port)
     dev.start()
     time.sleep(.25)
     msg = asbytes('hello again')
     req.send(msg)
     self.assertEquals(msg, self.recv(req))
     del dev
     req.close()

 def build_device(self, mon_sub=asbytes(""), in_prefix=asbytes('in'), out_prefix=asbytes('out')):
     self.device = devices.ThreadMonitoredQueue(zmq.PAIR, zmq.PAIR, zmq.PUB,
                                         in_prefix, out_prefix)
     alice = self.context.socket(zmq.PAIR)
     bob = self.context.socket(zmq.PAIR)
     mon = self.context.socket(zmq.SUB)
     
     aport = alice.bind_to_random_port('tcp://127.0.0.1')
     bport = bob.bind_to_random_port('tcp://127.0.0.1')
     mport = mon.bind_to_random_port('tcp://127.0.0.1')
     mon.setsockopt(zmq.SUBSCRIBE, mon_sub)
     
     self.device.connect_in("tcp://127.0.0.1:%i"%aport)
     self.device.connect_out("tcp://127.0.0.1:%i"%bport)
     self.device.connect_mon("tcp://127.0.0.1:%i"%mport)
     self.device.start()
     time.sleep(.2)
     try:
         # this is currenlty necessary to ensure no dropped monitor messages
         # see LIBZMQ-248 for more info
         mon.recv_multipart(zmq.NOBLOCK)
     except zmq.ZMQError:
         pass
     self.sockets.extend([alice, bob, mon])
     return alice, bob, mon

 def test_lifecycle2(self):
     """Run through a different ref counting cycle with a copy."""
     for i in range(5, 16):  # 32, 64,..., 65536
         s = (2**i)*x
         rc = 2
         self.assertEquals(grc(s), rc)
         m = zmq.Frame(s)
         rc += 2
         self.assertEquals(grc(s), rc)
         m2 = copy.copy(m)
         rc += 1
         self.assertEquals(grc(s), rc)
         b = m.buffer
         rc += view_rc
         self.assertEquals(grc(s), rc)
         self.assertEquals(s, asbytes(str(m)))
         self.assertEquals(s, asbytes(m2))
         self.assertEquals(s, m2.bytes)
         self.assertEquals(s, m.bytes)
         # self.assert_(s is str(m))
         # self.assert_(s is str(m2))
         del b
         self.assertEquals(grc(s), rc)
         del m
         # m.buffer is kept until m is del'd
         rc -= view_rc
         rc -= 1
         self.assertEquals(grc(s), rc)
         del m2
         rc -= 2
         self.assertEquals(grc(s), rc)
         self.assertEquals(rc, 2)
         del s

    def test_lifecycle1(self):
        """Run through a ref counting cycle with a copy."""
        for i in range(5, 16):  # 32, 64,..., 65536
            s = (2**i)*x
            rc = 2
            self.assertEquals(grc(s), rc)
            m = zmq.Message(s)
            rc += 2
            self.assertEquals(grc(s), rc)
            m2 = copy.copy(m)
            rc += 1
            self.assertEquals(grc(s), rc)
            b = m2.buffer

            rc += view_rc
            self.assertEquals(grc(s), rc)

            self.assertEquals(s, asbytes(str(m)))
            self.assertEquals(s, asbytes(m2))
            self.assertEquals(s, m.bytes)
            # self.assert_(s is str(m))
            # self.assert_(s is str(m2))
            del m2
            rc -= 1
            self.assertEquals(grc(s), rc)
            rc -= view_rc
            del b
            self.assertEquals(grc(s), rc)
            del m
            rc -= 2
            self.assertEquals(grc(s), rc)
            self.assertEquals(rc, 2)
            del s

    def test_pair(self):
        s1, s2 = self.create_bound_pair(zmq.PAIR, zmq.PAIR)

        # Sleep to allow sockets to connect.
        wait()

        poller = zmq.Poller()
        poller.register(s1, zmq.POLLIN|zmq.POLLOUT)
        poller.register(s2, zmq.POLLIN|zmq.POLLOUT)
        # Poll result should contain both sockets
        socks = dict(poller.poll())
        # Now make sure that both are send ready.
        self.assertEquals(socks[s1], zmq.POLLOUT)
        self.assertEquals(socks[s2], zmq.POLLOUT)
        # Now do a send on both, wait and test for zmq.POLLOUT|zmq.POLLIN
        s1.send(asbytes('msg1'))
        s2.send(asbytes('msg2'))
        wait()
        socks = dict(poller.poll())
        self.assertEquals(socks[s1], zmq.POLLOUT|zmq.POLLIN)
        self.assertEquals(socks[s2], zmq.POLLOUT|zmq.POLLIN)
        # Make sure that both are in POLLOUT after recv.
        s1.recv()
        s2.recv()
        socks = dict(poller.poll())
        self.assertEquals(socks[s1], zmq.POLLOUT)
        self.assertEquals(socks[s2], zmq.POLLOUT)

        poller.unregister(s1)
        poller.unregister(s2)

        # Wait for everything to finish.
        wait()

 def test_basic(self):
     s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
     s2.setsockopt(zmq.SUBSCRIBE,asbytes(''))
     time.sleep(0.1)
     msg1 = asbytes('message')
     s1.send(msg1)
     msg2 = s2.recv()  # This is blocking!
     self.assertEquals(msg1, msg2)

 def _process_socks(self, socks):
     if self.result_collector in socks:
         data = self.result_collector.recv_string()
         if 'status' not in data:
             self.stats_handler.write_result(ujson.loads(data))
             self.external_publisher.send_multipart([asbytes(self.topic), asbytes(data)])
             self.messages += 1
         else:
             self.turrets_manager.process_message(ujson.loads(data))

    def test_bad_send_recv(self):
        s1, s2 = self.create_bound_pair(zmq.REQ, zmq.REP)
        for copy in (True,False):
            self.assertRaisesErrno(zmq.EFSM, s1.recv, copy=copy)
            self.assertRaisesErrno(zmq.EFSM, s2.send, asbytes('asdf'), copy=copy)

        # I have to have this or we die on an Abort trap.
        msg1 = asbytes('asdf')
        msg2 = self.ping_pong(s1, s2, msg1)
        self.assertEquals(msg1, msg2)

 def test_close(self):
     ctx = zmq.Context()
     s = ctx.socket(zmq.PUB)
     s.close()
     self.assertRaises(zmq.ZMQError, s.bind, asbytes(''))
     self.assertRaises(zmq.ZMQError, s.connect, asbytes(''))
     self.assertRaises(zmq.ZMQError, s.setsockopt, zmq.SUBSCRIBE, asbytes(''))
     self.assertRaises(zmq.ZMQError, s.send, asbytes('asdf'))
     self.assertRaises(zmq.ZMQError, s.recv)
     del ctx

 def test_topic(self):
     s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
     s2.setsockopt(zmq.SUBSCRIBE, asbytes('x'))
     time.sleep(0.1)
     msg1 = asbytes('message')
     s1.send(msg1)
     self.assertRaisesErrno(zmq.EAGAIN, s2.recv, zmq.NOBLOCK)
     msg1 = asbytes('xmessage')
     s1.send(msg1)
     msg2 = s2.recv()
     self.assertEquals(msg1, msg2)