Python ioloop.stop函数代码示例

 def callback(f):
     ioloop.stop()
     try:
         f.result()
     except Exception:
         logging.error(
             "Error in stream: {0}".format(traceback.format_exc()))

 def stop(self):
     # FIXME: THIS ISN"T WORKING! should catch sigkill/sigterm and shutdown properly
     super(HTTPServer, self).stop()
     logger.debug("Tornado: Stop")
     ioloop = tornado.ioloop.IOLoop.instance()
     ioloop.stop()
     if hasattr(self, '_web_app'):
         del self._web_app

    def on_shutdown():
    #监听ctrl+c 以保证在退出时保存fetched
        logging.info("save fetched")
        with open("ed_fetched", "w") as f:
            for u in fetcher.fetch_finished:
                f.write(u + '\n')

        ioloop.stop()

    def bye_handler(signal, frame):
        import tornado.ioloop
        
        logging.info('interrupt signal received, shutting down...')

        # shut down the IO loop if it has been started
        ioloop = tornado.ioloop.IOLoop.instance()
        ioloop.stop()

def main():
    try:
	config = ConfigParser.SafeConfigParser({"accountId":None,"deviceId":None,"dmtp_url":'dmtp://54.84.59.135:21000'})
	config.read("/home/pi/attack_on_titan/src/settings.cfg")	
	print config.get("dmtp","dmtp_url")
	print config.get("dmtp","accountId")
	print config.get("dmtp","deviceId")

        logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
        ioloop = tornado.ioloop.IOLoop()
	client = SimpleAsyncDmtpClient(ioloop)
	
	def on_response(response):
	    print(response)
	    if response.error:
		print("errror sending packet")
	    else:
		print("tag in range sent")
	
	@gen.coroutine
        def on_message(body,consumer,basic_deliver):
	    try:
		print("received packet")
	        dmtp_packet = pickle.loads(body)
	        dmtp_request = DMTPRequest(\
		    config.get("dmtp","dmtp_url"),\
		    config.get("dmtp","accountId"),\
		    config.get("dmtp","deviceId"),\
		    packets=[dmtp_packet])
	        #yield DMTPResponse Object
	        response = yield client.fetch(dmtp_request)	
	        print('sent data and got here')
		if not(response.code == 200):
		    consumer.reject_message(basic_deliver.delivery_tag)	   
	            raise Exception("Error sending data")
	    	consumer.acknowledge_message(basic_deliver.delivery_tag)
		return
	    except:
		import sys
		print sys.exc_info()
	consumer = Consumer('amqp://guest:[email protected]:5672/%2F',ioloop,None,on_ack_message=on_message,durable=True)
        consumer.QUEUE = 'dmtp'
	consumer.EXCHANGE = 'upstream'
	consumer.run()
	ioloop.start()
    except KeyboardInterrupt:
        consumer.stop()
        ioloop.stop()

def main():
    tornado.options.parse_command_line()
    
    settings = {
        "template_path"     : config.TEMPLATE_PATH,
        "static_path"       : config.STATIC_PATH,
        "debug"             : config.DEBUG,
        "compress_response" : config.COMPRESS_RESPONSE,
        "cookie_secret"     : config.COOKIE_SECRET,
        "xsrf_cookies"      : config.XSRF_COOKIES,
        "login_url"         : config.LOGIN_URL
        }

    ioloop = tornado.ioloop.IOLoop.instance()
    
    app = tornado.web.Application(
            urls.handler_urls,
            **settings)

    app.db = momoko.Pool(
                dsn='dbname={} user={} password={} host={} port={}'.format(
                    config.DATABASE_NAME,
                    config.DATABASE_USER,
                    config.DATABASE_PASSWORD,
                    config.DATABASE_HOST,
                    config.DATABASE_PORT),
                cursor_factory=psycopg2.extras.RealDictCursor,
                size=1,
                ioloop=ioloop)
    future = app.db.connect()
    ioloop.add_future(future, lambda f: ioloop.stop())
    ioloop.start()
    http_server = tornado.httpserver.HTTPServer(app)
    http_server.listen(options.port)
    ioloop.start()

    def __init__(self):
        handlers = [
            (r"/", AllLists),
            (r"/create/", CreateLists),
        ]
        settings = dict(
            todo_title=u"ToDo",
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
            xsrf_cookies=True,
            cookie_secret=base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes),
            login_url="/auth/login",
            debug=True,
        )

        super(Application, self).__init__(handlers, **settings)

        ioloop = tornado.ioloop.IOLoop.instance()
        self.db = momoko.Pool(
            dsn='dbname=todo user={0} password={1} '
                'host=localhost port=5432'.format(USERNAME, PASSWORD),
            size=1,
            ioloop=ioloop,
            cursor_factory=psycopg2.extras.RealDictCursor
        )

        future = self.db.connect()
        ioloop.add_future(future, lambda f: ioloop.stop())
        ioloop.start()
        future.result()

def main():
    app = LetSpotify()
    http_server = tornado.httpserver.HTTPServer(app)
    http_server.listen(options.port)
    ioloop = tornado.ioloop.IOLoop.instance()

    app.db = momoko.Pool(
        dsn=settings['dsn'],
        size=5,
        raise_connect_errors=False,
        reconnect_interval=50,
        ioloop=ioloop,
    )

    future = app.db.connect()
    ioloop.add_future(future, lambda f: ioloop.stop())
    ioloop.start()
    future.result()  # raises exception on connection error

    Service.users = Users(app.db)
    Service.facebook = FacebookAPI(app.db)
    Service.rooms = Rooms(app.db)
    Service.login_token = LoginToken(app.db)

    ioloop.start()

def main(debug, static_dir, template_dir, listen):
    application = make_app(debug, static_dir, template_dir)
    application.listen(address=listen.address, port=listen.port)

    url = "http://{0}:{1}".format(listen.address, listen.port)
    print('Starting server at {0}'.format(url))

    # open a URL, if possible on new tab
    webbrowser.open(url, new=2)

    ioloop = tornado.ioloop.IOLoop.instance()
    try:
        ioloop.start()
    except KeyboardInterrupt:
        ioloop.stop()
        ioloop.close()

 def __init__(self):
     self.handlers = routs
     ioloop = tornado.ioloop.IOLoop.instance()
     self.settings = dict(
         debug=config.debug,
         template_path=config.template_path,
         static_path=config.static_path,
         cookie_secret=config.cookie_secret,
         login_url=config.login_url
     )
     super(Application, self).__init__(self.handlers, **self.settings)
     self.db_async = momoko.Pool(
         dsn=config.get_db_url(options.db_name,
                               options.db_user_name,
                               options.db_host,
                               options.db_port,
                               options.db_password),
         size=1,
         ioloop=ioloop,
         cursor_factory=DictCursor
     )
     future = self.db_async.connect()
     ioloop.add_future(future, lambda x: ioloop.stop())
     ioloop.start()
     future.result()

def main():
    try:
        tornado.options.parse_command_line()
        handlers = [
            (r'/', MainHandler)
        ]
        settings = dict(
                debug=True,
                template_path=os.path.join(os.path.dirname(__file__), "templates"),
                static_path=os.path.join(os.path.dirname(__file__), "static")
        )
        app = tornado.web.Application(handlers, **settings)

        ioloop = tornado.ioloop.IOLoop.instance()

        app.db = momoko.Pool(
                dsn=dsn,
                size=1,
                max_size=3,
                ioloop=ioloop,
                setsession=("SET TIME ZONE UTC",),
                raise_connect_errors=False
        )

        future = app.db.connect()
        ioloop.add_future(future, lambda f: ioloop.stop())
        ioloop.start()

        http_server = tornado.httpserver.HTTPServer(app)
        http_server.listen(options.port)
        ioloop.start()
    except KeyboardInterrupt:
        print('Exit.')

def test_login():
    username = sys.argv[1]
    password = sys.argv[2]

    session = Session()

    session.endpoint = '/gui/srp'
    session.srp_direct = options.server_address
    session.enable_direct()

    result = yield gen.Task( session.login, username, password )
    logging.info('got session %s' % result)

    result = yield gen.Task( session.get_token )

    logging.info('got token %s %s' % (result, session.token))

    # check result..
    old_style = True
    btappstr = 'testbtapp'
    #torrent = 'http://www.clearbits.net/get/503-control-alt-deus---made-of-fire.torrent'
    hash = ''.join([random.choice( list('abcdef') + map(str,range(10)) ) for _ in range(40)])
    torrent = 'magnet:?xt=urn:btih:%s' % hash


    cid = None
    count = 0
    while count < 10:
        count += 1
        #url_args = {'list':1}
        url_args = None
        #args = {}
        args = { 'list': 1 }
        if cid:
            args['cid'] = cid
        response = yield gen.Task( session.request, 'GET', url_params=url_args, body_params=args )
        #logging.info('got response %s' % response)
        if 'torrentc' in response.body:
            cid = response.body['torrentc']
        logging.info('list req response %s' % [response.body])
        yield gen.Task(asyncsleep,1)
        assert response.code == 200

    logging.info('woot!')

    ioloop.stop()

def main():
    try:
        if len(sys.argv) > 1:
            if sys.argv[1] == "config":
                ioloop.run_sync(config)
            elif sys.argv[1].endswith("help") or sys.argv[1] == "-h":
                print(helptext)
            else:
                print("I don't understand that. Here's the help text:")
                print(helptext)
        else:
            run()
    except KeyboardInterrupt:
        ioloop.stop()
        print("Stopping...")
    except Closed:
        ioloop.stop()
        print("Connection was closed")

def start(args, cfg):
    application = Application(cfg, args.debug)

    if args.debug:
        args.level = logging.DEBUG

    # setup logging level if specify
    if args.level is not None:
        logging.root.setLevel(args.level)

    # listen to port
    port = cfg['server']['port']
    try:
        application.listen(port)
        app_log.info('listening port %s', port)
    except OSError:
        app_log.error('unable to listen port %s', port)
        return

    ioloop = tornado.ioloop.IOLoop.instance()

    # prevent block for IO allowed ctrl-c to pass
    # http://stackoverflow.com/a/9578595
    def set_ping(timeout):
        ioloop.add_timeout(timeout, lambda: set_ping(timeout))

    set_ping(timedelta(seconds=0.5))

    # start main loop
    try:
        ioloop.start()
    except KeyboardInterrupt:
        app_log.info('Keyboard interrupt')
    except SystemExit:
        pass
    except Exception:
        app_log.exception('Error')
        raise

    ioloop.stop()
    app_log.info('Closed')
    return True

def do_stuff():
    # result = yield gen.Task( users.put, 'blah 2', dict( kyle = 102 ) )
    result = yield gen.Task(db.query, 'select * from users where version="24979" limit 2')
    logging.info("got result %s: %s, %s, %s" % (result.code, result.attributes, result.meta, result.results))
    if "NextToken" in result.meta:
        result = yield gen.Task(db.query, 'select * from users where version="24979" limit 2', result.meta["NextToken"])
        logging.info("got result %s: %s, %s, %s" % (result.code, result.attributes, result.meta, result.results))
    # result = yield gen.Task( db.query, "select" )

    return
    result = yield gen.Task(users.delete, "blah2", {"kyle": [1, 59, 84, 85, 88, 89, 90]})
    # yield gen.Task( asyncsleep, 5 )

    # result = yield gen.Task( users.get, 'blah2' )
    logging.info("got result %s: %s, %s" % (result.code, result.attributes, result.meta))

    result = yield gen.Task(users.get_metadata)
    logging.info("got result %s: %s, %s" % (result.code, result.attributes, result.meta))

    ioloop.stop()