def _mongo_init(self):
T_T = O_O.database.mongo
self._mongo_client = MongoClient(T_T.client).__getattr__(T_T.db)
self._motor_client = motor.MotorClient(T_T.client).__getattr__(T_T.db)
self._collection_dict = {(scls.__alias__ or scls.__collection_name__):
scls for scls in MongoBase.__subclasses__()}
if T_T.run_init:
for scls in MongoBase.__subclasses__():
scls.__collection_init__(self._mongo_client)
def make_db():
client = motor_tornado.MotorClient(defaults['mongodb_backend_settings']['host'])
db = None
try:
db = client[defaults['mongodb_backend_settings']['database']]
except InvalidName:
app_log.error("Database InvalidName")
IOLoop.current().stop()
exit()
return db
def main():
MONGO_URL = os.environ.get("MONGO_URL")
client = motor_tornado.MotorClient(MONGO_URL, retryWrites=False)
db = client.test
app = Application([("/", MainHandler), ("/roles", RolesHandler)], db=db)
http_server = HTTPServer(app)
http_server.listen(PORT)
IOLoop.current().start()
def make_app():
settings = {
'cookie_secret': 'dfdfdfd',
'xsrf_cookies': True,
'debug': True
}
other_db = {
'mongo': motor_tornado.MotorClient(**Config.get('MONGO_CONF')),
'redis': redis.StrictRedis()
}
return tornado.web.Application([(r'/web', WebHandler, other_db),
(r'/', HtmlHandler),
(r'/static/(.*)', StaticHandler)],
**settings)
def main():
MONGO_URL = os.environ.get('MONGO_URL')
client = motor_tornado.MotorClient(MONGO_URL, retryWrites=False)
db = client['pybr-roles']
app = Application([
('/', MainHandler),
('/roles', RolesHandler),
], db=db)
http_server = HTTPServer(app)
http_server.listen(PORT)
IOLoop.current().start()
def __init__(self, label):
assert label in ['user', 'programmer', 'argorithm']
logger.info(f"Connecting to mongodb collection={label}...")
if "mongodb+srv" in config.DB_ENDPOINT:
client = motor_tornado.MotorClient(config.DB_ENDPOINT)
else:
client = motor_asyncio.AsyncIOMotorClient(
config.DB_ENDPOINT,
port=config.DB_PORT,
username=config.DB_USERNAME,
password=config.DB_PASSWORD)
database = client['argorithmdb']
self.label = label
self.collection = database[self.label]
def main():
port = 8000
client = motor_tornado.MotorClient('localhost', 27017)
db = client.roles_db
app = Application([
('/', MainHandler),
('/roles', RolesHandler),
], db=db)
http_server = HTTPServer(app)
http_server.listen(port)
print('Listening on http://localhost:%i' % port)
IOLoop.current().start()
def create_crudster(api_prefix="/", collection_name="data",
database_name="crudster", handler=CRUDRequestHandler,
initialize_database=False, mongodb_uri="mongodb://127.0.0.1:27017",
**kwargs):
client = motor_tornado.MotorClient(mongodb_uri)
if initialize_database:
client.drop_database(database_name)
db = client[database_name]
settings = dict(db=db, collection_name=collection_name)
return web.Application([
(r"{}([0-9a-f]{{12}}4[0-9a-f]{{3}}[89ab][0-9a-f]{{15}})?".format(api_prefix), handler),
], **settings)
def connect(self):
"""建立连接"""
try:
self.recorder('INFO', '{obj} connect start'.format(obj=self))
self.set_idle()
self._client = motor_tornado.MotorClient(**self.setting)
if self.db:
self.select_db(self.db)
self.isConnect = True
self.recorder('INFO', '{obj} connect successful'.format(obj=self))
except ConnectionFailure as e:
self.recorder(
'ERROR', '{obj} connect failed [{msg}]'.format(obj=self,
msg=e))
self.error()
raise MongoError
raise Return(self)
def __init__(self, token):
super().__init__(token)
self.commands = {
"/start": self.handle_start,
"/help": self.handle_help,
"/stop": self.handle_stop,
"/add_to_feeder": self.handle_add_to_feeder,
"/care": self.handle_care,
'/hunger': self.handle_hunger,
'/sleep': self.handle_sleep,
'/play': self.handle_play,
'/hug': self.handle_hug,
'/to_show': self.handle_show,
}
self.kot_db = mt.MotorClient(teletoken.DB).kotbot
self.kot_chats = {}
self.show = cat_show.CatShow(self.kot_db.cats)
def initialize_pool(*args, **kwargs):
"""
创建 mongo 连接， 连接参数参照 pymongo
min_connections: 5
max_connections: 20
:param args:
:param kwargs:
:return:
"""
MongoTK.connection_pool = motor_tornado.MotorClient(
*args,
# maxPoolSize=1,
# minPoolSize=5,
# socketTimeoutMS=2000,
connectTimeoutMS=1000,
retryWrites=True,
appname="GCloud",
**kwargs)
def setup_db():
m1 = os.environ['MONGO1_ADDR']
m2 = os.environ['MONGO2_ADDR']
m3 = os.environ['MONGO3_ADDR']
mongo_port = os.environ['MONGO_PORT']
mongo_usr = os.environ['MONGO_USR']
mongo_pwd = os.environ['MONGO_PWD']
mongo_rs = os.environ['MONGO_RS']
mongo_uri = 'mongodb://'
mongo_uri += mongo_usr + ':'
mongo_uri += mongo_pwd + '@'
mongo_uri += m1 + ':' + mongo_port + ','
mongo_uri += m2 + ':' + mongo_port + ','
mongo_uri += m3 + ':' + mongo_port
mongo_uri += '/?replicaSet=' + mongo_rs
return motor_tornado.MotorClient(\
mongo_uri,
ssl=True,
ssl_cert_reqs=ssl.CERT_NONE
)
def make_app():
parse_command_line()
gen_log.info('upload path:{0}'.format(UPLOAD_DIR))
#db = motor_tornado.MotorClient('169.24.2.63', 27017).xlearning_job
db = motor_tornado.MotorClient(options.mongo_host,
options.mongo_port).xlearning_job
setting = {
"debug": True,
"static_file": path_join('dist'),
#"static_url_prefix": '/dist/'
}
handlers = [
url(r'/', IndexHandler),
url(r'/api/hello', HelloHandler),
url(r'/dist/(.*)', StaticFileHandler, {"path": path_join('dist')}),
url(r'/api/upload/model', FileUploadHandler),
url(r'/api/job/create', JobSubmitHandler),
url(r'/api/jobs', JobHandler),
]
app = Application(handlers=handlers, **setting)
app.db = db
app.listen(options.port)
IOLoop.current().start()
def main():
# port = 8000
port = int(os.environ.get('PORT'))
# client = motor_tornado.MotorClient('localhost', 27017)
username = config('USERNAME')
password = config('PASSWORD')
mlab = config('MLAB')
# client =
# motor_tornado.MotorClient(f'mongodb+srv://{username}:{password}@{mlab}/test?retryWrites=true&w=majority')
client = motor_tornado.MotorClient(config('MONGO_URL'))
# client =
# f'mongodb+srv://{username}:{password}@{mlab}/test?retryWrites=true&w=majority'
# db = client.roles_db
db = client['pybrdb']
app = Application([
('/', MainHandler),
('/roles', RolesHandler),
], db=db)
http_server = HTTPServer(app)
http_server.listen(port)
print('Listening on http://localhost:%i' % port)
IOLoop.current().start()
from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
from motor import motor_tornado
from tornado import ioloop, gen
from tornado.ioloop import IOLoop
import time
from bson.objectid import ObjectId
from functools import partial
import robot_conn
#import ardnet
mc_client = motor_tornado.MotorClient(
"mongodb://*****:*****@ds135798.mlab.com:35798/gspd",
connectTimeoutMS=30000,
socketTimeoutMS=None,
socketKeepAlive=True)
db = mc_client.gspd
global itemsInDB
global amt
# # # # # # # # # # # # # # # # # #
# MARK - Websocket interaction with client
# # # # # # # # # # # # # # # # # #
class SimpleEcho(WebSocket):
def handleMessage(client):
parameters = client.data.split('|')
command = parameters[0]
print(client.data)
def __new__(cls):
if not cls._instance:
client = motor_tornado.MotorClient(options.options.db_host)
cls._instance = motor_tornado.MotorDatabase(
client, options.options.db_name)
return cls._instance
def mongo_storage(args):
client = motor_tornado.MotorClient(args.mongodb_uri)
if args.reset_database:
client.drop_database(args.database_name)
db = client[args.database_name]
return MongoStorage(db, args.database_name)
# -*- coding: utf-8 -*-
"""
模型
"""
import aiodocker
from motor import motor_tornado
from conf import Config
docker_remote_url = "http://{0}:{1}".format(Config.docker_remote_ip, Config.docker_remote_port)
DockerClient = aiodocker.Docker(docker_remote_url)
MongoClient = motor_tornado.MotorClient(Config.mongdb_IP, Config.mongdb_port)
DBClient = MongoClient.DockerLab
from tornado.ioloop import IOLoop
from tornado.web import RequestHandler, Application
from motor import motor_tornado
import dns
client = motor_tornado.MotorClient(
'mongodb+srv://sysdba:[email protected]/test?retryWrites=true&w=majority'
)
db = client['teste']
class MainHandler(RequestHandler):
def get(self):
document = {'key': 'value'}
db = self.settings['db']
db['pybr'].insert_one(document)
self.write('E aí galera da Python Brasil 2019!')
if __name__ == '__main__':
app = Application([('/', MainHandler)], db=db)
app.listen(8000)
IOLoop.current().start()
from tornado.web import RequestHandler,Application,StaticFileHandler,url
import tornado.ioloop
import motor.motor_tornado as motor
import os
import datetime
db = motor.MotorClient("mongodb://localhost:27017/")
class home(RequestHandler):
def get(self):
self.render("home.html")
class register(RequestHandler):
def get(self):
self.render("register.html",error=None)
async def post(self):
user = db["web"]["user"]
uid = await user.estimated_document_count()
fname = self.get_body_argument("fname")
lname = self.get_body_argument("lname")
username = self.get_body_argument("username")
password = self.get_body_argument("passwd")
n = await user.find_one({"username":username})
if not n:
await user.insert_one({
"_id":uid+1,
"fname":fname,
"lname":lname,
"username":username,
def __init__(self):
self._client = motor_tornado.MotorClient('localhost', 27017)
self.write(json.dumps({"status": "something went wrong"}))
if not ml_response:
if int(send(gp, ig,
em="*****@*****.**")) != 202 and int(
send(gp, ig)) != 202:
self.write(json.dumps({"status": "something went wrong"}))
fire = firestore.Client()
x = fire.collection("data").document("1")
payload = {"gps": gp, "label": ml_response['img_label'], "img": ig}
y = x.get().to_dict()['data']
y.append(payload)
x.set({"data": y})
self.write(json.dumps({'flag': 'Everthing is coool'}))
if __name__ == "__main__":
options.parse_command_line()
client = motor_tornado.MotorClient(
"mongodb://*****:*****@ds143030.mlab.com:43030/projectx")
app = tornado.web.Application(handlers=[(r"/", test),
(r"/mlpredict", MLHandler)],
default_handler_class=my404handler,
debug=True,
db_client=client)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(os.environ.get("PORT", options.port))
print('listening on 8000')
tornado.ioloop.IOLoop.instance().start()
# -*- coding:utf-8 -*-
from tornado.httpclient import AsyncHTTPClient
from tornado.concurrent import Future
from tornado import gen
from motor import motor_tornado
import pprint
from util import stop_loop, start_loop
client = motor_tornado.MotorClient()
db = client['test']
@gen.coroutine
def insert_one():
result = yield db.test.insert_one({'hello': 'world'})
raise gen.Return(result)
@gen.coroutine
def find_one():
result = yield db.test.find_one()
pprint.pprint(result)
raise gen.Return(result)
def fetch_coroutine_callback(future):
print('coroutine callback')
print future.result()
stop_loop(2)
def load_db(db_settings):
client = motor_tornado.MotorClient('mongodb://{}:{}'.format(
db_settings['host'], db_settings['port']))
return client[db_settings['name']]
class Model(object):
"""An abstract db model."""
__metaclass__ = abc.ABCMeta
_db_con = motor_tornado.MotorClient(MONGO_DB_SERVER)
fields = {}
db_collection_name = None
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
for name, field in self.fields.items():
if not hasattr(self, name):
if 'default' in field:
setattr(self, name, Model._get_default(field))
else:
raise TypeError(
'__init__() missing the required argument: %r' % name)
def __getitem__(self, key):
"""Return value for key if it is used like m['key']."""
# only for the lulz
return getattr(self, key)
@classmethod
def objects(cls):
"""Return the manager for this model."""
return Model._db_con[cls.db_collection_name]
def to_json(self, id_as_str=False):
"""
Return a JSON serializable dict containing all data to be stored in db.
id_as_str: hack, because mongodb needs a ObjectId but this is not JSON
serializable. -> For mongodb: False, for JSON: True
"""
json_data = {
name: getattr(self, name)
for (name, field) in self.fields.items()
}
if hasattr(self, '_id'):
json_data['_id'] = str(self['_id']) if id_as_str else self['_id']
return json_data
def save(self):
"""
Save the object to database. Don't forget to save the ObjectId.
Return: The ObjectId of this object in db.
You might want to save it in this object like:
>>> m._id = m.save()
"""
return self.objects().insert(self.to_json())
@classmethod
def validate(cls, **kwargs):
"""Validate the kwargs and return cleaned data or raise a HTTPError."""
data = {}
for key, value in kwargs.items():
if cls.fields[key].get('multiple'):
values = value
for validator in cls.fields[key].get('list_validators', []):
values = validator.validate(values)
else:
values = [value]
for value in values:
for validator in cls.fields[key]['validators']:
value = validator.validate(value)
if cls.fields[key].get('multiple'):
data[key] = values
else:
data[key] = values[0]
return data
@classmethod
def create_from_request(cls,
request_handler,
include_id=False,
mapping=None,
strip=True):
"""
Create a object of this model out of an request.
include_id: If this should edit an existing object,
accept the _id from the request
mapping: dict: keys: model field name, value: request field name
strip: strip values
>>> my_obj = MyModel.create_from_request(self)
>>> result = my_obj.save()
"""
data = {}
if not mapping:
mapping = {}
if include_id:
data['_id'] = request_handler.get_argument('_id', strip=strip)
for name, field in cls.fields.items():
req_name = mapping.get(name, name)
if field.get('multiple'):
value = request_handler.get_arguments(name=req_name,
strip=strip)
elif 'default' in field:
value = request_handler.get_argument(
name=req_name,
strip=strip,
default=Model._get_default(field),
)
else:
value = request_handler.get_argument(name=req_name,
strip=strip)
data[name] = value
cleaned_data = cls.validate(**data)
return cls(**cleaned_data)
@staticmethod
def _get_default(field):
"""Helper method to return the default value of a field."""
if isinstance(field['default'], FunctionType):
return field['default']()
else:
return field['default']
# # creater:[email protected] # create time:2016-06-10 20:50:13 # description:todo RESTFul service # #================================================ from tornado.web import RequestHandler, escape import uuid import datetime from handler import json_encode from motor import motor_tornado from bson import ObjectId from tornado.gen import coroutine client = motor_tornado.MotorClient('192.168.2.14', 27017) db = client.test_database class TodoHandler(RequestHandler): @coroutine def get(self, *args, **kwargs): result = yield db.todos.find({}).to_list(length=None) self.set_header('content-type', 'application/json; charset=UTF-8') self.write(json_encode({'status': 'success', 'todos': result})) @coroutine def put(self, *args, **kwargs): todo_id = self.get_argument('id', None) todo_status = self.get_argument('status', 0) yield db.todos.update({'_id': ObjectId(todo_id)},
def motor(mongo_db, mongo_client, io_loop):
client = motor_tornado.MotorClient('localhost',
int(mongo_db.port),
io_loop=io_loop)
db = client["inmanta"]
yield db
import tornado.web
import tornado.ioloop
from tornado.gen import coroutine, Return
from motor import motor_tornado
from bson import ObjectId
import bson
client = motor_tornado.MotorClient('192.168.1.120', 30001)
db = client.piano
class LoginHandler(tornado.web.RequestHandler):
@coroutine
def get(self):
document = {"key": "insert", "value": "insert_one"}
ret = yield self.doing(document)
print(ret)
# print((yield ret.fetch_next))
self.write("111")
@coroutine
def doing(self, document):
ret = db.v1_category.aggregate([{
'$match': {
'instrument': {
'$in': [4]
},
'state': 1
}
}, {
"$group": {
self.render("index.html",
tarp=0,
name=patio['fname'],
listofdoc=listofdoc,
success=True)
else:
self.render("index.html",
tarp=None,
name="Amrut",
listofdoc=listofdoc,
success=True)
if __name__ == "__main__":
tornado.options.parse_command_line()
client = motor_tornado.MotorClient(
"mongodb://*****:*****@ds117605.mlab.com:17605/tornado")
settings = {
"default_handler_class": my404handler,
"debug": True,
"cookie_secret": "b'LPBDqiL4S8KGi54y5eXFLoSiKE+wz0vajAU6K9aZOJ4='",
"login_url": "/login",
"db_client": client,
"ap_details": dict()
}
test = dict()
app = tornado.web.Application(
handlers=[(r"/", AuthHandler), (r"/login", AuthHandler),
(r"/Signup", SignUpHandler), (r"/patient", PatientHandler),
(r"/logout", LogoutHandler), (r"/portal", PortalHandler),
(r"/path", PathHandler), (r"/user", PatientHandler),
(r"/doctor", DocHandler), (r"/appoint", DocListHandler)],
