cgserver 11.2.8 → 12.0.0

package/dist/lib/Framework/Server/WebServer/Engine/Request.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+const url_1 = require("url");
+const Core_1 = require("../../../Core/Core");
+const Log_1 = require("../../../Logic/Log");
+class Request {
+    _req = null;
+    get baseReq() {
+        return this._req;
+    }
+    _cfg = null;
+    _post_cb = null;
+    set onPost(value) {
+        this._post_cb = value;
+    }
+    _module = "";
+    get module() {
+        return this._module;
+    }
+    _controller = "";
+    get controller() {
+        return this._controller;
+    }
+    _action = "";
+    get action() {
+        return this._action;
+    }
+    _suffix = "";
+    get suffix() {
+        return this._suffix;
+    }
+    _file_url = null;
+    get fileUrl() {
+        return this._file_url;
+    }
+    _params = {};
+    get params() {
+        var body = (this._req.query || {});
+        for (let k in body) {
+            var v = body[k];
+            if (!Core_1.core.isString(v)) {
+                continue;
+            }
+            if (parseInt(v) == v) {
+                body[k] = parseInt(v);
+            }
+            else if (parseFloat(v) == v) {
+                body[k] == parseFloat(v);
+            }
+        }
+        return body;
+    }
+    /**
+     * 原始body字符串
+     */
+    get rawBody() {
+        if (!this._req) {
+            return "";
+        }
+        return this._req["rawBody"] || "";
+    }
+    get postData() {
+        var body = this._req.body || {};
+        if (this._req.headers["content-type"] == "application/x-www-form-urlencoded") {
+            for (let k in body) {
+                body = k;
+                break;
+            }
+        }
+        if (Core_1.core.isString(body)) {
+            try {
+                body = JSON.parse(body);
+            }
+            catch (e) {
+                Log_1.gLog.error("post data--" + body + "--parse error");
+                body = {};
+            }
+        }
+        return body;
+    }
+    get url() {
+        return this._req.url;
+    }
+    get root() {
+        let root = this._req.headers.host;
+        if (root != "") {
+            root = this._req.protocol + "://" + root;
+        }
+        return root;
+    }
+    get method() {
+        return this._req.method;
+    }
+    get headers() {
+        return this._req.headers;
+    }
+    get remoteHost() {
+        let ips = this._req.headers['x-forwarded-for'];
+        let ip = "";
+        if (Core_1.core.isArray(ips)) {
+            ip = ips[0];
+        }
+        else {
+            ip = ips;
+        }
+        ip = ip ||
+            this._req.socket.remoteAddress ||
+            this._req.ip || "";
+        ip = ip.replace("::ffff:", "");
+        return ip;
+    }
+    constructor(req, cfg) {
+        this._cfg = cfg;
+        this._req = req;
+        this._init();
+    }
+    getCookie(key) {
+        let cookie_key = this._cfg.cookie.prefix + key;
+        if (!this._req.cookies) {
+            return null;
+        }
+        return this._req.cookies[cookie_key];
+    }
+    _init() {
+        let path = this._req.url;
+        //服务器根目录路径写法，链接转换
+        let _i = path.lastIndexOf("~");
+        if (_i >= 0) {
+            path = path.substr(_i + 1);
+        }
+        //处理参数
+        this._parseParams(path);
+    }
+    _addListener(event, listener) {
+        this._req.addListener(event, listener);
+    }
+    _parseParams(path) {
+        this._module = this._cfg.routs.onlyModule || this._cfg.routs.defaults.module;
+        this._controller = this._cfg.routs.defaults.controller;
+        this._action = this._cfg.routs.defaults.action;
+        this._suffix = null;
+        this._file_url = null;
+        this._params = {};
+        if (path == "/") {
+            return;
+        }
+        let firstQuoteIndex = path.indexOf("?");
+        let preQuoteStr = path;
+        if (firstQuoteIndex > 0) {
+            preQuoteStr = path.substring(0, firstQuoteIndex);
+        }
+        let lastDotIndex = preQuoteStr.lastIndexOf(".");
+        if (lastDotIndex > 0) {
+            let dotStr = preQuoteStr.substring(lastDotIndex + 1);
+            this._suffix = dotStr;
+            this._file_url = preQuoteStr;
+            return;
+        }
+        let quote_index = path.indexOf("?");
+        if (quote_index >= 0) {
+            let url = new url_1.URL(path);
+            url.searchParams.forEach((value, name, searchParams) => {
+                this._params[name] = value;
+            });
+            path = path.substring(0, quote_index);
+        }
+        let params = path.split("/");
+        let default_module = false;
+        if (this._cfg.routs.onlyModule) {
+            default_module = true;
+        }
+        if (params.length > 1 && params[1].length > 0) {
+            /**
+             * 如果是only模式，那么就不支持controller和module相同，
+             * 如果相同则认为是模块名，这样就可以同时支持，带模块的路径模式和非带模块的路径模式了
+             */
+            if (default_module
+                && params[1].toLowerCase() == this._cfg.routs.onlyModule.toLowerCase()) {
+                default_module = false;
+            }
+            if (default_module) {
+                this._controller = params[1];
+            }
+            else {
+                this._module = params[1];
+            }
+        }
+        if (params.length > 2 && params[2].length > 0) {
+            if (default_module) {
+                this._action = params[2];
+            }
+            else {
+                this._controller = params[2];
+            }
+        }
+        if (params.length > 3
+            && params[3].length > 0
+            && !default_module) {
+            this._action = params[3];
+        }
+        this._params = this._params || {};
+        return;
+    }
+    getDebugInfo() {
+        let debuginfo = {
+            module: this._module,
+            controller: this._controller,
+            action: this._action,
+            suffix: this._suffix,
+            file_url: this._file_url,
+            params: this._params,
+            post: this.postData,
+            method: this._req.method.toLowerCase()
+        };
+        return debuginfo;
+    }
+    debugInfo(force = false) {
+        if (!this._cfg.debug && !force) {
+            return;
+        }
+        let debuginfo = this.getDebugInfo();
+        Log_1.gLog.info(debuginfo);
+    }
+}
+exports.Request = Request;

package/dist/lib/Framework/Server/WebServer/Engine/Response.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const fs = require("fs");
+const mime = require("mime");
+const Log_1 = require("../../../Logic/Log");
+class Response {
+    _res = null;
+    _cookie_prefix = "";
+    _cfg = null;
+    debug = false;
+    get baseRes() {
+        return this._res;
+    }
+    constructor(res, cfg) {
+        this._cfg = cfg;
+        this.debug = this._cfg.debug || false;
+        this._res = res;
+        this._cookie_prefix = this._cfg.cookie.prefix;
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param time 秒
+     */
+    setCookie(key, value, time) {
+        key = this._cookie_prefix + key;
+        if (time) {
+            this._res.cookie(key, value, { maxAge: time * 1000, httpOnly: true });
+        }
+        else {
+            this._res.cookie(key, value, { httpOnly: true });
+        }
+    }
+    clearCookie(key) {
+        this.setCookie(key, "", -1000);
+    }
+    redirect(path) {
+        this._res.writeHead(302, { 'Location': path });
+        this._res.end();
+    }
+    render(data) {
+        return this._res.send(data);
+    }
+    renderJson(data) {
+        this.debugInfo(data);
+        return this._res.json(data);
+    }
+    sendStatus(status) {
+        this.debugInfo(status);
+        this._res.sendStatus(status);
+    }
+    renderHtml(html) {
+        return this._res.send(html || "");
+    }
+    renderFile(fullPath) {
+        this._res.sendFile(fullPath);
+    }
+    downloadFile(fullPath) {
+        let fileName = "";
+        let quote_index = fullPath.indexOf("/");
+        if (quote_index > 0) {
+            fileName = fullPath.substring(quote_index + 1);
+        }
+        fs.stat(fullPath, (err, stats) => {
+            if (!stats || stats.isDirectory()) {
+                return this.sendStatus(404);
+            }
+            let size = stats.size;
+            var f = fs.createReadStream(fullPath);
+            this._res.writeHead(200, {
+                'Content-Type': mime.getType(fullPath) || 'application/octet-stream',
+                'Content-Disposition': 'attachment; filename=' + fileName,
+                'Content-Length': size
+            });
+            f.pipe(this._res);
+        });
+    }
+    debugInfo(data) {
+        if (!this.debug) {
+            return;
+        }
+        Log_1.gLog.info(data);
+    }
+}
+exports.Response = Response;

package/dist/lib/Framework/Server/WebServer/IWebServer.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IWebServer = void 0;
+const Engine_1 = require("./Engine/Engine");
+const RazorJs_1 = require("./Engine/RazorJs");
+const cgserver_1 = require("../../cgserver");
+const EventTool_1 = require("../../Logic/EventTool");
+const Log_1 = require("../../Logic/Log");
+const IServerConfig_1 = require("../../Config/IServerConfig");
+//实现对controller的手动注册
+class IWebServer {
+    _engine = null;
+    /**
+     * 启动服务器
+     * @param server_index 这个是服务器的配置index
+     */
+    async start(cfg, dbcfg) {
+        cgserver_1.gCgServer.addWebServer(this);
+        if (!cfg) {
+            Log_1.gLog.error("webserver 配置不存在，启动服务器失败");
+            return false;
+        }
+        if (!dbcfg && IServerConfig_1.gServerCfg) {
+            dbcfg = IServerConfig_1.gServerCfg.db;
+        }
+        if (dbcfg) {
+            await cgserver_1.gCgServer.initDb(dbcfg);
+        }
+        //初始化web引擎
+        this._engine = new Engine_1.Engine(cfg, new RazorJs_1.RazorJs());
+        this._engine.start();
+        this._registerController();
+        this._registerRouter();
+        EventTool_1.gEventTool.emit("web_server_init_done");
+        return true;
+    }
+    pause() {
+        this._engine.pause();
+    }
+    resume() {
+        this._engine.resume();
+    }
+    /**
+     * 注册控制器
+     * eg:GControllerMgr.registerController("Admin","System",SystemController)
+     */
+    _registerController() {
+    }
+    /**
+     * 注册路由
+     */
+    _registerRouter() {
+    }
+}
+exports.IWebServer = IWebServer;

package/dist/lib/Framework/Server/WebSocketServer/IClientWebSocket.js

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

package/dist/lib/Framework/Server/WebSocketServer/IRpc.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRpc = exports.RpcMsg = void 0;
+const IWebSocket_1 = require("./IWebSocket");
+class RpcMsg extends IWebSocket_1.BaseMsg {
+    __rpcid = "";
+    __return = false;
+    /**
+      * 发送者分组
+      */
+    from_group = "";
+    /**
+     * 发送者分组下的某个具体对象id
+     */
+    from_id = "";
+    /**
+     * 必填，目的组
+     */
+    to_group = "";
+    /**
+     * 目的分组下的某个具体对象id
+     */
+    to_id = "";
+    /**
+     * 监听的对象，比如，发送给push服务器的，监听了10086的服务器listem="10086",listem,也可以理解为子group
+     */
+    listen = "";
+    /**
+     * 消息携带的数据
+     */
+    data = null;
+}
+exports.RpcMsg = RpcMsg;
+class IRpc {
+}
+exports.IRpc = IRpc;

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRpcClientWebSocket = void 0;
+const IClientWebSocket_1 = require("./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 = super.getNewMsg(cmd, errcode);
+        msg.__rpcid = this._genId(cmd);
+        msg.from_group = this._group;
+        msg.from_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.from_group = req_msg.to_group;
+        ret_msg.from_id = this._id;
+        ret_msg.to_group = req_msg.from_group;
+        ret_msg.to_id = req_msg.from_id;
+        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);
+        }
+        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);
+            super.send(msg);
+        });
+    }
+    receive_init(req_msg) {
+        if (req_msg.__rpcid) {
+            req_msg.__return = true;
+        }
+        if (!req_msg.from_group) {
+            let ret_msg = this.toRetMsg(req_msg, req_msg.data, { id: 10004, des: "初始化消息必须带有identity" });
+            this.send(ret_msg);
+            return;
+        }
+        this._group = req_msg.from_group;
+        this._id = req_msg.from_id;
+        let ret_msg = this.toRetMsg(req_msg, null);
+        this.send(ret_msg);
+    }
+    receive_listen(req_msg) {
+        if (req_msg.__rpcid) {
+            req_msg.__return = true;
+        }
+        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[]" });
+            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);
+        this.send(ret_msg);
+    }
+    receive_unlisten(req_msg) {
+        if (req_msg.__rpcid) {
+            req_msg.__return = true;
+        }
+        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[]" });
+            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);
+        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);
+    }
+}
+exports.IRpcClientWebSocket = IRpcClientWebSocket;

package/dist/lib/Framework/Server/WebSocketServer/IRpcServerWebSocket.js

@@ -0,0 +1,82 @@
+"use strict";
+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");
+class IRpcServerWebSocket extends IServerWebSocket_1.IServerWebSocket {
+    /**
+     * 自己的身份
+     */
+    _group = "";
+    _id = "";
+    //超时时间
+    _timeout = 3000;
+    constructor(group, id, timeout = 3000) {
+        super();
+        this._group = group;
+        this._id = id;
+        this._timeout = timeout || 3000;
+    }
+    _genId(pre = "") {
+        return pre + "_" + Date.now() % 10000000000 + "_" + _.uniqueId() + _.random(9999999);
+    }
+    getNewMsg(cmd, errcode) {
+        let msg = super.getNewMsg(cmd, errcode);
+        msg.__rpcid = this._genId(cmd);
+        msg.from_group = this._group;
+        msg.from_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.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;
+        return ret_msg;
+    }
+    async callRemote(msg) {
+        if (!msg) {
+            Log_1.gLog.error("send null msg!");
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            let handler = null;
+            let func = (retRpcMsg) => {
+                if (handler) {
+                    clearTimeout(handler);
+                    handler = null;
+                }
+                resolve(retRpcMsg);
+            };
+            handler = setTimeout(() => {
+                EventTool_1.gEventTool.off(msg.__rpcid, func);
+                let error_msg = this.getNewMsg(msg.cmd, { id: 10086, des: "timeout" });
+                resolve(error_msg);
+            }, this._timeout);
+            EventTool_1.gEventTool.once(msg.__rpcid, func);
+            super.send(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);
+    }
+}
+exports.IRpcServerWebSocket = IRpcServerWebSocket;