@fdm-monster/server/dist/state/test-printer-socket.store.js

FDM Monster is a bulk OctoPrint, Klipper, PrusaLink and BambuLab manager to set up, configure and monitor 3D printers. Our aim is to provide neat overview over your farm.

import { validateInput } from "../handlers/validators.js";
import { printerEvents } from "../constants/event.constants.js";
import { AppConstants } from "../server.constants.js";
import { errorSummary } from "../utils/error.utils.js";
import { SOCKET_STATE } from "../shared/dtos/socket-state.type.js";
import { createTestPrinterSchema } from "./validation/create-test-printer.validation.js";
import { WsMessage, octoPrintEvent } from "../services/octoprint/octoprint-websocket.adapter.js";
import { moonrakerEvent } from "../services/moonraker/constants/moonraker.constants.js";
import { bambuEvent } from "../services/bambu/bambu-mqtt.adapter.js";
import { prusaLinkEvent } from "../services/prusa-link/constants/prusalink.constants.js";
import { captureException } from "@sentry/node";
import { setInterval, setTimeout } from "node:timers/promises";
//#region src/state/test-printer-socket.store.ts
const TEST_PRINTER_ID_BASE = 1e5;
let testPrinterIdCounter = 0;
var TestPrinterSocketStore = class TestPrinterSocketStore {
	testSocket;
	logger;
	constructor(loggerFactory, socketFactory, socketIoGateway, eventEmitter2) {
		this.socketFactory = socketFactory;
		this.socketIoGateway = socketIoGateway;
		this.eventEmitter2 = eventEmitter2;
		this.logger = loggerFactory(TestPrinterSocketStore.name);
	}
	async setupTestPrinter(correlationToken, printer) {
		if (this.testSocket) {
			this.testSocket.close();
			delete this.testSocket;
		}
		const validatedData = await validateInput(printer, createTestPrinterSchema);
		validatedData.enabled = true;
		const testPrinterId = TEST_PRINTER_ID_BASE + ++testPrinterIdCounter;
		this.testSocket = this.socketFactory.createInstance(printer.printerType);
		this.testSocket.registerCredentials({
			printerId: testPrinterId,
			loginDto: {
				apiKey: printer.apiKey,
				username: printer.username ?? void 0,
				password: printer.password ?? void 0,
				printerURL: printer.printerURL,
				printerType: printer.printerType
			}
		});
		const testEvents = [
			octoPrintEvent(WsMessage.WS_STATE_UPDATED),
			octoPrintEvent(WsMessage.API_STATE_UPDATED),
			octoPrintEvent(WsMessage.WS_CLOSED),
			octoPrintEvent(WsMessage.WS_OPENED),
			octoPrintEvent(WsMessage.WS_ERROR),
			moonrakerEvent(WsMessage.WS_STATE_UPDATED),
			moonrakerEvent(WsMessage.API_STATE_UPDATED),
			moonrakerEvent(WsMessage.WS_CLOSED),
			moonrakerEvent(WsMessage.WS_OPENED),
			moonrakerEvent(WsMessage.WS_ERROR),
			bambuEvent(WsMessage.WS_STATE_UPDATED),
			bambuEvent(WsMessage.API_STATE_UPDATED),
			bambuEvent(WsMessage.WS_CLOSED),
			bambuEvent(WsMessage.WS_OPENED),
			bambuEvent(WsMessage.WS_ERROR),
			prusaLinkEvent(WsMessage.WS_STATE_UPDATED),
			prusaLinkEvent(WsMessage.API_STATE_UPDATED),
			prusaLinkEvent(WsMessage.WS_CLOSED),
			prusaLinkEvent(WsMessage.WS_OPENED),
			prusaLinkEvent(WsMessage.WS_ERROR)
		];
		const listener = ({ event, payload, printerId }) => {
			if (printerId !== testPrinterId) return;
			this.socketIoGateway.send("test-printer-state", {
				event,
				payload,
				correlationToken
			});
		};
		testEvents.forEach((te) => {
			this.eventEmitter2.on(te, listener);
		});
		try {
			this.logger.log("Test API calls for authentication and session");
			await this.testSocket.setupSocketSession();
			this.logger.log("Test socket connection started");
			const promise = new Promise(async (resolve, reject) => {
				if (!this.testSocket) {
					this.logger.error("Aborting test as testSocket is undefined.");
					return;
				}
				this.testSocket.open();
				for await (const _startTime of setInterval(100)) {
					if (!this.testSocket) {
						this.logger.warn("Test without socket, rejecting");
						reject(/* @__PURE__ */ new Error("Test without socket, rejecting"));
						return;
					}
					if (this.testSocket.socketState === SOCKET_STATE.authenticated) {
						this.logger.log("Test completed successfully, resolving");
						resolve(true);
						break;
					}
				}
			});
			await Promise.race([promise, setTimeout(AppConstants.defaultWebsocketHandshakeTimeout)]);
			this.logger.log("Test finalized");
		} catch (e) {
			this.logger.error(`Test harness error ${errorSummary(e)}`);
			captureException(e);
		} finally {
			this.testSocket.disallowEmittingEvents();
			if (this.testSocket) this.testSocket.close();
			this.eventEmitter2.emit(printerEvents.printersDeleted, { printerIds: [testPrinterId] });
			delete this.testSocket;
			testEvents.forEach((te) => {
				this.eventEmitter2.off(te, listener);
			});
		}
	}
};
//#endregion
export { TestPrinterSocketStore };

//# sourceMappingURL=test-printer-socket.store.js.map