@testspectra/cli 1.1.8-rc.24 → 1.1.8-rc.28

package/dist/lifecycle/parallel-grouping.js

@@ -1,151 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-/**
- * Detects actual CPU quota available to the process, accounting for
- * Docker and Kubernetes cgroup v1 and cgroup v2 container limits.
- */
-export function detectContainerCpuQuota() {
-    try {
-        // 1. Check cgroup v2 (Unified Hierarchy): /sys/fs/cgroup/cpu.max
-        // Format: "<quota> <period>" e.g. "200000 100000" or "max 100000"
-        if (fs.existsSync('/sys/fs/cgroup/cpu.max')) {
-            const content = fs.readFileSync('/sys/fs/cgroup/cpu.max', 'utf-8').trim();
-            const [quotaStr, periodStr] = content.split(/\s+/);
-            if (quotaStr && quotaStr !== 'max' && periodStr) {
-                const quota = parseFloat(quotaStr);
-                const period = parseFloat(periodStr);
-                if (quota > 0 && period > 0) {
-                    return Math.max(0.5, quota / period);
-                }
-            }
-        }
-        // 2. Check cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us and cpu.cfs_period_us
-        if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
-            const quota = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf-8').trim());
-            const period = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf-8').trim());
-            if (quota > 0 && period > 0) {
-                return Math.max(0.5, quota / period);
-            }
-        }
-    }
-    catch { }
-    // 3. Fallback to host CPU count
-    if (typeof os.availableParallelism === 'function') {
-        try {
-            return os.availableParallelism();
-        }
-        catch { }
-    }
-    return os.cpus()?.length || 2;
-}
-/**
- * Detects available memory in bytes, respecting container cgroup memory limits
- * to prevent Linux OOM (Out of Memory) kills.
- */
-export function detectAvailableMemoryBytes() {
-    try {
-        // 1. Check cgroup v2: /sys/fs/cgroup/memory.max and /sys/fs/cgroup/memory.current
-        if (fs.existsSync('/sys/fs/cgroup/memory.max')) {
-            const maxStr = fs.readFileSync('/sys/fs/cgroup/memory.max', 'utf-8').trim();
-            if (maxStr !== 'max') {
-                const limit = parseFloat(maxStr);
-                let usage = 0;
-                if (fs.existsSync('/sys/fs/cgroup/memory.current')) {
-                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory.current', 'utf-8').trim()) || 0;
-                }
-                if (limit > 0) {
-                    return Math.max(0, limit - usage);
-                }
-            }
-        }
-        // 2. Check cgroup v1: /sys/fs/cgroup/memory/memory.limit_in_bytes
-        if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
-            const limit = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf-8').trim());
-            // cgroup v1 sets a huge number (e.g. 9223372036854771712) when no limit is enforced
-            if (limit > 0 && limit < 1e15) {
-                let usage = 0;
-                if (fs.existsSync('/sys/fs/cgroup/memory/memory.usage_in_bytes')) {
-                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf-8').trim()) || 0;
-                }
-                return Math.max(0, limit - usage);
-            }
-        }
-    }
-    catch { }
-    // 3. Fallback to host available memory (estimating reclaimable cache/buffer on modern OS)
-    try {
-        const free = os.freemem();
-        const total = os.totalmem();
-        return Math.max(free, total * 0.4);
-    }
-    catch {
-        return 1024 * 1024 * 1024; // 1 GB fallback
-    }
-}
-/**
- * Dynamically computes optimal worker concurrency respecting:
- * 1. Explicit user concurrency flag (--concurrency <N> or config)
- * 2. Real container cgroups CPU quota & host CPU count
- * 3. Low-CPU safety ratio (clamping <=2 CPUs to 1 worker, 3-4 CPUs to 2 workers)
- * 4. Memory-aware guard (~600MB RAM budget per Chromium instance to prevent OOM kills)
- * 5. Target items count & maximum worker cap
- */
-export function calculateWorkerCount(targetItems, options) {
-    const opts = typeof options === 'number' ? { maxWorkersCap: options } : options || {};
-    const itemCount = targetItems.length;
-    if (itemCount === 0)
-        return 1;
-    // 1. Explicit User Concurrency has absolute priority
-    if (opts.userConcurrency && opts.userConcurrency > 0) {
-        return Math.min(opts.userConcurrency, itemCount);
-    }
-    // 2. Determine CPU Quota (cgroups aware)
-    const cpuCount = opts.cpuQuotaOverride !== undefined ? opts.cpuQuotaOverride : detectContainerCpuQuota();
-    // 3. Low-CPU Safety Ratio:
-    // - CPU <= 2: Max 1 worker (prevents severe thrashing on 2-vCPU CI runners)
-    // - CPU 3-4: Max 2 workers
-    // - CPU > 4: cpuCount - 2 (leaves 2 cores for OS/IDE/DevTools)
-    let cpuBasedWorkers = 1;
-    if (cpuCount <= 2) {
-        cpuBasedWorkers = 1;
-    }
-    else if (cpuCount <= 4) {
-        cpuBasedWorkers = 2;
-    }
-    else {
-        cpuBasedWorkers = Math.max(1, Math.floor(cpuCount - 2));
-    }
-    // 4. Memory-Aware Guard (Anti-OOM):
-    // Allocate ~600MB per Chromium browser instance
-    const MEMORY_PER_WORKER_BYTES = 600 * 1024 * 1024;
-    const availableMemBytes = opts.memoryBytesOverride !== undefined ? opts.memoryBytesOverride : detectAvailableMemoryBytes();
-    const memBasedWorkers = Math.max(1, Math.floor(availableMemBytes / MEMORY_PER_WORKER_BYTES));
-    // 5. Apply Maximum Cap and Item Count Clamping
-    const maxCap = opts.maxWorkersCap || 6;
-    return Math.max(1, Math.min(cpuBasedWorkers, memBasedWorkers, maxCap, itemCount));
-}
-export function groupSpecs(specPaths, mode = 'suite') {
-    if (mode === 'testcase') {
-        return [...specPaths];
-    }
-    // Group by suite directory
-    const suiteGroups = new Map();
-    for (const specPath of specPaths) {
-        const normalized = specPath.replace(/\\/g, '/');
-        const parts = normalized.split('/');
-        let suiteKey = 'default';
-        const specsIdx = parts.findIndex((p) => p === 'specs' || p === 'suites');
-        if (specsIdx !== -1 && specsIdx + 1 < parts.length) {
-            suiteKey = parts.slice(0, specsIdx + 2).join('/');
-        }
-        else {
-            suiteKey = path.dirname(normalized);
-        }
-        if (!suiteGroups.has(suiteKey)) {
-            suiteGroups.set(suiteKey, []);
-        }
-        suiteGroups.get(suiteKey).push(specPath);
-    }
-    return Array.from(suiteGroups.values());
-}