def sreload():
"""供master调用的接口：热更新模块
"""
log.msg("reload")
if GlobalObject().reloadmodule:
reload(GlobalObject().reloadmodule)
return True
def _doChildLostConnect(childId):
"""
"""
try:
del GlobalObject().remote_map[childId]
except Exception,e:
log.msg(str(e))
def __init__(self, port, urls, app, debug=False, **ssl_options):
"""端口监听器\n
@param port: int 监听的端口\n
@param urls: 链接的正则表达式列表\n
@param apps: gevent-websocket封装的applications
@param ssl_options: ssl参数
"""
Greenlet.__init__(self)
self.port = port
self.urls = urls
self.apps = app
self.factory = None
#sessionno生成器
self.countGenerator = itertools.count(1, 1)
self.allClients = {}
#服务通道
self.service = None
#ssl_options
root_ca = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "ca")
if ssl_options:
self.ssl_options = ssl_options
self.ssl_options.update({
"keyfile":
os.path.join(root_ca, self.ssl_options['keyfile']),
"certfile":
os.path.join(root_ca, self.ssl_options['certfile'])
})
else:
self.ssl_options = {}
log.msg(self.ssl_options)
self.debug = debug
def joinRoom(self, conn):
"""
加入房间/判断重新链接
:param conn:
:return:
"""
uid = getattr(conn, "uid", None)
if uid in self.players:
#断线重连
p = self.players[uid]
p.reConnection(conn)
log.msg("reconnectioned ======== %s" % uid)
else:
if self.playerCount < self.cc:
p = Player(conn, self.playerNumGen.next())
self.players[uid] = p
#test发送PlayerJionMsg, InitRoomMsg
playerInitRoomMsg = FightBefore_pb2.InitRoomMsg()
playerInitRoomMsg.seed = self.seed
playerInitRoomMsg.localID = p.rid
playerInitRoomMsg.maxPlayer = self.cc
self.sendMsg(uid, 5, playerInitRoomMsg)
playerJoinMsg = FightBefore_pb2.PlayerJionMsg()
playerJoinMsg.playerLocalID = p.rid
self.multicast(6, playerJoinMsg, excludes=[uid])
for i in self.players.values():
playerJoinMsg = FightBefore_pb2.PlayerJionMsg()
playerJoinMsg.playerLocalID = i.rid
self.sendMsg(uid, 6, playerJoinMsg)
else:
raise Exception('player cc limit!!!')
def Forwarding_0(key, _conn, data):
'''转发服务器.用来接收客户端的消息转发给其他服务
'''
log.msg("Recv Key:%s dynamicId:%s data:%s" %
(key, _conn.transport.sessionno, data))
message = GlobalObject().remote['gate'].callRemote(
"forwarding", key, _conn.transport.sessionno, data)
return message
def on_close(self, reason):
log.msg("websocket Connection closed! ")
#kill 当前客户端的sender
self.mysender.close()
#移除client
del GlobalObject().wsapp.allClients[self.sessionno]
#掉线节点自己处理
GlobalObject().wsapp.doConnectionLost(self)
def connectionMade(self):
'''连接建立处理
'''
address = self.transport.getAddress()
log.msg('Client %d login in.[%s,%d]'%(self.transport.sessionno,\
address[0],address[1]))
self.factory.connmanager.addConnection(self)
self.factory.doConnectionMade(self)
def loopPush(self):
if not self.isPush:
log.msg('start loopPush!!!!')
#发送ready的消息
self.sendReady()
self.mSendTime = long(time.time() * 10000000) + 20 * 10000
self.isPush = True#每个房间只启动一个定时器
self._loopPush()
def dropConnectionByID(self, connID):
'''更加连接的id删除连接实例
@param connID: int 连接的id
'''
try:
del self._connections[connID]
except Exception as e:
log.msg(str(e))
def dropConnectionByID(self, connID):
'''更加连接的id删除连接实例
@param connID: int 连接的id
'''
try:
del self._connections[connID]
except Exception as e:
log.msg(str(e))
def dropChildByID(self, childId):
'''删除一个child 节点\n
@param childId: Child ID
'''
try:
del self._childs[childId]
except Exception, e:
log.msg(str(e))
def dropChildByID(self,childId):
'''删除一个child 节点\n
@param childId: Child ID
'''
try:
del self._childs[childId]
except Exception,e:
log.msg(str(e))
def serverStop():
"""停止服务进程
"""
log.msg('stop')
if GlobalObject().stophandler:
GlobalObject().stophandler()
reactor.callLater(0.5,reactor.stop)
return True
def connectionMade(self):
'''连接建立处理
'''
address = self.transport.getAddress()
log.msg('Client %d login in.[%s,%d]'%(self.transport.sessionno,\
address[0],address[1]))
self.factory.connmanager.addConnection(self)
self.factory.doConnectionMade(self)
def serverStop():
"""停止服务进程
"""
log.msg('stop')
if GlobalObject().stophandler:
GlobalObject().stophandler()
reactor.callLater(0.5, reactor.stop)
return True
def serverStop():
"""供master调用的接口：关闭服务器
"""
log.msg("stop")
if GlobalObject().stophandler:
GlobalObject().stophandler()
reactor.callLater(0.5, reactor.stop)
return True
def remote_takeProxy(self,name,transport):
'''设置代理通道
@param name: 根节点的名称
'''
log.msg('node [%s] takeProxy ready'%name)
child = Child(name)
self.childsmanager.addChild(child)
child.setTransport(transport)
self.doChildConnect(name, transport)
def dropChild(self, child):
'''删除一个child 节点\n
@param child: Child Object
'''
key = child._id
try:
del self._childs[key]
except Exception, e:
log.msg(str(e))
def on_open(self):
log.msg("Some websocket client connected!")
#self绑定自己的sender
self.mysender = MySender(self.getCurrentClient().ws)
self.mysender.start()
#设置sessionno并且保存所有的client到字典
GlobalObject().wsapp.allClients[self.sessionno] = self
#节点自己实现
GlobalObject().wsapp.doConnectionMade(self)
def leaveRoom(self, uid):
"""
离开房间
:param uid:
:return:
"""
if uid in self.players:
del self.players[uid]
log.msg("%s leaveRoom" % self.roomId)
def dropChild(self,child):
'''删除一个child 节点\n
@param child: Child Object
'''
key = child.getName()
try:
del self._childs[key]
except Exception,e:
log.msg(str(e))
def remote_takeProxy(self, name, transport):
'''设置代理通道
@param name: 根节点的名称
'''
log.msg('node [%s] takeProxy ready' % name)
child = Child(name, name)
self.childsmanager.addChild(child)
child.setTransport(transport)
self.doChildConnect(name, transport)
def stopLoopPush(self):
"""
停止定时器
:return:
"""
if self.tick:
self.tick.cancel()
self.tick = None
log.msg("canceled loopPush of room %s" % self.roomId)
def broadcast(self, message):
log.msg('broadcast')
for client in GlobalObject().wsapp.allClients.values():
self.safeWriteMsg(
client, {
'msg_type': 'message',
'nickname': message['nickname'],
'message': message['message']
})
def call(self, funckey, *args, **kw):
"""
"""
from app.ability.pushmsg import PushActionMessage
log.msg("call method [%s] from service " % funckey)
assert self.targets.has_key(funckey)
response = self.targets[funckey](*args, **kw)
PushActionMessage(args[0])
response["data"] = response.get("data", "")
return response
def _run(self):
"""启动监听器\n
"""
log.msg('WebSocketServer on %s' % self.port)
self.factory = WebSocketServer(self.getHost(),
Resource([(i, self.apps)
for i in self.urls]),
debug=self.debug,
**self.ssl_options)
self.factory.serve_forever()
def login_102(key, dynamicId, argument):
""" 登录协议.
"""
log.msg("login_102 dynamicId:%s argument:%s" % (dynamicId, argument))
acc = argument.get('acc')
pwd = argument.get('pwd')
user = UserManager().addUser(dynamicId, acc, pwd)
if user:
return SendMessage(1, user.getData())
else:
return SendMessage(0, "")
def register_101(key, dynamicId, argument):
""" 注册协议.
"""
log.msg("register_101 dynamicId:%s argument:%s" % (dynamicId, argument))
acc = argument.get('acc') # 获取帐号
pwd = argument.get('pwd') # 获取密码
userData = UserManager().createUser(dynamicId, acc, pwd) # 创建用户
if userData:
return SendMessage(1, userData) # 创建成功，返回用户数据
else:
return SendMessage(0, "") # 创建失败
def register_101(key, dynamicId, argument):
""" 注册协议.
"""
log.msg("register_101 dynamicId:%s argument:%s" % (dynamicId, argument))
acc = argument.get('acc') # 获取帐号
pwd = argument.get('pwd') # 获取密码
userData = UserManager().createUser(dynamicId, acc, pwd) # 创建用户
if userData:
return SendMessage(1, userData) # 创建成功，返回用户数据
else:
return SendMessage(0, "") # 创建失败
def login_102(key, dynamicId, argument):
""" 登录协议.
"""
log.msg("login_102 dynamicId:%s argument:%s" % (dynamicId, argument))
acc = argument.get('acc')
pwd = argument.get('pwd')
user = UserManager().addUser(dynamicId, acc, pwd)
if user:
return SendMessage(1, user.getData())
else:
return SendMessage(0, "")
def d_f(*args, **kwargs):
import cProfile, StringIO, pstats
# datafn = func.__name__ + ".profile" # Name the data file
prof = cProfile.Profile()
retval = prof.runcall(func, *args, **kwargs)
#prof.dump_stats(datafn)
s = StringIO.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(prof, stream=s).sort_stats(sortby)
ps.print_stats()
log.msg(s.getvalue())
return retval
def _run(self):
"""执行协议
"""
address = 'tcp://%s:%s'%self.to_db_address
self.sock.connect(address)
while True:
try:
message = self.inbox.get()
self.sock.send_pyobj(message)
except Exception as e:
log.err(_stuff=e,_why=traceback.format_exc())
log.msg(str(message))
def _run(self):
"""执行协议
"""
address = 'tcp://%s:%s' % self.to_db_address
self.sock.connect(address)
while True:
try:
message = self.inbox.get()
self.sock.send_pyobj(message)
except Exception as e:
log.err(_stuff=e, _why=traceback.format_exc())
log.msg(str(message))
def callTarget(self,targetKey,*args,**kw):
'''call Target by Single
@param conn:client connection
@param targetKey:target ID
@param data:client data
'''
target=self.getTarget(targetKey)
if not target:
log.err('the command' +str(targetKey)+'not Found on service')
return None
if targetKey not in self.unDisplay:
log.msg("call method %s on service[single]"%target.__name__)
response=target(targetKey,*args,**kw)
return response
def callTarget(self, targetKey, *args, **kw):
'''call Target
@param conn: client connection
@param targetKey: target ID
@param data: client data
'''
target = self.getTarget(targetKey)
if not target:
log.err('the command ' + str(targetKey) + ' not Found on service')
return None
if targetKey not in self.unDisplay:
log.msg("call method %s on service[single]" % target.__name__)
response = target(*args, **kw)
return response
def forEachQueryProps(sqlstr, props):
'''遍历所要查询属性，以生成sql语句'''
if props == '*':
sqlstr += ' *'
elif type(props) == type([0]):
i = 0
for prop in props:
if (i == 0):
sqlstr += ' ' + prop
else:
sqlstr += ', ' + prop
i += 1
else:
log.msg('props to query must be list')
return
return sqlstr
def _run(self):
"""执行协议
"""
self.connectionMade()
try:
while True:
data = self.transport.recv(1024)
if not data:
break
gevent.spawn(self.dataReceived, data)
# self.dataReceived(data)
except Exception, e:
if not isinstance(e, socket.error):
log.err(e, traceback.format_exc())
log.msg(e)
self.connectionLost(reason=e)
def doLostConnection(self, uid):
"""
用户掉线处理（支持断线重连）
:param uid:
:return:
"""
p = self.players.get(uid, None)
if p:
log.msg("room doLostConnection %s" % uid)
p.lostConnection()
log.msg("%s====%s" % (self.playerCount, self.offLineCount))
if self.playerCount == self.offLineCount:
#所有玩家都掉线了, 玩个屁啊, 直接删除房间得了
return True
else:
return False
else:
return False
def msg_1(_conn, data):
"""
用户登陆
:param _conn: 链接对象
:param data: 客户端数据包
:return:
"""
#数据解析
msg = Oauth_pb2.UserLogin()
msg.ParseFromString(data)
#检测tocken有效性
# TODO
userId = msg.userId
tocken = msg.accesstocken
log.msg(userId)
log.msg(tocken)
log.msg("client IP:%s Port: %s." % _conn.transport.getAddress())
#重复登陆
if userId:
setattr(_conn, 'uid', userId)
resp = Common_pb2.CommonResponse()
resp.state = True
# GlobalObject().netfactory.pushObject(1, resp, [_conn.transport.sessionno])
_conn.safeToWriteData(resp, 1)
else:
#掉线
GlobalObject().netfactory.loseConnection(_conn.transport.sessionno)
def dataReceived(self, data):
'''数据到达处理
@param data: str 客户端传送过来的数据
'''
length = self.factory.dataprotocl.getHeadlength() #获取协议头的长度
self.buff += data
while self.buff.__len__() >= length:
unpackdata = self.factory.dataprotocl.unpack(self.buff[:length])
if not unpackdata.get('result'):
log.msg('illegal data package --')
self.transport.loseConnection()
break
command = unpackdata.get('command')
rlength = unpackdata.get('length')
request = self.buff[length:length + rlength]
if request.__len__() < rlength:
log.msg('some data lose')
break
self.buff = self.buff[length + rlength:]
response = self.factory.doDataReceived(self, command, request)
if not response:
continue
self.safeToWriteData(response, command)
def dataReceived(self, data):
'''数据到达处理
@param data: str 客户端传送过来的数据
'''
length = self.factory.dataprotocl.getHeadlength()#获取协议头的长度
self.buff += data
while self.buff.__len__() >= length:
unpackdata = self.factory.dataprotocl.unpack(self.buff[:length])
if not unpackdata.get('result'):
log.msg('illegal data package --')
self.factory.connmanager.loseConnection(self.transport.sessionno)
break
command = unpackdata.get('command')
rlength = unpackdata.get('length')
request = self.buff[length:length+rlength]
if request.__len__()< rlength:
log.msg('some data lose')
break
self.buff = self.buff[length+rlength:]
response = self.factory.doDataReceived(self,command,request)
if not response:
continue
self.safeToWriteData(response, command)
def config(self, config, servername=None, dbconfig=None,
memconfig=None, masterconf=None):
'''配置服务器
'''
GlobalObject().json_config = 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连接
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:
log.msg(str(dbconfig))
dbpool.initPool(**dbconfig)
if hasmem and memconfig:
urls = memconfig.get('urls')
hostname = str(memconfig.get('hostname'))
mclient.connect(urls, hostname)
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 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
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
def start(self):
'''启动服务器
'''
log.msg('[%s] started...' % self.servername)
log.msg('[%s] pid: %s' % (self.servername, os.getpid()))
reactor.run()
def netconnlost(dynamicId):
""" 客户端断线 net转发给game
"""
log.msg('%s connlost' % dynamicId)
GlobalObject().root.callChild("game", 103, 103, dynamicId, None)
return
def connectionLost(self, reason):
clientID = self.transport.sessionno
log.msg("node [%d] lose"%clientID)
self.factory.root.dropChildSessionId(clientID)
def Forwarding_0(key, _conn, data):
'''转发服务器.用来接收客户端的消息转发给其他服务
'''
log.msg("Recv Key:%s dynamicId:%s data:%s" % (key, _conn.transport.sessionno, data))
message = GlobalObject().remote['gate'].callRemote("forwarding", key, _conn.transport.sessionno, data)
return message
def connectionLost(self, reason):
clientID = self.transport.sessionno
log.msg("node [%d] lose" % clientID)
self.factory.root.dropChildSessionId(clientID)
def logout_103(key, dynamicId, argument):
""" 下线协议.(客户端断开socket时自动调用)
"""
log.msg("logout_103 dynamicId:%s argument:%s" % (dynamicId, argument))
result = UserManager().dropUser(dynamicId)
return SendMessage(result, "")
def start(self):
'''启动服务器
'''
log.msg('[%s] started...'%self.servername)
log.msg('[%s] pid: %s'%(self.servername,os.getpid()))
reactor.run()
def connectionLost(self,reason):
'''连接断开处理
'''
log.msg('Client %d login out.'%(self.transport.sessionno))
self.factory.doConnectionLost(self)
self.factory.connmanager.dropConnectionByID(self.transport.sessionno)
