Fixed 267U.pre2

packages/backend/built/daemons/janitor.js

@@ -0,0 +1,15 @@
+// TODO: 消したい
+const interval = 30 * 60 * 1000;
+import { AttestationChallenges } from "../models/index.js";
+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/built/daemons/queue-stats.js

@@ -0,0 +1,45 @@
+import Xev from "xev";
+import { deliverQueue, inboxQueue } from "../queue/queues.js";
+const ev = new Xev();
+const interval = 10000;
+/**
+ * Report queue stats regularly
+ */ export default function() {
+    const log = [];
+    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/built/daemons/server-stats.js

@@ -0,0 +1,76 @@
+import si from "systeminformation";
+import Xev from "xev";
+import * as osUtils from "os-utils";
+import { fetchMeta } from "../misc/fetch-meta.js";
+const ev = new Xev();
+const interval = 2000;
+const roundCpu = (num)=>Math.round(num * 1000) / 1000;
+const round = (num)=>Math.round(num * 10) / 10;
+/**
+ * Report server stats regularly
+ */ export default function() {
+    const log = [];
+    ev.on("requestServerStatsLog", (x)=>{
+        ev.emit(`serverStatsLog:${x.id}`, log.slice(0, x.length || 50));
+    });
+    fetchMeta().then((meta)=>{
+        if (!meta.enableServerMachineStats) return;
+    });
+    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),
+                total: round(memStats.total)
+            },
+            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 ?? 0)),
+                w: round(Math.max(0, fsStats.wIO_sec ?? 0))
+            }
+        };
+        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)=>{
+            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
+    };
+}