def get_datebase(dbname='SpiderMan'):
return peewee_async.PooledMySQLDatabase(
dbname,
host=SpiderManConf.MYSQLHOST,
port=3306,
user=SpiderManConf.MYSQLUSER,
password=SpiderManConf.MYSQLPASSWORD,
charset='utf8')
def __init__(self, db=None):
if not db:
db = CONFIG.get('env', {}).get('env', None)
if db == 'root':
self.db = CONFIG.get('db_root')
elif db == 'test':
self.db = CONFIG.get('db_test')
elif db == 'analysis':
self.db = CONFIG.get('db_analysis')
else:
self.db = CONFIG.get('db')
self.redis_config = CONFIG.get('redis')
logger.debug('db setting: ' + str(self.db))
self.database = peewee.MySQLDatabase(self.db.get('database'),
host=self.db.get('host'),
port=self.db.get('port', 3306),
user=self.db.get('user'),
passwd=self.db.get('passwd'),
charset=self.db.get('charset'))
self.database_async = peewee_async.MySQLDatabase(
self.db.get('database'),
host=self.db.get('host'),
port=self.db.get('port', 3306),
user=self.db.get('user'),
password=self.db.get('passwd'),
charset=self.db.get('charset'))
self.pool = PooledMySQLDatabase(self.db.get('database'),
host=self.db.get('host'),
port=self.db.get('port', 3306),
user=self.db.get('user'),
passwd=self.db.get('passwd'),
max_connections=self.db.get(
'max_connections', 10))
self.pool_async = peewee_async.PooledMySQLDatabase(
self.db.get('database'),
host=self.db.get('host'),
port=self.db.get('port', 3306),
user=self.db.get('user'),
password=self.db.get('passwd'),
charset=self.db.get('charset'),
max_connections=self.db.get('max_connections', 10))
# redis_pool_async = aioredis.create_redis_pool(
# (config['redis']['host'], config['redis']['port']),
# minsize=config['redis']['minsize'],
# maxsize=config['redis']['maxsize'],
# loop=asyncio.get_event_loop()
# )
logger.debug('redis setting: ' + str(self.redis_config))
self.redis = redis.ConnectionPool(
host=self.redis_config['host'],
port=self.redis_config['port'],
password=self.redis_config['password'],
db=self.redis_config['db'],
max_connections=self.redis_config['maxsize'],
decode_responses=True)
def create_pool(self):
_mysql_pools = {}
mysql_conf = Config().mysql
for alias, cnf in mysql_conf.items():
db = cnf.pop('db')
is_async = cnf.pop('is_async', False)
db_conn = peewee_async.PooledMySQLDatabase(db, **cnf)
# 是否异步操作
if not bool(is_async):
db_conn.set_allow_sync(False)
manager = peewee_async.Manager(db_conn)
# 每个链接对象有两个属性：.db_conn .manager
_mysql_pools[alias] = dict2obj(
dict(db_conn=db_conn, manager=manager))
self.mysql_pools = _mysql_pools
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
db_dic = dict(
host=options['SQL_HOST'],
port=options['SQL_POST'],
user=options['SQL_USER'],
password=options['SQL_PWD'],
max_connections=options['SQL_MAX_CONN'],
database=options['SQL_DB_NAME'],
)
cls.conn = peewee_async.PooledMySQLDatabase(**db_dic,
charset='utf8mb4')
cls.manager = peewee_async.Manager(cls.conn)
cls._instance = super().__new__(cls)
return cls._instance
import peewee_async
import settings
database = peewee_async.PooledMySQLDatabase(settings.mysql.DATABASE,
host=settings.mysql.ENDPOINT,
port=settings.mysql.PORT,
user=settings.mysql.USER,
password=settings.mysql.PASSWORD)
manager = peewee_async.Manager(database)
import peewee_async
db = {
'user': '******',
'host': '192.168.88.157',
'password': '******',
'port': 3306,
'max_connections': 10
}
news_db = peewee_async.PooledMySQLDatabase('wordpress', **db)
objects = peewee_async.Manager(news_db)
# 数据库常量
# NEWS_TECHNOLOGY, NEWS_STAR, NEWS_SPORTS, NEWS_
# NEWS_TYPE = (
# (, ''),
# (, ''),
# (, ''),
# (, ''),
# )
# -*- coding: utf-8 -*-
import peewee as models
import peewee_async
database = peewee_async.PooledMySQLDatabase('blog',
max_connections=10,
**{
'charset': 'utf8',
'use_unicode': True,
'host': '127.0.0.1',
'user': '******',
'password': '******'
})
Objects = peewee_async.Manager(database)
__all__ = [
"Objects", "BaseModel", "Permission", "Group", "Author", "Category",
"Blog", "Tag", "Blogtag", "Skynet", "Message", "Visitor", "Comment",
"Reply", "Todolist"
]
class UnknownField(object):
def __init__(self, *_, **__):
pass
class BaseModel(models.Model):
class Meta:
from tornado import ioloop
import wtforms_json
import peewee_async
import aioredis
from utils.genCodePic import ValidCodeImg
from settings import settings
from elasticsearch import AsyncElasticsearch
from functools import partial
'''
创建各式微服务
'''
es = AsyncElasticsearch(hosts=settings['es']['host'])
db = peewee_async.PooledMySQLDatabase(**settings['mysql'])
wtforms_json.init()
db.set_allow_sync(False)
objects = peewee_async.Manager(db)
coder = ValidCodeImg()
redis = ioloop.IOLoop.current().run_sync(func=partial(
aioredis.create_redis_pool, 'redis://' + settings['redis']['host'] +
f':{settings["redis"]["port"]}'))
import os
import peewee_async
BASE_DIR = os.getcwd()
# peewee_async 连接池对象
# peewee_async 连接池
database = peewee_async.PooledMySQLDatabase('aiohttp_data', **{
'user': '******',
'password': '******',
'host': '127.0.0.1',
'port': 3306,
})
objects = peewee_async.Manager(database)
# objects.database.allow_sync = False
import peewee_async
from app.core import config
class AsyncMySQLConnection(peewee_async.AsyncMySQLConnection):
"""Asynchronous database connection pool.
"""
def __init__(self, *, database=None, loop=None, timeout=None, **kwargs):
self.pool = None
self.loop = loop
self.database = database
self.timeout = timeout
kwargs.setdefault('pool_recycle', 360)
self.connect_params = kwargs
db = peewee_async.PooledMySQLDatabase(
config.MYSQL_DB,
host=config.MYSQL_HOST,
user=config.MYSQL_USER,
password=config.MYSQL_PASSWORD,
charset='utf8mb4',
async_conn=AsyncMySQLConnection,
)
db.set_allow_sync(False)
objects = peewee_async.Manager(db)
import peewee
import peewee_async
import tornado.web
from tornado import httpserver
database = peewee_async.PooledMySQLDatabase('alexdb',
host='127.0.0.1',
port=3306,
user='******',
password='******',
charset='utf8')
# Define model
class TestNameModel(peewee.Model):
name = peewee.CharField()
class Meta:
database = database
def __str__(self):
return self.name
# Create table, add some instances
TestNameModel.create_table(True)
TestNameModel.get_or_create(id=1, defaults={'name': "试试中文问题"})
TestNameModel.get_or_create(id=2, defaults={'name': "TestNameModel id=2"})
TestNameModel.get_or_create(id=3, defaults={'name': "TestNameModel id=3"})
database.close()
import os
import peewee_async
MYSQL_USER = '******'
MYSQL_PASSWORD = '******'
MYSQL_DATABASE = 'test_db'
MYSQL_HOST = os.getenv('MYSQL_HOST', '127.0.0.1')
MYSQL_PORT = os.getenv('MYSQL_PORT', 3306)
if not MYSQL_USER or not MYSQL_PASSWORD:
raise RuntimeError('mysql credentials not configured')
cdb = peewee_async.PooledMySQLDatabase(
MYSQL_DATABASE,
user=MYSQL_USER,
password=MYSQL_PASSWORD,
host=MYSQL_HOST,
port=MYSQL_PORT,
charset='utf8',
max_connections=5
)
import peewee
import peewee_async
import tornado.web
from tornado import httpserver
database = peewee_async.PooledMySQLDatabase('alexdb',
host='127.0.0.1',
port=3306,
user='******',
password='')
# Define model
class TestNameModel(peewee.Model):
name = peewee.CharField()
class Meta:
database = database
def __str__(self):
return self.name
# Create table, add some instances
TestNameModel.create_table(True)
TestNameModel.get_or_create(id=1, defaults={'name': "TestNameModel id=1"})
TestNameModel.get_or_create(id=2, defaults={'name': "TestNameModel id=2"})
TestNameModel.get_or_create(id=3, defaults={'name': "TestNameModel id=3"})
database.close()
from collections import Iterable
import peewee_async
from playhouse.shortcuts import model_to_dict
from blogger_service import SERVICE_NAME
from chili.gateway import BaseConfig
database = BaseConfig(SERVICE_NAME).get_db_config()
db_name = database.pop('db_name')
blog_db = peewee_async.PooledMySQLDatabase(db_name, **database)
objects = peewee_async.Manager(blog_db)
def models_to_dict(models, *args, **kwargs):
""" 批量序列化 """
if not isinstance(models, Iterable):
return []
return [
model_to_dict(model, *args, **kwargs) for model in models
]
from datetime import datetime
import peewee
import peewee_async
config = {
'host': 'localhost',
'port': 33006,
'database': 'app',
'user': '******',
'password': '******'
}
database = peewee_async.PooledMySQLDatabase(**config)
# database_proxy = peewee.DatabaseProxy()
# database_proxy.initialize(database)
objects = peewee_async.Manager(database=database)
class BaseModel(peewee.Model):
class Meta:
database = database
class Tags(BaseModel):
name = peewee.CharField(max_length=50)
class Meta:
database = database
import peewee_async
from peewee import *
database = peewee_async.PooledMySQLDatabase('nero',
host='192.168.1.5',
port=3306,
user='******',
password='******',
charset='utf8')
class BaseModel(Model):
class Meta:
database = database
class GameMediatag(BaseModel):
cover = CharField()
groupid = IntegerField()
name = CharField()
order = IntegerField()
ref_count = IntegerField()
typeid = IntegerField()
usetype = IntegerField()
class Meta:
db_table = 'game_mediatag'
class GameQuinhighcategory(BaseModel):
created_time = DateTimeField()
def __new__(cls,
table_prefix=None,
use_async=True,
create_table=True,
multiplexing_conn=False):
"""
初始化数据库连接，构造peewee model实例
Parameters:
table_prefix - 表名前缀，由扫描目标的 host + "_" + str(port) 组成
use_async - 是否开启数据库连接的异步查询功能，默认为True
create_table - 数据表不存在时是否创建，默认为True
multiplexing_conn - 是否复用连接，为True时，相同的Model的实例会使用同一个连接，默认为False
Raises:
create_table为Fasle且目标数据表不存在时，引发exceptions.TableNotExist
"""
try:
cls.connect_para = {
"database": Config().get_config("database.db_name"),
"host": Config().get_config("database.host"),
"port": Config().get_config("database.port"),
"user": Config().get_config("database.username"),
"password": Config().get_config("database.password"),
"charset": "utf8mb4"
}
if not hasattr(cls, "db_created"):
conn = pymysql.connect(
host=Config().get_config("database.host"),
port=Config().get_config("database.port"),
user=Config().get_config("database.username"),
passwd=Config().get_config("database.password"),
charset="utf8mb4")
cursor = conn.cursor()
cursor._defer_warnings = True
sql = "CREATE DATABASE IF NOT EXISTS {dbname} default charset {charset} COLLATE {charset}_general_ci;".format(
dbname=Config().get_config("database.db_name"),
charset="utf8mb4")
cursor.execute(sql)
cursor.close()
conn.commit()
conn.close()
cls.db_created = True
if multiplexing_conn is True:
with BaseModel.mul_lock:
if not hasattr(BaseModel, "mul_database"):
BaseModel.mul_database = peewee_async.MySQLDatabase(
**cls.connect_para)
BaseModel.mul_database.connect()
BaseModel.mul_database_timeout = time.time() + 60
elif time.time() > BaseModel.mul_database_timeout:
BaseModel.mul_database.close()
BaseModel.mul_database = peewee_async.MySQLDatabase(
**cls.connect_para)
BaseModel.mul_database.connect()
BaseModel.mul_database_timeout = time.time() + 60
elif isinstance(multiplexing_conn, int):
with BaseModel.mul_lock:
if not hasattr(BaseModel, "mul_database"):
BaseModel.mul_database = peewee_async.PooledMySQLDatabase(
**cls.connect_para,
max_connections=multiplexing_conn)
except Exception as e:
cls._handle_exception("Mysql Connection Fail!", e)
instance = super(BaseModel, cls).__new__(cls)
return instance
import peewee_async
from peewee import *
from conf.op_conf import get_conf
import model
db = peewee_async.PooledMySQLDatabase(database=get_conf()['db'],
user=get_conf()['username'],
password=get_conf()['password'],
host=get_conf()['host'],
port=get_conf()['port'])
objs = peewee_async.Manager(db)
db.set_allow_sync(True)
class BaseModel(Model):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.trans = db.atomic_async # 将事务改成atomic_async
self.objs = peewee_async.Manager(db) # 添加一个Manager类
# add_time = DateTimeField(null=True, verbose_name="添加时间")
class Meta:
database = db
def create_table():
db.create_tables([model.index.Server, model.index.User])