refactoring

Resolve #7779

packages/backend/src/daemons/janitor.ts

@@ -0,0 +1,20 @@
+// TODO: 消したい
+
+const interval = 30 * 60 * 1000;
+import { AttestationChallenges } from '@/models/index';
+import { LessThan } from 'typeorm';
+
+/**
+ * Clean up database occasionally
+ */
+export default function() {
+	async function tick() {
+		await AttestationChallenges.delete({
+			createdAt: LessThan(new Date(new Date().getTime() - 5 * 60 * 1000))
+		});
+	}
+
+	tick();
+
+	setInterval(tick, interval);
+}

packages/backend/src/daemons/queue-stats.ts

@@ -0,0 +1,60 @@
+import Xev from 'xev';
+import { deliverQueue, inboxQueue } from '../queue/queues';
+
+const ev = new Xev();
+
+const interval = 10000;
+
+/**
+ * Report queue stats regularly
+ */
+export default function() {
+	const log = [] as any[];
+
+	ev.on('requestQueueStatsLog', x => {
+		ev.emit(`queueStatsLog:${x.id}`, log.slice(0, x.length || 50));
+	});
+
+	let activeDeliverJobs = 0;
+	let activeInboxJobs = 0;
+
+	deliverQueue.on('global:active', () => {
+		activeDeliverJobs++;
+	});
+
+	inboxQueue.on('global:active', () => {
+		activeInboxJobs++;
+	});
+
+	async function tick() {
+		const deliverJobCounts = await deliverQueue.getJobCounts();
+		const inboxJobCounts = await inboxQueue.getJobCounts();
+
+		const stats = {
+			deliver: {
+				activeSincePrevTick: activeDeliverJobs,
+				active: deliverJobCounts.active,
+				waiting: deliverJobCounts.waiting,
+				delayed: deliverJobCounts.delayed
+			},
+			inbox: {
+				activeSincePrevTick: activeInboxJobs,
+				active: inboxJobCounts.active,
+				waiting: inboxJobCounts.waiting,
+				delayed: inboxJobCounts.delayed
+			},
+		};
+
+		ev.emit('queueStats', stats);
+
+		log.unshift(stats);
+		if (log.length > 200) log.pop();
+
+		activeDeliverJobs = 0;
+		activeInboxJobs = 0;
+	}
+
+	tick();
+
+	setInterval(tick, interval);
+}

packages/backend/src/daemons/server-stats.ts

@@ -0,0 +1,79 @@
+import * as si from 'systeminformation';
+import Xev from 'xev';
+import * as osUtils from 'os-utils';
+
+const ev = new Xev();
+
+const interval = 2000;
+
+const roundCpu = (num: number) => Math.round(num * 1000) / 1000;
+const round = (num: number) => Math.round(num * 10) / 10;
+
+/**
+ * Report server stats regularly
+ */
+export default function() {
+	const log = [] as any[];
+
+	ev.on('requestServerStatsLog', x => {
+		ev.emit(`serverStatsLog:${x.id}`, log.slice(0, x.length || 50));
+	});
+
+	async function tick() {
+		const cpu = await cpuUsage();
+		const memStats = await mem();
+		const netStats = await net();
+		const fsStats = await fs();
+
+		const stats = {
+			cpu: roundCpu(cpu),
+			mem: {
+				used: round(memStats.used - memStats.buffers - memStats.cached),
+				active: round(memStats.active),
+			},
+			net: {
+				rx: round(Math.max(0, netStats.rx_sec)),
+				tx: round(Math.max(0, netStats.tx_sec)),
+			},
+			fs: {
+				r: round(Math.max(0, fsStats.rIO_sec)),
+				w: round(Math.max(0, fsStats.wIO_sec)),
+			}
+		};
+		ev.emit('serverStats', stats);
+		log.unshift(stats);
+		if (log.length > 200) log.pop();
+	}
+
+	tick();
+
+	setInterval(tick, interval);
+}
+
+// CPU STAT
+function cpuUsage() {
+	return new Promise((res, rej) => {
+		osUtils.cpuUsage((cpuUsage: number) => {
+			res(cpuUsage);
+		});
+	});
+}
+
+// MEMORY STAT
+async function mem() {
+	const data = await si.mem();
+	return data;
+}
+
+// NETWORK STAT
+async function net() {
+	const iface = await si.networkInterfaceDefault();
+	const data = await si.networkStats(iface);
+	return data[0];
+}
+
+// FS STAT
+async function fs() {
+	const data = await si.disksIO().catch(() => ({ rIO_sec: 0, wIO_sec: 0 }));
+	return data || { rIO_sec: 0, wIO_sec: 0 };
+}