cgserver 11.2.9 → 12.0.1

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/{ThirdParty → Server/RpcWebSocketServer}/CgMq.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CgMq = exports.RpcConfig = void 0;
-const Core_1 = require("../Core/Core");
-const IRpcServerWebSocket_1 = require("../SocketServer/IRpcServerWebSocket");
-const Log_1 = require("../Logic/Log");
+const Core_1 = require("../../Core/Core");
+const Log_1 = require("../../Logic/Log");
+const IRpcServerWebSocket_1 = require("./IRpcServerWebSocket");
 class CgMqServerWebsocket extends IRpcServerWebSocket_1.IRpcServerWebSocket {
     _cgmq = null;
     _listens = {};
@@ -52,18 +52,23 @@ class CgMqServerWebsocket extends IRpcServerWebSocket_1.IRpcServerWebSocket {
         return jsonData;
     }
     //把消息发送给rpc服务器，目的是调用远程函数
-    async push(to_group, data, to_id = "", listen = "") {
+    async push(to_group, data, to_id = "", listen = "", is_mq = false) {
         let msg = this.getNewMsg("msg");
         msg.to_group = to_group;
         msg.to_id = to_id;
         msg.data = data;
         msg.listen = listen;
+        msg.__is_mq = is_mq;
         let ret_rpcmsg = await this.callRemote(msg);
         return ret_rpcmsg;
     }
     //收到来自远程的调用消息
     async receive_msg(req_msg) {
         let data = await this._cgmq.onMsg(req_msg);
+        if (req_msg.__is_mq) {
+            //mq消息不需要回复
+            return;
+        }
         let ret_msg = this.toRetMsg(req_msg, data);
         this.send(ret_msg);
     }
@@ -146,13 +151,13 @@ class CgMq {
             }
         });
     }
-    async callRemote(group, to_id, listen, func_name, ...args) {
+    async callRemote(group, to_id, listen, func_name, is_mq = false, ...args) {
         let time = Date.now();
         let data = {
             cmd: func_name,
             args: args
         };
-        let ret_rpcmsg = await this._ws.push(group, data, to_id, listen);
+        let ret_rpcmsg = await this._ws.push(group, data, to_id, listen, is_mq);
         if (this._ws.debug_msg) {
             Log_1.gLog.info("[" + (Date.now() - time) + "ms] callRemote:" + group + "-" + func_name + "-" + listen);
         }

package/dist/lib/Framework/{SocketServer → Server/RpcWebSocketServer}/IRpc.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IRpc = exports.RpcMsg = void 0;
-const IWebSocket_1 = require("./IWebSocket");
+const IWebSocket_1 = require("../WebSocketServer/IWebSocket");
 class RpcMsg extends IWebSocket_1.BaseMsg {
     __rpcid = "";
     __return = false;
+    //mq消息不需要回复
+    __is_mq = false;
     /**
       * 发送者分组
       */
@@ -22,7 +24,7 @@ class RpcMsg extends IWebSocket_1.BaseMsg {
      */
     to_id = "";
     /**
-     * 监听的对象，比如，发送给push服务器的，监听了10086的服务器listem="10086",listem,也可以理解为子group
+     * 监听的对象，比如，发送给push服务器的，监听了10086的服务器listen="10086",listen,也可以理解为子group
      */
     listen = "";
     /**

package/dist/lib/Framework/Server/RpcWebSocketServer/IRpcClientWebSocket.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRpcClientWebSocket = void 0;
+const IRpc_1 = require("./IRpc");
+const IClientWebSocket_1 = require("../WebSocketServer/IClientWebSocket");
+const Core_1 = require("../../Core/Core");
+const Log_1 = require("../../Logic/Log");
+const EventTool_1 = require("../../Logic/EventTool");
+class IRpcClientWebSocket extends IClientWebSocket_1.IClientWebSocket {
+    /**
+     * 自己的身份
+     */
+    _group = "";
+    _id = "";
+    //超时时间
+    _timeout = 3000;
+    _listens = {};
+    isListenning(listen) {
+        if (!listen) {
+            return true;
+        }
+        return !!this._listens[listen];
+    }
+    _genId(pre = "") {
+        return pre + "_" + Core_1.core.getUuid();
+    }
+    getNewMsg(cmd, errcode) {
+        let msg = new IRpc_1.RpcMsg(cmd, errcode);
+        msg.__rpcid = this._genId(cmd);
+        msg.__return = false;
+        //mq消息不需要回复
+        msg.__is_mq = false;
+        msg.from_group = this._group;
+        msg.from_id = this._id;
+        msg.to_group = "";
+        msg.to_id = "";
+        msg.listen = "";
+        return msg;
+    }
+    toRetMsg(req_msg, data, errcode) {
+        let ret_msg = new IRpc_1.RpcMsg(req_msg.cmd, errcode);
+        //唯一标识必须保持一致
+        ret_msg.__rpcid = req_msg.__rpcid;
+        ret_msg.__return = true;
+        ret_msg.__is_mq = req_msg.__is_mq;
+        ret_msg.from_group = this._group;
+        ret_msg.from_id = this._id;
+        ret_msg.to_group = req_msg.from_group;
+        ret_msg.to_id = req_msg.from_id;
+        ret_msg.data = data;
+        return ret_msg;
+    }
+    async callRemote(msg) {
+        if (!msg) {
+            Log_1.gLog.error("send null msg!");
+            return;
+        }
+        if (!msg.__rpcid) {
+            msg.__rpcid = this._genId(msg.cmd);
+        }
+        if (msg.__is_mq) {
+            //mq消息不需要回复
+            this.send(msg);
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            let handler = null;
+            let func = (jsonData) => {
+                if (handler) {
+                    clearTimeout(handler);
+                    handler = null;
+                }
+                resolve(jsonData);
+            };
+            handler = setTimeout(() => {
+                EventTool_1.gEventTool.off(msg.__rpcid, func);
+                resolve({ errcode: { id: 10086, des: "timeout" } });
+            }, 3000);
+            EventTool_1.gEventTool.once(msg.__rpcid, func);
+            this.send(msg);
+        });
+    }
+    receive_init(req_msg) {
+        this._group = req_msg.from_group || "";
+        this._id = req_msg.from_id || "";
+        if (!req_msg.from_group) {
+            let ret_msg = this.toRetMsg(req_msg, req_msg.data, { id: 10004, des: "初始化消息必须带有identity" });
+            ret_msg.from_group = "cgrpc";
+            ret_msg.from_id = "";
+            this.send(ret_msg);
+            return;
+        }
+        let ret_msg = this.toRetMsg(req_msg, null);
+        ret_msg.from_group = "cgrpc";
+        ret_msg.from_id = "";
+        this.send(ret_msg);
+    }
+    receive_listen(req_msg) {
+        let data = req_msg.data;
+        if (!data || !Core_1.core.isArray(data)) {
+            let ret_msg = this.toRetMsg(req_msg, req_msg.data, { id: 10005, des: "listen data not correct must be string[]" });
+            ret_msg.from_group = "cgrpc";
+            ret_msg.from_id = "";
+            this.send(ret_msg);
+            return;
+        }
+        for (let i = 0; i < data.length; i++) {
+            let listen = data[i];
+            if (!listen) {
+                continue;
+            }
+            this._listens[listen] = true;
+        }
+        let ret_msg = this.toRetMsg(req_msg, null);
+        ret_msg.from_group = "cgrpc";
+        ret_msg.from_id = "";
+        this.send(ret_msg);
+    }
+    receive_unlisten(req_msg) {
+        let data = req_msg.data;
+        if (!data || !Core_1.core.isArray(data)) {
+            let ret_msg = this.toRetMsg(req_msg, req_msg.data, { id: 10005, des: "listen data not correct must be string[]" });
+            ret_msg.from_group = "cgrpc";
+            ret_msg.from_id = "";
+            this.send(ret_msg);
+            return;
+        }
+        for (let i = 0; i < data.length; i++) {
+            let listen = data[i];
+            if (!listen) {
+                continue;
+            }
+            this._listens[listen] = undefined;
+            delete this._listens[listen];
+        }
+        let ret_msg = this.toRetMsg(req_msg, null);
+        ret_msg.from_group = "cgrpc";
+        ret_msg.from_id = "";
+        this.send(ret_msg);
+    }
+    receive_other_all(msg) {
+        Log_1.gLog.error({ des: "no handle", msg });
+    }
+    async _onMessage(msg) {
+        if (msg.__return) {
+            let ret = this.filterMsg(msg);
+            if (!ret) {
+                return;
+            }
+            EventTool_1.gEventTool.emit(msg.__rpcid, msg);
+            return;
+        }
+        super._onMessage(msg);
+    }
+    constructor(server) {
+        super(server);
+        this._debug_msg = true;
+        this._group = "";
+        this._id = global.gCgServer.customprocessid;
+    }
+    getWsByGroup(group, listen) {
+        let wses = [];
+        if (!group) {
+            return wses;
+        }
+        let allClients = this.server.wsClients;
+        for (let key in allClients) {
+            let ct = allClients[key];
+            if (ct._group == group && ct.isListenning(listen)) {
+                wses.push(ct);
+            }
+        }
+        return wses;
+    }
+    getWsByGroupId(group, id) {
+        if (!group) {
+            return null;
+        }
+        let allClients = this.server.wsClients;
+        for (let key in allClients) {
+            let ct = allClients[key];
+            if (ct._group == group && ct._id == id) {
+                return ct;
+            }
+        }
+        return null;
+    }
+    async receive_msg(req_msg) {
+        if (!req_msg.__rpcid) {
+            let retMsg = this.getNewMsg("msg", { id: 10001, des: "非法rpc消息" });
+            this.send(retMsg);
+            return;
+        }
+        if (!req_msg.to_group) {
+            let ret_msg = this.toRetMsg(req_msg, req_msg.data, { id: 10002, des: "消息中必须附带接受方的身份to_group" });
+            this.send(ret_msg);
+            return;
+        }
+        let wses = [];
+        if (req_msg.to_id) {
+            let ws = this.getWsByGroupId(req_msg.to_group, req_msg.to_id);
+            wses.push(ws);
+        }
+        else {
+            wses = this.getWsByGroup(req_msg.to_group, req_msg.listen);
+        }
+        //发送给远程服务器的消息
+        if (wses.length == 0) {
+            req_msg.errcode = { id: 10004, des: "一个接收者都没找到" };
+            this.send(req_msg);
+            return;
+        }
+        let arets = [];
+        let rpc_id = req_msg.__rpcid;
+        let rpc_id_index = 0;
+        for (let key in wses) {
+            let ws = wses[key];
+            req_msg.__rpcid = rpc_id + "_" + rpc_id_index;
+            rpc_id_index++;
+            let ret = ws.callRemote(req_msg);
+            arets.push(ret);
+        }
+        if (req_msg.__is_mq) {
+            //mq消息不需要回复
+            return;
+        }
+        let rets = [];
+        let first_ret = null;
+        for (let key in arets) {
+            let ret = await arets[key];
+            rets.push(ret.data);
+            if (!first_ret) {
+                first_ret = ret;
+            }
+        }
+        //还原rpc_id
+        req_msg.__rpcid = rpc_id;
+        //回复给调用来源的服务器
+        let retMsg = this.toRetMsg(req_msg, rets);
+        if (first_ret) {
+            retMsg.from_group = req_msg.to_group;
+            retMsg.to_group = req_msg.from_group;
+            if (req_msg.to_id) {
+                retMsg.from_id = first_ret.from_id;
+            }
+            else {
+                retMsg.from_id = "";
+            }
+        }
+        this.send(retMsg);
+    }
+}
+exports.IRpcClientWebSocket = IRpcClientWebSocket;

package/dist/lib/Framework/{SocketServer → Server/RpcWebSocketServer}/IRpcServerWebSocket.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IRpcServerWebSocket = void 0;
 const _ = require("underscore");
-const IServerWebSocket_1 = require("./IServerWebSocket");
-const Log_1 = require("../Logic/Log");
-const EventTool_1 = require("../Logic/EventTool");
+const IRpc_1 = require("./IRpc");
+const Log_1 = require("../../Logic/Log");
+const EventTool_1 = require("../../Logic/EventTool");
+const IServerWebSocket_1 = require("../WebSocketServer/IServerWebSocket");
 class IRpcServerWebSocket extends IServerWebSocket_1.IServerWebSocket {
     /**
      * 自己的身份
@@ -23,28 +24,38 @@ class IRpcServerWebSocket extends IServerWebSocket_1.IServerWebSocket {
         return pre + "_" + Date.now() % 10000000000 + "_" + _.uniqueId() + _.random(9999999);
     }
     getNewMsg(cmd, errcode) {
-        let msg = super.getNewMsg(cmd, errcode);
+        let msg = new IRpc_1.RpcMsg(cmd, errcode);
         msg.__rpcid = this._genId(cmd);
+        msg.__return = false;
+        msg.__is_mq = false;
         msg.from_group = this._group;
         msg.from_id = this._id;
+        msg.to_group = this._group;
+        msg.to_id = this._id;
         return msg;
     }
     toRetMsg(req_msg, data, errcode) {
         let ret_msg = this.getNewMsg(req_msg.cmd, errcode);
         //唯一标识必须保持一致
-        ret_msg.__return = true;
         ret_msg.__rpcid = req_msg.__rpcid;
-        ret_msg.data = data;
+        ret_msg.__return = true;
+        ret_msg.__is_mq = req_msg.__is_mq;
         ret_msg.from_group = this._group;
         ret_msg.from_id = this._id;
         ret_msg.to_group = req_msg.from_group;
         ret_msg.to_id = req_msg.from_id;
+        ret_msg.data = data;
         return ret_msg;
     }
     async callRemote(msg) {
         if (!msg) {
             Log_1.gLog.error("send null msg!");
-            return;
+            return null;
+        }
+        if (msg.__is_mq) {
+            //mq消息不需要回复
+            this.send(msg);
+            return null;
         }
         return new Promise((resolve, reject) => {
             let handler = null;

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;