cgserver 6.0.7 → 6.1.0

package/dist/lib/Service/ini.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EAccountFrom = exports.EAccountState = exports.EUserState = exports.ERoleGroup = void 0;
+var ERoleGroup;
+(function (ERoleGroup) {
+    ERoleGroup[ERoleGroup["Creator"] = 1] = "Creator";
+    ERoleGroup[ERoleGroup["Admin"] = 2] = "Admin";
+    ERoleGroup[ERoleGroup["Proxy"] = 3] = "Proxy";
+    ERoleGroup[ERoleGroup["Common"] = 4] = "Common"; //普通成员
+})(ERoleGroup = exports.ERoleGroup || (exports.ERoleGroup = {}));
+var EUserState;
+(function (EUserState) {
+    EUserState[EUserState["Ban"] = -1] = "Ban";
+    EUserState[EUserState["Waitting"] = 0] = "Waitting";
+    EUserState[EUserState["Normarl"] = 1] = "Normarl";
+})(EUserState = exports.EUserState || (exports.EUserState = {}));
+var EAccountState;
+(function (EAccountState) {
+    EAccountState[EAccountState["Ban"] = -1] = "Ban";
+    EAccountState[EAccountState["Waitting"] = 0] = "Waitting";
+    EAccountState[EAccountState["Normarl"] = 1] = "Normarl";
+})(EAccountState = exports.EAccountState || (exports.EAccountState = {}));
+var EAccountFrom;
+(function (EAccountFrom) {
+    EAccountFrom[EAccountFrom["Guest"] = 0] = "Guest";
+    EAccountFrom[EAccountFrom["OpenSocial"] = 1] = "OpenSocial";
+    EAccountFrom[EAccountFrom["WeChat"] = 2] = "WeChat";
+    EAccountFrom[EAccountFrom["QQ"] = 3] = "QQ";
+    EAccountFrom[EAccountFrom["Phone"] = 4] = "Phone";
+    EAccountFrom[EAccountFrom["Email"] = 5] = "Email";
+    EAccountFrom[EAccountFrom["Name"] = 6] = "Name";
+    EAccountFrom[EAccountFrom["QuickPhone"] = 7] = "QuickPhone";
+    EAccountFrom[EAccountFrom["Apple"] = 8] = "Apple";
+    EAccountFrom[EAccountFrom["Google"] = 9] = "Google";
+})(EAccountFrom = exports.EAccountFrom || (exports.EAccountFrom = {}));

package/dist/lib/SocketServer/IClientWebSocket.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IClientWebSocket = void 0;
+const IWebSocket_1 = require("./IWebSocket");
+const ws = require("websocket");
+const Log_1 = require("../Logic/Log");
+const IProtoFilter_1 = require("./ProtoFilter/IProtoFilter");
+class IClientWebSocket extends IWebSocket_1.IWebSocket {
+    _host = "";
+    /**
+     * 连接的服务器地址
+     */
+    get host() {
+        return this._host;
+    }
+    _port = "";
+    /**
+     * 连接的服务器端口
+     */
+    get port() {
+        return this._port;
+    }
+    _need_close = false;
+    constructor(protoType = IProtoFilter_1.EProtoType.Json, protoPath = "") {
+        super(protoType, protoPath);
+    }
+    connect(domain, port) {
+        this._host = domain || this._host;
+        this._port = port || this._port;
+        this._connect();
+    }
+    _connect() {
+        let url = "ws://" + this._host + ":" + this._port + "/";
+        Log_1.GLog.info("Trying to connect to server : " + url);
+        let _ws = new ws.client();
+        _ws.on("connect", super.onConnect.bind(this));
+        _ws.on("connectFailed", this.onClose.bind(this));
+        _ws.connect(url, null, null, { cookie: "client=" + this._tipKey });
+    }
+    onOpen(e) {
+        super.onOpen(e);
+        Log_1.GLog.info("success to connect to " + this._host + ":" + this._port);
+    }
+    onClose(reasonCode, description) {
+        super.onClose(reasonCode, description);
+        if (!this._need_close) {
+            setTimeout(() => {
+                if (!this._need_close) {
+                    this.connect(this._host, this._port);
+                }
+            }, 1000);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    close() {
+        this._need_close = true;
+        super.close();
+    }
+    _onDecode(message, ...params) {
+        let msg = super._onDecode(message, "msgRes");
+        return msg;
+    }
+    _onEncode(data, ...params) {
+        let msg = super._onEncode(data, "msgReq");
+        return msg;
+    }
+}
+exports.IClientWebSocket = IClientWebSocket;

package/dist/lib/SocketServer/IServerWebSocket.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IServerWebSocket = void 0;
+const IWebSocket_1 = require("./IWebSocket");
+const Log_1 = require("../Logic/Log");
+const IProtoFilter_1 = require("./ProtoFilter/IProtoFilter");
+class IServerWebSocket extends IWebSocket_1.IWebSocket {
+    _server = null;
+    get server() {
+        return this._server;
+    }
+    constructor(server, protoType = IProtoFilter_1.EProtoType.Json, protoPath = "") {
+        super(protoType, protoPath);
+        this._server = server;
+        this._tipKey = this._server.name;
+    }
+    onClose(reasonCode, description) {
+        super.onClose(reasonCode, description);
+        this._server.removeServerWebSocketBySocketId(this._socket_id);
+    }
+    broadCast(data) {
+        let serverWS = this._server.serverWebSocket;
+        if (!data) {
+            Log_1.GLog.info("Send Message warning:null data!");
+            return;
+        }
+        Log_1.GLog.info("broadCast:----------------------------------");
+        Log_1.GLog.info(data);
+        let msg = this._protoFilter.encode(data);
+        serverWS.broadcast(msg);
+    }
+    _onDecode(message, ...params) {
+        let msg = super._onDecode(message, "msgReq");
+        return msg;
+    }
+    _onEncode(data, ...params) {
+        let msg = super._onEncode(data, "msgRes");
+        return msg;
+    }
+}
+exports.IServerWebSocket = IServerWebSocket;

package/dist/lib/SocketServer/ISocketServer.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISocketServer = void 0;
+const MysqlManager_1 = require("../Database/MysqlManager");
+const RedisManager_1 = require("../Database/RedisManager");
+const ws = require("websocket");
+const Log_1 = require("./../Logic/Log");
+const fs = require("fs");
+const http = require("http");
+const https = require("https");
+const FrameworkConfig_1 = require("../Config/FrameworkConfig");
+const MongoManager_1 = require("../Database/MongoManager");
+const MSSqlManager_1 = require("../Database/MSSqlManager");
+class ISocketServer {
+    //服务器已被关闭
+    _is_closed = false;
+    get isClosed() {
+        return this._is_closed;
+    }
+    _code = -1; //服务器唯一编码
+    get code() {
+        return this._code;
+    }
+    set code(value) {
+        this._code = value;
+    }
+    _name = "";
+    get name() {
+        return this._name;
+    }
+    get fullServerName() {
+        return this._name + "@" + this._code;
+    }
+    //监听websocket
+    _web_socket = null;
+    get serverWebSocket() {
+        return this._web_socket;
+    }
+    //来自于用户的链接
+    _ws_clients = new Map();
+    _listen_port = 0;
+    get listenPort() {
+        return this._listen_port;
+    }
+    set listenPort(value) {
+        this._listen_port = value;
+    }
+    /**
+     * websocket can accepted protocol
+     */
+    _accepted_protocol = null;
+    //服务器管理相关
+    /*
+        item=servername:class
+    */
+    _name_vs_class = {};
+    registerWebSocketHandleClass(name, cls) {
+        if (!name || name == "") {
+            throw "registerWebSocketHandleClass name must be not null or empty!";
+        }
+        this._name_vs_class[name] = cls;
+    }
+    constructor(server_name) {
+        this._name = server_name;
+    }
+    removeServerWebSocketBySocketId(socketId) {
+        this._ws_clients[socketId] = null;
+        delete this._ws_clients[socketId];
+    }
+    async run() {
+        await MSSqlManager_1.GMSSqlMgr.init();
+        await MysqlManager_1.GMysqlMgr.init();
+        await RedisManager_1.GRedisMgr.init(FrameworkConfig_1.GFCfg.db.redis);
+        await MongoManager_1.GMongoMgr.init();
+        let code = await RedisManager_1.GRedisMgr.incr("server_code");
+        this._code = code;
+        setTimeout(this.initWebSocket.bind(this), 3000); //给数据库相关留一点时间
+    }
+    stop() {
+        this._is_closed = true;
+        this._web_socket.closeAllConnections();
+    }
+    /*
+        把所有的客户端链接保存起来
+        方便统计，广播等
+    */
+    addClient(client_server) {
+        this._ws_clients[client_server.socketId] = client_server;
+    }
+    isOriginAllowed(origin) {
+        return true;
+    }
+    initWebSocket(wss) {
+        let server = null;
+        if (wss) {
+            console.log("wss:---");
+            let options = {
+                key: fs.readFileSync("ssl/ssl2.key"),
+                cert: fs.readFileSync("ssl/ssl2.crt"),
+                //passphrase:'1234'//如果秘钥文件有密码的话，用这个属性设置密码
+            };
+            server = https.createServer(options, (request, response) => {
+                Log_1.GLog.info((new Date()) + 'wss Received request for ' + request.url);
+                response.writeHead(404);
+                response.end();
+            });
+        }
+        else {
+            server = http.createServer((request, response) => {
+                Log_1.GLog.info((new Date()) + 'ws Received request for ' + request.url);
+                response.writeHead(404);
+                response.end();
+            });
+        }
+        server.listen(this._listen_port, this.onListenning.bind(this));
+        this._web_socket = new ws.server({
+            httpServer: server,
+            // You should not use autoAcceptConnections for production 
+            // applications, as it defeats all standard cross-origin protection 
+            // facilities built into the protocol and the browser.  You should 
+            // *always* verify the connection's origin and decide whether or not 
+            // to accept it. 
+            autoAcceptConnections: false
+        });
+        this._web_socket.on('request', this.onRequest.bind(this));
+        this._web_socket.on('close', this.onClose.bind(this));
+    }
+    onClose(connection, reason, desc) {
+    }
+    onListenning() {
+        let info = (new Date()) + "  Server " + this.fullServerName + " is listening on port " + this._listen_port;
+        Log_1.GLog.info(info);
+        console.log(info);
+    }
+    onRequest(req) {
+        if (this._is_closed) {
+            return;
+        }
+        let protocol = null;
+        if (req.requestedProtocols.length > 0) {
+            protocol = req.requestedProtocols[0];
+        }
+        let allowed = this.isOriginAllowed(req.origin);
+        if (!allowed) {
+            req.reject();
+            Log_1.GLog.info(' Connection from origin ' + req.origin + ' rejected.', true);
+            return;
+        }
+        try {
+            let conn = req.accept(this._accepted_protocol, req.origin);
+            if (!conn) {
+                Log_1.GLog.info(' protocol reject', true);
+                return;
+            }
+            Log_1.GLog.info((new Date()) + ' Connection accepted.');
+            let server_name = this._getServerNameByCookies(req.cookies);
+            this.createWebSocketObjectByProtocol(server_name, conn);
+        }
+        catch (e) {
+            Log_1.GLog.info(' protocol reject', true);
+        }
+    }
+    createWebSocketObjectByProtocol(server_name, _ws) {
+        server_name = server_name || "default";
+        let cls = this._name_vs_class[server_name];
+        if (!cls) {
+            Log_1.GLog.error("(createWebSocketObjectByProtocol in server(" + this.name + "))no this websocket handle class=" + server_name);
+            return null;
+        }
+        let ws_server = (new cls(this));
+        this.addClient(ws_server);
+        ws_server.onConnect(_ws);
+        return ws_server;
+    }
+    _getServerNameByCookies(cookies) {
+        let server_name = "";
+        if (!cookies) {
+            return server_name;
+        }
+        for (let index in cookies) {
+            let cookie = cookies[index];
+            if (cookie.name == "server") {
+                server_name = cookie.value;
+                break;
+            }
+        }
+        return server_name;
+    }
+}
+exports.ISocketServer = ISocketServer;

package/dist/lib/SocketServer/IWebSocket.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IWebSocket = void 0;
+const Log_1 = require("../Logic/Log");
+const ProtoFactory_1 = require("./ProtoFilter/ProtoFactory");
+const IProtoFilter_1 = require("./ProtoFilter/IProtoFilter");
+const Core_1 = require("../Core/Core");
+const FrameworkConfig_1 = require("../Config/FrameworkConfig");
+const _ = require("underscore");
+let WebSocketIdMgr = {
+    id: _.random(0, 99999999),
+    getNewID() {
+        return this.id++;
+    },
+};
+class IWebSocket {
+    _await = false;
+    get await() {
+        return this._await;
+    }
+    _debug_msg = false;
+    get debug_msg() {
+        return this._debug_msg;
+    }
+    set debug_msg(value) {
+        this._debug_msg = value;
+    }
+    _socket_id = 0;
+    get socketId() {
+        return this._socket_id;
+    }
+    _tipKey = "";
+    get tipKey() {
+        return this._tipKey;
+    }
+    _ws = null;
+    _protoType = IProtoFilter_1.EProtoType.Json;
+    _protoFilter = null;
+    _protoPath = "";
+    _ip = null;
+    get remoteHost() {
+        if (!this._ip) {
+            this._ip = this._ws.remoteAddress;
+            this._ip = this._ip.substring(this._ip.lastIndexOf(":") + 1);
+        }
+        return this._ip;
+    }
+    get connected() {
+        if (this._ws
+            && this._ws.connected == true) {
+            return true;
+        }
+        return false;
+    }
+    constructor(protoType = IProtoFilter_1.EProtoType.Json, protoPath = "") {
+        this._debug_msg = FrameworkConfig_1.GFCfg.debug_msg;
+        this._socket_id = WebSocketIdMgr.getNewID();
+        this._protoType = protoType;
+        this._protoPath = protoPath;
+    }
+    getNewMsg(cmd, errcode) {
+        let msg = {
+            cmd: cmd,
+            errcode: errcode,
+            servertime: new Date().getTime()
+        };
+        return msg;
+    }
+    receive_heartbeat(jsonData) {
+        this.send_heartbeat();
+    }
+    send_heartbeat() {
+        let msg = this.getNewMsg("heartbeat");
+        this.send(msg);
+    }
+    onConnect(_ws) {
+        this._ws = _ws;
+        if (!this._protoFilter) {
+            this._protoFilter = ProtoFactory_1.GProtoFactory.createFilter(this._protoType);
+            this._protoFilter.init(this._protoPath);
+        }
+        this._ws.on("message", this.onMessage.bind(this));
+        this._ws.on("error", this.onError.bind(this));
+        this._ws.on("close", this.onClose.bind(this));
+        this.onOpen();
+    }
+    _msgs = [];
+    onMessage(message) {
+        try {
+            let msg = this._onDecode(message);
+            if (this._await) {
+                this._msgs.push(msg);
+                if (!this._run_await) {
+                    this._awaitMessages();
+                }
+            }
+            else {
+                this._onMessage(msg);
+            }
+        }
+        catch (e) {
+            Log_1.GLog.error('Received Message Handle Error: ' + e);
+        }
+    }
+    _onDecode(message, ...params) {
+        let msg = null;
+        if (message.type === 'utf8') {
+            msg = this._protoFilter.decode(message.utf8Data, ...params);
+        }
+        else if (message.type === 'binary') {
+            msg = this._protoFilter.decode(message.binaryData, ...params);
+        }
+        return msg;
+    }
+    _onEncode(data, ...params) {
+        let msg = this._protoFilter.encode(data, ...params);
+        return msg;
+    }
+    _run_await = false;
+    async _awaitMessages() {
+        this._run_await = true;
+        while (this._msgs.length > 0) {
+            let msg = this._msgs.shift();
+            await this._onMessage(msg);
+        }
+        this._run_await = false;
+    }
+    /**
+     * 过滤消息，每个消息处理之前调用
+     * @param jsonData
+     * @returns
+     */
+    filterMsg(jsonData) {
+        if (this._debug_msg
+            && jsonData
+            && jsonData.cmd != "heartbeat") {
+            Log_1.GLog.info(this.tipKey + "  receive:--------", true);
+            Log_1.GLog.info(jsonData, true);
+        }
+        if (!jsonData.cmd || jsonData.cmd == "") {
+            Log_1.GLog.error('Received Message warning: no cmd param,data=');
+            Log_1.GLog.error(jsonData);
+            return false;
+        }
+        return true;
+    }
+    async _onMessage(data) {
+        let jsonData = data;
+        let ret = this.filterMsg(jsonData);
+        if (!ret) {
+            return;
+        }
+        else if (!this["receive_" + jsonData.cmd]) {
+            if (this["receive_other_all"]) {
+                try {
+                    await this["receive_other_all"](jsonData); //默认支持其他所有处理消息
+                }
+                catch (e) {
+                    if (e && e.stack) {
+                        Log_1.GLog.error(e.stack);
+                    }
+                    else {
+                        Log_1.GLog.error(e + "  msg:data=" + JSON.stringify(jsonData));
+                    }
+                }
+            }
+            else {
+                Log_1.GLog.error('Received Message warning: no cmd handle,cmd=' + jsonData.cmd);
+            }
+        }
+        else {
+            try {
+                await this["receive_" + jsonData.cmd](jsonData);
+            }
+            catch (e) {
+                if (e && e.stack) {
+                    Log_1.GLog.error("error msg:data=" + JSON.stringify(jsonData) + "\n" + e.stack);
+                }
+                else {
+                    Log_1.GLog.error(e + "  msg:data=" + JSON.stringify(jsonData));
+                }
+            }
+        }
+    }
+    onOpen(e) {
+    }
+    onError(e) {
+        Log_1.GLog.info("onError:" + e.message);
+    }
+    onClose(reasonCode, description) {
+        Log_1.GLog.info("onClose resonCode=" + reasonCode + "  des=" + description);
+    }
+    send(data) {
+        if (!this.connected) {
+            return;
+        }
+        if (!data) {
+            Log_1.GLog.error("Send Message warning:null data!");
+            return;
+        }
+        if (this._debug_msg
+            && data.cmd != "heartbeat") {
+            Log_1.GLog.info(this.tipKey + "  send:-----------------------------------", true);
+            Log_1.GLog.info(data, true);
+        }
+        let msg = this._onEncode(data);
+        this._ws.send(msg);
+    }
+    close() {
+        this._ws.close();
+    }
+    getServerNameFromCmd(cmd) {
+        if (!cmd || !Core_1.core.isString(cmd)) {
+            return null;
+        }
+        let index = cmd.indexOf("_");
+        if (index <= 0) {
+            return null;
+        }
+        return cmd.substring(0, index);
+    }
+}
+exports.IWebSocket = IWebSocket;

package/dist/lib/SocketServer/ProtoFilter/GoogleProtoFilter.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProtoFilter = void 0;
+const Log_1 = require("../../Logic/Log");
+const protobufjs = require("protobufjs");
+class GoogleProtoFilter {
+    _root = new protobufjs.Root();
+    _inited = false;
+    init(path) {
+        if (this._inited) {
+            return;
+        }
+        this._inited = true;
+        try {
+            this._root.loadSync(path, { keepCase: true });
+        }
+        catch (e) {
+            Log_1.GLog.error(e);
+            return false;
+        }
+        return true;
+    }
+    encode(data, root) {
+        let msg = { cmd: data.cmd };
+        msg[msg.cmd] = data;
+        msg[msg.cmd].cmd = undefined;
+        msg["errcode"] = data.errcode;
+        msg["tip"] = data.tip;
+        data.errcode = undefined;
+        delete data.errcode;
+        delete msg[msg.cmd].cmd;
+        let body = this._root.lookupType(root);
+        var errMsg = body.verify(msg);
+        if (errMsg)
+            throw Error(errMsg);
+        var msgBody = body.create(msg);
+        var bufferBody = body.encode(msgBody).finish();
+        return bufferBody;
+    }
+    decode(data, root) {
+        let body = this._root.lookupType(root);
+        if (!body) {
+            Log_1.GLog.info("proto body not in proto(!" + root + ")");
+            return null;
+        }
+        let msgBody = body.decode(data);
+        if (!msgBody) {
+            Log_1.GLog.info("proto body decode wrong!");
+            return null;
+        }
+        let objBody = body.toObject(msgBody);
+        let obj = objBody[objBody.cmd];
+        obj.cmd = objBody.cmd;
+        return obj;
+    }
+}
+exports.GoogleProtoFilter = GoogleProtoFilter;

package/dist/lib/SocketServer/ProtoFilter/IProtoFilter.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EProtoType = void 0;
+var EProtoType;
+(function (EProtoType) {
+    EProtoType[EProtoType["Json"] = 1] = "Json";
+    EProtoType[EProtoType["GoogleProtoBuffer"] = 2] = "GoogleProtoBuffer";
+})(EProtoType = exports.EProtoType || (exports.EProtoType = {}));

package/dist/lib/SocketServer/ProtoFilter/JsonProtoFilter.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonProtoFilter = void 0;
+const Core_1 = require("../../Core/Core");
+const Log_1 = require("../../Logic/Log");
+class JsonProtoFilter {
+    init(path) {
+        return true;
+    }
+    encode(data) {
+        if (!Core_1.core.isString(data)) {
+            data = JSON.stringify(data);
+        }
+        return data;
+    }
+    decode(data) {
+        try {
+            if (Core_1.core.isString(data)) {
+                data = JSON.parse(data);
+            }
+        }
+        catch (e) {
+            Log_1.GLog.error("decode json data Failed-----data=" + data);
+            return;
+        }
+        return data;
+    }
+}
+exports.JsonProtoFilter = JsonProtoFilter;

package/dist/lib/SocketServer/ProtoFilter/ProtoFactory.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GProtoFactory = void 0;
+const GoogleProtoFilter_1 = require("./GoogleProtoFilter");
+const JsonProtoFilter_1 = require("./JsonProtoFilter");
+const IProtoFilter_1 = require("./IProtoFilter");
+exports.GProtoFactory = null;
+class ProtoFactory {
+    _filters = new Map();
+    createFilter(type) {
+        let filter = this._filters.get(type);
+        if (filter) {
+            return filter;
+        }
+        switch (type) {
+            case IProtoFilter_1.EProtoType.GoogleProtoBuffer:
+                {
+                    filter = new GoogleProtoFilter_1.GoogleProtoFilter();
+                    break;
+                }
+            default:
+                {
+                    filter = new JsonProtoFilter_1.JsonProtoFilter();
+                    break;
+                }
+        }
+        this._filters.set(type, filter);
+        return filter;
+    }
+}
+exports.GProtoFactory = new ProtoFactory();