Python ioloop.install函数代码示例

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