Python ioloop.add_timeout函数代码示例

    def poll_media_list_process():
        ioloop = tornado.ioloop.IOLoop.instance()
        if _timelapse_process.is_alive(): # not finished yet
            now = datetime.datetime.now()
            delta = now - started[0]
            if delta.seconds < 300: # the subprocess has 5 minutes to complete its job
                ioloop.add_timeout(datetime.timedelta(seconds=0.5), poll_media_list_process)
                read_media_list()

            else: # process did not finish within 2 minutes
                logging.error('timeout waiting for the media listing process to finish')
                
                _timelapse_process.progress = -1

        else: # finished
            read_media_list()
            logging.debug('media listing process has returned %(count)s files' % {'count': len(media_list)})
            
            if not media_list:
                _timelapse_process.progress = -1
                
                return

            pictures = select_pictures(media_list)
            make_movie(pictures)

 def autoreload_handler(self):
     self.twlog.warning('Queueing autoreload shutdown!')
     self.caughtinterrupt = True
     ioloop = tornado.ioloop.IOLoop.instance()
     self.twlog.info('Waiting 1 second for requests to drain...')
     ioloop.add_timeout(datetime.timedelta(seconds=1.0),
                        self.final_autoreload)

def main():
  global tornadoApp
  watermark.printWatermark()

  tornado.options.parse_command_line()

  sockJSRouter = sockjs.tornado.SockJSRouter(SockJSClient, '/socket')

  app = Application(sockJSRouter.urls)
  tornadoApp = app # globals cheating
  ioloop = tornado.ioloop.IOLoop.instance()

  # instance sockJS server
  # app.sockjs = sockjs.tornado.SockJSRouter(SockJSClient, '/socket')
  # for handler in app.sockjs.urls:
  #   print(handler)
  #   print("")
  #   # app.add_handlers(handler[0], handler[1])
  # app.add_handlers(r"*", app.sockjs.urls)

  # instance rabbitMQ server
  app.rabbit = RabbitClient(app, ioloop)
  app.listen(options.port)
  
  ioloop.add_timeout(500, app.rabbit.connect)
  ioloop.start()

def start_motion():
    import tornado.ioloop
    import config
    import motionctl

    ioloop = tornado.ioloop.IOLoop.instance()
    
    # add a motion running checker
    def checker():
        if ioloop._stopped:
            return
            
        if not motionctl.running() and motionctl.started() and config.get_enabled_local_motion_cameras():
            try:
                logging.error('motion not running, starting it')
                motionctl.start()
            
            except Exception as e:
                logging.error('failed to start motion: %(msg)s' % {
                        'msg': unicode(e)}, exc_info=True)

        ioloop.add_timeout(datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)
    
    motionctl.start()
        
    ioloop.add_timeout(datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)

def main():
    pika_client = PikaClient()
    database={}
    database['g'] = 'f'
    database['gg'] = 'ff'
    database['ggg'] = 'gff'
    global g_port;
    
    application = tornado.web.Application(
    [(r'/sensor/.*', SensorHandler,dict(database=database)),(r'/.*',MainHandler,dict(database=database))],
#        [(r'/index.html',MainHandler)],
#        [(r'/tom/*',SensorHandler),(r'/index.html',MainHandler)],
#        **{'pika_client': pika_client, 'debug': True}

        #     **{'pika_client': pika_client, 'debug': True}
        #     [(r'/tom/*', Fib)],
             **{'pika_client': pika_client, 'debug': True}
    )
    try:
        port = int(sys.argv[1])  # $ python tornadoweb_pika.py 80
    except:
        port = 8000 
    g_port = port
    application.listen(port)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.add_timeout(time.time() + .1, pika_client.connect)
    ioloop.start()

def shutdown(server):
    ioloop = tornado.ioloop.IOLoop.instance()
    server.stop()
    
    def finalize():
        ioloop.stop()
        
    ioloop.add_timeout(time.time() + 1.5, finalize)

    def get(self, injector=None):
        import tornado.ioloop
        import time

        broker_client = injector.get('msg_broker_client')
        ioloop = tornado.ioloop.IOLoop.instance()
        ioloop.add_timeout(time.time() + 0.01, broker_client.connect)
        return ioloop

def main():
    http_server = tornado.httpserver.HTTPServer(Tutu())
    http_server.listen(options.port)

    ioloop = tornado.ioloop.IOLoop.instance()
    if not TEST:
        ioloop.add_timeout(ioloop.time(), registry_marathon_event_handler)

    ioloop.start()

def main():
    parse_command_line()

    ioloop = tornado.ioloop.IOLoop.instance()

    ioloop.add_timeout(timedelta(seconds=1), lambda: tweet_ingester.init_room_stream('follow'))
    ioloop.add_timeout(timedelta(seconds=7), lambda: tweet_ingester.init_room_stream('retweet'))

    ioloop.start()

def main():
    port = int(sys.argv[1])
    config_file = sys.argv[2]

    # queue for waiting answer from rabbit
    queue_answer = 'answer-%s' % port

    # queues for sending create/read messages
    queue_read = 'reading'
    queue_create = 'creation'

    logger_web = Logger('tornado-%s' % port).get()

    config = ConfigParser.ConfigParser()
    config.read(config_file)

    # TODO: check config
    redis_nodes = zip(config.get('rediscluster', 'hosts').split(' '),
                      config.get('rediscluster', 'ports').split(' '))
    rabbit_nodes = zip(config.get('rabbitmq', 'hosts').split(' '),
                       config.get('rabbitmq', 'ports').split(' '))

    startup_nodes = map(lambda node: {'host': node[0],
                                      'port': int(node[1])}, redis_nodes)
    logger_web.info('Redis has config: {0}'.format(startup_nodes))
    session_store = Session(startup_nodes=startup_nodes)

    public_root = os.path.join(os.path.dirname(__file__), 'client')
    application = tornado.web.Application(
        [(r'/', MainHandler, dict(session_store=session_store,
                                  logger=logger_web,
                                  queue_answer=queue_answer,
                                  queue_read=queue_read,
                                  queue_create=queue_create)),
         (r'/(.*)', tornado.web.StaticFileHandler, {'path': public_root})],
        # yeah, it's not secure, but it just for test
        cookie_secret='de973a5e-211f-11e6-bde5-3859f9e0729b'
    )

    logger_pika = Logger('tornado-%s-pika' % port).get()
    pc = PikaClient(logger=logger_pika,
                    queue_answer=queue_answer,
                    queue_read=queue_read,
                    queue_create=queue_create,
                    node_list=rabbit_nodes)
    application.pika = pc

    application.listen(port)
    logger_web.info('Tornado is serving on port {0}.'.format(port))
    ioloop = tornado.ioloop.IOLoop.instance()

    try:
        ioloop.add_timeout(time.time() + .1, pc.connect)
        ioloop.start()
    except:
        pc.stop()

 def scan(self):
   while self.running:
     if not self.supported_pids:
       # sleep 1s
       current = greenlet.getcurrent()
       ioloop.add_timeout(time.time() + 1, current.switch)
       current.parent.switch()
     for obd2id, pids in self.supported_pids.iteritems():
       for pid in pids:
         frame = self.query_block(obd2id, 1, pid)

 def open(self):
     'Websocket Connection opened.'
     
     #Initialize new pika client object for this websocket.
     self.pika_client = PikaClient()
     
     #Assign websocket object to a Pika client object attribute.
     self.pika_client.websocket = self
     
     ioloop.add_timeout(1000, self.pika_client.connect)

def main():
  tornado.options.parse_command_line()

  app = Application()
  ioloop = tornado.ioloop.IOLoop.instance()

  app.pika = ExamplePublisher(app, ioloop)
  app.listen(options.port)
  
  ioloop.add_timeout(500, app.pika.connect)
  ioloop.start()

    def __init__(self, app, can):
        self.app = app
        self.can = can
        self.can.subscribe(self.read, ids=OBD2_IDS)

        self.read_waiters = defaultdict(set)
        self.read_timeouts = []

        self.supported_pids = []

        start = lambda:greenlet.greenlet(self.init).switch()
        ioloop.add_timeout(time.time() + 2, start)

    def open(self, chat_id):
        """Websocket Connection opened."""

        print("WebSocket opened")

        # Initialize new pika client object for this websocket.
        self.pika_client = PikaClient(chat_id)

        # Assign websocket object to a Pika client object attribute.
        self.pika_client.websocket = self

        ioloop.add_timeout(1000, self.pika_client.connect)