TS 聚合查询 读取MongoDB

对服务器节点的 [cpu, rem, cpuG] 等数据进行读取和管理操作。这类记录下用到的若干TS方法。
主要参考这里的  聚合查询语法。

 

/**
 * InfoManager1.ts
 * 
 * 对服务器节点的 [cpu, rem, cpuG] 等数据进行读取和管理操作
 * 
 * Author:henry
 * Date:20200508
 * 
 */

import * as DATA_TYPE_STRUCT from './dataTypeStruct'
import { Mongo } from "lib/ts-server/core/db"
import { _, sleep, now, newDate } from "lib/ts-utils/utils"

//"2020-05-05 13:35:13"
/**时间间隔 */
let TimeGap = {
    /**实时 数据，取最近 10 分钟 */
    ss: 1000 * 60 * 15,
    /**分钟 数据，取最近 0 分钟...最新需求是下架这个分钟功能 */
    m: 1000 * 60 * 60,
    /**小时 数据，取最近 1 小时 */
    h: 1000 * 60 * 60 * 1,
    /**天 数据，取最近 24 小时  */
    d: 1000 * 60 * 60 * 24
}



/**客户端点击某个节点，弹出了实时页面之后，new 一个 Machine 类 */
export class CInfoManagerMongo {
    private constructor() { }
    /**节点的若干新，用于丰富界面显示内容 */
    private static machineInfo = <DATA_TYPE_STRUCT.MachineInfo>{};
    private static reqDataNum = <DATA_TYPE_STRUCT.DataNumber>{};
    private static mongoInfo = <DATA_TYPE_STRUCT.MONGODB_INFO>{};

    /**实时、分钟、小时、天的数据 */
    private static machineData_ss = {};
    private static machineData_m = {};
    private static machineData_h = {};
    private static machineData_d = {};

    /**设置显示的数据条数 */
    private static serverNodeMachineInit() {
        this.reqDataNum.SS_number = 40;
        this.reqDataNum.M_number = 60;
        this.reqDataNum.H_number = 60;
        this.reqDataNum.D_number = 100;
    }

    /**设置当前服务器节点的 若干新（名称、ip等），客户端展示可能会用到 */
    private static setMachineInfo(info: DATA_TYPE_STRUCT.MachineInfo) {
        this.machineInfo.ip = "127.0.0.1";
        //TODO:待完成
    }

    /**设置连接的数据库信息 */
    private static async  setMongoInfo(nodeID: number) {
        let subName = _.dateString(_.now()); //server_usage-2020-05
        subName = subName.substring(0, 7);//摘取 年月
        this.mongoInfo.dbName = `$log.server_usage-${subName}`;
        this.mongoInfo.collection = "srv_" + `${nodeID}`;

        console.log(_.logger('INFO'), "setMongoInfo dbName:", this.mongoInfo.dbName, ",collection:", this.mongoInfo.collection);
        this.serverNodeMachineInit();
    }



    /**处理客户端的请求,cpu,rem, cpuG数据，数据在MongoDB */
    static async HandleClientReq(clientReqDataParmas: DATA_TYPE_STRUCT.ClientReqDataParmas) {
        /**设置表明和数据库名...后面用到数据库查询的时候，会用到这里的变量。主要是做一个数据的临时存储*/
        await this.setMongoInfo(clientReqDataParmas.nodeID);
        if (DATA_TYPE_STRUCT.DataType.SS == clientReqDataParmas.dataType) {
            return await this.searchMachineDataSS(clientReqDataParmas);
        }
        else if (DATA_TYPE_STRUCT.DataType.M == clientReqDataParmas.dataType) {
            return await this.searchMachineDataM(clientReqDataParmas);
        }
        else if (DATA_TYPE_STRUCT.DataType.H == clientReqDataParmas.dataType) {
            return await this.searchMachineDataH(clientReqDataParmas);
        }
        else if (DATA_TYPE_STRUCT.DataType.D == clientReqDataParmas.dataType) {
            return await this.searchMachineDataD(clientReqDataParmas);
        }
        else {
            console.error(_.logger('ERROR'), `HandleClientReq() some error..`, clientReqDataParmas)
            return null;
        }
    }



    /**实时 数据...服务器配置里面控制请求条数*/
    /**
     * db:数据库名称
     * collection:表的名称
     * reqState：第一次请求还是非第一次请求。
     * 请求由客户端主动发起
     * 这是http协议，无状态、服务器是不能主动给客户端发数据的.服务器只能响应客户端请求.
     */
    static async searchMachineDataSS(clientReqDataParmas: DATA_TYPE_STRUCT.ClientReqDataParmas) {
        if (DATA_TYPE_STRUCT.DataReqState.FIRSTTIME == clientReqDataParmas.reqState) {
            let oldTimeStamp = _.dateString(_.now() - TimeGap.ss, 'S')
            let startTime = new Date();
            let retData1 = await Mongo.find(this.mongoInfo.dbName, this.mongoInfo.collection, { time: { "$gte": oldTimeStamp } }, { sort: { _id: -1 }, limit: this.reqDataNum.SS_number });
            let endTime = new Date();
            console.log(_.logger('INFO'), "searchMachineDataSS query cost times1:", endTime.getTime() - startTime.getTime(), ",dataLength:", retData1.length);
            if(0 === retData1.length){
                console.log(_.logger('WARN'), "searchMachineDataSS [cpu,rem,cpuG]  NO DATA RETURN");
            }
            return retData1;
        }
        else {
            if (!clientReqDataParmas.reqTimesGap || clientReqDataParmas.reqTimesGap < 0) {
                console.error(_.logger('ERROR'), `searchMachineDataSS() `, clientReqDataParmas);
                throw new Error("client Time gap error!!!");
            }
            let oldTimeStamp = _.dateString(_.now() - clientReqDataParmas.reqTimesGap, 'S')
            let startTime = new Date();
            let retData1 = await Mongo.find(this.mongoInfo.dbName, this.mongoInfo.collection, { time: { "$gte": oldTimeStamp } }, { sort: { _id: -1 }, limit: this.reqDataNum.SS_number });
            let endTime = new Date();
            console.log(_.logger('INFO'), "searchMachineDataSS query cost times2:", endTime.getTime() - startTime.getTime(), ",dataLength:", retData1.length);
            return retData1;
        }
    }

    /**查询 分钟 数据*/        // /**目前暂不区分第一次还是第N次 */
    static async searchMachineDataM(clientReqDataParmas: DATA_TYPE_STRUCT.ClientReqDataParmas) {
        let tempNowTime = new Date();
        let tempNowTimeStamp = _.dateString(tempNowTime);
        let oldTimeStamp = _.dateString(tempNowTime.getTime() - TimeGap.m, 'S');
        let startTime = new Date();
        let retData1 = await Mongo.aggregate(this.mongoInfo.dbName, this.mongoInfo.collection, [
            {
                $match: { time: { $gte: oldTimeStamp, $lt: tempNowTimeStamp } }
            },
            //"2020-05-03 20:29:45"
            {//2020-04-28 11:58
                $project: {
                    minute: {
                        $substr: ["$time", 0, 16]
                    },
                    cpu: '$cpu',
                    rem: '$rem',
                    cpuG: '$cpuG',
                }
            },
            {
                $group: {
                    _id: "$minute",
                    cpu: { $max: '$cpu' },
                    rem: { $max: '$rem' },
                    cpuG: { $max: '$cpuG' },
                },
            },
            { $sort: { _id: -1 } },
            { $limit: this.reqDataNum.M_number }
        ]);
        console.log(_.logger('INFO'), "searchMachineDataM query cost times:", new Date().getTime() - startTime.getTime(), ",dataLength:", retData1.length);
        return retData1;
    }



    /**查询 小时 数据*/
    static async searchMachineDataH(clientReqDataParmas: DATA_TYPE_STRUCT.ClientReqDataParmas) {
        let tempNowTime = new Date();
        let tempNowTimeStamp = _.dateString(tempNowTime);
        let oldTimeStamp = _.dateString(tempNowTime.getTime() - TimeGap.h, 'S');
        let startTime = new Date();
        let retData1 = await Mongo.aggregate(this.mongoInfo.dbName, this.mongoInfo.collection, [
            {
                $match: { time: { $gte: oldTimeStamp, $lt: tempNowTimeStamp } }
            },
            //"2020-05-03 20:29:45"
            {//"2020-05-03 20:29"取16个字符，每1分钟取样一次
                $project: {
                    hour: {
                        $substr: ["$time", 0, 16]
                    },
                    cpu: '$cpu',
                    rem: '$rem',
                    cpuG: '$cpuG'
                }
            },
            {
                $group: {
                    _id: "$hour",
                    cpu: { $max: '$cpu' },
                    rem: { $max: '$rem' },
                    cpuG: { $max: '$cpuG' },
                }
            },
            { $sort: { _id: -1 } },
            { $limit: this.reqDataNum.H_number }
        ]);
        console.log(_.logger('INFO'), "searchMachineDataH query cost times:", new Date().getTime() - startTime.getTime(), ",dataLength:", retData1.length);
        return retData1;
    }

    /**查询 天 数据*/
    static async searchMachineDataD(clientReqDataParmas: DATA_TYPE_STRUCT.ClientReqDataParmas) {
        let tempNowTime = new Date();
        let tempNowTimeStamp = _.dateString(tempNowTime);
        let oldTimeStamp = _.dateString(tempNowTime.getTime() - TimeGap.d, 'S');
        let startTime = new Date();
        let retData1 = await Mongo.aggregate(this.mongoInfo.dbName, this.mongoInfo.collection, [
            {
                $match: { time: { $gte: oldTimeStamp, $lt: tempNowTimeStamp } }
            },

            //"2020-05-03 20:29:45"
            {//"2020-05-03 20:2"取15个字符，每10分钟取样一次
                $project: {
                    day: {
                        $substr: ["$time", 0, 15]
                    },
                    cpu: '$cpu',
                    rem: '$rem',
                    cpuG: '$cpuG'
                }
            },
            {
                $group: {
                    _id: "$day",
                    cpu: { $max: '$cpu' },
                    rem: { $max: '$rem' },
                    cpuG: { $max: '$cpuG' },
                }
            },
            { $sort: { _id: -1 } },
            { $limit: this.reqDataNum.D_number }
        ]);
        console.log(_.logger('INFO'), "searchMachineDataD query cost times:", new Date().getTime() - startTime.getTime(), ",dataLength:", retData1.length);
        return retData1;
    }
}