@vpalmisano/webrtcperf 4.0.0

package/build/src/server.js

@@ -0,0 +1,639 @@
+"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 });
+exports.Server = void 0;
+const compression_1 = __importDefault(require("compression"));
+const crypto_1 = require("crypto");
+const express_1 = __importStar(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const http_1 = require("http");
+const https_1 = require("https");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const tar_fs_1 = __importDefault(require("tar-fs"));
+const ws_1 = require("ws");
+const zlib_1 = __importDefault(require("zlib"));
+const basic_auth_1 = __importDefault(require("basic-auth"));
+const config_1 = require("./config");
+const session_1 = require("./session");
+const utils_1 = require("./utils");
+const log = (0, utils_1.logger)('webrtcperf:server');
+/**
+ * An HTTP server instance that allows to control the tool using a REST
+ * interface. Moreover, it allows to aggregate stats data coming from multiple
+ * running tool instances.
+ */
+class Server {
+    /** The server listening port. */
+    serverPort;
+    /** The basic auth secret. */
+    serverSecret;
+    /** If HTTPS protocol should be used. */
+    serverUseHttps;
+    /** An optional path that the HTTP server will expose with the /data endpoint. */
+    serverData;
+    /** The file path that will be used to serve the \`/view/page.log\` requests. */
+    pageLogPath;
+    /** The path that will be used to serve the \`/cache\` requests. */
+    videoCachePath;
+    /** A {@link Stats} class instance. */
+    stats;
+    app;
+    server = null;
+    wss = null;
+    /**
+     * Server instance.
+     * All the HTTP endpoints are protected by basic authentication with user
+     * `admin` and password {@link Server.serverSecret}.
+     * @param serverPort The server listening port.
+     * @param serverSecret The basic auth secret.
+     * @param serverUseHttps If HTTPS protocol should be used.
+     * @param serverData An optional path that the HTTP server will expose with the /data endpoint.
+     * @param pageLogPath The file path that will be used to serve the \`/view/page.log\` requests.
+     * @param videoCachePath The path that will be used to serve the \`/cache\` requests.
+     * @param stats A {@link Stats} class instance.
+     */
+    constructor({ serverPort = 5000, serverSecret = 'secret', serverUseHttps = false, serverData = '', pageLogPath = '', videoCachePath = '', } = {}, stats) {
+        this.serverPort = serverPort;
+        this.serverSecret = serverSecret;
+        this.serverUseHttps = serverUseHttps;
+        this.serverData = serverData;
+        this.pageLogPath = pageLogPath;
+        this.videoCachePath = videoCachePath;
+        this.stats = stats;
+        //
+        this.app = (0, express_1.default)();
+        this.app.use((0, compression_1.default)());
+        this.app.use((0, express_1.json)({
+            limit: '10mb',
+        }));
+        this.app.use((req, res, next) => {
+            if (req.query.auth === this.serverSecret) {
+                return next();
+            }
+            const credentials = (0, basic_auth_1.default)(req);
+            if (!credentials || credentials.name !== 'admin' || credentials.pass !== this.serverSecret) {
+                res.setHeader('WWW-Authenticate', 'Basic realm="Restricted Area"');
+                res.status(401).send('Unauthorized');
+                return;
+            }
+            next();
+        });
+        this.app.get('/', (_req, res) => {
+            res.send('');
+        });
+        this.app.get('/stats', this.getStats.bind(this));
+        this.app.get('/collected-stats', this.getCollectedStats.bind(this));
+        this.app.get('/screenshot/:sessionId', this.getScreenshot.bind(this));
+        this.app.put('/collected-stats', this.putCollectedStats.bind(this));
+        this.app.put('/session', this.putSession.bind(this));
+        this.app.put('/sessions', this.putSessions.bind(this));
+        this.app.delete('/session', this.deleteSession.bind(this));
+        this.app.delete('/sessions', this.deleteSessions.bind(this));
+        this.app.get('/view/page.log', this.getPageLog.bind(this));
+        this.app.get('/view/docker.log', this.getDockerLog.bind(this));
+        this.app.get('/download/alert-rules', this.getAlertRules.bind(this));
+        this.app.get('/download/stats', this.getStatsFile.bind(this));
+        this.app.get('/download/detailed-stats', this.getDetailedStatsFile.bind(this));
+        this.app.get('/empty-page', this.getEmptyPage.bind(this));
+        if (this.serverData) {
+            log.debug(`using serverData: ${this.serverData}`);
+            fs_1.default.promises.mkdir(this.serverData, { recursive: true }).catch(err => {
+                log.error(`mkdir ${this.serverData} error: ${err.message}`);
+            });
+            this.app.get('/data', this.getDataArchive.bind(this));
+            this.app.get('/data/*', this.getData.bind(this));
+        }
+        if (this.videoCachePath) {
+            log.debug(`using videoCachePath: ${this.videoCachePath}`);
+            fs_1.default.promises.mkdir(this.videoCachePath, { recursive: true }).catch(err => {
+                log.error(`mkdir ${this.videoCachePath} error: ${err.message}`);
+            });
+            this.app.get('/cache/*', this.getCache.bind(this));
+        }
+        this.app.use((err, req, res, next) => {
+            log.error(`request path=${req.path} error:`, err.stack);
+            if (res.headersSent) {
+                return next(err);
+            }
+            res.status(500).send(err.message);
+        });
+    }
+    /*
+     * onConnection
+     * @param {Socket} socket
+     */
+    /* onConnection(socket) {
+      log.debug('onConnection', socket);
+  
+      socket.on('disconnect', () => {
+        log.debug('io socket disconnected');
+      });
+  
+      socket.on('message', (msg) => {
+        log.debug('message', msg);
+      });
+    } */
+    /**
+     * GET /stats endpoint.
+     *
+     * Returns a JSON array of the last statistics for each running Session.
+     */
+    async getStats(req, res, next) {
+        log.debug(`GET /stats`);
+        const stats = [];
+        try {
+            for (const session of this.stats.sessions.values()) {
+                stats.push(session.stats);
+            }
+            res.json(stats);
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * GET /download/stats endpoint.
+     *
+     * Returns the {@link Stats.statsWriter} file content.
+     */
+    getStatsFile(req, res, next) {
+        log.debug(`/download/stats`, req.query);
+        if (!this.stats.statsWriter) {
+            return next(new Error('statsPath not set'));
+        }
+        res.download(this.stats.statsPath);
+    }
+    /**
+     * GET /download/detailed-stats endpoint.
+     *
+     * Returns the {@link Stats.detailedStatsWriter} file content.
+     */
+    getDetailedStatsFile(req, res, next) {
+        log.debug(`/download/detailed-stats`, req.query);
+        if (!this.stats.detailedStatsWriter) {
+            return next(new Error('detailedStatsPath not set'));
+        }
+        res.download(this.stats.detailedStatsPath);
+    }
+    /**
+     * GET /collected-stats endpoint.
+     *
+     * Returns a JSON array of the last statistics collected from external running
+     * tools.
+     */
+    getCollectedStats(req, res, next) {
+        log.debug(`GET /collected-stats`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const stats = {};
+        try {
+            for (const [key, stat] of Object.entries(this.stats.collectedStats)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stats[key] = stat.data;
+            }
+            res.json(stats);
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * GET /screenshot/<sessionID> endpoint.
+     *
+     * Returns the page screenshot running inside the {@link Session} identified
+     * by `sessionID`.
+     * Additional query params:
+     * - `page`: the page number (starting from `0`) running inside the {@link Session}.
+     * - `format`: the image format (`jpeg`, `png`, `webp`). Default: `webp`.
+     */
+    async getScreenshot(req, res, next) {
+        const sessionId = parseInt(req.params.sessionId);
+        const pageId = parseInt(req.query.page || '0');
+        const format = req.query.format || 'webp';
+        log.debug(`GET /screenshot/${sessionId} page=${pageId} format=${format}`);
+        try {
+            const session = this.stats.sessions.get(sessionId);
+            if (!session) {
+                throw new Error(`Session not found: "${sessionId}"`);
+            }
+            const filePath = await session.pageScreenshot(pageId, format);
+            res.sendFile(path_1.default.resolve(filePath));
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * PUT /collected-stats endpoint.
+     *
+     * Allows to inject {@link Stats} metrics coming from an external tool.
+     */
+    putCollectedStats(req, res, next) {
+        log.debug(`PUT /collected-stats`);
+        const { id, stats, config } = req.body;
+        try {
+            this.stats.addExternalCollectedStats(id, stats, config);
+            res.json({
+                message: `Collected stats added`,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * PUT /session endpoint.
+     *
+     * Starts a new {@link Session}.
+     * The request body format will be parsed as a {@link SessionParams} object.
+     */
+    async putSession(req, res, next) {
+        log.debug(`PUT /session`, req.body);
+        try {
+            const id = this.stats.consumeSessionId();
+            await this.startLocalSession(id, req.body);
+            res.json({
+                message: `Session created`,
+                data: { id },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * PUT /sessions endpoint.
+     *
+     * Starts multiple {@link Session} instances as specified into the
+     * `body.sessions` value.
+     * The request body will be parsed as a {@link SessionParams} object.
+     */
+    async putSessions(req, res, next) {
+        log.debug(`PUT /sessions`, req.body);
+        try {
+            const { sessions } = req.body;
+            const sessionsIds = [];
+            for (let i = 0; i < sessions; i++) {
+                const id = this.stats.sessions.size;
+                await this.startLocalSession(id, req.body);
+                sessionsIds.push(id);
+            }
+            res.json({
+                message: `${sessions} sessions created`,
+                data: { ids: sessionsIds },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * DELETE /session endpoint.
+     *
+     * Delete the {@link Session} instance identified by the `body.id` param.
+     */
+    async deleteSession(req, res, next) {
+        log.debug(`DELETE /session`, req.body);
+        try {
+            const { id } = req.body;
+            await this.stopLocalSession(id);
+            res.json({
+                message: `Session deleted`,
+                data: { id },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * DELETE /sessions endpoint.
+     *
+     * Delete the {@link Session} instances specified by the `body.ids` array.
+     */
+    async deleteSessions(req, res, next) {
+        log.debug(`DELETE /sessions`, req.body);
+        try {
+            const { ids } = req.body;
+            for (const id of ids) {
+                await this.stopLocalSession(id);
+            }
+            res.json({
+                message: `${ids.length} sessions deleted`,
+                data: { ids },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * GET /view/page.log endpoint.
+     *
+     * Returns the page log file content as specified in {@link Config} `pageLogPath`.
+     */
+    getPageLog(req, res, next) {
+        log.debug(`GET /view/page.log`, req.query);
+        if (!this.pageLogPath) {
+            return next(new Error('pageLogPath not set'));
+        }
+        if (req.query.range && !req.headers.range) {
+            req.headers.range = `bytes=${req.query.range}`;
+        }
+        res.sendFile(path_1.default.resolve(this.pageLogPath));
+    }
+    /**
+     * GET /view/docker.log endpoint.
+     *
+     * Returns the Docker logs related to the container running the tool.
+     * It requires to run the Docker container with the following options:
+     * ```
+       --cidfile /tmp/docker.id
+       -v /tmp/docker.id:/root/.webrtcperf/docker.id:ro
+       -v /var/lib/docker:/var/lib/docker:ro
+     * ```
+     */
+    async getDockerLog(req, res, next) {
+        log.debug(`GET /view/docker.log`, req.query);
+        try {
+            const logPath = await (0, utils_1.getDockerLogsPath)();
+            if (req.query.range && !req.headers.range) {
+                req.headers.range = `bytes=${req.query.range}`;
+            }
+            res.sendFile(path_1.default.resolve(logPath));
+        }
+        catch (err) {
+            next(err);
+        }
+    }
+    /**
+     * GET /download/alert-rules endpoint.
+     *
+     * Downloads the alert rules report stored into the {@link Stats.alertRulesFilename}.
+     */
+    getAlertRules(req, res, next) {
+        log.debug(`GET /download/alert-rules`, req.query);
+        if (!this.stats.alertRulesFilename) {
+            return next(new Error('Stats alertRulesFilename not set'));
+        }
+        res.download(this.stats.alertRulesFilename);
+    }
+    /**
+     * GET /empty-page endpoint.
+     *
+     * Returns an empty HTML page. Useful for running tests with raw Javascript
+     * content without any DOM rendering.
+     */
+    getEmptyPage(req, res) {
+        log.debug(`GET /empty-page`, req.query);
+        const title = req.query.title || 'EmptyPage';
+        res.send(`<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+</head>
+<body></body>
+</html>`);
+    }
+    /**
+     * GET /data/* endpoint.
+     *
+     * Returns the file content relative to the {@link Config} `serverData` path.
+     * If the requested path points to a directory, it returns the directory
+     * content in tar.gz format.
+     */
+    getData(req, res, next) {
+        const paramPath = path_1.default.normalize(req.params[0]).replace(/^(\.\.(\/|\\|$))+/, '');
+        log.debug(`GET /data/${paramPath}`, req.query);
+        const fpath = path_1.default.resolve(this.serverData, paramPath);
+        if (!fs_1.default.existsSync(fpath)) {
+            return next(new Error(`${paramPath} not found`));
+        }
+        if (req.query.range && !req.headers.range) {
+            req.headers.range = `bytes=${req.query.range}`;
+        }
+        res.sendFile(fpath);
+    }
+    getDataArchive(req, res, next) {
+        log.debug(`GET /data`, req.query);
+        const fpath = path_1.default.resolve(this.serverData);
+        if (!fs_1.default.lstatSync(fpath).isDirectory()) {
+            return next(new Error(`${fpath} is not a directory`));
+        }
+        res.header('Content-Disposition', `attachment; filename="${path_1.default.basename(fpath)}.tar.gz"`);
+        res.setHeader('content-type', 'application/gzip');
+        tar_fs_1.default.pack(fpath).pipe(zlib_1.default.createGzip()).pipe(res);
+    }
+    getCache(req, res, next) {
+        const paramPath = path_1.default.normalize(req.params[0]).replace(/^(\.\.(\/|\\|$))+/, '');
+        log.debug(`GET /cache/${paramPath}`, req.query);
+        const fpath = path_1.default.resolve(this.videoCachePath, paramPath);
+        if (!fs_1.default.existsSync(fpath)) {
+            return next(new Error(`${paramPath} not found`));
+        }
+        if (req.query.range && !req.headers.range) {
+            req.headers.range = `bytes=${req.query.range}`;
+        }
+        res.sendFile(fpath);
+    }
+    /**
+     * Starts a new {@link Session} instance.
+     * @param id The session unique id.
+     * @param config The session configuration.
+     */
+    async startLocalSession(id, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sessionConfig = (0, config_1.loadConfig)(undefined, config);
+        const session = new session_1.Session({ ...sessionConfig, id });
+        session.once('stop', () => {
+            console.warn(`Session ${id} stopped, reloading...`);
+            setTimeout(this.startLocalSession.bind(this), sessionConfig.spawnPeriod, id, config);
+        });
+        this.stats.addSession(session);
+        try {
+            await session.start();
+        }
+        catch (err) {
+            this.stats.removeSession(session.id);
+            throw err;
+        }
+        return session;
+    }
+    /**
+     * Stops a new {@link Session} instance.
+     * @param {number} id The session unique id.
+     */
+    async stopLocalSession(id) {
+        const session = this.stats.sessions.get(id);
+        if (!session) {
+            log.warn(`stopLocalSession session ${id} not found`);
+            return;
+        }
+        session.removeAllListeners();
+        this.stats.removeSession(id);
+        await session.stop();
+    }
+    /**
+     * Starts the {@link Server} instance.
+     */
+    async start() {
+        log.debug('start');
+        if (this.serverUseHttps) {
+            const destDir = path_1.default.join(os_1.default.homedir(), '.webrtcperf/ssl');
+            await (0, utils_1.runShellCommand)(`mkdir -p ${destDir} && openssl req -newkey rsa:2048 -nodes -keyout ${destDir}/domain.key -x509 -days 365 -out ${destDir}/domain.crt -subj "/C=EU/ST=London/L=London/O=Global Security/OU=IT Department/CN=example.com"`);
+            this.server = (0, https_1.createServer)({
+                key: fs_1.default.readFileSync(`${destDir}/domain.key`),
+                cert: fs_1.default.readFileSync(`${destDir}/domain.crt`),
+            }, this.app);
+        }
+        else {
+            this.server = (0, http_1.createServer)(this.app);
+        }
+        // WebSocket endpoint.
+        const wss = new ws_1.WebSocketServer({ noServer: true });
+        wss.on('connection', (ws, request) => {
+            try {
+                const query = new URLSearchParams(request.url?.split('?')[1] || '');
+                const action = query.get('action') || '';
+                log.debug(`ws connection from ${request.socket.remoteAddress} action: ${action}`);
+                switch (action) {
+                    case 'write-stream': {
+                        if (!this.serverData) {
+                            throw new Error('serverData option not set');
+                        }
+                        const filename = query.get('filename') || '';
+                        if (!filename) {
+                            throw new Error('filename not set');
+                        }
+                        const paramPath = path_1.default.normalize(filename).replace(/^(\.\.(\/|\\|$))+/, '');
+                        log.debug(`ws write-stream ${paramPath}`);
+                        const fpath = path_1.default.resolve(this.serverData, paramPath);
+                        if (fs_1.default.existsSync(fpath)) {
+                            throw new Error(`file already exists: ${fpath}`);
+                        }
+                        const stream = fs_1.default.createWriteStream(fpath);
+                        let headerWritten = false;
+                        let framesWritten = 0;
+                        const close = async () => {
+                            stream.close();
+                            ws.close();
+                            try {
+                                if (!framesWritten) {
+                                    await fs_1.default.promises.unlink(fpath);
+                                }
+                            }
+                            catch (err) {
+                                log.error(`ws write-stream close error: ${err.message}`);
+                            }
+                        };
+                        stream.on('error', (err) => {
+                            log.error(`ws write-stream error: ${err.message}`);
+                            void close();
+                        });
+                        ws.on('error', (err) => {
+                            log.error(`ws write-stream error: ${err.message}`);
+                            void close();
+                        });
+                        ws.on('close', () => {
+                            log.debug(`ws write-stream close`);
+                            void close();
+                        });
+                        ws.on('message', (data) => {
+                            if (!data?.byteLength)
+                                return;
+                            if (!headerWritten) {
+                                stream.write(data);
+                                headerWritten = true;
+                                return;
+                            }
+                            stream.write(data);
+                            framesWritten++;
+                        });
+                        break;
+                    }
+                    default:
+                        throw new Error(`invalid action: ${action}`);
+                }
+            }
+            catch (err) {
+                log.error(`ws connection error: ${err.message}`);
+                ws.close();
+            }
+        });
+        this.wss = wss;
+        this.server.on('upgrade', (request, socket, head) => {
+            log.debug(`ws upgrade ${request.url}`);
+            try {
+                const query = new URLSearchParams(request.url?.split('?')[1] || '');
+                const auth = query.get('auth');
+                if (!auth || !(0, crypto_1.timingSafeEqual)(Buffer.from(auth), Buffer.from(this.serverSecret))) {
+                    throw new Error('invalid auth');
+                }
+            }
+            catch (err) {
+                log.error(`ws upgrade error: ${err.message}`);
+                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            wss.handleUpgrade(request, socket, head, ws => {
+                wss.emit('connection', ws, request);
+            });
+        });
+        this.server.listen(this.serverPort, () => {
+            log.debug(`HTTPS server listening on port ${this.serverPort}`);
+        });
+    }
+    /**
+     * Stops the {@link Server} instance.
+     */
+    stop() {
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+        if (this.server) {
+            log.debug('stop');
+            this.server.close();
+            this.server = null;
+        }
+    }
+}
+exports.Server = Server;
+//# sourceMappingURL=server.js.map