monitor page performance update & send command through heartbeat script

Author: undefined-moe

README.md

@@ -41,7 +41,6 @@ const serverSchema = Schema.intersect([
         port: Schema.number().default(5283), // 服务端口
         viewPass: Schema.string().default(String.random(8)), // UI登录密码，可通过 admin / {viewPass} 登录
         secretRoute: Schema.string().default(String.random(12)), // 打印路径，用于远程调用
-        seatFile: Schema.string().default('/home/icpc/Desktop/seat.txt'), // 选手座位绑定文件
     }).description('Basic Config'),
     Schema.union([
         Schema.object({

packages/server/config.ts

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import Schema from 'schemastery';
+import { Config } from './handler/monitor';
 import { version as packageVersion } from './package.json';
 import {
     checkReceiptPrinter,
@@ -47,7 +48,6 @@ if (!fs.existsSync(configPath)) {
 type: server # server | domjudge | hydro
 viewPass: ${randomstring(8)} # use admin / viewPass to login
 secretRoute: ${randomstring(12)}
-seatFile: /home/icpc/Desktop/seats.txt
 customKeyfile: 
 # if type is server, the following is not needed
 server: 
@@ -91,11 +91,8 @@ const serverSchema = Schema.intersect([
         xhost: Schema.string().default('x-forwarded-host'),
         viewPass: Schema.string().default(randomstring(8)),
         secretRoute: Schema.string().default(randomstring(12)),
-        seatFile: Schema.string().default('/home/icpc/Desktop/seat.txt'),
         customKeyfile: Schema.string().default(''),
-        monitor: Schema.object({
-            timeSync: Schema.boolean().default(false),
-        }).default({ timeSync: false }),
+        monitor: Config,
     }).description('Basic Config'),
     Schema.union([
         Schema.object({

packages/server/handler/commands.ts

@@ -6,12 +6,49 @@ import { AuthHandler } from './misc';
 
 class CommandsHandler extends AuthHandler {
     async get() {
-        this.response.body = '';
+        const commands = await this.ctx.db.command.find({}).sort({ time: -1 }).limit(100);
+        const monitors = await this.ctx.db.monitor.find({});
+        const monitorMap = new Map(monitors.map((m) => [m.mac, m]));
+        const commandsWithInfo = commands.map((cmd) => ({
+            _id: cmd._id,
+            command: cmd.command,
+            target: cmd.target || [],
+            executionResult: cmd.executionResult || {},
+            targetInfo: (cmd.target || []).map((mac) => ({
+                mac,
+                hostname: monitorMap.get(mac)?.hostname || mac,
+                name: monitorMap.get(mac)?.name || '',
+            })),
+            status: {
+                total: cmd.target?.length || 0,
+                completed: Object.keys(cmd.executionResult || {}).length,
+                pending: (cmd.target?.length || 0) - Object.keys(cmd.executionResult || {}).length,
+            },
+        }));
+        this.response.body = { commands: commandsWithInfo };
     }
 
-    async postCommand({ command }) {
+    async postCommand({ command, target, mode = 'heartbeat' }) {
         if (!command || typeof command !== 'string') throw new BadRequestError('Command', null, 'Command is required');
-        this.response.body = this.executeForAll(command);
+        if (mode === 'heartbeat') {
+            target ||= (await this.ctx.db.monitor.find({})).map((m) => m.mac);
+            target = target.map((i) => i.replace(/:/g, ''));
+            const res = await this.ctx.db.command.insert({
+                command,
+                time: Date.now(),
+                target,
+                pending: target,
+                executionResult: {},
+            });
+            this.response.body = { id: res._id };
+        } else {
+            this.response.body = this.executeForAll(command);
+        }
+    }
+
+    async postRemove({ command }) {
+        await this.ctx.db.command.deleteOne({ _id: command }, {});
+        this.response.body = { success: true };
     }
 
     async executeForAll(command: string, t = 10000) {
@@ -33,11 +70,7 @@ else
     export DISPLAY=:0
 fi
 export XAUTHORITY=/run/user/1000/gdm/Xauthority
-zenity --info --text "<span font='256'>$(cat ${config.seatFile})</span>"`);
-    }
-
-    async postSetHostname() {
-        this.response.body = await this.executeForAll(`hostnamectl hostname $(cat -- ${config.seatFile})`);
+zenity --info --text "<span font='256'>$(cat /etc/hostname)</span>"`);
     }
 
     async postAutologin({ }, autologin = false) {

packages/server/handler/monitor.ts

@@ -1,7 +1,13 @@
+import path from 'path';
 import { Context, Schema } from 'cordis';
+import fs from 'fs-extra';
 import { BadRequestError, Handler } from '@hydrooj/framework';
+import { Logger } from '../utils';
 import { AuthHandler } from './misc';
 
+const logger = new Logger('monitor');
+const actions = fs.createWriteStream(path.join(process.cwd(), 'data/actions.log'), { flags: 'a' });
+
 class MonitorAdminHandler extends AuthHandler {
     async get(params) {
         const { nogroup } = params;
@@ -90,14 +96,23 @@ class MonitorAdminHandler extends AuthHandler {
     }
 }
 
-async function saveMonitorInfo(ctx: Context, monitor: any) {
+const escape = (str: string) => str.trim().replace(/"/g, '\\"').replace(/\r/g, '').replace(/\n/g, '\\n');
+
+async function saveMonitorInfo(ctx: Context, monitor: any, config) {
     const {
         mac, version, uptime, seats, ip,
         os, kernel, cpu, cpuused, mem, memused, load,
+        window_cmdline, window_exe, window_name,
     } = monitor;
+    logger.debug('save monitor info %o', monitor);
+    actions.write(`${Date.now()},${seats},"${escape(window_cmdline)}","${escape(window_exe)}","${escape(window_name)}"\n`);
     const monitors = await ctx.db.monitor.find({ mac });
     const warn = monitors.length > 1 || (monitors.length && monitors[0].ip !== ip);
     if (warn) ctx.logger('monitor').warn(`Duplicate monitor ${mac} from (${ip}, ${monitors.length ? monitors[0].ip : 'null'})`);
+    const autoGroupPayload = (config.autoGroup && /^[A-Z][0-9]+$/.test(seats)) ? {
+        group: seats[0],
+        name: seats,
+    } : {};
     await ctx.db.monitor.updateOne({ mac }, {
         $set: {
             mac,
@@ -114,13 +129,15 @@ async function saveMonitorInfo(ctx: Context, monitor: any) {
             ...mem && { mem },
             ...mem && { memUsed: memused },
             ...load && { load },
+            ...autoGroupPayload,
         },
     }, { upsert: true });
 }
 
 export const Config = Schema.object({
     timeSync: Schema.boolean().default(false),
-});
+    autoGroup: Schema.boolean().default(false),
+}).default({ timeSync: false, autoGroup: false });
 
 export async function apply(ctx: Context, config: ReturnType<typeof Config>) {
     class MonitorReportHandler extends Handler {
@@ -132,8 +149,49 @@ export async function apply(ctx: Context, config: ReturnType<typeof Config>) {
             if (!params.mac) throw new BadRequestError();
             params.ip = this.request.ip.replace('::ffff:', '');
             if (params.mac === '00:00:00:00:00:00') throw new BadRequestError('Invalid MAC address');
-            await saveMonitorInfo(this.ctx, params);
-            this.response.body = `#!/bin/bash\n${config.timeSync ? `date "${new Date().toISOString()}"` : 'echo Success'}`;
+            await saveMonitorInfo(this.ctx, params, config);
+            if (this.request.files?.file) {
+                const resultContent = fs.readFileSync(this.request.files.file.filepath, 'utf-8');
+                const commandResults: Map<string, string> = new Map();
+                let currentCommandId: string | null = null;
+                let currentOutput: string[] = [];
+                const lines = resultContent.split('\n');
+                for (const line of lines) {
+                    const startMatch = line.match(/^---COMMAND_START:(.+?)---$/);
+                    const endMatch = line.match(/^---COMMAND_END:(.+?)---$/);
+                    if (startMatch) {
+                        currentCommandId = startMatch[1];
+                        currentOutput = [];
+                    } else if (endMatch && currentCommandId === endMatch[1]) {
+                        commandResults.set(currentCommandId, currentOutput.join('\n') || '(No output)');
+                        currentCommandId = null;
+                        currentOutput = [];
+                    } else if (currentCommandId) {
+                        currentOutput.push(line);
+                    }
+                }
+                if (currentCommandId) commandResults.set(currentCommandId, currentOutput.join('\n') || '(No output)');
+                await Promise.all(Array.from(commandResults.entries()).map(async ([commandId, output]) => {
+                    const cmd = await ctx.db.command.findOne({ _id: commandId });
+                    if (cmd) {
+                        const executionResult = cmd.executionResult || {};
+                        executionResult[params.mac] = output;
+                        const newPending = cmd.pending.filter((t: string) => t !== params.mac);
+                        await ctx.db.command.updateOne({ _id: commandId }, { $set: { executionResult, pending: newPending } });
+                    }
+                }));
+            }
+            const scriptParts: string[] = [
+                '#!/bin/bash',
+                config.timeSync ? `date --set="${new Date().toISOString()}"` : 'echo Time sync disabled',
+            ];
+            for (const cmd of await ctx.db.command.find({ pending: params.mac })) {
+                scriptParts.push(`echo ---COMMAND_START:${cmd._id}---`);
+                scriptParts.push(cmd.command);
+                scriptParts.push(`echo ---COMMAND_END:${cmd._id}---`);
+            }
+            this.response.body = `${scriptParts.join('\n')}\n`;
+            this.response.type = 'text/x-shellscript';
         }
     }
     ctx.Route('monitor_report', '/report', MonitorReportHandler);

packages/server/interface.ts

@@ -48,6 +48,15 @@ export interface MonitorDoc {
     desktop?: string;
 }
 
+export interface CommandTask {
+    _id: string;
+    time: number;
+    command: string;
+    target: string[];
+    pending: string[];
+    executionResult: Record<string, string>;
+}
+
 export interface ClientDoc {
     _id: string;
     id: string;

packages/server/service/db.ts

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { Context, Service } from 'cordis';
 import Datastore from 'nedb-promises';
 import {
-    BalloonDoc, ClientDoc, MonitorDoc, PrintCodeDoc, TeamDoc,
+    BalloonDoc, ClientDoc, CommandTask, MonitorDoc, PrintCodeDoc, TeamDoc,
 } from '../interface';
 import { fs } from '../utils';
 
@@ -12,6 +12,7 @@ export interface Collections {
     client: ClientDoc;
     balloon: BalloonDoc;
     teams: TeamDoc;
+    command: CommandTask;
 }
 
 declare module 'cordis' {
@@ -43,6 +44,7 @@ export default class DBService extends Service {
         await this.initDatabase('monitor', ['_id', 'mac', 'name', 'group']);
         await this.initDatabase('client', ['id', 'name', 'type', 'group']);
         await this.initDatabase('balloon', ['id', 'time', 'problem', 'teamid', 'awards', 'done', 'printDone']);
+        await this.initDatabase('command', ['_id', 'command', 'target', 'pending', 'time', 'executionResult']);
         await this.initDatabase('teams', []);
     }
 }

packages/server/service/fetcher.ts

@@ -1,9 +1,11 @@
 /* eslint-disable no-await-in-loop */
+import path from 'node:path';
 import { Context, Service } from 'cordis';
 import superagent from 'superagent';
 import { config } from '../config';
-import { fs, Logger, mongoId, sleep } from '../utils';
-import path from 'node:path';
+import {
+    fs, Logger, mongoId, sleep,
+} from '../utils';
 
 const logger = new Logger('fetcher');
 const fetch = (url: string, type: 'get' | 'post' = 'get') => {
@@ -266,9 +268,10 @@ class HydroFetcher extends BasicFetcher {
 
     async printInfo(all) {
         const doFetch = async () => {
-            const { body } = await fetch(`/d/${this.contest.domainId}/contest/${this.contest.id}/print`, 'post').send({ operation: 'allocate_print_task' });
+            const { body } = await fetch(`/d/${this.contest.domainId}/contest/${this.contest.id}/print`, 'post')
+                .send({ operation: 'allocate_print_task' });
             return body;
-        }
+        };
         let { task, udoc } = await doFetch();
         let cnt = 0;
         while (task) {
@@ -293,7 +296,8 @@ class HydroFetcher extends BasicFetcher {
     }
 
     async setPrintDone(pid) {
-        await fetch(`/d/${this.contest.domainId}/contest/${this.contest.id}/print`, 'post').send({ operation: 'update_print_task', taskId: pid, status: 'printed' });
+        await fetch(`/d/${this.contest.domainId}/contest/${this.contest.id}/print`, 'post')
+            .send({ operation: 'update_print_task', taskId: pid, status: 'printed' });
         this.logger.debug(`Print ${pid} set done`);
     }
 }

packages/server/service/server.ts

@@ -1,9 +1,11 @@
 import { Context } from 'cordis';
 import proxy from 'koa-proxies';
-import { ForbiddenError, HydroError, NotFoundError, UserFacingError, WebService } from '@hydrooj/framework';
+import {
+    ForbiddenError, HydroError, NotFoundError, UserFacingError, WebService,
+} from '@hydrooj/framework';
+import { errorMessage } from '@hydrooj/utils';
 import { config } from '../config';
 import { randomstring } from '../utils';
-import { errorMessage } from '@hydrooj/utils';
 export * from '@hydrooj/framework/decorators';
 
 export async function apply(pluginContext: Context) {
@@ -62,7 +64,6 @@ export async function apply(pluginContext: Context) {
                 error.msg ||= () => error.message;
                 if (error instanceof UserFacingError && !process.env.DEV) error.stack = '';
                 if (!(error instanceof NotFoundError) && !('nolog' in error)) {
-                    // eslint-disable-next-line max-len
                     console.error(`${this.request.method}: ${this.request.path}`, error.msg(), error.params);
                     if (error.stack) console.error(error.stack);
                 }