@vpalmisano/webrtcperf 4.3.2 → 4.4.2

package/src/docker.ts

@@ -0,0 +1,131 @@
+import path from 'path'
+import Docker from 'dockerode'
+import { logger, resolvePackagePath } from './utils'
+import { loadConfig } from './config'
+import fs from 'fs'
+
+const log = logger('webrtcperf:docker')
+
+export async function runWithDocker(argv: string[]) {
+  const docker = new Docker()
+  const configPath = argv.filter(s => s !== '--docker')[0]
+  if (!configPath) throw new Error('No configuration file specified')
+  const configName = path.basename(configPath)
+  const config = (await loadConfig(configPath))[0]
+
+  const startTimestamp = Date.now()
+  const dataDir = path.resolve(path.dirname(configPath), 'logs', `${startTimestamp}`)
+  await fs.promises.mkdir(dataDir, { recursive: true })
+
+  const binds: string[] = [
+    `${path.resolve(configPath)}:/config/${configName}:ro`,
+    '/dev/shm:/dev/shm',
+    `${dataDir}:/data`,
+    '/tmp/webrtcperf-cache:/root/.webrtcperf',
+  ]
+
+  if (config.scriptPath) {
+    const scriptName = path.basename(config.scriptPath)
+    binds.push(`${path.resolve(config.scriptPath)}:/scripts/${scriptName}:ro`)
+  }
+
+  if (process.env.DEBUG_SRC) {
+    binds.push(`${resolvePackagePath('app.min.js')}:/app/app.min.js:ro`)
+  }
+
+  const portBindings: Docker.PortMap = {}
+  const exposedPorts: { [portAndProtocol: string]: object } = {}
+  if (config.debuggingPort) {
+    for (let i = 0; i < config.sessions; i++) {
+      const port = `${config.debuggingPort + i}/tcp`
+      portBindings[port] = [{ HostPort: `${config.debuggingPort + i}` }]
+      exposedPorts[port] = {}
+    }
+  }
+
+  const env = [
+    `DEBUG_LEVEL=${process.env.DEBUG_LEVEL || 'info'}`,
+    'SHOW_PAGE_LOG=false',
+    'SHOW_STATS=false',
+    'SERVER_PORT=5000',
+    'SERVER_USE_HTTPS=true',
+    'SERVER_DATA=/data',
+    `START_TIMESTAMP=${startTimestamp}`,
+    `STATS_PATH=/data/stats.csv`,
+    `PAGE_LOG_PATH=/data/page.log`,
+    `DETAILED_STATS_PATH=/data/detailed-stats.csv`,
+  ]
+
+  if (config.scriptPath) {
+    const scriptName = path.basename(config.scriptPath)
+    env.push(`SCRIPT_PATH=/scripts/${scriptName}`)
+  }
+
+  if (config.debuggingPort) {
+    env.push(`DEBUGGING_PORT=${config.debuggingPort}`)
+  }
+
+  if (config.prometheusPushgateway.startsWith('http://localhost')) {
+    env.push('PROMETHEUS_PUSHGATEWAY=http://pushgateway:9091')
+  }
+
+  const containerConfig: Docker.ContainerCreateOptions = {
+    Image: 'ghcr.io/vpalmisano/webrtcperf:devel',
+    name: 'webrtcperf',
+    Cmd: [`/config/${configName}`],
+    HostConfig: {
+      Binds: binds,
+      PortBindings: portBindings,
+      CapAdd: ['NET_ADMIN'],
+      NetworkMode: config.prometheusPushgateway.startsWith('http://localhost') ? 'prometheus-stack_default' : 'bridge',
+    },
+    Env: env,
+    AttachStdin: true,
+    AttachStdout: true,
+    AttachStderr: true,
+    Tty: true,
+    OpenStdin: true,
+    StdinOnce: true,
+    ExposedPorts: exposedPorts,
+  }
+
+  try {
+    if (!process.env.DEBUG_SRC) {
+      log.info('Pulling latest webrtcperf image...')
+      await docker.pull('ghcr.io/vpalmisano/webrtcperf:devel')
+    }
+
+    try {
+      const existingContainer = await docker.getContainer('webrtcperf')
+      await existingContainer.remove({ force: true })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (err: unknown) {
+      // Container doesn't exist, continue
+    }
+
+    const container = await docker.createContainer(containerConfig)
+    await container.start()
+
+    const stream = await container.attach({
+      stream: true,
+      stdin: true,
+      stdout: true,
+      stderr: true,
+    })
+
+    process.stdin.pipe(stream)
+    stream.pipe(process.stdout)
+
+    await new Promise(resolve => {
+      container.wait((err: Error, data: { StatusCode: number }) => {
+        if (err) log.error('Error waiting for container:', data, err.stack)
+        resolve(data)
+      })
+    })
+
+    await container.remove()
+  } catch (error) {
+    log.error('Docker operation failed:', error)
+    throw error
+  }
+}

package/src/session.ts

@@ -1,4 +1,4 @@
-import { getSessionThrottleValues, throttleLauncher } from '@vpalmisano/throttler'
+import { getSessionThrottleValues, throttleLauncher, throttleNotifier } from '@vpalmisano/throttler'
 import assert from 'assert'
 import axios from 'axios'
 import EventEmitter from 'events'
@@ -30,8 +30,8 @@ import { gunzipSync } from 'zlib'
 import { RtcStats, rtcStatKey, updateRtcStats } from './rtcstats'
 import { FastStats } from './stats'
 import {
-  PeerConnectionExternal,
-  PeerConnectionExternalMethod,
+  /* PeerConnectionExternal,
+  PeerConnectionExternalMethod, */
   checkChromeExecutable,
   downloadUrl,
   enabledForSession,
@@ -163,6 +163,7 @@ export interface SessionParams {
   userAgent: string
   id: number
   throttleIndex: number
+  useBrowserThrottling: boolean
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   evaluateAfter?: any[]
   exposedFunctions?: string
@@ -279,6 +280,8 @@ export class Session extends EventEmitter {
   readonly id: number
   /** The throttle configuration index assigned to the session. */
   readonly throttleIndex: number
+  /** If true, the network will be throttled using the browser internal throttling mechanism. */
+  readonly useBrowserThrottling: boolean
   /** The test page url. */
   readonly url: string
   /** The url query. */
@@ -378,6 +381,7 @@ export class Session extends EventEmitter {
     userAgent,
     id,
     throttleIndex,
+    useBrowserThrottling,
     evaluateAfter,
     exposedFunctions,
     scriptParams,
@@ -475,6 +479,7 @@ export class Session extends EventEmitter {
     this.emulateCpuThrottling = emulateCpuThrottling
 
     this.throttleIndex = throttleIndex
+    this.useBrowserThrottling = useBrowserThrottling
     this.evaluateAfter = evaluateAfter || []
     this.exposedFunctions = exposedFunctions || {}
     if (scriptParams) {
@@ -676,7 +681,7 @@ export class Session extends EventEmitter {
             deviceScaleFactor: this.deviceScaleFactor,
             isMobile: false,
             hasTouch: false,
-            isLandscape: false,
+            isLandscape: true,
           },
         })
       } catch (err) {
@@ -803,7 +808,7 @@ try {
 } catch (err) {
   console.error('[webrtcperf] Error parsing scriptParams:', err);
   webrtcperf.params = {};
-}
+};
   `
 
     if (this.serverPort) {
@@ -892,6 +897,9 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
 
     const page = await this.getNewPage(tabIndex)
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const pageCDPSession = (page as any)._client() as CDPSession
+
     await page.setBypassCSP(true)
 
     if (this.userAgent) {
@@ -910,23 +918,29 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     if (this.localStorage) {
       log.debug('Using localStorage:', this.localStorage)
       Object.entries(this.localStorage).map(([key, value]) => {
-        cmd += `localStorage.setItem('${key}', '${JSON.stringify(value)}');\n`
+        cmd += `window.localStorage.setItem('${key}', ${JSON.stringify(value)});\n`
       })
     }
     if (this.sessionStorage) {
       log.debug('Using sessionStorage:', this.sessionStorage)
       Object.entries(this.sessionStorage).map(([key, value]) => {
-        cmd += `sessionStorage.setItem('${key}', '${JSON.stringify(value)}');\n`
+        cmd += `window.sessionStorage.setItem('${key}', ${JSON.stringify(value)});\n`
       })
     }
+    cmd += `
+Object.defineProperty(window.screen, 'width', { value: ${this.windowWidth}, writable: false });
+Object.defineProperty(window.screen, 'height', { value: ${this.windowHeight}, writable: false });
+Object.defineProperty(window.screen, 'availWidth', { value: ${this.windowWidth}, writable: false });
+Object.defineProperty(window.screen, 'availHeight', { value: ${this.windowHeight}, writable: false });
+Object.defineProperty(window.screen.orientation, 'type', { value: 'landscape-primary', writable: false });
+    `
     log.debug('init command:', cmd)
     await page.evaluateOnNewDocument(cmd)
 
     // Clear cookies.
     if (this.clearCookies) {
       try {
-        const client = await page.target().createCDPSession()
-        await client.send('Network.clearBrowserCookies')
+        await pageCDPSession.send('Network.clearBrowserCookies')
       } catch (err) {
         log.error(`clearCookies error: ${(err as Error).stack}`)
       }
@@ -970,8 +984,6 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     // Enable request interception.
     let setRequestInterceptionState = true
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const pageCDPSession = (page as any)._client() as CDPSession
     await pageCDPSession.send('Network.setBypassServiceWorker', {
       bypass: true,
     })
@@ -1174,7 +1186,7 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     }
 
     // PeerConnectionExternal
-    await page.exposeFunction(
+    /* await page.exposeFunction(
       'createPeerConnectionExternal',
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async (options: any) => {
@@ -1192,7 +1204,7 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
           return pc[name](arg)
         }
       },
-    )
+    )*/
 
     // Simulate keypress
     await page.exposeFunction('keypressText', async (selector: string, text: string, delay = 20) => {
@@ -1305,7 +1317,7 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     if (this.showPageLog || saveFile) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       page.on('pageerror', async (error: any) => {
-        const text = `pageerror: ${error.message?.message || error.message} - ${error.message?.stack || error.stack}`
+        const text = `pageerror: ${error?.message?.message || error?.message || error} - ${error?.message?.stack || error?.stack}`
         await this.onPageMessage(index, 'error', text, saveFile)
       })
 
@@ -1420,12 +1432,25 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
       resourcesStats.wsRecvBytes += event.response.payloadData.length
     })
 
-    // hardware concurrency
+    // Hardware concurrency.
     if (this.hardwareConcurrency) {
       const plugin = NavigatorHardwareConcurrency({ hardwareConcurrency: this.hardwareConcurrency })
       await plugin.onPageCreated(page)
     }
 
+    // Network throttling.
+    if (this.throttleIndex > -1 && (process.platform !== 'linux' || this.useBrowserThrottling)) {
+      log.debug(`Using internal network throttling`)
+      await pageCDPSession.send('Network.emulateNetworkConditions', {
+        offline: false,
+        uploadThroughput: 100000000 / 8,
+        downloadThroughput: 100000000 / 8,
+        latency: 0,
+        packetLoss: 0,
+        packetQueueLength: 0,
+      })
+    }
+
     // Load page script.
     {
       const filePath = resolvePackagePath('node_modules/@vpalmisano/webrtcperf-js/dist/webrtcperf.js')
@@ -1485,6 +1510,13 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     // add to pages map
     this.pages.set(index, page)
 
+    if (this.throttleIndex > -1 && (process.platform !== 'linux' || this.useBrowserThrottling)) {
+      await this.applyNetworkThrottling(pageCDPSession)
+      throttleNotifier.on('change', async () => {
+        await this.applyNetworkThrottling(pageCDPSession)
+      })
+    }
+
     log.debug(`Page ${index + 1} "${url}" loaded in ${(Date.now() - pageLoadTime) / 1000}s`)
 
     for (let i = 0; i < this.evaluateAfter.length; i++) {
@@ -1496,6 +1528,25 @@ webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost
     }
   }
 
+  private async applyNetworkThrottling(pageCDPSession: CDPSession) {
+    const throttleUpValues = getSessionThrottleValues(this.throttleIndex, 'up')
+    const throttleDownValues = getSessionThrottleValues(this.throttleIndex, 'down')
+    const params = {
+      offline: false,
+      uploadThroughput: throttleUpValues.rate || -1,
+      downloadThroughput: throttleDownValues.rate || -1,
+      latency: Math.max(throttleUpValues.delay || 0, throttleDownValues.delay || 0),
+      packetLoss: Math.max(throttleUpValues.loss || 0, throttleDownValues.loss || 0),
+      packetQueueLength: Math.max(throttleUpValues.queue || 0, throttleDownValues.queue || 0),
+    }
+    log.debug(`Apply internal network throttling: ${JSON.stringify(params)}`)
+    await pageCDPSession.send('Network.emulateNetworkConditions', {
+      ...params,
+      uploadThroughput: params.uploadThroughput !== -1 ? params.uploadThroughput / 8 : -1,
+      downloadThroughput: params.downloadThroughput !== -1 ? params.downloadThroughput / 8 : -1,
+    })
+  }
+
   private async getNewPage(tabIndex: number): Promise<Page> {
     log.debug(`getNewPage ${tabIndex}`)
     assert(this.context, 'NoBrowserContextCreated')

package/src/utils.ts

@@ -651,28 +651,37 @@ export async function runShellCommand(
   cmd: string,
   verbose = false,
   maxBuffer = 1024 * 1024,
+  { provideStdin = false, returnStdout = true, returnStderr = true } = {},
 ): Promise<{ stdout: string; stderr: string }> {
   if (verbose) log.debug(`runShellCommand cmd: ${cmd}`)
   return new Promise((resolve, reject) => {
     const p = spawn(cmd, {
       shell: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
+      stdio: [
+        provideStdin ? 'inherit' : 'ignore',
+        returnStdout ? 'pipe' : 'inherit',
+        returnStderr ? 'pipe' : 'inherit',
+      ],
       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
-    })
+    if (returnStdout) {
+      p.stdout?.on('data', data => {
+        if (maxBuffer && stdout.length > maxBuffer) {
+          stdout = stdout.slice(data.length)
+        }
+        stdout += data
+      })
+    }
+    if (returnStderr) {
+      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) {