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)

    def handle_message(self, message):
        data = json.loads(message)
        logging.info('recv message from %s %s' % (self.user, data))
        if 'a' in data:
            action = data['a']

        if action == ACTION_TURN:
            data['p'] = self.user.id
            if options.fake_latency:
                ioloop.add_timeout( time.time() + 0.1, functools.partial( self.game.broadcast, data ) )
            else:
                self.game.broadcast( data )

    def checker():
        if ioloop._stopped:
            return

        if not motionctl.running() and motionctl.started() and config.has_local_enabled_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)

  def __init__(self, write):
    self.running = True
    self.write = write

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

    self.supported_pids = dict()

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

    scan = lambda:greenlet.greenlet(self.scan).switch()
    ioloop.add_timeout(time.time() + 3, scan)

def countdown():
    global countdown_code
    global countdown_time
    global ws_clients
    ioloop = tornado.ioloop.IOLoop.current()
    if countdown_state == 'resume':
        if ws_clients:
            str_time = time.strftime('%M:%S', time.gmtime(countdown_code))
            for s in ws_clients:
                s.write_message(str_time)
        if countdown_code:
            countdown_code -= 1
        else:
            countdown_code = countdown_time
    ioloop.add_timeout(time.time() + 1, countdown)

def main():
    global db
    global log_db
    # if os.path.isfile("login_token.json") and os.path.isfile("login_user.json"):
    #     in_token = open("login_token.json")
    #     login_token = json.load(in_token)
    #     in_token.close()
    #     RedisHandler.f_hmset(LOGIN_T, login_token)
    #     in_user = open("login_user.json")
    #     SocketHandler.login_user = json.load(in_user)
    #     #util.RedisHandle.f_hmset(LOGIN_U, login_user)
    #     in_user.close()
    #     os.rename("login_token.json", "login_token"+str(long(time()))+".json")
    #     os.rename("login_user.json", "login_user"+str(long(time()))+".json")
    access = logging.getLogger("tornado.access")
    access.addHandler(NullHandler())
    access.propagate = False
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True)
    http_server.listen(options.port)
    try:
        util.MemCache.load(str(options.port))
        #util.RedisHandle.f_delete(*[CLIENT_UID_USER,CLIENT_USER_UID,USER_ONLINE_AT,USER_IP_LIST,HTTP_SERVER_INFO])
        ioloop=tornado.ioloop.IOLoop.instance()
        #db_client = motor.MotorReplicaSetClient(hosts_or_uri="127.0.0.1:27017",replicaSet='fbt_repl',io_loop=ioloop)
        #db_client.read_preference = ReadPreference.SECONDARY_ONLY
        #db = db_client.fbt
        #log_db = motor.MotorClient().fbt_log
        #log_db = db_client.fbt_log
        db = motorclient.fbt
        log_db = motorclient.fbt_log
        ResourceStoreManager.set_db(db)
        FBCoinManager.set_db(db)
        UserManager.set_db(db)
        msg_handle.set_db(db)
        LogForUser.set_db(log_db)
        #FBCoinManager.set_update_fb_callback(SocketHandler.update_fb)
        #FBRankManager.initialize() #load rank info from file
        #FBRankTimer.set_io_loop(ioloop)
        #FBRankTimer.run() #backup the weekly and monthly rank
        
        SocketHandler.set_io_loop(ioloop)
        SocketHandler.init()
        ioloop.add_timeout(long(time()) + 3600, lambda: SocketHandler.check_on_line())
        ioloop.start()
    except Exception, e:
        print e
        print "OK. I will exit..."