def main(): try: tornado.options.parse_command_line() application = tornado.web.Application([ (r'/', OverviewHandler), (r'/mogrify', MogrifyHandler), (r'/query', SingleQueryHandler), (r'/hstore', HstoreQueryHandler), (r'/json', JsonQueryHandler), (r'/transaction', TransactionHandler), (r'/multi_query', MultiQueryHandler), (r'/connection', ConnectionQueryHandler), ], debug=True) ioloop = tornado.ioloop.IOLoop.instance() application.db = asyncpg.Pool( dsn=dsn, size=1, max_size=3, ioloop=ioloop, setsession=("SET TIME ZONE UTC",), raise_connect_errors=False, ) # this is a one way to run ioloop in sync future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() if enable_hstore: future = application.db.register_hstore() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) if application.db.server_version >= 90200: future = application.db.register_json() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(8888, 'localhost') ioloop.start() except KeyboardInterrupt: print('Exit')
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 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 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(): options.parse_command_line() application = tornado.web.Application([ (r'/psql/select', PSQLSelectHandler), ], debug=False) ioloop = tornado.ioloop.IOLoop.instance() application.db = momoko.Pool( dsn=options.dsn, size=1, max_size=3, ioloop=ioloop, ) # this is a one way to run ioloop in sync future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() http_server = tornado.httpserver.HTTPServer(application) http_server.listen(options.port, 'localhost') 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 __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 run(): configure_logging() handlers = [ tornado.web.url(r'/', IndexHandler, name='index'), tornado.web.url(r'/api/v1/stream/(.*)', StreamHandler, name='api/stream'), tornado.web.url(r'/api/v1/update/(.*)', UpdateHandler, name='api/update'), ] base_dir = os.path.dirname(__file__) static_path = os.path.join(base_dir, 'static') template_path = os.path.join(base_dir, 'templates') app = tornado.web.Application(handlers, static_path=static_path, template_path=template_path, debug=True) app.listeners = Listeners() dsn = 'host=localhost port=6875 dbname=materialize' app.mzql = momoko.Pool(dsn=dsn) # Connect Momoko before starting Tornado's event loop # This let's Momoko create an initial connection to the database future = app.mzql.connect() ioloop = tornado.ioloop.IOLoop.current() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() port = 8875 log.info('Port %d ready to rumble!', port) app.listen(port) ioloop.start()
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 _async_init_cb(): def _run_server_cb(future): if future.exception() is not None: log.exception('failed to start: %s', future.exception()) sys.exit(1) run_server(tornado_app) ioloop.add_future(tornado_app.init_async(), _run_server_cb)
def _async_init_cb(): def _run_server_cb(future): if future.exception() is not None: log.exception('failed to start: %s', future.exception()) sys.exit(1) run_server(tornado_app) ioloop.add_future( tornado_app.init_async(), _run_server_cb )
def main(): debug = int(os.environ.get("AS_DEV", "0")) logging.basicConfig( format=f"%(asctime)s captain: %(levelname)s: %(message)s", level=logging.DEBUG if debug else logging.INFO, ) ioloop = tornado.ioloop.IOLoop.current() ioloop.add_callback(signal.signal, signal.SIGTERM, handle_sigterm) ioloop.add_future(asyncio.ensure_future(async_main()), lambda _: None) logging.debug("Entering the IOLoop...") ioloop.start()
def init_db(app, ioloop): """Init the app db connection to the postgres database""" app.db = momoko.Pool( dsn=('dbname=postgres user={user} password={password} ' 'host={host} port={port}').format(**DBARGS), size=1, ioloop=ioloop, cursor_factory=psycopg2.extras.DictCursor ) # this is a one way to run ioloop in sync future = app.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() future.result() # raises exception on connection error
def main(): init_log() try: tornado.options.parse_command_line() application = tornado.web.Application( [(r'/', OverviewHander), (r'/get-tick-data', TickDataHandler), (r'/get-new-stock', NewStockHandler), (r'/get-new-high', NewHighHandler), (r'/query', QueryHandler), (r'/connection', ConnectionHandler)], debug=True) ioloop = tornado.ioloop.IOLoop.instance() application.db = momoko.Pool( dsn=dsn, size=1, max_size=3, ioloop=ioloop, setsession=("SET TIME ZONE UTC", ), raise_connect_errors=False, ) # this is a one way to run ioloop in sync future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() if enable_hstore: future = application.db.register_hstore() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) if application.db.server_version >= 90200: future = application.db.register_json() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) # create http server http_server = tornado.httpserver.HTTPServer(application) http_server.listen(6888, 'localhost') # create json rpc server rpc_server = RPCServer() rpc_server.listen(8001) ioloop.start() except KeyboardInterrupt: print('Exit')
def main(): try: tornado.options.parse_command_line() application = tornado.web.Application([ (r'/', OverviewHandler), (r'/mogrify', MogrifyHandler), (r'/query', SingleQueryHandler), (r'/hstore', HstoreQueryHandler), (r'/json', JsonQueryHandler), (r'/transaction', TransactionHandler), (r'/multi_query', MultiQueryHandler), (r'/connection', ConnectionQueryHandler), ], debug=True) ioloop = tornado.ioloop.IOLoop.instance() application.db = momoko.Pool( dsn=dsn, size=1, max_size=3, ioloop=ioloop, setsession=("SET TIME ZONE UTC", ), raise_connect_errors=False, ) # this is a one way to run ioloop in sync future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() if enable_hstore: future = application.db.register_hstore() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) if application.db.server_version >= 90200: future = application.db.register_json() # This is the other way to run ioloop in sync ioloop.run_sync(lambda: future) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(8888, 'localhost') ioloop.start() except KeyboardInterrupt: print('Exit')
def _async_init_cb(): try: init_futures = app.default_init_futures + list(app.init_async()) if init_futures: def await_init(future): if future.exception() is not None: log.error('failed to initialize application, init_async returned: %s', future.exception()) sys.exit(1) run_server(app) ioloop.add_future(gen.multi(init_futures), await_init) else: run_server(app) except Exception: log.exception('failed to initialize application') sys.exit(1)
def main(): kr_addr = os.environ.get("AS_WEB_ADDR", "0.0.0.0") kr_port = int(os.environ.get("AS_WEB_PORT", 5000)) debug = int(os.environ.get("AS_DEV", "0")) cfg.start_logging("web", debug) master_root, master_lang = cfg.get_master_version() logging.info(f"Master: {master_root}") ioloop = tornado.ioloop.IOLoop.current() ioloop.add_future( asyncio.ensure_future( async_main(captain.application(master_root, master_lang, debug), kr_addr, kr_port)), lambda _: None, ) logging.debug("Entering the IOLoop...") ioloop.start()
def main(): tornado.options.parse_command_line() ioloop = tornado.ioloop.IOLoop.instance() application.db = momoko.Pool( dsn='dbname=health user=postgres password=dangerous123 ' 'host=localhost port=5432', size=1, ioloop=ioloop, ) future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() future.result() http_server = tornado.httpserver.HTTPServer(application) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
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='ss1sx!sdazxcccv2bfsdf232ggjhjjhjkjhk@!~s=d453', login_url='/admin/login' ) super(Application, self).__init__(self.handlers, **self.settings) self.db_async = momoko.Pool( dsn=config.get_db_url(), 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 __getattr__(self, item): if item in self.dbs and self._motorclient is None: if mode == 'test': self._motorclient = motor.MotorClient(host=self.localhost, port=self.port) self._motorclient_realtime = self._motorclient else: self._motorclient = motor.MotorReplicaSetClient( ','.join(mongo_machines), replicaSet=REPLICASET_NAME, readPreference=ReadPreference.NEAREST) self._motorclient_realtime = motor.MotorReplicaSetClient( ','.join(mongo_machines), replicaSet=REPLICASET_NAME, readPreference=ReadPreference.PRIMARY) ioloop=tornado.ioloop.IOLoop.instance() @tornado.gen.coroutine def auth_db(): yield self._motorclient.open() yield self._motorclient_realtime.open() #print "+++++++++authing++++++++++" yield self._motorclient.fbt_log.authenticate(FBT_USER, FBT_PASSWD) yield self._motorclient_realtime.fbt.authenticate(FBT_USER, FBT_PASSWD) yield self._motorclient.fbt.authenticate(FBT_USER, FBT_PASSWD) yield self._motorclient.fbt_reward.authenticate(FBT_USER, FBT_PASSWD) #print "+++++++++authing OK++++++++++"+str(ok) #ioloop.run_sync(f) #ioloop.add_timeout(time() + 1, lambda: ioloop.run_sync(f)) ioloop.add_future(auth_db(), lambda future: True) self.dbs['fbt'] = self._motorclient.fbt self.dbs['reward'] = self._motorclient.fbt_reward self.dbs['fbt_realtime'] = self._motorclient_realtime.fbt #self.dbs['fbt_test'] = self._motorclient_realtime.fbt_test self.dbs['fbt_log'] = self._motorclient.fbt_log self.module.__dict__.update(self.dbs) return getattr(self.module, item)
def _async_init_cb(): try: init_futures = app.default_init_futures + list( app.init_async()) if init_futures: def await_init(future): if future.exception() is not None: log.error( 'failed to initialize application, init_async returned: %s', future.exception()) sys.exit(1) run_server(app) ioloop.add_future(gen.multi(init_futures), await_init) else: run_server(app) except Exception: log.exception('failed to initialize application') sys.exit(1)
def start(): app = tornado.web.Application( [ (r'^/$', pages.Index), (r'^/comment/list/$', pages.CommentList), (r'^/comment/add/$', pages.CommentAdd), (r'^/comment/edit/$', pages.CommentEdit), (r'^/comment/delete/$', pages.CommentDelete), (r'^/comment/log/$', pages.CommentLog), (r'^/comment/download/$', pages.CommentDownload), ], **{ 'debug': config.DEBUG, 'static_path': os.path.join(config.ROOT, 'static'), 'template_path': os.path.join(config.ROOT, 'templates'), }) ioloop = tornado.ioloop.IOLoop.instance() # Postgres app.pg = momoko.Pool( dsn=config.PG_DSN, size=1, max_size=config.PG_POOL_SIZE, cursor_factory=psycopg2.extras.NamedTupleCursor, ioloop=ioloop, ) future = app.pg.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() # Server app.listen(config.PORT) ioloop.start()
static_path=os.path.join(os.path.dirname(__file__), "static"), debug=True ) application = tornado.web.Application([ tornado.web.url(r"/", MainHandler), tornado.web.url(r"/CodeChef", CodeChef), tornado.web.url(r"/Codeforces", CodeForces), tornado.web.url(r"/hackerrank", HackerRank), tornado.web.url(r"/query/(.*)", Query), tornado.web.url(r"/db", DBHandler), ## To see the saved data tornado.web.url(r"/db/(.*)", DBQuery) ## To add or delete any data ], **settings) if __name__=="__main__": ioloop = tornado.ioloop.IOLoop.instance() application.db = momoko.Pool( dsn='dbname=testdb user=admin password='' host='' port=5432' , size=1, ioloop=ioloop ) future = application.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() future.result() server = tornado.httpserver.HTTPServer(application) server.listen(8888) print "Listening on http://127.0.0.1:8888" ioloop.start()
def report_error(**kwargs): """ Report an error to Rollbar assumes ROLLBAR_TOKEN is in the environment also looks for ENVIRONMENT, which defaults to development. :exc_info: if given, will be used instead of sys.exc_info() :request: a HTTPServerRequest or HTTPRequest """ token = os.environ.get('ROLLBAR_TOKEN') env = os.environ.get('ENVIRONMENT', 'development') if token is None: logger.error("no rollbar token, skipping error reporting") return exc_info = kwargs.pop('exc_info', None) if exc_info is None: exc_info = sys.exc_info() cls, exc, trace = exc_info raw_frames = traceback.extract_tb(trace) frames = [{'filename': f[0], 'lineno': f[1], 'method': f[2], 'code': f[3]} for f in raw_frames] payload = { 'access_token': token, 'data': { 'environment': env, 'body': { 'trace': { 'frames': frames, 'exception': { 'class': cls.__name__, 'message': str(exc) }, }, }, } } if hasattr(exc, 'response'): response = exc.response payload['data']['custom'] = { 'request': _parse_request(response.request), 'response': { 'code': response.code, 'headers': response.headers, 'body': str(response.body, 'utf8'), 'url': response.effective_url, } } if 'request' in kwargs: payload['data']['request'] = _parse_request(kwargs['request']) logger.error("Reporting error") client = AsyncHTTPClient() f = client.fetch(ROLLBAR_URL, method='POST', headers={'Content-type': 'application/json'}, body=json.dumps(payload)) ioloop = tornado.ioloop.IOLoop.instance() ioloop.add_future(f, _handle)
def __init__(self): settings = dict( 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="cookie_secret_code", login_url="/login", autoescape=None, jinja2=Environment(loader=FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates")), trim_blocks=True), reserved=[ "user", "home", "setting", "forgot", "login", "logout", "register", "admin" ], ) handlers = [ (r"/", index.IndexHandler), (r"/login", user.LoginHandler), (r"/logout", user.LogoutHandler), (r"/nodes_list", node.NodeListHandler), (r"/nodes_nearby", node.GetNodesNearbyHandler), (r"/get_nodes", node.GetNodesHandler), (r"/node/(.*)", node.NodeDetailHandler), (r"/get_pkts", node_pkt.GetPktsHandler), (r"/get_latest_pkt", node_pkt.GetLatestPktInfoHandler), (r"/get_history", node_pkt.GetHistoryHandler), (r"/lora/push", node_pkt_push.NodePktPushHandler), (r"/(favicon\.ico)", tornado.web.StaticFileHandler, dict(path=settings["static_path"])), (r"/(sitemap.*$)", tornado.web.StaticFileHandler, dict(path=settings["static_path"])), (r"/(bdsitemap\.txt)", tornado.web.StaticFileHandler, dict(path=settings["static_path"])), ] tornado.web.Application.__init__(self, handlers, **settings) ioloop = tornado.ioloop.IOLoop.instance() self.db = momoko.Pool( dsn= 'dbname=lora user=postgres password=cisco123 host=9.9.9.14 port=5432', size=1, ioloop=ioloop) future = self.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() future.result() self.cluster = Cluster(['9.9.9.5']) self.session = self.cluster.connect('lora') self.cass_conn = TornadoCassandra(self.session, ioloop=ioloop) # Have one global model for db query self.user_model = UserModel(self.db) self.node_model = NodeModel(self.db) self.node_pkt_model = NodePktModel(self.cass_conn) # Have one global session controller self.session_manager = SessionManager(settings["cookie_secret"], ["127.0.0.1:11211"], 0) # Have one global memcache controller self.mc = memcache.Client(["127.0.0.1:11211"])
def _async_init_cb(): try: ioloop.add_future(tornado_app.init_async(), _run_server_cb) except Exception: log.exception('failed to initialize application') sys.exit(1)
def test_future(): future = Future() threading.Thread(target=long_task, args=(future,)).start() ioloop.add_future(future, after_task_done)
def delay_task(func, callback=None, *args, **kw): asynfutu = executor.submit(func, *args, **kw) if callback: tonafutu = to_tornado_future(asynfutu) ioloop = tornado.ioloop.IOLoop.current() ioloop.add_future(tonafutu, callback)