@vpalmisano/webrtcperf 4.0.0

package/build/src/utils.js

@@ -0,0 +1,1220 @@
+"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.FFProbeProcess = exports.PeerConnectionExternal = exports.Scheduler = exports.LoggerInterface = exports.Log = void 0;
+exports.logger = logger;
+exports.resolvePackagePath = resolvePackagePath;
+exports.sha256 = sha256;
+exports.getProcessStats = getProcessStats;
+exports.getSocketStats = getSocketStats;
+exports.getSystemStats = getSystemStats;
+exports.startUpdateSystemStats = startUpdateSystemStats;
+exports.stopTimers = stopTimers;
+exports.sleep = sleep;
+exports.startRandomActivateAudio = startRandomActivateAudio;
+exports.stopRandomActivateAudio = stopRandomActivateAudio;
+exports.randomActivateAudio = randomActivateAudio;
+exports.downloadUrl = downloadUrl;
+exports.uploadUrl = uploadUrl;
+exports.hideAuth = hideAuth;
+exports.registerExitHandler = registerExitHandler;
+exports.unregisterExitHandler = unregisterExitHandler;
+exports.runExitHandlersNow = runExitHandlersNow;
+exports.checkChromeExecutable = checkChromeExecutable;
+exports.clampMinMax = clampMinMax;
+exports.runShellCommand = runShellCommand;
+exports.resolveIP = resolveIP;
+exports.stripColors = stripColors;
+exports.systemGpuStats = systemGpuStats;
+exports.toTitleCase = toTitleCase;
+exports.getFiles = getFiles;
+exports.toPrecision = toPrecision;
+exports.getDefaultNetworkInterface = getDefaultNetworkInterface;
+exports.checkNetworkInterface = checkNetworkInterface;
+exports.portForwarder = portForwarder;
+exports.pageScreenshot = pageScreenshot;
+exports.enabledForSession = enabledForSession;
+exports.increaseKey = increaseKey;
+exports.chunkedPromiseAll = chunkedPromiseAll;
+exports.maybeNumber = maybeNumber;
+exports.ffprobe = ffprobe;
+exports.buildIvfHeader = buildIvfHeader;
+exports.ffmpeg = ffmpeg;
+exports.analyzeColors = analyzeColors;
+exports.waitStopProcess = waitStopProcess;
+exports.getDockerLogsPath = getDockerLogsPath;
+const browsers_1 = require("@puppeteer/browsers");
+const child_process_1 = require("child_process");
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = require("crypto");
+const dns = __importStar(require("dns"));
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = __importStar(require("fs"));
+const https_1 = require("https");
+const ipaddrJs = __importStar(require("ipaddr.js"));
+const net_1 = __importDefault(require("net"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const OSUtils = __importStar(require("node-os-utils"));
+const os_1 = __importStar(require("os"));
+const path_1 = __importStar(require("path"));
+const pidtree_1 = __importDefault(require("pidtree"));
+const pidusage_1 = __importDefault(require("pidusage"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+// eslint-disable-next-line
+const ps = require('pidusage/lib/ps');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.Log = require('debug-level').Log;
+function logger(name, options = {}) {
+    return new exports.Log(name, { splitLine: false, ...options });
+}
+class LoggerInterface {
+    name;
+    logInit(args) {
+        if (this.name) {
+            args.unshift(`[${this.name}]`);
+        }
+    }
+    debug(...args) {
+        this.logInit(args);
+        log.debug(...args);
+    }
+    info(...args) {
+        this.logInit(args);
+        log.info(...args);
+    }
+    warn(...args) {
+        this.logInit(args);
+        log.warn(...args);
+    }
+    error(...args) {
+        this.logInit(args);
+        log.error(...args);
+    }
+    log(...args) {
+        this.logInit(args);
+        log.log(...args);
+    }
+}
+exports.LoggerInterface = LoggerInterface;
+const log = logger('webrtcperf:utils');
+/**
+ * Resolves the absolute path from the package installation directory.
+ * @param relativePath The relative path.
+ * @returns The absolute path.
+ */
+function resolvePackagePath(relativePath) {
+    if ('__nexe' in process) {
+        return relativePath;
+    }
+    if (process.env.WEBPACK) {
+        return path_1.default.join(path_1.default.dirname(__filename), relativePath);
+    }
+    const libPath = require.resolve(relativePath);
+    if (fs_1.default.existsSync(libPath)) {
+        return libPath;
+    }
+    for (const d of ['..', '../..']) {
+        const p = path_1.default.join(__dirname, d, relativePath);
+        if (fs_1.default.existsSync(p)) {
+            return require.resolve(p);
+        }
+    }
+    throw new Error(`resolvePackagePath: ${relativePath} not found`);
+}
+/**
+ * Calculates the sha256 sum.
+ * @param data The string input
+ */
+function sha256(data) {
+    return (0, crypto_1.createHash)('sha256').update(data).digest('hex');
+}
+const ProcessStatsCache = new node_cache_1.default({ stdTTL: 5, checkperiod: 10 });
+const ProcessChildrenCache = new node_cache_1.default({ stdTTL: 15, checkperiod: 15 });
+/**
+ * Returns the process stats.
+ * @param pid The process pid
+ * @param children If process children should be taken into account.
+ * @returns
+ */
+async function getProcessStats(pid = 0, children = false) {
+    const processPid = pid || process.pid;
+    let stat = ProcessStatsCache.get(processPid);
+    if (stat) {
+        return stat;
+    }
+    const pidStats = await (0, pidusage_1.default)(processPid);
+    if (pidStats) {
+        stat = {
+            cpu: pidStats.cpu,
+            memory: pidStats.memory / 1e6,
+        };
+    }
+    else {
+        stat = { cpu: 0, memory: 0 };
+    }
+    if (children) {
+        try {
+            let childrenPids = ProcessChildrenCache.get(processPid);
+            if (!childrenPids?.length) {
+                childrenPids = await (0, pidtree_1.default)(processPid);
+                if (childrenPids?.length) {
+                    ProcessChildrenCache.set(processPid, childrenPids);
+                }
+            }
+            if (childrenPids?.length) {
+                const pidStats = await (0, pidusage_1.default)(childrenPids);
+                for (const p of childrenPids) {
+                    if (pidStats[p]) {
+                        stat.cpu += pidStats[p].cpu;
+                        stat.memory += pidStats[p].memory / 1e6;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            log.error(`getProcessStats children error: ${err.stack}`);
+        }
+    }
+    ProcessStatsCache.set(processPid, stat);
+    return stat;
+}
+async function getSocketStats(processPid) {
+    const stats = { recvBytes: 0, sendBytes: 0 };
+    try {
+        const { stdout } = await runShellCommand(`ss -nOHpti | { grep pid=${processPid} || true; }`);
+        for (const { groups } of stdout.matchAll(/bytes_sent:(?<sendBytes>\d+).+bytes_received:(?<recvBytes>\d+)/g)) {
+            if (!groups)
+                continue;
+            const recvBytes = parseInt(groups.recvBytes);
+            const sendBytes = parseInt(groups.sendBytes);
+            stats.recvBytes += recvBytes;
+            stats.sendBytes += sendBytes;
+        }
+    }
+    catch (err) {
+        log.error(`socketStats error: ${err.stack}`);
+    }
+    return stats;
+}
+// System stats.
+const SystemStatsCache = new node_cache_1.default({ stdTTL: 30, checkperiod: 60 });
+async function updateSystemStats() {
+    const [cpu, memInfo, gpuStats] = await Promise.all([OSUtils.cpu.free(10000), OSUtils.mem.info(), systemGpuStats()]);
+    const stat = {
+        usedCpu: 100 - cpu,
+        usedMemory: 100 - memInfo.freeMemPercentage,
+        usedGpu: gpuStats.gpu,
+        usedGpuMemory: gpuStats.mem,
+    };
+    SystemStatsCache.set('default', stat);
+}
+let systemStatsInterval = null;
+function getSystemStats() {
+    if (!systemStatsInterval) {
+        startUpdateSystemStats();
+    }
+    return SystemStatsCache.get('default');
+}
+function startUpdateSystemStats() {
+    if (systemStatsInterval) {
+        return;
+    }
+    systemStatsInterval = setInterval(updateSystemStats, 5000);
+}
+function stopTimers() {
+    if (systemStatsInterval) {
+        clearInterval(systemStatsInterval);
+        systemStatsInterval = null;
+    }
+}
+/**
+ * Sleeps for the specified amount of time.
+ * @param ms
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(() => resolve(), ms));
+}
+let randomActivateAudioTimeoutId = null;
+let randomActivateAudioRunning = false;
+function startRandomActivateAudio(sessions, randomAudioPeriod, randomAudioProbability, randomAudioRange) {
+    if (randomActivateAudioRunning)
+        return;
+    randomActivateAudioRunning = true;
+    void randomActivateAudio(sessions, randomAudioPeriod, randomAudioProbability, randomAudioRange);
+}
+function stopRandomActivateAudio() {
+    randomActivateAudioRunning = false;
+    if (randomActivateAudioTimeoutId)
+        clearTimeout(randomActivateAudioTimeoutId);
+}
+/**
+ * Randomly activate audio from one tab at time.
+ * @param sessions The sessions Map
+ * @param randomAudioPeriod If set, the function will be called in loop
+ * @param randomAudioProbability The activation probability
+ * @param randomAudioRange The number of pages to include into the automation
+ */
+async function randomActivateAudio(sessions, randomAudioPeriod, randomAudioProbability, randomAudioRange) {
+    if (!randomAudioPeriod || !randomActivateAudioRunning) {
+        return;
+    }
+    try {
+        let pages = [];
+        for (const session of sessions.values()) {
+            const sessionPages = [...session.pages.values()];
+            if (randomAudioRange) {
+                if (session.id > randomAudioRange) {
+                    break;
+                }
+                sessionPages.splice(randomAudioRange - session.id);
+            }
+            pages = pages.concat(sessionPages);
+        }
+        // Remove pages with no audio tracks.
+        for (const [i, page] of pages.entries()) {
+            if (!page) {
+                continue;
+            }
+            let active = 0;
+            try {
+                active = await page.evaluate(() => getActiveAudioTracks().length);
+            }
+            catch (err) {
+                log.error(`randomActivateAudio error: ${err.stack}`);
+            }
+            if (!active) {
+                pages[i] = null;
+            }
+        }
+        const pagesWithAudio = pages.filter(p => !!p);
+        //
+        const index = Math.floor(Math.random() * pagesWithAudio.length);
+        const enable = Math.round(100 * Math.random()) <= randomAudioProbability;
+        log.debug('randomActivateAudio %j', {
+            pages: pagesWithAudio.length,
+            randomAudioProbability,
+            index,
+            enable,
+        });
+        for (const [i, page] of pagesWithAudio.entries()) {
+            try {
+                if (i === index) {
+                    log.debug(`Changing audio in page ${i + 1}/${pagesWithAudio.length} (enable: ${enable})`);
+                    await page.evaluate(async (enable) => {
+                        if (typeof publisherSetMuted !== 'undefined') {
+                            await publisherSetMuted(!enable);
+                        }
+                        else {
+                            getActiveAudioTracks().forEach(track => {
+                                track.enabled = enable;
+                                // track.dispatchEvent(new Event('custom-enabled'));
+                            });
+                        }
+                    }, enable);
+                }
+                else {
+                    await page.evaluate(async () => {
+                        if (typeof publisherSetMuted !== 'undefined') {
+                            await publisherSetMuted(true);
+                        }
+                        else {
+                            getActiveAudioTracks().forEach(track => {
+                                track.enabled = false;
+                                // track.dispatchEvent(new Event('custom-enabled'));
+                            });
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                log.error(`randomActivateAudio in page ${i + 1}/${pagesWithAudio.length} error: ${err.stack}`);
+            }
+        }
+    }
+    catch (err) {
+        log.error(`randomActivateAudio error: ${err.stack}`);
+    }
+    finally {
+        if (randomActivateAudioRunning) {
+            const nextTime = randomAudioPeriod * (1 + Math.random());
+            if (randomActivateAudioTimeoutId)
+                clearTimeout(randomActivateAudioTimeoutId);
+            randomActivateAudioTimeoutId = setTimeout(randomActivateAudio, nextTime * 1000, sessions, randomAudioPeriod, randomAudioProbability, randomAudioRange);
+        }
+    }
+}
+/**
+ * Downloads the specified `url` to a local file or returning the file content
+ * as {@link DownloadData} object.
+ * @param url The remote url to download.
+ * @param auth The basic authentication (`user:password`).
+ * @param outputLocationPath The file output. If not specified, the download
+ * content will be returned as {@link DownloadData} instance.
+ * @param range The HTTP byte range to download (e.g. `10-100`).
+ * @param timeout The download timeout in milliseconds.
+ */
+async function downloadUrl(url, auth, outputLocationPath, range, timeout = 60000) {
+    log.debug(`downloadUrl url=${url} ${outputLocationPath}`);
+    const authParts = auth?.split(':');
+    let writer = null;
+    if (outputLocationPath) {
+        await fs_1.default.promises.mkdir((0, path_1.dirname)(outputLocationPath), {
+            recursive: true,
+        });
+        writer = (0, fs_1.createWriteStream)(outputLocationPath);
+    }
+    const response = await (0, axios_1.default)({
+        method: 'get',
+        url,
+        auth: authParts
+            ? {
+                username: authParts[0],
+                password: authParts[1],
+            }
+            : undefined,
+        headers: range
+            ? {
+                Range: `bytes=${range}`,
+            }
+            : undefined,
+        timeout,
+        onDownloadProgress: event => {
+            log.debug(`downloadUrl fileUrl=${url} progress=${event.progress || event.bytes}`);
+        },
+        httpsAgent: new https_1.Agent({
+            rejectUnauthorized: false,
+        }),
+        responseType: writer ? 'stream' : 'text',
+    });
+    if (writer) {
+        return new Promise((resolve, reject) => {
+            if (!writer) {
+                return;
+            }
+            response.data.pipe(writer);
+            let error = null;
+            writer.once('error', err => {
+                error = err;
+                if (writer)
+                    writer.close();
+                reject(err);
+            });
+            writer.once('close', () => {
+                if (!error) {
+                    resolve();
+                }
+            });
+        });
+    }
+    else {
+        /* log.debug(`downloadUrl ${response.data.length} bytes, headers=${
+          JSON.stringify(response.headers)}`); */
+        let start = 0;
+        let end = 0;
+        let total = 0;
+        if (response.headers['content-range']) {
+            log.debug(`downloadUrl ${response.data.length} bytes, content-range=${response.headers['content-range']}`);
+            const contentRange = response.headers['content-range'].split('/');
+            const rangeParts = contentRange[0].split('-');
+            total = parseInt(contentRange[1]);
+            if (rangeParts.length === 2) {
+                start = parseInt(rangeParts[0]);
+                end = parseInt(rangeParts[1]);
+            }
+            else if (contentRange[0].startsWith('-')) {
+                end = parseInt(rangeParts[0]);
+            }
+            else if (contentRange[0].endsWith('-')) {
+                start = parseInt(rangeParts[0]);
+                end = total;
+            }
+        }
+        return {
+            data: response.data,
+            start,
+            end,
+            total,
+        };
+    }
+}
+/**
+ * Uploads the file to the specified `url`.
+ * @param filePath The file path to upload.
+ * @param url The remote url to upload.
+ * @param auth The basic authentication (`user:password`).
+ */
+async function uploadUrl(filePath, url, auth) {
+    log.debug(`uploadUrl ${filePath} to ${url}`);
+    const authParts = auth?.split(':');
+    const formData = new form_data_1.default();
+    formData.append('file', fs_1.default.createReadStream(filePath));
+    const response = await (0, axios_1.default)({
+        method: 'post',
+        url,
+        auth: authParts
+            ? {
+                username: authParts[0],
+                password: authParts[1],
+            }
+            : undefined,
+        headers: formData.getHeaders(),
+        timeout: 3600 * 1000,
+        httpsAgent: new https_1.Agent({
+            rejectUnauthorized: false,
+        }),
+        responseType: 'text',
+        data: formData,
+    });
+    return response.data;
+}
+const HideAuthRegExp = new RegExp('(http[s]{0,1}://)(.+?:.+?@)', 'g');
+/**
+ * Hides the authentication part from an HTTP url.
+ * @param data
+ */
+function hideAuth(data) {
+    if (!data) {
+        return data;
+    }
+    return data.replace(HideAuthRegExp, '$1');
+}
+const exitHandlers = new Set();
+/**
+ * Register an {@link ExitHandler} callback that will be executed at the
+ * nodejs process exit.
+ * @param exitHandler
+ */
+function registerExitHandler(exitHandler) {
+    exitHandlers.add(exitHandler);
+}
+/**
+ * Un-registers the {@link ExitHandler} callback.
+ * @param exitHandler
+ */
+function unregisterExitHandler(exitHandler) {
+    exitHandlers.delete(exitHandler);
+}
+const runExitHandlers = async (signal) => {
+    let i = 0;
+    for (const exitHandler of exitHandlers.values()) {
+        const id = `${i + 1}/${exitHandlers.size}`;
+        log.debug(`running exitHandler ${id}`);
+        try {
+            await exitHandler(signal);
+            log.debug(`  exitHandler ${id} done`);
+        }
+        catch (err) {
+            log.error(`exitHandler ${id} error: ${err}`);
+        }
+        i++;
+    }
+    exitHandlers.clear();
+};
+let runExitHandlersPromise = null;
+/**
+ * Runs the registered exit handlers immediately.
+ * @param signal The process exit signal.
+ */
+async function runExitHandlersNow(signal) {
+    if (!runExitHandlersPromise) {
+        runExitHandlersPromise = runExitHandlers(signal);
+    }
+    await runExitHandlersPromise;
+    stopTimers();
+}
+const SIGNALS = [
+    'beforeExit',
+    'uncaughtException',
+    'unhandledRejection',
+    'SIGHUP',
+    'SIGINT',
+    'SIGQUIT',
+    'SIGILL',
+    'SIGTRAP',
+    'SIGABRT',
+    'SIGBUS',
+    'SIGFPE',
+    'SIGUSR1',
+    'SIGSEGV',
+    'SIGUSR2',
+    'SIGTERM',
+];
+process.setMaxListeners(process.getMaxListeners() + SIGNALS.length);
+SIGNALS.forEach(event => process.once(event, async (signal) => {
+    if (signal instanceof Error) {
+        log.error(`Exit on error: ${signal.stack || signal.message}`);
+    }
+    else {
+        log.debug(`Exit on signal: ${signal}`);
+    }
+    await runExitHandlersNow(signal);
+    process.exit(0);
+}));
+/**
+ * Downloads the configured chrome executable if it doesn't exists into the
+ * `$HOME/.webrtcperf/chrome` directory.
+ * @returns The revision info.
+ */
+async function checkChromeExecutable() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { loadConfig } = require('./config');
+    const config = loadConfig();
+    const cacheDir = path_1.default.join(os_1.default.homedir(), '.webrtcperf/chrome');
+    const fixSemVer = (v) => v.split('.').slice(0, 3).join('.');
+    const browsers = await (0, browsers_1.getInstalledBrowsers)({ cacheDir });
+    const revisions = browsers.map(b => fixSemVer(b.buildId));
+    const browser = browsers_1.Browser.CHROME;
+    revisions.sort((0, browsers_1.getVersionComparator)(browser));
+    log.debug(`Available chrome versions: ${revisions}`);
+    const requiredRevision = config.chromiumVersion;
+    if (!requiredRevision)
+        throw new Error('Chromium version not set');
+    if (!revisions.includes(fixSemVer(requiredRevision))) {
+        log.info(`Downloading chrome ${requiredRevision}...`);
+        let progress = 0;
+        await (0, browsers_1.install)({
+            browser,
+            buildId: requiredRevision,
+            cacheDir,
+            downloadProgressCallback: (downloadedBytes, totalBytes) => {
+                const cur = Math.round((100 * downloadedBytes) / totalBytes);
+                if (cur - progress > 1) {
+                    progress = cur;
+                    log.info(`  ${progress}%`);
+                }
+            },
+        });
+        log.info(`Downloading chrome ${requiredRevision} done.`);
+    }
+    return (0, browsers_1.computeExecutablePath)({
+        browser,
+        cacheDir,
+        buildId: requiredRevision,
+    });
+}
+function clampMinMax(value, min, max) {
+    return Math.max(Math.min(value, max), min);
+}
+/** Runs the shell command asynchronously. */
+async function runShellCommand(cmd, verbose = false, maxBuffer = 1024 * 1024) {
+    if (verbose)
+        log.debug(`runShellCommand cmd: ${cmd}`);
+    return new Promise((resolve, reject) => {
+        const p = (0, child_process_1.spawn)(cmd, {
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        p.stdout.on('data', data => {
+            if (maxBuffer && stdout.length > maxBuffer) {
+                stdout = stdout.slice(data.length);
+            }
+            stdout += data;
+        });
+        p.stderr.on('data', data => {
+            if (maxBuffer && stderr.length > maxBuffer) {
+                stderr = stderr.slice(data.length);
+            }
+            stderr += data;
+        });
+        p.once('error', err => reject(err));
+        p.once('close', code => {
+            if (code !== 0) {
+                reject(new Error(`runShellCommand cmd: ${cmd} failed with code ${code}: ${stderr}`));
+            }
+            else {
+                if (verbose)
+                    log.debug(`runShellCommand cmd: ${cmd} done`, { stdout, stderr });
+                resolve({ stdout, stderr });
+            }
+        });
+    });
+}
+//
+const ipCache = new Map();
+/**
+ * Resolves the IP address hostname.
+ * @param ip The IP address.
+ * @param cacheTime The number of milliseconds to keep the resolved hostname
+ * into the memory cache.
+ * @returns The IP address hostname.
+ */
+async function resolveIP(ip, cacheTime = 60 * 60 * 1000) {
+    if (!ip)
+        return '';
+    if (ipaddrJs.parse(ip).range() === 'private') {
+        return ip;
+    }
+    const timestamp = Date.now();
+    const ret = ipCache.get(ip);
+    if (!ret || timestamp - ret.timestamp > cacheTime) {
+        const host = await Promise.race([
+            sleep(1000),
+            dns.promises
+                .reverse(ip)
+                .then(hosts => {
+                if (hosts.length) {
+                    log.debug(`resolveIP ${ip} -> ${hosts.join(', ')}`);
+                    ipCache.set(ip, {
+                        host: hosts[0],
+                        // Keep the value for 10 min.
+                        timestamp: timestamp + 10 * cacheTime,
+                    });
+                    return hosts[0];
+                }
+                else {
+                    ipCache.set(ip, { host: ip, timestamp });
+                    return ip;
+                }
+            })
+                .catch(err => {
+                log.debug(`resolveIP error: ${err.stack}`);
+                ipCache.set(ip, { host: ip, timestamp });
+            }),
+        ]);
+        return host || ip;
+    }
+    return ret?.host || ip;
+}
+/**
+ * Strips the console logs characters from the provided string.
+ * @param str The input string.
+ * @returns The strippped string.
+ */
+function stripColors(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B[[(?);]{0,2}(;?\d)*./g, '');
+}
+const nvidiaGpuPresent = fs_1.default.existsSync('/usr/bin/nvidia-smi') && fs_1.default.existsSync('/dev/dri');
+const macOS = process.platform === 'darwin' && fs_1.default.existsSync('/usr/sbin/ioreg');
+/**
+ * Returns the GPU usage.
+ *
+ * On Linux, the `nvidia-smi` should be installed if Nvidia card is used.
+ * @returns The GPU usage.
+ */
+async function systemGpuStats() {
+    try {
+        if (nvidiaGpuPresent) {
+            const { stdout } = await runShellCommand('nvidia-smi --query-gpu=utilization.gpu,utilization.memory --format=csv');
+            const line = stdout.split('\n')[1].trim();
+            const [gpu, mem] = line.split(',').map(s => parseFloat(s.replace(' %', '')));
+            return { gpu, mem };
+        }
+        else if (macOS) {
+            const { stdout } = await runShellCommand('ioreg -r -d 1 -w 0 -c IOAccelerator | grep PerformanceStatistics\\"');
+            const stats = JSON.parse(stdout.trim().split(' = ')[1].replace(/=/g, ':'));
+            const gpu = stats['Device Utilization %'] || stats['GPU Activity(%)'] || 0;
+            return { gpu, mem: 0 };
+        }
+    }
+    catch (err) {
+        log.debug(`systemGpuStats error: ${err.stack}`);
+    }
+    return { gpu: 0, mem: 0 };
+}
+/**
+ * Schedules a function call at the specified time interval.
+ */
+class Scheduler {
+    name;
+    interval;
+    callback;
+    verbose;
+    running = false;
+    last = 0;
+    errorSum = 0;
+    statsTimeoutId;
+    /**
+     * Scheduler.
+     * @param name Logging name.
+     * @param interval Update interval in seconds.
+     * @param callback Callback function.
+     * @param verbose Verbose logging.
+     */
+    constructor(name, interval, callback, verbose = false) {
+        this.name = name;
+        this.interval = interval * 1000;
+        this.callback = callback;
+        this.verbose = verbose;
+        log.debug(`[${this.name}-scheduler] constructor interval=${this.interval}ms`);
+    }
+    start() {
+        log.debug(`[${this.name}-scheduler] start`);
+        this.running = true;
+        this.scheduleNext();
+    }
+    stop() {
+        log.debug(`[${this.name}-scheduler] stop`);
+        this.running = false;
+        if (this.statsTimeoutId) {
+            clearTimeout(this.statsTimeoutId);
+        }
+    }
+    scheduleNext() {
+        if (!this.running) {
+            return;
+        }
+        const now = Date.now();
+        if (this.last) {
+            this.errorSum += clampMinMax(now - this.last - this.interval, -this.interval, this.interval);
+            if (this.verbose) {
+                log.debug(`[${this.name}-scheduler] last=${now - this.last}ms drift=${this.errorSum}ms`);
+            }
+        }
+        this.last = now;
+        this.statsTimeoutId = setTimeout(async () => {
+            try {
+                const now = Date.now();
+                await this.callback(now);
+                const elapsed = Date.now() - now;
+                if (elapsed > this.interval) {
+                    log.warn(`[${this.name}-scheduler] callback elapsed=${elapsed}ms > ${this.interval}ms`);
+                }
+                else if (this.verbose) {
+                    log.debug(`[${this.name}-scheduler] callback elapsed=${elapsed}ms`);
+                }
+            }
+            catch (err) {
+                log.error(`[${this.name}-scheduler] callback error: ${err.stack}`, err);
+            }
+            finally {
+                this.scheduleNext();
+            }
+        }, this.interval - this.errorSum / 2);
+    }
+}
+exports.Scheduler = Scheduler;
+//
+class PeerConnectionExternal {
+    id;
+    process;
+    static cache = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(options) {
+        this.process = (0, child_process_1.spawn)('sleep', ['600']);
+        this.id = this.process.pid || -1;
+        log.debug(`PeerConnectionExternal contructor: ${this.id}`, options);
+        PeerConnectionExternal.cache.set(this.id, this);
+        this.process.stdout.on('data', data => {
+            log.debug(`PeerConnectionExternal stdout: ${data}`);
+        });
+        this.process.stderr.on('data', data => {
+            log.debug(`PeerConnectionExternal stderr: ${data}`);
+        });
+        this.process.on('close', code => {
+            log.debug(`PeerConnectionExternal process exited with code ${code}`);
+            PeerConnectionExternal.cache.delete(this.id);
+        });
+    }
+    static get(id) {
+        return PeerConnectionExternal.cache.get(id);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async createOffer(options) {
+        log.debug(`PeerConnectionExternal createOffer`, { options });
+        return {};
+    }
+    setLocalDescription(description) {
+        log.debug(`PeerConnectionExternal setLocalDescription`, description);
+    }
+    setRemoteDescription(description) {
+        log.debug(`PeerConnectionExternal setRemoteDescription`, description);
+    }
+}
+exports.PeerConnectionExternal = PeerConnectionExternal;
+function toTitleCase(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function getFiles(dir, ext) {
+    const dirs = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(dirs.map(entry => {
+        const res = path_1.default.resolve(dir, entry.name);
+        return entry.isDirectory() ? getFiles(res, ext) : res;
+    }));
+    return Array.prototype.concat(...files).filter(f => f.endsWith(ext));
+}
+/**
+ * Format number to the specified precision.
+ * @param value value to format
+ * @param precision precision
+ */
+function toPrecision(value, precision = 3) {
+    return (Math.round(value * 10 ** precision) / 10 ** precision).toFixed(precision);
+}
+async function getDefaultNetworkInterface() {
+    const { stdout } = await runShellCommand(`ip route | awk '/default/ {print $5; exit}' | tr -d ''`);
+    return stdout.trim();
+}
+async function checkNetworkInterface(device) {
+    await runShellCommand(`ip route | grep -q "dev ${device}"`);
+}
+async function portForwarder(port, listenInterface) {
+    if (!listenInterface) {
+        listenInterface = await getDefaultNetworkInterface();
+    }
+    const controller = new AbortController();
+    Object.entries((0, os_1.networkInterfaces)()).forEach(([iface, nets]) => {
+        if (listenInterface !== '0.0.0.0' && iface !== listenInterface)
+            return;
+        if (!nets)
+            return;
+        for (const n of nets) {
+            if (n.internal || n.address === '127.0.0.1' || n.family !== 'IPv4') {
+                continue;
+            }
+            const msg = `portForwarder on ${iface} (${n.address}:${port})`;
+            const server = net_1.default
+                .createServer(from => {
+                const to = net_1.default.createConnection({ host: '127.0.0.1', port });
+                from.once('error', err => {
+                    log.error(`${msg} error: ${err.stack}`);
+                    to.destroy();
+                });
+                to.once('error', err => {
+                    log.error(`${msg} error: ${err.stack}`);
+                    from.destroy();
+                });
+                from.pipe(to);
+                to.pipe(from);
+            })
+                .listen({ port, host: n.address, signal: controller.signal });
+            server.on('listening', () => {
+                log.debug(`${msg} listening`);
+            });
+            server.once('error', err => {
+                log.error(`${msg} error: ${err.stack}`);
+            });
+        }
+    });
+    return () => {
+        log.debug(`portForwarder on port ${port} stop`);
+        controller.abort();
+    };
+}
+async function pageScreenshot(url, filePath, width = 1920, height = 1024, selector = 'body', headers, extraCss) {
+    log.debug(`pageScreenshot ${url} -> ${filePath}`);
+    await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+    let executablePath = process.env.CHROMIUM_PATH;
+    if (!executablePath || !fs_1.default.existsSync(executablePath)) {
+        executablePath = await checkChromeExecutable();
+    }
+    const browser = await puppeteer_core_1.default.launch({
+        headless: true,
+        executablePath,
+        defaultViewport: {
+            width,
+            height,
+            deviceScaleFactor: 1,
+            isMobile: false,
+            hasTouch: false,
+            isLandscape: false,
+        },
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            //'--remote-debugging-port=9222',
+        ],
+    });
+    const page = await browser.newPage();
+    if (headers) {
+        await page.setExtraHTTPHeaders(headers);
+    }
+    if (extraCss) {
+        await page.evaluateOnNewDocument((css) => {
+            document.addEventListener('DOMContentLoaded', () => {
+                const style = document.createElement('style');
+                style.setAttribute('id', 'webrtcperf-extra-style');
+                style.setAttribute('type', 'text/css');
+                style.innerHTML = css;
+                document.head.appendChild(style);
+            });
+        }, extraCss);
+    }
+    await page.goto(url, {
+        waitUntil: ['domcontentloaded', 'networkidle0'],
+        timeout: 60 * 1000,
+    });
+    try {
+        const element = await page.waitForSelector(selector, {
+            visible: true,
+            timeout: 15 * 1000,
+        });
+        if (!element) {
+            throw new Error(`pageScreenshot selector "${selector}" not found`);
+        }
+        await element.screenshot({ path: filePath });
+    }
+    catch (err) {
+        log.error(`pageScreenshot error: ${err.message}`);
+    }
+    finally {
+        await page.close();
+        await browser.close();
+    }
+}
+function enabledForSession(index, value) {
+    if (value === true || value === 'true') {
+        return true;
+    }
+    else if (value === false || value === 'false' || value === undefined) {
+        return false;
+    }
+    else if (typeof value === 'string') {
+        if (value.includes('-')) {
+            const [start, end] = value.split('-').map(s => parseInt(s));
+            if (isFinite(start) && index < start) {
+                return false;
+            }
+            if (isFinite(end) && index > end) {
+                return false;
+            }
+            return true;
+        }
+        else {
+            const indexes = value
+                .split(',')
+                .map(s => s.trim())
+                .filter(s => s.length)
+                .map(s => parseInt(s));
+            return indexes.includes(index);
+        }
+    }
+    else if (index === value) {
+        return true;
+    }
+    return false;
+}
+function increaseKey(o, key, value) {
+    if (value === undefined || !isFinite(value))
+        return;
+    if (o[key] === undefined) {
+        o[key] = 0;
+    }
+    o[key] += value;
+}
+async function chunkedPromiseAll(items, f, chunkSize = 1) {
+    const results = Array(items.length);
+    for (let index = 0; index < items.length; index += chunkSize) {
+        await Promise.allSettled(items.slice(index, index + chunkSize).map(async (item, i) => {
+            const res = await f(item, index + i);
+            if (res !== undefined)
+                results[index + i] = res;
+        }));
+    }
+    return results;
+}
+function maybeNumber(s) {
+    const n = parseFloat(s);
+    return !isNaN(n) ? n : s;
+}
+var FFProbeProcess;
+(function (FFProbeProcess) {
+    FFProbeProcess["Skip"] = "skip";
+    FFProbeProcess["Stop"] = "stop";
+})(FFProbeProcess || (exports.FFProbeProcess = FFProbeProcess = {}));
+/**
+ * It runs the ffprobe command to extract the video/video frames.
+ * @param fpath The file path.
+ * @param kind The kind of the media (video or audio).
+ * @param entries Which entries to show.
+ * @param filters Apply filters.
+ * @param frameProcess A function to process the frame. The function return value could be:
+ *   - the modified frame object
+ *   - `FFProbeProcess.Skip` to skip the frame from the output
+ *   - `FFProbeProcess.Stop` to stop processing and immediately return the collected frames.
+ */
+async function ffprobe(fpath, kind = 'video', entries = '', filters = '', frameProcess) {
+    const cmd = `\
+exec ffprobe -loglevel error ${kind === 'video' ? '-select_streams v' : ''} -show_frames -print_format compact \
+${entries ? `-show_entries ${entries}` : ''} \
+-f lavfi -i '${kind === 'video' ? '' : 'a'}movie=${fpath}${filters ? `,${filters}` : ''}'`;
+    const frames = [];
+    let stderr = '';
+    let stopProcessing = false;
+    return new Promise((resolve, reject) => {
+        const p = (0, child_process_1.spawn)(cmd, {
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        p.stdout.on('data', data => {
+            if (stopProcessing)
+                return;
+            const frame = data
+                .toString()
+                .split('|')
+                .reduce((prev, cur) => {
+                const [key, value] = cur.split('=');
+                if (value && !key.startsWith('side_datum')) {
+                    prev[key.replace(/[:.]/g, '_')] = value;
+                }
+                return prev;
+            }, {});
+            if (frameProcess) {
+                const newFrame = frameProcess(frame);
+                if (newFrame === FFProbeProcess.Skip) {
+                    // Skip the frame.
+                }
+                else if (newFrame === FFProbeProcess.Stop) {
+                    stopProcessing = true;
+                    p.kill('SIGINT');
+                }
+                else {
+                    frames.push(newFrame);
+                }
+            }
+            else {
+                frames.push(frame);
+            }
+        });
+        p.stderr.on('data', data => {
+            stderr += data;
+        });
+        p.once('error', err => reject(err));
+        p.once('close', code => {
+            if (code !== 0 && !stopProcessing) {
+                reject(new Error(`${cmd} failed with code ${code}: ${stderr}`));
+            }
+            else {
+                resolve(frames);
+            }
+        });
+    });
+}
+function buildIvfHeader(width = 1920, height = 1080, frameRate = 30, fourcc = 'MJPG') {
+    const buffer = Buffer.alloc(32);
+    buffer.write('DKIF', 0, 'utf8');
+    buffer.writeUint16LE(0, 4); // version
+    buffer.writeUint16LE(32, 6); // header size
+    buffer.write(fourcc, 8, 'utf8');
+    buffer.writeUint16LE(width, 12);
+    buffer.writeUint16LE(height, 14);
+    buffer.writeUint32LE(frameRate, 16);
+    buffer.writeUint32LE(1, 20);
+    buffer.writeUint32LE(0, 24); // frame count
+    buffer.writeUint32LE(0, 28); // unused
+    return buffer;
+}
+async function ffmpeg(command = 'video', processFn) {
+    const port = 10000 + Math.floor(Math.random() * 10000);
+    const cmd = `exec ffmpeg -hide_banner -loglevel warning ${command} zmq:tcp://127.0.0.1:${port}`;
+    log.debug(`${cmd}`);
+    let stderr = '';
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const zmq = require('zeromq');
+    const sub = new zmq.Subscriber();
+    const p = (0, child_process_1.spawn)(cmd, {
+        shell: true,
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    p.stderr.on('data', data => {
+        stderr += data;
+    });
+    p.once('error', err => {
+        sub.close();
+        throw err;
+    });
+    p.once('close', code => {
+        sub.close();
+        if (code !== 0) {
+            throw new Error(`${cmd} failed with code ${code}: ${stderr}`);
+        }
+    });
+    sub.connect(`tcp://127.0.0.1:${port}`);
+    sub.subscribe('');
+    for await (const [msg] of sub) {
+        await processFn(msg);
+    }
+    sub.close();
+}
+async function analyzeColors(fpath) {
+    let Y = 0;
+    let U = 0;
+    let V = 0;
+    let SAT = 0;
+    let HUE = 0;
+    let count = 0;
+    await ffprobe(fpath, 'video', 'frame=lavfi.signalstats.YAVG,lavfi.signalstats.UAVG,lavfi.signalstats.VAVG,lavfi.signalstats.SATAVG,lavfi.signalstats.HUEAVG', 'signalstats', frame => {
+        Y += parseFloat(frame.tag_lavfi_signalstats_YAVG);
+        U += parseFloat(frame.tag_lavfi_signalstats_UAVG);
+        V += parseFloat(frame.tag_lavfi_signalstats_VAVG);
+        SAT += parseFloat(frame.tag_lavfi_signalstats_SATAVG);
+        HUE += parseFloat(frame.tag_lavfi_signalstats_HUEAVG);
+        count++;
+        return FFProbeProcess.Skip;
+    });
+    return { YAvg: Y / count, UAvg: U / count, VAvg: V / count, SatAvg: SAT / count, HueAvg: HUE / count };
+}
+/**
+ * Wait for the process to stop or kill it after the timeout.
+ * @param pid The process pid
+ * @param timeout The maximum wait time in milliseconds
+ * @returns `true` if the process stopped, `false` if the process was killed.
+ */
+async function waitStopProcess(pid, timeout = 5000) {
+    log.debug(`waitStopProcess pid: ${pid} timeout: ${timeout}`);
+    const now = Date.now();
+    while (Date.now() - now < timeout) {
+        try {
+            process.kill(pid, 0);
+            await sleep(Math.max(timeout / 10, 200));
+        }
+        catch {
+            return true;
+        }
+    }
+    log.warn(`waitStopProcess pid: ${pid} timeout`);
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        return true;
+    }
+    return false;
+}
+async function getDockerLogsPath() {
+    const containerId = await fs_1.default.promises.readFile(`${os_1.default.homedir()}/.webrtcperf/docker.id`, 'utf-8');
+    const logPath = `/var/lib/docker/containers/${containerId}/${containerId}-json.log`;
+    if (!fs_1.default.existsSync(logPath)) {
+        throw new Error(`docker logs path ${logPath} not found`);
+    }
+    return logPath;
+}
+//# sourceMappingURL=utils.js.map