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

✨ feat(服务器): 更新维护逻辑

Browse Source
This commit is contained in:
luying
2023-05-06 11:44:05 +08:00
parent a651254821
commit f47d2d131f
24 changed files with 183 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
game-server/app/servers/activity/remote/activityRemote.ts
View File

@@ -112,9 +112,9 @@ export class ActivityRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/servers/battle/remote/battleRemote.ts
View File

@@ -119,9 +119,9 @@ export class BattleRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/servers/chat/remote/chatRemote.ts
View File

@@ -119,9 +119,9 @@ export class ChatRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/servers/comBattle/remote/comBattleRemote.ts
View File

@@ -82,9 +82,9 @@ export class ComBattleRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

10
game-server/app/servers/connector/filter/global.ts
View File

@@ -36,6 +36,8 @@ class Filter {
const uid: number = session.get('userid');
const ip: string = session.get('ip');
// console.log('*********** global before ip', ip)
const version: string = session.get('version');
const isNewUser: boolean = session.get('isNewUser');
let guildCode = session.get('guildCode');
let blockType = session.get('blockType');
const logCode = genCode(10);
@@ -79,9 +81,10 @@ class Filter {
msg.guildCode = guildCode;
}
if(await this.checkMainten(serverId, sid, ip, uid)) {
if(routeRecord.route != 'connector.entryHandler.enter' && await this.checkMainten(serverId, sid, ip, uid, isNewUser)) {
sendMessageToUser(roleId, PUSH_ROUTE.SERVER_MAINTENANCE, resResult(STATUS.SERVER_MAINTENANCE), sid);
return next(new Error('globalFilter'), resResult(STATUS.SERVER_MAINTENANCE, { route: routeRecord.route }));
const mainten = getServerMainten(serverId);
return next(new Error('globalFilter'), resResult(STATUS.SERVER_MAINTENANCE, { route: routeRecord.route, curVersion: version, minVersion: mainten.version }));
}
next(null);
@@ -294,7 +297,7 @@ class Filter {
}
// 检查是否维护中
private async checkMainten(serverId: number, sid: string, ip: string, uid: number) {
private async checkMainten(serverId: number, sid: string, ip: string, uid: number, isNewUser: boolean) {
if(!sid) return false;
const mainten = getServerMainten(serverId);
@@ -303,6 +306,7 @@ class Filter {
let isWhiteList = await checkWhiteList(this.app.get('env'), ip, uid);
if(isWhiteList) return false;
if(isNewUser) return false;
return true
}

46
game-server/app/servers/connector/handler/entryHandler.ts
View File

@@ -21,11 +21,14 @@ import { getExpByLv } from '../../../pubUtils/data';
import { reportCreateRoleEventToTa, reportTAEvent, reportTAUserSet } from '../../../services/sdkService';
import { saveLoginAndOutLog } from '../../../pubUtils/logUtil';
import { sendMessageToAllWithSuc, sendMessageToUserWithSuc } from '../../../services/pushService';
import { checkServerIsOpen, getIpLocation } from '../../../services/roleService';
import { checkIsNewUser, getIpLocation } from '../../../services/roleService';
import { leaveRaceActivityToRemote } from '../../../services/guildActivity/guildActivityService';
import { leaveCity } from '../../../services/gvg/gvgBattleService';
import { autoCreateServerWhenRoleInit } from '../../../services/serverService';
import { getHiddenData } from '../../../services/memoryCache/hiddenData';
import { ServerlistModel } from '../../../db/Serverlist';
import { checkWhiteList } from '../../../pubUtils/sysUtil';
import { getAp } from '../../../services/actionPointService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -42,7 +45,7 @@ export class EntryHandler {
* @param {Object} msg request message
* @param {Object} session current session object
*/
async enter(msg: { token: string, serverId: number }, session: FrontendSession) {
async enter(msg: { token: string, serverId: number, version: string }, session: FrontendSession) {
// console.log('****** entry before', Date.now());
let self = this;
let serverId = msg.serverId;
@@ -64,8 +67,22 @@ export class EntryHandler {
}
let ip = this.getIp(session);
if(!await checkServerIsOpen(serverId, ip, user.uid)) {
return resResult(STATUS.SERVER_IS_NOT_OPEN)
let server = await ServerlistModel.findByServerId(serverId);
if(!server) return resResult(STATUS.SERVER_NOT_FOUND);
let isWhiteList = await checkWhiteList(pinus.app.get('env'), ip, user.uid);
if(!isWhiteList) { // 白名单
if(server.openTime > nowSeconds()) {
return resResult(STATUS.SERVER_IS_NOT_OPEN);
}
if(server.maintenance && server.maintenance.isOpen && server.maintenance.startTime <= nowSeconds() && server.maintenance.endTime >= nowSeconds()) {
let isNewUser = await checkIsNewUser(msg.version, server.maintenance.version, user.uid, server.latestServerUniqId);
console.log('#### isNewUser', isNewUser)
if(isNewUser && server.id == server.latestServerUniqId) {
user['isNewUser'] = true;
} else {
return resResult(STATUS.SERVER_MAINTENANCE, { curVersion: msg.version, minVersion: server.maintenance.version })
}
}
}
@@ -74,11 +91,10 @@ export class EntryHandler {
if (!role) {
return resResult(STATUS.ROLE_NOT_FOUND);
}
console.log('#### needCount 0', role.needCount)
let serverName = this.app.getServerId();
await roleLogin(role.roleId, user.userCode, serverName, role.createTime, role.serverId, role.lv, role.topLineupCe); // 保存在线用户
await this.addSession(user, role, session);
await this.addSession(user, role, msg.version, session);
await reportCreateRoleEventToTa(role, ip);
saveLoginAndOutLog(LOG_TYPE.LOGIN, session);
@@ -93,7 +109,6 @@ export class EntryHandler {
}
let todayZeroPoint = getZeroPoint();
console.log('####### needCount', role.needCount)
if(role.needCount) autoCreateServerWhenRoleInit(serverId);
// console.log('****** entry after', Date.now());
@@ -116,10 +131,12 @@ export class EntryHandler {
return session.remoteAddress.ip.replace('::ffff:', '');
}
async addSession(user: UserType, role: RoleType, session: FrontendSession) {
async addSession(user: UserType, role: RoleType, version: string, session: FrontendSession) {
const self = this;
let ip = this.getIp(session);
console.log('####### addSession', user['isNewUser']||false)
await session.abind(role.roleId);
session.set('userid', role.userInfo.uid);
session.set('roleId', role.roleId);
@@ -133,6 +150,8 @@ export class EntryHandler {
session.set('ip', ip);
session.set('vipStartTime', role.vipStartTime||0);
session.set('channel', user.channelInfo?.platformAppid||'pc');
session.set('isNewUser', user['isNewUser']||false);
session.set('version', version);
session.push('userid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
@@ -145,6 +164,8 @@ export class EntryHandler {
session.push('ip', () => { });
session.push('vipStartTime', () => { });
session.push('channel', () => { });
session.push('version', () => { });
session.push('isNewUser', () => { });
assignServer(role.roleId, session);
// console.log('#####', role.serverId, role.guildCode)
@@ -188,6 +209,15 @@ export class EntryHandler {
return resResult(STATUS.SUCCESS, data);
}
async comeBack(msg: { version: string }, session: FrontendSession) {
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
/**
* User log out handler
*

4
game-server/app/servers/connector/remote/connectorRemote.ts
View File

@@ -83,9 +83,9 @@ export class ConnectorRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

12
game-server/app/servers/gm/handler/gmServerHandler.ts
View File

@@ -65,8 +65,8 @@ export class GmHandler {
}
// 开始维护
async startMaintenance(msg: { id: number, startTime: number, endTime: number, hasNotify: boolean }, session: BackendSession) {
const { id, startTime, endTime, hasNotify } = msg;
async startMaintenance(msg: { id: number, startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { id, startTime, endTime, hasNotify, version } = msg;
if(!id || !isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
@@ -75,7 +75,7 @@ export class GmHandler {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(server.maintenance.batchCode, [server.id]);
}
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true }
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
server = await ServerlistModel.updateByServerId(id, { maintenance: newMaintenance });
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast([server]);
@@ -83,12 +83,12 @@ export class GmHandler {
}
// 大区一起维护
async startRegionMaintenance(msg: { startTime: number, endTime: number, hasNotify: boolean }, session: BackendSession) {
const { startTime, endTime, hasNotify } = msg;
async startRegionMaintenance(msg: { startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { startTime, endTime, hasNotify, version } = msg;
if(!isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true }
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
let serverIdsOfBatchCode = new Map<string, number[]>();
let serverIds: number[] = [];

4
game-server/app/servers/guild/remote/guildRemote.ts
View File

@@ -44,9 +44,9 @@ export class GuildRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/servers/order/remote/orderRemote.ts
View File

@@ -49,9 +49,9 @@ export class OrderRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/servers/role/remote/roleRemote.ts
View File

@@ -96,9 +96,9 @@ export class RoleRemote {
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime);
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}

4
game-server/app/services/connectorService.ts
View File

@@ -5,9 +5,9 @@ import { getMails } from './mailService';
import { recentGuildMsgs, recentLeagueMsgs, recentPrivateChatInfos, recentServerGroupMsgs, recentSysMsgs, recentWorldMsgs } from './chatService';
import { getCurTask, getPvpTask } from './task/taskService';
import { RoleType } from '../db/Role';
import { RoleModel, RoleType } from '../db/Role';
import { Application, FrontendOrBackendSession, pinus, RpcClient } from 'pinus';
import { getRandEelmWithWeight, resResult } from '../pubUtils/util';
import { compareVersion, getRandEelmWithWeight, resResult } from '../pubUtils/util';
import { STATUS, PUSH_BATCH, PUSH_INTERVAL, CONSUME_TYPE, HERO_SELECT, ENTERY_ROLE_PICK, JEWEL_SELECT, ITEM_SELECT, SKIN_SELECT, PUSH_ROUTE, ARTIFACT_SELECT, ACTIVITYITEM_SELECT, SNS_LINK_TYPE } from '../consts';
import { getAllShopList } from './shopService';
import { getGeneralRank, getRankFirstReward } from './rankService';

5
game-server/app/services/gmService.ts
View File

@@ -159,14 +159,15 @@ export async function sendOpenServerMail(type: 'openMail'|'circleMail', mail: St
return true;
}
export function setServerMainten(serverIds: number[], startTime: number, endTime: number) {
export function setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
let maintenServers = pinus.app.get('maintenServers')||new Map();
for(let id of serverIds) {
if(!maintenServers.has(id)) {
maintenServers.set(id, { startTime, endTime });
maintenServers.set(id, { startTime, endTime, version });
} else {
maintenServers.get(id).startTime = startTime;
maintenServers.get(id).endTime = endTime;
maintenServers.get(id).version = version;
}
}
pinus.app.set('maintenServers', maintenServers);

19
game-server/app/services/roleService.ts
View File

@@ -1,5 +1,5 @@
import { Channel, pinus } from 'pinus';
import { getRandValueByMinMax, getRandEelm, decodeIdCntArrayStr } from '../pubUtils/util';
import { getRandValueByMinMax, getRandEelm, decodeIdCntArrayStr, compareVersion } from '../pubUtils/util';
import { DEFAULT_HEROES, LINEUP_NUM, ROLE_SELECT, TALENT_RELATION_TYPE, TERAPH_RANDOM, SYSTEM_OPEN_ID, GuideUnloadNum, CHECK_HERO_CONSUME, ABI_STAGE } from "../consts";
import { DicTeraph } from '../pubUtils/dictionary/DicTeraph';
import { Teraph, RoleModel, RoleType, RoleUpdate } from '../db/Role';
@@ -17,6 +17,7 @@ import IP2Region from "ip2region";
import { getServerCreateTime } from './redisService';
import { checkWhiteList } from '../pubUtils/sysUtil';
import { nowSeconds } from '../pubUtils/timeUtil';
import { ServerlistModel } from '../db/Serverlist';
const query = new IP2Region({ disableIpv6: true });
@@ -305,13 +306,15 @@ export async function getIpLocation(ip: string) {
}
}
// 服务器是否开启
export async function checkServerIsOpen(serverId: number, ip: string, uid: number) {
let isWhiteList = await checkWhiteList(pinus.app.get('env'), ip, uid);
if(isWhiteList) return true;
let serverTime = await getServerCreateTime(serverId);
return serverTime <= nowSeconds();
// 玩家是否是新玩家
export async function checkIsNewUser(version: string, minVersion: string, uid: number, latestServerUniqId: number) {
let versionFlag = compareVersion(version, minVersion||'0.0.0.0');
if(versionFlag >= 0) {
let hasRole = await RoleModel.checkHasRole(uid, latestServerUniqId);
return !hasRole
} else {
return true;
}
}
export function calStarUpConsume(hero: HeroType) {

2
game-server/app/services/serverService.ts
View File

@@ -143,7 +143,7 @@ export async function autoCreateServerWhenRoleInit(serverId: number) {
return errlogger.error('create new server region not found');
}
if(region.stategy && region.stategy.type == 2 && region.latestServerUniqId == server.id && server.playerCnt >= region.stategy.maxPlayerCnt) {
if(region.stategy && region.stategy.isOpen && region.stategy.type == 2 && region.latestServerUniqId == server.id && server.playerCnt >= region.stategy.maxPlayerCnt) {
let params = new CreateServerParam();
params.setByRegionStategy(region, nowSeconds())
await createNewServer(region, server.serverId + 1, params);

18
game-server/app/services/timeTaskService.ts
View File

@@ -571,7 +571,7 @@ export async function initMaintenanaceInOtherServers() {
for(let server of servers) {
let { id, maintenance } = server;
if(maintenance && maintenance.isOpen) {
setServerMainten([id], maintenance.startTime, maintenance.endTime)
setServerMainten([id], maintenance.startTime, maintenance.endTime, maintenance.version)
}
}
}
@@ -641,14 +641,14 @@ async function startMaintenanceSchedule(batchCode: string) {
// 更新connectorRemote里面的维护服务器
console.log('******** startMaintenanceSchedule', batchCode, serverIds, maintenance.startTime, maintenance.endTime)
pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.activity.activityRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.battle.battleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.comBattle.comBattleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.chat.chatRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.guild.guildRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.order.orderRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.role.roleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.activity.activityRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.battle.battleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.comBattle.comBattleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.chat.chatRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.guild.guildRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.order.orderRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
pinus.app.rpc.role.roleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime, maintenance.version);
// 数数flush
pinus.app.rpc.activity.activityRemote.taflush.broadcast();
pinus.app.rpc.battle.battleRemote.taflush.broadcast();

5
shared/db/Role.ts
View File

@@ -876,6 +876,11 @@ export default class Role extends BaseModel {
let role: RoleType = await RoleModel.findOneAndUpdate({ roleId, closeTime: { $gte: now } }, { $set: { closeTime: 0, cancelCloseTime: now } }, { new: true }).select('roleId +closeTime').lean();
return role;
}
public static async checkHasRole(uid: number, serverId: number) {
return await RoleModel.exists({ 'userInfo.uid': uid, lv: { $gt: 3 }, serverId: { $lt: serverId } });
}
}
export const RoleModel = getModelForClass(Role);

33
shared/db/Serverlist.ts
View File

@@ -3,7 +3,6 @@ import { index, getModelForClass, prop, DocumentType, modelOptions, ReturnModelT
import { SERVER_STATUS } from '../consts';
import { CreateServerParam } from '../domain/backEndField/params';
import { RegionType } from './Region';
import { nowSeconds } from '../pubUtils/timeUtil';
import { getDicServerName } from '../pubUtils/data';
import { genCode } from '../pubUtils/util';
@@ -24,6 +23,9 @@ export class Maintenance {
@prop({ required: true })
hasNotify: boolean; // 是否有维护通知
@prop({ required: true })
version: string; // 可以进入的版本
}
/**
@@ -70,16 +72,8 @@ export default class Serverlist extends BaseModel {
@prop({ required: true })
generateCode: string; // 生成编号
public get status() {
let now = nowSeconds();
if (now < this.openTime) {
return SERVER_STATUS.WILL_OPEN;
} else if (this.maintenance && this.maintenance.isOpen && this.maintenance.startTime < now && this.maintenance.endTime > now) {
return SERVER_STATUS.MAINTENANCE;
} else {
return this.serverStatus; // 未开服
}
}
@prop({ required: true })
latestServerUniqId: number; // 最新服
@prop({ required: true })
openTime: number;
@@ -102,7 +96,7 @@ export default class Serverlist extends BaseModel {
public static async getAllServerList() {
let result: ServerlistType[] = [], id = 0;
for(let i = 0; i < 1000; i++) { // 防无限循环锁死
let servers: ServerlistType[] = await ServerlistModel.find({ id: { $gt: id }}).sort({ id: 1 }).lean({ getters: true, virtuals: true });
let servers: ServerlistType[] = await ServerlistModel.find({ id: { $gt: id }}).sort({ id: 1 }).lean({ getters: true });
if(servers.length == 0) break;
id = servers[servers.length -1].id;
result.push(...servers);
@@ -111,17 +105,17 @@ export default class Serverlist extends BaseModel {
}
public static async findByServerId(serverId: number) {
let server: ServerlistType = await ServerlistModel.findOne({ id: serverId }).lean({ getters: true, virtuals: true });
let server: ServerlistType = await ServerlistModel.findOne({ id: serverId }).lean({ getters: true });
return server;
}
public static async findByServerIds(serverIds: number[], select?: string) {
let servers: ServerlistType[] = await ServerlistModel.find({ id: { $in: serverIds } }).select(select).lean({ getters: true, virtuals: true });
let servers: ServerlistType[] = await ServerlistModel.find({ id: { $in: serverIds } }).select(select).lean({ getters: true });
return servers;
}
public static async updateByServerId(serverId: number, update: ServerlistUpdate) {
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id: serverId }, { $set: update }, {new: true}).lean({ getters: true, virtuals: true });
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id: serverId }, { $set: update }, {new: true}).lean({ getters: true });
return server;
}
@@ -148,10 +142,11 @@ export default class Serverlist extends BaseModel {
openTime, stopRegisterTime,
createdBy: uid, updatedBy: uid, generateCode
});
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id }, { $setOnInsert: update }, { new: true, upsert: true }).lean({ getters: true, virtuals: true });
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id }, { $setOnInsert: update }, { new: true, upsert: true }).lean({ getters: true });
if(server.generateCode == generateCode) {
// 旧服修改状态
await ServerlistModel.updateMany({ env, serverStatus: SERVER_STATUS.NEW, id: { $lt: id } }, { $set: { serverStatus: SERVER_STATUS.HOT } })
await ServerlistModel.updateMany({ env, serverStatus: SERVER_STATUS.NEW, id: { $lt: id } }, { $set: { serverStatus: SERVER_STATUS.HOT } })
await ServerlistModel.updateMany({ env }, { latestServerUniqId: server.id });
return server;
}
return null;
@@ -159,10 +154,10 @@ export default class Serverlist extends BaseModel {
public static async findByEnv(env?: string, isReview = false) {
if(isReview) {
let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 }, isReview }).sort({ id: -1 }).lean({ getters: true, virtuals: true });
let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 }, isReview }).sort({ id: -1 }).lean({ getters: true });
return server;
} else {
let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 } }).sort({ id: -1 }).lean({ getters: true, virtuals: true });
let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 } }).sort({ id: -1 }).lean({ getters: true });
return server;
}
}

12
shared/domain/gameField/serverlist.ts
View File

@@ -12,12 +12,12 @@ export class ServerParam {
status: number; // 状态
openTime: number; // 开服时间
constructor(server: ServerlistType) {
constructor(server: ServerlistType, status: number) {
this.id = server.id;
this.serverId = server.serverId;
this.serverStr = `${server.prefix}${server.serverId}`;
this.name = server.name;
this.status = server.status;
this.status = status;
this.openTime = server.openTime;
}
}
@@ -35,8 +35,8 @@ export class GroupParam {
this.servers = new Array<ServerParam>();
}
public pushServer(server: ServerlistType) {
let srv = new ServerParam(server);
public pushServer(server: ServerlistType, status: number) {
let srv = new ServerParam(server, status);
this.servers.push(srv);
this.servers.sort((a, b) => b.serverId - a.serverId);
let min = this.servers[this.servers.length - 1];
@@ -59,8 +59,8 @@ export class ServerParamWithRole extends ServerParam {
isClose: boolean; // 是否已经注销
closeTime: number; // 注销生效时间
constructor(role: RoleType, server: ServerlistType) {
super(server);
constructor(role: RoleType, server: ServerlistType, status: number) {
super(server, status);
this.groupId = server.groupId;
this.groupName = server.groupName;

22
shared/pubUtils/util.ts
View File

@@ -861,4 +861,24 @@ export function getArrayOfNumber(len: number) {
let arr: number[] = [];
for(let i = 1; i <= len; i++) arr.push(i);
return arr;
}
}
// 比较以 . 分隔的版本号。返回 0 则版本号相等，返回正数则 versionA 大，返回负数则 versionB 大
export function compareVersion(versionA: string, versionB: string) {
var vA = versionA.split('.');
var vB = versionB.split('.');
for (var i = 0; i < vA.length; ++i) {
var a = parseInt(vA[i]);
var b = parseInt(vB[i] || '0');
if (a === b) {
} else {
return a - b;
}
}
if (vB.length > vA.length) {
return -1;
} else {
return 0;
}
};

8
web-server/app/controller/game.ts
View File

@@ -87,7 +87,7 @@ export default class GameController extends Controller {
try {
const { ctx } = this;
let { uid } = ctx;
const { pid, gid } = ctx.request.body;
const { pid, gid, version } = ctx.request.body;
let serverList = new Array<GroupParam>();
let loginServerList = new Array<ServerParamWithRole>();
@@ -104,6 +104,7 @@ export default class GameController extends Controller {
// let env = isReview? curRegion.reviewEnv: ctx.app.config.realEnv;
let allServers = await ServerlistModel.findByEnv(ctx.app.config.realEnv, false);
let hasRole = await RoleModel.checkHasRole(uid, curRegion.latestServerUniqId);
if(pid && gid) {
const pkg = await PackageModel.getPackageByGidPid(gid, pid);
@@ -114,16 +115,17 @@ export default class GameController extends Controller {
let roles = await RoleModel.findAllByUid(uid, true, true);
for (let server of allServers) {
let status = ctx.service.utils.getServerStatus(server, version, hasRole)
let curGroup = serverList.find(cur => cur.groupId == server.groupId);
if (!curGroup) {
curGroup = new GroupParam(server);
serverList.push(curGroup);
}
curGroup.pushServer(server);
curGroup.pushServer(server, status);
let role = roles.find(role => role.serverId == server.id);
if (!!role) {
let curLoginInfo = new ServerParamWithRole(role, server);
let curLoginInfo = new ServerParamWithRole(role, server, status);
loginServerList.push(curLoginInfo);
}
}

18
web-server/app/middleware/checkMainten.ts
View File

@@ -2,10 +2,11 @@ import { STATUS } from '@consts';
import { ServerlistModel } from '@db/Serverlist';
import { nowSeconds } from 'app/pubUtils/timeUtil';
import { checkWhiteList } from 'app/pubUtils/sysUtil';
import { RoleModel } from '@db/Role';
module.exports = () => {
return async function checkMainten(ctx, next) {
const { serverId } = ctx.request.body;
const { serverId, version } = ctx.request.body;
if (serverId) {
let server = await ServerlistModel.findByServerId(serverId);
if (server && server.maintenance && server.maintenance.isOpen && server.maintenance.startTime < nowSeconds() && server.maintenance.endTime > nowSeconds()) {
@@ -13,8 +14,19 @@ module.exports = () => {
if (isWhiteList) {
return await next();
} else {
ctx.body = ctx.service.utils.resResult(STATUS.SERVER_MAINTENANCE);
return;
const versionFlag = ctx.service.utils.compareVersion(version, server.maintenance.version||'0.0.0');
if(versionFlag >= 0) { // 新版本号
let hasRole = await RoleModel.checkHasRole(ctx.uid, server.latestServerUniqId); // 是否是老玩家
if(!hasRole) {
return await next();
} else {
ctx.body = ctx.service.utils.resResult(STATUS.SERVER_MAINTENANCE);
return;
}
} else {
ctx.body = ctx.service.utils.resResult(STATUS.SERVER_MAINTENANCE);
return;
}
}
} else if(server && server.openTime > nowSeconds()) {
let isWhiteList = await checkWhiteList(ctx.app.config.realEnv, ctx.clientIp, ctx.uid);

2
web-server/app/service/Sdk.ts
View File

@@ -348,7 +348,7 @@ export default class Sdk extends Service {
let regions = await RegionModel.getAllRegion();
let data = servers.map(server => {
let statue = 0;
switch(server.status) {
switch(server.serverStatus) {
case SERVER_STATUS.MAINTENANCE:
statue = 0; break;
case SERVER_STATUS.WILL_OPEN:

24
web-server/app/service/Utils.ts
View File

@@ -2,8 +2,10 @@ import { Service } from 'egg';
import { resResult as pubResult } from '../pubUtils/util';
import { gameData } from 'app/pubUtils/data';
import { RedisClient } from 'redis';
import { REDIS_KEY } from '@consts';
import { REDIS_KEY, SERVER_STATUS } from '@consts';
import { getRedisSubChannel } from 'app/pubUtils/sdkUtil';
import { ServerlistType } from '@db/Serverlist';
import { nowSeconds } from 'app/pubUtils/timeUtil';
const csprng = require('csprng');
/**
* Utils Service
@@ -133,4 +135,24 @@ export default class Utils extends Service {
return 0;
}
};
public getServerStatus(server: ServerlistType, version: string, hasRole: boolean) {
let now = nowSeconds();
if (now < server.openTime) {
return SERVER_STATUS.WILL_OPEN;
} else if (server.maintenance && server.maintenance.isOpen && server.maintenance.startTime < now && server.maintenance.endTime > now) {
const versionFlag = this.ctx.service.utils.compareVersion(version, server.maintenance.version||'0.0.0');
if(versionFlag >= 0) { // 新版本号
if(!hasRole && server.id == server.latestServerUniqId) { // 新玩家
return server.serverStatus;
} else {
return SERVER_STATUS.MAINTENANCE;
}
} else {
return SERVER_STATUS.MAINTENANCE;
}
} else {
return server.serverStatus; // 未开服
}
}
}