Beispiel #1
0
 def test_frame_more(self):
     """test Frame.more attribute"""
     frame = zmq.Frame(b"hello")
     self.assertFalse(frame.more)
     sa,sb = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
     sa.send_multipart([b'hi', b'there'])
     frame = self.recv(sb, copy=False)
     self.assertTrue(frame.more)
     if zmq.zmq_version_info()[0] >= 3 and not PYPY:
         self.assertTrue(frame.get(zmq.MORE))
     frame = self.recv(sb, copy=False)
     self.assertFalse(frame.more)
     if zmq.zmq_version_info()[0] >= 3 and not PYPY:
         self.assertFalse(frame.get(zmq.MORE))
Beispiel #2
0
 def test_proxy(self):
     if zmq.zmq_version_info() < (3,2):
         raise SkipTest("Proxies only in libzmq >= 3")
     dev = devices.ThreadProxy(zmq.PULL, zmq.PUSH, zmq.PUSH)
     binder = self.context.socket(zmq.REQ)
     iface = 'tcp://127.0.0.1'
     port = binder.bind_to_random_port(iface)
     port2 = binder.bind_to_random_port(iface)
     port3 = binder.bind_to_random_port(iface)
     binder.close()
     time.sleep(0.1)
     dev.bind_in("%s:%i" % (iface, port))
     dev.bind_out("%s:%i" % (iface, port2))
     dev.bind_mon("%s:%i" % (iface, port3))
     dev.start()
     time.sleep(0.25)
     msg = b'hello'
     push = self.context.socket(zmq.PUSH)
     push.connect("%s:%i" % (iface, port))
     pull = self.context.socket(zmq.PULL)
     pull.connect("%s:%i" % (iface, port2))
     mon = self.context.socket(zmq.PULL)
     mon.connect("%s:%i" % (iface, port3))
     push.send(msg)
     self.sockets.extend([push, pull, mon])
     self.assertEqual(msg, self.recv(pull))
     self.assertEqual(msg, self.recv(mon))
Beispiel #3
0
    def get_monitor_socket(self, events=None, addr=None):
        """Return a connected PAIR socket ready to receive the event notifications.
        
        .. versionadded:: libzmq-4.0
        .. versionadded:: 14.0
        
        Parameters
        ----------
        events : bitfield (int) [default: ZMQ_EVENTS_ALL]
            The bitmask defining which events are wanted.
        addr :  string [default: None]
            The optional endpoint for the monitoring sockets.

        Returns
        -------
        socket :  (PAIR)
            The socket is already connected and ready to receive messages.
        """
        # safe-guard, method only available on libzmq >= 4
        if zmq.zmq_version_info() < (4,):
            raise NotImplementedError("get_monitor_socket requires libzmq >= 4, have %s" % zmq.zmq_version())
        if addr is None:
            # create endpoint name from internal fd
            addr = "inproc://monitor.s-%d" % self.FD
        if events is None:
            # use all events
            events = zmq.EVENT_ALL
        # attach monitoring socket
        self.monitor(addr, events)
        # create new PAIR socket and connect it
        ret = self.context.socket(zmq.PAIR)
        ret.connect(addr)
        return ret
Beispiel #4
0
 def test_proxy_steerable(self):
     if zmq.zmq_version_info() < (4, 1):
         raise SkipTest("Steerable Proxies only in libzmq >= 4.1")
     dev = devices.ThreadProxySteerable(
         zmq.PULL,
         zmq.PUSH,
         zmq.PUSH,
         zmq.PAIR
     )
     iface = 'tcp://127.0.0.1'
     port = dev.bind_in_to_random_port(iface)
     port2 = dev.bind_out_to_random_port(iface)
     port3 = dev.bind_mon_to_random_port(iface)
     port4 = dev.bind_ctrl_to_random_port(iface)
     dev.start()
     time.sleep(0.25)
     msg = b'hello'
     push = self.context.socket(zmq.PUSH)
     push.connect("%s:%i" % (iface, port))
     pull = self.context.socket(zmq.PULL)
     pull.connect("%s:%i" % (iface, port2))
     mon = self.context.socket(zmq.PULL)
     mon.connect("%s:%i" % (iface, port3))
     ctrl = self.context.socket(zmq.PAIR)
     ctrl.connect("%s:%i" % (iface, port4))
     push.send(msg)
     self.sockets.extend([push, pull, mon, ctrl])
     self.assertEqual(msg, self.recv(pull))
     self.assertEqual(msg, self.recv(mon))
     ctrl.send(b'TERMINATE')
     dev.join()
Beispiel #5
0
    def set_hwm(self, value):
        """set the High Water Mark
        
        On libzmq ≥ 3, this sets both SNDHWM and RCVHWM


        .. warning::

            New values only take effect for subsequent socket
            bind/connects.
        """
        major = zmq.zmq_version_info()[0]
        if major >= 3:
            raised = None
            try:
                self.sndhwm = value
            except Exception as e:
                raised = e
            try:
                self.rcvhwm = value
            except Exception as e:
                raised = e
            
            if raised:
                raise raised
        else:
            return self.setsockopt(zmq.HWM, value)
Beispiel #6
0
 def test_monitor(self):
     """Test monitoring interface for sockets."""
     s_rep = self.context.socket(zmq.REP)
     s_req = self.context.socket(zmq.REQ)
     self.sockets.extend([s_rep, s_req])
     s_req.bind("tcp://127.0.0.1:6666")
     # try monitoring the REP socket
     
     s_rep.monitor("inproc://monitor.rep", zmq.EVENT_ALL)
     # create listening socket for monitor
     s_event = self.context.socket(zmq.PAIR)
     self.sockets.append(s_event)
     s_event.connect("inproc://monitor.rep")
     s_event.linger = 0
     # test receive event for connect event
     s_rep.connect("tcp://127.0.0.1:6666")
     if zmq.zmq_version_info() < (3,3):
         self.assertRaises(NotImplementedError, get_monitor_message, s_event)
         return
     m = get_monitor_message(s_event)
     self.assertEqual(m['event'], zmq.EVENT_CONNECT_DELAYED)
     self.assertEqual(m['endpoint'], b"tcp://127.0.0.1:6666")
     # test receive event for connected event
     m = get_monitor_message(s_event)
     self.assertEqual(m['event'], zmq.EVENT_CONNECTED)
Beispiel #7
0
def _zmq_has_curve():
    """
    Return whether the current ZMQ has support for auth and CurveZMQ security.

    :rtype: bool

     Version notes:
       `zmq.curve_keypair()` is new in version 14.0, new in version libzmq-4.0.
            Requires libzmq (>= 4.0) to have been linked with libsodium.
       `zmq.auth` module is new in version 14.1
       `zmq.has()` is new in version 14.1, new in version libzmq-4.1.
    """
    zmq_version = zmq.zmq_version_info()
    pyzmq_version = zmq.pyzmq_version_info()

    if pyzmq_version >= (14, 1, 0) and zmq_version >= (4, 1):
        return zmq.has('curve')

    if pyzmq_version < (14, 1, 0):
        return False

    if zmq_version < (4, 0):
        # security is new in libzmq 4.0
        return False

    try:
        zmq.curve_keypair()
    except zmq.error.ZMQError:
        # security requires libzmq to be linked against libsodium
        return False

    return True
Beispiel #8
0
    def enable_monitor(self, events=None):

        # The standard approach of binding and then connecting does not
        # work in this specific case. The event loop does not properly
        # detect messages on the inproc transport which means that event
        # messages get missed.
        # pyzmq's 'get_monitor_socket' method can't be used because this
        # performs the actions in the wrong order for use with an event
        # loop.
        # For more information on this issue see:
        # http://lists.zeromq.org/pipermail/zeromq-dev/2015-July/029181.html

        if (zmq.zmq_version_info() < (4,) or
                zmq.pyzmq_version_info() < (14, 4,)):
            raise NotImplementedError(
                "Socket monitor requires libzmq >= 4 and pyzmq >= 14.4, "
                "have libzmq:{}, pyzmq:{}".format(
                    zmq.zmq_version(), zmq.pyzmq_version()))

        if self._monitor is None:
            addr = "inproc://monitor.s-{}".format(self._zmq_sock.FD)
            events = events or zmq.EVENT_ALL
            _, self._monitor = yield from create_zmq_connection(
                lambda: _ZmqEventProtocol(self._loop, self._protocol),
                zmq.PAIR, connect=addr, loop=self._loop)
            # bind must come after connect
            self._zmq_sock.monitor(addr, events)
            yield from self._monitor.wait_ready
Beispiel #9
0
 def setUp(self):
     if zmq.zmq_version_info() < (4, 0):
         raise SkipTest("security is new in libzmq 4.0")
     try:
         zmq.curve_keypair()
     except zmq.ZMQError:
         raise SkipTest("security requires libzmq to be linked against libsodium")
     super(TestSecurity, self).setUp()
Beispiel #10
0
 def setUp(self):
     if zmq.zmq_version_info() < (4,0):
         raise SkipTest("security is new in libzmq 4.0")
     try:
         zmq.curve_keypair()
     except zmq.ZMQError:
         raise SkipTest("security requires libzmq to be built with CURVE support")
     super(TestSecurity, self).setUp()
Beispiel #11
0
 def test_ctx_opts(self):
     if zmq.zmq_version_info() < (3,):
         raise SkipTest("context options require libzmq 3")
     ctx = self.Context()
     ctx.set(zmq.MAX_SOCKETS, 2)
     self.assertEqual(ctx.get(zmq.MAX_SOCKETS), 2)
     ctx.max_sockets = 100
     self.assertEqual(ctx.max_sockets, 100)
     self.assertEqual(ctx.get(zmq.MAX_SOCKETS), 100)
Beispiel #12
0
 def setUp(self):
     if zmq.zmq_version_info() < (4, 0):
         raise SkipTest("security is new in libzmq 4.0")
     try:
         zmq.curve_keypair()
     except zmq.ZMQError:
         raise SkipTest(
             "security requires libzmq to be linked against libsodium")
     super(TestSecurity, self).setUp()
Beispiel #13
0
 def test_ctx_opts(self):
     if zmq.zmq_version_info() < (3, ):
         raise SkipTest("context options require libzmq 3")
     ctx = self.Context()
     ctx.set(zmq.MAX_SOCKETS, 2)
     self.assertEqual(ctx.get(zmq.MAX_SOCKETS), 2)
     ctx.max_sockets = 100
     self.assertEqual(ctx.max_sockets, 100)
     self.assertEqual(ctx.get(zmq.MAX_SOCKETS), 100)
Beispiel #14
0
    def test_int_sockopts(self):
        "test integer sockopts"
        v = zmq.zmq_version_info()
        if v < (3, 0):
            default_hwm = 0
        else:
            default_hwm = 1000
        p, s = self.create_bound_pair(zmq.PUB, zmq.SUB)
        p.setsockopt(zmq.LINGER, 0)
        self.assertEqual(p.getsockopt(zmq.LINGER), 0)
        p.setsockopt(zmq.LINGER, -1)
        self.assertEqual(p.getsockopt(zmq.LINGER), -1)
        self.assertEqual(p.hwm, default_hwm)
        p.hwm = 11
        self.assertEqual(p.hwm, 11)
        # p.setsockopt(zmq.EVENTS, zmq.POLLIN)
        self.assertEqual(p.getsockopt(zmq.EVENTS), zmq.POLLOUT)
        self.assertRaisesErrno(zmq.EINVAL, p.setsockopt, zmq.EVENTS, 2**7 - 1)
        self.assertEqual(p.getsockopt(zmq.TYPE), p.socket_type)
        self.assertEqual(p.getsockopt(zmq.TYPE), zmq.PUB)
        self.assertEqual(s.getsockopt(zmq.TYPE), s.socket_type)
        self.assertEqual(s.getsockopt(zmq.TYPE), zmq.SUB)

        # check for overflow / wrong type:
        errors = []
        backref = {}
        constants = zmq.constants
        for name in constants.__all__:
            value = getattr(constants, name)
            if isinstance(value, int):
                backref[value] = name
        for opt in zmq.constants.int_sockopts.union(
                zmq.constants.int64_sockopts):
            sopt = backref[opt]
            if sopt.startswith((
                    'ROUTER',
                    'XPUB',
                    'TCP',
                    'FAIL',
                    'REQ_',
                    'CURVE_',
                    'PROBE_ROUTER',
                    'IPC_FILTER',
            )):
                # some sockopts are write-only
                continue
            try:
                n = p.getsockopt(opt)
            except zmq.ZMQError as e:
                errors.append("getsockopt(zmq.%s) raised '%s'." % (sopt, e))
            else:
                if n > 2**31:
                    errors.append(
                        "getsockopt(zmq.%s) returned a ridiculous value."
                        " It is probably the wrong type." % sopt)
        if errors:
            self.fail('\n'.join([''] + errors))
Beispiel #15
0
    def __init__(self, conf, ctx):
        if zmq.zmq_version_info() < (4, 0):
            raise RuntimeError(
                "Security is not supported in libzmq version < 4.0. libzmq version {0}"
                .format(zmq.zmq_version()))
        self._conf = conf
        self._zctx = ctx

        self._send_attempts = 0
Beispiel #16
0
 def setUp(self):
     if zmq.zmq_version_info() < (4, 0):
         raise SkipTest("security is new in libzmq 4.0")
     super(TestThreadedAuthentication, self).setUp()
     # silence auth module debug log output during test runs
     logger = logging.getLogger()
     self.original_log_level = logger.getEffectiveLevel()
     logger.setLevel(logging.DEBUG)
     self.auth = None
 def setUp(self):
     if zmq.zmq_version_info() < (4, 0):
         raise SkipTest("security is new in libzmq 4.0")
     try:
         zmq.curve_keypair()
     except zmq.ZMQError:
         raise SkipTest(
             "security requires libzmq to be built with CURVE support")
     super(TestSecurity, self).setUp()
Beispiel #18
0
 def test_int_sockopts(self):
     "test integer sockopts"
     v = zmq.zmq_version_info()
     if v < (3,0):
         default_hwm = 0
     else:
         default_hwm = 1000
     p,s = self.create_bound_pair(zmq.PUB, zmq.SUB)
     p.setsockopt(zmq.LINGER, 0)
     self.assertEqual(p.getsockopt(zmq.LINGER), 0)
     p.setsockopt(zmq.LINGER, -1)
     self.assertEqual(p.getsockopt(zmq.LINGER), -1)
     self.assertEqual(p.hwm, default_hwm)
     p.hwm = 11
     self.assertEqual(p.hwm, 11)
     # p.setsockopt(zmq.EVENTS, zmq.POLLIN)
     self.assertEqual(p.getsockopt(zmq.EVENTS), zmq.POLLOUT)
     self.assertRaisesErrno(zmq.EINVAL, p.setsockopt,zmq.EVENTS, 2**7-1)
     self.assertEqual(p.getsockopt(zmq.TYPE), p.socket_type)
     self.assertEqual(p.getsockopt(zmq.TYPE), zmq.PUB)
     self.assertEqual(s.getsockopt(zmq.TYPE), s.socket_type)
     self.assertEqual(s.getsockopt(zmq.TYPE), zmq.SUB)
     
     # check for overflow / wrong type:
     errors = []
     backref = {}
     constants = zmq.constants
     for name in constants.__all__:
         value = getattr(constants, name)
         if isinstance(value, int):
             backref[value] = name
     for opt in zmq.constants.int_sockopts.union(zmq.constants.int64_sockopts):
         sopt = backref[opt]
         if sopt.startswith((
             'ROUTER', 'XPUB', 'TCP', 'FAIL',
             'REQ_', 'CURVE_', 'PROBE_ROUTER',
             'IPC_FILTER', 'GSSAPI', 'STREAM_',
             'VMCI_BUFFER_SIZE', 'VMCI_BUFFER_MIN_SIZE',
             'VMCI_BUFFER_MAX_SIZE', 'VMCI_CONNECT_TIMEOUT',
             )):
             # some sockopts are write-only
             continue
         try:
             n = p.getsockopt(opt)
         except zmq.ZMQError as e:
             errors.append("getsockopt(zmq.%s) raised '%s'."%(sopt, e))
         else:
             if n > 2**31:
                 errors.append("getsockopt(zmq.%s) returned a ridiculous value."
                                 " It is probably the wrong type."%sopt)
     if errors:
         self.fail('\n'.join([''] + errors))
Beispiel #19
0
 def test_removed(self):
     zmq_version = zmq.zmq_version_info()
     for version, new_names in constant_names.removed_in.items():
         should_have = zmq_version < version
         for name in new_names:
             try:
                 value = getattr(zmq, name)
             except AttributeError:
                 if should_have:
                     self.fail("AttributeError: zmq.%s" % name)
             else:
                 if not should_have:
                     self.fail("Shouldn't have: zmq.%s=%s" % (name, value))
Beispiel #20
0
 def test_removed(self):
     zmq_version = zmq.zmq_version_info()
     for version, new_names in constant_names.removed_in.items():
         should_have = zmq_version < version
         for name in new_names:
             try:
                 value = getattr(zmq, name)
             except AttributeError:
                 if should_have:
                     self.fail("AttributeError: zmq.%s" % name)
             else:
                 if not should_have:
                     self.fail("Shouldn't have: zmq.%s=%s" % (name, value))
Beispiel #21
0
    def test_int_sockopts(self):
        "test non-uint64 sockopts"
        v = zmq.zmq_version_info()
        if not v >= (2, 1):
            raise SkipTest("only on libzmq >= 2.1")
        elif v < (3, 0):
            hwm = zmq.HWM
            default_hwm = 0
        else:
            hwm = zmq.SNDHWM
            default_hwm = 1000
        p, s = self.create_bound_pair(zmq.PUB, zmq.SUB)
        p.setsockopt(zmq.LINGER, 0)
        self.assertEquals(p.getsockopt(zmq.LINGER), 0)
        p.setsockopt(zmq.LINGER, -1)
        self.assertEquals(p.getsockopt(zmq.LINGER), -1)
        self.assertEquals(p.getsockopt(hwm), default_hwm)
        p.setsockopt(hwm, 11)
        self.assertEquals(p.getsockopt(hwm), 11)
        # p.setsockopt(zmq.EVENTS, zmq.POLLIN)
        self.assertEquals(p.getsockopt(zmq.EVENTS), zmq.POLLOUT)
        self.assertRaisesErrno(zmq.EINVAL, p.setsockopt, zmq.EVENTS, 2 ** 7 - 1)
        self.assertEquals(p.getsockopt(zmq.TYPE), p.socket_type)
        self.assertEquals(p.getsockopt(zmq.TYPE), zmq.PUB)
        self.assertEquals(s.getsockopt(zmq.TYPE), s.socket_type)
        self.assertEquals(s.getsockopt(zmq.TYPE), zmq.SUB)

        # check for overflow / wrong type:
        errors = []
        backref = {}
        constants = zmq.core.constants
        for name in constants.__all__:
            value = getattr(constants, name)
            if isinstance(value, int):
                backref[value] = name
        for opt in zmq.core.constants.int_sockopts + zmq.core.constants.int64_sockopts:
            sopt = backref[opt]
            if sopt == "FAIL_UNROUTABLE":
                # fail_unroutable is write-only
                continue
            try:
                n = p.getsockopt(opt)
            except zmq.ZMQError as e:
                errors.append("getsockopt(zmq.%s) raised '%s'." % (sopt, e))
            else:
                if n > 2 ** 31:
                    errors.append(
                        "getsockopt(zmq.%s) returned a ridiculous value." " It is probably the wrong type." % sopt
                    )
        if errors:
            self.fail("\n".join(errors))
Beispiel #22
0
    def test_int_sockopts(self):
        "test non-uint64 sockopts"
        v = zmq.zmq_version_info()
        if not v >= (2, 1):
            raise SkipTest("only on libzmq >= 2.1")
        elif v < (3, 0):
            hwm = zmq.HWM
            default_hwm = 0
        else:
            hwm = zmq.SNDHWM
            default_hwm = 1000
        p, s = self.create_bound_pair(zmq.PUB, zmq.SUB)
        p.setsockopt(zmq.LINGER, 0)
        self.assertEquals(p.getsockopt(zmq.LINGER), 0)
        p.setsockopt(zmq.LINGER, -1)
        self.assertEquals(p.getsockopt(zmq.LINGER), -1)
        self.assertEquals(p.getsockopt(hwm), default_hwm)
        p.setsockopt(hwm, 11)
        self.assertEquals(p.getsockopt(hwm), 11)
        # p.setsockopt(zmq.EVENTS, zmq.POLLIN)
        self.assertEquals(p.getsockopt(zmq.EVENTS), zmq.POLLOUT)
        self.assertRaisesErrno(zmq.EINVAL, p.setsockopt, zmq.EVENTS, 2**7 - 1)
        self.assertEquals(p.getsockopt(zmq.TYPE), p.socket_type)
        self.assertEquals(p.getsockopt(zmq.TYPE), zmq.PUB)
        self.assertEquals(s.getsockopt(zmq.TYPE), s.socket_type)
        self.assertEquals(s.getsockopt(zmq.TYPE), zmq.SUB)

        # check for overflow / wrong type:
        errors = []
        backref = {}
        constants = zmq.core.constants
        for name in constants.__all__:
            value = getattr(constants, name)
            if isinstance(value, int):
                backref[value] = name
        for opt in zmq.core.constants.int_sockopts + zmq.core.constants.int64_sockopts:
            sopt = backref[opt]
            if sopt == 'ROUTER_BEHAVIOR' or 'TCP' in sopt:
                # fail_unroutable is write-only
                continue
            try:
                n = p.getsockopt(opt)
            except zmq.ZMQError as e:
                errors.append("getsockopt(zmq.%s) raised '%s'." % (sopt, e))
            else:
                if n > 2**31:
                    errors.append(
                        "getsockopt(zmq.%s) returned a ridiculous value."
                        " It is probably the wrong type." % sopt)
        if errors:
            self.fail('\n'.join([''] + errors))
Beispiel #23
0
def _check_version(min_version_info, msg='Feature'):
    """Check for libzmq
    
    raises ZMQVersionError if current zmq version is not at least min_version
    
    min_version_info is a tuple of integers, and will be compared against zmq.zmq_version_info().
    """
    global _zmq_version_info
    if _zmq_version_info is None:
        from zmq import zmq_version_info
        _zmq_version_info = zmq_version_info()
    if _zmq_version_info < min_version_info:
        min_version = '.'.join(str(v) for v in min_version_info)
        raise ZMQVersionError(min_version, msg)
Beispiel #24
0
    def _select_recv(self, multipart, socket, **kwargs):
        """call recv[_multipart] in a way that raises if there is nothing to receive"""
        if zmq.zmq_version_info() >= (3, 1, 0):
            # zmq 3.1 has a bug, where poll can return false positives,
            # so we wait a little bit just in case
            # See LIBZMQ-280 on JIRA
            time.sleep(0.1)

        r, w, x = zmq.select([socket], [], [], timeout=5)
        assert len(r) > 0, "Should have received a message"
        kwargs['flags'] = zmq.DONTWAIT | kwargs.get('flags', 0)

        recv = socket.recv_multipart if multipart else socket.recv
        return recv(**kwargs)
Beispiel #25
0
def main():
    if zmq.zmq_version_info() < (4, 0):
        raise RuntimeError(
            "Security is not supported in libzmq version < 4.0. libzmq version "
            "{0}".format(zmq.zmq_version()))

    if '-v' in sys.argv:
        level = logging.DEBUG
    else:
        level = logging.INFO

    logging.basicConfig(level=level, format="[%(levelname)s] %(message)s")

    run()
Beispiel #26
0
def _check_version(min_version_info, msg='Feature'):
    """Check for libzmq
    
    raises ZMQVersionError if current zmq version is not at least min_version
    
    min_version_info is a tuple of integers, and will be compared against zmq.zmq_version_info().
    """
    global _zmq_version_info
    if _zmq_version_info is None:
        from zmq import zmq_version_info
        _zmq_version_info = zmq_version_info()
    if _zmq_version_info < min_version_info:
        min_version = '.'.join(str(v) for v in min_version_info)
        raise ZMQVersionError(min_version, msg)
Beispiel #27
0
 def _select_recv(self, multipart, socket, **kwargs):
     """call recv[_multipart] in a way that raises if there is nothing to receive"""
     if zmq.zmq_version_info() >= (3,1,0):
         # zmq 3.1 has a bug, where poll can return false positives,
         # so we wait a little bit just in case
         # See LIBZMQ-280 on JIRA
         time.sleep(0.1)
     
     r,w,x = zmq.select([socket], [], [], timeout=5)
     assert len(r) > 0, "Should have received a message"
     kwargs['flags'] = zmq.DONTWAIT | kwargs.get('flags', 0)
     
     recv = socket.recv_multipart if multipart else socket.recv
     return recv(**kwargs)
Beispiel #28
0
 def test_proxy_bind_to_random_with_args(self):
     if zmq.zmq_version_info() < (3, 2):
         raise SkipTest("Proxies only in libzmq >= 3")
     dev = devices.ThreadProxy(zmq.PULL, zmq.PUSH, zmq.PUSH)
     iface = 'tcp://10.0.0.7'
     ports = []
     min, max = 5000, 5050
     ports.extend([
         dev.bind_in_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_out_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_mon_to_random_port(iface, min_port=min, max_port=max)
     ])
     for port in ports:
         if port < min or port > max:
             self.fail('Unexpected port number: %i' % port)
Beispiel #29
0
 def __init__(self, context=None, encoding='utf-8'):
     if zmq.zmq_version_info() < (4,0):
         raise NotImplementedError("Security is only available in libzmq >= 4.0")
     self.context = context or zmq.Context.instance()
     self.encoding = encoding
     self.allow_any = False
     self.zap_socket = None
     self.whitelist = []
     self.blacklist = []
     # passwords is a dict keyed by domain and contains values
     # of dicts with username:password pairs.
     self.passwords = {}
     # certs is dict keyed by domain and contains values
     # of dicts keyed by the public keys from the specified location.
     self.certs = {}
Beispiel #30
0
 def _setup_socket(self):
     if self.socket is None:
         self.socket = self.context.socket(self.socket_type)
     if self.routing_id:
         self.socket.identity = self.routing_id
     if self.socket_type == zmq.ROUTER:
         self.socket.ROUTER_MANDATORY = True
         if zmq.zmq_version_info() >= (4, 1, 0):
             self.socket.ROUTER_HANDOVER = True
     elif self.socket_type == zmq.REQ:
         self.socket.RCVTIMEO = int(self.timeout * 1000)
     self.socket.SNDTIMEO = int(self.timeout * 1000)
     self.auth_backend.configure()
     self.heartbeat_backend.configure()
     self.initialized = True
Beispiel #31
0
 def test_proxy_bind_to_random_with_args(self):
     if zmq.zmq_version_info() < (3, 2):
         raise SkipTest("Proxies only in libzmq >= 3")
     dev = devices.ThreadProxy(zmq.PULL, zmq.PUSH, zmq.PUSH)
     iface = 'tcp://127.0.0.1'
     ports = []
     min, max = 5000, 5050
     ports.extend([
         dev.bind_in_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_out_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_mon_to_random_port(iface, min_port=min, max_port=max)
     ])
     for port in ports:
         if port < min or port > max:
             self.fail('Unexpected port number: %i' % port)
Beispiel #32
0
 def test_hwm(self):
     zmq3 = zmq.zmq_version_info()[0] >= 3
     for stype in (zmq.PUB, zmq.ROUTER, zmq.SUB, zmq.REQ, zmq.DEALER):
         s = self.context.socket(stype)
         s.hwm = 100
         self.assertEqual(s.hwm, 100)
         if zmq3:
             try:
                 self.assertEqual(s.sndhwm, 100)
             except AttributeError:
                 pass
             try:
                 self.assertEqual(s.rcvhwm, 100)
             except AttributeError:
                 pass
         s.close()
Beispiel #33
0
 def get_hwm(self):
     """get the High Water Mark
     
     On libzmq ≥ 3.x, this gets SNDHWM if available, otherwise RCVHWM
     """
     major = zmq.zmq_version_info()[0]
     if major >= 3:
         # return sndhwm, fallback on rcvhwm
         try:
             return self.getsockopt(zmq.SNDHWM)
         except zmq.ZMQError as e:
             pass
         
         return self.getsockopt(zmq.RCVHWM)
     else:
         return self.getsockopt(zmq.HWM)
Beispiel #34
0
 def _setup_socket(self, probing=False):
     if self.socket is None:
         self.socket = self.context.socket(self.socket_type)
     if self.routing_id:
         self.socket.setsockopt(zmq.IDENTITY, self.routing_id)
     if self.socket_type == zmq.ROUTER:
         self.socket.setsockopt(zmq.ROUTER_MANDATORY, True)
         if zmq.zmq_version_info() >= (4, 1, 0):
             self.socket.setsockopt(zmq.ROUTER_HANDOVER, True)
     elif self.socket_type == zmq.REQ:
         self.socket.setsockopt(zmq.RCVTIMEO, int(self.timeout * 1000))
     self.socket.setsockopt(zmq.SNDTIMEO, int(self.timeout * 1000))
     self.socket.setsockopt(zmq.PROBE_ROUTER, probing)
     self.auth_backend.configure()
     self.heartbeat_backend.configure()
     self.initialized = True
Beispiel #35
0
 def _setup_socket(self, probing=False):
     if self.socket is None:
         self.socket = self.context.socket(self.socket_type)
     if self.routing_id:
         self.socket.setsockopt(zmq.IDENTITY, self.routing_id)
     if self.socket_type == zmq.ROUTER:
         self.socket.setsockopt(zmq.ROUTER_MANDATORY, True)
         if zmq.zmq_version_info() >= (4, 1, 0):
             self.socket.setsockopt(zmq.ROUTER_HANDOVER, True)
     elif self.socket_type == zmq.REQ:
         self.socket.setsockopt(zmq.RCVTIMEO, int(self.timeout * 1000))
     self.socket.setsockopt(zmq.SNDTIMEO, int(self.timeout * 1000))
     self.socket.setsockopt(zmq.PROBE_ROUTER, probing)
     self.auth_backend.configure()
     self.heartbeat_backend.configure()
     self.initialized = True
Beispiel #36
0
 def test_hwm(self):
     zmq3 = zmq.zmq_version_info()[0] >= 3
     for stype in (zmq.PUB, zmq.ROUTER, zmq.SUB, zmq.REQ, zmq.DEALER):
         s = self.context.socket(stype)
         s.hwm = 100
         self.assertEqual(s.hwm, 100)
         if zmq3:
             try:
                 self.assertEqual(s.sndhwm, 100)
             except AttributeError:
                 pass
             try:
                 self.assertEqual(s.rcvhwm, 100)
             except AttributeError:
                 pass
         s.close()
 def get_hwm(self):
     """get the High Water Mark
     
     On libzmq ≥ 3.x, this gets SNDHWM if available, otherwise RCVHWM
     """
     major = zmq.zmq_version_info()[0]
     if major >= 3:
         # return sndhwm, fallback on rcvhwm
         try:
             return self.getsockopt(zmq.SNDHWM)
         except zmq.ZMQError as e:
             pass
         
         return self.getsockopt(zmq.RCVHWM)
     else:
         return self.getsockopt(zmq.HWM)
Beispiel #38
0
 def test_proxy_steerable_bind_to_random_with_args(self):
     if zmq.zmq_version_info() < (4, 1):
         raise SkipTest("Steerable Proxies only in libzmq >= 4.1")
     dev = devices.ThreadProxySteerable(zmq.PULL, zmq.PUSH, zmq.PUSH,
                                        zmq.PAIR)
     iface = 'tcp://127.0.0.1'
     ports = []
     min, max = 5000, 5050
     ports.extend([
         dev.bind_in_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_out_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_mon_to_random_port(iface, min_port=min, max_port=max),
         dev.bind_ctrl_to_random_port(iface, min_port=min, max_port=max),
     ])
     for port in ports:
         if port < min or port > max:
             self.fail('Unexpected port number: %i' % port)
Beispiel #39
0
 def connect_or_bind(self, name, endpoint):
     if self.socket is None:
         self.socket = self.context.socket(self.socket_type)
     if self.routing_id:
         self.socket.identity = self.routing_id
     if self.socket_type == zmq.ROUTER:
         self.socket.ROUTER_MANDATORY = True
         if zmq.zmq_version_info() >= (4, 1, 0):
             self.socket.ROUTER_HANDOVER = True
     elif self.socket_type == zmq.REQ:
         self.socket.RCVTIMEO = int(self.timeout * 1000)
     self.socket.SNDTIMEO = int(self.timeout * 1000)
     self.auth_backend.configure()
     self.heartbeat_backend.configure()
     caller = operator.methodcaller(name, endpoint)
     caller(self.socket)
     self.initialized = True
Beispiel #40
0
 def __init__(self, context=None, encoding='utf-8', log=None):
     if zmq.zmq_version_info() < (4, 0):
         raise NotImplementedError(
             "Security is only available in libzmq >= 4.0")
     self.context = context or zmq.Context.instance()
     self.encoding = encoding
     self.allow_any = False
     self.zap_socket = None
     self.whitelist = set()
     self.blacklist = set()
     # passwords is a dict keyed by domain and contains values
     # of dicts with username:password pairs.
     self.passwords = {}
     # certs is dict keyed by domain and contains values
     # of dicts keyed by the public keys from the specified location.
     self.certs = {}
     self.log = log or logging.getLogger('zmq.auth')
Beispiel #41
0
def set_tcp_keepalive(sock, opts=None):
    # Warn if ZMQ < 3.2
    try:
        zmq_version_info = zmq.zmq_version_info()
    except AttributeError:
        # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
        # using zmq.zmq_version() and build a version info tuple.
        zmq_version_info = tuple(
            [int(x) for x in zmq.zmq_version().split('.')]
        )
    if zmq_version_info < (3, 2):
        log.warning(
            'You have a version of ZMQ less than ZMQ 3.2! There are '
            'known connection keep-alive issues with ZMQ < 3.2 which '
            'may result in loss of contact with minions. Please '
            'upgrade your ZMQ!'
        )
    ####
    # try:
    #     ip=socket.gethostbyname(socket.gethostname())
    #     if ip == "127.0.0.1":
    #         raise Exception("127.0.0.1")
    # except Exception,e:
    #     (status,ip) = commands.getstatusoutput("/sbin/ifconfig -a|grep inet|grep -v 127.0.0.1|grep -v inet6|awk '{print $2}'|tr -d 'addr:'")
    #     ip = ip
    if opts['ha'] == True:
        while True:
            time.sleep(5)
            try:
                sys.path.append("/usr/lib/python2.7/site-packages/salt")
                from zkclient import ZKClient, zookeeper, watchmethod
                zk = ZKClient('172.16.163.14:2181',1000)
                if zk.exists('/broker'):
                    value = zk.get('/broker')
                    logging.error(str(value[0]))
                    if value[0] == opts['id']:
                        break
                else:
                    zk.create('/broker')
                    zk.set('/broker',data='%s'%opts['id'])
                    logging.error("create the zk path is successful !")
                    continue
            except Exception,e:
                logging.error(str(e))
                continue
Beispiel #42
0
    def test_server_can_send_to_trustable_peer_identity(self):
        """
        Uses internal metadata of zmq.Frame.get() to fetch identity of sender
        """
        from pseud import Client, Server

        server_id = b'server'
        endpoint = b'tcp://127.0.0.1:8989'
        server_public, server_secret = zmq.curve_keypair()
        security_plugin = 'trusted_curve'

        server = Server(server_id,
                        security_plugin=security_plugin,
                        public_key=server_public,
                        secret_key=server_secret,
                        io_loop=self.io_loop)
        server.bind(endpoint)

        bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
        client = Client(server_id,
                        user_id=b'bob',
                        security_plugin=security_plugin,
                        public_key=bob_public,
                        secret_key=bob_secret,
                        peer_public_key=server_public,
                        io_loop=self.io_loop)
        client.connect(endpoint)
        assert server.socket.mechanism == zmq.CURVE
        assert client.socket.mechanism == zmq.CURVE

        yield server.start()
        yield client.start()

        @server.register_rpc(with_identity=True)
        def echo(peer_identity, message):
            return peer_identity, message

        result = yield client.echo(b'one')
        if zmq.zmq_version_info() >= (4, 1, 0):
            assert result == (b'bob', b'one')
        else:
            assert result == (b'', b'one')
        server.stop()
        client.stop()
Beispiel #43
0
    def setUp(self):
        super(TestIOLoopAuthentication, self).setUp()
        if zmq.zmq_version_info() < (4,0):
            raise SkipTest("security is new in libzmq 4.0")

        # silence auth module debug log output during test runs
        logger = logging.getLogger()
        self.original_log_level = logger.getEffectiveLevel()
        logger.setLevel(logging.DEBUG)

        self.test_result = True
        self.io_loop = ioloop.IOLoop()
        self.auth = None
        self.server = self.socket(zmq.PUSH)
        self.client = self.socket(zmq.PULL)
        # Only need slow reconnect intervals for testing.
        self.client.reconnect_ivl = 1000
        self.pushstream = zmqstream.ZMQStream(self.server, self.io_loop)
        self.pullstream = zmqstream.ZMQStream(self.client, self.io_loop)
Beispiel #44
0
 def __init__(self, opts):
     '''
     Create a salt broker instance
     '''
     self.opts = opts
     # Warn if ZMQ < 3.2
     try:
         zmq_version_info = zmq.zmq_version_info()
     except AttributeError:
         # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
         # using zmq.zmq_version() and build a version info tuple.
         zmq_version_info = tuple(
             [int(x) for x in zmq.zmq_version().split('.')])
     if zmq_version_info < (3, 2):
         log.warning(
             'You have a version of ZMQ less than ZMQ 3.2! There are '
             'known connection keep-alive issues with ZMQ < 3.2 which '
             'may result in loss of contact with minions. Please '
             'upgrade your ZMQ!')
Beispiel #45
0
    def test_server_can_send_to_trustable_peer_identity(self):
        """
        Uses internal metadata of zmq.Frame.get() to fetch identity of sender
        """
        from pseud import Client, Server

        server_id = b'server'
        endpoint = b'tcp://127.0.0.1:8989'
        server_public, server_secret = zmq.curve_keypair()
        security_plugin = 'trusted_curve'

        server = Server(server_id, security_plugin=security_plugin,
                        public_key=server_public,
                        secret_key=server_secret,
                        io_loop=self.io_loop)
        server.bind(endpoint)

        bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
        client = Client(server_id,
                        user_id=b'bob',
                        security_plugin=security_plugin,
                        public_key=bob_public,
                        secret_key=bob_secret,
                        peer_public_key=server_public,
                        io_loop=self.io_loop)
        client.connect(endpoint)
        assert server.socket.mechanism == zmq.CURVE
        assert client.socket.mechanism == zmq.CURVE

        yield server.start()
        yield client.start()

        @server.register_rpc(with_identity=True)
        def echo(peer_identity, message):
            return peer_identity, message

        result = yield client.echo(b'one')
        if zmq.zmq_version_info() >= (4, 1, 0):
            assert result == (b'bob', b'one')
        else:
            assert result == (b'', b'one')
        server.stop()
        client.stop()
Beispiel #46
0
    def get_monitor_socket(self, events=None, addr=None):
        """Return a connected PAIR socket ready to receive the event notifications.
        
        .. versionadded:: libzmq-4.0
        .. versionadded:: 14.0
        
        Parameters
        ----------
        events : int [default: ZMQ_EVENTS_ALL]
            The bitmask defining which events are wanted.
        addr :  string [default: None]
            The optional endpoint for the monitoring sockets.

        Returns
        -------
        socket :  (PAIR)
            The socket is already connected and ready to receive messages.
        """
        # safe-guard, method only available on libzmq >= 4
        if zmq.zmq_version_info() < (4, ):
            raise NotImplementedError(
                "get_monitor_socket requires libzmq >= 4, have %s" %
                zmq.zmq_version())

        # if already monitoring, return existing socket
        if self._monitor_socket:
            if self._monitor_socket.closed:
                self._monitor_socket = None
            else:
                return self._monitor_socket

        if addr is None:
            # create endpoint name from internal fd
            addr = "inproc://monitor.s-%d" % self.FD
        if events is None:
            # use all events
            events = zmq.EVENT_ALL
        # attach monitoring socket
        self.monitor(addr, events)
        # create new PAIR socket and connect it
        self._monitor_socket = self.context.socket(zmq.PAIR)
        self._monitor_socket.connect(addr)
        return self._monitor_socket
Beispiel #47
0
    def test_router_router(self):
        """test router-router MQ devices"""
        dev = devices.ThreadMonitoredQueue(zmq.ROUTER, zmq.ROUTER, zmq.PUB,
                                           b'in', b'out')
        self.device = dev
        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 = b'a'
        b = self.context.socket(zmq.DEALER)
        b.identity = b'b'
        self.sockets.extend([a, 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)
        if zmq.zmq_version_info() >= (3, 1, 0):
            # flush erroneous poll state, due to LIBZMQ-280
            ping_msg = [b'ping', b'pong']
            for s in (a, b):
                s.send_multipart(ping_msg)
                try:
                    s.recv(zmq.NOBLOCK)
                except zmq.ZMQError:
                    pass
        msg = [b'hello', b'there']
        a.send_multipart([b'b'] + msg)
        bmsg = self.recv_multipart(b)
        self.assertEqual(bmsg, [b'a'] + msg)
        b.send_multipart(bmsg)
        amsg = self.recv_multipart(a)
        self.assertEqual(amsg, [b'b'] + msg)
        self.teardown_device()
Beispiel #48
0
    def open(self):
        if self._socket and not self._socket.closed:
            self.close()

        self._socket = self._context.socket(self._qtype)

        if zmq.zmq_version_info()[0] == 2:
            self._socket.setsockopt(zmq.HWM, self._hwm)
        else:
            self._socket.setsockopt(zmq.SNDHWM, self._hwm)
            self._socket.setsockopt(zmq.RCVHWM, self._hwm)

        if not self._attach:
            if self._qtype in (zmq.PUB, zmq.REP, zmq.PUSH):
                self._attach = BIND
            elif self._qtype in (zmq.SUB, zmq.REQ, zmq.PULL):
                self._attach = CONNECT

        for a in self._addr:
            if self._attach == BIND:
                self._socket.bind(a)
                log.debug('bind: %s HWM=%d' % (a, self._hwm))
                time.sleep(0.5)  # HACK: need proper startup here
            elif self._attach == CONNECT:
                if self._ssh_key and self._ssh_conn:
                    zmq.ssh.tunnel_connection(self._socket,
                                              a,
                                              server=self._ssh_conn,
                                              keyfile=self._ssh_key,
                                              paramiko=self._use_paramiko)
                    log.debug('tunnel_connection: %s HWM=%d, server=%s' %
                              (a, self._hwm, self._ssh_conn))
                else:
                    self._socket.connect(a)
                    log.debug('connect: %s HWM=%d' % (a, self._hwm))
            else:
                raise Exception(
                    'Invalid attachment type %s. Use BIND or CONNECT.' %
                    (str(self._attach), ))

        if self._qtype == zmq.SUB:
            self._socket.setsockopt(zmq.SUBSCRIBE, '')
Beispiel #49
0
 def test_router_router(self):
     """test router-router MQ devices"""
     dev = devices.ThreadMonitoredQueue(zmq.ROUTER, zmq.ROUTER, zmq.PUB, b'in', b'out')
     self.device = dev
     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(1)
     a = self.context.socket(zmq.DEALER)
     a.identity = b'a'
     b = self.context.socket(zmq.DEALER)
     b.identity = b'b'
     self.sockets.extend([a, 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(1)
     if zmq.zmq_version_info() >= (3,1,0):
         # flush erroneous poll state, due to LIBZMQ-280
         ping_msg = [ b'ping', b'pong' ]
         for s in (a,b):
             s.send_multipart(ping_msg)
             try:
                 s.recv(zmq.NOBLOCK)
             except zmq.ZMQError:
                 pass
     msg = [ b'hello', b'there' ]
     a.send_multipart([b'b']+msg)
     bmsg = self.recv_multipart(b)
     self.assertEqual(bmsg, [b'a']+msg)
     b.send_multipart(bmsg)
     amsg = self.recv_multipart(a)
     self.assertEqual(amsg, [b'b']+msg)
     self.teardown_device()
Beispiel #50
0
    def monitor(self, addr, events=-1):
        """s.monitor(addr, flags)

        Start publishing socket events on inproc.
        See libzmq docs for zmq_monitor for details.
        
        Note: requires libzmq >= 3.2
        
        Parameters
        ----------
        addr : str
            The inproc url used for monitoring.
        events : int [default: zmq.EVENT_ALL]
            The zmq event bitmask for which events will be sent to the monitor.
        """
        if zmq.zmq_version_info() < (3,2):
            raise NotImplementedError("monitor requires libzmq >= 3.2, have %s" % zmq.zmq_version())
        if events < 0:
            events = zmq.EVENT_ALL
        rc = C.zmq_socket_monitor(self._zmq_socket, addr, events)
 def test_proxy_steerable_statistics(self):
     if zmq.zmq_version_info() < (4, 3):
         raise SkipTest("STATISTICS only in libzmq >= 4.3")
     dev = devices.ThreadProxySteerable(zmq.PULL, zmq.PUSH, zmq.PUSH,
                                        zmq.PAIR)
     binder = self.context.socket(zmq.REQ)
     iface = 'tcp://127.0.0.1'
     port = binder.bind_to_random_port(iface)
     port2 = binder.bind_to_random_port(iface)
     port3 = binder.bind_to_random_port(iface)
     port4 = binder.bind_to_random_port(iface)
     binder.close()
     time.sleep(0.1)
     dev.bind_in("%s:%i" % (iface, port))
     dev.bind_out("%s:%i" % (iface, port2))
     dev.bind_mon("%s:%i" % (iface, port3))
     dev.bind_ctrl("%s:%i" % (iface, port4))
     dev.start()
     time.sleep(0.25)
     msg = b'hello'
     push = self.context.socket(zmq.PUSH)
     push.connect("%s:%i" % (iface, port))
     pull = self.context.socket(zmq.PULL)
     pull.connect("%s:%i" % (iface, port2))
     mon = self.context.socket(zmq.PULL)
     mon.connect("%s:%i" % (iface, port3))
     ctrl = self.context.socket(zmq.PAIR)
     ctrl.connect("%s:%i" % (iface, port4))
     push.send(msg)
     self.sockets.extend([push, pull, mon, ctrl])
     self.assertEqual(msg, self.recv(pull))
     self.assertEqual(msg, self.recv(mon))
     ctrl.send(b'STATISTICS')
     stats = self.recv_multipart(ctrl)
     stats_int = [struct.unpack("<Q", x)[0] for x in stats]
     self.assertEqual(1, stats_int[0])
     self.assertEqual(len(msg), stats_int[1])
     self.assertEqual(1, stats_int[6])
     self.assertEqual(len(msg), stats_int[7])
     ctrl.send(b'TERMINATE')
     dev.join()
    def test_curve_public(self):
        """test curve_public"""
        try:
            public, secret = zmq.curve_keypair()
        except zmq.ZMQError:
            raise SkipTest("CURVE unsupported")
        if zmq.zmq_version_info() < (4, 2):
            raise SkipTest("curve_public is new in libzmq 4.2")

        derived_public = zmq.curve_public(secret)

        self.assertEqual(type(derived_public), bytes)
        self.assertEqual(len(derived_public), 40)

        # verify that it is indeed Z85
        bpublic = z85.decode(derived_public)
        self.assertEqual(type(bpublic), bytes)
        self.assertEqual(len(bpublic), 32)

        # verify that it is equal to the known public key
        self.assertEqual(derived_public, public)
Beispiel #53
0
 def test_proxy(self):
     if zmq.zmq_version_info() < (3, 2):
         raise SkipTest("Proxies only in libzmq >= 3")
     dev = devices.ThreadProxy(zmq.PULL, zmq.PUSH, zmq.PUSH)
     iface = 'tcp://10.0.0.7'
     port = dev.bind_in_to_random_port(iface)
     port2 = dev.bind_out_to_random_port(iface)
     port3 = dev.bind_mon_to_random_port(iface)
     dev.start()
     time.sleep(0.25)
     msg = b'hello'
     push = self.context.socket(zmq.PUSH)
     push.connect("%s:%i" % (iface, port))
     pull = self.context.socket(zmq.PULL)
     pull.connect("%s:%i" % (iface, port2))
     mon = self.context.socket(zmq.PULL)
     mon.connect("%s:%i" % (iface, port3))
     push.send(msg)
     self.sockets.extend([push, pull, mon])
     self.assertEqual(msg, self.recv(pull))
     self.assertEqual(msg, self.recv(mon))
 def set_hwm(self, value):
     """set the High Water Mark
     
     On libzmq ≥ 3.x, this sets *both* SNDHWM and RCVHWM
     """
     major = zmq.zmq_version_info()[0]
     if major >= 3:
         raised = None
         try:
             self.sndhwm = value
         except Exception as e:
             raised = e
         try:
             self.rcvhwm = value
         except Exception:
             raised = e
         
         if raised:
             raise raised
     else:
         return self.setsockopt(zmq.HWM, value)
Beispiel #55
0
 def set_hwm(self, value):
     """set the High Water Mark
     
     On libzmq ≥ 3.x, this sets *both* SNDHWM and RCVHWM
     """
     major = zmq.zmq_version_info()[0]
     if major >= 3:
         raised = None
         try:
             self.sndhwm = value
         except Exception as e:
             raised = e
         try:
             self.rcvhwm = value
         except Exception:
             raised = e
         
         if raised:
             raise raised
     else:
         return self.setsockopt(zmq.HWM, value)
Beispiel #56
0
    def __init__(self, broker, conf=None, context=None, io_loop = None):

        if zmq.zmq_version_info() < (4, 0):
            raise RuntimeError("monitoring in libzmq version < 4.0 is not supported")

        conf = conf or {}
        self._conf = dict(
            autostart=conf.get('autostart') or False,
            reconnect=conf.get('reconnect') or 1000,
            heartbeat=conf.get('heartbeat') or 2500,
            timeout=conf.get('timeout') or 60000,
            retry=0,
            prefix='C{0}'.format(uuid4())
        )

        print('client id {0}'.format( self._conf.get('prefix')))
        self._liveness = HEARTBEAT_LIVENESS
        self._broker = broker
        self._loop = io_loop or ioloop.IOLoop.current()
        self._ctx = context or zmq.Context.instance()
        self._reqs = dict()

        if self._conf['autostart']:
            self.start()
def zmq_has_curve():
    """
    Return whether the current ZMQ has support for auth and CurveZMQ security.

    :rtype: bool

     Version notes:
       `zmq.curve_keypair()` is new in version 14.0, new in version libzmq-4.0.
            Requires libzmq (>= 4.0) to have been linked with libsodium.
       `zmq.auth` module is new in version 14.1
       `zmq.has()` is new in version 14.1, new in version libzmq-4.1.
    """
    if platform.system() == "Windows":
        # TODO: curve is not working on windows #7919
        return False

    zmq_version = zmq.zmq_version_info()
    pyzmq_version = zmq.pyzmq_version_info()

    if pyzmq_version >= (14, 1, 0) and zmq_version >= (4, 1):
        return zmq.has('curve')

    if pyzmq_version < (14, 1, 0):
        return False

    if zmq_version < (4, 0):
        # security is new in libzmq 4.0
        return False

    try:
        zmq.curve_keypair()
    except zmq.error.ZMQError:
        # security requires libzmq to be linked against libsodium
        return False

    return True
Beispiel #58
0
import zlib
import os
import time
from tempfile import mkstemp

import six
from six.moves import cPickle as pickle
import snappy
from zmq import constants, error, Socket, ZMQError
from zope.interface import implementer
from twisted.internet import reactor
from twisted.internet.interfaces import IFileDescriptor, IReadDescriptor
from twisted.python import log
from zmq import zmq_version_info

ZMQ3 = zmq_version_info()[0] >= 3

from veles.txzmq.manager import ZmqContextManager
from veles.txzmq.sharedio import SharedIO

from veles.compat import lzma, from_none
from veles.logger import Logger
from veles.pickle2 import best_protocol


class ZmqEndpointType(object):
    """
    Endpoint could be "bound" or "connected".
    """
    bind = "bind"
    """