477 lines
14 KiB
JavaScript
477 lines
14 KiB
JavaScript
import os from 'os'
|
||
import _ from 'lodash'
|
||
import fs from 'fs'
|
||
import { common } from './index.js'
|
||
import { Config, Data } from '../components/index.js'
|
||
import request from '../lib/request/request.js'
|
||
|
||
export default new class {
|
||
constructor () {
|
||
this.si = null
|
||
this.osInfo = null
|
||
// 是否可以获取gpu
|
||
this.isGPU = false
|
||
// 网络
|
||
this._network = null
|
||
// 读写速率
|
||
this._fsStats = null
|
||
// 记录60条数据一分钟记录一次
|
||
this.chartData = {
|
||
network: {
|
||
// 上行
|
||
upload: [],
|
||
// 下行
|
||
download: []
|
||
},
|
||
fsStats: {
|
||
// 读
|
||
readSpeed: [],
|
||
// 写
|
||
writeSpeed: []
|
||
},
|
||
// cpu
|
||
cpu: [],
|
||
// 内存
|
||
ram: [],
|
||
// 主题
|
||
echarts_theme: Data.readJSON('resources/state/theme_westeros.json')
|
||
}
|
||
|
||
this.valueObject = {
|
||
networkStats: 'rx_sec,tx_sec,iface',
|
||
currentLoad: 'currentLoad',
|
||
mem: 'active',
|
||
fsStats: 'wx_sec,rx_sec'
|
||
}
|
||
|
||
this.init()
|
||
}
|
||
|
||
set network (value) {
|
||
if (_.isNumber(value[0]?.tx_sec) && _.isNumber(value[0]?.rx_sec)) {
|
||
this._network = value
|
||
this.addData(this.chartData.network.upload, [Date.now(), value[0].tx_sec])
|
||
this.addData(this.chartData.network.download, [Date.now(), value[0].rx_sec])
|
||
}
|
||
}
|
||
|
||
get network () {
|
||
return this._network
|
||
}
|
||
|
||
set fsStats (value) {
|
||
if (_.isNumber(value?.wx_sec) && _.isNumber(value?.rx_sec)) {
|
||
this._fsStats = value
|
||
this.addData(this.chartData.fsStats.writeSpeed, [Date.now(), value.wx_sec])
|
||
this.addData(this.chartData.fsStats.readSpeed, [Date.now(), value.rx_sec])
|
||
}
|
||
}
|
||
|
||
get fsStats () {
|
||
return this._fsStats
|
||
}
|
||
|
||
async initDependence () {
|
||
try {
|
||
this.si = await import('systeminformation')
|
||
this.osInfo = await this.si.osInfo()
|
||
return this.si
|
||
} catch (error) {
|
||
if (error.stack?.includes('Cannot find package')) {
|
||
logger.warn('--------椰奶依赖缺失--------')
|
||
logger.warn(`yenai-plugin 缺少依赖将无法使用 ${logger.yellow('椰奶状态')}`)
|
||
logger.warn(`如需使用请运行：${logger.red('pnpm add systeminformation -w')}`)
|
||
logger.warn('---------------------------')
|
||
logger.debug(decodeURI(error.stack))
|
||
} else {
|
||
logger.error(`椰奶载入依赖错误：${logger.red('systeminformation')}`)
|
||
logger.error(decodeURI(error.stack))
|
||
}
|
||
}
|
||
}
|
||
|
||
async init () {
|
||
if (!await this.initDependence()) return
|
||
const { controllers } = await this.si.graphics()
|
||
// 初始化GPU获取
|
||
if (controllers?.find(item =>
|
||
item.memoryUsed && item.memoryFree && item.utilizationGpu)
|
||
) {
|
||
this.isGPU = true
|
||
}
|
||
// 给有问题的用户关闭定时器
|
||
if (!Config.state.statusTask) return
|
||
|
||
if (Config.state.statusPowerShellStart) this.si.powerShellStart()
|
||
this.getData()
|
||
// 网速
|
||
const Timer = setInterval(async () => {
|
||
let data = await this.getData()
|
||
if (_.isEmpty(data)) clearInterval(Timer)
|
||
}, 60000)
|
||
}
|
||
|
||
async getData () {
|
||
let data = await this.si.get(this.valueObject)
|
||
_.forIn(data, (value, key) => {
|
||
if (_.isEmpty(value)) {
|
||
logger.debug(`获取${key}数据失败，停止获取对应数据`)
|
||
delete this.valueObject[key]
|
||
}
|
||
})
|
||
let {
|
||
fsStats,
|
||
networkStats,
|
||
mem: { active },
|
||
currentLoad: { currentLoad }
|
||
} = data
|
||
this.fsStats = fsStats
|
||
this.network = networkStats
|
||
if (_.isNumber(active)) {
|
||
this.addData(this.chartData.ram, [Date.now(), active])
|
||
}
|
||
if (_.isNumber(currentLoad)) {
|
||
this.addData(this.chartData.cpu, [Date.now(), currentLoad])
|
||
}
|
||
return data
|
||
}
|
||
|
||
/**
|
||
* 向数组中添加数据，如果数组长度超过允许的最大值，则删除最早添加的数据
|
||
* @param {Array} arr - 要添加数据的数组
|
||
* @param {*} data - 要添加的新数据
|
||
* @param {number} [maxLen] - 数组允许的最大长度，默认值为60
|
||
* @returns {void}
|
||
*/
|
||
addData (arr, data, maxLen = 60) {
|
||
if (data === null || data === undefined) return
|
||
// 如果数组长度超过允许的最大值，删除第一个元素
|
||
if (arr.length >= maxLen) {
|
||
_.pullAt(arr, 0)
|
||
}
|
||
// 添加新数据
|
||
arr.push(data)
|
||
}
|
||
|
||
/**
|
||
* 重试获取数据，直到成功或达到最大重试次数。
|
||
* @param {Function} fetchFunc 获取数据的函数，返回一个Promise对象。
|
||
* @param {Array} [params] 需要执行函数的参数数组
|
||
* @param {number} [timerId] 定时器的id，用于在获取数据失败时停止定时器
|
||
* @param {number} [maxRetryCount] 最大重试次数。
|
||
* @param {number} [retryInterval] 两次重试之间的等待时间，单位为毫秒。。
|
||
* @returns {Promise} 获取到的数据。如果达到最大重试次数且获取失败，则返回null。
|
||
*/
|
||
async fetchDataWithRetry (fetchFunc, params = [], timerId, maxRetryCount = 3, retryInterval = 1000) {
|
||
let retryCount = 0
|
||
let data = null
|
||
while (retryCount <= maxRetryCount) {
|
||
data = await fetchFunc(...params)
|
||
if (!_.isEmpty(data)) {
|
||
break
|
||
}
|
||
retryCount++
|
||
if (retryCount > maxRetryCount && timerId) {
|
||
logger.debug(`获取${fetchFunc.name}数据失败，停止定时器`)
|
||
clearInterval(timerId)
|
||
break
|
||
}
|
||
await new Promise(resolve => setTimeout(resolve, retryInterval))
|
||
}
|
||
return data
|
||
}
|
||
|
||
/**
|
||
* 将文件大小从字节转化为可读性更好的格式，例如B、KB、MB、GB、TB。
|
||
* @param {number} size - 带转化的字节数。
|
||
* @param {boolean} [isByte] - 如果为 true，则最终的文件大小显示保留 B 的后缀.
|
||
* @param {boolean} [isSuffix] - 如果为 true，则在所得到的大小后面加上 kb、mb、gb、tb 等后缀.
|
||
* @returns {string} 文件大小格式转换后的字符串.
|
||
*/
|
||
getFileSize (size, isByte = true, isSuffix = true) { // 把字节转换成正常文件大小
|
||
if (size == null || size == undefined) return 0
|
||
let num = 1024.00 // byte
|
||
if (isByte && size < num) {
|
||
return size.toFixed(2) + 'B'
|
||
}
|
||
if (size < Math.pow(num, 2)) {
|
||
return (size / num).toFixed(2) + `K${isSuffix ? 'b' : ''}`
|
||
} // kb
|
||
if (size < Math.pow(num, 3)) {
|
||
return (size / Math.pow(num, 2)).toFixed(2) + `M${isSuffix ? 'b' : ''}`
|
||
} // M
|
||
if (size < Math.pow(num, 4)) {
|
||
return (size / Math.pow(num, 3)).toFixed(2) + 'G'
|
||
} // G
|
||
return (size / Math.pow(num, 4)).toFixed(2) + 'T' // T
|
||
}
|
||
|
||
/**
|
||
* 圆形进度条渲染
|
||
* @param {number} res 百分比小数
|
||
* @returns {*} css样式
|
||
*/
|
||
Circle (res) {
|
||
let num = (res * 360).toFixed(0)
|
||
let color = 'var(--low-color)'
|
||
if (res >= 0.9) {
|
||
color = 'var(--high-color)'
|
||
} else if (res >= 0.8) {
|
||
color = 'var(--medium-color)'
|
||
}
|
||
let leftCircle = `style="transform:rotate(-180deg);background:${color};"`
|
||
let rightCircle = `style="transform:rotate(360deg);background:${color};"`
|
||
if (num > 180) {
|
||
leftCircle = `style="transform:rotate(${num}deg);background:${color};"`
|
||
} else {
|
||
rightCircle = `style="transform:rotate(-${180 - num}deg);background:${color};"`
|
||
}
|
||
return { leftCircle, rightCircle }
|
||
}
|
||
|
||
/** 获取nodejs内存情况 */
|
||
getNodeInfo () {
|
||
let memory = process.memoryUsage()
|
||
// 总共
|
||
let rss = this.getFileSize(memory.rss)
|
||
// 堆
|
||
let heapTotal = this.getFileSize(memory.heapTotal)
|
||
// 栈
|
||
let heapUsed = this.getFileSize(memory.heapUsed)
|
||
// 占用率
|
||
let occupy = (memory.rss / (os.totalmem() - os.freemem())).toFixed(2)
|
||
return {
|
||
...this.Circle(occupy),
|
||
inner: Math.round(occupy * 100) + '%',
|
||
title: 'Node',
|
||
info: [
|
||
`总 ${rss}`,
|
||
`堆 ${heapTotal}`,
|
||
`栈 ${heapUsed}`
|
||
]
|
||
}
|
||
}
|
||
|
||
/** 获取当前内存占用 */
|
||
getMemUsage () {
|
||
// 内存使用率
|
||
let MemUsage = (1 - os.freemem() / os.totalmem()).toFixed(2)
|
||
// 空闲内存
|
||
let freemem = this.getFileSize(os.freemem())
|
||
// 总共内存
|
||
let totalmem = this.getFileSize(os.totalmem())
|
||
// 使用内存
|
||
let Usingmemory = this.getFileSize((os.totalmem() - os.freemem()))
|
||
|
||
return {
|
||
...this.Circle(MemUsage),
|
||
inner: Math.round(MemUsage * 100) + '%',
|
||
title: 'RAM',
|
||
info: [
|
||
`总共 ${totalmem}`,
|
||
`已用 ${Usingmemory}`,
|
||
`空闲 ${freemem}`
|
||
]
|
||
}
|
||
}
|
||
|
||
/** 获取CPU占用 */
|
||
async getCpuInfo () {
|
||
let { currentLoad: { currentLoad }, cpuCurrentSpeed } = await this.si.get({
|
||
currentLoad: 'currentLoad',
|
||
cpuCurrentSpeed: 'max,avg'
|
||
})
|
||
if (currentLoad == null || currentLoad == undefined) return false
|
||
// 核心
|
||
let cores = os.cpus()
|
||
// cpu制造者
|
||
let cpuModel = cores[0]?.model.slice(0, cores[0]?.model.indexOf(' ')) || ''
|
||
return {
|
||
...this.Circle(currentLoad / 100),
|
||
inner: Math.round(currentLoad) + '%',
|
||
title: 'CPU',
|
||
info: [
|
||
`${cpuModel} ${cores.length}核 ${this.osInfo?.arch}`,
|
||
`平均${cpuCurrentSpeed.avg}GHz`,
|
||
`最大${cpuCurrentSpeed.max}GHz`
|
||
]
|
||
|
||
}
|
||
}
|
||
|
||
/** 获取GPU占用 */
|
||
async getGPU () {
|
||
if (!this.isGPU) return false
|
||
try {
|
||
const { controllers } = await this.si.graphics()
|
||
let graphics = controllers?.find(item =>
|
||
item.memoryUsed && item.memoryFree && item.utilizationGpu
|
||
)
|
||
if (!graphics) {
|
||
logger.warn('[Yenai-plugin][state]状态GPU数据异常：\n', controllers)
|
||
return false
|
||
}
|
||
let {
|
||
vendor, temperatureGpu, utilizationGpu,
|
||
memoryTotal, memoryUsed, powerDraw
|
||
} = graphics
|
||
temperatureGpu && (temperatureGpu = temperatureGpu + '℃')
|
||
powerDraw && (powerDraw = powerDraw + 'W')
|
||
return {
|
||
...this.Circle(utilizationGpu / 100),
|
||
inner: Math.round(utilizationGpu) + '%',
|
||
title: 'GPU',
|
||
info: [
|
||
`${vendor} ${temperatureGpu} ${powerDraw}`,
|
||
`总共 ${(memoryTotal / 1024).toFixed(2)}G`,
|
||
`已用 ${(memoryUsed / 1024).toFixed(2)}G`
|
||
]
|
||
}
|
||
} catch (e) {
|
||
logger.warn('[Yenai-Plugin][State] 获取GPU失败')
|
||
return false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取硬盘
|
||
* @returns {*}
|
||
*/
|
||
async getFsSize () {
|
||
// 去重
|
||
let HardDisk = _.uniqWith(await this.si.fsSize(),
|
||
(a, b) =>
|
||
a.used === b.used && a.size === b.size && a.use === b.use && a.available === b.available
|
||
)
|
||
.filter(item => item.size && item.used && item.available && item.use)
|
||
// 为空返回false
|
||
if (_.isEmpty(HardDisk)) return false
|
||
// 数值转换
|
||
return HardDisk.map(item => {
|
||
item.used = this.getFileSize(item.used)
|
||
item.size = this.getFileSize(item.size)
|
||
item.use = Math.round(item.use)
|
||
item.color = 'var(--low-color)'
|
||
if (item.use >= 90) {
|
||
item.color = 'var(--high-color)'
|
||
} else if (item.use >= 70) {
|
||
item.color = 'var(--medium-color)'
|
||
}
|
||
return item
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 获取FastFetch
|
||
* @param e
|
||
*/
|
||
async getFastFetch (e) {
|
||
if (process.platform == 'win32' && !/pro/.test(e.msg)) return ''
|
||
let ret = await common.execSync('bash plugins/yenai-plugin/resources/state/state.sh')
|
||
if (ret.error) {
|
||
e.reply(`❎ 请检查是否使用git bash启动Yunzai-bot\n错误信息：${ret.stderr}`)
|
||
return ''
|
||
}
|
||
return ret.stdout.trim()
|
||
}
|
||
|
||
// 获取读取速率
|
||
get DiskSpeed () {
|
||
if (!this.fsStats ||
|
||
this.fsStats.rx_sec == null ||
|
||
this.fsStats.wx_sec == null
|
||
) {
|
||
return false
|
||
}
|
||
return {
|
||
rx_sec: this.getFileSize(this.fsStats.rx_sec, false, false),
|
||
wx_sec: this.getFileSize(this.fsStats.wx_sec, false, false)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取网速
|
||
* @returns {object}
|
||
*/
|
||
get getnetwork () {
|
||
let network = _.cloneDeep(this.network)?.[0]
|
||
if (!network || network.rx_sec == null || network.tx_sec == null) {
|
||
return false
|
||
}
|
||
network.rx_sec = this.getFileSize(network.rx_sec, false, false)
|
||
network.tx_sec = this.getFileSize(network.tx_sec, false, false)
|
||
// return network
|
||
return {
|
||
first: network.iface,
|
||
tail: `↑${network.tx_sec}/s | ↓${network.rx_sec}/s`
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 取插件包
|
||
* @returns {*} 插件包数量
|
||
*/
|
||
get getPluginNum () {
|
||
let str = './plugins'
|
||
let arr = fs.readdirSync(str)
|
||
let plugin = []
|
||
arr.forEach((val) => {
|
||
let ph = fs.statSync(str + '/' + val)
|
||
if (ph.isDirectory()) {
|
||
plugin.push(val)
|
||
}
|
||
})
|
||
let del = ['example', 'genshin', 'other', 'system', 'bin']
|
||
plugin = plugin.filter(item => !del.includes(item))
|
||
const plugins = plugin?.length || 0
|
||
const js = fs.readdirSync('./plugins/example')?.filter(item => item.includes('.js'))?.length || 0
|
||
// return {
|
||
// plugins: plugin?.length || 0,
|
||
// js: fs.readdirSync('./plugins/example')?.filter(item => item.includes('.js'))?.length || 0
|
||
// }
|
||
return {
|
||
first: '插件',
|
||
tail: `${plugins} plugin | ${js} js`
|
||
}
|
||
}
|
||
|
||
async getNetworkLatency (url, timeoutTime = 5000) {
|
||
const AbortController = globalThis.AbortController || await import('abort-controller')
|
||
|
||
const controller = new AbortController()
|
||
const timeout = setTimeout(() => {
|
||
controller.abort()
|
||
}, timeoutTime)
|
||
try {
|
||
const startTime = Date.now()
|
||
let { status } = await request.get(url, { signal: controller.signal })
|
||
const endTime = Date.now()
|
||
let delay = endTime - startTime
|
||
let color = ''; let statusColor = ''
|
||
if (delay > 2000) {
|
||
color = '#F44336'
|
||
} else if (delay > 500) {
|
||
color = '#d68100'
|
||
} else {
|
||
color = '#188038'
|
||
}
|
||
if (status >= 500) {
|
||
statusColor = '#9C27B0'
|
||
} else if (status >= 400) {
|
||
statusColor = '#F44336'
|
||
} else if (status >= 300) {
|
||
statusColor = '#FF9800'
|
||
} else if (status >= 200) {
|
||
statusColor = '#188038'
|
||
} else if (status >= 100) {
|
||
statusColor = '#03A9F4'
|
||
}
|
||
return `<span style='color:${statusColor}'>${status}</span> | <span style='color:${color}'>${delay}ms</span>`
|
||
} catch {
|
||
return "<span style='color:#F44336'>timeout</span>"
|
||
} finally {
|
||
clearTimeout(timeout)
|
||
}
|
||
}
|
||
}()
|