uwebsockets 2.2.2 → 3.0.0

package/tests/Hammer.js

@@ -7,9 +7,9 @@
 /* Run with AddressSanitizer enabled for best effect. */
 
 /* We use websockets/ws as client counterpart */
-const WebSocket = require('ws');
+const WebSocket = require("ws");
 
-const uWS = require('../dist/uws.js');
+const uWS = require("../dist/uws.js");
 const port = 9001;
 
 let openedClientConnections = 0;
@@ -22,182 +22,185 @@ const maxPayloadSize = 5 * 1024 * 1024;
 const largeBuffer = new ArrayBuffer(maxPayloadSize);
 
 function printStatistics() {
-    console.log('Opened clients ' + openedClientConnections);
-    console.log('Closed clients ' + closedClientConnections + '\n');
+  console.log("Opened clients " + openedClientConnections);
+  console.log("Closed clients " + closedClientConnections + "\n");
 }
 
 /* 0 to 1-less than max */
 function getRandomInt(max) {
-    return Math.floor(Math.random() * Math.floor(max));
+  return Math.floor(Math.random() * Math.floor(max));
 }
 
 /* This gets called every time we either open a new connection,
  * or it immediately land in websockets/ws error handler */
 function accountForConnection() {
-    /* Open more connections */
-    if (++openedClientConnections < /*100*/ 1000) {
-        establishNewConnection();
-    } else {
-        /* Stop listening */
-        uWS.us_listen_socket_close(listenSocket);
-    }
+  /* Open more connections */
+  if (++openedClientConnections < /*100*/ 1000) {
+    establishNewConnection();
+  } else {
+    /* Stop listening */
+    uWS.us_listen_socket_close(listenSocket);
+  }
 }
 
 function establishNewConnection() {
-    const ws = new WebSocket('ws://localhost:' + port);
-
-    ws.on('open', () => {
-        /* Mark this socket as opened */
-        ws._opened = true;
-        accountForConnection();
-
-        printStatistics();
-        performRandomClientAction(ws);
-    });
-
-    /* It seems you can get messages after close?! */
-    ws.on('message', (data) => {
-        performRandomClientAction(ws);
-    });
-
-    /* Close can be called more times than open, websockets/ws is really messy! */
-    ws.on('close', () => {
-        /* Check if this websocket really was opened first */
-        if (!ws._opened) {
-            accountForConnection();
-        }
-
-        closedClientConnections++;
-        printStatistics();
-        /* I guess there is no need for us to call anything
-         * here, websockets/ws will not send anything to us anyways */
-        //performRandomClientAction(ws);
-    });
-
-    ws.on('error', () => {
-        /* We simply ignore errors. websockets/ws will call our close handler
-         * on errors, potentially before even calling the open handler */
-    });
+  const ws = new WebSocket("ws://localhost:" + port);
+
+  ws.on("open", () => {
+    /* Mark this socket as opened */
+    ws._opened = true;
+    accountForConnection();
+
+    printStatistics();
+    performRandomClientAction(ws);
+  });
+
+  /* It seems you can get messages after close?! */
+  ws.on("message", (data) => {
+    performRandomClientAction(ws);
+  });
+
+  /* Close can be called more times than open, websockets/ws is really messy! */
+  ws.on("close", () => {
+    /* Check if this websocket really was opened first */
+    if (!ws._opened) {
+      accountForConnection();
+    }
+
+    closedClientConnections++;
+    printStatistics();
+    /* I guess there is no need for us to call anything
+     * here, websockets/ws will not send anything to us anyways */
+    //performRandomClientAction(ws);
+  });
+
+  ws.on("error", () => {
+    /* We simply ignore errors. websockets/ws will call our close handler
+     * on errors, potentially before even calling the open handler */
+  });
 }
 
 /* Perform random websockets/ws action */
 function performRandomClientAction(ws) {
-    /* 0, 1, 2 but never 3 */
-    let action = getRandomInt(3);
+  /* 0, 1, 2 but never 3 */
+  let action = getRandomInt(3);
 
-    /* Sending a message should have higher probability */
-    if (getRandomInt(100) < 80) {
-        action = 1;
-    }
+  /* Sending a message should have higher probability */
+  if (getRandomInt(100) < 80) {
+    action = 1;
+  }
 
-    switch (action) {
-        case 0: {
-            ws.close();
-            break;
-        }
-        case 1: {
-            /* Length should be random from small to huge */
-            try {
-                ws.send('a test message');
-            } catch (e) {
-                /* Apparently websockets/ws can throw at any moment */
-
-            }
-            break;
-        }
-        case 2: {
-            ws.terminate();
-            break;
-        }
+  switch (action) {
+    case 0: {
+      ws.close();
+      break;
+    }
+    case 1: {
+      /* Length should be random from small to huge */
+      try {
+        ws.send("a test message");
+      } catch (e) {
+        /* Apparently websockets/ws can throw at any moment */
+      }
+      break;
     }
+    case 2: {
+      ws.terminate();
+      break;
+    }
+  }
 }
 
-/* Perform random uWebSockets.js action */
+/* Perform random uwebsockets action */
 function performRandomServerAction(ws, uniform) {
-    /* 0, 1, 2 but never 3 */
-    let action = getRandomInt(3);
-
-    /* Sending a message should have higher probability,
-     * except for when we are draining. */
-    if (!uniform) {
-        if (getRandomInt(100) < 80) {
-            action = 1;
-        }
+  /* 0, 1, 2 but never 3 */
+  let action = getRandomInt(3);
+
+  /* Sending a message should have higher probability,
+   * except for when we are draining. */
+  if (!uniform) {
+    if (getRandomInt(100) < 80) {
+      action = 1;
     }
+  }
 
-    switch (action) {
-        case 0: {
-            ws.end();
-            break;
-        }
-        case 1: {
-            /* If we have very high backpressure we skip sending more */
-            if (ws.getBufferedAmount() > maxBackpressure) {
-                /* Do something else instead */
-                performRandomServerAction(ws);
-            } else {
-                /* Length should be random from small to huge, ArrayBuffer.slice is a copy (bad but we don't care I guess) */
-                ws.send(largeBuffer.slice(0, getRandomInt(maxPayloadSize + 1)));
-            }
-            break;
-        }
-        case 2: {
-            ws.close();
-            break;
-        }
+  switch (action) {
+    case 0: {
+      ws.end();
+      break;
+    }
+    case 1: {
+      /* If we have very high backpressure we skip sending more */
+      if (ws.getBufferedAmount() > maxBackpressure) {
+        /* Do something else instead */
+        performRandomServerAction(ws);
+      } else {
+        /* Length should be random from small to huge, ArrayBuffer.slice is a copy (bad but we don't care I guess) */
+        ws.send(largeBuffer.slice(0, getRandomInt(maxPayloadSize + 1)));
+      }
+      break;
     }
+    case 2: {
+      ws.close();
+      break;
+    }
+  }
 }
 
-const app = uWS./*SSL*/App({
-  key_file_name: 'misc/key.pem',
-  cert_file_name: 'misc/cert.pem',
-  passphrase: '1234'
-}).ws('/*', {
-  compression: 0,
-  /* We intentionally accept less than what might be sent so to test force closing */
-  maxPayloadLength: maxPayloadSize / 2,
-  idleTimeout: 100,
-
-  open: (ws, req) => {
-    /* Doing a terminate here will be interesting */
-    performRandomServerAction(ws, false);
-  },
-  message: (ws, message, isBinary) => {
-    performRandomServerAction(ws, false);
-  },
-  drain: (ws) => {
-    /* We only perform actions while draining rarely (5%), and we do it uniformly.
-     * There's no real NEED to do anything here, as it will eventually result in
-     * message event for client. */
-    if (getRandomInt(100) < 5) {
+const app = uWS
+  ./*SSL*/ App({
+    key_file_name: "misc/key.pem",
+    cert_file_name: "misc/cert.pem",
+    passphrase: "1234",
+  })
+  .ws("/*", {
+    compression: 0,
+    /* We intentionally accept less than what might be sent so to test force closing */
+    maxPayloadLength: maxPayloadSize / 2,
+    idleTimeout: 100,
+
+    open: (ws, req) => {
+      /* Doing a terminate here will be interesting */
+      performRandomServerAction(ws, false);
+    },
+    message: (ws, message, isBinary) => {
+      performRandomServerAction(ws, false);
+    },
+    drain: (ws) => {
+      /* We only perform actions while draining rarely (5%), and we do it uniformly.
+       * There's no real NEED to do anything here, as it will eventually result in
+       * message event for client. */
+      if (getRandomInt(100) < 5) {
         performRandomServerAction(ws, true);
-    }
-  },
-  close: (ws, code, message) => {
-    /* TODO: We SHOULD TECHNICALLY allow sending here.
-     * It should not throw, but just silently ignore it
-     * as it makes no sense to send on a closed socket
-     * while still being technically valid */
-    try {
+      }
+    },
+    close: (ws, code, message) => {
+      /* TODO: We SHOULD TECHNICALLY allow sending here.
+       * It should not throw, but just silently ignore it
+       * as it makes no sense to send on a closed socket
+       * while still being technically valid */
+      try {
         performRandomServerAction(ws, false);
-    } catch (e) {
+      } catch (e) {
         /* We expect to land here always, since socket is invalid */
         return;
+      }
+      /* We should never land here */
+      uWS.print("ERROR: Did not throw in close!");
+      process.exit(-1);
+    },
+  })
+  .any("/*", (res, req) => {
+    res.end("Nothing to see here!");
+  })
+  .listen(port, (token) => {
+    if (token) {
+      console.log("Hammering on port " + port);
+
+      /* Establish first connection */
+      establishNewConnection();
+
+      /* Use this to stop listening when done */
+      listenSocket = token;
     }
-    /* We should never land here */
-    uWS.print('ERROR: Did not throw in close!');
-    process.exit(-1);
-  }
-}).any('/*', (res, req) => {
-  res.end('Nothing to see here!');
-}).listen(port, (token) => {
-  if (token) {
-    console.log('Hammering on port ' + port);
-
-    /* Establish first connection */
-    establishNewConnection();
-
-    /* Use this to stop listening when done */
-    listenSocket = token;
-  }
-});
+  });

package/tests/fuzzingclient.json

@@ -1,28 +1,28 @@
 {
-   "outdir": "./reports/servers",
-   "servers": [
-      {
-         "url": "ws://localhost:9001",
-         "agent": "uWebSockets.js non-SSL, non-compression"
-      },
-      {
-         "url": "wss://localhost:9002",
-         "agent": "uWebSockets.js SSL, shared compressor"
-      },
-      {
-         "url": "ws://localhost:9003",
-         "agent": "uWebSockets.js non-SSL, dedicated compressor"
-      },
-      {
-         "url": "ws://localhost:9004",
-         "agent": "uWebSockets.js non-SSL, non-compression, pubsub based"
-      },
-      {
-         "url": "wss://localhost:9005",
-         "agent": "uWebSockets.js SSL, non-compression, pubsub based"
-      }
-   ],
-   "cases": ["*.*"],
-   "exclude-cases": [],
-   "exclude-agent-cases": {}
+  "outdir": "./reports/servers",
+  "servers": [
+    {
+      "url": "ws://localhost:9001",
+      "agent": "uwebsockets non-SSL, non-compression"
+    },
+    {
+      "url": "wss://localhost:9002",
+      "agent": "uwebsockets SSL, shared compressor"
+    },
+    {
+      "url": "ws://localhost:9003",
+      "agent": "uwebsockets non-SSL, dedicated compressor"
+    },
+    {
+      "url": "ws://localhost:9004",
+      "agent": "uwebsockets non-SSL, non-compression, pubsub based"
+    },
+    {
+      "url": "wss://localhost:9005",
+      "agent": "uwebsockets SSL, non-compression, pubsub based"
+    }
+  ],
+  "cases": ["*.*"],
+  "exclude-cases": [],
+  "exclude-agent-cases": {}
 }

package/uws.js

@@ -1,5 +1,5 @@
 /*
- * Authored by Alex Hultman, 2018-2021.
+ * Authored by Alex Hultman, 2018-2022.
  * Intellectual property of third-party.
 
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,6 +19,6 @@ module.exports = (() => {
 	try {
 		return require('./uws_' + process.platform + '_' + process.arch + '_' + process.versions.modules + '.node');
 	} catch (e) {
-		throw new Error('This version of µWS is not compatible with your Node.js build:\n\n' + e.toString());
+		throw new Error('This version of uWS.js supports only Node.js LTS versions 16, 18 and 20 on (glibc) Linux, macOS and Windows, on Tier 1 platforms (https://github.com/nodejs/node/blob/master/BUILDING.md#platform-list).\n\n' + e.toString());
 	}
 })();