def test_pyzmq_version_info(self):
     version = zmq.sugar.version
     save = version.__version__
     try:
         version.__version__ = '2.10dev'
         info = zmq.pyzmq_version_info()
         self.assertTrue(isinstance(info, tuple))
         self.assertEquals(len(info), 3)
         self.assertTrue(info > (2,10,99))
         self.assertEquals(info, (2,10,float('inf')))
         version.__version__ = '2.1.10'
         info = zmq.pyzmq_version_info()
         self.assertEquals(info, (2,1,10))
         self.assertTrue(info > (2,1,9))
     finally:
         version.__version__ = save

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

def check_for_pyzmq():
    try:
        import zmq
    except ImportError:
        print_status('pyzmq', "no (required for qtconsole, notebook, and parallel computing capabilities)")
        return False
    else:
        # pyzmq 2.1.10 adds pyzmq_version_info funtion for returning
        # version as a tuple
        if hasattr(zmq, 'pyzmq_version_info'):
            if zmq.pyzmq_version_info() >= (2,1,4):
                print_status("pyzmq", zmq.__version__)
                return True
            else:
                # this branch can never occur, at least until we update our
                # pyzmq dependency beyond 2.1.10
                return False
        # this is necessarily earlier than 2.1.10, so string comparison is
        # okay
        if zmq.__version__ < '2.1.4':
            print_status('pyzmq', "no (have %s, but require >= 2.1.4 for"
            " qtconsole and parallel computing capabilities)"%zmq.__version__)
            return False
        else:
            print_status("pyzmq", zmq.__version__)
            return True

    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

 def test_pyzmq_version_info(self):
     info = zmq.pyzmq_version_info()
     self.assertTrue(isinstance(info, tuple))
     for n in info[:3]:
         self.assertTrue(isinstance(n, int))
     if version.VERSION_EXTRA:
         self.assertEqual(len(info), 4)
         self.assertEqual(info[-1], float('inf'))
     else:
         self.assertEqual(len(info), 3)

 def init_signal(self):
     # FIXME: remove this check when pyzmq dependency is >= 2.1.11
     # safely extract zmq version info:
     try:
         zmq_v = zmq.pyzmq_version_info()
     except AttributeError:
         zmq_v = [ int(n) for n in re.findall(r'\d+', zmq.__version__) ]
         if 'dev' in zmq.__version__:
             zmq_v.append(999)
         zmq_v = tuple(zmq_v)
     if zmq_v >= (2,1,9):
         # This won't work with 2.1.7 and
         # 2.1.9-10 will log ugly 'Interrupted system call' messages,
         # but it will work
         signal.signal(signal.SIGINT, self._handle_sigint)
     signal.signal(signal.SIGTERM, self._signal_stop)

def check_for_pyzmq():
    try:
        import zmq
    except ImportError:
        print_status('pyzmq', "no (required for qtconsole, notebook, and parallel computing capabilities)")
        return False
    else:
        # pyzmq 2.1.10 adds pyzmq_version_info funtion for returning
        # version as a tuple
        if hasattr(zmq, 'pyzmq_version_info') and zmq.pyzmq_version_info() >= (2,1,11):
                print_status("pyzmq", zmq.__version__)
                return True
        else:
            print_status('pyzmq', "no (have %s, but require >= 2.1.11 for"
            " qtconsole, notebook, and parallel computing capabilities)" % zmq.__version__)
            return False

 def init_signal(self):
     # FIXME: remove this check when pyzmq dependency is >= 2.1.11
     # safely extract zmq version info:
     try:
         zmq_v = zmq.pyzmq_version_info()
     except AttributeError:
         zmq_v = [ int(n) for n in re.findall(r'\d+', zmq.__version__) ]
         if 'dev' in zmq.__version__:
             zmq_v.append(999)
         zmq_v = tuple(zmq_v)
     if zmq_v >= (2,1,9) and not sys.platform.startswith('win'):
         # This won't work with 2.1.7 and
         # 2.1.9-10 will log ugly 'Interrupted system call' messages,
         # but it will work
         signal.signal(signal.SIGINT, self._handle_sigint)
     signal.signal(signal.SIGTERM, self._signal_stop)
     if hasattr(signal, 'SIGUSR1'):
         # Windows doesn't support SIGUSR1
         signal.signal(signal.SIGUSR1, self._signal_info)
     if hasattr(signal, 'SIGINFO'):
         # only on BSD-based systems
         signal.signal(signal.SIGINFO, self._signal_info)

    def get_esky_freezer_includes(self):
        # Sometimes the auto module traversal doesn't find everything, so we
        # explicitly add it. The auto dependency tracking especially does not work for
        # imports occurring in salt.modules, as they are loaded at salt runtime.
        # Specifying includes that don't exist doesn't appear to cause a freezing
        # error.
        freezer_includes = [
            'zmq.core.*',
            'zmq.utils.*',
            'ast',
            'csv',
            'difflib',
            'distutils',
            'distutils.version',
            'numbers',
            'json',
            'M2Crypto',
            'Cookie',
            'asyncore',
            'fileinput',
            'sqlite3',
            'email',
            'email.mime.*',
            'requests',
            'sqlite3',
        ]
        if HAS_ZMQ and hasattr(zmq, 'pyzmq_version_info'):
            if HAS_ZMQ and zmq.pyzmq_version_info() >= (0, 14):
                # We're freezing, and when freezing ZMQ needs to be installed, so this
                # works fine
                if 'zmq.core.*' in freezer_includes:
                    # For PyZMQ >= 0.14, freezing does not need 'zmq.core.*'
                    freezer_includes.remove('zmq.core.*')

        if IS_WINDOWS_PLATFORM:
            freezer_includes.extend([
                'imp',
                'win32api',
                'win32file',
                'win32con',
                'win32com',
                'win32net',
                'win32netcon',
                'win32gui',
                'win32security',
                'ntsecuritycon',
                'pywintypes',
                'pythoncom',
                '_winreg',
                'wmi',
                'site',
                'psutil',
            ])
        elif sys.platform.startswith('linux'):
            freezer_includes.append('spwd')
            try:
                import yum  # pylint: disable=unused-variable
                freezer_includes.append('yum')
            except ImportError:
                pass
        elif sys.platform.startswith('sunos'):
            # (The sledgehammer approach)
            # Just try to include everything
            # (This may be a better way to generate freezer_includes generally)
            try:
                from bbfreeze.modulegraph.modulegraph import ModuleGraph
                mgraph = ModuleGraph(sys.path[:])
                for arg in glob.glob('salt/modules/*.py'):
                    mgraph.run_script(arg)
                for mod in mgraph.flatten():
                    if type(mod).__name__ != 'Script' and mod.filename:
                        freezer_includes.append(str(os.path.basename(mod.identifier)))
            except ImportError:
                pass
            # Include C extension that convinces esky to package up the libsodium C library
            # This is needed for ctypes to find it in libnacl which is in turn needed for raet
            # see pkg/smartos/esky/sodium_grabber{.c,_installer.py}
            freezer_includes.extend([
                'sodium_grabber',
                'ioflo',
                'raet',
                'libnacl',
            ])
        return freezer_includes

    'ast',
    'difflib',
    'distutils',
    'distutils.version',
    'numbers',
    'json',
    'M2Crypto',
    'Cookie',
    'asyncore',
    'fileinput',
    'email',
    'email.mime.*',
]

if HAS_ZMQ and hasattr(zmq, 'pyzmq_version_info'):
    if HAS_ZMQ and zmq.pyzmq_version_info() >= (0, 14):
        # We're freezing, and when freezing ZMQ needs to be installed, so this
        # works fine
        if 'zmq.core.*' in FREEZER_INCLUDES:
            # For PyZMQ >= 0.14, freezing does not need 'zmq.core.*'
            FREEZER_INCLUDES.remove('zmq.core.*')

if IS_WINDOWS_PLATFORM:
    FREEZER_INCLUDES.extend([
        'win32api',
        'win32file',
        'win32con',
        'win32com',
        'win32net',
        'win32netcon',
        'win32gui',

    # The socket monitor can be explicitly disabled if necessary.
    # yield from ct.disable_monitor()

    # If a socket monitor is left enabled on a socket being closed,
    # the socket monitor will be closed automatically.
    ct.close()
    yield from cp.wait_closed

    st.close()
    yield from sp.wait_closed


def main():
    asyncio.get_event_loop().run_until_complete(go())
    print("DONE")


if __name__ == '__main__':
    # import logging
    # logging.basicConfig(level=logging.DEBUG)

    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()))

    main()