def __init__(self): handlers = [ (r'/api/signup', SignupHandler), (r'/api/token/get', TokenGetHandler), (r'/api/token/renew', TokenRenewHandler), (r'/api/key/get', GetKeyHandler), (r'/api/test', TestApiHandler) ] settings = dict( login_url='/login', debug=True ) super(Application, self).__init__(handlers, **settings) # MongoDB self.db = MotorClient(**MONGODB_HOST)[MONGODB_DBNAME] # ThreadPoolExecutor for long tasks like password hashing self.executor = ThreadPoolExecutor(WORKERS) # Secret key for HMAC self.hmac_key = nacl.utils.random(size=APP_SECRETKEY_SIZE)
def initialize(connection_string): database = MotorClient(connection_string).experiment database.add_son_manipulator(ObjectIdAsTimestamp()) session_status = model.SessionStatus() sessions = model.Sessions(database) seeder = model.Final() snippets = model.Snippets() emails = model.Emails(database) trials = model.Trials(database) template_path = './static/templates/' def static(pattern): return url(pattern, web.Page, dict(path=template_path)) def template(file_, **kwargs): t = dict(path=template_path + '%s' % file_) t.update(kwargs) return t routes = [ url(r'/', web.Home, template('home.html', sessions=sessions, trials=trials)), static(r'/(questions)/?'), static(r'/(tutorial)/?'), static(r'/(experiment)/?'), url(r'/(complete)/?', web.CompletePage, dict(path=template_path)), url(r'/admin/?', web.Admin, template('admin.html', sessions=sessions)), url(r'/admin/login?', web.AdminLogin), url(r'/admin/logout?', web.AdminLogout), url(r'/admin/clear?', web.AdminClearUserCookie), url(r'/api/trial/?', api.Trial, dict(sessions=sessions, trials=trials)), url(r'/api/sessions/?', api.Sessions, dict(sessions=sessions)), #Test url( r'/api/form/?', api.Form, dict(sessions=sessions, session_status=session_status, trials=trials)), # post #url(r'/api/email/?', api.EmailForm, dict(emails=emails)), # post url(r'/api/admin/db\.json', api.AdminDbDump, dict(sessions=sessions)), url(r'/api/admin/sessions/?', api.AdminSessions, dict(sessions=sessions)), url(r'/api/admin/emails/?', api.AdminEmails, dict(emails=emails)), url(r'/api/admin/sessions/([\w^/]+)?', api.AdminSessionData, dict(sessions=sessions)), url(r'/api/admin/trials/?', api.AdminTrials, dict(trials=trials, seeder=seeder)), url(r'/api/admin/trials/([\w^/]+)?', api.AdminUpdateTrials, dict(trials=trials)), url(r'/api/admin/duplicates/?', api.Duplicates, dict(sessions=sessions, trials=trials)), url(r'/api/admin/missing/?', api.Missing, dict(sessions=sessions, trials=trials)), url(r'/api/admin/snippets/?', api.AdminSnippets, dict(snippets=snippets)), ] return routes
def setUp(self): super(AsyncLRUTest, self).setUp() self.sr = redis.StrictRedis() self.ar = AsyncStrictRedis() self.m = MotorClient() self.c = self.m.my_test self.io_loop.run_sync(self.setup_coro)
def __init__(self): handlers = [(r'/', TestWebHandler), (r'/login', LoginHandler), (r'/logout', LogoutHandler), (r'/api/signup', SignupHandler), (r'/api/token/get', TokenGetHandler), (r'/api/token/renew', TokenRenewHandler), (r'/api/key/get', GetKeyHandler), (r'/api/test', TestApiHandler)] template_path = os.path.join(os.path.dirname(__file__), 'templates') settings = { 'template_path': template_path, 'login_url': '/login', 'debug': DEBUG, 'xsrf_cookies': True, 'cookie_secret': nacl.utils.random(size=64) } super(WebApp, self).__init__(handlers, **settings) self.token_expires_time = TOKEN_EXPIRES_TIME # MongoDB self.db = MotorClient(**DBHOST)[DBNAME] # ThreadPoolExecutor for long tasks like password hashing self.executor = ThreadPoolExecutor(WORKERS) # Secret key for HMAC self.hmac_key = nacl.utils.random(size=64)
class RESTserver(AsyncTCPServer): db = MotorClient('localhost', 27017) @coroutine def handle_stream(self, stream, address): connection = HandlerClient(stream, address, RESTserver.db) yield connection.on_connect()
def connect(cfg): """connect to mongo database :param cfg: Dictionary containing configuration for MongoDB connection :type cfg: dict """ args = { 'tz_aware': cfg.get('tz_aware', False), 'replicaset': cfg.get('replicaset', cfg.get('replica_set')) } if 'uri' in cfg: args['host'] = cfg['uri'] else: args['host'] = cfg.get('host', 'localhost') args['port'] = int(cfg.get('port', 27017)) client = MotorClient(*args) if cfg.get('user'): yield client[cfg['db']].authenticate(cfg['user'], cfg['password']) if cfg.get('read_preference'): read_preference = cfg['read_preference'].upper() client.read_preference = getattr( pymongo.read_preferences.ReadPreference, read_preference) raise gen.Return(client)
def create_app(checker: BaseChecker, mongo_url: str = "mongodb://mongodb:27017") -> None: logger = logging.getLogger(__name__) mongo = MotorClient(mongo_url)[checker.name] app = tornado.web.Application([ (r"/", EnoCheckerRequestHandler) ], logger=logger, checker=checker, mongo=mongo) app.listen(checker.checker_port) tornado.ioloop.IOLoop.current().start()
def setUpClass(self): self.my_app.db = MotorClient(**MONGODB_HOST)[MONGODB_DBNAME] self.my_app.executor = ThreadPoolExecutor(WORKERS) self.my_app.whitelist = WHITELIST self.my_app.hmac_key = random(size=APP_SECRETKEY_SIZE)
def create_app(): client = MotorClient(DATABASE_SETTINGS['url']) db = client[DATABASE_SETTINGS['name']] return web.Application([ web.url(r'/', IndexHandler, {'db': db}, name='index'), web.url(r'/index', IndexHandler, {'db': db}), web.url(r'/success', SuccessHandler, {'db': db}), ], **TORNADO_SETTINGS)
def create_pool(para): """ 生成数据库连接池 :param para: 数据库配置参数 :param cursor_class: :return: """ client = MotorClient(para['mongo_auth_url']) return client
def get_db_conn(db_name='iot_simple_api'): conn = MotorClient(MONGODB_URI) db = conn[db_name] # Create a capped collection to Stream data db.create_collection('stream', capped=True, size=DEFAULT_COLLECTION_SIZE, callback=lambda x, y: (x, y)) return db, conn
async def testFunc(): motor = MotorClient( 'mongodb://*****:*****@172.16.60.199:27019/IFData' ) storage = Storage(motor.IFData) get = await storage.append('DBTest', '2020-07-25T15:37:45.318000+08:00', 'FetchTime', filter={'FetchTime': 1}) print(get)
def setUp(self): super(MyTestCase, self).setUp() self.client = MotorClient() # wait for the setup coroutine to complete before beginning the test self.io_loop.run_sync(self.setup_coro) # for visual control client = MongoClient() db = client.test cursor = db.collection.find() for document in cursor: print(document)
def __init__(self): self.client = MotorClient() self.withdraw_db = self.client.withdraw_db self.available_tokens = self.withdraw_db.available_tokens self.withdraw_requests = self.withdraw_db.withdraw_requests self.withdraw_custom_token_requests = self.withdraw_db.withdraw_custom_token_requests self.create_token_requests = self.withdraw_db.create_token_requests self.executed_withdraws = self.withdraw_db.executed_withdraws self.withdraw_db["tokens"].create_index("contract_address", unique=True)
def __test(): import logging import sys from motor import MotorClient logging.basicConfig( stream=sys.stdout, level=logging.DEBUG, format='[%(asctime)s] %(levelname)s %(module)s:%(lineno)d %(message)s') register(logging) client = MotorClient() client.test.collection.insert({'message': 'hi!'})
def __init__(self): assert not hasattr(self.__class__, '_instance'), 'Do not call constructor directly!' host = config.MONGODB_HOST port = config.MONGODB_PORT print("\033[1;30;46m|motor : host %s port %s \033[0m" % (config.MONGODB_HOST, config.MONGODB_PORT)) db = config.MONGODB_NAME self.client = MotorClient(config.MONGODB_HOST_LIST) if os.environ.get( "DOCKER") else MotorClient(host=host, port=port) self.db = self.client[db] self.user_coll = self.db['users'] self.vendor_coll = self.db['vendor'] self.seq_coll = self.db['seq'] self.channel_coll = self.db['channel'] self.cgoods_coll = self.db['cgoods'] self.fgoods_coll = self.db['fgoods'] self.worker_coll = self.db['worker'] self.channel_titles_coll = self.db["channel_titles"] # 渠道表标题 self.in_channel_coll = self.db['in_channel'] # 导入的原始渠道订单 self.out_channel_coll = self.db['out_channel'] # 原始订单里导出的发往厂家的订单 self.down_channel_coll = self.db['down_channel'] # 生成的可以下下载的给厂家的表格 self.in_vendor_coll = self.db['in_vendor'] # 导入的原始厂商回单 self.out_vendor_coll = self.db['out_vendor'] # 厂商回单分到个渠道 self.down_vendor_coll = self.db['down_vendor'] # 生成的可以下下载的给渠道的表格 self.music_order_coll = self.db['music_order'] # 生成的可以下下载的给ai的订单 self.channel_model_coll = self.db['channel_model'] # 渠道模型 self.vendor_model_coll = self.db['vendor_model'] # 厂商模型 self.sys_order_coll = self.db['sys_order'] # 系统订单 self.channel_form_coll = self.db["channel_form"] # 渠道上传的表单 self.vendor_form_coll = self.db["vendor_form"] # 厂商上传的表单 self.order_statistics_coll = self.db["order_statistics"] # 订单统计
def __init__(self, mongo_host, mongo_port, mongo_db_name, tornado_debug=None): """ Инициализация класса """ handlers = [ (r"/user/(.*)", UserHandler), (r"/post/(.*)", PostHandler), (r"/posts/(.*)", PostsHandler) ] settings = dict( title="Test Mail", debug=tornado_debug or True, ) super(RestApplication, self).__init__(handlers, **settings) motor = MotorClient(mongo_host, mongo_port, tz_aware=True) self.motor = motor[mongo_db_name]
def _init_connection(self): # 配置数据库的连接信息,这里并不会去连接数据库,只有在第一次数据库操作时进行连接 if self._client is None: try: # uri = "mongodb://%s:%s@%s" % ( # quote_plus(self._user_name), quote_plus(self._password), self._host) self._client = MotorClient( host=self._host, port=self._port, username=self._user_name, password=self._password, authSource=self._db_name, maxPoolSize=self._max_pool_size, minPoolSize=self._min_pool_size, socketTimeoutMS=self._socket_timeout, connectTimeoutMS=self._conn_timeout, heartbeatFrequencyMS=self._heartbeat, serverSelectionTimeoutMS=self._server_select_timeout, connect=self._connect, appname=self._app_name) self._db = self._client[self._db_name] except ConnectionFailure as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) except OperationFailure as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) except Exception as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) try: # The ismaster command is cheap and does not require auth. self._client.admin.command('ismaster') except ConnectionFailure as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) except OperationFailure as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) except Exception as e: LOGGER.error(traceback.print_exc()) LOGGER.error(message_format("mongo init error: " + e.message)) else: LOGGER.info("mongo init success")
def __init__(self, loop): self._loop = loop handlers = [(r'/', IndexHandler), (r'/api', ApiHandler), (r'/[a-zA-Z0-9]*/?', RedirectHandler)] template_path = os.path.join(os.path.dirname(__file__), 'templates') settings = { 'template_path': template_path, 'debug': True, } super(WebApp, self).__init__(handlers, **settings) # TODO: move workers, db host params and domain to config self.db = MotorClient(host='127.0.0.1')['pushort'] self.executor = ThreadPoolExecutor(32) # FIXME self.short_domain = 'http://127.0.0.1:8888'
def __init__(self, database='proauth2', host='localhost', port=27017, user=None, pwd=None): ''' initialize a mongodb connection to mongodb://user:pass@host:port use database ''' if user and pwd: connection_string = 'mongodb://%s:%s@%s:%s' % \ (user, pwd, host, port) else: connection_string = 'mongodb://%s:%s' % \ (host, port) self.db = MotorClient(connection_string).open_sync()[database]
async def main(): """ Demo main updates a database via a Kew """ # Create the db connection # Async clients should be init'd inside of an async scope conn = MotorClient("mongodb://*****:*****@loc.test.com:12345") # Create the Kew with db conn so the workers have access to it kew = MyKew(conn) # Load data into the Kew data = {"a": 1, "b": 2, "c": 3} for pair in data.items(): await kew.add(pair) # Wait for the Kew to finish processing the data await kew.finish()
def setUp(self): super(FileNameSearcherTest, self).setUp() self.sr = redis.StrictRedis() self.ar = AsyncStrictRedis() self.m = MotorClient() self.c = self.m.fbt self.patcher1 = mock.patch('redis_handler.RedisHandler.redis_client', return_value=mock_redis) self.patcher1.start() ''' self.patcher2 = mock.patch("pymongo.MongoReplicaSetClient", return_value=sync_db) self.patcher3 = mock.patch("motor.MotorReplicaSetClient", return_value=db) #self.patcher4 = mock.patch("async_redis.asyncRedis.AsyncStrictRedis", spec=AsyncStrictRedis, return_value=AsyncStrictRedis()) self.patcher2.start() self.patcher3.start() #self.patcher4.start() ''' self.io_loop.run_sync(self.setup_coro)
def __init__(self, database='moth', host='localhost', port=27017, user=None, pwd=None): ''' Moth uses a mongo back-end (although other data stores may be added later) __init__ creates a mongo connection with the passed credentials. ''' if user and pwd: connection_string = 'mongodb://%s:%s@%s:%s' % \ (user, pwd, host, port) else: connection_string = 'mongodb://%s:%s' % \ (host, port) self.db = MotorClient(connection_string).open_sync()[database]
def __init__(self): handlers = [(r'/desqol-auth/?', WelcomeHandler), (r'/desqol-auth/api/?', WelcomeHandler), (r'/desqol-auth/api/registration', RegistrationHandler), (r'/desqol-auth/api/login', LoginHandler), (r'/desqol-auth/api/logout', LogoutHandler), (r'/desqol-auth/api/user', UserHandler)] settings = dict() super(Application, self).__init__(handlers, **settings) self.db = MotorClient(**MONGODB_HOST)[MONGODB_DBNAME] self.executor = ThreadPoolExecutor(WORKERS) self.whitelist = WHITELIST self.hmac_key = random(size=APP_SECRETKEY_SIZE)
def __init__(self): db = MotorClient(os.environ['MONGOHQ_URL']).rin_stg settings = { 'template_path': str(pathlib.Path(__file__).parent.resolve() / 'template'), 'static_path': str(pathlib.Path(__file__).parent.resolve() / 'static'), # 'debug': True, 'flickr': flickr.Flickr(os.environ['FLICKR_API_KEY']), 'cache': flickr.FlickrCache(db) } handlers = [ (r'/', MainHandler), (r'/page/([1-9][0-9]{0,8})', MainHandler), ] super().__init__(handlers, **settings)
def connect(cfg): """connect to mongo database :param cfg: Dictionary containing configuration for MongoDB connection :type cfg: dict """ LOG.info("connecting to %s", cfg['host']) client = MotorClient(host=cfg.get('host', 'localhost'), port=cfg.get('port', 27017), tz_aware=cfg.get('tz_aware', False), replicaset=cfg.get('replicaset', cfg.get('replica_set'))) if cfg.get('user'): yield client[cfg['db']].authenticate(cfg['user'], cfg['password']) if cfg.get('read_preference'): read_preference = cfg['read_preference'].upper() client.read_preference = getattr( pymongo.read_preferences.ReadPreference, read_preference) raise gen.Return(client)
def main(): app = Application([url(r"/ws/(\w+)", WSHandler), url(r"/static/(.*)", StaticFileHandler, {'path': get_current_dir()+"/static"}), url(r"/new/(\w+)", HomeHandler), url(r"/(.+)", StaticFileHandler, {'path': get_current_dir()+"/html"}), url(r"/", HomeHandler)], debug=False) server = HTTPServer(app) parser = ArgumentParser() parser.add_argument("--mongo", help="Mongo hostname", default="localhost") parser.add_argument("--port", help="Server port", default=8888) parser.add_argument("--distance", help="Distance", default=1000) args = parser.parse_args() server.bind(args.port) server.start(1) app.settings["db"] = MotorClient(args.mongo).db138 app.settings["distance"] = args.distance IOLoop.current().start()
def run(): mock_redis = redis.StrictRedis() sync_db = MongoClient() db = MotorClient() mock_mapping = { "settings": { "refresh_interval": "5s", "number_of_shards": 2, "number_of_replicas": 1 }, "mappings": { "_default_": { "_all": { "enabled": False } }, } } # CAUTION: local search disabled!!! es = ESSearch(host="localhost", port=9200, index_name="test_index", type_name="test_type", index_mapping=mock_mapping, analyze_fields=[], none_analyze_fields=[]) with mock.patch('redis_handler.RedisHandler.redis_client', return_value=mock_redis) as whate_ever: with mock.patch('redis_cluster_proxy.Redis', return_value=mock_redis) as whate_ever1: with mock.patch("pymongo.MongoReplicaSetClient", return_value=sync_db) as what_ever2: with mock.patch("motor.MotorReplicaSetClient", return_value=db) as what_ever3: with mock.patch("es_search.ESSearch", return_value=es) as what_ever4: from fbt_http import main main()
def get_app(self): db = MotorClient(os.getenv('DB_HOST', 'mongodb://localhost:27017'), ) loop = asyncio.get_event_loop() loop.run_until_complete(db.drop_database(os.getenv('DB_NAME'))) return application
""" module to import all necessary modules """ # tornado modules from tornado.gen import coroutine from tornado.ioloop import IOLoop from tornado.escape import json_encode, json_decode from tornado.httpserver import HTTPServer from tornado.options import define, options from tornado.web import RequestHandler, Application, removeslash # other modules import json from os.path import join, dirname, isfile from motor import MotorClient import jwt from bson.objectid import ObjectId import os, uuid, sys from passlib.hash import pbkdf2_sha256 from datetime import datetime, timedelta secret = "gnberghnergb" db = MotorClient()["iwp"]