archiver/src/index.ts

import Application from "@framework/app/Application";
import EventListener from "@framework/events/EventListener";
import { Logger } from "@framework/log/Logger";
import { Class } from "@framework/types/Utils";
import { sourceFile } from "@framework/utils/utils";
import { Extension } from "@sudobot/extensions/Extension";
import { ChildProcess, fork } from "child_process";
import { Awaitable } from "discord.js";
import "module-alias/register";
import path from "path";
import MessageCreateEventListener from "./events/MessageCreateEventListener";
import { MessageType } from "./types/MessageType";

export default class ArchiverExtension extends Extension {
    private readonly logger = new Logger(`extension:${this.constructor.name}`, true);
    private archiverProcess?: ChildProcess;
    private archiveServerProcess?: ChildProcess;

    protected override events(): Awaitable<Class<EventListener, [Application]>[]> {
        return [MessageCreateEventListener];
    }

    public override postConstruct(): void {
        const archiverProcess = fork(sourceFile(path.resolve(__dirname, "service/ArchiveProcess")));

        archiverProcess.on("message", serializable => {
            if (
                !serializable ||
                typeof serializable !== "object" ||
                !("type" in serializable) ||
                typeof serializable.type !== "string"
            ) {
                return;
            }

            const message = serializable as Record<string, unknown>;
            this.logger.debug("Archiver: ", message);

            switch (message.type) {
                case MessageType.Ping:
                    archiverProcess.send({
                        type: MessageType.Acknowledgement
                    });
                    break;
                case MessageType.ServerReady:
                    this.logger.info("Archive server is ready");
                    break;
                case MessageType.Message:
                    this.logger.info("Archiver: ", message.payload);
                    break;
            }
        });

        archiverProcess.on("error", error => {
            this.logger.error("Archiver: ", error);
        });

        archiverProcess.on("disconnect", () => {
            this.logger.warn("Archiver process disconnected");
        });

        archiverProcess.on("spawn", () => {
            this.logger.info("Archiver process spawned");
        });

        archiverProcess.on("exit", code => {
            if (code !== 0) {
                this.logger.error(`Unexpected archiver process exit with code ${code}`);
            } else {
                this.logger.info("Archiver process exited successfully");
            }
        });

        process.on("beforeExit", () => {
            archiverProcess.kill("SIGKILL");
        });

        setTimeout(() => {
            archiverProcess.send({
                type: MessageType.Ping
            });
        }, 1000);

        this.archiverProcess = archiverProcess;
    }

    public override cleanup() {
        if (this.archiverProcess) {
            this.archiverProcess.kill("SIGTERM");
        }

        if (this.archiveServerProcess) {
            this.archiveServerProcess.kill("SIGTERM");
        }
    }

    public sendToArchiver(message: Record<string, unknown>) {
        this.archiverProcess?.send(message);
    }
}
1	import Application from "@framework/app/Application";
2	import EventListener from "@framework/events/EventListener";
3	import { Logger } from "@framework/log/Logger";
4	import { Class } from "@framework/types/Utils";
5	import { sourceFile } from "@framework/utils/utils";
6	import { Extension } from "@sudobot/extensions/Extension";
7	import { ChildProcess, fork } from "child_process";
8	import { Awaitable } from "discord.js";
9	import "module-alias/register";
10	import path from "path";
11	import MessageCreateEventListener from "./events/MessageCreateEventListener";
12	import { MessageType } from "./types/MessageType";
13
14	export default class ArchiverExtension extends Extension {
15	private readonly logger = new Logger(`extension:${this.constructor.name}`, true);
16	private archiverProcess?: ChildProcess;
17	private archiveServerProcess?: ChildProcess;
18
19	protected override events(): Awaitable<Class<EventListener, [Application]>[]> {
20	return [MessageCreateEventListener];
21	}
22
23	public override postConstruct(): void {
24	const archiverProcess = fork(sourceFile(path.resolve(__dirname, "service/ArchiveProcess")));
25
26	archiverProcess.on("message", serializable => {
27	if (
28	!serializable \|\|
29	typeof serializable !== "object" \|\|
30	!("type" in serializable) \|\|
31	typeof serializable.type !== "string"
32	) {
33	return;
34	}
35
36	const message = serializable as Record<string, unknown>;
37	this.logger.debug("Archiver: ", message);
38
39	switch (message.type) {
40	case MessageType.Ping:
41	archiverProcess.send({
42	type: MessageType.Acknowledgement
43	});
44	break;
45	case MessageType.ServerReady:
46	this.logger.info("Archive server is ready");
47	break;
48	case MessageType.Message:
49	this.logger.info("Archiver: ", message.payload);
50	break;
51	}
52	});
53
54	archiverProcess.on("error", error => {
55	this.logger.error("Archiver: ", error);
56	});
57
58	archiverProcess.on("disconnect", () => {
59	this.logger.warn("Archiver process disconnected");
60	});
61
62	archiverProcess.on("spawn", () => {
63	this.logger.info("Archiver process spawned");
64	});
65
66	archiverProcess.on("exit", code => {
67	if (code !== 0) {
68	this.logger.error(`Unexpected archiver process exit with code ${code}`);
69	} else {
70	this.logger.info("Archiver process exited successfully");
71	}
72	});
73
74	process.on("beforeExit", () => {
75	archiverProcess.kill("SIGKILL");
76	});
77
78	setTimeout(() => {
79	archiverProcess.send({
80	type: MessageType.Ping
81	});
82	}, 1000);
83
84	this.archiverProcess = archiverProcess;
85	}
86
87	public override cleanup() {
88	if (this.archiverProcess) {
89	this.archiverProcess.kill("SIGTERM");
90	}
91
92	if (this.archiveServerProcess) {
93	this.archiveServerProcess.kill("SIGTERM");
94	}
95	}
96
97	public sendToArchiver(message: Record<string, unknown>) {
98	this.archiverProcess?.send(message);
99	}
100	}