add timesync

Author: undefined-moe

packages/server/client/printer.ts

@@ -6,7 +6,7 @@ import { PDFDocument } from 'pdf-lib';
 import superagent from 'superagent';
 import { config, saveConfig } from '../config';
 import {
-    fs, getPrinters, initWinPrinter, Logger, print, sleep,
+    fs, getPrinters, initWinPrinter, Logger, print, randomstring, sleep,
 } from '../utils';
 import { createTypstCompiler, generateTypst } from './typst';
 
@@ -46,7 +46,7 @@ function toUtf8(code: Buffer) {
 
 export async function ConvertCodeToPDF(code: Buffer, lang, filename, team, location, codeColor = false) {
     compiler ||= await createTypstCompiler();
-    const fakeFilename = String.random(8); // cubercsl: do not trust filename from user
+    const fakeFilename = randomstring(8); // cubercsl: do not trust filename from user
     const typst = generateTypst(team, location, fakeFilename, filename, lang, codeColor);
     compiler.addSource('/main.typst', typst);
     compiler.addSource(`/${fakeFilename}`, toUtf8(code));

packages/server/config.ts

@@ -3,7 +3,7 @@ import Schema from 'schemastery';
 import { version as packageVersion } from './package.json';
 import {
     checkReceiptPrinter,
-    fs, getPrinters, Logger, yaml,
+    fs, getPrinters, Logger, randomstring, yaml,
 } from './utils';
 
 const logger = new Logger('init');
@@ -21,15 +21,17 @@ if (!fs.existsSync(configPath)) {
     exit = new Promise((resolve) => (async () => {
         const serverConfigDefault = `\
 type: server # server | domjudge | hydro
-viewPass: ${String.random(8)} # use admin / viewPass to login
-secretRoute: ${String.random(12)}
+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: 
 token: 
 username: 
 password: 
+monitor:
+  timeSync: false
 `;
         let printers = [];
         if (isClient) {
@@ -62,10 +64,13 @@ const serverSchema = Schema.intersect([
         ] as const).description('server type').required(),
         port: Schema.number().default(5283),
         xhost: Schema.string().default('x-forwarded-host'),
-        viewPass: Schema.string().default(String.random(8)),
-        secretRoute: Schema.string().default(String.random(12)),
+        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 }),
     }).description('Basic Config'),
     Schema.union([
         Schema.object({

packages/server/handler/client.ts

@@ -3,7 +3,7 @@ import { Context } from 'cordis';
 import {
     BadRequestError, ForbiddenError, Handler, ValidationError,
 } from '@hydrooj/framework';
-import { fs, Logger } from '../utils';
+import { fs, Logger, randomstring } from '../utils';
 import { AuthHandler } from './misc';
 
 const logger = new Logger('handler/client');
@@ -18,7 +18,7 @@ class ClientControlHandler extends AuthHandler {
         const { name, type } = params;
         const client = await this.ctx.db.client.findOne({ name });
         if (client) throw new ValidationError('Client', null, 'Client already exists');
-        const id = String.random(6);
+        const id = randomstring(6);
         await this.ctx.db.client.insert({
             id,
             name,

packages/server/handler/misc.ts

@@ -4,9 +4,11 @@ import { Registry } from 'prom-client';
 import { Handler } from '@hydrooj/framework';
 import { config, version } from '../config';
 import StaticFrontend from '../data/static.frontend';
-import { createMetricsRegistry, decodeBinary, StaticHTML } from '../utils';
+import {
+    createMetricsRegistry, decodeBinary, randomstring, StaticHTML,
+} from '../utils';
 
-const randomHash = String.random(8).toLowerCase();
+const randomHash = randomstring(8).toLowerCase();
 const buf = decodeBinary(StaticFrontend);
 let registry: Registry;
 

packages/server/handler/monitor.ts

@@ -1,11 +1,7 @@
-/* eslint-disable no-await-in-loop */
-import { Context } from 'cordis';
+import { Context, Schema } from 'cordis';
 import { BadRequestError, Handler } from '@hydrooj/framework';
-import { Logger } from '../utils';
 import { AuthHandler } from './misc';
 
-const logger = new Logger('handler/monitor');
-
 class MonitorAdminHandler extends AuthHandler {
     async get(params) {
         const { nogroup } = params;
@@ -101,7 +97,7 @@ async function saveMonitorInfo(ctx: Context, monitor: any) {
     } = monitor;
     const monitors = await ctx.db.monitor.find({ mac });
     const warn = monitors.length > 1 || (monitors.length && monitors[0].ip !== ip);
-    if (warn) logger.warn(`Duplicate monitor ${mac} from (${ip}, ${monitors.length ? monitors[0].ip : 'null'})`);
+    if (warn) ctx.logger('monitor').warn(`Duplicate monitor ${mac} from (${ip}, ${monitors.length ? monitors[0].ip : 'null'})`);
     await ctx.db.monitor.updateOne({ mac }, {
         $set: {
             mac,
@@ -122,21 +118,24 @@ async function saveMonitorInfo(ctx: Context, monitor: any) {
     }, { upsert: true });
 }
 
-class MonitorReportHandler extends Handler {
-    async get() {
-        this.response.body = 'Monitor server is running';
-    }
+export const Config = Schema.object({
+    timeSync: Schema.boolean().default(false),
+});
 
-    async post(params) {
-        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 = 'Monitor server is running';
-    }
-}
+export async function apply(ctx: Context, config: ReturnType<typeof Config>) {
+    class MonitorReportHandler extends Handler {
+        async get() {
+            this.response.body = 'Monitor server is running';
+        }
 
-export async function apply(ctx: Context) {
+        async post(params) {
+            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'}`;
+        }
+    }
     ctx.Route('monitor_report', '/report', MonitorReportHandler);
     ctx.Route('monitor_admin', '/monitor', MonitorAdminHandler);
 }

packages/server/index.ts

@@ -1,10 +1,11 @@
 import os from 'os';
 import path from 'path';
+import LoggerService from '@cordisjs/plugin-logger';
+import { TimerService } from '@cordisjs/plugin-timer';
 import { Context } from 'cordis';
+import DBService from './service/db';
 import { fs, Logger } from './utils';
 
-Logger.levels.base = 3;
-
 const logger = new Logger('tools');
 
 process.on('unhandledRejection', (e) => { logger.error(e); });
@@ -22,36 +23,54 @@ try {
 }
 
 async function applyServer(ctx: Context) {
-    ctx.plugin(require('./service/server'));
-    ctx.plugin(require('./service/db'));
-    ctx.plugin(require('./service/fetcher'));
-    ctx.inject(['server', 'dbservice', 'fetcher'], (c) => {
-        c.plugin(require('./handler/misc'));
-        c.plugin(require('./handler/printer'));
-        c.plugin(require('./handler/monitor'));
-        c.plugin(require('./handler/client'));
-        c.plugin(require('./handler/balloon'));
-        c.plugin(require('./handler/commands'));
+    await Promise.all([
+        ctx.plugin(require('./service/server')),
+        ctx.plugin(require('./service/fetcher')),
+    ]);
+    await ctx.inject(['server', 'dbservice', 'fetcher'], async (c) => {
+        await Promise.all([
+            c.plugin(require('./handler/misc')),
+            c.plugin(require('./handler/printer')),
+            c.plugin(require('./handler/monitor'), config.monitor),
+            c.plugin(require('./handler/client')),
+            c.plugin(require('./handler/balloon')),
+            c.plugin(require('./handler/commands')),
+        ]);
         c.server.listen();
     });
 }
 
-async function applyClient(ctx: Context) {
+function applyClient(ctx: Context) {
     if (config.printers?.length) ctx.plugin(require('./client/printer'));
     if (config.balloon) ctx.plugin(require('./client/balloon'));
 }
 
 async function apply(ctx) {
     if (process.argv.includes('--client')) {
-        await applyClient(ctx);
+        applyClient(ctx);
     } else {
-        await applyServer(ctx);
+        ctx.plugin(DBService);
+        ctx.inject(['dbservice'], (c) => {
+            applyServer(c);
+        });
     }
-    await ctx.lifecycle.flush();
-    await ctx.parallel('app/listen');
     logger.success('Tools started');
     process.send?.('ready');
     await ctx.parallel('app/ready');
 }
 
-if (config) apply(app);
+app.plugin(TimerService);
+app.plugin(LoggerService, {
+    console: {
+        showDiff: false,
+        showTime: 'dd hh:mm:ss',
+        label: {
+            align: 'right',
+            width: 9,
+            margin: 1,
+        },
+        levels: { default: process.env.DEV ? 3 : 2 },
+    },
+});
+
+if (config) app.inject(['logger', 'timer'], (ctx) => apply(ctx));

packages/server/service/db.ts

@@ -21,12 +21,11 @@ declare module 'cordis' {
     }
 }
 
-export class DBService extends Service {
+export default class DBService extends Service {
     constructor(ctx: Context) {
         fs.ensureDirSync(path.resolve(process.cwd(), 'data/.db'));
-        super(ctx, 'dbservice', true);
+        super(ctx, 'dbservice');
         ctx.mixin('dbservice', ['db']);
-        this.start();
     }
 
     db: { [T in keyof Collections]: Datastore<Collections[T]> } = {} as any;
@@ -39,16 +38,11 @@ export class DBService extends Service {
         this.ctx.logger('db').info(`${key} Database loaded`);
     }
 
-    async start() {
+    async [Service.init]() {
         await this.initDatabase('code', ['_id', 'createAt', 'done', 'printer', 'deleted']);
         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('teams', []);
     }
 }
-
-export function apply(ctx: Context) {
-    ctx.provide('dbservice', undefined, true);
-    ctx.dbservice = new DBService(ctx);
-}