def _init_context(self, context):
     self.context = context or zmq.Context.instance()
     if self.loop is None:
         ioloop.install()
         self.loop = ioloop.IOLoop.instance()
     self.ctrl = Controller(self.endpoint, self.multicast_endpoint,
                            self.context, self.loop, self, self.check_delay)

    def run(self):
        if self.filename == 'sys.stdout':
            self.file = sys.stdout
        elif self.filename == 'sys.stderr':
            self.file = sys.stderr
        else:
            self.file = open(self.filename, 'a+b')

        ioloop.install()
        loop = ioloop.IOLoop.instance()

        stream = None
        try:
            context = zmq.Context()
            socket = context.socket(zmq.SUB)
            socket.connect(self.addr)
            socket.setsockopt(zmq.SUBSCRIBE, '')
            stream = ZMQStream(socket)
        except Exception, err:
            print self.name, 'error getting outstream:', err
            exc_type, exc_value, exc_traceback = sys.exc_info()
            traceback.print_exception(exc_type, exc_value, exc_traceback)
            traceback.print_tb(exc_traceback, limit=30)
            if stream and not stream.closed():
                stream.close()

 def initialize(self, argv=None):
     super(IPKernelApp, self).initialize(argv)
     if self.subapp is not None:
         return
     # register zmq IOLoop with tornado
     zmq_ioloop.install()
     self.init_blackhole()
     self.init_connection_file()
     self.init_poller()
     self.init_sockets()
     self.init_heartbeat()
     # writing/displaying connection info must be *after* init_sockets/heartbeat
     self.write_connection_file()
     # Log connection info after writing connection file, so that the connection
     # file is definitely available at the time someone reads the log.
     self.log_connection_info()
     self.init_io()
     self.init_signal()
     self.init_kernel()
     # shell init steps
     self.init_path()
     self.init_shell()
     if self.shell:
         self.init_gui_pylab()
         self.init_extensions()
         self.init_code()
     # flush stdout/stderr, so that anything written to these streams during
     # initialization do not get associated with the first execution request
     sys.stdout.flush()
     sys.stderr.flush()

    def run(self):
        ioloop.install()

        # Command stream.
        self._ctx = zmq.Context()
        self._cmd_sock = self._ctx.socket(zmq.REQ)
        self._auth_token = _extract_auth_token(sys.argv[1])
        addr = _remove_auth_token(sys.argv[1])
        self._cmd_sock.connect(addr)
        self._cmd_sock.send_json((self._auth_token, 'port_info',))
        self._data_port, md = self._cmd_sock.recv_json()
        self._cmd_stream = zmqstream.ZMQStream(self._cmd_sock)
        self._cmd_stream.on_recv(self._handle_cmd_feedback)
        wx.CallAfter(Publisher().sendMessage, "init", md)

        # Data stream.
        addr = _remove_auth_token(sys.argv[1])
        addr = "%s:%s" % (addr.rsplit(':', 1)[0], self._data_port)
        self._sock = self._ctx.socket(zmq.SUB)
        self._sock.connect(addr)
        self._sock.setsockopt(zmq.SUBSCRIBE, '')
        self._stream = zmqstream.ZMQStream(self._sock)
        self._stream.on_recv(self._handle_data)

        # UI stream.
        self._ui_sock = self._ui_ctx.socket(zmq.SUB)
        self._ui_sock.setsockopt(zmq.SUBSCRIBE, '')
        self._ui_sock.connect('inproc://ui')
        self._ui_stream = zmqstream.ZMQStream(self._ui_sock)
        self._ui_stream.on_recv(self._handle_ui)

        ioloop.IOLoop.instance().start()

def run_hub(task):
    logging.basicConfig(level=logging.DEBUG)

    task.reset()

    # Register on receive callback.
    task.command_stream = zmqstream.ZMQStream(task.command_socket)
    task.command_stream.on_recv(task.on_command_recv)

    # Register on receive callback.
    task.query_stream = zmqstream.ZMQStream(task.query_socket)
    task.query_stream.on_recv(task.on_query_recv)

    def dump_registry():
        print '\n' + (72 * '*') + '\n'
        print task.registry
        print '\n' + (72 * '*') + '\n'

    try:
        ioloop.install()
        logger.info('Starting hub ioloop')
        PeriodicCallback(dump_registry, 100,
                         io_loop=ioloop.IOLoop.instance()).start()
        ioloop.IOLoop.instance().start()
    except RuntimeError:
        logger.warning('IOLoop already running.')

def main():
    logger.info('Starting')
    ioloop.install()  # See the link in the module's docstring
    application = web.Application(
        [(r'/', HomepageHandler)],
    )
    application.listen(config.HTTP_PORT)
    ioloop.IOLoop.instance().start()

 def setUp(self):
     ioloop.install()
     super(TestCircus, self).setUp()
     self.arbiters = []
     self.files = []
     self.dirs = []
     self.tmpfiles = []
     self.cli = AsyncCircusClient()

 def runFifoNetWorker(self, netName, pubAgentAddr, sinkAgentAddr, neighbor):
 
     self.dataObject = None
     self.dataObjectId = None
     ioloop.install()
     self.prMod = None
     self.nodeIloop = ioloop.IOLoop.instance()
     self.statusQueue = Queue()
     
     self.fifoStats = FifoStats()
     
     logFname = netName.replace(":", "_")
     logFname = "logs/"+logFname
     logging.basicConfig(level=logging.DEBUG, filename=logFname)
     
     self.name = netName
     self.pubAgent = pubAgentAddr
     self.sinkAgent = sinkAgentAddr
     
     self.neighborAddr = "tcp://"+neighbor
     self.neighbor = neighbor
 
     logging.debug("\tCreating SubAgent socket")
     self.context = zmq.Context()
     self.cmdSubSock = self.context.socket(zmq.SUB)
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, netName)
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Exit')
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'ConnectToNeighbor')
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'TestConnectionToNeighbor')
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Reset')
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Set')
     self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Echo')
     
     self.cmdSubSock.connect(self.pubAgent)
     self.streamCmdIn = zmqstream.ZMQStream(self.cmdSubSock)
     self.streamCmdIn.on_recv_stream(self.procAgentCmd)
     
     
     logging.debug("\tCreating PUSH-to-Agent socket")
     self.cmdReqRepSock = self.context.socket(zmq.REQ)
     self.cmdReqRepSock.connect(self.sinkAgent)
     self.streamCmdOut = zmqstream.ZMQStream(self.cmdReqRepSock)
     self.streamCmdOut.on_send(self.cmdOutRequestToSink)
     
     self.stupidVerificationSocket =  self.context.socket(zmq.REQ)
     self.stupidVerificationSocket.connect(self.sinkAgent)
     
     
     logging.debug("\tCreating Local Server socket")
     self.peerSockServ = self.context.socket(zmq.REP)
     localbindAddr = "tcp://*:"+netName.split(':')[1]
     self.peerSockServ.bind(localbindAddr)
     self.peerServStream = zmqstream.ZMQStream(self.peerSockServ)
     self.peerServStream.on_recv_stream(self.procPeerRxServerMsg)
     self.peerServStream.on_send_stream(self.procPeerTxServerMsg)
     
     
     self.nodeIloop.start()

def runserver(args):
    settings = json.load(args.config)
    ioloop.install()
    loop = IOLoop.instance()

    listeners = []

    if "air" in settings.keys():
        from components.air import air_handlers
        listeners += air_handlers

    if "roots" in settings.keys():
        from components.roots import roots_handlers
        listeners += roots_handlers

    if "branch" in settings.keys():
        from components.branch import branch_handlers
        listeners += branch_handlers

    if "druid" in settings.keys():
        from components.druid import druid_handlers
        listeners += druid_handlers

    application = Trunk(settings["base"], handlers=listeners)

    if "air" in settings.keys():
        from components.air import Air
        application.air = Air(application, settings["air"]["host"], settings["air"]["port"])

    if "roots" in settings.keys():
        from components.roots import Roots
        application.roots = Roots(application, settings["roots"])

    if "branch" in settings.keys():
        from components.branch import Branch
        application.branch = Branch(application, settings["branch"])

    if "druid" in settings.keys():
        from components.druid import Druid
        application.druid = Druid(application, settings["druid"])

    application.listen(settings["base"]["port"], settings["base"]["host"])

    def cleanup(signum=None, frame=None):
        if signum != signal.SIGQUIT:
            log_message("Cleaning up...", begin="\r")
            application.cleanup()
            log_message("Done!")
        else:
            log_message("Shutting down forest, keeping uwsgi", begin="\r")

        loop.stop()
        sys.exit(0)

    for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGQUIT]:
        signal.signal(sig, cleanup)

    loop.start()

def start_io_loop():
    if not tornado.ioloop.IOLoop.instance():
        ioloop.install()

    try:
        tornado.ioloop.IOLoop.instance().start()
    except Exception as e:
        print "openbazaar::start_io_loop Exception:", e
        raise

def run(parser=None, options=None, args=None):
    ''' Launch the GUI with specified options.
    '''

    # install zmq ioloop before creating any tornado objects
    ioloop.install()

    # create the server and kick it off
    server = AppServer(options)
    server.serve()

 def _setup_tornado(self):
     if self._is_setup:
         return
     from zmq.eventloop import ioloop, zmqstream
     ioloop.install()
     from tornado.ioloop import IOLoop
     self._zmqioloop = ioloop
     self._zmqstream = zmqstream
     self._tornadoioloop = IOLoop
     self._is_setup = True

        def worker(vent_address,sink_address,sz,dtype):

            import zmq
            import theano
            from zmq.eventloop import ioloop
            ioloop.install()
            from zmq.eventloop.zmqstream import ZMQStream

            # Context
            context = zmq.Context()

            # Socket to receive messages on
            receiver = context.socket(zmq.PULL)
            receiver.connect(vent_address)
            receiver_stream = ZMQStream(receiver)

            # Socket to send messages to
            sender = context.socket(zmq.PUSH)
            sender.connect(sink_address)

            def _worker(msg_list, sz=sz, dtype=dtype, sender=sender):
                import theano
                import numpy as np

                msg = msg_list[0]

                # if normalize_A does any inplace operation, we need to .copy() here:
                new_A = np.frombuffer(buffer(msg), dtype=dtype).reshape(sz).copy()
                new_A = l.model.normalize_A(new_A)

                l.model.A.set_value(new_A.astype(theano.config.floatX))

                x = l.get_databatch()
                dA = l.model.gradient(x)['dA']
                dA *= l.eta

                param_max = np.max(np.abs(l.model.A.get_value()), axis=0)
                update_max = np.max(np.abs(dA), axis=0)
                update_max = np.max(update_max / param_max)

                l._adapt_eta(update_max)

                # no subset selection:
                sender.send(dA,copy=False)

                # subset selection:
                #inds = np.argwhere(dA.sum(0) != 0.).ravel()
                #subset_dA = dA[:, inds]
                #sender.send_pyobj(dict(inds=inds, subset_dA=subset_dA))

            receiver_stream.on_recv(_worker,copy=False)
            iolooper = ioloop.IOLoop.instance()
            iolooper.start()

            return

    def start(self):
        """Starts the server"""
        ioloop.install()
        connection = self.config["transport"] + "://" + self.config["ip"]
        secure_key = self.config["key"].encode()
        digestmod = self.signature_schemes[self.config["signature_scheme"]]
        self.auth = hmac.HMAC(secure_key, digestmod=digestmod)

        # Heartbeat
        ctx = zmq.Context()
        self.heartbeat_socket = ctx.socket(zmq.REP)
        self.config["hb_port"] = bind(
            self.heartbeat_socket, connection, self.config["hb_port"]
        )

        # IOPub/Sub, aslo called SubSocketChannel in IPython sources
        self.iopub_socket = ctx.socket(zmq.PUB)
        self.config["iopub_port"] = bind(
            self.iopub_socket, connection, self.config["iopub_port"]
        )
        self.iopub_stream = zmqstream.ZMQStream(self.iopub_socket)
        self.iopub_stream.on_recv(self.iopub_handler)

        # Control
        self.control_socket = ctx.socket(zmq.ROUTER)
        self.config["control_port"] = bind(
            self.control_socket, connection, self.config["control_port"]
        )
        self.control_stream = zmqstream.ZMQStream(self.control_socket)
        self.control_stream.on_recv(self.control_handler)

        # Stdin:
        self.stdin_socket = ctx.socket(zmq.ROUTER)
        self.config["stdin_port"] = bind(
            self.stdin_socket, connection, self.config["stdin_port"]
        )
        self.stdin_stream = zmqstream.ZMQStream(self.stdin_socket)
        self.stdin_stream.on_recv(self.stdin_handler)

        # Shell
        self.shell_socket = ctx.socket(zmq.ROUTER)
        self.config["shell_port"] = bind(
            self.shell_socket, connection, self.config["shell_port"]
        )
        self.shell_stream = zmqstream.ZMQStream(self.shell_socket)
        self.shell_stream.on_recv(self.shell_handler)

        # start up configurtation
        self.dprint(2, "Config:", json.dumps(self.config))
        self.dprint(1, "Starting loops...")
        self.hb_thread = threading.Thread(target=self.heartbeat_loop)
        self.hb_thread.daemon = True
        self.hb_thread.start()
        self.dprint(1, "Ready! Listening...")
        ioloop.IOLoop.instance().start()

def main():
    ''' Process command line arguments, create server, and start it up.
    '''
    # make sure to install zmq ioloop before creating any tornado objects
    ioloop.install()

    # create the server and kick it off
    parser = ZMQServer.get_options_parser()
    (options, args) = parser.parse_args()
    server = ZMQServer(options)
    server.serve()

    def run(self):
        """
        The main run loop for the management process. Sets a signal handler so that the process can be
        stopped by sending SIGTERM. You can also call the "stop()" function from inside the same process
        to stop the management server.

        This version of the run loop does provides the web configuration front-end. The web front-end is a
        RESTful API that provides status and configuration command and control interfaces. See api_client
        for use.

        :return: 0 on success, nonzero for error conditions.
        """
        Controller.instance = self

        zmq_ioloop.install()
        signal.signal(signal.SIGTERM, self._stop_signal_handler)

        # Setup the web application
        self.application = tornado.web.Application(api.handlers, gzip=True)
        self.application.listen(self.config.get("management", "configuration_port"),
                                address=self.config.get("management", "configuration_ip"))

        # Setup handlers to care for the management tasks.
        announce_timer = tornado.ioloop.PeriodicCallback(self.announce_presence, 1000)
        management_timer = tornado.ioloop.PeriodicCallback(self.process_node_tasks, 100)
        leader_timer = tornado.ioloop.PeriodicCallback(self.process_leader_tasks, 100)
        announce_timer.start()
        management_timer.start()
        leader_timer.start()

        instance = zmq_ioloop.ZMQIOLoop.instance()
        instance.add_handler(self.presence_socket.fileno(), self._process_presence, zmq_ioloop.ZMQIOLoop.READ)

        # Start the I/O loop
        logging.info("Started management process, announcing on %s:%s, configuration=%s:%s, command=%s:%s",
                     self.mcast_group, self.mcast_port,
                     self.config.get("management", "configuration_ip"),
                     self.config.get("management", "configuration_port"),
                     self.config.get("management", "management_ip"),
                     self.config.get("management", "management_port")
        )
        instance.start()
        announce_timer.stop()
        management_timer.stop()
        leader_timer.stop()

        # Unregister the signal handler and exit.
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        logging.info("Stopped management process.")
        return 0

def install_zmq_hooks():
    ioloop.install()
    context = zmq.Context()
    socket_jobs = context.socket(zmq.SUB)
    socket_jobs.setsockopt(zmq.SUBSCRIBE, "")
    socket_jobs.connect ("tcp://localhost:%s" % GATEWAY_PORT_JOBS)
    stream_jobs = zmqstream.ZMQStream(socket_jobs)
    stream_jobs.on_recv(pushjobs)
    
    socket_logs = context.socket(zmq.SUB)
    socket_logs.setsockopt(zmq.SUBSCRIBE, "")
    socket_logs.connect ("tcp://localhost:%s" % GATEWAY_PORT_LOGS)
    stream_logs = zmqstream.ZMQStream(socket_logs)
    stream_logs.on_recv(pushlogs)

    def __init__(self, *args, **kw):
        self.context = zmq.Context()

        ioloop.install()

        zmq_broker_address = conf.get('dealer', 'zmq_broker_address')

        if zmq_broker_address == None:
            zmq_broker_address = "tcp://localhost:5570"

        self.dealer = self.context.socket(zmq.DEALER)
        self.dealer.identity = (u"Dealer-%s-%s" % (socket.getfqdn(), os.getpid())).encode('ascii')
        self.dealer.connect(zmq_broker_address)

        self.dealer_stream = zmqstream.ZMQStream(self.dealer)
        self.dealer_stream.on_recv(self.stop)

def main(args=None):
    if args is None:
        args = sys.argv[1:]

    parser = optparse.OptionParser()
    parser.add_option("--repurl", action="store", type="string", dest='repurl',
                      help="url of REP socket", default='tcp://*:5555')
    parser.add_option("--puburl", action="store", type="string", dest='puburl',
                      help="url of PUB socket", default='tcp://*:5556')
    parser.add_option("-c", "--class", action="store", type="string", dest='classpath',
                      help="module path to class of top level component")
    parser.add_option("-p", "--publish", action="append", type="string", dest='published',
                      help="specify a variable to publish", default=[])
    parser.add_option("--wspub", action="store", type="string", dest='wspub',
                      help="route to pub websocket")
    parser.add_option("--wscmd", action="store", type="string", dest='wscmd',
                      help="route to cmd websocket")

    (options, args) = parser.parse_args(args)

    if options.classpath is None:
        print "you must specify the module path to a class or factory function"
        parser.print_help()
        sys.exit(-1)

    if options.wspub or options.wscmd:
        ioloop.install() # must call this before importing any tornado stuff

    parts = options.classpath.split('.')
    modpath = '.'.join(parts[:-1])
    __import__(modpath)

    try:
        mod = sys.modules[modpath]
        ctor = getattr(mod, parts[-1])
    except (KeyError, AttributeError):
        print "can't locate %s" % options.classpath
        sys.exit(-1)

    top = set_as_top(ctor())
    top.register_published_vars(options.published)

    ZmqCompWrapper.serve(top, rep_url=options.repurl, pub_url=options.puburl,
                         wspub=options.wspub, wscmd=options.wscmd)

def run_plugin(task):
    logging.basicConfig(level=logging.DEBUG)

    task.reset()

    # Register on receive callback.
    task.command_stream = zmqstream.ZMQStream(task.command_socket)
    task.command_stream.on_recv(task.on_command_recv)

    # Register on receive callback.
    task.query_stream = zmqstream.ZMQStream(task.subscribe_socket)
    task.query_stream.on_recv(task.on_subscribe_recv)

    try:
        ioloop.install()
        logger.info('Starting plugin %s ioloop' % task.name)
        ioloop.IOLoop.instance().start()
    except RuntimeError:
        logger.warning('IOLoop already running.')