loadtest 7.1.1 → 8.0.1

package/lib/httpClient.js

@@ -3,21 +3,14 @@ import * as http from 'http'
 import * as https from 'https'
 import * as querystring from 'querystring'
 import * as websocket from 'websocket'
-import {HighResolutionTimer} from './hrtimer.js'
 import {addUserAgent} from './headers.js'
 import * as agentkeepalive from 'agentkeepalive'
 import * as HttpsProxyAgent from 'https-proxy-agent'
 
-
+http.globalAgent.maxSockets = 1000;
+https.globalAgent.maxSockets = 1000;
 let uniqueIndex = 1
 
-/**
- * Create a new HTTP client.
- * Seem parameters below.
- */
-export function create(loadTest, options) {
-	return new HttpClient(loadTest, options);
-}
 
 /**
  * A client for an HTTP connection. Constructor:
@@ -26,11 +19,12 @@ export function create(loadTest, options) {
  *		- running: if the loadTest is running or not.
  *	- `options`: same options as exports.loadTest.
  */
-class HttpClient {
-	constructor(loadTest, options) {
+export class HttpClient {
+	constructor(loadTest) {
 		this.loadTest = loadTest
-		this.options = options
-		this.stopped = false
+		this.latency = loadTest.latency
+		this.options = loadTest.options
+		this.running = true
 		this.init();
 	}
 
@@ -45,18 +39,11 @@ class HttpClient {
 			this.params.key = this.options.key;
 		}
 		this.params.agent = false;
-		if (this.options.requestsPerSecond) {
-			// rps for each client is total / concurrency (# of clients)
-			this.params.requestsPerSecond = this.options.requestsPerSecond / this.options.concurrency
-		}
 		if (this.options.agentKeepAlive) {
 			const KeepAlive = (this.params.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive.default;
 			let maxSockets = 10;
-			if (this.params.requestsPerSecond) {
-				maxSockets += Math.floor(this.params.requestsPerSecond);
-			}
 			this.params.agent = new KeepAlive({
-				maxSockets: maxSockets,
+				maxSockets,
 				maxKeepAliveRequests: 0, // max requests per keepalive socket, default is 0, no limit
 				maxKeepAliveTime: 30000  // keepalive for 30 seconds
 			});
@@ -111,39 +98,27 @@ class HttpClient {
 	 * Start the HTTP client.
 	 */
 	start() {
-		if (this.stopped) {
-			// solves testing issue: with requestsPerSecond clients are started at random,
-			// so sometimes they are stopped before they have even started
-			return
-		}
-		if (!this.params.requestsPerSecond) {
-			return this.makeRequest();
-		}
-		const interval = 1000 / this.params.requestsPerSecond;
-		this.requestTimer = new HighResolutionTimer(interval, () => this.makeRequest());
+		return this.makeRequest();
 	}
 
 	/**
 	 * Stop the HTTP client.
 	 */
 	stop() {
-		this.stopped = true
-		if (this.requestTimer) {
-			this.requestTimer.stop();
-		}
+		this.running = false
 	}
 
 	/**
 	 * Make a single request to the server.
 	 */
 	makeRequest() {
-		if (!this.loadTest.running) {
-			return;
+		if (!this.running) {
+			return
 		}
-		if (this.loadTest.options.maxRequests && this.loadTest.requests >= this.loadTest.options.maxRequests) return
-		this.loadTest.requests += 1;
-
-		const id = this.loadTest.latency.start();
+		if (!this.latency.shouldSend()) {
+			return
+		}
+		const id = this.latency.begin();
 		const params = {...this.params, headers: {...this.params.headers}}
 		this.customizeIndex(params)
 		const request = this.getRequest(id, params)
@@ -226,7 +201,7 @@ class HttpClient {
 				errorCode = '-1';
 			}
 		}
-		const elapsed = this.loadTest.latency.end(id, errorCode);
+		const elapsed = this.latency.end(id, errorCode);
 		if (elapsed < 0) {
 			// not found or not running
 			return;
@@ -234,7 +209,7 @@ class HttpClient {
 		if (result) {
 			result.requestElapsed = elapsed;
 		}
-		this.loadTest.finishRequest(error, result, () => this.makeRequest());
+		this.loadTest.pool.finishRequest(this, result, error);
 	}
 
 	connect(connection, id) {

package/lib/latency.js

@@ -3,37 +3,36 @@ import {Result} from './result.js'
 
 
 /**
- * Latency measurements. Options can be:
+ * Latency measurements. Receives a load test instance, containing options which can be:
  *	- maxRequests: max number of requests to measure before stopping.
  *	- maxSeconds: max seconds, alternative to max requests.
- * An optional callback(error, result) will be called with an error,
- * or the result after max is reached.
  */
 export class Latency {
-	constructor(options, callback) {
-		this.options = options
-		this.callback = callback
+	constructor(loadTest) {
+		this.loadTest = loadTest
+		this.options = loadTest.options
 		this.requests = new Map();
 		this.partialRequests = 0;
 		this.partialTime = 0;
 		this.partialErrors = 0;
+		this.begunRequests = 0;
+		this.totalRequests = 0
 		this.lastShownNs = this.getTimeNs();
 		this.startTimeNs = this.getTimeNs();
-		this.totalRequests = 0;
 		this.totalTime = 0;
 		this.totalErrors = 0;
 		this.maxLatencyMs = 0;
 		this.minLatencyMs = 999999;
 		this.histogramMs = {};
 		this.errorCodes = {};
-		this.running = true;
 		this.totalsShown = false;
 	}
 
 	/**
 	 * Start the request with the given id.
 	 */
-	start(requestId) {
+	begin(requestId) {
+		this.begunRequests += 1
 		requestId = requestId || randomUUID();
 		this.requests.set(requestId, this.getTimeNs())
 		return requestId;
@@ -44,10 +43,11 @@ export class Latency {
 	 * Accepts an optional error code signaling an error.
 	 */
 	end(requestId, errorCode) {
+		this.totalRequests += 1
 		if (!this.requests.has(requestId)) {
 			return -2;
 		}
-		if (!this.running) {
+		if (!this.loadTest.running) {
 			return -1;
 		}
 		const elapsed = this.getElapsedMs(this.requests.get(requestId));
@@ -64,7 +64,6 @@ export class Latency {
 		this.partialTime += time;
 		this.partialRequests++;
 		this.totalTime += time;
-		this.totalRequests++;
 		if (errorCode) {
 			errorCode = String(errorCode);
 			this.partialErrors++;
@@ -85,9 +84,6 @@ export class Latency {
 			this.histogramMs[rounded] = 0;
 		}
 		this.histogramMs[rounded] += 1;
-		if (this.isFinished()) {
-			this.finish();
-		}
 	}
 
 	/**
@@ -95,6 +91,9 @@ export class Latency {
 	 */
 	showPartial() {
 		const elapsedSeconds = this.getElapsedMs(this.lastShownNs) / 1000;
+		if (elapsedSeconds < 1) {
+			return
+		}
 		const meanTime = this.partialTime / this.partialRequests || 0.0;
 		const result = {
 			meanLatencyMs: Math.round(meanTime * 10) / 10,
@@ -135,15 +134,19 @@ export class Latency {
 	 * @return {Number} the elapsed time in milliseconds
 	 */
 	getElapsedMs(startTimeNs) {
-		const endTimeNs = this.getTimeNs()
-		const elapsedNs = endTimeNs - startTimeNs
+		const stopTimeNs = this.getTimeNs()
+		const elapsedNs = stopTimeNs - startTimeNs
 		return Number(elapsedNs / 1000000n)
 	}
 
-	/**
-	 * Check out if the measures are finished.
-	 */
-	isFinished() {
+	shouldSend() {
+		if (this.options.maxRequests && this.begunRequests >= this.options.maxRequests) {
+			return false;
+		}
+		return true
+	}
+
+	shouldStop() {
 		if (this.options.maxRequests && this.totalRequests >= this.options.maxRequests) {
 			return true;
 		}
@@ -157,12 +160,8 @@ export class Latency {
 	/**
 	 * We are finished.
 	 */
-	finish() {
-		this.running = false;
-		this.endTimeNs = this.getTimeNs()
-		if (this.callback) {
-			return this.callback(null, this.getResult());
-		}
+	stop() {
+		this.stopTimeNs = this.getTimeNs()
 	}
 
 	/**
@@ -170,7 +169,8 @@ export class Latency {
 	 */
 	getResult() {
 		const result = new Result()
-		result.compute(this.options, this)
+		result.compute(this)
+		result.clients = this.loadTest.countClients()
 		return result
 	}
 

package/lib/loadtest.js

@@ -1,16 +1,10 @@
-import * as http from 'http'
-import * as https from 'https'
-import * as httpClient from './httpClient.js'
-import * as websocket from './websocket.js'
+import {Pool} from './pool.js'
 import {Latency} from './latency.js'
 import {HighResolutionTimer} from './hrtimer.js'
 import {processOptions} from './options.js'
 
 const SHOW_INTERVAL_MS = 5000;
 
-http.globalAgent.maxSockets = 1000;
-https.globalAgent.maxSockets = 1000;
-
 
 /**
  * Run a load test.
@@ -35,6 +29,7 @@ https.globalAgent.maxSockets = 1000;
  *	 - debug: show debug messages (deprecated).
  *	 - requestGenerator: use a custom function to generate requests.
  *	 - statusCallback: function called after every request.
+ *	 - tcp: use TCP sockets (experimental).
  * - `callback`: optional `function(result, error)` called if/when the test finishes;
  * if not present a promise is returned.
  */
@@ -52,20 +47,19 @@ async function loadTestAsync(options) {
 
 function runLoadTest(options) {
 	return new Promise((resolve, reject) => {
-		const operation = new LoadTest(options, (error, result) => {
-			if (error) {
-				return reject(error)
-			}
-			return resolve(result)
-		});
-		operation.start();
+		try {
+			const loadTest = new LoadTest(options, result => resolve(result))
+			loadTest.start();
+		} catch(error) {
+			return reject(error)
+		}
 	})
 }
 
 /**
  * Used to keep track of individual load test runs.
  */
-let operationInstanceIndex = 0;
+let instanceIndex = 0;
 
 /**
  * A load test operation.
@@ -74,74 +68,39 @@ class LoadTest {
 	constructor(options, callback) {
 		this.options = options;
 		this.finalCallback = callback;
-		this.running = true;
-		this.latency = null;
-		this.clients = {};
-		this.requests = 0;
-		this.completedRequests = 0;
+		this.latency = new Latency(this);
+		this.pool = new Pool(this)
+		this.instanceIndex = instanceIndex++
 		this.showTimer = null;
 		this.stopTimeout = null;
-		this.instanceIndex = operationInstanceIndex++;
-		this.requestIndex = 0
+		this.running = true;
 	}
 
 	/**
 	 * Start the operation.
 	 */
 	start() {
-		this.latency = new Latency(this.options);
-		this.startClients();
 		if (this.options.maxSeconds) {
 			this.stopTimeout = setTimeout(() => this.stop(), this.options.maxSeconds * 1000).unref();
 		}
 		this.showTimer = new HighResolutionTimer(SHOW_INTERVAL_MS, () => this.latency.showPartial());
 		this.showTimer.unref();
+		this.pool.start()
 	}
 
-	/**
-	 * Call after each request has finished.
-	 */
-	finishRequest(error, result, next) {
-		this.completedRequests += 1;
-		if (this.options.maxRequests) {
-			if (this.completedRequests == this.options.maxRequests) {
-				this.stop();
-			}
-		}
-		if (this.running && !this.options.requestsPerSecond) {
-			next();
+	checkStop() {
+		if (!this.running) {
+			return true
 		}
-		if (this.options.statusCallback) {
-			result.requestIndex = this.requestIndex++
-			result.instanceIndex = this.instanceIndex
-			this.options.statusCallback(error, result);
+		if (!this.latency.shouldStop()) {
+			return false
 		}
+		this.stop()
+		return true
 	}
 
-	/**
-	 * Start a number of measuring clients.
-	 */
-	startClients() {
-		for (let index = 0; index < this.options.concurrency; index++) {
-			const createClient = this.getClientCreator()
-			const client = createClient(this, this.options);
-			this.clients[index] = client;
-			if (!this.options.requestsPerSecond) {
-				client.start();
-			} else {
-				// start each client at a random moment in one second
-				const offset = Math.floor(Math.random() * 1000);
-				setTimeout(() => client.start(), offset);
-			}
-		}
-	}
-
-	getClientCreator() {
-		// TODO: || this.options.url.startsWith('wss:'))
-		if (this.options.url.startsWith('ws:')) {
-			return websocket.create;
-		}
-		return httpClient.create;
+	countClients() {
+		return this.pool.clients.length
 	}
 
 	/**
@@ -149,20 +108,18 @@ class LoadTest {
 	 */
 	stop() {
 		this.running = false;
-		this.latency.finish()
+		this.pool.stop()
+		this.latency.stop()
 		if (this.showTimer) {
 			this.showTimer.stop();
 		}
 		if (this.stopTimeout) {
 			clearTimeout(this.stopTimeout);
 		}
-		Object.keys(this.clients).forEach(index => {
-			this.clients[index].stop();
-		});
 		if (this.finalCallback) {
 			const result = this.latency.getResult();
 			result.instanceIndex = this.instanceIndex;
-			this.finalCallback(null, result);
+			this.finalCallback(result);
 		} else {
 			this.latency.show();
 		}

package/lib/options.js

@@ -17,7 +17,7 @@ class Options {
 	constructor(options) {
 		this.url = this.getUrl(options)
 		const configuration = loadConfig();
-		this.concurrency = options.concurrency || configuration.concurrency || 1
+		this.concurrency = options.concurrency || configuration.concurrency || 10
 		const rps = options.rps ? parseFloat(options.rps) : null
 		this.requestsPerSecond = options.requestsPerSecond || rps || configuration.requestsPerSecond
 		this.agentKeepAlive = options.keepalive || options.agent || options.agentKeepAlive || configuration.agentKeepAlive;
@@ -46,6 +46,10 @@ class Options {
 		this.proxy = options.proxy || configuration.proxy
 		this.quiet = options.quiet || configuration.quiet
 		this.statusCallback = options.statusCallback
+		this.tcp = options.tcp || configuration.tcp
+		if (!this.maxRequests && !this.maxSeconds) {
+			this.maxSeconds = 10
+		}
 	}
 
 	getUrl(options) {

package/lib/parser.js

@@ -0,0 +1,167 @@
+import microprofiler from 'microprofiler'
+
+const bodySeparator = '\r\n\r\n'
+const lineSeparator = '\r\n'
+const packetInfos = new Map()
+// max size to consider packets duplicated
+const maxPacketSize = 1000
+
+
+export class Parser {
+	constructor(method) {
+		this.method = method
+		this.pending = null
+		this.finished = false
+		this.headers = {}
+		this.partialBody = false
+		this.packetInfo = null
+	}
+
+	addPacket(data) {
+		if (this.pending) {
+			this.pending = Buffer.concat([this.pending, data])
+		} else {
+			this.pending = data
+		}
+		if (this.partialBody) {
+			this.parseBody(this.pending, this.packetInfo)
+			return
+		}
+		this.parsePacket()
+	}
+
+	parsePacket() {
+		const division = this.pending.indexOf(bodySeparator)
+		if (division == -1) {
+			// cannot parse yet
+			return
+		}
+		//const start1 = microprofiler.start()
+		this.packetInfo = new PacketInfo(this.pending.length, division)
+		const messageHeader = this.pending.subarray(0, division)
+		const messageBody = this.pending.subarray(division + 4)
+		this.parseFirstLine(messageHeader)
+		//microprofiler.measureFrom(start1, 'parse first line', 100000)
+		//const start2 = microprofiler.start()
+		const key = this.packetInfo.getKey()
+		const existing = packetInfos.get(key)
+		if (existing && this.packetInfo.isDuplicated(existing)) {
+			// no need to parse headers or body
+			this.finished = true
+			return
+		}
+		packetInfos.set(key, this.packetInfo)
+		this.parseHeaders(messageHeader)
+		//microprofiler.measureFrom(start2, 'parse headers', 100000)
+		const start3 = microprofiler.start()
+		this.parseBody(messageBody)
+		microprofiler.measureFrom(start3, 'parse body', 100000)
+	}
+
+	parseFirstLine(messageHeader) {
+		let firstReturn = messageHeader.indexOf(lineSeparator)
+		if (firstReturn == -1) {
+			// no headers
+			firstReturn = messageHeader.length
+		}
+		const firstLine = messageHeader.toString('utf8', 0, firstReturn)
+		this.packetInfo.parseFirstLine(firstLine)
+	}
+
+	parseHeaders(messageHeader) {
+		if (this.packetInfo.hasNoBody(this.method)) {
+			// do not parse headers
+			return
+		}
+		let firstReturn = messageHeader.indexOf(lineSeparator)
+		let position = firstReturn + 2
+		while (position < messageHeader.length) {
+			let nextReturn = messageHeader.indexOf(lineSeparator, position)
+			if (nextReturn == -1) {
+				nextReturn = messageHeader.length
+			}
+			const line = messageHeader.toString('utf8', position, nextReturn)
+			this.parseHeader(line)
+			position = nextReturn + 2
+		}
+	}
+
+	parseBody(messageBody) {
+		if (this.packetInfo.hasNoBody(this.method)) {
+			if (messageBody.length != 0) {
+				throw new Error(`Should not have a body`)
+			}
+			// do not parse body
+			this.finished = true
+			return
+		}
+		if (!this.packetInfo.contentLength) {
+			throw new Error(`Missing content length`)
+		}
+		if (this.packetInfo.contentLength != messageBody.length) {
+			this.partialBody = true
+			this.pending = messageBody
+			return
+		}
+		// we do not actually parse the body, have no use for it
+		this.finished = true
+	}
+
+	parseHeader(line) {
+		const colon = line.indexOf(': ')
+		if (colon == -1) {
+			throw new Error(`Invalid header ${line}`)
+		}
+		const key = line.substring(0, colon).toLowerCase()
+		if (key == 'content-length') {
+			const value = line.substring(colon + 2)
+			this.packetInfo.contentLength = parseInt(value)
+		}
+		// this.headers[key] = value
+	}
+}
+
+class PacketInfo {
+	constructor(length, division) {
+		this.length = length
+		this.division = division
+		this.contentLength = 0
+		this.statusCode = 0
+	}
+
+	getKey() {
+		return `${this.length}-${this.division}`
+	}
+
+	parseFirstLine(firstLine) {
+		const words = firstLine.split(' ')
+		if (words.length < 2) {
+			throw new Error(`Unexpected response line ${firstLine}`)
+		}
+		if (words[0] != 'HTTP/1.1') {
+			throw new Error(`Unexpected first word ${words[0]}`)
+		}
+		this.statusCode = parseInt(words[1])
+		if (!this.statusCode || this.statusCode < 100 || this.statusCode >= 600) {
+			throw new Error(`Unexpected status code ${this.statusCode}`)
+		}
+	}
+
+	hasNoBody(method) {
+		if (method == 'HEAD') {
+			return true
+		}
+		if (this.statusCode < 200 || this.statusCode == 204 || this.statusCode == 304) {
+			return true
+		}
+		return false
+	}
+
+	isDuplicated(info) {
+		if (this.length > maxPacketSize) {
+			return false
+		}
+		return this.length == info.length && this.division == info.division && this.statusCode == info.statusCode
+	}
+}
+