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}