def recharge_response():
post_sign = request.form.get('sign')
post_notify_data = request.form.get('notify_data')
post_orderid = request.form.get('orderid')
post_dealseq = request.form.get('dealseq')
post_uid = request.form.get('uid')
post_subject = request.form.get('subject')
post_v = request.form.get('v')
logger.debug('kuaiyong recharge:%s', request.form)
result, fee = recharge_verify(post_sign, post_notify_data, post_orderid,
post_dealseq, post_uid, post_subject, post_v)
if result:
player_id = int(post_dealseq.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return 'failed'
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.kuaiyong_recharge_remote(oldvcharacter.dynamic_id,
post_subject, fee, True)
if result:
return 'success'
return 'failed'
def recharge_vivo_response():
logger.debug('vivo recharge:%s', request.form)
if request.form['respCode'] != '200' or request.form[
'tradeStatus'] != '0000':
logger.error('failed!! %s', request.form)
return json.dumps(dict(respCode=120014))
product_per_price = request.form['orderAmount']
cp_order_id = request.form['cpOrderNumber']
product_id = request.form['extInfo']
player_id = int(cp_order_id.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return json.dumps(dict(code=120014, message='', value='', redirect=''))
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.vivo_recharge_remote(oldvcharacter.dynamic_id,
product_id, product_per_price,
cp_order_id, True)
if result is True:
logger.debug('response:success')
return json.dumps(dict(respCode=200))
logger.debug('response:failed')
return json.dumps(dict(respCode=120014))
def recharge_lenovo_response():
logger.debug('lenovo recharge:%s', request.form)
data = eval(request.form['transdata'])
product_per_price = data['money']
cp_order_id = data['exorderno']
product_id = data['cpprivate']
player_id = int(cp_order_id.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return 'FAILURE'
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.lenovo_recharge_remote(oldvcharacter.dynamic_id,
product_id, product_per_price,
cp_order_id, True)
if result is True:
logger.debug('response:success')
return 'SUCCESS'
logger.debug('response:failed')
return 'FAILURE'
def server_login_2(command_id, dynamic_id, request_proto):
""" 帐号登录
@param command_id:
@param dynamic_id:
@param request_proto:
@return:
"""
# 登录数据解析
account_request = account_pb2.AccountLoginRequest()
account_request.ParseFromString(request_proto)
key = account_request.passport
account_response = account_pb2.AccountResponse()
account_response.result = False
# 通知帐号服
logger.info('rpc account verify:%s', key)
result = GlobalObject().remote['login'].account_verify_remote(key)
result = eval(result)
logger.info('verify result:%s', result)
if result.get('result') is True: # 登录成功
uuid = result.get('uuid')
logger.info('login uuid:%s', uuid)
account_id = get_account_id(uuid)
# print account_id
if account_id == 0:
account_response.result = False
account_response.message = '2'
else:
account_response.result = __manage_user(uuid,
account_id,
dynamic_id)
logger.debug(account_response)
return account_response.SerializeToString()
def recharge_oppo_response():
logger.debug('oppo recharge:%s', request.form)
# 验证签名
partnerOrder = request.form['partnerOrder']
product_id = request.form['partnerOrder']
data = {'notifyId': request.form['notifyId'],
'partnerOrder': partnerOrder,
'productName': request.form['productName'],
'productDesc': request.form['productDesc'],
'price': request.form['price'],
'count': request.form['count'],
'attach': request.form['attach'],
'sign': request.form['sign']}
check_res = check_sign(data)
# 验签失败
if not check_res:
logger.error("result=FAIL&resultMsg=Sign无效")
return "result=FAIL&resultMsg=Sign无效"
# 发货
player_id = int(partnerOrder.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error("result=FAIL&resultMsg=玩家未在线")
return "result=FAIL&resultMsg=玩家未在线"
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.oppo_recharge_remote(oldvcharacter.dynamic_id,
product_id, partnerOrder, True)
if not result:
logger.error("result=FAIL&resultMsg=发货失败")
return "result=FAIL&resultMsg=发货失败"
return "result=OK"
def recharge_uc_response():
logger.debug('uc recharge:%s', request.json)
# 验证签名
data = request.json['data']
sign = request.json['sign']
check_res = check_sign(data, sign)
logger.debug('uc check_res:%s', check_res)
# 验签失败
if not check_res:
return "FAILURE"
# 发货
cpOrderId = data['cpOrderId']
orderId = data['callbackInfo']
player_id = int(cpOrderId.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
return "FAILURE"
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.uc_recharge_remote(
oldvcharacter.dynamic_id, orderId, cpOrderId, True)
logger.debug('uc result:%s', result)
if not result:
return "FAILURE"
return "SUCCESS"
def xm_recharge_response():
logger.debug('xiaomi recharge:%s', request.form)
appId = request.form.get('appId')
cpOrderId = request.form.get('cpOrderId')
# cpUserInfo = request.form.get('cpUserInfo')
# uid = request.form.get('uid')
# orderId = request.form.get('orderId')
orderStatus = request.form.get('orderStatus')
payFee = request.form.get('payFee')
productCode = request.form.get('productCode')
# productName = request.form.get('productName')
# productCount = request.form.get('productCount')
# payTime = request.form.get('payTime')
# orderConsumeType = request.form.get('orderConsumeType')
# signature = request.form.get('signature')
if int(AppId) != int(appId):
logger.error('appId diff:%s get %s' % (AppId, appId))
return return_data(1515)
if orderStatus == "TRADE_SUCCESS":
player_id = int(cpOrderId.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return ''
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.xiaomi_recharge_remote(
oldvcharacter.dynamic_id, productCode, payFee, cpOrderId, True)
return return_data(result)
return return_data(1525)
def remote_transit(self, node, command, *arg, **kw):
_node = GlobalObject().remote.get(node)
if _node:
return _node.__getattr__(command)(*arg, **kw)
_node = GlobalObject().child(node)
if _node:
return _node.__getattr__(command)(*arg, **kw)
logger.error('remote_transit:%s-%s', node, command)
return None
def recharge_baidu_response():
resultCode = "1"
resultMsg = "成功"
logger.debug('baidu recharge:%s', request.form)
appid = request.form['AppID']
orderSerial = request.form['OrderSerial']
cooperatorOrderSerial = request.form['CooperatorOrderSerial']
content = request.form['Content']
sign = request.form['Sign']
# 验证签名
sign_l = sign_make(sign, appid, orderSerial, cooperatorOrderSerial,
content)
if sign != sign_l:
resultCode = "10001"
resultMsg = "Sign无效"
logger.error('error:md5--%s : %s', sign, sign_l)
return resultMsg
# base64解码
content = base64.b64decode(content)
# json解析
js = json.loads(content)
logger.debug('content:', js)
# print js["UID"]
# print js["MerchandiseName"]
fee = js["OrderMoney"]
# print js["StartDateTime"]
# print js["BankDateTime"]
# print js["OrderStatus"]
# print js["StatusMsg"]
product_id = js["ExtInfo"]
# print js["VoucherMoney"]
# print resultMsg
response = "{\"AppID\":" + appid + ",\"ResultCode\":" + resultCode + \
",\"ResultMsg\":\"" + resultMsg + "\",\"Sign\":\"" + \
response_sign(resultCode) + "\",\"Content\":\"\"}"
player_id = int(cooperatorOrderSerial.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return 'failed'
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.baidu_recharge_remote(
oldvcharacter.dynamic_id, product_id, fee, cooperatorOrderSerial, True)
if result is True:
logger.debug('response:%s', response)
return response
logger.debug('response:failed')
return 'failed'
def to_transit(key, character_id, args):
oldvcharacter = VCharacterManager().get_by_id(character_id)
# print VCharacterManager().character_client
if oldvcharacter:
args = (key, oldvcharacter.dynamic_id) + args + (True,)
child_node = groot.child(oldvcharacter.node)
return child_node.callbackChild(*args)
else:
transit_remote = GlobalObject().remote['transit']
return transit_remote.push_message_remote(key, character_id, *args)
def forwarding_remote(key, dynamic_id, data):
"""
"""
if key in local_service._targets:
return local_service.callTarget(key, dynamic_id, data)
else:
oldvcharacter = VCharacterManager().get_by_dynamic_id(dynamic_id)
if not oldvcharacter:
logger.error('cant find player:%s', dynamic_id)
return
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.callbackChild(key, dynamic_id, data)
return result
def recharge360_response():
# order_id=1211090012345678901&
# app_key=1234567890abcdefghijklmnopqrstuv&
# product_id=p1&
# amount=101&
# app_uid=123456789&
# app_ext1=XXX201211091985&
# app_order_id=order1234&
# user_id=987654321&
# sign_type=md5&
# gateway_flag=success&
# sign=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx&
# sign_return=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
product_id = request.args.get('product_id')
# order_id = request.args.get('order_id')
app_key = request.args.get('app_key')
# amount = request.args.get('amount')
app_uid = request.args.get('app_uid')
# app_ext1 = request.FORM.GET('app_ext1')
app_order_id = request.args.get('app_order_id')
# user_id = request.args.get('user_id')
# sign_type = request.args.get('sign_type')
# gateway_flag = request.args.get('gateway_flag')
# sign = request.args.get('sign')
# sign_return = request.args.get('sign_return')
if APPKEY != app_key:
logger.error('err appkey=%s-%s, appid=%s-%s', APPKEY, app_key, APPID,
app_uid)
logger.error('360 recharge:%s', request.args)
return 'failed'
logger.debug('360 recharge:%s', request.args)
player_id = int(app_order_id.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return 'failed'
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.q360_recharge_remote(oldvcharacter.dynamic_id,
product_id, app_order_id, True)
if result:
return 'ok'
return 'failed'
def push_message_maintime_remote(key, character_id, maintain_time, args):
logger.debug("netforwarding.push_message_maintime_remote")
logger.debug("push time message %s %s %s %s" % (key, character_id,
maintain_time, args))
oldvcharacter = VCharacterManager().get_by_id(character_id)
# print VCharacterManager().character_client
if oldvcharacter:
args = (key, oldvcharacter.dynamic_id) + args + (True,)
child_node = groot.child(oldvcharacter.node)
return child_node.callbackChild(*args)
else:
transit_remote = GlobalObject().remote['transit']
return transit_remote.push_message_maintime_remote(key,
character_id,
maintain_time,
*args)
def send_rank_reward_mails(self):
"""
排行奖励
"""
logger.debug("hjqy send_award_top_ten===========")
award_info = game_configs.base_config.get("hjqyDayReward")
for up, down, mail_id in award_info.values():
ranks = self._rank_instance.get(up, down)
for k, v in enumerate(ranks):
player_id, val = v
logger.debug("send_award_top_ten: player_id %s, value %s, mail_id %s" % (player_id, v, mail_id))
mail_data, _ = deal_mail(conf_id=mail_id, receive_id=int(player_id))
remote_gate = GlobalObject().child('gate')
remote_gate.push_message_to_transit_remote('receive_mail_remote',
int(player_id), mail_data)
#clear rankinfo
self._rank_instance.clear_rank()
def recharge_huawei_response():
logger.debug('huawei recharge:%s', request.form)
# userName = request.form['userName']
# orderId = request.form['orderId']
# orderTime = request.form['orderTime']
# spending = request.form['spending']
# accessMode = request.form['accessMode']
# payType = request.form['payType']
# productName = request.form['productName']
amount = request.form['amount']
# tradeTime = request.form['tradeTime']
# result = request.form['result']
# notifyTime = request.form['notifyTime']
# sign = request.form['sign']
requestId = request.form['requestId']
extReserved = request.form['extReserved']
# 验证签名
# if sign != hashlib.md5(appid + orderSerial + cooperatorOrderSerial +
# content + secretkey).hexdigest():
# resultCode = "10001"
# resultMsg = "Sign无效"
# print 'error:', sign, 'md5:', hashlib.md5(
# appid + orderSerial + cooperatorOrderSerial + content +
# secretkey).hexdigest()
# return resultMsg
player_id = int(requestId.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return json.dumps(dict(result=3))
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.huawei_recharge_remote(
oldvcharacter.dynamic_id, extReserved, amount, requestId, True)
if result is True:
logger.debug('response:success')
return json.dumps(dict(result=0))
logger.debug('response:failed')
return json.dumps(dict(result=3))
def __character_login(dynamic_id, pay_arg):
user = UsersManager().get_by_dynamic_id(dynamic_id)
logger.info("user_id:%d", dynamic_id)
if not user:
logger.error("user not exist!")
return {'result': False, 'result_no': 4001}
v_character = VCharacterManager().get_by_id(user.user_id)
if v_character:
v_character.dynamic_id = dynamic_id
v_character.state = 1 # 恢复掉线状态-> 正常状态
else:
v_character = VirtualCharacter(user.user_id, dynamic_id)
VCharacterManager().add_character(v_character)
now_node = v_character.node
if not now_node:
now_node = SceneSerManager().get_best_sceneid()
if not now_node:
logger.error("can't find game server!")
return {'result': False, 'result_no': 4002}
v_character.node = now_node
# game服登录
child_node = GlobalObject().child(now_node)
res_data = child_node.enter_scene_remote(dynamic_id, user.user_id, pay_arg)
if not res_data['player_data']:
logger.error("enter scene error!")
return {'result': False, 'result_no': 4003}
# logger.debug("pull_message_remote")
# # pull message from transit
# GlobalObject().remote['transit'].pull_message_remote(user.user_id)
SceneSerManager().add_client(now_node, dynamic_id)
res_data['result'] = True
return res_data
def SendMessage(topicID, dynamicId, state, message, isSend=False):
Data = {
'State': state,
}
if state:
Data['Data'] = message
else:
Data['Message'] = message
jsonData = dumps(Data, separators=(',', ':'), default=jsonDefault)
if isSend is False:
return jsonData
return GlobalObject().root.callChild("net", "pushObject", topicID, msg,
dynamicId)
def masterapp(self):
"""
"""
config = json.load(open(self.configpath, 'r'))
GlobalObject().json_config = config
mastercnf = config.get('master')
rootport = mastercnf.get('rootport')
webport = mastercnf.get('webport')
masterlog = mastercnf.get('log')
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
self.webroot = Flask("master")
GlobalObject().root = self.root
GlobalObject().webroot = self.webroot
if masterlog:
log.addObserver(loogoo(masterlog)) #日志处理
log.startLogging(sys.stdout)
import webapp
import rootapp
reactor.listenWSGI(webport, self.webroot)
reactor.listenTCP(rootport, BilateralFactory(self.root))
def send_message_1002(command_id, dynamic_id, request_proto):
"""发送消息
@param command_id: 协议号
@param dynamic_id: 动态ID
#param request_proto: 消息体
"""
argument = chat_pb2.ChatConectingRequest()
argument.ParseFromString(request_proto)
logger.debug("argument %s" % argument)
response = chat_pb2.ChatResponse()
character_id = argument.owner.id
character_nickname = argument.owner.nickname
room_id = argument.channel
content = argument.content
guild_position = argument.guild_position
to_character_id = argument.other.id
to_character_nickname = argument.other.nickname
guild_id = argument.guild_id
vip_level = argument.vip_level
head = argument.other.head
child_chat = GlobalObject().root.childsmanager.child('chat')
info = child_chat.callbackChild(command_id, character_id, dynamic_id,
room_id, content, character_nickname,
to_character_id, to_character_nickname,
guild_id, vip_level, guild_position, head)
# info = localservice.callTarget(command_id, character_id, dynamic_id,
# room_id, content, character_nickname, \
# to_character_id, to_character_nickname)
result = info.get('result', False)
response.result = result
if info.get('result_no'):
response.result_no = info.get('result_no')
if info.get('gag_time'):
response.gag_time = info.get('gag_time')
return response.SerializeToString()
def callTarget(self, targetKey, *args, **kw):
_conn = args[0]
data = args[1]
if targetKey == 100002:
return data
dynamic_id = _conn.transport.sessionno
if not GlobalObject().netfactory.connmanager.hasConnection(dynamic_id):
return
result = remote_gate.forwarding_remote(targetKey,
_conn.transport.sessionno, data)
return result
def get_best_sceneid(self):
"""获取最佳的game服务器
"""
for child in GlobalObject().root.childsmanager._childs.values():
if "game" in child.name and child.id not in self._scenesers:
self.add_scene(child.id)
serverlist = self._scenesers.values()
print("serverlist: %s" % serverlist)
slist = sorted(serverlist,
reverse=False,
key=lambda ser: ser.get_client_count())
if slist:
return slist[0].id
def remote_transit(self, node, command, *arg, **kw):
_node = GlobalObject().remote.get(node)
if _node:
return _node.__getattr__(command)(*arg, **kw)
_node = GlobalObject().child(node)
if _node:
return _node.__getattr__(command)(*arg, **kw)
logger.error('remote_transit:%s-%s', node, command)
return None
def hjqy_battle_remote(player_info, boss_id, str_red_units, red_unpar_data, attack_type, seed1, seed2):
"""开始战斗
"""
logger.debug("hjqy_battle_remote======")
red_units = cPickle.loads(str_red_units)
result = False
boss = hjqy_manager.get_boss(boss_id)
player_id = player_info.get("player_id")
player_level = player_info.get("level")
blue_units = boss.blue_units
origin_hp = boss.hp
result = hjqy_start(red_units, blue_units, red_unpar_data, {}, attack_type, seed1, seed2, player_level)
logger.debug("blue unit length %s" % len(blue_units))
boss.blue_units = blue_units
current_damage_hp = origin_hp - boss.hp
logger.debug("origin_hp %s, current_hp %s, current_damage_hp %s" % (origin_hp, boss.hp, current_damage_hp))
player_info["damage_hp"] = current_damage_hp
hjqy_manager.add_rank_item(player_info) # 添加排行
is_kill = 0
if boss.get_state() == const.BOSS_DEAD: # 击杀boss
is_kill = 1
# send last kill reward mail
hjqyKillBossReward = game_configs.base_config.get("hjqyKillBossRewardID")
mail_data, _ = deal_mail(conf_id=hjqyKillBossReward, receive_id=int(player_id))
remote_gate = GlobalObject().child('gate')
remote_gate.push_message_to_transit_remote('receive_mail_remote',
int(player_id), mail_data)
result = True
#return dict(result=result, state=boss.get_state())
logger.debug("hjqy_battle_remote over===================")
boss.save_data()
return result, boss.get_state(), current_damage_hp, is_kill
def _doChildConnect(name,transport):
"""当server节点连接到master的处理
"""
server_config = GlobalObject().json_config.get('servers',{}).get(name,{})
remoteport = server_config.get('remoteport',[])
child_host = transport.transport.address[0]
root_list = [rootport.get('rootname') for rootport in remoteport]
GlobalObject().remote_map[name] = {"host":child_host,"root_list":root_list}
#通知有需要连的node节点连接到此root节点
for servername,remote_list in GlobalObject().remote_map.items():
remote_host = remote_list.get("host","")
remote_name_host = remote_list.get("root_list","")
if name in remote_name_host:
GlobalObject().root.callChild(servername,"remote_connect",name,remote_host)
#查看当前是否有可供连接的root节点
master_node_list = GlobalObject().remote_map.keys()
for root_name in root_list:
if root_name in master_node_list:
root_host = GlobalObject().remote_map[root_name]['host']
GlobalObject().root.callChild(name,"remote_connect",root_name,root_host)
def login_chat_1001(command_id, dynamic_id, request_proto):
"""登录聊天服务器
"""
# TODO 登录协议需要修改
argument = chat_pb2.LoginToChatRequest()
argument.ParseFromString(request_proto)
response = chat_pb2.ChatResponse()
character_id = argument.owner.id
character_nickname = argument.owner.nickname
result = GlobalObject().childsmanager.child('chat').login_chat_remote(character_id,
dynamic_id,
character_nickname)
response.result = result
return response.SerializeToString()
def enterScene(dynamicId, characterId, placeId,force):
'''进入场景
@param dynamicId: int 客户端的ID
@param characterId: int 角色的ID
@param placeId: int 场景的ID
@param force: bool
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer:
return None
nownode = SceneSerManager().getBsetScenNodeId()
d = GlobalObject().root.callChild(nownode,601,dynamicId, characterId, placeId,force,None)
vplayer.setNode(nownode)
SceneSerManager().addClient(nownode, vplayer.dynamicId)
return d
def forwarding(key, dynamicId, data):
"""
"""
if localservice._targets.has_key(key):
return 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 setUp(self):
config = json.load(open('../config.json', 'r'))
def init():
hostname = "127.0.0.1" # 要连接的数据库主机名
user = "******" # 要连接的数据库用户名
password = "******" # 要连接的数据库密码
port = 3306 # 3306 是MySQL服务使用的TCP端口号，一般默认是3306
dbname = "traversing_1" # 要使用的数据库库名
charset = "utf8" # 要使用的数据库的编码
dbpool.initPool(
host=hostname,
user=user,
passwd=password,
port=port,
db=dbname,
charset=charset
) ##firefly重新封装的连接数据库的方法，这一步就是初始化数据库连接池，这样你就可连接到你要使用的数据库了
init()
client = RedisClient()
mmanager = MAdminManager()
GlobalObject().json_model_config = config.get("models")
redis_manager.connection_setup(config.get("memcached").get("urls"))
m1 = redis_mode.MAdmin('tb_character_hero', 'id')
m1.insert()
data = {
'hero_no': 10001,
'character_id': 106,
'level': 9,
'break_level': 10,
'exp': 11,
'equipment_ids': ''
}
self.hero_mmode = m1.new(data)
self.hero = Hero(1)
self.hero.level = 12306
return None
if isinstance(defer_data, defer.Deferred):
return defer_data
d = defer.Deferred()
d.callback(defer_data)
finally:
self._lock.release()
return d
netservice = NetCommandService("loginService")
def netserviceHandle(target):
"""
"""
netservice.mapTarget(target)
GlobalObject().netfactory.addServiceChannel(netservice)
@netserviceHandle
def Forwarding_0(keyname, _conn, data):
'''消息转发，将客户端发送的消息请求转发给gateserver分配处理
'''
dd = GlobalObject().remote['gate'].callRemote("forwarding", keyname,
_conn.transport.sessionno,
data)
return dd
# -*- coding:utf-8 -*-
"""
"""
from app.game.component.Component import Component
from app.game.redis_mode import tb_character_info
import time
from shared.db_opear.configs_data import game_configs
from app.game.core.activity import get_act_info
from shared.common_logic.activity import do_get_act_open_info
from gfirefly.server.logobj import logger
from shared.utils.date_util import get_current_timestamp, days_to_current
from app.proto_file import activity_pb2
from gfirefly.server.globalobject import GlobalObject
remote_gate = GlobalObject().remote.get('gate')
WIN_MINE_QUALITY = 1
MIX_RUNT_QUALITY = 1
A_OR_B_TREASURE_QUALITY = 1
A_TREASURE_QUALITY = 1
B_TREASURE_QUALITY = 1
TREASURE_QUALITY = 1
TREASURE_TYPE = 2
class CharacterActComponent(Component):
"""CharacterActComponent"""
def __init__(self, owner):
super(CharacterActComponent, self).__init__(owner)
self._received_ids = {} # {type:[act_ids]}
# -*- coding:utf-8 -*-
"""
created by server on 14-7-7下午7:05.
"""
from gfirefly.server.globalobject import GlobalObject
from gfirefly.distributed.node import RemoteObject
GlobalObject().remote['gate'] = RemoteObject('gate')
# -*- coding:utf-8 -*-
"""
created by server on 14-6-19下午7:49.
"""
from gfirefly.server.globalobject import GlobalObject
from gfirefly.utils.services import CommandService
from gfirefly.server.logobj import logger
from app.game.core.PlayersManager import PlayersManager
import traceback
import time
from shared.utils.exception import AuthError
remote_gate = GlobalObject().remote.get('gate')
class GameCommandService(CommandService):
def callTarget(self, targetKey, *args, **kw):
target = self.getTarget(targetKey)
if not target:
print 'targetKey', targetKey
logger.error('command %s not Found on service' % str(targetKey))
return None
# if targetKey not in self.unDisplay:
# logger.info("call method %s on service[%s]" %
# (target.__name__, self._name))
t = time.time()
dynamic_id = args[0]
_player = PlayersManager().get_player_by_dynamic_id(dynamic_id)
try:
#logger.debug('key and dynamic_id,%s,%s', dynamic_id, targetKey)
# -*- coding:utf-8 -*-
"""
created by sphinx on
"""
import json
import uuid
from flask import request
from app.login.model import manager
from gfirefly.server.globalobject import webserviceHandle
from gfirefly.server.logobj import logger
from gfirefly.server.globalobject import GlobalObject
from geventhttpclient import HTTPClient
from geventhttpclient.url import URL
SERVERS_MA_WEBPORT = GlobalObject().allconfig['servers']['MA']['webport']
SERVER_MA_URL = GlobalObject().json_config['MA_url']
@webserviceHandle('/login')
def ma_server_login():
""" account login """
logger.debug('server_login======================')
verify_passport = request.args.get('passport')
result = eval(__login(verify_passport))
if result.get('result') is False:
return json.dumps(dict(result=False))
game_passport = uuid.uuid1().get_hex()
manager.account_cache[game_passport] = verify_passport
import netapp
import gatenodeapp
from gfirefly.server.globalobject import GlobalObject
from gfirefly.netconnect.datapack import DataPackProtoc
def conn_made(conn):
'''当连接建立时调用的方法'''
if not GlobalObject().netfactory.connmanager.hasConnection(conn.transport.sessionno):
queue_num = GlobalObject().netfactory.connmanager.queue_num
GlobalObject().netfactory.pushObject(1326, str(queue_num), [conn.transport.sessionno])
return
def conn_lost(conn):
dynamic_id = conn.transport.sessionno
if dynamic_id != 0:
GlobalObject().remote['gate'].net_conn_lost_remote_noresult(dynamic_id)
# pop queue conn to normal conn, when conn lost
conn = GlobalObject().netfactory.connmanager.pop_queue()
if conn:
GlobalObject().netfactory.pushObject(1326, str(0), [conn.instance.transport.sessionno])
GlobalObject().netfactory.doConnectionLost = conn_lost
GlobalObject().netfactory.doConnectionMade = conn_made
dataprotocl = DataPackProtoc(0, 0, 0, 0, 0, 0)
GlobalObject().netfactory.setDataProtocl(dataprotocl)
def conn_made(conn):
'''当连接建立时调用的方法'''
if not GlobalObject().netfactory.connmanager.hasConnection(conn.transport.sessionno):
queue_num = GlobalObject().netfactory.connmanager.queue_num
GlobalObject().netfactory.pushObject(1326, str(queue_num), [conn.transport.sessionno])
return
def get_act_id_from_world_remote():
world_remote = GlobalObject().remote['world']
return world_remote.get_act_id_remote()
#coding:utf8
import action
from gfirefly.server.logobj import logger
from gtwisted.core import reactor
from gfirefly.server.globalobject import GlobalObject
from shared.utils.ranking import Ranking
front_ip = GlobalObject().json_config['front_ip']
front_port = GlobalObject().json_config['front_port']
name = GlobalObject().json_config['name']
def tick():
result = GlobalObject().remote['login'].server_sync_remote(
name, front_ip, front_port, 'recommend')
if result is False:
reactor.callLater(1, tick)
else:
reactor.callLater(60, tick)
reactor.callLater(1, tick)
# 初始化工会排行
Ranking.init('GuildLevel', 9999)
import uuid
from flask import request
from app.login.model import manager
from gfirefly.server.globalobject import webserviceHandle
from gfirefly.server.logobj import logger
from gfirefly.server.globalobject import GlobalObject
from sdk.api.xiaomi.XMHttpClient import XMHttpClient
from sdk.api.xiaomi.XMUtils import XMUtils
host = 'msdk.qq.com'
pay_host = ('10.142.22.11', 8080)
buy_goods_host = ('10.142.22.11', 8080)
valid_host = ('10.130.2.233', 80)
AppId = GlobalObject().allconfig["xmsdk"]["AppId"]
AppKey = GlobalObject().allconfig["xmsdk"]["AppKey"]
AppSecret = GlobalObject().allconfig["xmsdk"]["AppSecret"]
VerifySession_URL = GlobalObject().allconfig["xmsdk"]["VerifySession_URL"]
# print(AppId, AppKey, AppSecret, VerifySession_URL)
@webserviceHandle('/login_xiaomi')
def server_login():
""" account login """
logger.info("server_login login in.")
uid = request.args.get('uid')
session = request.args.get('session')
logger.debug("uid, session, %s %s" % (uid, session))
result = eval(__login(uid, session))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
root to node.
"""
from gfirefly.server.globalobject import GlobalObject
from gfirefly.server.globalobject import rootserviceHandle
childsmanager = GlobalObject().root.childsmanager
class LimitHeroObj():
act_id = 0
limit_hero_obj = LimitHeroObj()
def push_all_object_message(topic_id, msg):
"""
向所有node节点（全服gate）推送消息。
"""
for child in childsmanager.childs.values():
child.push_all_object_remote(topic_id, msg)
return True
@rootserviceHandle
def get_act_id_remote():
"""
向随便一个gate节点 推送消息。
def pull_message_remote(character_id):
transit_remote = GlobalObject().remote['transit']
return transit_remote.pull_message_remote(character_id)
def config(self,
config,
servername=None,
dbconfig=None,
memconfig=None,
masterconf=None):
'''配置服务器
'''
GlobalObject().json_config = config
GlobalObject().remote_connect = self.remote_connect
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 netport:
self.netfactory = LiberateFactory()
netservice = services.CommandService("netservice")
self.netfactory.addServiceChannel(netservice)
reactor.listenTCP(netport, self.netfactory)
if webport:
self.webroot = Flask("servername")
GlobalObject().webroot = self.webroot
reactor.listenWSGI(webport, 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)
if hasdb and dbconfig:
if dbconfig.has_key("user") and dbconfig.has_key(
"host") and dbconfig.has_key("host"):
dbpool.initPool({"default": dbconfig})
else:
dbpool.initPool(dbconfig)
if hasmem and memconfig:
urls = memconfig.get('urls')
# hostname = str(memconfig.get('hostname'))
memcached_connect(urls)
from gfirefly.dbentrust.util import M2DB_PORT, M2DB_HOST, ToDBAddress
ToDBAddress().setToDBHost(memconfig.get("pubhost", M2DB_HOST))
ToDBAddress().setToDBPort(memconfig.get("pubport", M2DB_PORT))
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])
if masterconf:
masterport = masterconf.get('rootport')
masterhost = masterconf.get('roothost')
self.master_remote = RemoteObject(servername)
GlobalObject().masterremote = self.master_remote
import admin
addr = ('localhost',
masterport) if not masterhost else (masterhost, masterport)
self.master_remote.connect(addr)
"host": child_host,
"root_list": root_list
}
# 通知有需要连的node节点连接到此root节点
for servername, remote_list in GlobalObject().remote_map.items():
remote_host = remote_list.get("host", "")
remote_name_host = remote_list.get("root_list", "")
if name in remote_name_host:
child_name = GlobalObject().root.childsmanager.child(servername)
child_name.callbackChild("remote_connect", name, remote_host)
# 查看当前是否有可供连接的root节点
master_node_list = GlobalObject().remote_map.keys()
for root_name in root_list:
if root_name in master_node_list:
root_host = GlobalObject().remote_map[root_name]['host']
child_name = GlobalObject().root.childsmanager.child(name)
child_name.callbackChild("remote_connect", root_name, root_host)
def _doChildLostConnect(childId):
"""
"""
try:
del GlobalObject().remote_map[childId]
except Exception, e:
logger.info(str(e))
GlobalObject().root.doChildConnect = _doChildConnect
GlobalObject().root.doChildLostConnect = _doChildLostConnect
config = None
if len(args) > 2:
servername = args[1]
config = json.load(open(args[2], 'r'))
else:
raise ValueError
dbconf = config.get('db')
memconf = config.get('memcached')
redis_conf = config.get('redis')
sersconf = config.get('servers', {})
masterconf = config.get('master', {})
msdkconf = config.get('msdk', {})
mconfig = json.load(open('models.json', 'r'))
model_default_config = mconfig.get('model_default', {})
model_config = mconfig.get('models', {})
GlobalObject().allconfig = config
serconfig = sersconf.get(servername)
ser = FFServer()
ser.config(serconfig,
servername=servername,
dbconfig=dbconf,
memconfig=memconf,
redis_config=redis_conf,
masterconf=masterconf,
model_default_config=model_default_config,
model_config=model_config,
msdk_config=msdkconf)
ser.start()
#coding:utf8
from gfirefly.server.globalobject import GlobalObject
from gfirefly.server.logobj import log
#导入逻辑接口
import common_api
import root_api
def doConnectionMade(conn):
'''当连接建立时调用的方法'''
print 'do some thing. 1111111'
def doConnectionLost(conn):
'''当连接断开时调用的方法'''
print 'do some thing. 2222222'
GlobalObject().wsapp.doConnectionMade = doConnectionMade #将自定义的登陆后执行的方法绑定到框架
GlobalObject().wsapp.doConnectionLost = doConnectionLost #将自定义的下线后执行的方法绑定到框架
log.msg("net_node api: %s" % GlobalObject().wsapp.service._targets.keys())
import re
import time
from app.game.core.PlayersManager import PlayersManager
from app.game.core.guild import Guild
from app.proto_file.guild_pb2 import *
from app.game.redis_mode import tb_guild_info, tb_guild_name
from app.game.redis_mode import tb_character_guild
from app.game.redis_mode import tb_character_info
from gfirefly.server.logobj import logger
from gfirefly.server.globalobject import remoteserviceHandle
from gfirefly.server.globalobject import GlobalObject
from shared.db_opear.configs_data.game_configs import guild_config
from shared.db_opear.configs_data.game_configs import base_config
from shared.utils import trie_tree
remote_gate = GlobalObject().remote['gate']
@remoteserviceHandle('gate')
def create_guild_801(data, player):
"""创建公会 """
args = CreateGuildRequest()
args.ParseFromString(data)
g_name = args.name
response = GuildCommonResponse()
p_id = player.base_info.id
g_id = player.guild.g_id
if base_config.get('create_level') > player.level.level:
response.result = False
response.message = "等级不够"
def remote_connect(rname, rhost):
"""供master调用的接口：进行远程的rpc连接
"""
GlobalObject().remote_connect(rname, rhost)
def get_remote_gate():
"""docstring for get_remote_gate"""
return GlobalObject().child('gate')
# coding:utf8
"""
Created on 2013-8-14
@author: lan (www.9miao.com)
"""
from gfirefly.server.globalobject import GlobalObject
from gfirefly.utils.services import CommandService
# from gfirefly.server.logobj import logger
class NetCommandService(CommandService):
def callTarget(self, targetKey, *args, **kw):
_conn = args[0]
data = args[1]
if targetKey == 100002:
return data
dynamic_id = _conn.transport.sessionno
if not GlobalObject().netfactory.connmanager.hasConnection(dynamic_id):
return
result = remote_gate.forwarding_remote(targetKey,
_conn.transport.sessionno, data)
return result
remote_gate = GlobalObject().remote['gate']
netservice = NetCommandService("NetService")
GlobalObject().netfactory.addServiceChannel(netservice)
# coding:utf8
"""
created by sphinx on
"""
from gfirefly.server.globalobject import rootserviceHandle, GlobalObject
from app.transit.root.messagecache import message_cache
from gfirefly.server.logobj import logger
groot = GlobalObject().root
@rootserviceHandle
def push_message_remote(key, character_id, *args):
logger.debug("message.push_message_remote")
logger.debug(args)
childs = groot.childsmanager.childs
for child in childs.values():
if 'gate' in child.name:
result = child.pull_message_remote(key, character_id, *args)
if type(result) is bool and result:
return
message_cache.cache(key, character_id, *args)
return True
@rootserviceHandle
def push_message_maintime_remote(key, character_id, maintain_time, *args):
logger.debug("message.push_message_maintime_remote")
logger.debug(args)
childs = groot.childsmanager.childs
def push_message_remote(key, character_id, *args):
transit_remote = GlobalObject().remote['transit']
return transit_remote.push_message_remote(key, character_id, *args)
