def save_config(): logging.info("Saving current config to: %s" % options.config) with open(options.config, 'w') as fp: fp.write("##########################") fp.write(" Root the Box Config File ") fp.write("##########################\n") fp.write("# Last updated: %s\n" % datetime.now()) for group in options.groups(): # Shitty work around for Tornado 4.1 if 'rootthebox.py' in group.lower() or group == '': continue fp.write("\n# [ %s ]\n" % group.title()) try: # python2 opt = options.group_dict(group).iteritems() except AttributeError: # python3 opt = options.group_dict(group).items() for key, value in opt: try: # python2 value_type = basestring except NameError: # python 3 value_type = str if isinstance(value, value_type): # Str/Unicode needs to have quotes fp.write(u'%s = "%s"\n' % (key, value)) else: # Int/Bool/List use __str__ fp.write('%s = %s\n' % (key, value))
def main(): if os.path.exists(options.config_file): parse_config_file(options.config_file) parse_command_line() app = Application( [ url(r'/token/?', auth.TokenHandler), url(r'/tasks/?', tasks.TaskHandler), url(r'/tasks/({uuid})/?'.format(uuid=UUID_PATTERN), tasks.TaskHandler), url(r'/domains/?', vms.DomainHandler), url(r'/domains/({uuid})/?'.format(uuid=UUID_PATTERN), vms.DomainHandler), url(r'/nodes/?', vms.NodeHandler), url(r'/nodes/([\d+])/?', vms.NodeHandler) ], template_path=os.path.join(BASE_DIR, 'templates'), static_path=os.path.join(BASE_DIR, 'static'), **options.group_dict('application') ) app.listen(options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.current().add_callback(start_queue, app) IOLoop.current().start()
def main(): """Construct and serve the tornado application.""" api_root = '/api/v1' app = Application( handlers=[ (r'/', HomeView), (r'/favicon.ico', HomeView), (r'/error_500', ErrorView), (api_root, InfoView), (api_root + r'/login', LoginView), (api_root + r'/accounts', RegistrationView), (api_root + r'/accounts/([\w]+)', ProfileView), (api_root + r'/accounts/([\w]+)/tasks', TaskListView), (api_root + r'/accounts/([\w]+)/tasks/([\d]+)', TaskView), (api_root + r'/accounts/([\w]+)/logout', LogoutView), ], db=SQLAlchemy( os.environ.get( 'DATABASE_URL', 'postgres://*****:*****@localhost:5432/task_manager')), cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", **options.group_dict('application'), login_url="/api/v1/login", xsrf_cookies=True, debug=True, static_path=os.path.join(os.path.dirname(__file__), "static"), template_path=os.path.join(os.path.dirname(__file__), "templates")) http_server = HTTPServer(app) http_server.listen(options.port) print('Listening on http://localhost:%d' % options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.current().start()
def setup_options(self): name = self.name opts = options.group_dict(f'{name} database') uri = opts[option_name(name, 'uri')] r = urlparse(uri) q = query_as_dict(r.query) if r.scheme.lower() != 'mysql': raise MysqlConnectorError( f'{uri} is not a mysql connection scheme') self._host = r.hostname or 'localhost' self._port = r.port or 3306 self._user = r.username self._password = r.password self._db = r.path.lstrip('/') or r.username self._charset = q.get('charset') or 'utf8mb4' fmt = ('host={host} port={port} dbname={db} ' 'user={user} password={pw} charset={charset}') dsn = fmt.format(host=self._host, port=self._port, user=self._user, pw=self._password, db=self._db, charset=self._charset) self._connection_string = dsn self._num_connections = opts[option_name(name, 'num-connections')] self._pool_recycle = opts[option_name(name, 'pool-recycle')]
def main(): define("debug", default=False, help="Run in debug mode") options.parse_command_line() settings = {} settings.update(options.group_dict(None)) settings.update(tornado_jsonapi.handlers.not_found_handling_settings()) conn = sqlite3.connect(":memory:") r = tornado_jsonapi.resource.DBAPI2Resource(schema, sqlite3, conn) r._create_table() cur = conn.cursor() for i in range(1, 16): cur.execute("INSERT INTO posts(text,author) VALUES(?,?)", ("Text" + str(i), str(i))) application = tornado.web.Application([ ( r"/api/posts/([^/]*)", tornado_jsonapi.handlers.APIHandler, dict(resource=r), ), ], **settings) application.listen(8888) tornado.ioloop.IOLoop.current().start()
def start(prefix, settings, modules, routes, known_exceptions, **kwargs): """starts the tornado application. :param prefix: the url prefix :param settings: the user defined settings :param modules: the modules to load :param handlers: the list of url routes (url, handler) :param known_exceptions: the mapping of known exceptions to HTTP codes :param kwargs: the tornado application arguments """ from tornado.options import options options.define( "config", type=str, help="path to config file", callback=lambda p: options.parse_config_file(p, final=False)) options.define("port", default=8000, help="listening port", type=int) options.define("address", default='127.0.0.1', help="listening address") options.add_parse_callback(log.patch_logger) loop = _get_event_loop() modules_registry = ModulesRegistry(loop.asyncio_loop, log.gen_log) for module in modules: modules_registry.lazy_load(module, options) for opt in settings: options.define(**opt) options.parse_command_line(final=True) if not prefix.endswith('/'): prefix += '/' kwargs.update(options.group_dict('application')) kwargs.setdefault('default_handler_class', handler.DefaultHandler) # prevent override this option kwargs['known_exceptions'] = known_exceptions kwargs['modules'] = modules_registry handlers = [] for uri, methods in routes: log.app_log.info("add resource: %s", uri) handlers.append((_concat_url(prefix, uri), compile_handler(methods))) app = web.Application(handlers, **kwargs) app.listen(options.port, options.address, xheaders=True) signal.signal(signal.SIGTERM, lambda *x: loop.stop()) log.app_log.info("start listening on %s:%d", options.address, options.port or 80) try: loop.start() except (KeyboardInterrupt, SystemExit): pass loop.close() log.app_log.info("gracefully shutdown.")
async def infinite_update_loop(): while True: await asyncio.sleep( UPDATE_PERIOD ) # switch to other code and continue execution in 5 seconds db = options.group_dict('db') dbpass = db['password'] dbuser = db['username'] dbhost = db['host'] dbname = db['name'] dbport = db['port'] session = queries.TornadoSession( f'postgresql://{dbuser}:{dbpass}@{dbhost}:{dbport}/{dbname}') ## DETERMINE IF THERE WAS AN UPDATE OR NOT BY CHECKING IN THE PASSED XX SECONDS (which should coincide with ## HOW EVER LONG WE WAIT BAHHHH!HHH!HH!H!!HHHH if update: logger.debug(f"sending update, next update in {UPDATE_PERIOD}") for connection in connections: await to_asyncio_future( connection.write_message(msg) ) # send message to each connected client else: logger.debug(f"next update in {UPDATE_PERIOD}")
def main(): define("debug", default=False, help="Run in debug mode") options.parse_command_line() settings = {} settings.update(options.group_dict(None)) settings.update(tornado_jsonapi.handlers.not_found_handling_settings()) io_loop = tornado.ioloop.IOLoop.current() # connect to postgre using momoko # see http://momoko.61924.nl/en/latest/tutorial.html#trival-example conn = momoko.Pool( 'dbname=postgres ' 'user=postgres ' 'host=localhost ' 'port=5432', ioloop=io_loop) future = conn.connect() io_loop.add_future(future, lambda x: io_loop.stop()) io_loop.start() connection = future.result() # raises exception on connection error r = tornado_jsonapi.resource.DBAPI2Resource(schema, momoko, connection) io_loop.add_future(r._create_table(), lambda x: io_loop.stop()) io_loop.start() application = tornado.web.Application([ (r"/api/posts/([^/]*)", tornado_jsonapi.handlers.APIHandler, dict(resource=r)), ], **settings) application.listen(8888) io_loop.start()
def save_config(): logging.info("Saving current config to: %s" % options.config) with open(options.config, "w") as fp: fp.write("##########################") fp.write(" Root the Box Config File ") fp.write("##########################\n") fp.write( "# Documentation: %s\n" % "https://github.com/moloch--/RootTheBox/wiki/Configuration-File-Details" ) fp.write("# Last updated: %s\n" % datetime.now()) for group in options.groups(): # Shitty work around for Tornado 4.1 if "rootthebox.py" in group.lower() or group == "": continue fp.write("\n# [ %s ]\n" % group.title()) opt = list(options.group_dict(group).items()) for key, value in opt: try: # python2 value_type = basestring except NameError: # python 3 value_type = str if isinstance(value, value_type): # Str/Unicode needs to have quotes fp.write('%s = "%s"\n' % (key, value)) else: # Int/Bool/List use __str__ fp.write("%s = %s\n" % (key, value))
def export_game_config(self, root): """ Exports the game configuration options to an XML doc. """ game_elem = ET.SubElement(root, "configuration") game_list = options.group_dict("game") images = ["ctf_logo", "story_character", "scoreboard_right_image"] for key in game_list: value = game_list[key] if key in images and len(value) > 0: if os.path.isfile(value): path = value elif os.path.isfile(os.path.join("files", value)): path = os.path.join("files", value) elif value[0] == "/" and os.path.isfile(value[1:]): path = value[1:] else: continue with open(path, mode="rb") as logo: data = logo.read() ET.SubElement(game_elem, key).text = encode(data, "base64") elif isinstance(value, list): child = ET.Element(key) game_elem.append(child) for item in value: ET.SubElement(child, "line").text = str(item) elif len(str(value)) > 0: ET.SubElement(game_elem, key).text = str(value)
async def connect(self, load_balancing_policy=None): name = self.name opts = options.group_dict(f'{name} cassandra') uri = opts[option_name(name, 'uri')] r = urlparse(uri) query_as_dict(r.query) if r.scheme.lower() != 'cassandra': raise CassandraConnectorError( f'{uri} is not a cassandra connection scheme') self._hosts = r.hostname.split(',') if r.hostname else ['127.0.0.1'] self._port = r.port or 9042 self._keyspace = None self._user = r.username self._password = r.password keyspace = r.path.lstrip('/') if keyspace: self._keyspace = keyspace executor_threads = opts[option_name(name, 'executor-threads')] _load_balancing_policy = load_balancing_policy or RoundRobinPolicy() LOG.info(f'connecting cassandra [{self.name}] {uri}') auth_provider = PlainTextAuthProvider( username=self._user, password=self._password) # TODO 选取合适的loadbalancingpolicy # Cluster.__init__ called with contact_points specified # should specify a load-balancing policy # http://datastax.github.io/python-driver/_modules/cassandra/cluster.html#Cluster # NOQA # RoundRobinPolicy: # http://datastax.github.io/python-driver/_modules/cassandra/policies.html#RoundRobinPolicy # NOQA cluster = Cluster(contact_points=self._hosts, port=self._port, executor_threads=executor_threads, load_balancing_policy=_load_balancing_policy, auth_provider=auth_provider) self._session = cluster.connect(keyspace=self._keyspace) aiosession(self._session)
async def connect(self, event_loop=None): if event_loop is None: event_loop = asyncio.get_event_loop() name = self.name opts = options.group_dict(f'{name} queue') uri = opts[option_name(name, 'uri')] LOG.info(f'connecting amqp [{self.name} {uri}') self._connection = await connect_robust(uri, loop=event_loop)
def run_server(): bootstrap() client = connect_to_mongo() database = client['tinyurld'] app = make_app(database, options.group_dict('application')) tornado.log.app_log.info('Start application at {}:{} port'.format(options.host, options.port)) app.listen(options.port, address=options.host) IOLoop.current().start()
async def connect(self, event_loop=None): if event_loop is None: event_loop = asyncio.get_event_loop() name = self.name opts = options.group_dict('%s queue' % name) uri = opts[option_name(name, "uri")] LOG.info('connecting amqp [%s] %s' % (self.name, uri)) self._connection = await connect_robust(uri, loop=event_loop)
def run_server(): bootstrap() client = connect_to_mongo() database = client['tinyurld'] app = make_app(database, options.group_dict('application')) tornado.log.app_log.info('Start application at {}:{} port'.format( options.host, options.port)) app.listen(options.port, address=options.host) IOLoop.current().start()
def start(prefix, settings, modules, routes, known_exceptions, **kwargs): """starts the tornado application. :param prefix: the url prefix :param settings: the user defined settings :param modules: the modules to load :param handlers: the list of url routes (url, handler) :param known_exceptions: the mapping of known exceptions to HTTP codes :param kwargs: the tornado application arguments """ from tornado.options import options options.define("config", type=str, help="path to config file", callback=lambda p: options.parse_config_file(p, final=False)) options.define("port", default=8000, help="listening port", type=int) options.define("address", default='127.0.0.1', help="listening address") options.add_parse_callback(log.patch_logger) loop = _get_event_loop() modules_registry = ModulesRegistry(loop.asyncio_loop, log.gen_log) for module in modules: modules_registry.lazy_load(module, options) for opt in settings: options.define(**opt) options.parse_command_line(final=True) if not prefix.endswith('/'): prefix += '/' kwargs.update(options.group_dict('application')) kwargs.setdefault('default_handler_class', handler.DefaultHandler) # prevent override this option kwargs['known_exceptions'] = known_exceptions kwargs['modules'] = modules_registry handlers = [] for uri, methods in routes: log.app_log.info("add resource: %s", uri) handlers.append((_concat_url(prefix, uri), compile_handler(methods))) app = web.Application(handlers, **kwargs) app.listen(options.port, options.address, xheaders=True) signal.signal(signal.SIGTERM, lambda *x: loop.stop()) log.app_log.info("start listening on %s:%d", options.address, options.port or 80) try: loop.start() except (KeyboardInterrupt, SystemExit): pass loop.close() log.app_log.info("gracefully shutdown.")
def decorator(self, *args, **kwargs): user = HandlerMethods.get_current_user(self) if not user: self.set_status(401) self.write({'status': 'error', 'message': 'not authorized'}) else: self.user_authenticator = pickle.loads(user) self.user_authenticator.xen = XenAdapter({**opts.group_dict('xenadapter'), **opts.group_dict('rethinkdb')}) self.xen = self.user_authenticator.xen return method(self)
def initialize(self): logger.debug("setting up db session") db = options.group_dict('db') dbpass = db['password'] dbuser = db['username'] dbhost = db['host'] dbname = db['name'] dbport = db['port'] self.session = queries.TornadoSession( f'postgresql://{dbuser}:{dbpass}@{dbhost}:{dbport}/{dbname}')
def start(name, io_loop=None): opt_name = '' if name == 'master' else '-%s' % name postgres_settings = tornado_options.group_dict('%s database' % name) instance = PostgreSQLConnector.instance(name) uri = postgres_settings['postgres%s-uri' % opt_name] if not io_loop: io_loop = tornado.ioloop.IOLoop.instance() def _start(): return instance.connect(uri, **postgres_settings) #io_loop.add_future(f, _done) io_loop.run_sync(_start)
def get_engine(db_path=None): """Create and return engine. If db_path is not given, settings in app.conf are used""" global engine if not engine: if not db_path: db_path = options.db_path % options.group_dict('db') engine = create_engine(db_path, convert_unicode=True, echo=options.db_debug, pool_size=POOL_SIZE) return engine
def main(): parse_command_line(final=False) parse_config_file(options.config_file) app = Application([("/", MainHandler), ("/login", LoginHandler), ("/logout", LogoutHandler)], login_url="/login", **options.group_dict("application")) app.listen(options.port) logging.info("Listening on http://localhost:%d" % options.port) IOLoop.current().start()
def main(): parse_command_line(final=False) parse_config_file(options.config_file) app = Application( [("/", MainHandler), ("/login", LoginHandler), ("/logout", LogoutHandler)], login_url="/login", **options.group_dict("application") ) app.listen(options.port) logging.info("Listening on http://localhost:%d" % options.port) IOLoop.current().start()
def main(): parse_command_line(final=False) parse_config_file(options.config_file) app = Application([ ('/', MainHandler), ('/login', LoginHandler), ('/logout', LogoutHandler), ], login_url='/login', **options.group_dict('application')) app.listen(options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.instance().start()
def main(): if os.path.exists(options.config_file): parse_config_file(options.config_file) parse_command_line() app = Application([ url(r'/directions/?', directions.DirectionsHandler), url(r'/routes/?', routes.RoutesHandler), url(r'/routes/({uuid})/?'.format(uuid=UUID4_PATTERN), routes.RoutesHandler), ], **options.group_dict('application')) app.listen(port=options.port, address=options.host) logging.info('Listening on http://%s:%d' % (options.host, options.port)) IOLoop.current().start()
def main(): define("debug", default=False, help="Run in debug mode") options.parse_command_line() settings = {} settings.update(options.group_dict(None)) settings.update(tornado_jsonapi.handlers.not_found_handling_settings()) application = tornado.web.Application([ ( r"/api/posts/([^/]*)", tornado_jsonapi.handlers.APIHandler, dict(resource=Posts(json.loads(open("data.json").read()))), ), ], **settings) application.listen(8888) tornado.ioloop.IOLoop.current().start()
def make_app(): wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) urls_to_tornado = [ (r'/static/?(.*)', tornado.web.StaticFileHandler, { 'path': STATIC_ROOT, 'default_filename': 'index.html' }), (r'/api/(.*)', tornado.web.FallbackHandler, dict(fallback=container)), (r'/?(.*)', tornado.web.StaticFileHandler, { 'path': ANGULARJS_APP, 'default_filename': 'index.html' }), ] return tornado.web.Application(urls_to_tornado, **options.group_dict('application'))
def main(): parse_command_line(final=False) parse_config_file(options.config) handlers = [ URLSpec("/", MainHandler, name="root"), URLSpec("/login", LoginHandler, name="login"), URLSpec("/logout", LogoutHandler, name="logout") ] app = Application(handlers, login_url="/login", **options.group_dict("application")) app.listen(options.port) logging.info("Listening on http://localhost:%d" % options.port) IOLoop.current().start()
def main(): parse_command_line(final=False) parse_config_file(options.config_file) app = Application( [ ('/', MainHandler), ('/login', LoginHandler), ('/logout', LogoutHandler), ], login_url='/login', **options.group_dict('application')) app.listen(options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.instance().start()
def main(): define("debug", default=False, help="Run in debug mode") options.parse_command_line() settings = {} settings.update(options.group_dict(None)) settings.update(tornado_jsonapi.handlers.not_found_handling_settings()) r = tornado_jsonapi.resource.DBAPI2Resource(schema, sqlite3, sqlite3.connect(':memory:')) r._create_table() application = tornado.web.Application([ (r"/api/posts/([^/]*)", tornado_jsonapi.handlers.APIHandler, dict(resource=r)), ], **settings) application.listen(8888) tornado.ioloop.IOLoop.current().start()
def prepare(self): super().prepare() #copy some members to context, we'll use then in a resolvers self.request.async_run = self.async_run self.request.log = self.log self.request.actions_log = self.actions_log user = self.get_current_user() self.request.executor = self.executor if user: self.request.user_authenticator = pickle.loads(user) self.request.user_authenticator.xen = XenAdapter({**opts.group_dict('xenadapter'), **opts.group_dict('rethinkdb')}) self.request.set_task_status = lambda **operation: self.op.upsert_task(self.request.user_authenticator, operation) self.request.get_task_status = lambda id: self.op.get_task(self.request.user_authenticator, id) self.request.conn = self.conn
def main(): tornado.options.parse_command_line() if options.config: config_to_read = options.config else: config_to_read = './server.conf' tornado.options.parse_config_file(config_to_read) if options.debug: logging.getLogger("palnot.server").setLevel(logging.DEBUG) http_server = tornado.httpserver.HTTPServer(setup_application(options.group_dict('application'))) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def make_app(): """ Create a Tornado app for BackendWebServer. """ return tornado.web.Application( [("/", MainHandler), (r"/archive", ArchiveHandler), (r"/ranking", RankingHandler), (r"/problem/.+", ProblemHandler), (r"/contestlist", ContestListHandler), (r"/submissions", SubmissionsHandler), (r"/submission", SubmissionDetailsHandler), (r"/register", RegisterHandler), (r"/contest/.+", ContestHandler), (r"/contest/.+/problem/.+", ProblemHandler), (r"/user/.+", UserHandler), (r"/login", LoginHandler), (r"/logout", LogoutHandler), (r"/confirm/.+", UserConfirmationHandler), (r"/recovery/.+", RecoveryHandler)], **options.group_dict('application'))
def save_config(): logging.info("Saving current config to: %s" % options.config) with open(options.config, 'w') as fp: fp.write("##########################") fp.write(" Sonar Server Config File ") fp.write("##########################\n") fp.write("# Last updated: %s\n" % datetime.now()) for group in options.groups(): if group.lower() in SKIP_GROUPS or group == '': continue fp.write("\n# [ %s ]\n" % group.title()) for key, value in options.group_dict(group).iteritems(): if isinstance(value, basestring): # Str/Unicode needs to have quotes fp.write(u'%s = "%s"\n' % (key, value)) else: # Int/Bool/List use __str__ fp.write('%s = %s\n' % (key, value))
def setup_options(self): name = self.name opts = options.group_dict(f'{name} database') uri = opts[option_name(name, 'uri')] r = urlparse(uri) if r.scheme.lower() != 'postgres': raise PostgresConnectorError( f'{uri} is not a postgres connection scheme') fmt = ('host={host} port={port} dbname={db} user={user} password={pw}') dsn = fmt.format(host=r.hostname or 'localhost', port=r.port or 5432, user=r.username, pw=r.password, db=r.path.lstrip('/') or r.username) self._connection_string = dsn self._reconnect_interval = opts[option_name(name, 'reconnect-interval')] self._num_connections = opts[option_name(name, 'num-connections')]
def main(): define("debug", default=False, help="Run in debug mode") options.parse_command_line() settings = {} settings.update(options.group_dict(None)) settings.update(tornado_jsonapi.handlers.not_found_handling_settings()) engine = create_engine('sqlite:///:memory:', echo=settings['debug']) Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) application = tornado.web.Application([ (r"/api/posts/([^/]*)", tornado_jsonapi.handlers.APIHandler, dict(resource=tornado_jsonapi.resource.SQLAlchemyResource( Post, Session))), ], **settings) application.listen(8888) tornado.ioloop.IOLoop.current().start()
def main(): """Construct and serve the application.""" api_root = '/api/v1' app = Application([ (api_root, InfoView), (api_root + r'/accounts', RegistrationView), (api_root + r'/accounts/([\w]+)', ProfileView), (api_root + r'/accounts/([\w]+)/tasks', TaskListView), (api_root + r'/accounts/([\w]+)/tasks/([\d]+)', TaskView), ], session_factory=factory, cookie_secret=os.environ.get('SESSION_SECRET', 'beefy'), **options.group_dict('application'), ) http_server = HTTPServer(app) http_server.listen(options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.current().start()
def main(): if os.path.exists(options.config_file): parse_config_file(options.config_file) parse_command_line() app = Application( [ url(r'/directions/?', directions.DirectionsHandler), url(r'/routes/?', routes.RoutesHandler), url(r'/routes/({uuid})/?'.format(uuid=UUID4_PATTERN), routes.RoutesHandler), ], **options.group_dict('application') ) app.listen(port=options.port, address=options.host) logging.info('Listening on http://%s:%d' % (options.host, options.port)) IOLoop.current().start()
def main(): parse_command_line(final=False) parse_config_file(options.config) handlers = [ URLSpec("/", MainHandler, name="root"), URLSpec("/login", LoginHandler, name="login"), URLSpec("/logout", LogoutHandler, name="logout") ] app = Application( handlers, login_url="/login", **options.group_dict("application") ) app.listen(options.port) logging.info("Listening on http://localhost:%d" % options.port) IOLoop.current().start()
async def connect(self, event_loop=None): name = self.name opts = options.group_dict('%s redis' % name) connection_string = opts[option_name(name, "uri")] r = urlparse(connection_string) if r.scheme.lower() != 'redis': raise RedisConnectorError('%s is not a redis connection scheme' % connection_string) num_connections = opts[option_name(name, "num-connections")] LOG.info('connecting redis [%s] %s' % (self.name, connection_string)) if event_loop is None: event_loop = asyncio.get_event_loop() self._connections = await aioredis.create_pool( connection_string, encoding="UTF-8", minsize=int(num_connections[0]), maxsize=int(num_connections[-1]), loop=event_loop)
async def connect(self, event_loop=None): name = self.name opts = options.group_dict(f'{name} redis') connection_string = opts[option_name(name, 'uri')] r = urlparse(connection_string) if r.scheme.lower() != 'redis': raise RedisConnectorError( f'{connection_string} is not a redis connection scheme') num_connections = opts[option_name(name, 'num-connections')] LOG.info(f'connecting redis [{self.name}] {connection_string}') if event_loop is None: event_loop = asyncio.get_event_loop() self._connections = await aioredis.create_pool( connection_string, encoding='UTF-8', minsize=int(num_connections[0]), maxsize=int(num_connections[-1]), loop=event_loop, )
def main(): tornado.options.parse_command_line() if options.config: config_to_read = options.config else: config_to_read = './server.conf' tornado.options.parse_config_file(config_to_read) if options.debug: logging.getLogger("arduino.server").setLevel(logging.DEBUG) init(options.database_file) http_server = tornado.httpserver.HTTPServer(setup_application(options.group_dict('application'))) http_server.listen(os.getenv('OIKOSENSE_PORT', options.port)) if os.getenv('OIKOSENSE_ARDUINO_TTY', options.arduino_tty): hermes_server = SonersServer(hermes_urls) hermes_server.listen(os.getenv('OIKOSENSE_ARDUINO_TTY', options.arduino_tty)) tornado.ioloop.IOLoop.instance().start()
def make_app(): return Application([ url(r"/", MainHandler), ], **options.group_dict("application"))
def __init__(self, handlers, config='settings.py', **kwargs): # trigger parse_config_file options.config = config settings = options.group_dict('app') settings.update(kwargs) super(Application, self).__init__(handlers,**settings)
""" Observations """ from fieldDaySiteObservationsHandler import FieldDaySiteObservationsHandler """ Volunteers """ from volunteerHandler import VolunteerListHandler from baseHandler import BaseAuthenticatedHandler import importlib """ Determine which storage engine is specified in the user config and import the appropriate modules to support that """ try: persistenceOptions = options.group_dict("persistence") except KeyError: raise else: """ Mongo DB Persistence """ if "mongo_instance" in persistenceOptions: from pymongo import MongoClient mongoClient = MongoClient(persistenceOptions["mongo_instance"]) mongoDb = mongoClient[persistenceOptions["mongo_database"]] if "mongo_user" in persistenceOptions and persistenceOptions["mongo_user"]: mongoDb.authenticate(persistenceOptions["mongo_user"], persistenceOptions["mongo_password"]) else: noMongoMessage = "Warning! No persistence engine was specified for Field Day List - See localSettings.py.sample for examples" print noMongoMessage print "Using Dummy persistence instead - That's ok for Demos"