@vpalmisano/webrtcperf 4.2.2 → 4.3.2

package/src/app.ts

@@ -23,6 +23,7 @@ import { calculateVisqolScore } from './visqol'
 import { calculateVmafScore, convertToIvf, prepareVideo } from './vmaf'
 import path from 'path'
 import { markedTerminal } from 'marked-terminal'
+import { EventEmitter } from 'events'
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const { marked } = require('marked')
@@ -56,141 +57,167 @@ Default value: \`${value.default}\`
   }
 }
 
-async function postTest(config: Config): Promise<void> {
-  // vmaf score.
-  if (config.vmafPath) {
-    console.log('Calculating VMAF score...')
-    try {
-      await calculateVmafScore(config)
-    } catch (err: unknown) {
-      log.error(`vmaf score error: ${(err as Error).stack}`)
+export class Application extends EventEmitter {
+  readonly config: Config
+  readonly stats: Stats
+  readonly server?: Server
+  private mediaPaths: MediaPath[] = []
+
+  constructor(config: Config) {
+    super()
+    if (!config.startTimestamp) {
+      config.startTimestamp = Date.now()
+    }
+    this.config = config
+    this.stats = new Stats(config)
+    if (config.serverPort) {
+      this.server = new Server(config, this.stats)
     }
   }
 
-  // visqol score
-  if (config.visqolPath) {
-    console.log('Calculating Visqol score...')
-    try {
-      await calculateVisqolScore(config)
-    } catch (err: unknown) {
-      log.error(`visqol score error: ${(err as Error).stack}`)
+  async start() {
+    log.debug(`start (runDuration: ${this.config.runDuration})`)
+    await this.stats.start()
+    if (this.server) {
+      await this.server.start()
     }
-  }
-}
+    const config = this.config
 
-export async function setupApplication(config: Config): Promise<{ stats: Stats; stop: () => Promise<void> }> {
-  if (!config.startTimestamp) {
-    config.startTimestamp = Date.now()
-  }
+    // Handle vmaf commands.
+    if (config.vmafPrepareVideo) {
+      await prepareVideo(config, true)
+    }
+    if (config.vmafProcessVideo) {
+      await convertToIvf(
+        config.vmafProcessVideo,
+        config.vmafVideoCrop,
+        config.vmafKeepSourceFiles,
+        config.vmafSkipDuplicated,
+      )
+    }
 
-  // Stats.
-  const stats = new Stats(config)
-  await stats.start()
+    // Handle sessions.
+    if (config.sessions > 0) {
+      // Prepare fake video and audio.
+      if (config.videoPath && !this.mediaPaths.length) {
+        for (const videoPath of config.videoPath.split(',')) {
+          const ret = await prepareFakeMedia({ ...config, videoPath })
+          this.mediaPaths.push(ret)
+        }
+      }
 
-  // Control server.
-  let server: Server | undefined
-  if (config.serverPort) {
-    server = new Server(config, stats)
-    await server.start()
-  }
+      // Network throttle.
+      if (config.throttleConfig) {
+        await startThrottle(config.throttleConfig)
+      }
 
-  // If sessions are set, prepare fake video/audio and start sessions.
-  if (config.sessions > 0) {
-    // Prepare fake video and audio.
-    const mediaPaths: MediaPath[] = []
-    if (config.videoPath) {
-      for (const videoPath of config.videoPath.split(',')) {
-        const ret = await prepareFakeMedia({ ...config, videoPath })
-        mediaPaths.push(ret)
+      // Download browser if necessary.
+      if (!config.chromiumUrl && !config.chromiumPath) {
+        await checkChromeExecutable()
       }
-    }
 
-    // Network throttle.
-    if (config.throttleConfig) {
-      await startThrottle(config.throttleConfig)
+      // Start the local sessions.
+      if (config.randomAudioPeriod) {
+        startRandomActivateAudio(
+          this.stats.sessions,
+          config.randomAudioPeriod,
+          config.randomAudioProbability,
+          config.randomAudioRange,
+        )
+      }
+      const spawnPeriod = 1000 / config.spawnRate
+      log.debug(`Starting ${config.sessions} sessions (spawnPeriod: ${spawnPeriod}ms)`)
+      const startTime = Date.now()
+      for (let i = 0; i < config.sessions; i += 1) {
+        const id = this.stats.consumeSessionId(config.tabsPerSession)
+        await this.startSession(id, spawnPeriod)
+        // If not the last session, sleep.
+        if (i < config.sessions - 1) {
+          await sleep(spawnPeriod)
+        }
+      }
+      const elapsed = Math.round((Date.now() - startTime) / 1000)
+      const spawnRate = (config.sessions * config.tabsPerSession) / elapsed
+      log.debug(`${config.sessions * config.tabsPerSession} pages started in ${elapsed}s (${spawnRate.toFixed(2)}/s)`)
     }
 
-    // Download browser if necessary.
-    if (!config.chromiumUrl && !config.chromiumPath) {
-      await checkChromeExecutable()
+    if (config.runDuration || config.vmafPath || config.visqolPath) {
+      setTimeout(() => this.stop(), config.runDuration * 1000)
     }
+  }
 
-    // Start session function.
-    const startLocalSession = async (id: number, spawnPeriod: number): Promise<void> => {
-      const throttleIndex = getSessionThrottleIndex(id)
-      const mediaPath = mediaPaths.length ? mediaPaths[id % mediaPaths.length] : undefined
-      const session = new Session({
-        ...config,
-        mediaPath,
-        spawnPeriod,
-        id,
-        throttleIndex,
-      })
-      session.once('stop', () => {
-        console.warn(`Session ${id} stopped, reloading...`)
-        setTimeout(startLocalSession, spawnPeriod, id)
-      })
-      stats.addSession(session)
-      await session.start()
-    }
+  private async startSession(id: number, spawnPeriod: number) {
+    log.debug(`startSession ${id}`)
+    const throttleIndex = getSessionThrottleIndex(id)
+    const mediaPath = this.mediaPaths.length ? this.mediaPaths[id % this.mediaPaths.length] : undefined
+    const session = new Session({
+      ...this.config,
+      mediaPath,
+      spawnPeriod,
+      id,
+      throttleIndex,
+    })
+    session.once('stop', () => {
+      console.warn(`Session ${id} stopped, reloading...`)
+      setTimeout(() => this.startSession(id, spawnPeriod), spawnPeriod)
+    })
+    this.stats.addSession(session)
+    await session.start()
+  }
 
-    // Start the local sessions.
-    if (config.randomAudioPeriod) {
-      startRandomActivateAudio(
-        stats.sessions,
-        config.randomAudioPeriod,
-        config.randomAudioProbability,
-        config.randomAudioRange,
-      )
+  private async postTest() {
+    log.debug('postTest')
+
+    // vmaf score.
+    if (this.config.vmafPath) {
+      console.log('Calculating VMAF score...')
+      try {
+        await calculateVmafScore(this.config)
+      } catch (err: unknown) {
+        log.error(`vmaf score error: ${(err as Error).stack}`)
+      }
     }
-    const spawnPeriod = 1000 / config.spawnRate
-    log.debug(`Starting ${config.sessions} sessions (spawnPeriod: ${spawnPeriod}ms)`)
-    const startTime = Date.now()
-    for (let i = 0; i < config.sessions; i += 1) {
-      const id = stats.consumeSessionId(config.tabsPerSession)
-      await startLocalSession(id, spawnPeriod)
-      // If not the last session, sleep
-      if (i < config.sessions - 1) {
-        await sleep(spawnPeriod)
+
+    // visqol score
+    if (this.config.visqolPath) {
+      console.log('Calculating Visqol score...')
+      try {
+        await calculateVisqolScore(this.config)
+      } catch (err: unknown) {
+        log.error(`visqol score error: ${(err as Error).stack}`)
       }
     }
-    const elapsed = Math.round((Date.now() - startTime) / 1000)
-    const spawnRate = (config.sessions * config.tabsPerSession) / elapsed
-    log.debug(`${config.sessions * config.tabsPerSession} pages started in ${elapsed}s (${spawnRate.toFixed(2)}/s)`)
   }
 
-  return {
-    stats,
-    stop: async (): Promise<void> => {
-      log.debug('Stopping')
+  async stop(canceled = false) {
+    log.debug(`stop (canceled: ${canceled})`)
 
-      stopRandomActivateAudio()
+    stopRandomActivateAudio()
 
-      await stats.stop()
+    await this.stats.stop()
 
-      if (config.throttleConfig) {
-        await stopThrottle()
-      }
+    if (this.config.throttleConfig) {
+      await stopThrottle()
+    }
 
-      stopTimers()
+    stopTimers()
 
-      await postTest(config)
+    await this.postTest()
 
-      // Copy docker logs to data directory.
-      if (config.pageLogPath) {
-        try {
-          const logPath = await getDockerLogsPath()
-          const dataDir = path.dirname(config.pageLogPath)
-          await fs.promises.cp(logPath, path.resolve(dataDir, 'docker.log'))
-        } catch (err: unknown) {
-          log.debug(`docker logs not found: ${(err as Error).message}`)
-        }
+    // Copy docker logs to data directory.
+    if (this.config.pageLogPath) {
+      try {
+        const logPath = await getDockerLogsPath()
+        const dataDir = path.dirname(this.config.pageLogPath)
+        await fs.promises.cp(logPath, path.resolve(dataDir, 'docker.log'))
+      } catch (err: unknown) {
+        log.debug(`docker logs not found: ${(err as Error).message}`)
       }
+    }
 
-      server?.stop()
+    this.server?.stop()
 
-      log.debug('Stopped')
-    },
+    this.emit('stop', canceled)
   }
 }
 
@@ -200,7 +227,7 @@ export async function setupApplication(config: Config): Promise<{ stats: Stats;
 async function main(): Promise<void> {
   showHelpOrVersion()
 
-  let config: Config
+  let configs: Config[]
 
   if (process.argv.slice(2).includes('--prompt')) {
     const params = await loadConfigFromPrompt(
@@ -213,39 +240,36 @@ async function main(): Promise<void> {
       console.log(json5.stringify(params, null, 2))
       process.exit(0)
     }
-    config = await loadConfig(undefined, params)
+    configs = await loadConfig(undefined, params)
   } else {
-    config = await loadConfig(process.argv[2])
+    configs = await loadConfig(process.argv[2])
   }
 
-  if (config.vmafPrepareVideo) {
-    await prepareVideo(config, true)
-    process.exit(0)
-  }
+  if (!configs.length) throw new Error('No configuration found')
 
-  if (config.vmafProcessVideo) {
-    await convertToIvf(
-      config.vmafProcessVideo,
-      config.vmafVideoCrop,
-      config.vmafKeepSourceFiles,
-      config.vmafSkipDuplicated,
-    )
-    process.exit(0)
-  }
+  let application: Application
+  const runNext = () => {
+    const config = configs.splice(0, 1)[0]
 
-  const { stop: stopApplication } = await setupApplication(config)
+    application = new Application(config)
+    application.once('stop', canceled => {
+      if (!canceled && configs.length) {
+        log.info(`Application stopped, running next (${configs.length} left)...`)
+        runNext()
+      } else {
+        process.exit(0)
+      }
+    })
+    return application.start()
+  }
 
-  const stop = async (): Promise<void> => {
+  const stop = async () => {
     console.log('Exiting...')
-
-    await stopApplication()
-
-    process.exit(0)
+    await application.stop(true)
   }
   registerExitHandler(() => stop())
 
-  // Stop after a configured duration.
-  setTimeout(stop, config.runDuration * 1000)
+  await runNext()
 
   // Command line interface.
   if (process.stdin && process.stdin.setRawMode) {

package/src/config.ts

@@ -6,6 +6,7 @@ import path, { join } from 'path'
 import json5 from 'json5'
 import yaml from 'yaml'
 import toml from 'toml'
+import fs from 'fs'
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const puppeteer = require('puppeteer-core')
@@ -56,8 +57,7 @@ convict.addParser([
   { extension: 'toml', parse: toml.parse },
 ])
 
-// config schema
-const configSchema = convict({
+const configSchema = {
   url: {
     doc: `The page url to load.`,
     format: String,
@@ -859,7 +859,7 @@ E.g. \`{ w: "iw-10", h: "ih-5", x: "10", y: '5' }\``,
     env: 'VISQOL_KEEP_SOURCE_FILES',
     arg: 'visqol-keep-source-files',
   },
-})
+}
 
 type ConfigDocs = Record<string, { doc: string; format: string; default: string }>
 
@@ -897,10 +897,10 @@ function formatDocs(
  * It returns the formatted configuration docs.
  */
 export function getConfigDocs(): ConfigDocs {
-  return formatDocs({}, null, configSchema.getSchema())
+  return formatDocs({}, null, convict(configSchema).getSchema())
 }
 
-const _schemaProperties = configSchema.getProperties()
+const _schemaProperties = convict(configSchema).getProperties()
 
 /** [[include:config.md]] */
 export type Config = typeof _schemaProperties
@@ -909,7 +909,8 @@ export type Config = typeof _schemaProperties
  * Loads the config object.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function loadConfig(filePath?: string, values?: any): Promise<Config> {
+export async function loadConfig(filePath?: string, values?: any): Promise<Config[]> {
+  const configs: Config[] = []
   if (filePath) {
     if (filePath.startsWith('http')) {
       log.debug(`Loading config from url: ${filePath}`)
@@ -917,41 +918,45 @@ export async function loadConfig(filePath?: string, values?: any): Promise<Confi
       if (!res?.data) {
         throw new Error(`Failed to download configuration from: ${filePath}`)
       }
-      const values =
+      values =
         res.contentType === 'application/x-yaml'
           ? yaml.parse(res.data)
           : res.contentType === 'application/toml'
             ? toml.parse(res.data)
             : json5.parse(res.data)
-      configSchema.load(values)
     } else if (existsSync(filePath)) {
       log.debug(`Loading config from local file: ${filePath}`)
       if (filePath.endsWith('.js') || filePath.endsWith('.mjs')) {
         const module = await import(/* webpackIgnore: true */ path.resolve(filePath))
-        configSchema.load(await module.default())
+        values = await module.default()
       } else {
-        configSchema.loadFile(filePath)
+        const data = String(await fs.promises.readFile(filePath))
+        values =
+          filePath.endsWith('.yml') || filePath.endsWith('.yaml')
+            ? yaml.parse(data)
+            : filePath.endsWith('.toml')
+              ? toml.parse(data)
+              : json5.parse(data)
       }
     }
-  } else if (values) {
-    log.debug('Loading config from values.')
-    configSchema.load(values)
-  } else {
-    log.debug('Loading config from default values.')
-    configSchema.load({})
   }
-
-  configSchema.validate({ allowed: 'strict' })
-  const config = configSchema.getProperties()
-
-  log.debug('Using config:', config)
-  return config
+  if (!Array.isArray(values)) {
+    values = [values || {}]
+  }
+  for (const value of values) {
+    const schema = convict(configSchema)
+    schema.load(value || {})
+    schema.validate({ allowed: 'strict' })
+    configs.push(schema.getProperties())
+  }
+  log.debug('Using config:', configs)
+  return configs
 }
 
 function getFunctionDeclaration() {
   const properties: Record<string, { type: string; description: string; nullable?: boolean }> = {}
   const required: string[] = []
-  const schema = configSchema.getSchema()
+  const schema = convict(configSchema).getSchema()
 
   Object.entries(schema._cvtProperties).forEach(([name, value]) => {
     const { format, doc, nullable } = value as SchemaObj

package/src/server.ts

@@ -11,10 +11,12 @@ import { WebSocketServer } from 'ws'
 import zlib from 'zlib'
 import auth from 'basic-auth'
 
-import { loadConfig } from './config'
+import { Config, loadConfig } from './config'
 import { Session, SessionParams } from './session'
 import { Stats } from './stats'
 import { logger, runShellCommand, getDockerLogsPath } from './utils'
+import { getSessionThrottleIndex } from '@vpalmisano/throttler'
+import { MediaPath, prepareFakeMedia } from './media'
 
 const log = logger('webrtcperf:server')
 
@@ -272,7 +274,8 @@ export class Server {
   private async putSession(req: express.Request, res: express.Response, next: express.NextFunction): Promise<void> {
     log.debug(`PUT /session`, req.body)
     try {
-      const id = this.stats.consumeSessionId()
+      const config = req.body as Config
+      const id = this.stats.consumeSessionId(config.tabsPerSession)
       await this.startLocalSession(id, req.body)
       res.json({
         message: `Session created`,
@@ -293,10 +296,10 @@ export class Server {
   private async putSessions(req: express.Request, res: express.Response, next: express.NextFunction): Promise<void> {
     log.debug(`PUT /sessions`, req.body)
     try {
-      const { sessions } = req.body
+      const { sessions, tabsPerSession } = req.body as Config
       const sessionsIds = []
       for (let i = 0; i < sessions; i++) {
-        const id = this.stats.sessions.size
+        const id = this.stats.consumeSessionId(tabsPerSession)
         await this.startLocalSession(id, req.body)
         sessionsIds.push(id)
       }
@@ -471,12 +474,25 @@ export class Server {
    * @param config The session configuration.
    */
   private async startLocalSession(id: number, config: SessionParams): Promise<Session> {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const sessionConfig = loadConfig(undefined, config) as any
-    const session = new Session({ ...sessionConfig, id })
+    const configs = await loadConfig(undefined, config)
+    const sessionConfig = configs[0]
+    const throttleIndex = getSessionThrottleIndex(id)
+    const spawnPeriod = 1000 / sessionConfig.spawnRate
+
+    // Prepare fake video and audio.
+    const mediaPaths: MediaPath[] = []
+    if (sessionConfig.videoPath) {
+      for (const videoPath of sessionConfig.videoPath.split(',')) {
+        const ret = await prepareFakeMedia({ ...sessionConfig, videoPath })
+        mediaPaths.push(ret)
+      }
+    }
+    const mediaPath = mediaPaths.length ? mediaPaths[id % mediaPaths.length] : undefined
+
+    const session = new Session({ ...sessionConfig, throttleIndex, spawnPeriod, mediaPath, id })
     session.once('stop', () => {
       console.warn(`Session ${id} stopped, reloading...`)
-      setTimeout(this.startLocalSession.bind(this), sessionConfig.spawnPeriod, id, config)
+      setTimeout(this.startLocalSession.bind(this), spawnPeriod, id, config)
     })
     this.stats.addSession(session)
     try {
@@ -510,13 +526,17 @@ export class Server {
     log.debug('start')
     if (this.serverUseHttps) {
       const destDir = path.join(os.homedir(), '.webrtcperf/ssl')
-      await 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"`,
-      )
+      const keyPath = path.join(destDir, 'domain.key')
+      const crtPath = path.join(destDir, 'domain.crt')
+      if (!fs.existsSync(keyPath) || !fs.existsSync(crtPath)) {
+        await runShellCommand(
+          `mkdir -p ${destDir} && openssl req -newkey rsa:2048 -nodes -keyout ${keyPath} -x509 -days 365 -out ${crtPath} -subj "/C=EU/ST=London/L=London/O=Global Security/OU=IT Department/CN=example.com"`,
+        )
+      }
       this.server = _createServer(
         {
-          key: fs.readFileSync(`${destDir}/domain.key`),
-          cert: fs.readFileSync(`${destDir}/domain.crt`),
+          key: fs.readFileSync(keyPath),
+          cert: fs.readFileSync(crtPath),
         },
         this.app,
       )