def __migrate_accounts_registered(self):
try:
yield redis.delete( DICT_ACCOUNT_REGISTERED )
yield redis.delete( DICT_NICKNAME_REGISTERED )
yield redis.delete( SET_CID_REGISTERED )
db_conf = {'host': DB['host'],
'port' : DB['port'],
'user' : DB['user'],
'passwd' : DB['pass'],
'db' : DB['db_userdb'],
'charset' : 'utf8'
}
conn = MySQLdb.connect(**db_conf)
cu = conn.cursor()
cu.execute('SELECT `account`,`nick_name`,`id`,`sid` FROM tb_character')
_dataset = cu.fetchall()
for _account_name, _nick_name, _id, _sid in _dataset:
yield redis.hset(DICT_ACCOUNT_REGISTERED, '%s%s'%(_account_name,_sid), _id)
yield redis.hset(DICT_NICKNAME_REGISTERED, _nick_name, _id)
yield redis.sadd(SET_CID_REGISTERED, _id)
cu.close()
conn.close()
conn = None
cu = None
except Exception, e:
reactor.callLater(1, self.__migrate_accounts_registered)
print 'ERROR:', e
print 'WARNING. Redis connection fail, callLater 1 second. redis:', redis
def check_excite_activity(activity_id, deleted=False):
''' 检查精彩活动中是否有定时活动并定时开启, 活动结束后定时把未领奖励发到领奖中心
@param: deleted-True:清除旧数据, False:不清除
'''
global PAY_ACTIVITY_AWARD_TIME, CONSUME_ACTIVITY_AWARD_TIME, GROUP_BUY_AWARD_TIME
_redis_key = None
_award_center_type = AWARD_TYPE_UNKNOWN
if activity_id == EXCITE_PAY_ACTIVITY:
_redis_key = HASH_PAY_ACTIVITY
_award_center_type = AWARD_TYPE_PAY_ACTIVITY
PAY_ACTIVITY_AWARD_TIME = int(time())
elif activity_id == EXCITE_CONSUME_ACTIVITY:
_redis_key = HASH_CONSUME_ACTIVITY
_award_center_type = AWARD_TYPE_CONSUME_ACTIVITY
CONSUME_ACTIVITY_AWARD_TIME = int(time())
elif activity_id == EXCITE_PAY_CREDITS_BACK:
_redis_key = HASH_PAY_CREDITS_BACK
elif activity_id == EXCITE_GROUP_BUY:
_redis_key = DICT_GROUP_BUY_PERSON_INFO
GROUP_BUY_AWARD_TIME = int(time())
_award_center_type = AWARD_TYPE_GROUP_BUY
if not _redis_key:
defer.returnValue( None )
_all_excite_conf = get_excite_activity_conf()
for _excite_conf in _all_excite_conf.itervalues():
if _excite_conf['ActivityID'] == activity_id:
break
else:
yield redis.delete( _redis_key )
defer.returnValue( None )
# 每次OSS同步会删除旧的数据, 策划要求
if deleted:
yield redis.delete( _redis_key )
# 定时发放奖励 针对活动结束时需要发放奖励的活动
if activity_id == EXCITE_PAY_ACTIVITY:
interval_seconds = datetime2time( _excite_conf['CloseTime'] )- PAY_ACTIVITY_AWARD_TIME
log.warn('excite activity would award to award center after {0} seconds, activity_id: {1}.'.format( interval_seconds, activity_id ))
if interval_seconds <= 0:
defer.returnValue( None )
reactor.callLater( interval_seconds, grant_excite_activity_award, activity_id, _redis_key, _award_center_type, PAY_ACTIVITY_AWARD_TIME )
elif activity_id == EXCITE_CONSUME_ACTIVITY:
interval_seconds = datetime2time( _excite_conf['CloseTime'] )- CONSUME_ACTIVITY_AWARD_TIME
log.warn('excite activity would award to award center after {0} seconds, activity_id: {1}.'.format( interval_seconds, activity_id ))
if interval_seconds <= 0:
defer.returnValue( None )
reactor.callLater( interval_seconds, grant_excite_activity_award, activity_id, _redis_key, _award_center_type, CONSUME_ACTIVITY_AWARD_TIME )
elif activity_id == EXCITE_GROUP_BUY:
interval_seconds = datetime2time( _excite_conf['CloseTime'] )- GROUP_BUY_AWARD_TIME
log.warn('excite activity would award to award center after {0} seconds, activity_id: {1}.'.format( interval_seconds, activity_id ))
if interval_seconds <= 0:
defer.returnValue( None )
reactor.callLater( interval_seconds, grant_group_buy_award, activity_id, _redis_key, _award_center_type, GROUP_BUY_AWARD_TIME )
defer.returnValue( None )
def reset_joust_data(self):
''' 重置大乱斗的数据 '''
yield redis.delete(SET_JOUST_LAST_CID_SCORE)
#_cid_scores = yield redis.zrange( SET_JOUST_CID_SCORE, 0, 9, withscores=True )
#for _cid, _score in _cid_scores:
# yield redis.zadd( SET_JOUST_LAST_CID_SCORE, _cid, _score )
yield redis.rename(SET_JOUST_CID_SCORE, SET_JOUST_LAST_CID_SCORE)
yield redis.delete(HASH_JOUST_ENEMY_INFO)
defer.returnValue(NO_ERROR)
def check_limit_fellow(deleted=False):
''' 开服期间的限时神将活动
@param: deleted-True:清除旧数据, False:不清除
'''
global ACTIVITY_AWARD_TIME
_all_excite_conf = get_excite_activity_conf()
for _excite_conf in _all_excite_conf.itervalues():
if _excite_conf['ActivityID'] == EXCITE_LIMIT_FELLOW:
break
else:
yield redis.delete(HASH_LIMIT_FELLOW_SHRINE,
SET_LIMIT_FELLOW_NAME_SCORE)
defer.returnValue(None)
# 限时神将 每次OSS同步会删除旧的数据
if deleted:
yield redis.delete(HASH_LIMIT_FELLOW_SHRINE,
SET_LIMIT_FELLOW_NAME_SCORE)
# 限时神将中开启的活动配置
_activity = get_limit_fellow_conf()
if not _activity:
yield redis.delete(HASH_LIMIT_FELLOW_SHRINE,
SET_LIMIT_FELLOW_NAME_SCORE)
defer.returnValue(None)
_activity_id = _activity['ActivityID']
# 限时神将 活动的奖励
_award_conf = get_limit_fellow_award_conf(_activity_id)
if not _award_conf:
yield redis.delete(HASH_LIMIT_FELLOW_SHRINE,
SET_LIMIT_FELLOW_NAME_SCORE)
defer.returnValue(None)
# 定时
all_ranks = _award_conf.keys()
ACTIVITY_AWARD_TIME = int(time())
interval_seconds = datetime2time(
_excite_conf['CloseTime']) - ACTIVITY_AWARD_TIME
if interval_seconds <= 0:
defer.returnValue(None)
log.warn(
'limit fellow would award to award center after {0} seconds, _activity_id: {1}, ACTIVITY_AWARD_TIME: {2}.'
.format(interval_seconds, _activity_id, ACTIVITY_AWARD_TIME))
reactor.callLater(interval_seconds, grant_limit_fellow_award, all_ranks,
_activity_id, ACTIVITY_AWARD_TIME)
defer.returnValue(None)
def grant_limit_fellow_award(all_ranks, activity_id, timestamp):
'''
@param: timestamp-借用时间戳作为callLater的有效性验证
'''
log.warn('limit fellow award. activity_id: {0}, timestamp: {1}, ACTIVITY_AWARD_TIME: {2}.'.format( activity_id, timestamp, ACTIVITY_AWARD_TIME ))
# 判断是否是正确的callLater
if ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue( None )
_max_rank = max(all_ranks)
if _max_rank > 0:
_rank = 1
_name_scores = yield redis.zrevrange( SET_LIMIT_FELLOW_NAME_SCORE, 0, _max_rank, withscores=True )
for _nick_name, _score in _name_scores:
if _score <= 0:
continue
_cid = yield redis.hget(DICT_NICKNAME_REGISTERED, str(_nick_name))
if _cid:
yield g_AwardCenterMgr.new_award( _cid, AWARD_TYPE_LIMIT_FELLOW_RANK, [int(time()), activity_id, _rank] )
_rank += 1
if 0 in all_ranks:
_names = yield redis.zrangebyscore( SET_LIMIT_FELLOW_NAME_SCORE, 60, '+inf' )
for _name in _names:
_cid = yield redis.hget(DICT_NICKNAME_REGISTERED, str(_name))
if _cid:
yield g_AwardCenterMgr.new_award( _cid, AWARD_TYPE_LIMIT_FELLOW_SCORE, [int(time()), activity_id, 0] )
yield redis.delete( HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE )
def __migrate_accounts_registered(self):
try:
yield redis.delete(HASH_NICKNAME_REGISTERED, HASH_MACHINE_CODE_REGISTERED, HASH_UID_MACHINE_CODE, SET_RANK_PVP_WEIGHT)
db_conf = {'host': setting.DB_CONF['host'],
'port' : setting.DB_CONF['port'],
'user' : setting.DB_CONF['user'],
'passwd' : setting.DB_CONF['pass'],
'db' : setting.DB_CONF['userdb'],
'charset' : 'utf8'
}
conn = MySQLdb.connect(**db_conf)
cu = conn.cursor()
cu.execute('SELECT `id`,`machine_code`,`nickname`,`max_weight` FROM tb_character')
_dataset = cu.fetchall()
for _id, _machine_code, _nickname, _max_weight in _dataset:
yield redis.hset(HASH_NICKNAME_REGISTERED, _nickname, _id)
yield redis.hset(HASH_MACHINE_CODE_REGISTERED, _machine_code, _id)
yield redis.hset(HASH_UID_MACHINE_CODE, _id, _machine_code)
yield redis.zadd(SET_RANK_PVP_WEIGHT, _id, -_max_weight)
cu.close()
conn.close()
conn = None
cu = None
except Exception, e:
reactor.callLater(1, self.__migrate_accounts_registered)
print 'ERROR:', e
print 'WARNING. Redis connection fail, callLater 1 second. redis:', redis
def grant_group_buy_award(activity_id,
redis_key,
award_center_type,
timestamp=0):
log.warn(
'excite activity award. activity_id: {0}, timestamp: {1}, GROUP_BUY_AWRAD_TIME: {2}.'
.format(activity_id, timestamp, GROUP_BUY_AWARD_TIME))
_field = None
_award_conf = None
if GROUP_BUY_AWARD_TIME != timestamp:
defer.returnValue(None)
if activity_id != EXCITE_GROUP_BUY:
defer.returnValue(None)
_all_data = yield redis.hgetall(redis_key)
if not _all_data:
defer.returnValue(None)
_group_buy_info = yield redis.hgetall(DICT_GROUP_BUY_INFO)
_wlist = list(set(get_group_buy_count())) #buy_num level
_gdict = dict()
#save group_buy activity buy_num
for k, v in _group_buy_info.iteritems():
_gdict[k] = loads(v)
for _cid, _data in _all_data.iteritems():
_data = loads(_data)
_args_list = []
for _index, (_count, _status) in enumerate(_data):
if _count <= 0:
break
_award_ids = []
for dex, i in enumerate(_status):
if i == 1 or dex in _award_ids:
continue
if _gdict[_index + 1] >= _wlist[_index] and i == 0:
_args_list.append([_index + 1, _wlist[_index + 1]])
_award_ids.append(dex)
if len(_args_list) >= 1:
yield g_AwardCenterMgr.new_award(
_cid, award_center_type,
[int(time()), activity_id, _args_list])
yield redis.delete(redis_key)
yield redis.delete(DICT_GROUP_BUY_INFO)
def check_limit_fellow(deleted=False):
''' 开服期间的限时神将活动
@param: deleted-True:清除旧数据, False:不清除
'''
global ACTIVITY_AWARD_TIME
_all_excite_conf = get_excite_activity_conf()
for _excite_conf in _all_excite_conf.itervalues():
if _excite_conf['ActivityID'] == EXCITE_LIMIT_FELLOW:
break
else:
yield redis.delete( HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE )
defer.returnValue( None )
# 限时神将 每次OSS同步会删除旧的数据
if deleted:
yield redis.delete( HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE )
# 限时神将中开启的活动配置
_activity = get_limit_fellow_conf()
if not _activity:
yield redis.delete( HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE )
defer.returnValue( None )
_activity_id = _activity['ActivityID']
# 限时神将 活动的奖励
_award_conf = get_limit_fellow_award_conf( _activity_id )
if not _award_conf:
yield redis.delete( HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE )
defer.returnValue( None )
# 定时
all_ranks = _award_conf.keys()
ACTIVITY_AWARD_TIME = int(time())
interval_seconds = datetime2time( _excite_conf['CloseTime'] ) - ACTIVITY_AWARD_TIME
if interval_seconds <= 0:
defer.returnValue( None )
log.warn('limit fellow would award to award center after {0} seconds, _activity_id: {1}, ACTIVITY_AWARD_TIME: {2}.'.format( interval_seconds, _activity_id, ACTIVITY_AWARD_TIME ))
reactor.callLater( interval_seconds, grant_limit_fellow_award, all_ranks, _activity_id, ACTIVITY_AWARD_TIME )
defer.returnValue( None )
def grant_group_buy_award(activity_id, redis_key, award_center_type, timestamp=0):
log.warn('excite activity award. activity_id: {0}, timestamp: {1}, GROUP_BUY_AWRAD_TIME: {2}.'.format( activity_id, timestamp,
GROUP_BUY_AWARD_TIME))
_field = None
_award_conf = None
if GROUP_BUY_AWARD_TIME != timestamp:
defer.returnValue( None )
if activity_id != EXCITE_GROUP_BUY:
defer.returnValue( None )
_all_data = yield redis.hgetall( redis_key )
if not _all_data:
defer.returnValue( None )
_group_buy_info = yield redis.hgetall( DICT_GROUP_BUY_INFO )
_wlist = list(set(get_group_buy_count())) #buy_num level
_gdict = dict()
#save group_buy activity buy_num
for k, v in _group_buy_info.iteritems():
_gdict[k] = loads(v)
for _cid, _data in _all_data.iteritems():
_data = loads(_data)
_args_list = []
for _index, (_count, _status) in enumerate(_data):
if _count <= 0:
break
_award_ids = []
for dex, i in enumerate(_status):
if i == 1 or dex in _award_ids:
continue
if _gdict[_index+1] >= _wlist[_index] and i == 0:
_args_list.append([_index+1, _wlist[_index+1]])
_award_ids.append(dex)
if len(_args_list) >= 1:
yield g_AwardCenterMgr.new_award( _cid, award_center_type, [int(time()), activity_id, _args_list] )
yield redis.delete( redis_key )
yield redis.delete( DICT_GROUP_BUY_INFO )
def grant_excite_activity_award(activity_id,
redis_key,
award_center_type,
timestamp=0):
''' 精彩活动结束时 定时发放未领的奖励到领奖中心
@param: activity_id-精彩活动ID
@param: redis_key-精彩活动对应的redis_key
@param: award_center_type-领奖中心奖励类型
@param: timestamp-借用时间戳作为callLater的有效性验证
'''
log.warn(
'excite activity award. activity_id: {0}, timestamp: {1}, ACTIVITY_AWARD_TIME: {2}.'
.format(activity_id, timestamp,
(PAY_ACTIVITY_AWARD_TIME, CONSUME_ACTIVITY_AWARD_TIME)))
_field = None
_award_conf = None
# 判断是否是正确的callLater
if activity_id == EXCITE_PAY_ACTIVITY:
_field = 'TotalPay'
_award_conf = get_pay_activity_conf()
if PAY_ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue(None)
elif activity_id == EXCITE_CONSUME_ACTIVITY:
_field = 'TotalConsume'
_award_conf = get_consume_activity_conf()
if CONSUME_ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue(None)
if not _award_conf:
defer.returnValue(None)
_all_data = yield redis.hgetall(redis_key)
if not _all_data:
defer.returnValue(None)
# 进领奖中心
for _cid, _data in _all_data.iteritems():
_data = loads(_data)
_award_ids = []
for _award in _award_conf.itervalues():
if _award['ID'] in _data[0] or _award['ID'] in _award_ids:
continue
if _award[_field] <= _data[1]:
_award_ids.append(_award['ID'])
yield g_AwardCenterMgr.new_award(
_cid, award_center_type,
[int(time()), activity_id, _award['ID']])
# 删除旧的活动数据
yield redis.delete(redis_key)
def gm_sync_broadcast_msgs(cmd, ts, args, sign):
res_err = {'result': 1}
msgs_data = {}
for _msg in args:
msgs_data[_msg['id']] = _msg['content']
yield redis.delete( HASH_OSS_MESSAGES )
if msgs_data:
yield redis.hset( HASH_OSS_MESSAGES, FIELD_BROADCAST, marshal.dumps(msgs_data.values()) )
# 更新内存数据
sync_broadcast_messages( msgs_data.values() )
defer.returnValue( res_err )
def __migrate_accounts_registered(self):
try:
yield redis.delete(DICT_ACCOUNT_REGISTERED)
yield redis.delete(DICT_NICKNAME_REGISTERED)
yield redis.delete(SET_CID_REGISTERED)
db_conf = {
'host': DB['host'],
'port': DB['port'],
'user': DB['user'],
'passwd': DB['pass'],
'db': DB['db_userdb'],
'charset': 'utf8'
}
conn = MySQLdb.connect(**db_conf)
cu = conn.cursor()
cu.execute(
'SELECT `account`,`nick_name`,`id`,`sid` FROM tb_character')
_dataset = cu.fetchall()
for _account_name, _nick_name, _id, _sid in _dataset:
yield redis.hset(DICT_ACCOUNT_REGISTERED,
'%s%s' % (_account_name, _sid), _id)
yield redis.hset(DICT_NICKNAME_REGISTERED, _nick_name, _id)
yield redis.sadd(SET_CID_REGISTERED, _id)
cu.close()
conn.close()
conn = None
cu = None
except Exception, e:
reactor.callLater(1, self.__migrate_accounts_registered)
print 'ERROR:', e
print 'WARNING. Redis connection fail, callLater 1 second. redis:', redis
def gm_sync_broadcast_msgs(cmd, ts, args, sign):
res_err = {'result': 1}
msgs_data = {}
for _msg in args:
msgs_data[_msg['id']] = _msg['content']
yield redis.delete(HASH_OSS_MESSAGES)
if msgs_data:
yield redis.hset(HASH_OSS_MESSAGES, FIELD_BROADCAST,
marshal.dumps(msgs_data.values()))
# 更新内存数据
sync_broadcast_messages(msgs_data.values())
defer.returnValue(res_err)
def grant_excite_activity_award(activity_id, redis_key, award_center_type, timestamp=0):
''' 精彩活动结束时 定时发放未领的奖励到领奖中心
@param: activity_id-精彩活动ID
@param: redis_key-精彩活动对应的redis_key
@param: award_center_type-领奖中心奖励类型
@param: timestamp-借用时间戳作为callLater的有效性验证
'''
log.warn('excite activity award. activity_id: {0}, timestamp: {1}, ACTIVITY_AWARD_TIME: {2}.'.format( activity_id, timestamp, (PAY_ACTIVITY_AWARD_TIME,CONSUME_ACTIVITY_AWARD_TIME) ))
_field = None
_award_conf = None
# 判断是否是正确的callLater
if activity_id == EXCITE_PAY_ACTIVITY:
_field = 'TotalPay'
_award_conf = get_pay_activity_conf()
if PAY_ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue( None )
elif activity_id == EXCITE_CONSUME_ACTIVITY:
_field = 'TotalConsume'
_award_conf = get_consume_activity_conf()
if CONSUME_ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue( None )
if not _award_conf:
defer.returnValue( None )
_all_data = yield redis.hgetall( redis_key )
if not _all_data:
defer.returnValue( None )
# 进领奖中心
for _cid, _data in _all_data.iteritems():
_data = loads(_data)
_award_ids = []
for _award in _award_conf.itervalues():
if _award['ID'] in _data[0] or _award['ID'] in _award_ids:
continue
if _award[_field] <= _data[1]:
_award_ids.append( _award['ID'] )
yield g_AwardCenterMgr.new_award( _cid, award_center_type, [int(time()), activity_id, _award['ID']] )
# 删除旧的活动数据
yield redis.delete( redis_key )
def refresh_group_by_oss(self, dict_group_config):
res = 1
try:
self.groups_sorted = []
yield redis.delete(LIST_TIME_LIMITED_GROUP)
for _group_id, dict_config in dict_group_config.iteritems():
_group_id = int(_group_id)
_begin_t, _end_t = str2timestamp(dict_config['begin_time']), str2timestamp(dict_config['end_time'])
_group = ItemGroup(_group_id, _begin_t, _end_t)
insort_right(self.groups_sorted, _group)
yield redis.lpush(LIST_TIME_LIMITED_GROUP, dumps((_group_id, _begin_t, _end_t)))
yield self.load_by_group()
except:
log.exception('dict_group_config:{0}'.format(dict_group_config))
res = OSS_TIME_LIMITED_SHOP_GROUP_EXCEPTION
defer.returnValue( res )
def grant_limit_fellow_award(all_ranks, activity_id, timestamp):
'''
@param: timestamp-借用时间戳作为callLater的有效性验证
'''
log.warn(
'limit fellow award. activity_id: {0}, timestamp: {1}, ACTIVITY_AWARD_TIME: {2}.'
.format(activity_id, timestamp, ACTIVITY_AWARD_TIME))
# 判断是否是正确的callLater
if ACTIVITY_AWARD_TIME != timestamp:
defer.returnValue(None)
_max_rank = max(all_ranks)
if _max_rank > 0:
_rank = 1
_name_scores = yield redis.zrevrange(SET_LIMIT_FELLOW_NAME_SCORE,
0,
_max_rank,
withscores=True)
for _nick_name, _score in _name_scores:
if _score <= 0:
continue
_cid = yield redis.hget(DICT_NICKNAME_REGISTERED, str(_nick_name))
if _cid:
yield g_AwardCenterMgr.new_award(
_cid, AWARD_TYPE_LIMIT_FELLOW_RANK,
[int(time()), activity_id, _rank])
_rank += 1
if 0 in all_ranks:
_names = yield redis.zrangebyscore(SET_LIMIT_FELLOW_NAME_SCORE, 60,
'+inf')
for _name in _names:
_cid = yield redis.hget(DICT_NICKNAME_REGISTERED, str(_name))
if _cid:
yield g_AwardCenterMgr.new_award(
_cid, AWARD_TYPE_LIMIT_FELLOW_SCORE,
[int(time()), activity_id, 0])
yield redis.delete(HASH_LIMIT_FELLOW_SHRINE, SET_LIMIT_FELLOW_NAME_SCORE)
def __migrate_accounts_registered(self):
try:
yield redis.delete(HASH_NICKNAME_REGISTERED,
HASH_MACHINE_CODE_REGISTERED,
HASH_UID_MACHINE_CODE, SET_RANK_PVP_WEIGHT)
db_conf = {
'host': setting.DB_CONF['host'],
'port': setting.DB_CONF['port'],
'user': setting.DB_CONF['user'],
'passwd': setting.DB_CONF['pass'],
'db': setting.DB_CONF['userdb'],
'charset': 'utf8'
}
conn = MySQLdb.connect(**db_conf)
cu = conn.cursor()
cu.execute(
'SELECT `id`,`machine_code`,`nickname`,`max_weight` FROM tb_character'
)
_dataset = cu.fetchall()
for _id, _machine_code, _nickname, _max_weight in _dataset:
yield redis.hset(HASH_NICKNAME_REGISTERED, _nickname, _id)
yield redis.hset(HASH_MACHINE_CODE_REGISTERED, _machine_code,
_id)
yield redis.hset(HASH_UID_MACHINE_CODE, _id, _machine_code)
yield redis.zadd(SET_RANK_PVP_WEIGHT, _id, -_max_weight)
cu.close()
conn.close()
conn = None
cu = None
except Exception, e:
reactor.callLater(1, self.__migrate_accounts_registered)
print 'ERROR:', e
print 'WARNING. Redis connection fail, callLater 1 second. redis:', redis
def update(self):
try:
_isRunning = self.is_running()
if self._running and (not _isRunning or self.life <= 0): #end
self._running = False
self._finished = True
self.close()
log.info('world boss was gone... life:', self.life,
'duration:', self._duration)
elif not self._running and _isRunning: #Begin
self._level = get_current_level(self._level,
self._damage_total)
self._max_life = int(
get_worldboss_attribute(self._level)['Life'])
self._char_names_last = []
self._char_name_lastkill = ""
self._damage_total = 0
redis.delete(DICT_WORLDBOSS_ATTACKER_DATA)
redis.delete(DICT_WORLDBOSS_RANKER_DATA)
redis.delete(RANK_WORLDBOSS_DAMAGE)
AttackerData._cache = {}
self._cached_rank = []
self._running = True
self._finished = False
log.info('world boss is coming... life:', self.life,
'duration:', self._duration)
if self._running:
self.broadcast()
except:
log.exception()
reactor.callLater(1, self.update)
def update(self):
try:
_isRunning = self.is_running()
if self._running and (not _isRunning or self.life <= 0): #end
self._running = False
self._finished = True
self.close()
log.info('world boss was gone... life:', self.life, 'duration:', self._duration)
elif not self._running and _isRunning: #Begin
self._level = get_current_level(self._level, self._damage_total)
self._max_life = int(get_worldboss_attribute(self._level)['Life'])
self._char_names_last = []
self._char_name_lastkill = ""
self._damage_total = 0
redis.delete(DICT_WORLDBOSS_ATTACKER_DATA)
redis.delete(DICT_WORLDBOSS_RANKER_DATA)
redis.delete(RANK_WORLDBOSS_DAMAGE)
AttackerData._cache = {}
self._cached_rank = []
self._running = True
self._finished = False
log.info('world boss is coming... life:', self.life, 'duration:', self._duration)
if self._running:
self.broadcast()
except:
log.exception()
reactor.callLater(1, self.update)
def sync(self):
_v = [dumps(item) for item in self.item_list()]
if _v:
yield redis.delete(LIST_TIME_LIMITED_SHOP)
redis.lpush(LIST_TIME_LIMITED_SHOP, _v)
def check_excite_activity(activity_id, deleted=False):
''' 检查精彩活动中是否有定时活动并定时开启, 活动结束后定时把未领奖励发到领奖中心
@param: deleted-True:清除旧数据, False:不清除
'''
global PAY_ACTIVITY_AWARD_TIME, CONSUME_ACTIVITY_AWARD_TIME, GROUP_BUY_AWARD_TIME
_redis_key = None
_award_center_type = AWARD_TYPE_UNKNOWN
if activity_id == EXCITE_PAY_ACTIVITY:
_redis_key = HASH_PAY_ACTIVITY
_award_center_type = AWARD_TYPE_PAY_ACTIVITY
PAY_ACTIVITY_AWARD_TIME = int(time())
elif activity_id == EXCITE_CONSUME_ACTIVITY:
_redis_key = HASH_CONSUME_ACTIVITY
_award_center_type = AWARD_TYPE_CONSUME_ACTIVITY
CONSUME_ACTIVITY_AWARD_TIME = int(time())
elif activity_id == EXCITE_PAY_CREDITS_BACK:
_redis_key = HASH_PAY_CREDITS_BACK
elif activity_id == EXCITE_GROUP_BUY:
_redis_key = DICT_GROUP_BUY_PERSON_INFO
GROUP_BUY_AWARD_TIME = int(time())
_award_center_type = AWARD_TYPE_GROUP_BUY
if not _redis_key:
defer.returnValue(None)
_all_excite_conf = get_excite_activity_conf()
for _excite_conf in _all_excite_conf.itervalues():
if _excite_conf['ActivityID'] == activity_id:
break
else:
yield redis.delete(_redis_key)
defer.returnValue(None)
# 每次OSS同步会删除旧的数据, 策划要求
if deleted:
yield redis.delete(_redis_key)
# 定时发放奖励 针对活动结束时需要发放奖励的活动
if activity_id == EXCITE_PAY_ACTIVITY:
interval_seconds = datetime2time(
_excite_conf['CloseTime']) - PAY_ACTIVITY_AWARD_TIME
log.warn(
'excite activity would award to award center after {0} seconds, activity_id: {1}.'
.format(interval_seconds, activity_id))
if interval_seconds <= 0:
defer.returnValue(None)
reactor.callLater(interval_seconds, grant_excite_activity_award,
activity_id, _redis_key, _award_center_type,
PAY_ACTIVITY_AWARD_TIME)
elif activity_id == EXCITE_CONSUME_ACTIVITY:
interval_seconds = datetime2time(
_excite_conf['CloseTime']) - CONSUME_ACTIVITY_AWARD_TIME
log.warn(
'excite activity would award to award center after {0} seconds, activity_id: {1}.'
.format(interval_seconds, activity_id))
if interval_seconds <= 0:
defer.returnValue(None)
reactor.callLater(interval_seconds, grant_excite_activity_award,
activity_id, _redis_key, _award_center_type,
CONSUME_ACTIVITY_AWARD_TIME)
elif activity_id == EXCITE_GROUP_BUY:
interval_seconds = datetime2time(
_excite_conf['CloseTime']) - GROUP_BUY_AWARD_TIME
log.warn(
'excite activity would award to award center after {0} seconds, activity_id: {1}.'
.format(interval_seconds, activity_id))
if interval_seconds <= 0:
defer.returnValue(None)
reactor.callLater(interval_seconds, grant_group_buy_award, activity_id,
_redis_key, _award_center_type, GROUP_BUY_AWARD_TIME)
defer.returnValue(None)
def del_all_requests(self):
''' 删除公会所有的入会申请 '''
yield redis.delete( TPL_LIST_ALLIANCE_REQUEST % self.__id )
del_request_to_dict( self.__requests.values() )
