def process_data(self, data):
if isinstance(data, str):
data = bytes(data, encoding='utf8')
self._buffer += data
_buffer = b""
if self._head is None:
if len(self._buffer) < self.head_len:
return
self._head = struct.unpack(self.handfrt,
self._buffer[:self.head_len]) # 包头
self._buffer = self._buffer[self.head_len:]
content_len = self._head[0] - self.head_len
logger.info("here22222: {}".format(
[content_len, len(self._buffer), self._head]))
if len(self._buffer) >= content_len:
data = self.encode_ins.decode(self._buffer[:content_len]) # 解密
if not data:
raise DataException()
logger.debug("receive a message data: {}, {}".format(
len(self._buffer), self._buffer[:100]))
asyncio.ensure_future(self.message_handle(self._head[1],
self._head[2], data),
loop=GlobalObject().loop)
_buffer = self._buffer[content_len:]
self._buffer = b""
self._head = None
logger.info("process_data: {}".format(
[len(_buffer), len(self._buffer), self._buffer[:100]]))
return _buffer
async def execute(self, *args, **kwargs):
logger.info("default: {}, {}, {}".format(args, kwargs, self.params))
user_id = self.params.get("user_id", -1)
if -1 == user_id and self.command_id not in [USER_OFFLINE]:
return
class_obj = RegisterEvent.events.get(self.command_id)
if not class_obj:
return BaseHandler.error_response(COMMAND_NOT_FOUND)
self.params.update({"session_id": self.session_id})
event_ins = class_obj(self.params, self.command_id, self.session_id)
try:
ret = event_ins.execute()
print("cccccccc3333:", self.params, ret, [ret.get("need_push", 1)])
if not ret.get("need_push", 1): # 不需要推送
print("ddafafafas", [ret.get("need_push", 1)])
return
return success_response(ret)
except ValidatorError as e:
print("eeeeeeeeeeeee:", e)
return error_response(e.error_code)
except Exception as e:
print("fffffffff:", traceback.format_exc())
return error_response(INVALID_REQUEST)
async def update_remote_rpc_config(self):
"""
更新远程rpc连接
:param server_type: int, 待更新的服务节点类型
:param addr_info: dict, {host: port1, host2: port2, ...}
:return:
"""
for server_type, addr_info in GlobalObject().remote_ports.items():
remote_names = [
RpcConnectionManager.gen_node_name(k, v)
for k, v in addr_info.items()
]
for r in RpcConnectionManager().conns.keys():
if r not in remote_names:
if RpcConnectionManager(
).conns[r]["status"] == ConnectionStatus.ESTABLISHED:
RpcConnectionManager(
).conns[r]["conn"].transport.close()
RpcConnectionManager().conns.pop(r)
for k, v in addr_info.items():
name = RpcConnectionManager.gen_node_name(k, v)
if name not in RpcConnectionManager().conns.keys() \
or RpcConnectionManager().conns[name]["status"] != ConnectionStatus.ESTABLISHED:
RpcConnectionManager().add_type_node(server_type, k, v)
RpcConnectionManager().store_connection(k, v, None)
try:
await self.loop.create_connection(RpcPushProtocol,
host=k,
port=v)
logger.info("success connect to {}:{}".format(k, v))
except ConnectionRefusedError as e:
logger.error("try connect to {}:{} failed!")
def act_chu(self, act_params={}):
# 出操作处理
logger.info("### act_chu act_params=", act_params)
from service.mahjong.models.playeract.chu import Chu
if not self.acts.get("chu", None):
self.acts['chu'] = Chu(game_data=self.game_data)
return self.acts["chu"].execute(act_params=act_params)
def config(self, config):
"""
:param config:
:return:
"""
host = config.get("host")
self.host = host
ws_port = config.get("websocket", {}).get("port", 0) # web_socket port
web_port = config.get("http", {}).get("port", 0) # web httpserver port
rpc_port = config.get("rpc", {}).get("port", 0) # rpcserver port
remote_ports = config.get("remote_ports", []) # remote_ports list
if "mongo" == config.get("available_way", "local") and config.get(
"mongo_uri", ""):
# 如果高可用使用的是MongoDB存储配置方式
remote_ports = AvailServerConfig.get_instance(
uri=config.get("mongo_uri"))
GlobalObject().update_remote_ports(remote_ports)
api_path = config.get("api_path", "")
if api_path:
__import__(api_path)
GlobalObject().loop = self.loop
GlobalObject().init_from_config(config)
if ws_port and self.socket_handler: # websocketserver port start
GlobalObject().ws_server = self.loop.run_until_complete(
websockets.serve(self.socket_handler,
self.host,
ws_port,
create_protocol=WebSocketProtocol))
if web_port and self.web_handler: # web httpserver port start
GlobalObject().http_server = self.loop.run_until_complete(
self.start_web(web_port))
if rpc_port:
GlobalObject().rpc_server = self.loop.run_until_complete(
self.loop.create_server(RpcProtocol, self.host, rpc_port))
if remote_ports:
for rp in remote_ports:
host = rp.get("host", "")
port = rp.get("port", 0)
s_type = NodeType.get_type(rp.get('type'))
if host and port:
RpcConnectionManager().add_type_node(s_type, host, port)
RpcConnectionManager().store_connection(host, port, None)
if not RpcConnectionManager().get_connection(host, port):
remote_serv = self.loop.create_connection(
RpcPushProtocol, host=host, port=port)
try:
self.loop.run_until_complete(remote_serv)
except ConnectionRefusedError:
logger.debug("config all conns:{}".format(
RpcConnectionManager().conns))
logger.info("connecting to {}:{} failed!".format(
host, port))
async def execute(self, *args, **kwargs):
logger.info("enter_rank_room_handler:{} {}".format(args, kwargs))
user_id = self.params.get("user_id", -1)
if -1 == user_id:
return {}
# ...
pass
return {"code": 200, "data": {"desc": "恭喜，进入排位场房间接口测试通过~"}}
async def execute(self, *args, **kwargs):
logger.info("login_handler:{} {}".format(args, kwargs))
user_name = self.params.get("name", "")
passwd = self.params.get("passwd", "")
if not user_name or not passwd:
return {}
# ...
pass
return {"code": 200, "data": {"user_id": 10, "desc": "恭喜，登录接口测试通过~"}}
def insert(self, param_name, config):
"""
:param param_name: str, 配置参数名
:param config: json(dict|list), 待插入的配置信息
:return:
"""
self.conn.insert({"name": param_name, "info": config})
logger.info("insert to mongo: {}, {}".format(param_name, config))
return
async def start_web(self, web_port):
"http协议 web"
app = web.Application()
for k, v in self.web_handler.items():
app.router.add_route("*", k, v)
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, self.host, web_port)
logger.info('server started at httpserver://{0}:{1}...'.format(
self.host, web_port))
await site.start()
async def execute(self, *args, **kwargs):
logger.info("login_handler:{} {}".format(args, kwargs))
user_id = self.params.get("user_id", -1)
passwd = self.params.get("passwd", "")
if -1 == user_id or not passwd:
return {}
login_result = route_ins.login(user_id=user_id,
passwd=passwd,
new_sessionid=self.session_id,
data=self.params)
print("login_result:", login_result)
if 200 == login_result.get('code'):
info = login_result.get("info")
old_session = info.get("old_session")
if old_session and self.session_id != old_session:
# 踢掉之前用户
to, _ = old_session.split("_")
data = error_response(USER_LOGIN_OTHER_DEVICE)
await push_message(NodeType.PROXY, USER_LOGIN_OTHER_DEVICE,
data, old_session, to)
return login_result
else:
logger.error("process_login: unknown error:%s", str(login_result))
return login_result
async def schedule(self):
# 定时rpc断线重连
while True:
await asyncio.sleep(3)
# logger.info("start new schedule task~")
# print("schedule:", RpcConnectionManager().type_dict, RpcConnectionManager().conns)
for node_type, name_lst in RpcConnectionManager().type_dict.items(
):
for name in name_lst:
if name not in RpcConnectionManager().conns.keys()\
or ConnectionStatus.ESTABLISHED != RpcConnectionManager().conns[name]["status"]:
host = RpcConnectionManager().conns[name]["host"]
port = RpcConnectionManager().conns[name]["port"]
try:
logger.debug("try to reconnect:{}".format(
[name, host, port]))
await self.loop.create_connection(RpcPushProtocol,
host=host,
port=port)
logger.info("success connect to {}:{}".format(
host, port))
except ConnectionRefusedError as e:
logger.error(
"schedule try connect to {}:{} failed!")
def handler_func(*args, **kwargs):
start_time = time.time()
logger.info("start " + str(filename) + " time: " + str(start_time))
res = func(*args, **kwargs)
end_time = time.time()
logger.info("end " + str(filename) + " time: " + str(end_time))
spent_time = end_time - start_time
if spent_time > MAX_EXCEED_TIME:
logger.warning("handler " + str(filename) + " spent time: " +
str(spent_time) + ",exceed time!")
else:
logger.info("handler " + str(filename) + " spent time: " +
str(spent_time) + ",ok.")
return res
async def websocket_handler(self, websocket, path):
logger.debug("websocket_handler: {}, {}".format(
websocket.remote_address, path))
while True:
try:
data = await asyncio.wait_for(
websocket.recv(), timeout=GlobalObject().ws_timeout)
logger.debug('websocketserver received {!r}'.format(data))
# await websocket.send("hello")
while data: # 解决TCP粘包问题
data = await websocket.process_data(data, websocket)
except asyncio.TimeoutError:
logger.info("{} connection timeout!".format(
websocket.remote_address))
await websocket.close()
except ConnectionClosed as e:
logger.info("{} connection lose ({}, {})".format(
websocket.remote_address, e.code, e.reason))
return 0
except DataException as e:
logger.info("data decrypt error!")
await websocket.close()
return 0
async def execute(self, *args, **kwargs):
logger.info("offline: {}, {}".format(args, kwargs))
pass
return {"code": NORMAL}
async def execute(self, *args, **kwargs):
logger.info("login_1000:{} {}".format(args, kwargs))
# print("login_1000:", self.command_id, self.session_id)
return {"code": 200, "user_id": 10}
async def execute(self, *args, **kwargs):
logger.info("heartbeat: {}, {}".format(args, kwargs))
pass
return {"code": 200}
async def execute(self, *args, **kwargs):
logger.info("default handler:{} {}".format(args, kwargs))
return {"code": 200}
