def start(self): self.init_frame() self.frame.start() self._init_web() self.web_svr.start() log.info('app started') # spawn_later(2, self.stop) while 1: try: self._waiter.wait() break except KeyboardInterrupt: log.info('app stoped:KeyboardInterrupt') except SystemExit: log.info('app stoped:SystemExit') except: log.log_except() break log.info('spawn app stop') spawn(self.stop) sleep(0.2) cmd = ' '.join(list(map(str, [ sys.executable, ] + sys.argv))) log.info('*****app(%s) stoped', cmd) self.stop() #守护进程方式,重启服务 if self.restarted and hasattr(self, 'daemon_runner'): self.daemon_runner.domain_restart()
def start(self): if not self.stoped: return self._sock.settimeout(self.timeout + self.delay_time) self._loop_task = corelib.spawn(self._loop) self._heartbeat_task = corelib.spawn(self.heartbeat) self._send_task = corelib.spawn(self._send_let)
def over1(start, end, host, port): """ 压力测试1:模拟多个角色进入 """ func_times = range(8, 20) move_times = range(1, 2) wait_event = Event() count = 0 tasks = [] TESTS = TestCase.get_tests() def _show_info(): while 1: sleep(10) log.info(u'******tasks(%s / %s) runing', len(tasks), count) def _test_one(name): tasks.append(name) try: p = enter(name, host, port) log.debug(u'玩家(%s)进入', name) p.valid_gm() while 1: _test(name, p, TESTS[:], func_times) #close(p.user) except KeyboardInterrupt: wait_event.set() except: log.log_except() finally: tasks.remove(name) for i in xrange(start, end+1): count += 1 name = 'over1_%s' % i spawn(_test_one, name) spawn(_show_info) wait_event.wait()
def SetTodayAct(self, num): self.cycleDay.Set("guildTodayAct", num) spawn(self.owner.call, "guildTodayActPush", {"todayAct": num}, noresult=True) # 抛事件 self.owner.safe_pub(msg_define.MSG_GUILD_TODAY_ACTEXP_CHANGE)
def init_monitor(): global client_monitor_export, grpc_monitor, monitor_store if not getattr(app_config, 'monitor', None): return if client_monitor_export == monitor_export: log.info('init_monitor has done') return log.info('init_monitor') client_monitor_export = monitor_export grpc_monitor = _grpc_monitor monitor_store = _monitor_store def report(): try: import app except ImportError: return st = 30 * 60 m = Monitor.instance() while not app.stoped: data = m.pop_report() for fn, (t, total, use, err) in data.iteritems(): Game.glog.log_rpc( dict(func=fn, t=t, total=total, use=use, err=err)) sleep(st) spawn(report)
def player_login(self, pid): resp_f = 'enter' player_data = PlayerData.load(pid) player = Player() player.data.update(player_data) if player.data.id is None: log.error('player(%d)player_login load error:%s', pid, player_data) return pack_msg(resp_f, 0, err=errcode.EC_VALUE) if player.is_forbid_login: return pack_msg(resp_f, 0, err=errcode.EC_FORBID_LOGON) if not self.mgr.add_player(player): return pack_msg(resp_f, 0, err=errcode.EC_TIME_UNDUE) self.player = player try: player.set_rpc(self._rpc) player.login(self) map_id = player.data.mapId if player.data.mapId else 1 player.scene_enter(map_id, login=True) self.mgr.logon_player(player) log.debug(u'(%s)玩家(%s)登陆成功', player.data.id, player.data.name) player.send_msg(player.get_init_msg()) spawn(self.mgr.logoned_player, player) return pack_msg(resp_f, 1) except: log.log_except(u'玩家(%s)登陆初始化失败', player.data.id) self.player_logout() return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
def _check_loop(self): """ 检查 """ pass_time = 60 while 1: spawn(self._check_set) sleep(pass_time) self._log_info(pass_time)
def Use(self, xnum, select): reward = {} cnum = 0 for i in range(xnum): r = self.getSelect(select) if not r: continue cnum += 1 for k, v in r.items(): reward[k] = reward.get(k, 0) + v if not cnum: return respBag = self.ownerMode.owner.bag.costItem( {self.resID: cnum}, constant.ITEM_COST_OPEN_BOX, wLog=True) if not respBag.get("rs", 0): return respBag2 = self.ownerMode.owner.bag.add(reward, constant.ITEM_ADD_OPEN_BOX, wLog=True, mail=True) respBag = self.ownerMode.owner.mergeRespBag(respBag, respBag2) # 打包返回信息 dUpdate = self.ownerMode.owner.packRespBag(respBag) resp = { "allUpdate": dUpdate, } spawn(self.ownerMode.owner.call, "itemUse", resp, noresult=True)
def run(self): import game game.init(self) sys.modules['app'] = self self.names = None #subgame names self.sub_mgr = subgame.SubGameMgr(self) self.sub_mgr.start() self.rpc_svr.bind(self.admin_addr) self.rpc_svr.register(self) self.rpc_svr.start() self._init_web() self.web_svr.start() log.info('app started') while 1: try: self._waiter.wait() break except KeyboardInterrupt: log.info('app stoped:KeyboardInterrupt') except SystemExit: log.info('app stoped:SystemExit') except: log.log_except() break log.info('spawn app stop') spawn(self.stop) sleep(0.2) cmd = ' '.join(map(str, [sys.executable,] + sys.argv)) log.info('*****app(%s) stoped', cmd) self.stop() #守护进程方式,重启服务 if self.restarted and hasattr(self, 'daemon_runner'): self.daemon_runner.domain_restart()
def start(self): self._game.rpc_player_mgr.rpc_sub(logon_by_boss, MSG_LOGON, _proxy=True) self._game.rpc_player_mgr.rpc_sub(logout_by_boss, MSG_LOGOUT, _proxy=True) self._game.rpc_ally_mgr.rpc_sub(ally_up, MSG_ALLY_UP, _proxy=True) self.load() self._loop_task_ally = spawn(self._a_boss) self._loop_task_world = spawn(self._w_boos)
def AddItem(who, dAdd): dAdd = eval(dAdd) respBag = who.bag.add(dAdd, constant.ITEM_ADD_GM) cost_update = who.packRespBag(respBag) resp = { "allUpdate": cost_update, } spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start(self): """ 开启 """ self.load() spawn(self.loop) #保存前十 spawn(self.rank_save) Game.rpc_horn_mgr.rpc_sub(deep_enter, MSG_DEEP_FLOOR, _proxy=True) Game.rpc_boss_mgr.rpc_sub(boss_rank, MSG_WBOSS_RANK, _proxy=True)
def testFight(who, barrID): import time t1 = time.time() barrID = int(barrID) from game.fight import createFight # position = [{1: '38030013-1', 2: '38030013-2', 3: '38030013-3'}] # who._handler.rc_uploadBattleArray (1, position) fightobj = createFight(constant.FIGHT_TYPE_100) rs = fightobj.init_data( who.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL), barrID) if not rs: return 0, errcode.EC_INIT_BARR_FAIL fightLog = fightobj.doFight() log_end = fightLog.get("end", {}) winerList = log_end.get("winerList", []) fightResult = 1 if who.id in winerList else 0 barrRes = Game.res_mgr.res_barrier.get(barrID) rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId) respBag = {} if fightResult: dReward = rewardRes.doReward() respBag = who.bag.add(dReward, constant.ITEM_ADD_MORMAL_SCENE_FIGHT, wLog=True) # 打包返回信息 dUpdate = who.packRespBag(respBag) resp = { "fightLog": fightLog, "allUpdate": dUpdate, } spawn(who.call, "mapNormalFight", resp, noresult=True) t2 = time.time() import ujson dump_log = ujson.dumps(fightLog) t3 = time.time() import config if config.serverNo == '030013': fp = open("D:\\work\\pokemon2\\server\\code\\log\\testFight.log", "a") fp.write(dump_log) fp.write("\n") fp.write(str(t2 - t1)) fp.write("\n") fp.write(str(t3 - t2)) fp.write("\n") fp.close() from corelib import log log.debug(t2 - t1) log.debug(t3 - t2)
def SetActExp(self, actExp): self.actExp = actExp self.markDirty() spawn(self.owner.call, "guildActInfoPush", { "actLv": self.actLv, "actExp": self.actExp }, noresult=True)
def loop(self): try: while 1: sleep(self.loop_time) if not self.resp_and_sends: continue self.flush() finally: spawn(self.stop)
def rescueKv(who, k, v): who.rescue.rescueSystemKey({int(k): int(v)}) dUpdate = {} dUpdate["rescue"] = who.rescue.to_init_data() resp = { "allUpdate": dUpdate, } spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start(self, room, pid, data=None): """ 开战 """ self.room = room self.group = data self.group.win_node(room.aid) self.war_node = self.group.get_node(room.aid) self.is_choose = False self.smap_broad() spawn(self.auto_choose_node) return True, None
def rescueAuto(who): who.rescue.rescueAuto() dUpdate = {} dUpdate["rescue"] = who.rescue.to_init_data() resp = { "allUpdate": dUpdate, } spawn(who.call, "roleAllUpdate", resp, noresult=True)
def _process(self, data): msgs = self._unpacker.unpack(data) #log.debug('read data:%s, msgs=%s', len(data), msgs) for m in msgs: full_name = m.DESCRIPTOR.full_name if full_name.startswith('com.shendian.protobuf.'): func_name = full_name.replace('com.shendian.protobuf.', '') func = self._get_handle(full_name) if func: corelib.spawn(self._call_func, func, m)
def loop(self): """ 定时获取排名数据 """ level_rank = RankData() cbe_rank = RankData() while 1: level_rank.init() cbe_rank.init() spawn(self.loop_data, level_rank, cbe_rank) spawn(self.save) sleep(RESET_LOAD_TIME)
def _process(self, data): msgs = self._unpacker.unpack(data) if DEBUG_PACK: log.debug('read data:%s, msgs=%s', len(data), msgs) for m in msgs: tag = m.pop('_tag') full_name = m['f'] func = self._get_handle(full_name) if func: corelib.spawn(self._call_func, func, tag, m) else: self.send(self.pack_msg(full_name, 0, err=1, tag=tag))
def rescueScore(who, s): who.rescue.score = int(s) who.rescue.markDirty() dUpdate = {} dUpdate["rescue"] = who.rescue.to_init_data() resp = { "allUpdate": dUpdate, } spawn(who.call, "roleAllUpdate", resp, noresult=True)
def AddExp(who, add): add = int(add) iCurExp = who.base.GetExp() iNewExp = iCurExp + add who.base.SetExp(iNewExp) dUpdate = {} dUpdate["base"] = {"exp": who.base.GetExp()} resp = { "allUpdate": dUpdate, } spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start_broad(self, pid=0): """ 开战或和进入下一场广播 """ resp_f = 'awarStartB' self.war_data.start() self._loop_task_broad = spawn(self._loop_broad) for pid in self.war_data.war_pids: data = self.get_data(pid) data.update(dict(asid=self.room.res_warstart_config.id)) self.send_msg(resp_f, data, send_pids=[pid]) if self.war_per_config.hurts: spawn(self.boss_hurt_boat) spawn(self._loop_war)
def time_start(self): """ 根据当前时间和配置表数据对应开启活动 """ now_sec = common.current_time() - common.zero_day_time() for res_config in self.res_warstart_configs.itervalues(): notice_time = res_config.stime - res_config.ntime if notice_time <= now_sec < res_config.etime: self.warstart_config = res_config l_sec = now_sec - res_config.stime spawn(self._notice, l_sec) log.debug('start----- %s, %s', res_config.stime, res_config.type) return True return False
def start(self): self.data = self.DATA_CLS.load(Game.store, self.DATA_CLS.TABLE_KEY) if not self.data: self.data = self.DATA_CLS() else: self.load_from_dict(self.data.dataDict) self.data.set_owner(self) self._save_loop_task = spawn(self._saveLoop) self.loop_ChengzhangjijinNum_timer = spawn( self.ChengzhangjijinNum_loop)
def cron_clean_data_zero(self, inited=False): """ 定在每天凌晨0点初始化的处理 """ now = datetime.datetime.now() refresh_time = custom_today(hour=0, minute=0) refresh_time += ONE_DAY_DELTA sleep_times = (refresh_time - now).seconds + 5 self.timer_set.call_later(sleep_times, self.cron_clean_data_zero) #执行游戏逻辑刷新 if not inited: log.info(u"每日0点定时刷新开始") spawn(self.on_cron_clean_data_zero)
def stop(self): self.stoped = True for sub_frame in list(self.sub_proxys.values())[::-1]: try: sub_frame.stop(_no_result=1) except: log.log_except() for part_proxy in self.part_proxys.values(): spawn(part_proxy.stop, _no_result=1) sleep(1) self.rpc_svr.stop() grpc.uninit() self.cell_mgr.stop()
def del_sub_proxy(self, sub_proxy): """ 子进程删除 """ addr = sub_proxy.get_addr() if addr not in self.sub_proxys: return self.sub_proxys.pop(addr) app_name = sub_proxy._app_name names = sub_proxy._app_names if not self.stoped: #通知更新 self.application.del_addr_names(app_name, addr, names) for sub_frame in self.sub_proxys.values(): spawn(sub_frame.del_other_proxy, app_name, addr, names)
def gw_close(self, rpc_gw): """ 网关断开 """ svc = rpc_gw.get_service() close_gwid = getattr(svc, self.GWID) log.warning('网关(%s - %s)断开', rpc_gw.get_addr(), close_gwid) self.rpc_gws.pop(close_gwid) for key in self.processers.values(): gwid, pid = key if gwid != close_gwid: continue p = self.del_process(gwid, pid) if p: spawn(p.close, client=False)
def charge(self, id, rmb, test=False): Game.glog.log2File("charge_begin", "%s|%s|%s" % (self.owner.id, id, rmb)) res = Game.res_mgr.res_charge.get(id) if not res: return constant.CHARGE_INSIDE_ERR_NOT_FOUND_ID if test: rmb = res.rmb if res.rmb != rmb: return constant.CHARGE_INSIDE_ERR_RMB modresAll = getattr(Game.res_mgr, "res_%s" % res.type, None) if not modresAll: return constant.CHARGE_INSIDE_ERR_MODRES modres = modresAll.get(res.typeid) if not modres: return constant.CHARGE_INSIDE_ERR_MODRESID moddef = getattr(self, "%s" % res.type, None) if not moddef: return constant.CHARGE_INSIDE_ERR_MODDEF Game.glog.log2File("charge_process", "%s|%s|%s" % (self.owner.id, id, rmb)) self.owner.vip.addExp(res.exp) dUpdate = moddef(modres, res.rmb) dUpdate["vipInfo"] = self.owner.vip.to_init_data() spawn(self.owner.call, "PushCharge", { "id": id, "allUpdate": dUpdate }, noresult=True) if not test: Game.glog.log2File( "playerPay", "%s|%s|%s|%s|%s" % (self.owner.id, self.owner.name, int(time.time()), rmb, id), flag=1) self.markDirty() return constant.CHARGE_INSIDE_OK
def rc_loginSNS(self, t, sid, session, UDID, DT, MAC='', DEV='', VER='', **kw): """ 平台登录接口 """ resp_f = 'loginSNS' if not self.area_legal(): return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_AREA_ERR) if not self.is_debug_time(): return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_DEBUG_TIME) log.debug(u'平台(%s)用户登录请求:%s, %s, %s, %s, %s, %s, %s, %s', t, sid, session, UDID, DT, MAC, DEV, VER, kw) if self.count >= self.max_players: return pack_msg(resp_f, 0, err=errcode.EC_TEAM_ROLE_FULL) if not sid and t not in SNS_LOGINS:#游客登录 return pack_msg(resp_f, 0, err=errcode.EC_VALUE) #u = Game.rpc_store.query_loads(TN_USER, dict(UDID=UDID, name='')) else: rs, data = self.sns_client.login(t, sid, session) if not rs: return pack_msg(resp_f, 0, err=data) if data:#login返回sid sid = data u = UserData.user_by_sns(t, sid) if not u: #不存在自动增加 u = self._new_user(t, sid, '', UDID, DT, MAC, DEV, VER) else: u = u[0] u = User(adict=u) #如果mac地址不同,记录 if u.data.UDID != UDID or u.data.DT != DT or \ u.data.DEV != DEV or \ u.data.MAC != MAC or u.data.VER != VER: def _log_mac(): if 1: #强制保存更新信息, not u.data.MAC: u.data.UDID = UDID u.data.DT = DT u.data.MAC = MAC u.data.DEV = DEV u.data.VER = VER u.save(Game.rpc_store) else: self.glog(PM_MAC, u=u.data.id, UDID=UDID, MAC=MAC, DEV=DEV, VER=VER) spawn(_log_mac) params = self._get_login_params(sid, u.data.id, t) log.debug(u'loginSNS finish:%s', params) return pack_msg(resp_f, 1, data=params)
def start_broad(self, pid=0): """ 开战或进入下一场广播 """ resp_f = 'awarStartB' if self.war_data: self.enter_next_scene() else: self.data_init() self.war_data.start() self._loop_task_broad = spawn(self._loop_broad) sleep(1) for pid in self.war_data.war_pids: data = self.pack_data(pid) self.send_msg(resp_f, data, send_pids=[pid]) spawn(self._loop_war)
def set(self, key, value, timeout=None): """ timeout:过期时间(单位秒),如果为0,不过期 """ if timeout is None or timeout < 0: timeout = self.default_timeout if timeout > 0: timeout = time.time() + abs(timeout) self._times[key] = timeout self._caches[key] = (value, timeout) if len(self._caches) > self.size and \ self._gc_time + self.gc_time < time.time(): log.warn(u'TimeMemCache缓存(%s-%s)不足,开始清理缓存', self.name, len(self._caches)) spawn(self.gc) #sleep(0.01) return value
def stop(self): if self.stoped: return self._loop_task.kill(block=False) self._loop_task = None self._heartbeat_task.kill(block=False) self._heartbeat_task = None self._send_task.kill(block=False) self._send_task = None if self._sock is not None: self._sock.close() self._sock = None on_close = getattr(self._export, 'on_close', None) if on_close: corelib.spawn(on_close, self)
def gm_start_activity(self, war_type, time=300): """ gm开启活动 """ if time > 300: time = 300 self.stop_activity() now_sec = common.current_time() - common.zero_day_time() for res_warstart in self.res_warstart_configs.itervalues(): if war_type == res_warstart.type: self.warstart_config = copy.copy(res_warstart) self.warstart_config.etime = now_sec + 60 * 60 start_time = now_sec + time self.warstart_config.stime = start_time log.debug('gm-start----- %s, %s', start_time, res_warstart.type) break l_sec = self.warstart_config.stime - now_sec if l_sec <= self.warstart_config.ntime: spawn(self._notice, l_sec)
def _remove_logic(self, app, app_exist=True): pid, game = self.logics.pop(app, None) log.debug('remove_logic:%s, %s', pid, game) #self.mgr.apps.pop(app, None) #反注册 try: if game: Game.unreg_other_game(game.get_addr()) except: log.log_except() if app_exist: game.stop() app.stop() app.get_service().stop() spawn(self.mgr._del_game, app) spawn_later(5, self.mgr._del_subgame, pid, app)
def start(self): self._svr = new_stream_server_by_ports('0.0.0.0', config.player_ports, self._on_client_accept) self.address = config.inet_ip, self._svr.address[1] self.key = Game.rpc_player_mgr.reg_sub_mgr(self, self._game.name, self._game.get_addr(), _proxy=True) Game.sub_rpc_mgr_init(Game.rpc_player_mgr, self._rpc_mgr_init) self._loop_task = spawn(self._loop)
def choose_node(self, node, type, pid=None): """ 降龙战队长选择路线 """ if self.is_choose: return False, errcode.EC_ALLY_WAR_OUTTIME log.debug('choos-node %s',pid) self.is_choose = True self.war_node = node self.node_type = type self.hit_nodes.append(node) res_map = Game.res_mgr.awar_strong_maps.get(self.war_node) res_war_per = Game.res_mgr.awar_per_configs.get(int(float(res_map.apcid))) if res_war_per is None: return False, errcode.EC_NORES #记录选择时该节点是否已被占据 if self.group.copy_mgr.get_copys(node): self.start_is_copy = True self.war_per_config = res_war_per spawn(self.choose_node_broad, pid) return True, None
def start(self, l_sec): """ 开启同盟boss战并初始化数据 """ max_hp = self._get_max_hp() self._init_boss(self.data.aid, l_sec, max_hp) #广播boss战斗开始通知 self.handle_horn(HORN_TYPE_ALLYNOTICE, aid=self.data.aid) #广播通知即将开始 self.notice(l_sec) #开启等待数据的广播 self.loop_task = spawn(self._notice_data, l_sec)
def pass_scene(self, aid): """ 通过本场 """ if self.war_data.war_end: return log.debug('pass_scene-node-type %s',self.node_type) if self.node_type == NODE_TYPE_COPY: self._copy_reward() #当战胜隐分身或者开战前该点未被占领 时占领此节点 if self.node_type == NODE_TYPE_COPY or not self.start_is_copy: self.group.win_node(aid, self.war_node) log.debug('time1------------') self.start_is_copy = False #广播势力地图 self.is_choose = False self.smap_broad() spawn(self.auto_choose_node) log.debug('time2------------') self.group.copy_mgr.new_copys(aid, self.war_node) log.debug('time3------------')
def load(self): Game.res_mgr.sub(MSG_RES_RELOAD, self.lood) self.lood() init_vip_sett() allys = self.rpc_store.load_all(TN_ALLY) for one_ally in allys: ally = Ally(self, adict = one_ally) ally.load() self._stream_in_mgrs(ally) self._loop_sort = spawn(self.refurbish)
def start(self, l_sec): """ 开启boss战并初始化数据 """ self.init() max_hp = self._get_max_hp() self._init_boss(AID_WORLD_BOSS, l_sec, max_hp) #大喇叭广播boss战斗开始通知 self.handle_horn(HORN_TYPE_WORLDNOTICE) #广播通知即将开始 self.notice(l_sec) #开启等待数据的广播 self.loop_task = spawn(self._notice_data, l_sec)
def heartbeat(self): """ 心跳 """ fmt = hb_fmt packet_size = hb_packet_size pkt = hb_pkt htime = int(self.timeout / 2) while True: gevent.sleep(htime) try: with self._slock: if self.stoped: break self._sock.sendall(pkt) except GreenletExit: break except: log.log_except() break log.info('[client_rpc]heartbeat stop:%s' % (self.addr, )) corelib.spawn(self.stop)
def load(self): """ 加载数据(执行中的任务) """ store = self.player._game.rpc_store end_tasks = self.player.play_attr.setdefault(PLAYER_ATTR_TASKS, '') self.tid_bm.from_base64(end_tasks) querys = dict(pid=self.player.data.id, status=1) tasks = store.query_loads(TN_P_TASK, querys) for data in tasks: tid = data['tid'] if tid in self.tids:#重复记录... log.warn('[task]player(%s) task(%s) repeat', self.player.data.id, tid) spawn(store.delete, TN_P_TASK, data['id']) continue task = Task.new_by_dict(data) if not task: log.warn('[task]res_task not found:%s', tid) continue if tid in self.tid_bm:#记录异常 self.player.log_task(tid, data['id'], t=PL_ERROR) self.tasks[data['id']] = task self.tids[tid] = task if task.data.isRun: self.run_task = task if not end_tasks:#新玩家 #log.debug(u'new player accept_tasks') def _fun(): if not (self.player and self.player.logined): return self.accept_tasks(TUL_LEVEL, 1) spawn_later(2, _fun) init_data = {TASK_BFTASK_FINISH:0, TASK_ZXTASK_FINISH:0, TASK_YCTASK_FINISH:0} self.p_attr_task = self.player.play_attr.setdefault(PLAYER_ATTR_TASK, init_data) if not self.p_attr_task: self.p_attr_task = init_data
def get(self, key, default=None, add_time = None): """ """ if self._gc_time + self.gc_max_time < time.time(): # log.debug(u'TimeMemCache(%s)缓存(%s)定时清理', # self.name, len(self._caches)) #定时清理 spawn(self.gc) self.total += 1 try: cache = self._caches[key] except KeyError: self.miss += 1 return default timeout = cache[1] if add_time: value = cache[0] self.set(key, value, add_time) if timeout and time.time() >= timeout: self.delete(key) return default self.hit += 1 return cache[0]
def send_imme(self, msg): """ 立即发送 msg:必须为字符串或者protobuf对象, 在外部将protobuf对象序列化后,直接发送字符串,能优化速度 """ if isinstance(msg, str): if msg.startswith(PRE_MSG): data = msg[PRE_MSG_LEN:] data, self._w_token, self.adler_value = \ self._packer.safe_pack_raw(data, self._w_token, self.adler_value) else: raise ValueError, 'can not send str type:%s' % repr(msg) else: data, self._w_token, self.adler_value = \ self._packer.safe_pack(msg, self._w_token, self.adler_value) try: with self._slock: self._sock.sendall(data) return True except socket.error, e: log.error('[clientRpc]error:%s' % e) corelib.spawn(self.stop) return False
def send_imme(self, msg): """ 立即发送 msg:必须为字符串或者protobuf对象, 在外部将protobuf对象序列化后,直接发送字符串,能优化速度 """ if isinstance(msg, str): if msg.startswith(PRE_MSG): data = msg[PRE_MSG_LEN:] else: raise ValueError, 'can not send str type:%s' % repr(msg) else: data = self._packer.pack(msg) ## length = len(data) #log.debug('[rpc]send:%s-%s' % (self.addr, msg.DESCRIPTOR.full_name)) try: with self._slock: # self._sock.sendall(hb_pkt+data) #TODO: 测试 self._sock.sendall(data) return True except socket.error, e: log.error('[clientRpc]error:(%s)%s' % (id(self), e)) corelib.spawn(self.stop) return False
def load(self, app=None): if self._loop_task is None: self._loop_task = spawn(self._loop) for tname, load_func in self.tables.iteritems(): try: load_func() except error: #网络错误 log.log_except() return 0 except: log.log_except() if app and app.stoped: return 0 self.db_ver = self._get_db_ver() return 1
def start(self): if config.subgame_addrs: self.free_addrs = config.subgame_addrs[:] else: self.free_addrs = None self.proc_mgr = LocalProcessMgr(config.root_path) self.logic_mgr = LogicMgr(self) self.union_mgr = UnionMgr(self) if not self.is_single: self._init_normal() else: self._init_single() self.logic_mgr.start() self._loop_task = spawn(self._loop)