WIP: convert to local runner

Author: wesleytodd

package-lock.json

@@ -4,8 +4,6 @@
   "description": "ExpressJS Performance Working Group",
   "scripts": {
     "setup": "npm i",
-    "local-server": "expf local-server",
-    "local-load": "expf local-load",
     "test": "echo \"Error: no test specified\" && exit 1",
     "lint": "npm run --workspaces --if-present lint",
     "lint:fix": "npm run --workspaces --if-present lint:fix",

package.json

@@ -1,5 +1,7 @@
 import autocannon from 'autocannon';
 
+export * from './spawn.mjs';
+
 export function run (opts) {
   return new Promise((resolve, reject) => {
     autocannon(opts, (err, result) => {

packages/autocannon/index.mjs

@@ -12,7 +12,8 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
-    "autocannon": "^8.0.0"
+    "autocannon": "^8.0.0",
+    "shell-quote": "^1.8.3"
   },
   "devDependencies": {
     "semistandard": "^17.0.0"

packages/autocannon/package.json

@@ -0,0 +1,144 @@
+import { availableParallelism } from 'node:os';
+import { spawn } from 'node:child_process';
+import { quote as shellQuote } from 'shell-quote';
+
+export class AutocannonCLI {
+  // NOTE: I don't use windows or have a windows machine to test on, so this
+  // was just carried over from the previous implementation, someone
+  // should go and test I didn't break this
+  executable = process.platform === 'win32' ? 'autocannon.cmd' : 'autocannon';
+  isPresent = null;
+  status = null;
+  procs = [];
+
+  duration = 60;
+  connections = 100;
+  method = 'GET';
+  url = new URL('http://127.0.0.1:3000/');
+  headers = {};
+  body;
+
+  constructor (opts = {}) {
+    // autocannon options
+    this.duration = opts.duration || this.duration;
+    this.connections = opts.connections || this.connections;
+
+    // request options
+    this.method = opts.method || this.method;
+    this.url = opts.url || this.url;
+    this.headers = opts.headers || this.headers;
+    this.body = opts.body || this.body;
+  }
+
+  async start (opts = {}) {
+    // Check if present, but only once
+    if (this.isPresent === null) {
+      try {
+        await this.spawn(['-h']);
+        this.isPresent = true;
+      } catch (e) {
+        // Set the status to the error we got
+        this.status = e;
+        this.isPresent = false;
+      }
+    }
+
+    if (!this.isPresent) {
+      this.status = this.status || 'not present';
+      throw new Error('executable not present', {
+        cause: this.status
+      });
+    }
+
+    this.status = 'starting';
+
+    const args = [
+      // -d/--duration SEC
+      '-d', this.duration,
+      // -c/--connections NUM
+      '-c', this.connections,
+      // -w/--workers NUM
+      '-w', Math.min(this.connections, availableParallelism() || 8),
+
+      // -j/--json
+      '-j',
+      // -n/--no-progress
+      '-n',
+
+      // -m/--method METHOD
+      '-m', opts.method || this.method
+    ];
+
+    // -b/--body BODY
+    const body = opts.body || this.body;
+    if (body) {
+      args.push('-b', typeof body === 'string' ? body : JSON.stringify(body));
+    }
+
+    // -H/--headers K=V
+    for (const [header, value] of Object.entries(opts.headers || this.headers)) {
+      args.push('-H', `${header}=${value}`);
+    }
+
+    // url (positional)
+    const url = opts.url ? new URL(opts.url, this.url) : this.url;
+    args.push(url.toString());
+
+    // Run the process
+    const stdout = await this.spawn(args);
+
+    const result = JSON.parse(stdout);
+    if (!result.requests.average) {
+      throw new Error(`${this.executable} produced invalid JSON output`);
+    }
+
+    return result;
+  }
+
+  async spawn (args = [], opts = {}) {
+    return new Promise((resolve, reject) => {
+      if (this.status === 'aborted') {
+        return reject(new Error('Aborted before start'));
+      }
+      const proc = spawn(`${this.executable} ${shellQuote(args)}`, {
+        shell: true
+      }, opts);
+
+      this.procs.push(proc);
+
+      let stderr = '';
+      proc.stderr.setEncoding('utf8');
+      proc.stderr.on('data', (chunk) => {
+        stderr += chunk;
+      });
+
+      let stdout = '';
+      proc.stdout.setEncoding('utf8');
+      proc.stdout.on('data', (chunk) => {
+        stdout += chunk;
+      });
+
+      const onError = (e, data) => {
+        Object.assign(e, { stderr, stdout, ...data });
+        this.status = e;
+        reject(e);
+      };
+
+      proc.once('error', (e) => onError(e));
+
+      proc.once('close', (code) => {
+        if (code) {
+          return onError(new Error(`${this.executable} failed with ${code}`, { code }));
+        }
+        resolve(stdout);
+      });
+    });
+  }
+
+  close () {
+    this.procs.forEach((proc) => {
+      proc.kill('SIGINT');
+    });
+    this.status = 'aborted';
+  }
+}

packages/autocannon/spawn.mjs

@@ -88,20 +88,6 @@ switch (positionals[2]) {
       console.error(e);
     }
     break;
-  case 'local-server':
-    try {
-      await (await import('../local-server.mjs')).default(values);
-    } catch (e) {
-      console.error(e);
-    }
-    break;
-  case 'local-load':
-    try {
-      await (await import('../local-load.mjs')).default(values);
-    } catch (e) {
-      console.error(e);
-    }
-    break;
   default:
     console.log(`
 Express Performance Testing CLI

packages/cli/bin/expf.mjs

@@ -11,7 +11,7 @@ export function help (opts = {}) {
   Flags:
 
     --cwd=${opts.cwd || normalize(join(import.meta.dirname, '..', '..'))}
-    --runner=@expressjs/perf-runner-vanilla
+    --runner=@expressjs/perf-runner-local
     --repo=https://github.com/expressjs/perf-wg.git
     --repo-ref=master
     --test=@expressjs/perf-load-example
@@ -59,9 +59,9 @@ export default function main (_opts = {}) {
 
     const opts = {
       cwd,
-      repo: 'https://github.com/expressjs/perf-wg.git',
-      repoRef: 'master',
-      runner: '@expressjs/perf-runner-vanilla',
+      repo: null, // 'https://github.com/expressjs/perf-wg.git',
+      repoRef: null, // 'master',
+      runner: '@expressjs/perf-runner-local',
       test: '@expressjs/perf-load-example',
       node: 'lts_latest',
       ...conf,
@@ -116,6 +116,12 @@ export default function main (_opts = {}) {
       vers = await nv(opts.node, {
         latestOfMajorOnly: true
       });
+
+      if (!vers?.[0]?.version) {
+        throw Object.assign(new Error(`Unable to resolve node version`), {
+          spec: opts.node
+        });
+      }
     } catch (e) {
       // If offline or cannt load node versions, use
       // the option as passed in without a default
@@ -138,7 +144,9 @@ export default function main (_opts = {}) {
       await writeFile(outputFile, JSON.stringify(results, null, 2));
       console.log(`written to: ${outputFile}`);
     } else {
-      console.log(results);
+      console.log(...Object.entries(results).flatMap(([k, v]) => {
+        return ['\n', k, '\n', v];
+      }));
     }
     completed = true;