xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

redis：保存不同频道对应的sid；提取redisClient获取

Browse Source
This commit is contained in:
liangtongchuan
2021-03-05 16:30:38 +08:00
parent 1c5be8a155
commit d43fd51e9a
1 changed files with 57 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
game-server/app/services/redisService.ts
View File

@@ -14,7 +14,7 @@ import { comBtlRanges } from '../pubUtils/gamedata';
* 在服务重新启动时，将信息存入redis
*/
export async function initAllRank() {
const client: Redis.RedisClient = pinus.app.get('redis');
const client: Redis.RedisClient = redisClient();
const serverList = await GameModel.getAllServerList();
await client.delAsync(REDIS_KEY.ONLINE_USERS);
await client.delAsync(REDIS_KEY.USER_INFO);
@@ -35,7 +35,7 @@ export async function initAllRank() {
*/
export async function initRank(serverId: number) {
// console.log('*****', 'initRank')
const client: Redis.RedisClient = pinus.app.get('redis');
const client: Redis.RedisClient = redisClient();
await client.expireAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), 30 * 24 * 60 * 60);
await client.expireAsync(REDIS_KEY.PVP_RANK, 30 * 24 * 60 * 60);
await client.expireAsync(REDIS_KEY.USER_INFO, 30 * 24 * 60 * 60);
@@ -64,9 +64,8 @@ export async function initSingleRank(key: string) {
*/
export async function initSingleRankWithServer(key: string, serverId: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(getKeyName(key, serverId));
await client.expireAsync(key, 30 * 24 * 60 * 60);
await redisClient().delAsync(getKeyName(key, serverId));
await redisClient().expireAsync(key, 30 * 24 * 60 * 60);
await setRankRedisFromDb(key, serverId);
}
@@ -76,12 +75,11 @@ export async function initSingleRankWithServer(key: string, serverId: number) {
* @param serverId 分服
*/
async function setRankRedisFromDb(type: string, serverId: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
if(type == REDIS_KEY.TOWER_RANK) {
let ranks = await RoleModel.getRank('tower', serverId, ['roleId', 'roleName', 'towerLv', 'lv', 'vLv', 'headHid', 'sHid', 'title', 'updatedAt']);
for(let {towerLv, roleId, roleName, lv, vLv, towerUpTime, headHid, sHid, title} of ranks) {
// console.log(roleId);
await client.zaddAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
await redisClient().zaddAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
}
@@ -90,7 +88,7 @@ async function setRankRedisFromDb(type: string, serverId: number) {
for(let { code, icon, name, lv, leader, activeWeekly = 0, activeUpdateTime = 0 } of ranks) {
let _leader = <RoleType>leader;
let { roleName, title, sHid, headHid, lv: leaderLv } = _leader;
await client.zaddAsync(getKeyName(REDIS_KEY.GUILD_ACTIVE_RANK, serverId), encodeScoreWithTime(activeWeekly, activeUpdateTime * 1000 ), code);
await redisClient().zaddAsync(getKeyName(REDIS_KEY.GUILD_ACTIVE_RANK, serverId), encodeScoreWithTime(activeWeekly, activeUpdateTime * 1000 ), code);
let rankParam = new GuildRankParam(icon, name, lv, { roleName, title, sHid, headHid, lv: leaderLv });
await redisUserInfoAdd(REDIS_KEY.GUILD_INFO, code, rankParam);
}
@@ -100,8 +98,7 @@ async function setRankRedisFromDb(type: string, serverId: number) {
// 排行榜是否存在
export async function existsRank(key: string, serverId: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
const result = await client.existsAsync(getKeyName(key, serverId));
const result = await redisClient().existsAsync(getKeyName(key, serverId));
return result;
}
@@ -115,37 +112,34 @@ export function getKeyName(key: string, serverId?: number) {
// 更新玩家信息
export async function redisUserInfoUpdate(key: string, roleId: string, arr: Array<{field: string, value:(string|number|GuildLeader)}>) {
const client: Redis.RedisClient = pinus.app.get('redis');
let params = await client.hgetAsync(key, roleId);
let params = await redisClient().hgetAsync(key, roleId);
if(params) {
let obj = JSON.parse(params);
for(let {field, value} of arr) {
obj[field] = value;
}
return await client.hsetAsync(key, roleId, JSON.stringify(obj));
return await redisClient().hsetAsync(key, roleId, JSON.stringify(obj));
}
}
// 添加玩家信息缓存
export async function redisUserInfoAdd(key: string, roleId: string, params: RankParam|GuildRankParam) {
const client: Redis.RedisClient = pinus.app.get('redis');
let value = JSON.stringify(params);
return await client.hsetAsync(key, roleId, value);
return await redisClient().hsetAsync(key, roleId, value);
}
// 更新排行榜, 如pvp这样跨服的，serverId传0
export async function setRank(key: string, serverId: number, myId: string, score: number, timestamp: number, params: RankParam|GuildRankParam, limit = 100) {
const client: Redis.RedisClient = pinus.app.get('redis');
// 更新分数
const _score = encodeScoreWithTime(score, timestamp);
await client.zaddAsync(getKeyName(key, serverId), _score, myId);
await redisClient().zaddAsync(getKeyName(key, serverId), _score, myId);
// 移除100名以外
await client.zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
await redisClient().zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
let infoKey = REDIS_RANK_TO_INFO.get(key);
// 如果没有信息，更新玩家信息
const hasCurUser = await client.hexistsAsync(infoKey, myId);
const hasCurUser = await redisClient().hexistsAsync(infoKey, myId);
if(!hasCurUser) {
await redisUserInfoAdd(infoKey, myId, params);
}
@@ -155,16 +149,15 @@ export async function setRank(key: string, serverId: number, myId: string, score
// 获取排行榜
export async function getRank(key: string, serverId: number, roleId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
let ranks = [], myRank = null;
const rankFromDb = await client.zrevrangebyscoreAsync(getKeyName(key, serverId), '+inf', '-inf', "WITHSCORES", "LIMIT", 0, 100);
const rankFromDb = await redisClient().zrevrangebyscoreAsync(getKeyName(key, serverId), '+inf', '-inf', "WITHSCORES", "LIMIT", 0, 100);
let infoKey = REDIS_RANK_TO_INFO.get(key);
for(let ii = 0; ii < rankFromDb.length; ii+=2) {
const _roleId = rankFromDb[ii];
const _score = decodeScoreWithTime(rankFromDb[ii + 1]);
const info = await client.hgetAsync(infoKey, _roleId);
const info = await redisClient().hgetAsync(infoKey, _roleId);
const _userInfo = JSON.parse(info);
const tmp = {..._userInfo, num: _score, rank: Math.floor(ii/2)+1};
if(infoKey == REDIS_KEY.USER_INFO) {
@@ -180,15 +173,13 @@ export async function getRank(key: string, serverId: number, roleId: string) {
// 获取我的排名
export async function getMyRank(key: string, serverId: number, roleId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
let myRank = await client.zrevrankAsync(getKeyName(key, serverId), roleId);
let myRank = await redisClient().zrevrankAsync(getKeyName(key, serverId), roleId);
return myRank + 1;
}
// 获取排名第几名的信息
export async function getFieldByRank(key: string, serverId: number, rank: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
let myRank = await client.zrevrangeAsync(getKeyName(key, serverId), rank - 1, rank - 1);
let myRank = await redisClient().zrevrangeAsync(getKeyName(key, serverId), rank - 1, rank - 1);
return myRank;
}
@@ -209,8 +200,7 @@ function decodeScoreWithTime(num: string): number {
// 从排行榜中移除
export async function removeFromRank(key: string, serverId: number, myId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.zremAsync(getKeyName(key, serverId), myId);
await redisClient().zremAsync(getKeyName(key, serverId), myId);
return true;
}
@@ -246,14 +236,13 @@ function getComTeamValue(roleId: string, sid: string) {
* @returns
*/
export async function setTeamSearchReq(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
let cmds = [];
qualityArr.forEach(quality => {
if (quality) {
cmds.push(['sadd', getComTeamKey(quality, lvRange), getComTeamValue(roleId, sid)]);
}
});
const multiClient = client.multi(cmds) as Redis.Multi;
const multiClient = redisClient().multi(cmds) as Redis.Multi;
const newMulti = promisifyAll(multiClient) as Redis.Multi;
const res = await newMulti.execAsync();
console.log('setTeamSearchReq: ', res);
@@ -270,7 +259,6 @@ export async function setTeamSearchReq(roleId: string, sid: string, qualityArr:
*/
export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
let cmds = [];
for (let q of qualityArr) {
if (lvRange) {
@@ -281,7 +269,7 @@ export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: A
}
}
};
const multiClient = client.multi(cmds) as Redis.Multi;
const multiClient = redisClient().multi(cmds) as Redis.Multi;
const newMulti = promisifyAll(multiClient) as Redis.Multi;
await newMulti.execAsync();
}
@@ -294,9 +282,8 @@ export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: A
* @returns
*/
export async function getTeamSearchByQuality(quality: number, lvRange: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
// TODO: 操作不具有原子性
const userInfos = await client.srandmemberAsync(getComTeamKey(quality, lvRange), 2);
const userInfos = await redisClient().srandmemberAsync(getComTeamKey(quality, lvRange), 2);
console.log('getTeamSearchByQuality: ' + userInfos);
if (!userInfos || !userInfos.length) return null;
@@ -320,9 +307,8 @@ export async function getTeamSearchByQuality(quality: number, lvRange: number) {
* @returns
*/
export async function checkRoleInQueue(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
for (let quality of qualityArr) {
let res = await client.sismemberAsync(getComTeamKey(quality, lvRange), `${roleId}:${sid}`);
let res = await redisClient().sismemberAsync(getComTeamKey(quality, lvRange), `${roleId}:${sid}`);
if (res) {
return true;
}
@@ -335,34 +321,40 @@ export async function checkRoleInQueue(roleId: string, sid: string, qualityArr:
* @export
*/
export async function clearComBtlQueue() {
const client: Redis.RedisClient = pinus.app.get('redis');
for (let q of COM_BTL_QUALITY) {
for (let lvRange of comBtlRanges()) {
await client.delAsync(getComTeamKey(q, lvRange));
await redisClient().delAsync(getComTeamKey(q, lvRange));
}
}
}
export function setRedis(key: string, data: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
client.setAsync(key, data);
redisClient().setAsync(key, data);
}
export async function getRedis(key: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
const str = await client.getAsync(key);
const str = await redisClient().getAsync(key);
return str;
}
export async function delRedis(key: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(key);
await redisClient().delAsync(key);
}
export function redisSidKey(roleId: string) {
return `login_roleId_${roleId}`;
}
export async function redisChannelServer(roomId: string) {
const sid = await redisClient().hgetAsync(REDIS_KEY.ONLINE_USERS, roomId);
return sid;
}
export async function addRedisChannel(roomId: string, sid: string) {
const result = await redisClient().hsetAsync(REDIS_KEY.ONLINE_USERS, roomId, sid);
return result;
}
/**
* 玩家上线
* @param roleId role表id
@@ -370,9 +362,8 @@ export function redisSidKey(roleId: string) {
* @param sid connector服的那个sid
*/
export async function roleLogin(roleId: string, userCode: string, sid: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
let param = { userCode, sid };
return await client.hsetAsync(REDIS_KEY.ONLINE_USERS, roleId, JSON.stringify(param));
return await redisClient().hsetAsync(REDIS_KEY.ONLINE_USERS, roleId, JSON.stringify(param));
}
/**
@@ -380,8 +371,7 @@ export async function roleLogin(roleId: string, userCode: string, sid: string) {
* @param roleId role表id
*/
export async function roleLeave(roleId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
return await client.hdelAsync(REDIS_KEY.ONLINE_USERS, roleId);
return await redisClient().hdelAsync(REDIS_KEY.ONLINE_USERS, roleId);
}
/**
@@ -389,8 +379,7 @@ export async function roleLeave(roleId: string) {
* @param roleId role表id
*/
export async function isRoleOnline(roleId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
let result = await client.hexistsAsync(REDIS_KEY.ONLINE_USERS, roleId);
let result = await redisClient().hexistsAsync(REDIS_KEY.ONLINE_USERS, roleId);
return !!result;
}
@@ -399,8 +388,7 @@ export async function isRoleOnline(roleId: string) {
* @param roleId
*/
export async function getRoleOnlineInfo(roleId: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
let str = await client.hgetAsync(REDIS_KEY.ONLINE_USERS, roleId);
let str = await redisClient().hgetAsync(REDIS_KEY.ONLINE_USERS, roleId);
if(str) {
try {
let result = JSON.parse(str);
@@ -421,14 +409,12 @@ export async function getRoleOnlineInfo(roleId: string) {
* 获得所有在线的玩家
*/
export async function getAllOnlineRoles() {
const client: Redis.RedisClient = pinus.app.get('redis');
let allRoles = await client.hgetallAsync(REDIS_KEY.ONLINE_USERS);
let allRoles = await redisClient().hgetallAsync(REDIS_KEY.ONLINE_USERS);
return allRoles;
}
export async function resetPvpRanks() {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(REDIS_KEY.PVP_RANK);
await redisClient().delAsync(REDIS_KEY.PVP_RANK);
let { seasonNum } = await SystemConfigModel.findSystemConfig();
console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
let pvpRank = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
@@ -438,9 +424,9 @@ export async function resetPvpRanks() {
continue;
}
let { roleName, headHid, sHid, title, lv, vLv } = role;
await client.zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
await redisClient().zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
const hasCurUser = await client.hexistsAsync(REDIS_KEY.USER_INFO, roleId);
const hasCurUser = await redisClient().hexistsAsync(REDIS_KEY.USER_INFO, roleId);
if(!hasCurUser) {
let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
@@ -450,31 +436,26 @@ export async function resetPvpRanks() {
// 排行榜是否存在
export async function smembersAsync(key: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
const result = await client.smembersAsync(key);
const result = await redisClient().smembersAsync(key);
return result;
}
export async function saddAsync(key: string, values: Array<string>) {
const client: Redis.RedisClient = pinus.app.get('redis');
const result = await client.saddAsync(key, values);
const result = await redisClient().saddAsync(key, values);
return result;
}
export async function sismemberAsync(key: string, value: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
const result = await client.sismemberAsync(key, value);
const result = await redisClient().sismemberAsync(key, value);
return result;
}
export async function delAsync(key:string) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(key);
await redisClient().delAsync(key);
}
export async function sremAsync(key:string, member:string) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.sremAsync(key, member);
await redisClient().sremAsync(key, member);
}
/**************** 寻宝相关 end */
@@ -485,20 +466,23 @@ export async function readDataBase() {
}
async function setServerList() {
const client: Redis.RedisClient = pinus.app.get('redis');
const serverList = await GameModel.getAllServerList();
await client.delAsync(REDIS_KEY.DB_GAME);
await redisClient().delAsync(REDIS_KEY.DB_GAME);
for(let { id, serverType, name } of serverList) {
// console.log(roleId);
await client.hsetAsync(REDIS_KEY.DB_GAME, `${serverType}_${id}`, name);
await redisClient().hsetAsync(REDIS_KEY.DB_GAME, `${serverType}_${id}`, name);
}
}
export async function getServerName(serverType: string, serverId: number) {
const client: Redis.RedisClient = pinus.app.get('redis');
let name = await client.hgetAsync(REDIS_KEY.DB_GAME, `${serverType}_${serverId}`);
let name = await redisClient().hgetAsync(REDIS_KEY.DB_GAME, `${serverType}_${serverId}`);
return name
}
function redisClient() {
const client: Redis.RedisClient = pinus.app.get('redis');
return client;
}
/**************** 数据库表end */