def run(self):
        """Run the test suite, with nose, or unittest if nose is unavailable"""
        # crude check for inplace build:
        try:
            import zmq
        except ImportError:
            print_exc()
            fatal(
                "\n       ".join(
                    [
                        "Could not import zmq!",
                        "You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
                        "If you did build pyzmq in-place, then this is a real error.",
                    ]
                )
            )
            sys.exit(1)

        info("Testing pyzmq-%s with libzmq-%s" % (zmq.pyzmq_version(), zmq.zmq_version()))

        if nose is None:
            warn("nose unavailable, falling back on unittest. Skipped tests will appear as ERRORs.")
            return self.run_unittest()
        else:
            return self.run_nose()

    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 main():
    # Parse command line args.
    parser = argparse.ArgumentParser(description='Calico ACL Manager')
    parser.add_argument('-c', '--config-file', dest='config_file')
    args = parser.parse_args()

    # Read config file.
    config = ConfigParser.ConfigParser()
    config.read(args.config_file or 'acl_manager.cfg')
    plugin_address = config.get('global', 'PluginAddress')
    log_file_path = config.get('log', 'LogFilePath')

    # Configure logging.
    common.mkdir_p(os.path.dirname(log_file_path))
    logging.basicConfig(filename=log_file_path, level=logging.DEBUG)
    
    # Create ZeroMQ context.
    context = zmq.Context()
    log.info("pyzmq version is %s" % zmq.pyzmq_version())
    
    # Create and start components.
    acl_store = ACLStore()
    network_store = NetworkStore()
    
    publisher = ACLPublisher(context, acl_store)
    acl_store.start(publisher)

    processor = RuleProcessor(acl_store, network_store)
    network_store.add_processor(processor)
    
    subscriber = NetworkSubscriber(context, network_store, plugin_address)

    def _printheader(self, log):
        """Prints header to log file; inspired by that in GPAW."""
        log(logo)
        log('Amp: Atomistic Machine-learning Package')
        log('Developed by Andrew Peterson, Alireza Khorshidi, and others,')
        log('Brown University.')
        log(' PI Website: http://brown.edu/go/catalyst')
        log(' Official repository: http://bitbucket.org/andrewpeterson/amp')
        log(' Official documentation: http://amp.readthedocs.org/')
        log(' Citation:')
        log('  Khorshidi & Peterson, Computer Physics Communications')
        log('  doi:10.1016/j.cpc.2016.05.010 (2016)')
        log('=' * 70)
        log('User: %s' % getuser())
        log('Hostname: %s' % gethostname())
        log('Date: %s' % now(with_utc=True))
        uname = platform.uname()
        log('Architecture: %s' % uname[4])
        log('PID: %s' % os.getpid())
        log('Amp version: %s' % 'NOT NUMBERED YET.')  # FIXME/ap. Look at GPAW
        ampdirectory = os.path.dirname(os.path.abspath(__file__))
        log('Amp directory: %s' % ampdirectory)
        commithash, commitdate = get_git_commit(ampdirectory)
        log(' Last commit: %s' % commithash)
        log(' Last commit date: %s' % commitdate)
        log('Python: v{0}.{1}.{2}: %s'.format(*sys.version_info[:3]) %
            sys.executable)
        log('ASE v%s: %s' % (aseversion, os.path.dirname(ase.__file__)))
        log('NumPy v%s: %s' %
            (np.version.version, os.path.dirname(np.__file__)))
        # SciPy is not a strict dependency.
        try:
            import scipy
            log('SciPy v%s: %s' %
                (scipy.version.version, os.path.dirname(scipy.__file__)))
        except ImportError:
            log('SciPy: not available')
        # ZMQ an pxssh are only necessary for parallel calculations.
        try:
            import zmq
            log('ZMQ/PyZMQ v%s/v%s: %s' %
                (zmq.zmq_version(), zmq.pyzmq_version(),
                 os.path.dirname(zmq.__file__)))
        except ImportError:
            log('ZMQ: not available')
        try:
            import pxssh
            log('pxssh: %s' % os.path.dirname(pxssh.__file__))
        except ImportError:
            log('pxssh: Not available from pxssh.')
            try:
                from pexpect import pxssh
            except ImportError:
                log('pxssh: Not available from pexpect.')
            else:
                import pexpect
                log('pxssh (via pexpect v%s): %s' %
                    (pexpect.__version__, pxssh.__file__))

        log('=' * 70)

    def __init__(self, port, require_settings=False):
        """ Constructor
        - port      : the 0mq communication port
        """
        # Setup the 0mq channel.
        self.__context = zmq.Context()
        self.__socket = self.__context.socket(zmq.PAIR)
        print "{}: (pyzmq version: {}) started on: tcp://127.0.0.1:{}"\
            .format(self.__class__.__name__, zmq.pyzmq_version(), port)
        self.__socket.connect("{}:{}".format(
            BaseService.__HOST_ADDRESS, port))

        # Initialize state.
        self.__enabled = False
        self.__shutting_down = False
        self._state = None
        self._update_state()

        # Setup service if possible.
        if not require_settings:
            self._setup()
            self.__initialized = True
        else:
            self.__initialized = False

        # Setup setting handling.
        self.__setting_store = SettingsStore()

 def __init__(self):
   Tool.__init__(self)
   
   # * Initialize ZMQ context and open subscriber, publisher sockets
   self.logger.debug("ZMQ version: {}, PyZMQ version: {}".format(zmq.zmq_version(), zmq.pyzmq_version()))
   # ** Context
   self.zmqContext = zmq.Context()
   # ** Subscriber
   self.subSocket = self.zmqContext.socket(zmq.SUB)
   self.subSocket.connect(self.sub_address)
   time.sleep(0.005)  # mandatory sleep for ZMQ backend
   self.logger.debug("[sub] Connected to {}".format(self.sub_address))
   # ** Subscriber topics for input messages
   self.subSocket.setsockopt(zmq.SUBSCRIBE, self.sub_topic)
   self.subSocket.setsockopt(zmq.LINGER, self.sub_socket_linger)
   self.logger.debug("[sub]Subscribed to topic \"{}\"".format(self.sub_topic))
   time.sleep(0.005)  # mandatory sleep for ZMQ backend
   # ** Publisher
   self.pubSocket = self.zmqContext.socket(zmq.PUB)
   self.pubSocket.bind(self.pub_address)
   time.sleep(0.005)  # mandatory sleep for ZMQ backend
   self.logger.debug("[pub] Bound to {}".format(self.pub_address))
   
   # * Initialize other members
   self.valid = False
   self.buttons = [0, 0]  # primary, secondary
   self.transform = hm.translation(hm.identity(), self.position_offset)
   #self.position = self.position_offset
   self.loop = True  # TODO ensure this is properly shared across threads
   
   # * Start sensing loop
   self.senseThread = Thread(target=self.senseLoop)
   self.senseThread.daemon = True  # to prevent indefinite wait on recv()
   self.senseThread.start()
   time.sleep(0.005)  # sleep to allow child thread to run

 def test_pyzmq_version(self):
     vs = zmq.pyzmq_version()
     vs2 = zmq.__version__
     self.assertTrue(isinstance(vs, str))
     if zmq.__revision__:
         self.assertEquals(vs, '@'.join(vs2, zmq.__revision__))
     else:
         self.assertEquals(vs, vs2)

def print_info():
    log.info("Python version: %s, %s",
             '.'.join((str(e) for e in sys.version_info)),
             sys.executable)

    log.info("zeromq version: %s", zmq.zmq_version())
    log.info("pyzmq version:  %s", zmq.pyzmq_version())
    log.info("track version:  %s", str(track_base.version_info))

 def test_pyzmq_version(self):
     vs = zmq.pyzmq_version()
     vs2 = zmq.__version__
     self.assertTrue(isinstance(vs, str))
     if zmq.__revision__:
         self.assertEqual(vs, '@'.join(vs2, zmq.__revision__))
     else:
         self.assertEqual(vs, vs2)
     if version.VERSION_EXTRA:
         self.assertTrue(version.VERSION_EXTRA in vs)
         self.assertTrue(version.VERSION_EXTRA in vs2)

def log_versions(logger):
    logger.info(
        'Versions:\n'
        '  PyZMQ: %s\n'
        '  libzmq: %s\n'
        '  Tornado: %s\n'
        '  SockJS-Tornado: Not Available\n'  # TODO find the verison
        '  SockJS-ZMQProxy: %s\n',
        zmq.pyzmq_version(),
        zmq.zmq_version(),
        tornado_version,
        version
    )

 def run(self):
     """Run the test suite with py.test"""
     # crude check for inplace build:
     try:
         import zmq
     except ImportError:
         print_exc()
         fatal('\n       '.join(["Could not import zmq!",
         "You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
         "If you did build pyzmq in-place, then this is a real error."]))
         sys.exit(1)
     
     info("Testing pyzmq-%s with libzmq-%s" % (zmq.pyzmq_version(), zmq.zmq_version()))
     p = Popen([sys.executable, '-m', 'pytest', '-v', os.path.join('zmq', 'tests')])
     p.wait()
     sys.exit(p.returncode)

 def level_1(info):
     # print header (some general info)
     info += ["name: %s" % self.job_name]
     info += ["version: %s" % getattr(self, "__version__", "")]
     info += ["service: %s" % self.service_name]
     info += ["pid: %i" % os.getpid()]
     info += ["started: %s" % strftime(getattr(self, "started", ""))]
     info += ["status: %s" % getattr(self, "status", "")]
     info += ["time-consumed: %s" % " ".join(map(str, os.times()[:4]))]
     info += ["info-period: %s" % self.stats_period]
     info += ["info-written: %s" % strftime(time.time())]
     info += ["platform: %s" % platform.platform()]
     info += ["python: %s" % platform.python_version()]
     info += ["skytools: %s" % skytools.__version__]
     info += ["libzmq: %s" % zmq.zmq_version()]
     info += ["pyzmq: %s" % zmq.pyzmq_version()]
     info += [""]

 def __init__(self, providerLocation):
     self._providerLocation = providerLocation
     self._context = zmq.Context()
     self._socket = self._context.socket(zmq.REQ)
     self._socket.connect(providerLocation)
     self._socket.setsockopt(zmq.LINGER, 0)
     self._lock = threading.Lock()
     self._closed = False
     self._activeAllocations = []
     self.call("handshake", versionInfo=dict(
         ASSET_VERSION=api.VERSION,
         ZERO_MQ=dict(
             PYZMQ_VERSION=zmq.pyzmq_version(),
             VERSION=zmq.VERSION,
             VERSION_MAJOR=zmq.VERSION_MAJOR,
             VERSION_MINOR=zmq.VERSION_MINOR,
             VERSION_PATCH=zmq.VERSION_PATCH)))
     self._connectionToProviderInterrupted = suicide.killSelf
     self._heartbeat = heartbeat.HeartBeat(self)

import zmq

STATE_PRIMARY = 1
STATE_BACKUP = 2
STATE_ACTIVE = 3
STATE_PASSIVE = 4

PEER_PRIMARY = 1
PEER_BACKUP = 2
PEER_ACTIVE = 3
PEER_PASSIVE = 4
CLIENT_REQUEST = 5

HEARTBEAT = 1000

pyzmq_version = tuple(map(int, zmq.pyzmq_version().split('.')))
if pyzmq_version <= (2, 1, 7):
    zmq.ROUTER = zmq.XREP


class BStarState(object):
    def __init__(self, state, event, peer_expiry):
        self.state = state
        self.event = event
        self.peer_expiry = peer_expiry


class BStarException(Exception):
    pass

fsm_states = {

def main():
    print zmq.zmq_version()
    print zmq.pyzmq_version()

def print_info():
    log.info("zeromq version: %s" % zmq.zmq_version())
    log.info("pyzmq version:  %s" % zmq.pyzmq_version())
    log.info("track version:  %s" % str(track_base.version_info))

    def __init__(self, pgm_group, screens=0, name=None, context=None,
                 error_handler=None):
        LOGGER.debug("ZMQ version: {0} PYZMQ version: {1}".\
                     format(zmq.zmq_version(), zmq.pyzmq_version()))
        # Check pgm_group
        if not pgm_group:
            pgm_group = 1
        pgm_ip = '239.128.128.{0}:5555'.format(pgm_group)
        LOGGER.debug('PGM IP {0}'.format(pgm_ip))

        #Create context
        self.context = context if context else zmq.Context()
        self.context.setsockopt(zmq.LINGER, 0)  # Set default linger value.

        #Create publisher
        self.publisher = self.context.socket(zmq.PUB)
        self.publisher_loopback = self.context.socket(zmq.PUB)
        self.ip = utils.GetLocalIPAddress(diwavars.STORAGE)
        LOGGER.info('Own IP: %s', self.ip)
        if self.ip:
            self.id = self.ip.split('.')[3]
        else:
            self.id = random.randint(1, 154)
        self.node = Node(int(self.id), int(screens), name)
        self.online = True

        # Prevent overflowing slow subscribers
        self.publisher.setsockopt(zmq.LINGER, 0)
        self.publisher.setsockopt(zmq.RATE, 1000000)
        self.publisher.set_hwm(5)
        self.publisher_loopback.setsockopt(zmq.LINGER, 0)
        self.publisher_loopback.set_hwm(50)

        # Bind publisher
        self.tladdr = 'epgm://' + self.ip + ';' + pgm_ip
        self.ipraddr = 'inproc://mcast_loopback'
        self.publisher.bind(self.tladdr)
        self.publisher_loopback.bind(self.ipraddr)
        # Subscriber threads
        targs = ([self.tladdr, self.ipraddr], )
        self.sub_thread = SWNP.start_sub_routine(None, self.sub_routine,
                                                 'Sub thread', targs)
        self.sub_thread_sys = SWNP.start_sub_routine(None,
                                                     self.sub_routine_sys,
                                                     'Sub sys thread', targs)
        LOGGER.debug('Bound listeners on: %s', str(self.tladdr))

        join_str = '{id}_SCREENS_{screens}_NAME_{name}_DATA_{_data}'
        join_str = join_str.format(**self.node.__dict__)
        self.send('SYS', PREFIX_CHOICES[0], join_str)
        self.last_joined = self.id
        self.NODE_LIST.add(self.node)
        self.do_ping()

        #heartbeat
        self.ping_stop = threading.Event()
        self.ping_thread = threading.Thread(
            target=self.ping_routine,
            name='Ping thread',
            args=(error_handler,)
        )
        self.ping_thread.daemon = True
        self.ping_thread.start()
        self.timeout_stop = threading.Event()
        self.timeout_thread = threading.Thread(target=self.timeout_routine,
                                               name='timeout thread')
        self.timeout_thread.daemon = True
        self.timeout_thread.start()

#initialize any zmq libs
import zmq
print zmq.pyzmq_version()
import time
import sys

port = "5556"

#we want to run the server on multiple ports(so request can be distributed)
if len(sys.argv) >1:
	port = sys.argv[1]
	print port
	int(port)
#multiple contexts can be created in an app.
#contexts are thread-safe unlike sockets
context = zmq.Context()

#create REP socket from the context
socket = context.socket(zmq.REP)
#bind socket to port
socket.bind("tcp://*:%s" % port)

while True:
	#wait for request
	message = socket.recv()
	print "Received client request" , message

	time.sleep(1)
	socket.send("Server got your request, here's your response from %s" %port)

import zmq

print(zmq.pyzmq_version())

 def test_version_available(self):
     self.assertIsNotNone(zmq.pyzmq_version())