def sreload():
"""
"""
log.msg('reload')
if GlobalObject().reloadmodule:
reload(GlobalObject().reloadmodule)
return True
def serverStop():
"""
"""
log.msg('stop')
if GlobalObject().stophandler:
GlobalObject().stophandler()
reactor.callLater(0.5, reactor.stop)
return True
def stopBefore(self):
"""
停止之前
:return:
"""
log.msg('[%s] server is stopped ...' % self.servername)
if GlobalObject().stophandler:
GlobalObject().stophandler()
signal.alarm(1)
def render(self,request):
username = request.args['username'][0]
oprea_str = request.args['opera_str'][0]
usermodedata = register_admin.getObjData(username)#register_admin，注册表的mmode管理器，getObjData(username)，通过主键获取的对应的数据，dict型
if not usermodedata:
return "Account does not exist!!!"
pid = usermodedata.get('characterId')#角色id
if not pid:
return "Role does not exist!!!"#角色不存在，创建了账号没有创建人物
gate_node = GlobalObject().remote.get('gate')
gate_node.callRemote("opera_player",pid,oprea_str)
return "Success"
def config(self,config,dbconfig = None,memconfig = None,masterconf=None):
"""配置服务器
"""
remoteportlist = config.get('remoteport',[])#remote节点配置列表
servername = config.get('name')#服务器名称
logpath = config.get('log')#日志
hasdb = config.get('db')#数据库连接
hasmem = config.get('mem')#memcached连接
app = config.get('app')#入口模块名称
mreload = config.get('reload')#重新加载模块名称
self.servername = servername
if masterconf:
masterport = masterconf.get('rootport')
addr = ('localhost', masterport)
leafnode = leafNode(servername)
serviceControl.initControl(leafnode.getServiceChannel())
leafnode.connect(addr)
GlobalObject().leafNode = leafnode
for cnf in remoteportlist:
rname = cnf.get('rootname')
rport = cnf.get('rootport')
self.remote[rname] = leafNode(servername)
addr = ('localhost',rport)
self.remote[rname].connect(addr)
GlobalObject().remote = self.remote
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 app:
reactor.callLater(0.1, __import__, app)
if mreload:
GlobalObject().reloadmodule = __import__(mreload)
def render(self, request):
username = request.args['username'][0]
oprea_str = request.args['opera_str'][0]
usermodedata = register_admin.getObjData(
username
) #register_admin，注册表的mmode管理器，getObjData(username)，通过主键获取的对应的数据，dict型
if not usermodedata:
return "Account does not exist!!!"
pid = usermodedata.get('characterId') #角色id
if not pid:
return "Role does not exist!!!" #角色不存在，创建了账号没有创建人物
gate_node = GlobalObject().remote.get('gate')
gate_node.callRemote("opera_player", pid, oprea_str)
return "Success"
def Forwarding_0(keyname, _conn, data):
"""消息转发，将客户端发送的消息请求转发给gateserver分配处理
"""
dd = GlobalObject().remote['gate'].callRemote("forwarding", keyname,
_conn.transport.sessionno,
data)
return dd
def config(self, config, dbconfig=None, memconfig=None, masterconf=None):
"""配置服务器
"""
servername = config.get('name') #服务器名称
logpath = config.get('log') #日志
hasdb = config.get('db') #数据库连接
hasmem = config.get('mem') #memcached连接
app = config.get('app') #入口模块名称
self.servername = servername
if masterconf:
masterport = masterconf.get('rootport')
addr = ('localhost', masterport)
self.leafNode = leafNode(servername)
self.leafNode.connect(addr)
GlobalObject().leafNode = self.leafNode
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 app:
reactor.callLater(0.1, __import__, app)
def render(self, request):
"""
"""
for child in GlobalObject().root.childsmanager._childs.values():
d = child.callbackChild('sreload')
d.addCallback(ErrorBack)
return "reload"
def forwarding(key,dynamicId,data):
"""
"""
if key in GlobalObject().localservice._targets:
return GlobalObject().localservice.callTarget(key,dynamicId,data)
else:
user = UsersManager().getUserByDynamicId(dynamicId)
if not user:
return
oldvcharacter = VCharacterManager().getVCharacterByClientId(dynamicId)
if not oldvcharacter:
return
if oldvcharacter.getLocked():#判断角色对象是否被锁定
return
node = VCharacterManager().getNodeByClientId(dynamicId)
return GlobalObject().root.callChild(node, key, dynamicId, data)
def remote_connect(rname, rhost):
"""
连接远程节点
:param rname:
:param rhost:
:return:
"""
GlobalObject().remote_connect(rname, rhost)
def render(self, request):
"""
"""
for child in GlobalObject().root.childsmanager._childs.values():
d = child.callbackChild('serverStop')
d.addCallback(ErrorBack)
reactor.callLater(0.5,reactor.stop)
return "stop"
def remote_connect(rname, rhost):
"""
连接远程节点
:param rname:
:param rhost:
:return:
"""
# logger.debug("rname:%s, rhost:%s", rname, rhost)
GlobalObject().remote_connect(rname, rhost)
def SavePlayerInfoInDB(dynamicId):
"""将玩家信息写入数据库
node: 用于判定是 game1，game2，。。。。。这些节点
magic number: 2 --> "maybe save to db"
"""
vcharacter = VCharacterManager().getVCharacterByClientId(dynamicId)
nodeid = vcharacter.getNode()
d = GlobalObject().root.callChild(nodeid,2,dynamicId)
return d
def opera_player(pid,oprea_str):
"""
#vcharacter是虚拟角色，VCharacterManager()虚拟角色管理器，{角色id:虚拟角色实例}
"""
vcharacter = VCharacterManager().getVCharacterByCharacterId(pid)
if not vcharacter:
node = "game1"
else:
node = vcharacter.getNode()
GlobalObject().root.callChild(node,99,pid,oprea_str)
def config(self, config, dbconfig=None, memconfig=None, masterconf=None):
"""配置服务器
"""
netport = config.get('netport') #客户端连接
gatelist = config.get('remoteport', []) #remote节点配置列表
servername = config.get('name') #服务器名称
logpath = config.get('log') #日志
app = config.get('app') #入口模块名称
self.servername = servername
if masterconf:
masterport = masterconf.get('rootport')
addr = ('localhost', masterport)
leafnode = leafNode(servername)
serviceControl.initControl(leafnode.getServiceChannel())
leafnode.connect(addr)
GlobalObject().leafNode = leafnode
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
GlobalObject().netfactory = self.netfactory
for cnf in gatelist:
rname = cnf.get('rootname')
rport = cnf.get('rootport')
self.gates[rname] = leafNode(servername)
addr = ('localhost', rport)
self.gates[rname].connect(addr)
GlobalObject().remote = self.gates
if logpath:
log.addObserver(loogoo(logpath)) #日志处理
log.startLogging(sys.stdout)
if app:
reactor.callLater(0.1, __import__, app)
def config(self, config, dbconfig=None, memconfig=None, masterconf=None):
"""配置服务器
"""
rootport = config.get('rootport') #root节点配置
servername = config.get('name') #服务器名称
logpath = config.get('log') #日志
hasdb = config.get('db') #数据库连接
hasmem = config.get('mem') #memcached连接
app = config.get('app') #入口模块名称
self.servername = servername
if masterconf:
masterport = masterconf.get('rootport')
addr = ('localhost', masterport)
leafnode = leafNode(servername)
serviceControl.initControl(leafnode.getServiceChannel())
leafnode.connect(addr)
GlobalObject().leafNode = leafnode
if rootport:
self.root = PBRoot("rootservice")
reactor.listenTCP(rootport, BilateralFactory(self.root))
GlobalObject().root = self.root
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 app:
reactor.callLater(0.1, __import__, app)
def __startWeb(self):
GlobalObject().webroot = webapp.initWeb()
reactor.listenTCP(self.webport, DelaySite(GlobalObject().webroot))
def __startRoot(self):
GlobalObject().root = PBRoot("rootservice")
reactor.listenTCP(self.rootport, BilateralFactory(GlobalObject().root))
def set_config(self):
"""
初始化节点服务配置
:return:
"""
config = Config().config
ser_cfg = config.get("servers", {}).get(self.servername)
if not ser_cfg:
raise ValueError
mem_cfg = config.get("cache")
master_cfg = config.get("master")
db_cfg = config.get("db")
GlobalObject().json_config = ser_cfg
netport = ser_cfg.get('netport') # 客户端连接
webport = ser_cfg.get('webport') # http连接
rootport = ser_cfg.get('rootport') # root节点配置
wsport = ser_cfg.get("wsport") # WebSocket端口
self.remoteportlist = ser_cfg.get('remoteport', []) # remote节点配置列表
logpath = ser_cfg.get('log') # 日志
hasdb = ser_cfg.get('db') # 数据库连接
hasmem = ser_cfg.get('mem') # memcached连接
app = ser_cfg.get('app') # 入口模块名称
cpuid = ser_cfg.get('cpu') # 绑定cpu
mreload = ser_cfg.get('reload') # 重新加载模块名称
if master_cfg:
masterport = master_cfg.get('rootport')
masterhost = master_cfg.get('roothost')
self.master_remote = RemoteObject(self.servername)
addr = ('localhost',
masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
GlobalObject().masterremote = self.master_remote
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = vhost.NameVirtualHost()
GlobalObject().webroot = self.webroot
reactor.listenTCP(webport, DelaySite(self.webroot))
if rootport:
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
reactor.listenTCP(rootport, BilateralFactory(self.root))
if wsport:
self.ws = WsFactory(wsport)
wsservice = services.CommandService("wsservice")
self.ws.addServiceChannel(wsservice)
reactor.listenTCP(wsport, self.ws)
for cnf in self.remoteportlist:
rname = cnf.get('rootname')
self.remote[rname] = RemoteObject(self.servername)
if hasdb and db_cfg:
log.msg(str(db_cfg))
dbpool.initPool(**db_cfg)
if hasmem and mem_cfg:
urls = mem_cfg.get('urls')
hostname = str(mem_cfg.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)
GlobalObject().server = self
if app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,
fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
import admin
def callWhenConnLost(conn):
dynamicId = conn.transport.sessionno
GlobalObject().remote['gate'].callRemote("netconnlost",dynamicId)
def __init__(self, parent=None):
super().__init__(parent)
GlobalObject().addEventListener("hello", self.foo)
self._label = QtWidgets.QLabel()
lay = QtWidgets.QVBoxLayout(self)
lay.addWidget(self._label)
def on_clicked(self):
GlobalObject().dispatchEvent("hello")
def pushObject(topicID,msg,sendList):
GlobalObject().netfactory.pushObject(topicID, msg, sendList)
def pushObject(topicID, msg, sendList):
"""
"""
GlobalObject().root.callChild("net", "pushObject", topicID, msg, sendList)
#coding:utf8
"""
Created on 2013-8-14
@author: lan (www.9miao.com)
"""
from globalobject import GlobalObject
from services import CommandService
remoteservice = CommandService("gateremote")
GlobalObject().remote["gate"].setServiceChannel(remoteservice)
def remoteserviceHandle(target):
"""
"""
remoteservice.mapTarget(target)
#coding:utf8
"""
Created on 2013-8-14
@author: lan (www.9miao.com)
"""
from dataloader import load_config_data,registe_madmin
from globalobject import GlobalObject
from app.game.core.PlayersManager import PlayersManager
from twisted.python import log
def doWhenStop():
"""服务器关闭前的处理
"""
for player in PlayersManager()._players.values():
try:
player.updatePlayerDBInfo()
PlayersManager().dropPlayer(player)
except Exception as ex:
log.err(ex)
GlobalObject().stophandler = doWhenStop
def loadModule():
"""
"""
load_config_data()
registe_madmin()
from gatenodeapp import *
#coding:utf8 """ Created on 2013-8-13 @author: lan (www.9miao.com) """ from globalobject import GlobalObject from dbfront import initconfig GlobalObject().stophandler = initconfig.doWhenStop initconfig.loadModule()
def remote_connect(rname, rhost):
"""
"""
GlobalObject().remote_connect(rname, rhost)
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 masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername, "master")
addr = ('localhost',
masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
GlobalObject().masterremote = self.master_remote
if netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = vhost.NameVirtualHost()
GlobalObject().webroot = self.webroot
reactor.listenTCP(webport, DelaySite(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, rname)
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 app:
__import__(app)
if mreload:
_path_list = mreload.split(".")
GlobalObject().reloadmodule = __import__(mreload,
fromlist=_path_list[:1])
GlobalObject().remote_connect = self.remote_connect
import admin
def initNetApp():
netservice = NetCommandService("loginService")
netservice.mapTarget(Forwarding_0)
GlobalObject().netfactory.addServiceChannel(netservice)