chore: stabilize monorepo build and typescript setup

2026-07-20 21:54:36 +02:00
parent 5fd48d1971
commit 4855bb882c
30 changed files with 1536 additions and 405 deletions
@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const amqp = __importStar(require("amqplib"));
+const os_1 = __importDefault(require("os"));
+const config_1 = require("./config");
+const processManager_1 = require("./processManager");
+const statusReporter_1 = require("./statusReporter");
+const queryManager_1 = require("./queryManager");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("Wrapper");
+class Wrapper {
+    constructor() {
+        this.processManager = new processManager_1.ProcessManager();
+        this.queryManager = new queryManager_1.QueryManager(this.processManager);
+    }
+    async start() {
+        const config = (0, config_1.loadConfig)();
+        logger.info("Konfiguration geladen");
+        if (config.wrapperId) {
+            this.id =
+                config.wrapperId;
+            logger.debug("Starte mit vorhandener ID:", this.id);
+        }
+        else {
+            logger.warn("Keine Wrapper ID vorhanden - neue Registrierung");
+        }
+        this.connection =
+            await amqp.connect(config_1.RABBITMQ_URL);
+        this.channel =
+            await this.connection.createChannel();
+        logger.info("RabbitMQ Verbindung hergestellt");
+        this.queryManager.start();
+        await this.register();
+    }
+    async register() {
+        const reply = await this.channel.assertQueue("", {
+            exclusive: true
+        });
+        const replyQueue = reply.queue;
+        await this.channel.consume(replyQueue, msg => {
+            if (!msg)
+                return;
+            const data = JSON.parse(msg.content.toString());
+            logger.debug("Antwort vom Manager:", data.type);
+            if (data.type === "wrapper.registered") {
+                this.id =
+                    data.wrapperId;
+                (0, config_1.saveConfig)({
+                    wrapperId: this.id
+                });
+                logger.info("Registrierung beim Manager erfolgreich");
+                logger.debug("Wrapper ID gespeichert:", this.id);
+                if (!this.id) {
+                    logger.error("Keine Wrapper ID erhalten!");
+                    return;
+                }
+                this.listenCommands(data.commandQueue);
+                const reporter = new statusReporter_1.StatusReporter(this.channel, this.processManager, this.queryManager, this.id);
+                reporter.start();
+            }
+            this.channel.ack(msg);
+        });
+        const message = {
+            type: "wrapper.register",
+            // vorhandene ID mitsenden
+            wrapperId: this.id,
+            hostname: os_1.default.hostname(),
+            cpu: os_1.default.cpus().length,
+            ram: Math.round(os_1.default.totalmem() / 1024 / 1024),
+            replyQueue
+        };
+        await this.channel.sendToQueue("wrapper.register", Buffer.from(JSON.stringify(message)));
+        logger.debug("Registrierung gesendet", this.id ?? "ohne ID");
+    }
+    async listenCommands(queue) {
+        await this.channel.consume(queue, msg => {
+            if (!msg)
+                return;
+            const rawCommand = JSON.parse(msg.content.toString());
+            const commandType = rawCommand.type;
+            switch (commandType) {
+                case "test": {
+                    const command = rawCommand;
+                    logger.debug("TEST COMMAND:", command.message);
+                    break;
+                }
+                case "server.start": {
+                    const command = rawCommand;
+                    this.processManager.startServer(command);
+                    break;
+                }
+                case "server.stop": {
+                    const command = rawCommand;
+                    this.processManager.stopServer(command.serverId);
+                    break;
+                }
+                default:
+                    logger.warn("Unbekannter Command:", commandType);
+            }
+            this.channel.ack(msg);
+        });
+        logger.debug("Warte auf Commands:", queue);
+        this.heartbeat();
+    }
+    heartbeat() {
+        logger.debug("Heartbeat gestartet");
+        setInterval(() => {
+            if (!this.id)
+                return;
+            const heartbeat = {
+                type: "wrapper.heartbeat",
+                wrapperId: this.id
+            };
+            this.channel.sendToQueue("wrapper.register", Buffer.from(JSON.stringify(heartbeat)));
+            logger.debug("Heartbeat gesendet");
+        }, config_1.WRAPPER_HEARTBEAT_INTERVAL);
+    }
+}
+new Wrapper().start();