清理无用代码，并排序Import

Author: qwertycxz

config/config.example.toml

@@ -12,10 +12,6 @@ name = "TestJudger"
 "xc6slx9-2-ftg256.verilog.xst" = "/usr/src/xc6slx9-2-ftg256.verilog.xst"
 [language]
 cat = "/usr/bin/cat"
-ise = "/usr/bin/ise" # TODO: delete
-shell = "/usr/bin/shell" # TODO: delete?
-verilog = "/usr/bin/verilog" # TODO: delete
-vhdl = "/usr/bin/vhdl" # TODO: delete
 xst = "/usr/bin/xst"
 ngdbuild = "/usr/bin/ngdbuild"
 map = "/usr/bin/map"

src/Config.ts

@@ -3,59 +3,21 @@ import { plainToClass, Type } from "class-transformer";
 import {
     ArrayNotEmpty,
     ArrayUnique,
-    isBoolean,
     IsBoolean,
     IsHexadecimal,
     IsInt,
     IsNotEmpty,
     IsNumber,
     IsOptional,
     IsPositive,
-    isString,
     IsString,
     Min,
-    ValidateBy,
     ValidateNested,
     validateSync,
-    ValidationOptions,
 } from "class-validator";
 import fs from "fs";
 import { getLogger } from "log4js";
 
-function Or(...constraints: ((value: unknown) => boolean)[]): PropertyDecorator;
-function Or(
-    validationOptions?: ValidationOptions,
-    ...constraints: ((value: unknown) => boolean)[]
-): PropertyDecorator;
-function Or(
-    validationOptions?: ValidationOptions | ((value: unknown) => boolean),
-    ...constraints: ((value: unknown) => boolean)[]
-): PropertyDecorator {
-    if (typeof validationOptions === "function") {
-        constraints = [validationOptions, ...constraints];
-        validationOptions = undefined;
-    }
-    return ValidateBy(
-        {
-            name: "or",
-            constraints,
-            validator: {
-                validate: (value, validationArguments) => {
-                    if (validationArguments) {
-                        for (const constraint of validationArguments.constraints) {
-                            if (constraint(value)) {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                },
-            },
-        },
-        validationOptions
-    );
-}
-
 const logger = getLogger("ConfigService");
 const configToml = fs.readFileSync("config/config.toml").toString();
 export class LanguageConfig {
@@ -64,18 +26,6 @@ export class LanguageConfig {
     cat!: string;
     @IsString()
     @IsNotEmpty()
-    ise!: string;
-    @Or(isBoolean, isString)
-    @IsNotEmpty()
-    shell!: string | boolean;
-    @IsString()
-    @IsNotEmpty()
-    verilog!: string;
-    @IsString()
-    @IsNotEmpty()
-    vhdl!: string;
-    @IsString()
-    @IsNotEmpty()
     xst!: string;
     @IsString()
     @IsNotEmpty()
@@ -157,20 +107,6 @@ export class FpgaConfig {
     })
     serial!: string[];
 }
-export class Builtin {
-    @IsString()
-    @IsNotEmpty()
-    "ax309.ucf"!: string;
-    @IsString()
-    @IsNotEmpty()
-    "main.cmd"!: string;
-    @IsString()
-    @IsNotEmpty()
-    "verilog.prj"!: string;
-    @IsString()
-    @IsNotEmpty()
-    "xc6slx9-2-ftg256.verilog.xst"!: string;
-}
 export class Config {
     @ValidateNested()
     @IsNotEmpty()

src/Spawn/Language/PlainText.ts

@@ -1,50 +1,21 @@
 import path from "path";
 import { getConfig } from "../../Config";
 import {
-    RunOption,
+    ExecType,
     Language,
     LanguageConfigureOption,
-    ExecType,
+    RunOption,
     RunType,
 } from "./decl";
 
 export class PlainText extends Language {
-    private src = "src.in";
-
     constructor(option: LanguageConfigureOption) {
         super(option);
         if (this.execType !== ExecType.Usr)
             throw new Error("Unrecognized language");
     }
 
-    get compileCacheable(): boolean {
-        return true;
-    }
-
-    get srcFileName(): string {
-        return this.src;
-    }
-
-    compileOptionGenerator(): RunOption {
-        return { skip: true };
-    }
-
-    get compiledFiles(): string[] {
-        return [];
-    }
-
-    pragramOptionGenerator(): RunOption {
-        const binPath = path.join(this.runDir, this.src);
-        return {
-            skip: false,
-            command: getConfig().language.cat,
-            args: [binPath],
-        };
-    }
-
-    get judgeTimeout() {
-        return 1000;
-    }
+    srcFileName = "src.in";
 
     [RunType.Synthesis] = {
         cacheable: true,
@@ -85,4 +56,13 @@ export class PlainText extends Language {
             return { skip: true };
         },
     };
+
+    pragramOptionGenerator(): RunOption {
+        const binPath = path.join(this.runDir, this.srcFileName);
+        return {
+            skip: false,
+            command: getConfig().language.cat,
+            args: [binPath],
+        };
+    }
 }

src/Spawn/Language/Verilog.ts

@@ -1,31 +1,8 @@
 import { join } from "path";
-import { Language, RunOption, RunType } from "./decl";
 import { getConfig } from "../../Config";
+import { Language, RunOption, RunType } from "./decl";
 
 export class Verilog extends Language {
-    get compileCacheable() {
-        return true;
-    }
-
-    get compiledFiles() {
-        return [join(this.runDir, "par.bit")];
-    }
-
-    compileOptionGenerator(): RunOption {
-        return {
-            skip: false,
-            command: getConfig().language.verilog,
-            args: [getConfig().language.ise],
-            spawnOption: {
-                timeLimit: 60000,
-            },
-        };
-    }
-
-    get judgeTimeout() {
-        return 1000;
-    }
-
     srcFileName = "main.v";
 
     [RunType.Synthesis] = {

src/Spawn/Language/decl.ts

@@ -54,10 +54,6 @@ export abstract class Language {
         this.excutable = option.excutable;
         this.runDir = option.runDir;
     }
-    abstract get compileCacheable(): boolean;
-    abstract get compiledFiles(): string[];
-    abstract get judgeTimeout(): number;
-    abstract compileOptionGenerator(): RunOption;
     abstract get srcFileName(): string;
     abstract [RunType.Synthesis]: compileOption;
     abstract [RunType.Translate]: compileOption;

src/Spawn/index.ts

@@ -1,9 +1,8 @@
-import { ChildProcess, spawn } from "child_process";
+import { spawn } from "child_process";
 import { getLogger } from "log4js";
+import { constants } from "os";
 import { BasicSpawnOption, CompleteStdioOptions } from "./BasicSpawn";
 import { MeteredChildProcess } from "./Meter";
-import { constants } from "os";
-import { getConfig } from "../Config";
 
 const logger = getLogger("JailMeterSpawn");
 
@@ -22,33 +21,14 @@ export interface HengSpawnOption {
     gid?: number; // nsjail(append root), meter
 }
 
-export function loggedSpawn(
-    spawnFunction: (command: string, args: string[]) => ChildProcess
-): (command: string, args: string[]) => ChildProcess {
-    return function (command: string, args: string[]) {
-        logger.info(`${command} ${args.join(" ")}`);
-        return spawnFunction(command, args);
-    };
-}
-
-// intended typo, seted => set
-export function optionSetedSpawn<V, T>(
-    spawn: (command: string, args: string[], options: V) => T,
-    options: V
-): (command: string, args: string[]) => T {
-    return function (command: string, args: string[]) {
-        return spawn(command, args, options);
-    };
-}
-
 export function hengSpawn(
     command: string,
     args: string[],
     options: HengSpawnOption
 ): MeteredChildProcess {
     const basicOption: BasicSpawnOption = {
         cwd: options.cwd,
-        shell: getConfig().language.shell,
+        // shell: getConfig().language.shell,
         timeout: options.timeLimit,
     };
 
@@ -59,10 +39,8 @@ export function hengSpawn(
     options.stdio.push("pipe");
     basicOption.stdio = options.stdio;
 
-    const subProcess = loggedSpawn(optionSetedSpawn(spawn, basicOption))(
-        command,
-        args
-    );
+    logger.info(`${command} ${args.join(" ")}`);
+    const subProcess = spawn(command, args, basicOption);
     return {
         ...(subProcess as MeteredChildProcess),
         result: new Promise((resolve, reject) => {

src/Utilities/ExecutableAgent.ts

@@ -1,16 +1,16 @@
 import * as crypto from "crypto";
+import fs from "fs";
+import { FileHandle } from "fs/promises";
 import { DynamicFile, Executable } from "heng-protocol";
+import { getLogger } from "log4js";
 import path from "path";
-import fs from "fs";
-import { ExecType, Language, RunType } from "../Spawn/Language/decl";
-import { FileAgent } from "./File";
 import { getBuiltin, getConfig } from "../Config";
+import { hengSpawn, HengSpawnOption } from "../Spawn";
 import { CompleteStdioOptions } from "../Spawn/BasicSpawn";
 import { getConfiguredLanguage } from "../Spawn/Language";
-import { getLogger } from "log4js";
-import { FileHandle } from "fs/promises";
-import { hengSpawn, HengSpawnOption } from "../Spawn";
+import { ExecType, Language, RunType } from "../Spawn/Language/decl";
 import { MeterResult } from "../Spawn/Meter";
+import { FileAgent } from "./File";
 
 export const SourceCodeName = "srcCode";
 export const runLogName = "run.log";

src/Utilities/File.ts

@@ -1,13 +1,13 @@
+import axios from "axios";
+import * as crypto from "crypto";
 import fs from "fs";
+import { getLogger } from "log4js";
+import path, { PlatformPath } from "path";
 import stream, { Readable } from "stream";
 import unzip from "unzip-stream";
-import path, { PlatformPath } from "path";
 import util from "util";
 import { getConfig } from "../Config";
-import * as crypto from "crypto";
 import { Throttle } from "./Throttle";
-import { getLogger } from "log4js";
-import axios from "axios";
 const pipeline = util.promisify(stream.pipeline);
 
 const logger = getLogger("File");

src/Utilities/Judge.ts

@@ -1,3 +1,5 @@
+import * as crypto from "crypto";
+import fs from "fs";
 import {
     Executable,
     JudgeCaseResult,
@@ -9,23 +11,21 @@ import {
     TestPolicy,
 } from "heng-protocol";
 import { CreateJudgeArgs } from "heng-protocol/internal-protocol/ws";
-import path from "path";
-import fs from "fs";
-import os from "os";
+import { range } from "lodash";
 import { getLogger } from "log4js";
+import os from "os";
+import path from "path";
+import { SerialPort } from "serialport";
 import { getConfig } from "../Config";
-import { FileAgent, readStream } from "./File";
-import { Throttle } from "./Throttle";
+import { Controller } from "../controller";
 import { Tests } from "../SelfTest";
-import { runLogName, ExecutableAgent } from "./ExecutableAgent";
 import { ExecType, RunType } from "../Spawn/Language/decl";
-import { range } from "lodash";
-import { Controller } from "../controller";
-import { stat } from "./Statistics";
-import * as crypto from "crypto";
 import { MeterResult } from "../Spawn/Meter";
-import { SerialPort } from "serialport";
+import { ExecutableAgent, runLogName } from "./ExecutableAgent";
+import { FileAgent, readStream } from "./File";
 import { closePort } from "./Serial";
+import { stat } from "./Statistics";
+import { Throttle } from "./Throttle";
 
 const UsrCompileResultTransformer = {
     mle: JudgeResultKind.CompileMemoryLimitExceeded,