def __init__(self, workers):
self.client_fd = None
self.recv_buf = ''
self.send_buf = ''
self.conn_id = None
self.msg = Message()
self.logger = Log()
self.workers = workers
def __init__(self):
self.connections = {} # key = conn_id, val = connection
self.auto_id = 0
self.logger = Log()
self.workers = None
self.mode = None
self.auto_increase = 0
self.send_queue = {} # conn_id : Queue { msg1, msg2, ... } IO复用才需要，普通的直接发了
def __init__(self, conn_id=0, msg=None):
if msg is None:
self.msg = Message()
else:
self.msg = copy.copy(msg)
self.conn_id = conn_id
self.content = None
self.logger = Log()
self.parse_success = False
self.parse_err = None
def __init__(self, name, uuid):
self.os_name = platform.system()
self.python_version = platform.python_version().split(".")[0]
self.server_name = name
self.server_id = uuid
self.network_server = None
self.work_process = None
self.logger = Log()
self.conf_loader = ConfigLoader()
def synchronization_report_action_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.SYNCHRONIZATION_REPORT_ACTION_SERVICE, req.parse_err))
return
user_id = req.content["user_id"]
action = req.content["action"]
client_frame = req.content["frame"]
err_msg = ''
req_dict = controller.handler_dict[config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE].inline_call(controller, {
"user_id": user_id
})
if req_dict["ret"] != 0:
res.content = {
"ret": -1,
"err_msg": "report action error:" + req_dict["err_msg"]
}
return
room_id = req_dict["room_id"]
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
sync_controller = room_runtime.get_sync()
if sync_controller.report_logic_frame(controller, client_frame, user_id, action):
ret = 0
else:
ret = -1
res.content = {
"ret": ret,
"err_msg": err_msg,
"frame": sync_controller.server_frame
}
def game_mgr_solve_weapons_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_SOLVE_WEAPONS_SERVICE, req.parse_err))
return
user_id = req.content["user_id"]
wid = req.content["wid"]
# 获取玩家所在房间
req_dict = controller.handler_dict[
config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE].inline_call(
controller, {"user_id": user_id})
if req_dict["ret"] != 0:
res.content = {
"ret": -1,
"err_msg": '',
}
return
room_id = req_dict["room_id"]
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
for uid in room_runtime.user_id_list:
conn_id = controller.mem_cache.get(ckv.get_ckv_user_to_conn(uid))
if not conn_id:
continue
r = Response()
r.conn_id = conn_id
r.content = {"ret": 0, "err_msg": '', "user_id": user_id, "wid": wid}
res.msg_queue.append(r)
res.content = {
"ret": -1,
"err_msg": '',
}
def synchronization_query_user_transform_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.SYNCHRONIZATION_QUERY_USER_TRANSFORM_SERVICE, req.parse_err))
return
user_id = req.content["user_id"]
req_time = req.content["time"]
err_msg = ""
ret = 0
position = ''
rotation = ''
user_runtime = controller.mem_cache.get(ckv.get_ckv_user_runtime(user_id))
if user_runtime is not None:
position, rotation = user_runtime.role.get_transform()
else:
ret = -1
err_msg = 'user exit'
res.content = {
"ret": ret,
"user_id": user_id,
"position": position,
"rotation": rotation,
"err_msg": err_msg,
"time": req_time
}
def game_mgr_fight_system_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_FIGHT_SYSTEM_SERVICE, req.parse_err))
return
room_id = req.content["room_id"]
opt = req.content["opt"]
param = req.content["param"] # 客户端上来的参数按 英文逗号分隔
msg = ''
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
if room_runtime is None:
res.content = {"ret": -1, "err_msg": '', "opt": opt, "msg": msg}
return
if opt == "attacked":
attack_id, player_id, hp = [int(v) for v in param.split(",")]
room_runtime.fight_system.attacked(attack_id, player_id, hp)
msg = "#".join([
str(attack_id),
str(room_runtime.fight_system.get_gaol(attack_id))
])
elif opt == "query_players":
msg = room_runtime.fight_system.query_players_hp()
res.content = {"ret": 0, "err_msg": '', "opt": opt, "msg": msg}
def game_mgr_play_alone_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_PLAY_ALONE_SERVICE, req.parse_err))
return
user_id = str(req.content["user_id"])
ret = 0
err_msg = ''
room_id = -1
res_dict = controller.handler_dict[
config.ROOM_MGR_ENTER_ROOM_SERVICE].inline_call(
controller, {
"user_id": user_id,
"room_type": 2
})
if res_dict["ret"] != 0:
ret = res_dict["ret"]
err_msg = "ROOM_MGR_ENTER_ROOM_SERVICE error: " + res_dict["err_msg"]
else:
room_id = res_dict["room_id"]
res.content = {"ret": ret, "err_msg": err_msg, "room_id": room_id}
def fetchone(self, sql, data):
try:
if sql is not None and sql != '' and data is not None:
conn = self.get_coon()
cur = self.get_cursor(conn)
cur.execute(sql, data)
r = cur.fetchall()
self.close_all(conn, cur)
return r
else:
Log().warn("query sql format fail. sql [{}] data[{}]".format(
sql, data))
except Exception as e:
Log().warn(
"query sql format fail. sql [{}] data[{}] err:{}".format(
sql, data, e.message))
def user_change_password_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.USER_CHANGE_PASSWORD_SERVICE, req.parse_err))
return
username = req.content["username"]
password = req.content["password"]
old_password = req.content["old_password"]
print username, password, old_password
ret = 0
success = False
err_msg = ''
user = User.select_user_by_user_name(username)
if user is None:
success = False
err_msg = 'user not exist'
res.content = {"ret": 0, "success": success, "err_msg": err_msg}
return
if user.md5_str == common.get_md5_str(old_password + user.salt):
user.password = password
user.update_user_by_user_id()
success = True
else:
err_msg = 'old password not right'
success = False
res.content = {"ret": ret, "err_msg": err_msg, "success": success}
def room_mgr_query_user_belonged_room_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn(
"service %d req parse err %s" %
(config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE, req.parse_err))
return
user_id = str(req.content["user_id"])
ret = 0
err_msg = ""
room_type = -1
room_id = -1
user_runtime = controller.mem_cache.get(ckv.get_ckv_user_runtime(user_id))
if user_runtime is None:
ret = -1
err_msg = 'user not enter any room'
else:
room_type, room_id = user_runtime.get_room()
if room_type is None or room_id is None:
ret = -1
err_msg = 'room not exist'
res.content = {
"ret": ret,
"room_type": room_type,
"room_id": room_id,
"err_msg": err_msg
}
def __init__(self, mode=None):
self.mode = mode # 默认使用单进程单线程模式
self.logger = Log()
self.conn_pool = None
# key = id, value = FunctionHandler. int 到函数的映射
self.handler_dict = {}
# 通用工具集
self.common_tools = CommonTools()
# 多进程 删掉了 并没有什么用
self.process_count = 1
self.process_pool = None
# 单进程模式下处理完的事件丢到这里，后面主循环处理发回客户端
self.response_queue = []
self.auto_incr = 0
def get_coon(self):
try:
conn = sqlite3.connect(self.path)
conn.text_factory = str # 让 原来 sqllite 返回的 unicode 设置为 str
if os.path.exists(self.path) and os.path.isfile(self.path):
return conn
except Exception as e:
Log().error("db connect create fail." + e.message)
def room_mgr_enter_room_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.ROOM_MGR_ENTER_ROOM_SERVICE, req.parse_err))
return
user_id = str(req.content["user_id"])
room_type = req.content["room_type"]
ret = 0
room_id = 0
err_msg = ""
if room_type == 1: # 预设 room_type == 1 表示玩家申请加入游戏大厅
room_id = 0
elif room_type == 2: # 预设 room_type == 2 表示玩家主动申请新房间
res_dict = controller.handler_dict[config.ROOM_MGR_REGISTER_A_ROOM_SERVICE].inline_call(controller, {
"user_id": user_id
})
if res_dict["ret"] == 0:
room_id = res_dict["room_id"]
else:
ret = res_dict["ret"]
err_msg = "register room fail. " + res_dict["err_msg"]
elif room_type == 3: # 预设 room_type == 3 表示玩家加入某个指定房间，中途加入，或者多个玩家匹配加入
if "room_id" not in req.content.keys():
res.content = {
"ret": -1,
"room_id": -1,
"err_msg": "room_id not found"
}
return
else:
room_id = req.content["room_id"]
else:
res.content = {
"ret": -1,
"room_id": -1,
"err_msg": "room_type un define"
}
return
game_room.out_of_last_room(controller, user_id)
user_runtime = game_mgr.init_user_runtime(controller, user_id)
user_runtime.set_room(room_type=room_type, room_id=room_id)
user_runtime.restart()
room_runtime = game_mgr.init_room_runtime(controller, room_id)
if not room_runtime.add_user(user_id):
ret = -1
err_msg = "user has already in room"
room_id = -1
res.content = {
"ret": ret,
"room_id": room_id,
"err_msg": err_msg
}
def get_stream(self):
try:
return self.__pack_buffer()
except Exception as e:
Log().debug("get_stream err. " + e.message)
self.pack_buffer(
self.__handler_val if self.__handler_val is not None else 0,
"err")
return self.__pack_buffer()
def update(self, sql, data):
try:
if sql is not None and sql != '' and data is not None:
conn = self.get_coon()
cur = self.get_cursor(conn)
cur.execute(sql, data)
conn.commit()
rows_effect = cur.rowcount
self.close_all(conn, cur)
return rows_effect
else:
Log().warn("update sql format fail. sql [{}] data[{}]".format(
sql, data))
return 0
except Exception as e:
Log().warn(
"update sql format fail. sql [{}] data[{}] err:{}".format(
sql, data, e.message))
return 0
def game_mgr_query_matching_result_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn(
"service %d req parse err %s" %
(config.GAME_MGR_QUERY_MATCHING_RESULT_SERVICE, req.parse_err))
return
user_id = req.content["user_id"]
player_count = req.content["player_count"]
ret = 0
err_msg = ''
key = ckv.get_ckv_user_in_matching()
matching_list = controller.mem_cache.get(key)
room_id = 0
# 说明这个玩家已经匹配成功
if user_id not in matching_list:
res_dict = controller.handler_dict[
config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE].inline_call(
controller, {
"user_id": user_id,
})
if res_dict['ret'] != 0:
game_mgr.stop_match(user_id)
ret = -2
err_msg = "user not match. " + res_dict['err_msg']
else:
room_id = res_dict['room_id']
else:
if len(matching_list) >= player_count:
room_id, ret, err_msg = game_room.register_a_room(
controller, user_id)
if ret != 0:
res.content = {
"ret": ret,
"err_msg": err_msg,
"room_id": room_id
}
return
# 把目前所有玩家丢到匹配房间
num, ret, err_msg = game_mgr.matching_some_players(
controller, matching_list, room_id)
matching_list = matching_list[num:]
controller.mem_cache.set(key, matching_list)
else:
ret = -1
err_msg = "not enough players"
res.content = {"ret": ret, "err_msg": err_msg, "room_id": room_id}
class NetworkServerBase:
def __init__(self, port):
self.host = "0.0.0.0"
self.port = port
self.server_fd = None
self.state = config.SERVER_STOP
self.logger = Log()
def _close_fd(self):
try:
self.server_fd.shutdown(socket.SHUT_RDWR)
self.server_fd.close()
except IOError as e:
self.logger.error("net socket close fail err: " + str(e.errno) +
" " + e.strerror)
def _network_start(self):
self.server_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_fd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
self.server_fd.bind((self.host, self.port))
except IOError as e:
self._close_fd()
self.logger.error("server bind fail. msg: " + str(e.errno) + " " +
e.strerror)
return
self.server_fd.listen(config.MAX_LISTEN_QUEUE_SIZE)
self.server_fd.setblocking(False)
self.port = self.server_fd.getsockname()[1]
self.state = config.SERVER_ESTABLISHED
self.logger.info("server established. port:" + str(self.port))
def add_user(self, user_id):
try:
user_id = int(user_id)
except ValueError:
Log().warn(
"game_room id: {}, user_id {}, user_id must be int".format(
self.room_id, user_id))
return False
if user_id not in self.user_id_list:
self.user_id_list.append(str(user_id))
self.fight_system.add_player(int(user_id))
return True
return False
def room_mgr_exist_room_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.ROOM_MGR_EXIST_ROOM_SERVICE, req.parse_err))
return
user_id = str(req.content["user_id"])
game_room.out_of_last_room(controller, user_id)
res.content = {
"ret": 0,
"err_msg": '',
}
def game_mgr_player_event_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_PLAYER_EVENT_SERVICE, req.parse_err))
return
room_id = req.content["room_id"]
opt = req.content["opt"]
event = req.content["event"]
param = req.content["param"]
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
res.content = {"ret": 0, "opt": opt, "err_msg": ''}
def user_network_test_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.USER_NETWORK_TEST_SERVICE, req.parse_err))
return
last_time = req.content["last_time"]
msg = req.content["msg"]
res.content = {
"ret": 0,
"err_msg": '',
"last_time": last_time,
"extend": msg,
}
class Connection:
err_d = (errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK)
err_conn = (errno.EISCONN, 10057, 10035) # client 10053
def __init__(self, workers):
self.client_fd = None
self.recv_buf = ''
self.send_buf = ''
self.conn_id = None
self.msg = Message()
self.logger = Log()
self.workers = workers
def close_fd(self):
try:
self.logger.debug(
"client exit. fd = " + str(self.client_fd) + "port = " + str(self.client_fd.getpeername()[1]))
self.client_fd.shutdown(socket.SHUT_RDWR)
self.client_fd.close()
except IOError as err:
self.logger.error("conn socket close fail err:" + str(err.errno))
def assign(self, fd, conn_id):
self.client_fd = fd
self.client_fd.setblocking(False)
self.client_fd.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
self.conn_id = conn_id
self.logger.debug("new client. fd = " + str(self.client_fd) + "port = " + str(self.client_fd.getpeername()[1]))
def _package_message(self):
while len(self.recv_buf) != 0:
size = self.msg.recv(self.recv_buf)
self.recv_buf = self.recv_buf[size:]
if self.msg.finish():
# self.logger.debug("recv msg:" + self.msg.__str__())
# print "recv msg:" + self.msg.__str__()
self.workers.message_handler(self.conn_id, self.msg)
self.msg.assign()
def recv_event(self):
text = ''
# 客户端退出 not text为 True，这里text上空字符串。
# 如果是客户端暂时没有数据，并不会导致text为空传，导致10035异常，非阻塞模式中
try:
text = self.client_fd.recv(1024)
if not text:
err_code = 10000
self.close_fd()
return True
except socket.error, (code, strerror):
if code not in Connection.err_d:
err_code = code
self.close_fd()
return True
self.recv_buf += text
self._package_message()
return False
def game_mgr_register_robot_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_REGISTER_ROBOT_SERVICE, req.parse_err))
return
room_id = req.content["room_id"]
robot_key = req.content["robot_key"]
user_id = req.content["user_id"]
born_point = 0
ret = 0
err_msg = ''
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
if room_runtime is None:
res.content = {"ret": -1, "err_msg": "room not exist"}
return
fight_system = room_runtime.fight_system
if robot_key in fight_system.robots_keys.keys():
old_user_id, robot_id = fight_system.robots_keys.get(robot_key)
if user_id != old_user_id and room_runtime.isOnline(old_user_id):
res.content = {ret: -1, err_msg: "has been controller"}
return
else:
robot_id = common.get_server_core(controller).get_robot_id()
fight_system.robots_keys[robot_key] = (user_id, robot_id)
if robot_id not in fight_system.players:
controller.handler_dict[
config.ROOM_MGR_ENTER_ROOM_SERVICE].inline_call(
controller, {
"user_id": robot_id,
"room_type": 3,
"room_id": room_id
})
res.content = {
"ret": ret,
"err_msg": err_msg,
"robot_id": robot_id,
"robot_key": robot_key,
"born": born_point
}
def user_login_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.USER_LOGIN_SERVICE, req.parse_err))
return
username = req.content["username"]
password = req.content["password"]
req_time = req.content["time"]
login_success = False
user = User.select_user_by_user_name(username)
if user is None:
res.content = {
"ret": -1,
"login_success": login_success,
"user_id": -1,
"time": req_time
}
return
res_dict = controller.handler_dict[config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE].inline_call(controller, {
"user_id": user.user_id,
})
if res_dict["ret"] == 0:
res.content = {
"ret": -1,
"login_success": False,
"user_id": -1,
"time": req_time
}
return
if user.md5_str == common.get_md5_str(password + user.salt):
login_success = True
else:
login_success = False
res.content = {
"ret": 0,
"login_success": login_success,
"user_id": user.user_id,
"time": req_time
}
def game_mgr_aoe_freeze_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.GAME_MGR_AOE_FREEZE_SERVICE, req.parse_err))
return
room_id = req.content["room_id"]
pos = req.content["pos"]
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
for user_id in room_runtime.user_id_list:
conn_id = controller.mem_cache.get(ckv.get_ckv_user_to_conn(user_id))
if not conn_id:
continue
r = Response()
r.conn_id = conn_id
r.content = {"ret": 0, "err_msg": '', "pos": pos}
res.msg_queue.append(r)
res.content = {"ret": -1, "err_msg": ''}
def synchronization_query_action_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn(
"service %d req parse err %s" %
(config.SYNCHRONIZATION_QUERY_ACTION_SERVICE, req.parse_err))
return
client_frame = req.content["frame"]
user_id = req.content["user_id"]
ret = 0
err_msg = ''
# 查询用户所在游戏房间
req_dict = controller.handler_dict[
config.ROOM_MGR_QUERY_USER_BELONGED_ROOM_SERVICE].inline_call(
controller, {"user_id": user_id})
if req_dict["ret"] != 0:
res.content = {
"ret": -1,
"err_msg": "query action error:" + req_dict["err_msg"]
}
return
room_id = req_dict["room_id"]
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
sync_controller = room_runtime.get_sync()
action = sync_controller.query_logic_frame(user_id, client_frame)
if action is None:
ret = -1
err_msg = 'query error'
action = ''
res.content = {
"ret": ret,
"err_msg": err_msg,
"action": action,
"frame": sync_controller.server_frame
}
def user_user_level_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" %
(config.USER_USER_LEVEL_SERVICE, req.parse_err))
return
user_id = req.content["user_id"]
opt = req.content["opt"]
val = req.content["val"]
user_level = UserLevel.select_user_level_by_user_id(user_id)
exist = True
if user_level is None:
exist = False
user_level = UserLevel()
user_level.user_id = user_id
user_level.level = 0
if opt == 1: # 上报
user_level.level += val
if not exist:
user_level.insert_to_db()
else:
user_level.update_user_level_by_user_id()
res.content = {"ret": 0, "opt": opt, "err_msg": ''}
return
if opt == 2:
if not exist:
user_level.insert_to_db()
res.content = {
"ret": 0,
"err_msg": '',
"opt": opt,
"val": user_level.level
}
return
res.content = {"ret": -1}
def room_mgr_query_room_users_service_run(controller, req, res):
if not req.parse_success or not req.content:
Log().warn("service %d req parse err %s" % (config.ROOM_MGR_QUERY_ROOM_USERS_SERVICE, req.parse_err))
return
room_id = req.content["room_id"]
err_msg = ""
ret = 0
user_id_list = ''
room_runtime = controller.mem_cache.get(ckv.get_ckv_room_runtime(room_id))
if room_runtime is None:
ret = -1
else:
user_id_list = room_runtime.get_user_id_list_str()
res.content = {
"ret": ret,
"user_id_list": user_id_list,
"err_msg": err_msg
}
