def usage_update():
'''
updates the main db with connection and message numbers
'''
db = database.Connection(settings.DB_HOST,
settings.DB_DATABASE,
user=settings.DB_USER,
password=settings.DB_PASSWORD)
for k, v in CLIENTS.iteritems():
msgs = v['usage']['messages']
conns = v['usage']['connections']
if msgs == 0:
continue
v['usage']['messages'] = 0
api_account = db.get(
'select id from common_apiaccount where api_key="%s"' % k)
if api_account:
db.execute(
'insert into common_usagetransaction (api_account_id, created, messages, connections) \
values (%s, NOW(), %s, %s)' %
(api_account['id'], msgs, conns))
db.close()
def __init__(self, key, lockname="wechatlock"):
self.mdb = database.Connection(
"%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)), MYSQL_DB, MYSQL_USER,
MYSQL_PASS)
self.__lockname = lockname
self.__key = key # 使用锁需要一个key，根据key的权限不同，可以使用不同的操作，管理者key可以进行所以操作，普通key只能进行普通操作
self.__adminkey = self.get_admin_key() # 该锁的管理者key
self.__state = self.islocked()
def _setup(cls):
#todo: in future, should be able to setup different db / rs for different SonicObj
try:
cls._db = _dbs[str(config.default_db)]
except KeyError:
cls._db = database.Connection(*config.default_db)
_dbs[str(config.default_db)] = cls._db
cls._db_name = config.default_db[1]
cls._rs = redis.Redis(**config.default_rs)
cls._agent = None
if not hasattr(cls, "_fields"):
cls._fields = []
cls._field_names = set()
cls._field_types = {}
cls.pre_commits = set()
cls.after_commits = set()
cls.after_deletes = set()
for k, v in cls.__dict__.iteritems():
field = v
if isinstance(field, SonicField) and k not in cls._field_names:
field.name = k
cls._fields.append(field)
cls._field_names.add(field.name)
cls._field_types[field.name] = field
cls._fields.sort(key=lambda a: a.creation_counter)
cls._indexes = []
cls._uniques = []
cls._fulltext_indexes = []
if hasattr(cls, "indexes"):
#todo: must check index field, alert case like put two list field in same index
i = 0
for k, v in cls.indexes.iteritems():
order_by = cls.get_order_by(i)
item = []
for f in v:
item.append(f.name)
cls._indexes.append(index(item, order_by))
i += 1
if hasattr(cls, "uniques"):
for k, v in cls.uniques.iteritems():
item = []
for f in v:
item.append(f.name)
cls._indexes.append(index(item))
cls._uniques.append(item)
#todo: should check if fulltext_indexes definition valid here
if not hasattr(cls, "fulltext_indexes"):
cls.fulltext_indexes = None
def get_mysql():
conf = db_config.mysql_conf
conn = database.Connection(
host="%s:%s" % (conf['host'], conf['port']),
database=conf['db'],
user=conf['user'],
password=conf['passwd'],
)
return conn
def get_apply_info(self, ticket):
# 获取申请信息
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
mdb._ensure_connected()
apply_info = mdb.get(
"SELECT * FROM `lockkeypairtmp` WHERE `ticket` = %s", ticket)
mdb.execute("DELETE FROM `lockkeypairtmp` WHERE `ticket` = %s", ticket)
mdb.close()
return apply_info
def create_connection(**kwargs):
'''keys in argument kwargs.
host: mysql server host's ip address or name
database: use a database in mysql server
user: user connect to mysql server
passwrod: user's password connect to mysql server
max_idle_time: max idle time for a connection
'''
return database.Connection(**kwargs)
def dele_key(self, ticket_del, key):
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
getinfo = mdb.get(
"SELECT `lockname` FROM `lock` WHERE `ticket_del` = %s",
ticket_del)
print getinfo, key
mdb.execute(
"DELETE FROM `lockkeypair` WHERE `lockname` = %s AND `key` = %s",
getinfo['lockname'], key)
def post(self):
db = database.Connection("localhost", "mtg", "root", "temple29")
username = self.get_argument("name")
passwd = hashlib.md5(self.get_argument("password")).hexdigest()
rows = db.execute_rowcount(
"SELECT * FROM users WHERE usr = '******' AND pass = '******'" %
(username, passwd))
print "User logged in - %s" % (username)
self.set_secure_cookie("user", self.get_argument("name"))
self.redirect("/")
print "Redirected to /"
def run_server(conf_root=''):
'''Add webdav status codes'''
httplib.responses[207] = 'Multiple Status'
httplib.responses[422] = 'Unprocessable Entity'
httplib.responses[423] = 'Locked'
httplib.responses[424] = 'Failed Dependency'
conf_file = os.path.abspath(os.path.join(conf_root, CONFIG_FILE))
if os.path.exists(conf_file):
tornado.options.parse_config_file(conf_file)
tornado.options.parse_command_line()
db = database.Connection(options.mysql_host, options.mysql_name,
options.mysql_user, options.mysql_passwd)
usersdb = {}
if options.auth_file == 'MYSQL':
users = DbSqlAuth(options.realm, db)
usersdb = users._usersdb
else:
auth_file = os.path.abspath(os.path.join(conf_root, options.auth_file))
if os.path.exists(auth_file):
users = DbFileAuth(options.realm, auth_file)
usersdb = users._usersdb
if options.auth_type == 'basic':
auth = BasicAuth(usersdb, options.realm)
elif options.auth_type == 'digest':
auth = DigestAuth(usersdb, options.realm)
else:
auth = None
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
}
application = DavApplication(options.root, auth, db, settings)
use_ssl = options.use_ssl
if use_ssl:
ssl_options = dict(
certfile=options.ssl_cretfile,
keyfile=options.ssl_keyfile,
)
http_server = tornado.httpserver.HTTPServer(application,
ssl_options=ssl_options)
else:
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
def apply_key(self, lockticket, key, ticket):
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
lockticket = lockticket
key = key
ticket = ticket
mdb._ensure_connected()
if mdb.get(
"SELECT `lockticket` FROM `lockkeypairtmp` WHERE `lockticket` = %s",
lockticket):
mdb.execute("DELETE FROM `lockkeypairtmp` WHERE `lockticket` = %s",
lockticket)
mdb.execute(
"INSERT INTO `lockkeypairtmp` (`lockticket`,`key`, `ticket`) values(%s,%s,%s)",
lockticket, key, ticket)
mdb.close()
def init_sqlite(cls):
cls.db = database.Connection("127.0.0.1", "test")
try:
migrate_str = """
CREATE TABLE page_items (
`id` int(11) NOT NULL AUTO_INCREMENT,
`keyword` varchar(255) DEFAULT NULL,
`page_num` int(11) DEFAULT NUll,
`title` text DEFAULT NULL,
`content` text DEFAULT NUll,
`created_at` DATETIME NULL,
`reply_date` DATETIME NULL,
`active` tinyint(1) DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;
"""
cls.db.execute(migrate_str)
except:
pass
def get_ticket_cmd(self, ticket):
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
if mdb.get("SELECT `lockname` FROM `lock` WHERE `ticket` = %s",
ticket):
# 如果ticket在lock数据表中，尝试开锁
cmd = "unlock"
elif mdb.get(
"SELECT `lockticket` FROM `lockkeypairtmp` WHERE `ticket` = %s",
ticket):
# ticket在临时添加锁匙对列表中，尝试添加锁匙对
cmd = "addkey"
elif mdb.get("SELECT `lockname` FROM `lock` WHERE `ticket_del` = %s",
ticket):
cmd = "delkey"
else:
cmd = "unknown"
mdb.close()
return cmd
def setup(cls, db=None):
db = db if db else config.default_db
cls._db = database.Connection(*db)
cls._db_name = db[1]
if not hasattr(cls, "_fields"):
cls._fields = []
cls._field_names = set()
cls.after_commits = set()
cls.after_deletes = set()
for k, v in cls.__dict__.iteritems():
field = v
if isinstance(field, SonicField) and k not in cls._field_names:
field.name = k
cls._fields.append(field)
cls._field_names.add(field.name)
def wdb(self):
# write database
try:
return self.db_links['wdb']
except Exception, e:
from tornado import database
import settings
db_links = database.Connection(
'%s:%s' % (settings.database_config['wdb']['host'],
int(settings.database_config['wdb']['port'])),
settings.database_config['wdb']['dbnm'],
settings.database_config['wdb']['user'],
settings.database_config['wdb']['pswd'],
max_idle_time=15,
)
try:
self.db_links['wdb'] = db_links
except Exception, e:
self.db_links = {}
self.db_links['wdb'] = db_links
def dellock(lockname, bosskey):
if check_boss(bosskey):
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
mdb._ensure_connected()
if mdb.get("SELECT `lockname` FROM `lock` WHERE `lockname` = %s",
lockname):
# 如果锁存在，删除锁关联的密匙；再删除锁
mdb._ensure_connected()
mdb.execute("DELETE FROM `lockkeypair` WHERE `lockname` = %s",
lockname)
mdb.execute("DELETE FROM `lock` WHERE `lockname` = %s LIMIT 1",
lockname)
rt = u'成功删除锁'
else:
rt = u'不存在这个锁'
mdb.close()
return rt
else:
return u'你不是我的大boss，我不能接受这个指令'
def addlock(lockname, adminkey, bosskey):
# 只有qomoliao有权添加锁
if check_boss(bosskey):
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB, MYSQL_USER, MYSQL_PASS)
mdb._ensure_connected()
if mdb.get("SELECT `lockname` FROM `lock` WHERE `lockname` = %s",
lockname):
rt = u'这个锁名已被使用'
else:
query = "INSERT INTO `lock` (`lockname`,`admin`,`state`) values(%s,%s,%s)"
mdb._ensure_connected()
mdb.execute(query, lockname, adminkey, True)
# 将管理员密匙添加到锁密匙列表
lock = Lock(lockname)
lock.addkey(adminkey, adminkey)
rt = u'成功添加锁和管理员'
mdb.close()
return rt
else:
return u'你不是我的大boss，我不能接受这个指令'
def on_open(self, request):
log('ws connecting')
self.api_key = request.get_argument('api_key')
self.user_id = request.get_argument('user_id')
self.is_authenticated = False
# get conn id
r = redis_connect(db=1)
self.conn_id = str(r.incr('conn_id'))
CLIENTS.setdefault(self.api_key, {})
client = CLIENTS[self.api_key]
client.setdefault('conns', set()).add(self)
client.setdefault('event_auth', {})
client.setdefault('subs', {})
client.setdefault('presence:joined', set())
client.setdefault('presence:left', set())
client.setdefault('usage', {})
client.setdefault('conn_ids', {})
client['conn_ids'][self.conn_id] = self
client['usage'].setdefault('messages', 0)
client['usage'].setdefault('connections', 0)
client['usage']['connections'] += 1
# check api_key exists in db
try:
db = database.Connection(settings.DB_HOST,
settings.DB_DATABASE,
user=settings.DB_USER,
password=settings.DB_PASSWORD)
api_result = db.get(
'SELECT id, callback_url, disabled from common_apiaccount where api_key="%s"'
% self.api_key)
db.close()
if api_result:
if api_result['disabled'] == 1:
return False
self.callback_url = api_result['callback_url']
else:
return False
except:
return False
# start a redis listener thread for this api_key
if not REDIS_THREADS.has_key(self.api_key):
redis_thread = threading.Thread(target=redis_listener,
args=(self.api_key, ))
redis_thread.daemon = True
REDIS_THREADS[self.api_key] = redis_thread
redis_thread.start()
# emit presence event (broadcast)
r = redis_connect()
r.publish(
self.api_key,
json.dumps({
'action':
'broadcast',
'api_key':
self.api_key,
'conn_id':
self.conn_id,
'channel':
'presence:joined',
'message':
json.dumps({
'conn_id': self.conn_id,
'user_id': self.user_id
})
}))
self.add_msg_count()
return self.conn_id
self.db_links['wdb'] = db_links
except Exception, e:
self.db_links = {}
self.db_links['wdb'] = db_links
return db_links
def rdb(self):
# read database
try:
settings.database_config['rdb']
except Exception, e:
return self.wdb()
try:
return self.db_links['rdb']
except Exception, e:
import settings
rdbconfig = settings.database_config['rdb']
if len(rdbconfig):
from tornado import database
import random
dbconfig = rdbconfig #random.choice( rdbconfig )
db_links = database.Connection(
'%s:%s' % (dbconfig['host'], int(dbconfig['port'])),
dbconfig['dbnm'],
dbconfig['user'],
dbconfig['pswd'],
max_idle_time=15,
)
else:
return self.wdb()
# -*- coding: utf-8 -*-
from tornado import database
from setting import *
from utils import *
mdb = sdb = database.Connection('%s:%s' % (db_host, db_port), db_name, db_user,
db_passwd, max_idle_time)
if is_sae:
sdb = database.Connection('%s:%s' % (db_host2, db_port2), db_name2,
db_user2, db_passwd2, max_idle_time)
__all__ = ('Post', 'Tag', 'Option', 'Link')
class _Option:
def get(self, name):
row = sdb.get('select value from px_option where name=%s', name)
if row:
return row.value
else:
return None
def set(self, name, value, description=''):
old = self.get(name)
if old is not None:
sql = 'update px_option set value=%s where name=%s'
return mdb.execute_rowcount(sql, value, name)
else:
sql = 'insert into px_option(name,value,description) values(%s,%s,%s)'
return mdb.execute_lastrowid(sql, name, value, description)
MYSQL_DB = sae.const.MYSQL_DB
MYSQL_USER = sae.const.MYSQL_USER
MYSQL_PASS = sae.const.MYSQL_PASS
MYSQL_HOST_M = sae.const.MYSQL_HOST
MYSQL_HOST_S = sae.const.MYSQL_HOST_S
MYSQL_PORT = sae.const.MYSQL_PORT
#主数据库 进行Create,Update,Delete 操作
#从数据库 读取
##
HTML_REG = re.compile(r"""<[^>]+>""", re.I | re.M | re.S)
mdb = database.Connection("%s:%s" % (MYSQL_HOST_M, str(MYSQL_PORT)),
MYSQL_DB,
MYSQL_USER,
MYSQL_PASS,
max_idle_time=MAX_IDLE_TIME)
sdb = database.Connection("%s:%s" % (MYSQL_HOST_S, str(MYSQL_PORT)),
MYSQL_DB,
MYSQL_USER,
MYSQL_PASS,
max_idle_time=MAX_IDLE_TIME)
###
CODE_RE = re.compile(r"""\[code\](.+?)\[/code\]""", re.I | re.M | re.S)
def n2br(text):
con = text.replace('>\n\n', '>').replace('>\n', '>')
con = "<p>%s</p>" % ('</p><p>'.join(con.split('\n\n')))
def initialize(self):
self.db = database.Connection(host=options.mysql_host,
user=options.mysql_user,
database=options.mysql_database,
password=options.mysql_password)
m = md5_constructor()
m.update(key)
return map(ord, m.digest())
########NEW FILE########
__FILENAME__ = setting
#!/usr/bin/env python
# -*- coding: utf8 -*-
try:
from tornado import database
except:
import torndb as database
conn = database.Connection("127.0.0.1", "test", "root", "root")
conn1 = database.Connection("127.0.0.1", "test", "root", "root")
conn2 = database.Connection("127.0.0.1", "test", "root", "root")
conn3 = database.Connection("127.0.0.1", "test", "root", "root")
ring = [conn1, conn2, conn3]
########NEW FILE########
__FILENAME__ = torndb
#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
import os
import json
from tornado import wsgi
from tornado import database
from tornado.options import options
from chat import handlers, settings
services = json.loads(os.environ.get('VCAP_SERVICES', '{}'))
if services:
creds = services['mysql-5.1'][0]['credentials']
settings['db'] = database.Connection(creds['host'],
creds['name'],
user=creds['username'],
password=creds['password'])
application = wsgi.WSGIApplication(handlers, **settings)
