@testring/devtool-backend/dist/devtool-server-controller.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DevtoolServerController = void 0;
const path = require("path");
const child_process_1 = require("@testring/child-process");
const utils_1 = require("@testring/utils");
const pluggable_module_1 = require("@testring/pluggable-module");
const logger_1 = require("@testring/logger");
const default_devtool_config_1 = require("./default-devtool-config");
const devtool_extension_1 = require("@testring/devtool-extension");
class DevtoolServerController extends pluggable_module_1.PluggableModule {
    constructor(transport) {
        super([
            "beforeStart" /* beforeStart */,
            "afterStart" /* afterStart */,
            "beforeStop" /* beforeStop */,
            "afterStop" /* afterStop */,
        ]);
        this.transport = transport;
        this.logger = logger_1.loggerClient.withPrefix('[recorder-server]');
    }
    getConfig() {
        return default_devtool_config_1.defaultDevtoolConfig;
    }
    getRuntimeConfiguration() {
        if (this.config === undefined) {
            throw Error('Configuration is not initialized yet');
        }
        else {
            const { httpPort, wsPort, host, } = this.config;
            return {
                extensionId: devtool_extension_1.extensionId,
                httpPort,
                wsPort,
                host,
            };
        }
    }
    getWorkerID() {
        if (!this.workerID) {
            this.workerID = `recorder/${utils_1.generateUniqId()}`;
        }
        return this.workerID;
    }
    startServer() {
        return __awaiter(this, void 0, void 0, function* () {
            const workerPath = path.resolve(__dirname, 'worker');
            const workerID = this.getWorkerID();
            this.worker = yield child_process_1.fork(workerPath);
            if (this.worker.stdout) {
                this.worker.stdout.on('data', (data) => {
                    this.logger.log(`[logged] ${data.toString().trim()}`);
                });
            }
            else {
                this.logger.warn(`[logged] The STDOUT of worker ${this.getWorkerID()} is null`);
            }
            if (this.worker.stderr) {
                this.worker.stderr.on('data', (data) => {
                    this.logger.warn(`[logged] ${data.toString().trim()}`);
                });
            }
            else {
                this.logger.warn(`[logged] The STDERR of worker ${this.getWorkerID()} is null`);
            }
            this.transport.registerChild(workerID, this.worker);
            this.logger.debug(`Registered child process ${workerID}`);
        });
    }
    stopServer() {
        return __awaiter(this, void 0, void 0, function* () {
            this.worker.kill();
        });
    }
    addToServerProxyHandler(messageType) {
        const toServerHandler = (messageData, processID = null) => {
            this.transport.send(this.getWorkerID(), "RecorderMessage/TO_WORKER" /* TO_WORKER */, {
                source: processID,
                messageType,
                messageData,
            });
        };
        this.transport.on(messageType, toServerHandler);
    }
    handleProxiedMessage(message) {
        if (message.source) {
            this.transport.send(message.source, message.messageType, message.messageData);
        }
        else {
            this.transport.broadcastLocal(message.messageType, message.messageData);
        }
    }
    initMessagesProxy() {
        [
            "TestWorkerAction/register" /* register */,
            "TestWorkerAction/updateExecutionState" /* updateExecutionState */,
            "TestWorkerAction/unregister" /* unregister */,
            "WebApplication/register" /* register */,
            "WebApplication/unregister" /* unregister */,
        ].forEach((event) => this.addToServerProxyHandler(event));
        this.transport.on("RecorderMessage/FROM_WORKER" /* FROM_WORKER */, (payload) => {
            this.handleProxiedMessage(payload);
        });
    }
    init() {
        return __awaiter(this, void 0, void 0, function* () {
            this.config = yield this.callHook("beforeStart" /* beforeStart */, this.getConfig());
            yield this.startServer();
            this.transport.send(this.getWorkerID(), "RecorderServerEvents/START_SERVER" /* START_SERVER */, this.config);
            let caughtError = null;
            let pending = true;
            let handler = (error) => {
                caughtError = error;
                pending = false;
            };
            this.transport.once("RecorderServerEvents/START_SERVER_COMPLETE" /* START_SERVER_COMPLETE */, (error) => handler(error));
            yield new Promise((resolve, reject) => {
                if (pending) {
                    handler = (error) => {
                        if (error) {
                            reject(error);
                        }
                        else {
                            resolve();
                        }
                    };
                }
                else if (caughtError) {
                    reject(caughtError);
                }
                else {
                    resolve();
                }
            });
            yield this.initMessagesProxy();
            yield this.callHook("afterStart" /* afterStart */);
        });
    }
    kill() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.callHook("beforeStop" /* beforeStop */);
            yield this.stopServer();
            yield this.callHook("afterStop" /* afterStop */);
        });
    }
}
exports.DevtoolServerController = DevtoolServerController;