@vpalmisano/webrtcperf 4.4.8 → 4.4.10

package/src/docker.ts

@@ -1,48 +1,51 @@
-import path from 'path'
 import Docker from 'dockerode'
 import { logger, resolvePackagePath } from './utils'
 import { loadConfig } from './config'
+import { runShellCommand } from '@vpalmisano/throttler'
+import os from 'os'
 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]
+  const configPath = argv[0]
   if (!configPath) throw new Error('No configuration file specified')
-  const configName = path.basename(configPath)
-  const config = (await loadConfig(configPath))[0]
+  const configs = await loadConfig(configPath)
+  if (!configs.length) throw new Error('Failed to load configuration file')
 
   const startTimestamp = Date.now()
-  const dataDir = path.resolve(path.dirname(configPath), 'logs', `${startTimestamp}`)
-  await fs.promises.mkdir(dataDir, { recursive: true })
+  const dataDir = process.cwd()
+  const tmpDir = os.tmpdir()
+
+  const jsonConfigPath = `${tmpDir}/webrtcperf-config-${startTimestamp}.json`
+  await fs.promises.writeFile(jsonConfigPath, JSON.stringify(configs), 'utf-8')
 
   const binds: string[] = [
-    `${path.resolve(configPath)}:/config/${configName}:ro`,
     '/dev/shm:/dev/shm',
     `${dataDir}:/data`,
-    '/tmp/webrtcperf-cache:/root/.webrtcperf',
+    `${tmpDir}/webrtcperf-cache:/root/.webrtcperf`,
+    `${jsonConfigPath}:/tmp/config.json:ro`,
   ]
 
-  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}` }]
+  if (configs[0].debuggingPort) {
+    for (let i = 0; i < configs[0].sessions; i++) {
+      const port = `${configs[0].debuggingPort + i}/tcp`
+      portBindings[port] = [{ HostPort: `${configs[0].debuggingPort + i}` }]
       exposedPorts[port] = {}
     }
   }
 
+  if (configs[0].throttleConfig && os.platform() === 'linux') {
+    await runShellCommand('sudo modprobe ifb numifbs=1')
+  }
+
   const env = [
     `DEBUG_LEVEL=${process.env.DEBUG_LEVEL || 'info'}`,
     'SHOW_PAGE_LOG=false',
@@ -51,33 +54,25 @@ export async function runWithDocker(argv: string[]) {
     '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')) {
+  if (configs[0].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}`],
+    WorkingDir: '/data',
+    Cmd: ['/tmp/config.json'],
     HostConfig: {
       Binds: binds,
       PortBindings: portBindings,
-      CapAdd: ['NET_ADMIN'],
-      NetworkMode: config.prometheusPushgateway.startsWith('http://localhost') ? 'prometheus-stack_default' : 'bridge',
+      CapAdd: configs[0].throttleConfig && os.platform() === 'linux' ? ['NET_ADMIN'] : [],
+      NetworkMode: configs[0].prometheusPushgateway.startsWith('http://localhost')
+        ? 'prometheus-stack_default'
+        : 'bridge',
+      ExtraHosts: process.env.EXTRA_HOSTS ? process.env.EXTRA_HOSTS.split(',').map(h => h.trim()) : [],
     },
     Env: env,
     AttachStdin: true,
@@ -128,4 +123,6 @@ export async function runWithDocker(argv: string[]) {
     log.error('Docker operation failed:', error)
     throw error
   }
+
+  await fs.promises.unlink(jsonConfigPath)
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './app'
 export * from './config'
+export * from './docker'
 export * from './media'
 export * from './rtcstats'
 export * from './server'
@@ -7,3 +8,4 @@ export * from './session'
 export * from './stats'
 export * from './utils'
 export * from './vmaf'
+export * from './scenarios'

package/src/scenarios.ts

@@ -0,0 +1,148 @@
+import fs from 'fs'
+import path from 'path'
+import { FastStats } from './stats'
+import { ThrottleConfig, ThrottleRule } from '@vpalmisano/throttler'
+import { Config } from './config'
+
+export async function parseStatsFile(filePath: string) {
+  const fileData = await fs.promises.readFile(filePath, 'utf-8')
+  const lines = fileData.split('\n')
+  const headers = lines[0].split(',')
+  const data = lines.slice(1).map(line =>
+    line.split(',').reduce(
+      (acc, value, index) => {
+        if (value !== '') {
+          acc[headers[index]] = isNaN(Number(value)) ? value : Number(value)
+        }
+        return acc
+      },
+      {} as Record<string, string | number>,
+    ),
+  )
+  return data
+}
+
+export async function aggregateStatsSummary({
+  dirPath = 'logs',
+  senderParticipantName = 'Participant-000001',
+  receiverParticipantName = 'Participant-000000',
+  nameParser = (name: string) => {
+    const [_, id, scenario] = name.split('_')
+    return { id, scenario }
+  },
+}) {
+  const stats = [] as {
+    timestamp: number
+    id: string
+    scenario: string
+    videoRecvBitratePerPixel: FastStats
+    videoRecvFps: FastStats
+    videoSentFps: FastStats
+  }[]
+  const results = await fs.promises.readdir(dirPath)
+  for (const test of results) {
+    const filePath = path.join(dirPath, test, 'detailed-stats-summary.csv')
+    if (!fs.existsSync(filePath)) continue
+    const timestamp = fs.statSync(path.join(dirPath, test)).ctime.getTime()
+    const data = await parseStatsFile(filePath)
+    const { id, scenario } = nameParser(test)
+
+    const aggregated = {
+      timestamp,
+      id,
+      scenario,
+      videoRecvBitratePerPixel: new FastStats(),
+      videoRecvFps: new FastStats(),
+      videoSentFps: new FastStats(),
+    }
+    data.forEach(v => {
+      const { participantName, trackId } = v as { participantName: string; trackId: string }
+      const metrics = v as Record<string, number>
+      if (participantName === receiverParticipantName) {
+        if (trackId?.endsWith('-v') && metrics.videoRecvFrames > 0) {
+          const videoRecvBitratePerPixel =
+            metrics.videoRecvBitrates / (metrics.videoRecvWidth * metrics.videoRecvHeight)
+          if (!isNaN(videoRecvBitratePerPixel)) aggregated.videoRecvBitratePerPixel.push(videoRecvBitratePerPixel)
+          if (!isNaN(metrics.videoRecvFps)) aggregated.videoRecvFps.push(metrics.videoRecvFps)
+        }
+      } else if (participantName === senderParticipantName) {
+        if (trackId?.endsWith('-v') && metrics.videoSentFrames > 0) {
+          if (!isNaN(metrics.videoSentFps)) aggregated.videoSentFps.push(metrics.videoSentFps)
+        }
+      }
+    })
+    stats.push(aggregated)
+  }
+  return stats.sort((a, b) => a.timestamp - b.timestamp)
+}
+
+export type ThrottleDirection = 'up' | 'down' | 'bidi'
+
+export function formatThrottleRule(throttleRule: ThrottleRule, direction: ThrottleDirection) {
+  const { rate, loss, delay } = throttleRule
+  return `${direction}-r${rate}-l${loss}-d${delay}`
+}
+
+export function parseThrottleRule(throttleDesc: string) {
+  const match = throttleDesc.match(/(up|down|bidi)-r(\d+)-l([\d.]+)-d(\d+)/)
+  if (!match) throw new Error(`Invalid throttle description: ${throttleDesc}`)
+  const direction = match[1] as ThrottleDirection
+  const rate = parseInt(match[2])
+  const loss = parseInt(match[3])
+  const delay = parseInt(match[4])
+  return { direction, rate, loss, delay }
+}
+
+export async function simpleTestWithRateLossDelay(
+  id: string,
+  { rate, loss, delay, direction }: { rate: number; loss: number; delay: number; direction: ThrottleDirection },
+  repeat: 1,
+) {
+  const throttle: ThrottleConfig = {}
+  const queue = 25
+  if (direction === 'down' || direction === 'bidi') {
+    throttle.down = [
+      { rate: 20000, loss: 0, delay: 0, queue },
+      { rate, loss, delay, queue, at: 30 },
+    ]
+  }
+  if (direction === 'up' || direction === 'bidi') {
+    throttle.up = [
+      { rate: 20000, loss: 0, delay, queue },
+      { rate, loss, delay, queue, at: 30 },
+    ]
+  }
+  const throttleDesc = formatThrottleRule({ rate, loss, delay }, direction)
+  const now = Date.now()
+  const ret: Partial<Config>[] = []
+  for (let i = 0; i < repeat; i++) {
+    const basePath = `logs/${now}-${i + 1}_${id}_${throttleDesc}`
+    const sessions = direction === 'bidi' ? '0-1' : direction === 'down' ? '0' : '1'
+    ret.push({
+      sessions: 2,
+      runDuration: 60 * 3,
+      debuggingPort: 9000,
+      prometheusPushgateway: 'http://localhost:9091',
+      prometheusPushgatewayJobName: id,
+      statsPath: `${basePath}/stats.csv`,
+      detailedStatsPath: `${basePath}/detailed-stats.csv`,
+      showPageLog: false,
+      showStats: false,
+      statsInterval: 5,
+      scriptParams: JSON.stringify({
+        enableMic: '0-1',
+        enableCam: '1',
+      }),
+      throttleConfig: JSON.stringify([
+        {
+          sessions,
+          protocol: 'udp',
+          skipSourcePorts: '53,80,443',
+          skipDestinationPorts: '53,80,443',
+          ...throttle,
+        },
+      ]),
+    })
+  }
+  return ret
+}

package/src/utils.ts

@@ -23,7 +23,6 @@ import pidusage from 'pidusage'
 import puppeteer, { ImageFormat, Page } from 'puppeteer-core'
 
 import { Session } from './session'
-import { FastStats } from './stats'
 
 // eslint-disable-next-line
 const ps = require('pidusage/lib/ps')
@@ -1256,75 +1255,3 @@ export async function getDockerLogsPath(): Promise<string> {
   }
   return logPath
 }
-
-export async function parseStatsFile(filePath: string) {
-  const fileData = await fs.promises.readFile(filePath, 'utf-8')
-  const lines = fileData.split('\n')
-  const headers = lines[0].split(',')
-  const data = lines.slice(1).map(line =>
-    line.split(',').reduce(
-      (acc, value, index) => {
-        if (value !== '') {
-          acc[headers[index]] = isNaN(Number(value)) ? value : Number(value)
-        }
-        return acc
-      },
-      {} as Record<string, string | number>,
-    ),
-  )
-  return data
-}
-
-export async function aggregateStatsSummary({
-  dirPath = 'logs',
-  senderParticipantName = 'Participant-000001',
-  receiverParticipantName = 'Participant-000000',
-  nameParser = (name: string) => {
-    const [destination, scenario] = name.split('_')
-    return { destination, scenario }
-  },
-}) {
-  const stats = [] as {
-    timestamp: number
-    destination: string
-    scenario: string
-    videoRecvBitratePerPixel: FastStats
-    videoRecvFps: FastStats
-    videoSentFps: FastStats
-  }[]
-  const results = await fs.promises.readdir(dirPath)
-  for (const test of results) {
-    const filePath = path.join(dirPath, test, 'detailed-stats-summary.csv')
-    if (!fs.existsSync(filePath)) continue
-    const timestamp = fs.statSync(path.join(dirPath, test)).ctime.getTime()
-    const data = await parseStatsFile(filePath)
-    const { destination, scenario } = nameParser(test)
-
-    const aggregated = {
-      timestamp,
-      destination,
-      scenario,
-      videoRecvBitratePerPixel: new FastStats(),
-      videoRecvFps: new FastStats(),
-      videoSentFps: new FastStats(),
-    }
-    data.forEach(v => {
-      const { participantName, trackId } = v as { participantName: string; trackId: string }
-      const metrics = v as Record<string, number>
-      if (participantName === receiverParticipantName) {
-        if (trackId?.endsWith('-v') && metrics.videoRecvFrames > 0) {
-          const videoRecvBitratePerPixel =
-            metrics.videoRecvBitrates / (metrics.videoRecvWidth * metrics.videoRecvHeight)
-          if (!isNaN(videoRecvBitratePerPixel)) aggregated.videoRecvBitratePerPixel.push(videoRecvBitratePerPixel)
-          if (!isNaN(metrics.videoRecvFps)) aggregated.videoRecvFps.push(metrics.videoRecvFps)
-        }
-      } else if (participantName === senderParticipantName) {
-        if (trackId?.endsWith('-v') && metrics.videoSentFrames > 0) {
-          if (!isNaN(metrics.videoSentFps)) aggregated.videoSentFps.push(metrics.videoSentFps)
-        }
-      }
-    })
-    stats.push(aggregated)
-  }
-  return stats.sort((a, b) => a.timestamp - b.timestamp)
-}