def init():
hostname = "127.0.0.1" # 要连接的数据库主机名
user = "******" # 要连接的数据库用户名
password = "******" # 要连接的数据库密码
port = 3306 # 3306 是MySQL服务使用的TCP端口号，一般默认是3306
dbname = "traversing_1" # 要使用的数据库库名
charset = "utf8" # 要使用的数据库的编码
dbpool.initPool(host=hostname, user=user, passwd=password, port=port, db=dbname,
charset=charset) ##firefly重新封装的连接数据库的方法，这一步就是初始化数据库连接池，这样你就可连接到你要使用的数据库了
def init():
hostname = "127.0.0.1" # 要连接的数据库主机名
user = "******" # 要连接的数据库用户名
password = "******" # 要连接的数据库密码
port = 3306 # 3306 是MySQL服务使用的TCP端口号，一般默认是3306
dbname = "traversing_1" # 要使用的数据库库名
charset = "utf8" # 要使用的数据库的编码
dbpool.initPool(host=hostname, user=user, passwd=password, port=port, db=dbname,
charset=charset) ##firefly重新封装的连接数据库的方法，这一步就是初始化数据库连接池，这样你就可连接到你要使用的数据库了
def _init_(self):
self.dbConfig = json.load(open('config.json', \
'r')).get('db')
dbpool.initPool(host = self.dbConfig['host'], \
user = self.dbConfig['user'], \
passwd = self.dbConfig['passwd'], \
port = self.dbConfig['port'], \
db = self.dbConfig['db'], \
char = self.dbConfig['charset'])
self.conn = dbpool.connection()
self.cursor = self.conn.cursor()
def config(self,
config,
servername=None,
dbconfig=None,
memconfig=None,
masterconf=None):
'''配置服务器
'''
GlobalObject().json_config = config
GlobalObject().remote_connect = self.remote_connect
netport = config.get('netport') #客户端连接
webport = config.get('webport') #http连接
rootport = config.get('rootport') #root节点配置
self.remoteportlist = config.get('remoteport', []) #remote节点配置列表
if not servername:
servername = config.get('name') #服务器名称
logpath = config.get('log') #日志
hasdb = config.get('db') #数据库连接
hasmem = config.get('mem') #memcached连接
app = config.get('app') #入口模块名称
cpuid = config.get('cpu') #绑定cpu
mreload = config.get('reload') #重新加载模块名称
self.servername = servername
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = Flask("servername")
GlobalObject().webroot = self.webroot
reactor.listenWSGI(webport, self.webroot)
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and dbconfig:
if dbconfig.has_key("user") and dbconfig.has_key(
"host") and dbconfig.has_key("host"):
dbpool.initPool({"default": dbconfig})
else:
dbpool.initPool(dbconfig)
if hasmem and memconfig:
urls = memconfig.get('urls')
# hostname = str(memconfig.get('hostname'))
memcached_connect(urls)
from gfirefly.dbentrust.util import M2DB_PORT, M2DB_HOST, ToDBAddress
ToDBAddress().setToDBHost(memconfig.get("pubhost", M2DB_HOST))
ToDBAddress().setToDBPort(memconfig.get("pubport", M2DB_PORT))
if logpath:
log.addObserver(loogoo(logpath)) #日志处理
log.startLogging(sys.stdout)
if cpuid:
affinity.set_process_affinity_mask(os.getpid(), cpuid)
GlobalObject().config(netfactory=self.netfactory,
root=self.root,
remote=self.remote)
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,
fromlist=_path_list[:1])
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
GlobalObject().masterremote = self.master_remote
import admin
addr = ('localhost',
masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
logger.info('tourist query :%s', get_result)
return json.dumps(dict(result=True,
account_name=get_result['account_name'],
account_password=get_result['account_password']))
if __name__ == '__main__':
dbconfig = {'host': '127.0.0.1',
'user': '******',
'passwd': 'test',
'db': 'db_traversing',
'port': 8066,
'charset': 'utf8'}
dbpool.initPool(**dbconfig)
# ddd = util.GetOneRecordInfo(USER_TABLE_NAME, dict(account_name='aaa'))
user = dict(id=get_uuid(),
account_name='ddd',
account_password='******',
last_login=0,
create_time=int(time.time()))
sql_result = util.InsertIntoDB(USER_TABLE_NAME, user)
# print get_id()
# threads = []
# for _ in range(100):
# threads.append(gevent.spawn(get_id))
# gevent.joinall(threads)
# sql_result = select_execute(USER_TABLE_NAME, dict(account_name='eee'))
user = dict(id='fdsfsfjkl',
for i in range(10):
dbpool_get()
print 'end get db'
if __name__ == '':
log_init_only_out()
hostname = "127.0.0.1"
user = "******"
password = "******"
port = 8066
dbname = "db_traversing"
charset = "utf8"
dbpool.initPool(host=hostname,
user=user,
passwd=password,
port=port,
db=dbname,
charset=charset)
records = util.GetSomeRecordInfo(PVP_TABLE_NAME, 'id=10',
['id', 'nickname', 'level', 'units'])
for r in records:
# u = cPickle.loads(u)
print r.get('nickname'), r.get('level'), r.get('id') # r.get('units')
import gevent
thread1 = gevent.spawn(test_db)
thread2 = gevent.spawn(test_db)
gevent.joinall([thread1, thread2])
def __init__(self, name, mc):
pass
if __name__ == '__main__':
hostname = "127.0.0.1" # 要连接的数据库主机名
user = "******" # 要连接的数据库用户名
password = "******" # 要连接的数据库密码
port = 3306 # 3306 是MySQL服务使用的TCP端口号，一般默认是3306
dbname = "test" # 要使用的数据库库名
charset = "utf8" # 要使用的数据库的编码
dbpool.initPool(host=hostname,
user=user,
passwd=password,
port=port,
db=dbname,
charset=charset
) ##firefly重新封装的连接数据库的方法，这一步就是初始化数据库连接池，这样你就可连接到你要使用的数据库了
connection_setting = ["127.0.0.1:6379"]
redis_manager.connection_setup(connection_setting)
tower_info = MAdmin("tb_character", "id")
#print '#1:', tower_info.__dict__
tower_info.insert()
# MAdminManager().registe(tower_info)
tower_info.checkAll()
mm = tower_info.getObj(123)
def config(self, config, servername=None, dbconfig=None,
memconfig=None, masterconf=None):
'''配置服务器
'''
GlobalObject().json_config = config
GlobalObject().remote_connect = self.remote_connect
netport = config.get('netport')#客户端连接
webport = config.get('webport')#http连接
rootport = config.get('rootport')#root节点配置
self.remoteportlist = config.get('remoteport',[])#remote节点配置列表
if not servername:
servername = config.get('name')#服务器名称
logpath = config.get('log')#日志
hasdb = config.get('db')#数据库连接
hasmem = config.get('mem')#memcached连接
app = config.get('app')#入口模块名称
cpuid = config.get('cpu')#绑定cpu
mreload = config.get('reload')#重新加载模块名称
self.servername = servername
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport,self.netfactory)
if webport:
self.webroot = Flask("servername")
GlobalObject().webroot = self.webroot
reactor.listenWSGI(webport, self.webroot)
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and dbconfig:
if dbconfig.has_key("user") and dbconfig.has_key("host") and dbconfig.has_key("host"):
dbpool.initPool({"default":dbconfig})
else:
dbpool.initPool(dbconfig)
if hasmem and memconfig:
urls = memconfig.get('urls')
# hostname = str(memconfig.get('hostname'))
memcached_connect(urls)
from gfirefly.dbentrust.util import M2DB_PORT,M2DB_HOST,ToDBAddress
ToDBAddress().setToDBHost(memconfig.get("pubhost",M2DB_HOST))
ToDBAddress().setToDBPort(memconfig.get("pubport",M2DB_PORT))
if logpath:
log.addObserver(loogoo(logpath))#日志处理
log.startLogging(sys.stdout)
if cpuid:
affinity.set_process_affinity_mask(os.getpid(), cpuid)
GlobalObject().config(netfactory = self.netfactory, root=self.root,
remote = self.remote)
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,fromlist=_path_list[:1])
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
GlobalObject().masterremote = self.master_remote
import admin
addr = ('localhost',masterport) if not masterhost else (masterhost,masterport)
self.master_remote.connect(addr)
def config(self, config, servername=None, dbconfig=None,
memconfig=None, redis_config=None, masterconf=None, model_default_config=None,
model_config=None):
"""配置服务器"""
GlobalObject().json_config = config
GlobalObject().json_model_config = model_default_config
GlobalObject().json_model_config = model_config
netport = config.get('netport') # 客户端连接
webport = config.get('webport') # http连接
rootport = config.get('rootport') # root节点配置
self.remoteportlist = config.get('remoteport', []) # remote节点配置列表
if not servername:
servername = config.get('name') # 服务器名称
logpath = config.get('log') # 日志
hasdb = config.get('db') # 数据库连接
hasmem = config.get('mem') # memcached连接
hasredis = config.get('redis') # redis连接
app = config.get('app') # 入口模块名称
cpuid = config.get('cpu') # 绑定cpu
mreload = config.get('reload') # 重新加载模块名称
self.servername = servername
if logpath:
log_init(logpath) # 日志处理
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = Flask("master")
GlobalObject().webroot = self.webroot
self.webroot.debug = True
# reactor.listenTCP(webport, self.webroot)
reactor.listenWSGI(webport, self.webroot)
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and dbconfig:
# logger.info(str(dbconfig))
dbpool.initPool(**dbconfig)
if hasmem and memconfig:
urls = memconfig.get('urls')
hostname = str(memconfig.get('hostname'))
mclient.connect(urls, hostname)
if hasredis and redis_config:
host = redis_config.get("host")
port = redis_config.get("port")
db = redis_config.get("db", 0)
redis_client.connect(host, port, db)
if cpuid:
affinity.set_process_affinity_mask(os.getpid(), cpuid)
GlobalObject().config(netfactory=self.netfactory, root=self.root,
remote=self.remote)
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload, fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
addr = ('localhost', masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
GlobalObject().masterremote = self.master_remote
import admin
# -*- coding:utf-8 -*-
"""
created by server on 14-6-5下午12:05.
"""
from gfirefly.dbentrust.dbpool import dbpool
if __name__ == '__main__':
hostname = "127.0.0.1"
user = "******"
password = "******"
port = 8066
dbname = "db_traversing"
charset = "utf8"
dbpool.initPool(host=hostname, user=user, passwd=password, port=port, db=dbname, charset=charset)
sql1 = 'update account_sequence set id = last_insert_id(id+1)'
conn = dbpool.connection()
cursor = conn.cursor()
cursor.execute(sql1)
conn.commit()
id = cursor.lastrowid
cursor.close()
conn.close()
print id
'user': '******',
'passwd': '111',
'db': 'legend',
'port': 3306,
'charset': 'utf8'
},
"master": {
'host': "localhost",
'user': '******',
'passwd': '111',
'db': 'test',
'port': 3306,
'charset': 'utf8'
}
}
dbpool.initPool(aa)
class router(RouterBase):
def db_for_read(self, **kw):
return "default"
def db_for_write(self, **kw):
return "master"
dbpool.bind_router(router)
ma = MemAdmin('tb_role_info', 'id', incrkey='id')
mm = ma.getObj(1)
mm.data['vip_exp'] = 123
###########firefly、MySQL和Memcached共同使用###########
from flask import json
from gfirefly.dbentrust.dbpool import dbpool
from gfirefly.dbentrust.madminanager import MAdminManager
from gfirefly.dbentrust.memclient import mclient
from gfirefly.dbentrust.mmode import MAdmin
from gfirefly.server.globalobject import GlobalObject
hostname = "127.0.0.1" # 要连接的数据库主机名
user = "******" # 要连接的数据库用户名
password = "******" # 要连接的数据库密码
port = 8066 # 3306 是MySQL服务使用的TCP端口号，一般默认是3306
dbname = "db_traversing" # 要使用的数据库库名
charset = "utf8" # 要使用的数据库的编码
dbpool.initPool(host=hostname, user=user, passwd=password, port=port, db=dbname, charset=charset) ##firefly重新封装的连接数据库的方法，这一步就是初始化数据库连接池，这样你就可连接到你要使用的数据库了
def old_test():
address = ["127.0.0.1:11211"] #要连接的Memcached的主机地址端口号
hostname = "localhost" #要连接的Memcached的主机名
mclient.connect(address, hostname) #firefly重新封装的连接Memcached的方法，这样你就可连接到你要使用的Memcached
tower_info = MAdmin("tb_tower_info", "id") #实例化一个MAdmin管理器，用来管理player表中的数据，player是你要管理的表名，id是该表的主键
#不清楚MAdmin是什么的童鞋请移步http://firefly.9miao.com/wiki/index.htm，wiki里面有个dbentrust使用文档，里面详细说明了firefly自定义的几个类与数据库之间的关联
tower_info.insert() #将管理器player注册到memcached中
tower_info.load() #一次性从数据库中将player表中所有数据读取到memcached中，如果不写本句，player只是一个空模型，没有数据，第一次取值时会到数据库中取出此次需要的数据并加载到memcached中，
#如果第二次取值同第一次相同，则在memcached中取，否则需要再次同数据库建立连接进行取值
m = tower_info.getObj(1) #取出player表中主键（本例为id）为100001的这条数据对象（Mmode）
def config(self, config, servername=None, dbconfig=None,
memconfig=None, redis_config=None, masterconf=None,
model_default_config=None, model_config=None, msdk_config=None):
"""配置服务器"""
GlobalObject().json_config = config
GlobalObject().json_model_config = model_default_config
GlobalObject().json_model_config = model_config
netport = config.get('netport') # 客户端连接
webport = config.get('webport') # http连接
rootport = config.get('rootport') # root节点配置
self.remoteportlist = config.get('remoteport', []) # remote节点配置列表
if not servername:
servername = config.get('name') # 服务器名称
logpath = config.get('log') # 日志
hasdb = config.get('db') # 数据库连接
# hasmem = config.get('mem') # memcached连接
hasredis = config.get('redis') # redis连接
app = config.get('app') # 入口模块名称
cpuid = config.get('cpu') # 绑定cpu
mreload = config.get('reload') # 重新加载模块名称
self.servername = servername
if servername == 'net':
time.sleep(6)
if logpath:
log_init(logpath) # 日志处理
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = Flask("master")
GlobalObject().webroot = self.webroot
self.webroot.debug = True
# reactor.listenTCP(webport, self.webroot)
reactor.listenWSGI(webport, self.webroot)
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and dbconfig:
# logger.info(str(dbconfig))
dbpool.initPool(**dbconfig)
if hasredis and redis_config:
connection_setting = redis_config.get('urls')
redis_manager.connection_setup(connection_setting)
if cpuid:
affinity.set_process_affinity_mask(os.getpid(), cpuid)
GlobalObject().config(netfactory=self.netfactory, root=self.root,
remote=self.remote)
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload, fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
addr = ('localhost', masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
GlobalObject().masterremote = self.master_remote
if msdk_config:
#zone_id = msdk_config.get("zone_id")
host = msdk_config.get("host")
#pay_host = msdk_config.get("pay_host")
goods_host = msdk_config.get("buy_goods_host")
valid_host = msdk_config.get("valid_host")
qq_appid = msdk_config.get("qq_appid")
qq_appkey = msdk_config.get("qq_appkey")
wx_appid = msdk_config.get("wx_appid")
wx_appkey = msdk_config.get("wx_appkey")
log = logger_sdk.new_log('TxApi')
GlobalObject().msdk = Msdk(host, qq_appid, qq_appkey, wx_appid, wx_appkey, log=log)
GlobalObject().pay = MidasApi(host, goods_host, valid_host, log=log)
import admin
dict(result=True,
account_name=get_result['account_name'],
account_password=get_result['account_password']))
if __name__ == '__main__':
dbconfig = {
'host': '127.0.0.1',
'user': '******',
'passwd': 'test',
'db': 'db_traversing',
'port': 8066,
'charset': 'utf8'
}
dbpool.initPool(**dbconfig)
# ddd = util.GetOneRecordInfo(USER_TABLE_NAME, dict(account_name='aaa'))
user = dict(id=get_uuid(),
account_name='ddd',
account_password='******',
last_login=0,
create_time=int(time.time()))
sql_result = util.InsertIntoDB(USER_TABLE_NAME, user)
# print get_id()
# threads = []
# for _ in range(100):
# threads.append(gevent.spawn(get_id))
# gevent.joinall(threads)
# sql_result = select_execute(USER_TABLE_NAME, dict(account_name='eee'))
user = dict(id='fdsfsfjkl',
"""
Created on 2015-1-8
@author: root
"""
from gfirefly.dbentrust.dbpool import dbpool, RouterBase
from gfirefly.dbentrust.memclient import memcached_connect
memcached_connect(["127.0.0.1:11211"])
from gfirefly.dbentrust.memmodel import MemAdmin
aa = {
"default": {"host": "localhost", "user": "******", "passwd": "111", "db": "legend", "port": 3306, "charset": "utf8"},
"master": {"host": "localhost", "user": "******", "passwd": "111", "db": "test", "port": 3306, "charset": "utf8"},
}
dbpool.initPool(aa)
class router(RouterBase):
def db_for_read(self, **kw):
return "default"
def db_for_write(self, **kw):
return "master"
dbpool.bind_router(router)
ma = MemAdmin("tb_role_info", "id", incrkey="id")
mm = ma.getObj(1)
mm.data["vip_exp"] = 123
def config(self,
config,
servername=None,
dbconfig=None,
memconfig=None,
redis_config=None,
masterconf=None,
model_default_config=None,
model_config=None,
msdk_config=None):
"""配置服务器"""
GlobalObject().json_config = config
GlobalObject().json_model_config = model_default_config
GlobalObject().json_model_config = model_config
netport = config.get('netport') # 客户端连接
webport = config.get('webport') # http连接
rootport = config.get('rootport') # root节点配置
self.remoteportlist = config.get('remoteport', []) # remote节点配置列表
if not servername:
servername = config.get('name') # 服务器名称
logpath = config.get('log') # 日志
hasdb = config.get('db') # 数据库连接
# hasmem = config.get('mem') # memcached连接
hasredis = config.get('redis') # redis连接
app = config.get('app') # 入口模块名称
cpuid = config.get('cpu') # 绑定cpu
mreload = config.get('reload') # 重新加载模块名称
self.servername = servername
#if servername == 'net':
#time.sleep(6)
#if servername == 'gate':
#time.sleep(16)
if logpath:
log_init(logpath) # 日志处理
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = Flask("master")
GlobalObject().webroot = self.webroot
self.webroot.debug = True
# reactor.listenTCP(webport, self.webroot)
reactor.listenWSGI(webport, self.webroot)
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and dbconfig:
# logger.info(str(dbconfig))
dbpool.initPool(**dbconfig)
if hasredis and redis_config:
connection_setting = redis_config.get('urls')
redis_manager.connection_setup(connection_setting)
if cpuid:
affinity.set_process_affinity_mask(os.getpid(), cpuid)
GlobalObject().config(netfactory=self.netfactory,
root=self.root,
remote=self.remote)
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,
fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
addr = ('localhost',
masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
GlobalObject().masterremote = self.master_remote
if msdk_config:
#zone_id = msdk_config.get("zone_id")
host = msdk_config.get("host")
#pay_host = msdk_config.get("pay_host")
goods_host = msdk_config.get("buy_goods_host")
valid_host = msdk_config.get("valid_host")
qq_appid = msdk_config.get("qq_appid")
qq_appkey = msdk_config.get("qq_appkey")
wx_appid = msdk_config.get("wx_appid")
wx_appkey = msdk_config.get("wx_appkey")
log = logger_sdk.new_log('TxApi')
GlobalObject().msdk = Msdk(host,
qq_appid,
qq_appkey,
wx_appid,
wx_appkey,
log=log)
GlobalObject().pay = MidasApi(host,
goods_host,
valid_host,
log=log)
import admin
