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"]
