uwebsockets 1.0.0

package/examples/Headers.js

@@ -0,0 +1,31 @@
+/* Example of looping over all headers (not recommended as production solution,
+ * do NOT use this to "solve" your problems with headers, use ONLY for debugging) */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).get('/*', (res, req) => {
+
+  res.write('<h2>Hello, your headers are:</h2><ul>');
+
+  req.forEach((k, v) => {
+    res.write('<li>');
+    res.write(k);
+    res.write(' = ');
+    res.write(v);
+    res.write('</li>');
+  });
+
+  res.end('</ul>');
+
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/HelloWorld.js

@@ -0,0 +1,18 @@
+/* Minimal SSL/non-SSL example */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).get('/*', (res, req) => {
+  res.end('Hello World!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/JsonPost.js

@@ -0,0 +1,72 @@
+/* Simple example of getting JSON from a POST */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).post('/*', (res, req) => {
+
+  /* Note that you cannot read from req after returning from here */
+  let url = req.getUrl();
+
+  /* Read the body until done or error */
+  readJson(res, (obj) => {
+    console.log('Posted to ' + url + ': ');
+    console.log(obj);
+
+    res.end('Thanks for this json!');
+  }, () => {
+    /* Request was prematurely aborted or invalid or missing, stop reading */
+    console.log('Invalid JSON or no data at all!');
+  });
+
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});
+
+/* Helper function for reading a posted JSON body */
+function readJson(res, cb, err) {
+  let buffer;
+  /* Register data cb */
+  res.onData((ab, isLast) => {
+    let chunk = Buffer.from(ab);
+    if (isLast) {
+      let json;
+      if (buffer) {
+        try {
+          json = JSON.parse(Buffer.concat([buffer, chunk]));
+        } catch (e) {
+          /* res.close calls onAborted */
+          res.close();
+          return;
+        }
+        cb(json);
+      } else {
+        try {
+          json = JSON.parse(chunk);
+        } catch (e) {
+          /* res.close calls onAborted */
+          res.close();
+          return;
+        }
+        cb(json);
+      }
+    } else {
+      if (buffer) {
+        buffer = Buffer.concat([buffer, chunk]);
+      } else {
+        buffer = Buffer.concat([chunk]);
+      }
+    }
+  });
+
+  /* Register error cb */
+  res.onAborted(err);
+}

package/examples/ProxyProtocol.js

@@ -0,0 +1,25 @@
+/* Minimal SSL/non-SSL example using PROXY Protocol v2 */
+
+const uWS = require('../dist/uws.js');
+const port = 3000;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).get('/*', (res, req) => {
+  /* Respond with their addresses */
+  res.cork(() => {
+    res.write('<html><h1>');
+    res.write('Your proxied IP is: ' + Buffer.from(res.getProxiedRemoteAddressAsText()).toString());
+    res.write('</h1><h1>');
+    res.write('Your IP as seen by the origin server is: ' + Buffer.from(res.getRemoteAddressAsText()).toString());
+    res.end('</h1></html>');
+  });
+}).listen(port, (listenSocket) => {
+  if (listenSocket) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/PubSub.js

@@ -0,0 +1,57 @@
+/* Simple pub/sub example (WIP) */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).ws('/*', {
+  /* Options */
+  compression: uWS.SHARED_COMPRESSOR,
+  maxPayloadLength: 16 * 1024 * 1024,
+  idleTimeout: 10,
+  maxBackpressure: 1024,
+
+  /* Todo, Setting 1: merge messages in one, or keep them as separate WebSocket frames - mergePublishedMessages */
+  /* Todo, Setting 4: send to all including us, or not? That's not a setting really just use ws.publish or global uWS.publish */
+
+  /* Handlers */
+  open: (ws) => {
+    /* Let this client listen to all sensor topics */
+    ws.subscribe('home/sensors/#');
+  },
+  message: (ws, message, isBinary) => {
+    /* Parse this message according to some application
+     * protocol such as JSON [action, topic, message] */
+
+    /* Let's pretend this was a temperature message
+     * [pub, home/sensors/temperature, message] */
+    ws.publish('home/sensors/temperature', message);
+
+    /* Let's also pretend this was a light message
+     * [pub, home/sensors/light, message] */
+    ws.publish('home/sensors/light', message);
+
+    /* If you have good imagination you can also
+     * pretend some message was a subscription
+     * like so: [sub, /home/sensors/humidity].
+     * I hope you get how any application protocol
+     * can be implemented with these helpers. */
+  },
+  drain: (ws) => {
+
+  },
+  close: (ws, code, message) => {
+    /* The library guarantees proper unsubscription at close */
+  }
+}).any('/*', (res, req) => {
+  res.end('Nothing to see here!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/RateLimit.js

@@ -0,0 +1,69 @@
+/* RateLimit example */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const RateLimit = (limit, interval) => { let now = 0; const last = Symbol(), count = Symbol(); setInterval(() => ++now, interval); return ws => { if (ws[last] != now) { ws[last] = now; ws[count] = 1 } else { return ++ws[count] > limit } } }
+const rateLimit = RateLimit(1, 10000) //  limit is: 1 message per 10 seconds.
+const rateLimit2 = RateLimit(10, 2000) // limit per interval (milliseconds)
+
+
+const app = uWS./*SSL*/App({
+    key_file_name: 'misc/key.pem',
+    cert_file_name: 'misc/cert.pem',
+    passphrase: '1234'
+}).ws('/*', {
+    /* Options */
+    compression: uWS.SHARED_COMPRESSOR,
+    maxPayloadLength: 16 * 1024 * 1024,
+    idleTimeout: 10,
+    /* Handlers */
+    open: (ws) => {
+        console.log('A WebSocket connected!');
+    },
+    message: async (ws, message, isBinary) => {
+
+        // rateLimit(ws) returns true if over limit
+        if (rateLimit(ws)) {
+            /*
+                Do as you wish, personally, I prefer to inform the client, do Log,
+                 and close the connection if over limit happened.
+                or you can just ignore its message and just return. 
+            */
+            const dataToSendToClient = {
+                action: 'info',
+                data: {
+                    message: {
+                        english: 'over limit! please slow down.',
+                        farsi: 'یواش‌تر'
+                    }
+                }
+            }
+            await ws.send(JSON.stringify(dataToSendToClient));
+            console.warn('rate limit hit!');
+            return ws.end();
+        }
+
+        //or maybe different type of message or /endpoint needs different limit
+        if (ws.type2 && rateLimit2(ws)) {
+            console.warn('type2 is over limit');
+            return ws.end();
+        }
+
+        // rest of message code goes here ...
+    },
+    drain: (ws) => {
+        console.log('WebSocket backpressure: ' + ws.getBufferedAmount());
+    },
+    close: (ws, code, message) => {
+        console.log('WebSocket closed');
+    }
+}).any('/*', (res, req) => {
+    res.end('Nothing to see here!');
+}).listen(port, (token) => {
+    if (token) {
+        console.log('Listening to port ' + port);
+    } else {
+        console.log('Failed to listen to port ' + port);
+    }
+});

package/examples/Router.js

@@ -0,0 +1,30 @@
+/* Simple demonstration of some router features */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).any('/anything', (res, req) => {
+  res.end('Any route with method: ' + req.getMethod());
+}).get('/user/agent', (res, req) => {
+  /* Read headers */
+  res.end('Your user agent is: ' + req.getHeader('user-agent') + ' thank you, come again!');
+}).get('/static/yes', (res, req) => {
+  /* Static match */
+  res.end('This is very static');
+}).get('/candy/:kind', (res, req) => {
+  /* Parameters */
+  res.end('So you want candy? Have some ' + req.getParameter(0) + '!');
+}).get('/*', (res, req) => {
+  /* Wildcards - make sure to catch them last */
+  res.end('Nothing to see here!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/ServerName.js

@@ -0,0 +1,34 @@
+/* Minimal SSL example using ServerNameIndication */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS.SSLApp({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).missingServerName((hostname) => {
+
+  /* Note: You don't have to use this callback but can pre-load
+   * relevant server names up front. This callback is not "async",
+   * you either add the server name HERE IMMEDIATELY, or the hangshake
+   * will continue with default certificate (which will most likely fail) */
+
+  console.log("Hello! We are missing server name <" + hostname + ">");
+
+  /* We simply assume it is localhost, so adding it here */
+  app.addServerName("localhost", {
+    key_file_name: 'misc/key.pem',
+    cert_file_name: 'misc/cert.pem',
+    passphrase: '1234'
+  });
+
+}).get('/*', (res, req) => {
+  res.end('Hello World!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/ServerSentEvents.js

@@ -0,0 +1,48 @@
+/* Server-sent events (EventSource) example */
+/* curl -n localhost:9001 # check events by using curl */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const headers = [
+  ['Content-Type', 'text/event-stream'],
+  ['Connection', 'keep-alive'],
+  ['Cache-Control', 'no-cache']
+]
+
+function sendHeaders(res) {
+  for (const [header, value] of headers) {
+    res.writeHeader(header, value)
+  }
+}
+
+function serializeData(data) {
+  return `data: ${JSON.stringify(data)}\n\n`
+}
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).get('/*', (res) => {
+  const clientId = Date.now()
+  console.log(`Client with id: ${clientId} connected, starting streaming`)
+  sendHeaders(res);
+  res.writeStatus('200 OK')
+
+  let intervalRef = setInterval(() => {
+    res.write(serializeData({ message: 'Hello world!' }))
+  }, 1000)
+
+  res.onAborted(() => {
+    clearInterval(intervalRef)
+    intervalRef = undefined
+    console.log(`Client with id: ${clientId} disconnected`)
+  })
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/SlowReceiver.js

@@ -0,0 +1,53 @@
+
+
+const uWS = require('uWebSockets.js');
+const port = 9001;
+
+const wsc = require('ws');
+
+const app = uWS.App().ws('/*', {
+  /* Options */
+  maxPayloadLength: 16 * 1024 * 1024,
+  idleTimeout: 10,
+  maxBackpressure: 1024,
+  closeOnBackpressureLimit: true, /* Enable or disable as needed */
+
+  /* Handlers */
+  open: (ws) => {
+    console.log("Client connected");
+    ws.subscribe('clock_feed');
+
+    /* Disable closeOnBackpressureLimit and see this lie around 1024 */
+    ws.clock = setInterval(() => {
+      console.log("Connected socket has " + ws.getBufferedAmount() + " bytes buffered");
+    }, 1000);
+  },
+  close: (ws, code, message) => {
+    clearInterval(ws.clock);
+    console.log("Client disconnected: " + code + ", " + message);
+    /* The library guarantees proper unsubscription at close */
+  }
+}).listen(port, (listenSocket) => {
+  if (listenSocket) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});
+
+/* Publish the time as fast as possible in a loop */
+function sendTime() {
+  app.publish("clock_feed", Date.now().toString());
+  setImmediate(sendTime);
+}
+sendTime();
+
+/* Make a connection to the server */
+const ws = new wsc.WebSocket('ws://localhost:9001');
+ws.on('message', function message(data) {
+  console.log('received: %s', data);
+
+  /* If we pause receive, we will become slow receiver */
+  console.log("Will become slow receiver");
+  ws._socket.pause();
+});

package/examples/Upgrade.js

@@ -0,0 +1,51 @@
+/* A quite detailed WebSockets example */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).ws('/*', {
+  /* Options */
+  compression: uWS.SHARED_COMPRESSOR,
+  maxPayloadLength: 16 * 1024 * 1024,
+  idleTimeout: 10,
+  /* Handlers */
+  upgrade: (res, req, context) => {
+    console.log('An Http connection wants to become WebSocket, URL: ' + req.getUrl() + '!');
+
+    /* This immediately calls open handler, you must not use res after this call */
+    res.upgrade({
+        myData: req.getUrl() /* First argument is UserData (see WebSocket.getUserData()) */
+      },
+      /* Spell these correctly */
+      req.getHeader('sec-websocket-key'),
+      req.getHeader('sec-websocket-protocol'),
+      req.getHeader('sec-websocket-extensions'),
+      context);
+
+  },
+  open: (ws) => {
+    console.log('A WebSocket connected with URL: ' + ws.myData);
+  },
+  message: (ws, message, isBinary) => {
+    /* Ok is false if backpressure was built up, wait for drain */
+    let ok = ws.send(message, isBinary);
+  },
+  drain: (ws) => {
+    console.log('WebSocket backpressure: ' + ws.getBufferedAmount());
+  },
+  close: (ws, code, message) => {
+    console.log('WebSocket closed');
+  }
+}).any('/*', (res, req) => {
+  res.end('Nothing to see here!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/UpgradeAsync.js

@@ -0,0 +1,80 @@
+/* A quite detailed WebSockets upgrade example "async" */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).ws('/*', {
+  /* Options */
+  compression: uWS.SHARED_COMPRESSOR,
+  maxPayloadLength: 16 * 1024 * 1024,
+  idleTimeout: 10,
+  /* Handlers */
+  upgrade: (res, req, context) => {
+    console.log('An Http connection wants to become WebSocket, URL: ' + req.getUrl() + '!');
+
+    /* Keep track of abortions */
+    const upgradeAborted = {aborted: false};
+
+    /* You MUST copy data out of req here, as req is only valid within this immediate callback */
+    const url = req.getUrl();
+    const secWebSocketKey = req.getHeader('sec-websocket-key');
+    const secWebSocketProtocol = req.getHeader('sec-websocket-protocol');
+    const secWebSocketExtensions = req.getHeader('sec-websocket-extensions');
+
+    /* Simulate doing "async" work before upgrading */
+    setTimeout(() => {
+      console.log("We are now done with our async task, let's upgrade the WebSocket!");
+
+      if (upgradeAborted.aborted) {
+        console.log("Ouch! Client disconnected before we could upgrade it!");
+        /* You must not upgrade now */
+        return;
+      }
+
+      /* Cork any async response including upgrade */
+      res.cork(() => {
+        /* This immediately calls open handler, you must not use res after this call */
+        res.upgrade(
+          { url: url },
+          /* Use our copies here */
+          secWebSocketKey,
+          secWebSocketProtocol,
+          secWebSocketExtensions,
+          context
+        );
+      });
+      
+    }, 1000);
+
+    /* You MUST register an abort handler to know if the upgrade was aborted by peer */
+    res.onAborted(() => {
+      /* We can simply signal that we were aborted */
+      upgradeAborted.aborted = true;
+    });
+  },
+  open: (ws) => {
+    console.log('A WebSocket connected with URL: ' + ws.url);
+  },
+  message: (ws, message, isBinary) => {
+    /* Ok is false if backpressure was built up, wait for drain */
+    let ok = ws.send(message, isBinary);
+  },
+  drain: (ws) => {
+    console.log('WebSocket backpressure: ' + ws.getBufferedAmount());
+  },
+  close: (ws, code, message) => {
+    console.log('WebSocket closed');
+  }
+}).any('/*', (res, req) => {
+  res.end('Nothing to see here!');
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});

package/examples/Upload.js

@@ -0,0 +1,36 @@
+/* Minimal POST example a SSL/non-SSL */
+/* todo: proper throttling, better example */
+
+/* a good example would be using the router to get
+ * a file name and stream that file to disk */
+
+const uWS = require('../dist/uws.js');
+const port = 9001;
+
+const app = uWS./*SSL*/App({
+  key_file_name: 'misc/key.pem',
+  cert_file_name: 'misc/cert.pem',
+  passphrase: '1234'
+}).post('/*', (res, req) => {
+  console.log('Posted to ' + req.getUrl());
+  res.onData((chunk, isLast) => {
+    /* Buffer this anywhere you want to */
+    console.log('Got chunk of data with length ' + chunk.byteLength + ', isLast: ' + isLast);
+
+    /* We respond when we are done */
+    if (isLast) {
+      res.end('Thanks for the data!');
+    }
+  });
+
+  res.onAborted(() => {
+    /* Request was prematurely aborted, stop reading */
+    console.log('Eh, okay. Thanks for nothing!');
+  });
+}).listen(port, (token) => {
+  if (token) {
+    console.log('Listening to port ' + port);
+  } else {
+    console.log('Failed to listen to port ' + port);
+  }
+});