cgserver 11.2.8 → 12.0.0

package/README.md

@@ -1,3 +1,5 @@
+12.0.0
+1、增加socketserver
 11.2.5
 1、Engine 增加app接口
 11.2.2

package/dist/lib/Framework/Server/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/Framework/Server/ProtoFilter/IProtoFilter.js

@@ -0,0 +1,9 @@
+"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[EProtoType["Custom"] = 3] = "Custom";
+})(EProtoType = exports.EProtoType || (exports.EProtoType = {}));

package/dist/lib/Framework/Server/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/Framework/Server/ProtoFilter/ProtoFactory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gProtoFactory = exports.ProtoFactory = void 0;
+const GoogleProtoFilter_1 = require("./GoogleProtoFilter");
+const JsonProtoFilter_1 = require("./JsonProtoFilter");
+const IProtoFilter_1 = require("./IProtoFilter");
+class ProtoFactory {
+    _filters = new Map();
+    _type_filter_classes = new Map();
+    constructor() {
+        this.registerFilter(IProtoFilter_1.EProtoType.Json, JsonProtoFilter_1.JsonProtoFilter);
+        this.registerFilter(IProtoFilter_1.EProtoType.GoogleProtoBuffer, GoogleProtoFilter_1.GoogleProtoFilter);
+    }
+    registerFilter(type, proto_filter_class) {
+        this._type_filter_classes[type] = proto_filter_class;
+    }
+    createFilter(type) {
+        let filter = this._filters.get(type);
+        if (filter) {
+            return filter;
+        }
+        let proto_class = this._type_filter_classes[type];
+        if (proto_class) {
+            filter = new proto_class();
+        }
+        else {
+            //默认
+            filter = new JsonProtoFilter_1.JsonProtoFilter();
+        }
+        this._filters.set(type, filter);
+        return filter;
+    }
+}
+exports.ProtoFactory = ProtoFactory;
+exports.gProtoFactory = new ProtoFactory();

package/dist/lib/Framework/Server/SocketServer/IClientSocket.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IClientSocket = void 0;
+const Log_1 = require("../../Logic/Log");
+const ISocket_1 = require("./ISocket");
+const IProtoFilter_1 = require("../ProtoFilter/IProtoFilter");
+/**
+ * 服务器接收到的客户端的连接
+ * 客户端的session对象
+ */
+class IClientSocket extends ISocket_1.ISocket {
+    _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.removeServerSocketBySocketId(this._socket_id);
+    }
+    broadCast(data) {
+        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);
+        this._server.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.IClientSocket = IClientSocket;

package/dist/lib/Framework/Server/SocketServer/IServerSocket.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IServerSocket = void 0;
+const ISocket_1 = require("./ISocket");
+const ws = require("websocket");
+const IProtoFilter_1 = require("../ProtoFilter/IProtoFilter");
+const Log_1 = require("../../Logic/Log");
+/**
+ * 连接到服务器的websocket
+ * 默认自动重连
+ */
+class IServerSocket extends ISocket_1.ISocket {
+    _host = "";
+    /**
+     * 连接的服务器地址
+     */
+    get host() {
+        return this._host;
+    }
+    _port = -1;
+    /**
+     * 连接的服务器端口
+     */
+    get port() {
+        return this._port;
+    }
+    _requestedProtocols = null;
+    get requestedProtocols() {
+        return this._requestedProtocols;
+    }
+    _origin = null;
+    get origin() {
+        return this._origin;
+    }
+    _headers = null;
+    get headers() {
+        return this._headers;
+    }
+    _extraRequestOptions = null;
+    get extraRequestOptions() {
+        return this._extraRequestOptions;
+    }
+    _need_close = false;
+    constructor(protoType = IProtoFilter_1.EProtoType.Json, protoPath = "") {
+        super(protoType, protoPath);
+    }
+    connect(domain, port, requestedProtocols = null, origin = null, headers = null, extraRequestOptions = null) {
+        this._host = domain || this._host;
+        this._port = port || this._port;
+        this._requestedProtocols = requestedProtocols || this._requestedProtocols;
+        this._origin = origin || this._origin;
+        this._headers = headers || this._headers;
+        this._extraRequestOptions = extraRequestOptions || this._extraRequestOptions;
+        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", this.onConnect.bind(this));
+        _ws.on("connectFailed", this.onClose.bind(this));
+        _ws.connect(url, this._requestedProtocols, this._origin, this._headers, this._extraRequestOptions);
+    }
+    onOpen(e) {
+        super.onOpen(e);
+        Log_1.gLog.info(this._socket_id + ":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();
+                }
+            }, 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.IServerSocket = IServerSocket;

package/dist/lib/Framework/Server/SocketServer/ISocket.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISocket = exports.BaseMsg = void 0;
+const IProtoFilter_1 = require("../ProtoFilter/IProtoFilter");
+const Core_1 = require("../../Core/Core");
+const _ = require("underscore");
+const ProtoFactory_1 = require("../ProtoFilter/ProtoFactory");
+const SyncQueueTool_1 = require("../../Logic/SyncQueueTool");
+const Log_1 = require("../../Logic/Log");
+const PacketParser_1 = require("./PacketParser");
+class BaseMsg {
+    cmd;
+    errcode;
+    servertime = Date.now();
+    constructor(cmd, errcode) {
+        this.cmd = cmd;
+        this.errcode = errcode;
+    }
+}
+exports.BaseMsg = BaseMsg;
+class ISocket {
+    /**
+     * 是否同步消息
+     * 默认为true
+     */
+    _is_sync_msg = true;
+    get isSynMsg() {
+        return this._is_sync_msg;
+    }
+    _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;
+    }
+    _socket = null;
+    get socket() {
+        return this._socket;
+    }
+    _protoType = IProtoFilter_1.EProtoType.Json;
+    _protoFilter = null;
+    _protoPath = "";
+    _ip = null;
+    get remoteHost() {
+        if (!this._ip && this._socket) {
+            this._ip = this._socket.remoteAddress;
+            this._ip = this._ip.substring(this._ip.lastIndexOf(":") + 1);
+        }
+        return this._ip;
+    }
+    get connected() {
+        if (this._socket
+            && this._socket.readyState == "open") {
+            return true;
+        }
+        return false;
+    }
+    _nodebugmsgs = {
+        "heartbeat": true,
+        "ping": true
+    };
+    _packetParser;
+    constructor(protoType = IProtoFilter_1.EProtoType.Json, protoPath = "") {
+        this._socket_id = parseInt(_.uniqueId());
+        this._protoType = protoType;
+        this._protoPath = protoPath;
+        this._packetParser = new PacketParser_1.PacketParser();
+    }
+    getNewMsg(cmd, errcode) {
+        let msg = new BaseMsg(cmd, errcode);
+        return msg;
+    }
+    receive_heartbeat(jsonData) {
+        this.send_heartbeat();
+    }
+    send_heartbeat() {
+        let msg = this.getNewMsg("heartbeat");
+        this.send(msg);
+    }
+    onConnect(_socket) {
+        this._socket = _socket;
+        if (!this._protoFilter) {
+            this._protoFilter = ProtoFactory_1.gProtoFactory.createFilter(this._protoType);
+            this._protoFilter.init(this._protoPath);
+        }
+        this._socket.on("data", this._onData.bind(this));
+        this._socket.on("error", this.onError.bind(this));
+        this._socket.on("close", this.onClose.bind(this));
+        this.onOpen();
+    }
+    _onData(message) {
+        try {
+            this._packetParser.push(message);
+            let packet = this._packetParser.parse();
+            while (packet) {
+                this._onMessage(packet);
+                packet = this._packetParser.parse();
+            }
+        }
+        catch (e) {
+            Log_1.gLog.error(this.tipKey + ' Received Message Handle Error: ' + e);
+        }
+    }
+    onMessage(message) {
+        try {
+            let msg = this._onDecode(message);
+            if (this._is_sync_msg) {
+                SyncQueueTool_1.gSyncQueueTool.add(this._socket_id + "", this._onMessage, this, msg);
+            }
+            else {
+                this._onMessage(msg);
+            }
+        }
+        catch (e) {
+            Log_1.gLog.error(this.tipKey + ' Received Message Handle Error: ' + e);
+        }
+    }
+    _onDecode(message, ...params) {
+        return this._protoFilter.decode(message, ...params);
+    }
+    _onEncode(data, ...params) {
+        let msg = this._protoFilter.encode(data, ...params);
+        return msg;
+    }
+    /**
+     * 过滤消息，每个消息处理之前调用
+     * @param msg
+     * @returns
+     */
+    filterMsg(msg) {
+        if (!msg) {
+            Log_1.gLog.error({ tipKey: this.tipKey, action: "receive", error: "no cmd", msg });
+            return false;
+        }
+        if (this._debug_msg && !this._nodebugmsgs[msg.cmd]) {
+            Log_1.gLog.info({ tipKey: this.tipKey, action: "receive", msg });
+        }
+        if (!msg.cmd) {
+            Log_1.gLog.error({ tipKey: this.tipKey, action: "receive", error: "no cmd", msg });
+            return false;
+        }
+        return true;
+    }
+    async _onMessage(data) {
+        let time = Date.now();
+        let jsonData = data;
+        let func = this["receive_" + jsonData.cmd];
+        let ret = this.filterMsg(jsonData);
+        if (!ret) {
+            return;
+        }
+        else if (!func) {
+            let otherfunc = this["receive_other_all"];
+            if (otherfunc) {
+                await Core_1.core.safeCall(otherfunc, this, jsonData);
+            }
+            else {
+                Log_1.gLog.error(this.tipKey + ' Received Message warning: no cmd handle,cmd=' + jsonData.cmd);
+            }
+        }
+        else {
+            await Core_1.core.safeCall(func, this, jsonData);
+        }
+        if (this._debug_msg && !this._nodebugmsgs[jsonData.cmd]) {
+            Log_1.gLog.info("[" + (Date.now() - time) + "ms] " + jsonData.cmd);
+        }
+    }
+    onOpen(e) {
+    }
+    onError(e) {
+    }
+    onClose(reasonCode, description) {
+        Log_1.gLog.info(this.tipKey + " " + this._socket_id + ":onClose resonCode=" + reasonCode + "  des=" + description);
+    }
+    filterSendMsg(msg) {
+        if (!this.connected) {
+            return false;
+        }
+        if (!msg) {
+            Log_1.gLog.error(this.tipKey + " Send Message warning:null data!");
+            return false;
+        }
+        if (this._debug_msg && !this._nodebugmsgs[msg.cmd]) {
+            Log_1.gLog.info({ tipKey: this.tipKey, action: "send", msg });
+        }
+        return true;
+    }
+    send(msg) {
+        let ret = this.filterSendMsg(msg);
+        if (!ret) {
+            return;
+        }
+        let data = this._onEncode(msg);
+        this._socket.write(this._packetParser.pack(data));
+    }
+    /**
+     * Close the connection. A close frame will be sent to the remote peer indicating
+     * that we wish to close the connection, and we will then wait for up to
+     * `config.closeTimeout` milliseconds for an acknowledgment from the remote peer
+     * before terminating the underlying socket connection.
+     */
+    close(reasonCode, description) {
+        this._socket.end();
+    }
+    /**
+     * Send a close frame to the remote peer and immediately close the socket without
+     * waiting for a response. This should generally be used only in error conditions.
+     */
+    drop(reasonCode, description, skipCloseFrame) {
+        this._socket.destroy();
+    }
+}
+exports.ISocket = ISocket;

package/dist/lib/Framework/Server/SocketServer/ISocketServer.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISocketServer = void 0;
+const cgserver_1 = require("../../cgserver");
+const Log_1 = require("../../Logic/Log");
+const EventTool_1 = require("../../Logic/EventTool");
+const net = require("net");
+class ISocketServer {
+    _cfg = null;
+    //方便提示
+    get cfg() {
+        return this._cfg;
+    }
+    //服务器已被关闭
+    _is_runging = false;
+    get isrunging() {
+        return this._is_runging;
+    }
+    get name() {
+        return this._cfg.serverName;
+    }
+    //监听websocket
+    _listening_socket = null;
+    get listeningSocket() {
+        return this._listening_socket;
+    }
+    //来自于用户的链接
+    _ws_clients = {};
+    get listenPort() {
+        return this._cfg.port;
+    }
+    /**
+     * websocket can accepted protocol
+     */
+    _accepted_protocol = null;
+    //服务器管理相关
+    /*
+        item=servername:class
+    */
+    _cls = null;
+    registerSocketHandleClass(cls) {
+        this._cls = cls;
+    }
+    constructor(cfg) {
+        this._cfg = cfg;
+    }
+    removeServerSocketBySocketId(socketId) {
+        this._ws_clients[socketId] = null;
+        delete this._ws_clients[socketId];
+    }
+    async run() {
+        cgserver_1.gCgServer.addSocketServer(this);
+        if (this._cfg.db) {
+            await cgserver_1.gCgServer.initDb(this._cfg.db);
+        }
+        this.initSocket();
+    }
+    pause() {
+        if (!this._is_runging) {
+            Log_1.gLog.error("socketserver has paused:" + this._cfg.port);
+            return;
+        }
+        this._is_runging = false;
+        for (let key in this._ws_clients) {
+            this._ws_clients[key].close();
+        }
+        Log_1.gLog.info("socketserver paused:" + this._cfg.port);
+    }
+    resume() {
+        if (this._is_runging) {
+            Log_1.gLog.error("socketserver is running:" + this._cfg.port);
+            return;
+        }
+        this._is_runging = true;
+        Log_1.gLog.error("socketserver resumed:" + this._cfg.port);
+    }
+    /*
+        把所有的客户端链接保存起来
+        方便统计，广播等
+    */
+    addClient(ws_client) {
+        this._ws_clients[ws_client.socketId] = ws_client;
+    }
+    initSocket(wss) {
+        let server = net.createServer();
+        server.listen(this._cfg.port, this.onListenning.bind(this));
+        server.on("connection", this.onConnection.bind(this));
+        this._listening_socket.on('close', this.onClose.bind(this));
+    }
+    onClose() {
+    }
+    onListenning() {
+        this._is_runging = true;
+        EventTool_1.gEventTool.emit("socket_server_init_done");
+        let info = (new Date()) + "  Server " + this.name + " is listening on port " + this._cfg.port;
+        Log_1.gLog.info(info);
+    }
+    onConnection(socket) {
+        if (!this._is_runging) {
+            socket.end();
+            Log_1.gLog.error(' Connection rejected.');
+            return;
+        }
+        try {
+            Log_1.gLog.info((new Date()) + ' Connection accepted.');
+            this.createSocketObjectByProtocol(socket);
+        }
+        catch (e) {
+            Log_1.gLog.error(' protocol reject');
+        }
+    }
+    createSocketObjectByProtocol(socket) {
+        let cls = this._cls;
+        if (!cls) {
+            Log_1.gLog.error("(createSocketObjectByProtocol in server(" + this.name + "))no this socket handle class");
+            return null;
+        }
+        let s_client = (new cls(this));
+        this.addClient(s_client);
+        s_client.onConnect(socket);
+        return s_client;
+    }
+    /**
+     * 广播消息
+     * @param msg
+     */
+    broadCast(msg) {
+        for (var key in this._ws_clients) {
+            let ws = this._ws_clients[key];
+            ws.send(msg);
+        }
+    }
+    /**
+     * 获取任意客户端连接
+     * @returns
+     */
+    getAnyWebSocket() {
+        for (var key in this._ws_clients) {
+            return this._ws_clients[key];
+        }
+        return null;
+    }
+}
+exports.ISocketServer = ISocketServer;

package/dist/lib/Framework/Server/SocketServer/PacketParser.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketParser = void 0;
+class PacketParser {
+    buffer;
+    offset;
+    constructor() {
+        this.buffer = Buffer.alloc(0);
+        this.offset = 0;
+    }
+    push(chunk) {
+        const newBuffer = Buffer.alloc(this.buffer.length + chunk.length);
+        this.buffer.copy(newBuffer, 0);
+        chunk.copy(newBuffer, this.buffer.length);
+        this.buffer = newBuffer;
+    }
+    parse() {
+        if (this.buffer.length < 4)
+            return null;
+        // Read packet length (first 4 bytes)
+        const length = this.buffer.readUInt32BE(0);
+        if (this.buffer.length < length + 4)
+            return null;
+        // Extract packet
+        const packet = this.buffer.slice(4, length + 4);
+        // Remove parsed data from buffer
+        this.buffer = this.buffer.slice(length + 4);
+        return packet;
+    }
+    pack(data) {
+        const length = data.length;
+        const packet = Buffer.alloc(length + 4);
+        // Write length header
+        packet.writeUInt32BE(length, 0);
+        // Write data
+        data.copy(packet, 4);
+        return packet;
+    }
+}
+exports.PacketParser = PacketParser;