@depup/primus 8.0.9-depup.0

package/transformers/sockjs/server.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const sockjs = require('sockjs');
+const url = require('url');
+
+const PrimusError = require('../../errors').PrimusError;
+
+/**
+ * Minimum viable SockJS server for Node.js that works through the primus
+ * interface.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  let fayeOptions = { maxLength: this.primus.options.maxLength };
+  let prefix = this.primus.pathname;
+
+  if (this.primus.options.compression) {
+    try {
+      fayeOptions.extensions = [ require('permessage-deflate') ];
+    } catch (e) {
+      [
+        '',
+        'Missing required npm dependency for sockjs',
+        'To use the permessage-deflate extension with the sockjs transformer, ',
+        'you have to install an additional dependency.',
+        'Please run the following command and try again:',
+        '',
+        '  npm install --save permessage-deflate',
+        ''
+      ].forEach((line) => console.error(`Primus: ${line}`));
+
+      throw new PrimusError(
+        'Missing dependencies for transformer: "sockjs"',
+        this.primus
+      );
+    }
+  }
+
+  if (prefix.charAt(prefix.length - 1) !== '/') prefix += '(?:[^/]+)?';
+
+  this.service = sockjs.createServer();
+
+  //
+  // We've received a new connection, create a new Spark. The Spark will
+  // automatically announce it self as a new connection once it's created (after
+  // the next tick).
+  //
+  this.service.on('connection', (socket) => {
+    if (!socket) {
+      return;  
+    }
+    const headers = socket.headers.via;
+
+    headers.via = headers._via;
+    socket.headers.via = null;
+
+    const spark = new this.Spark(
+        headers                      // HTTP request headers.
+      , socket                       // IP address location.
+      , url.parse(socket.url).query  // Optional query string.
+      , socket.id                    // Unique connection id.
+      , null                         // We don't have have a HTTP request.
+      , socket                       // Reference to the SockJS socket.
+    );
+
+    spark.on('outgoing::end', () => socket && socket.close());
+    spark.on('outgoing::data', (data) => socket.write(data));
+
+    socket.on('error', spark.emits('incoming::error'));
+    socket.on('data', spark.emits('incoming::data'));
+    socket.on('close', spark.emits('incoming::end', (next) => {
+      socket.removeAllListeners();
+      socket = null;
+      next();
+    }));
+  });
+
+  //
+  // Listen to requests.
+  //
+  const handle = this.service.listener(Object.assign({
+    faye_server_options: fayeOptions
+  }, this.primus.options.transport, {
+    log: this.logger.plain,
+    prefix: prefix
+  })).getHandler();
+
+  //
+  // Here be demons. SockJS has this really horrible "security" feature where it
+  // limits the HTTP headers that you're allowed to see and use in your
+  // applications. I whole heartly disagree with this decision so we're hacking
+  // around this by storing the full header in an accepted header key and re-use
+  // that when we construct a Primus Spark.
+  //
+  this.on('upgrade', (req, socket, head) => {
+    req.headers._via = req.headers.via;
+    req.headers.via = req.headers;
+
+    handle.call(this, req, socket, head);
+  }).on('request', (req, res) => {
+    req.headers._via = req.headers.via;
+    req.headers.via = req.headers;
+
+    handle.call(this, req, res);
+  });
+};

package/transformers/uws/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+//
+// Expose the module as new Transformer instance.
+//
+module.exports = require('../../transformer').extend({
+  // Creating a new real-time server.
+  server: require('./server'),
+
+  // The client-logic to connect with the server.
+  client: require('../websockets/client')
+});

package/transformers/uws/server.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const http = require('http');
+const url = require('url');
+const uws = require('uws');
+
+const native = uws.native;
+
+//
+// uws v0.12.0+ needs a set "no operation" callback.
+//
+if (native.setNoop) native.setNoop(() => {});
+
+/**
+ * Server of µWebSockets transformer.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  const opts = Object.assign({
+    perMessageDeflate: !!this.primus.options.compression,
+    maxPayload: this.primus.options.maxLength
+  }, this.primus.options.transport);
+
+  this.service = native.server;
+
+  let flags = 0;
+
+  if (opts.perMessageDeflate) {
+    flags |= uws.PERMESSAGE_DEFLATE;
+    if (opts.perMessageDeflate.serverNoContextTakeover === false) {
+      flags |= uws.SLIDING_DEFLATE_WINDOW;
+    }
+  }
+
+  const group = native.server.group.create(flags, opts.maxPayload);
+  let upgradeReq = null;
+
+  native.server.group.onConnection(group, (socket) => {
+    const spark = new this.Spark(
+      upgradeReq.headers,               // HTTP request headers.
+      upgradeReq,                       // IP address location.
+      url.parse(upgradeReq.url).query,  // Optional query string.
+      null,                             // We don't have an unique id.
+      upgradeReq,                       // Reference to the HTTP req.
+      socket                            // Reference to the socket.
+    );
+
+    native.setUserData(socket, spark);
+
+    spark.ultron.on('outgoing::end', () => native.server.close(socket));
+    spark.on('outgoing::data', (data) => {
+      const opcode = Buffer.isBuffer(data)
+        ? uws.OPCODE_BINARY
+        : uws.OPCODE_TEXT;
+
+      native.server.send(socket, data, opcode, undefined, true);
+    });
+  });
+
+  native.server.group.onDisconnection(group, (socket, code, msg, spark) => {
+    native.clearUserData(socket);
+    spark.ultron.remove('outgoing::end');
+    spark.emit('incoming::end');
+  });
+
+  native.server.group.onMessage(group, (msg, spark) => {
+    //
+    // Binary data is passed zero-copy as an `ArrayBuffer` so we first have to
+    // convert it to a `Buffer` and then copy it to a new `Buffer`.
+    //
+    if ('string' !== typeof msg) msg = Buffer.from(Buffer.from(msg));
+
+    spark.emit('incoming::data', msg);
+  });
+
+  native.server.group.onPing(group, (msg, spark) => spark.emit('incoming::pong'));
+
+  //
+  // Listen to upgrade requests.
+  //
+  this.on('upgrade', (req, soc) => {
+    const secKey = req.headers['sec-websocket-key'];
+
+    if (soc.readable && soc.writable && secKey && secKey.length === 24) {
+      soc.setNoDelay(opts.noDelay);
+
+      let socketHandle = soc._handle;
+      let sslState = null;
+
+      if (soc.ssl) {
+        socketHandle = soc._parent._handle;
+        sslState = soc.ssl._external;
+      }
+
+      const ticket = native.transfer(
+        socketHandle.fd === -1 ? socketHandle : socketHandle.fd,
+        sslState
+      );
+
+      soc.on('close', () => {
+        upgradeReq = req;
+        native.upgrade(
+          group,
+          ticket,
+          secKey,
+          req.headers['sec-websocket-extensions']
+        );
+
+        //
+        // Delete references to destroyed socket.
+        //
+        req.client = req.connection = req.socket = null;
+        upgradeReq = null;
+      });
+    }
+
+    soc.destroy();
+  });
+
+  //
+  // Listen to non-upgrade requests.
+  //
+  this.on('request', (req, res) => {
+    res.writeHead(426, { 'content-type': 'text/plain' });
+    res.end(http.STATUS_CODES[426]);
+  });
+
+  this.once('close', () => native.server.group.close(group));
+};

package/transformers/websockets/client.js

@@ -0,0 +1,112 @@
+'use strict';
+/*globals MozWebSocket */
+
+/**
+ * Minimum viable WebSocket client. This function is stringified and added
+ * in our client-side library.
+ *
+ * @runat client
+ * @api private
+ */
+module.exports = function client() {
+  var primus = this
+    , socket;
+
+  //
+  // Select an available WebSocket factory.
+  //
+  var Factory = (function factory() {
+    if ('undefined' !== typeof WebSocket) return WebSocket;
+    if ('undefined' !== typeof MozWebSocket) return MozWebSocket;
+
+    try { return Primus.requires('ws'); }
+    catch (e) {}
+
+    return undefined;
+  })();
+
+  if (!Factory) return primus.critical(new Error(
+    'Missing required `ws` module. Please run `npm install --save ws`'
+  ));
+
+  //
+  // Connect to the given URL.
+  //
+  primus.on('outgoing::open', function opening() {
+    primus.emit('outgoing::end');
+
+    //
+    // FireFox will throw an error when we try to establish a connection from
+    // a secure page to an unsecured WebSocket connection. This is inconsistent
+    // behaviour between different browsers. This should ideally be solved in
+    // Primus when we connect.
+    //
+    try {
+      var options = {
+        protocol: primus.url.protocol === 'ws+unix:' ? 'ws+unix:' : 'ws:',
+        query: true
+      };
+
+      //
+      // Only allow primus.transport object in Node.js, it will throw in
+      // browsers with a TypeError if we supply to much arguments.
+      //
+      if (Factory.length === 3) {
+        if ('ws+unix:' === options.protocol) {
+          options.pathname =
+            '/' +
+            primus.url.hostname +
+            primus.url.pathname +
+            ':' +
+            primus.pathname;
+        }
+        primus.socket = socket = new Factory(
+          primus.uri(options),  // URL
+          [],                   // Sub protocols
+          primus.transport      // options.
+        );
+      } else {
+        primus.socket = socket = new Factory(primus.uri(options));
+        socket.binaryType = 'arraybuffer';
+      }
+    } catch (e) { return primus.emit('error', e); }
+
+    //
+    // Setup the Event handlers.
+    //
+    socket.onopen = primus.emits('incoming::open');
+    socket.onerror = primus.emits('incoming::error');
+    socket.onclose = primus.emits('incoming::end');
+    socket.onmessage = primus.emits('incoming::data', function parse(next, evt) {
+      next(undefined, evt.data);
+    });
+  });
+
+  //
+  // We need to write a new message to the socket.
+  //
+  primus.on('outgoing::data', function write(message) {
+    if (!socket || socket.readyState !== Factory.OPEN) return;
+
+    try { socket.send(message); }
+    catch (e) { primus.emit('incoming::error', e); }
+  });
+
+  //
+  // Attempt to reconnect the socket.
+  //
+  primus.on('outgoing::reconnect', function reconnect() {
+    primus.emit('outgoing::open');
+  });
+
+  //
+  // We need to close the socket.
+  //
+  primus.on('outgoing::end', function close() {
+    if (!socket) return;
+
+    socket.onerror = socket.onopen = socket.onclose = socket.onmessage = function () {};
+    socket.close();
+    socket = null;
+  });
+};

package/transformers/websockets/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+//
+// Expose the module as new Transformer instance.
+//
+module.exports = require('../../transformer').extend({
+  // Creating a new real-time server.
+  server: require('./server'),
+
+  // The client-logic to connect with the server.
+  client: require('./client')
+});

package/transformers/websockets/server.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const http = require('http');
+const url = require('url');
+const ws = require('ws');
+
+/**
+ * Minimum viable WebSocket server for Node.js that works through the Primus
+ * interface.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  this.service = new ws.Server(Object.assign({
+    perMessageDeflate: !!this.primus.options.compression,
+    maxPayload: this.primus.options.maxLength
+  }, this.primus.options.transport, {
+    clientTracking: false,
+    noServer: true
+  }));
+
+  /**
+   * Noop! Pointless, empty function that will actually be really useful.
+   *
+   * @param {Error} err We failed at something.
+   * @api private
+   */
+  const noop = (err) => err && this.logger.error(err);
+
+  //
+  // Listen to upgrade requests.
+  //
+  this.on('upgrade', (req, socket, head) => {
+    this.service.handleUpgrade(req, socket, head, (socket) => {
+      const spark = new this.Spark(
+          req.headers               // HTTP request headers.
+        , req                       // IP address location.
+        , url.parse(req.url).query  // Optional query string.
+        , null                      // We don't have an unique id.
+        , req                       // Reference to the HTTP req.
+        , socket                    // Reference to the WebSocket.
+      );
+
+      spark.on('outgoing::end', () => socket && socket.close());
+      spark.on('outgoing::data', (data) => {
+        if (socket.readyState !== socket.OPEN) return;
+        socket.send(data, noop);
+      });
+
+      socket.on('message',
+        spark.emits('incoming::data', (next, data, isBinary) => {
+          next(undefined, isBinary === false ? data.toString() : data);
+        })
+      );
+      socket.on('error', spark.emits('incoming::error'));
+      socket.on('ping', spark.emits('incoming::pong', (next) => {
+        next(undefined, null);
+      }));
+      socket.on('close', spark.emits('incoming::end', (next) => {
+        socket.removeAllListeners();
+        socket = null;
+        next();
+      }));
+    });
+  });
+
+  //
+  // Listen to non-upgrade requests.
+  //
+  this.on('request', (req, res) => {
+    res.writeHead(426, { 'content-type': 'text/plain' });
+    res.end(http.STATUS_CODES[426]);
+  });
+
+  this.once('close',  () => this.service.close());
+};

package/transformers.json

@@ -0,0 +1,26 @@
+{
+  "websockets": {
+    "server": "ws",
+    "client": "ws"
+  },
+  "engine.io": {
+    "server": "engine.io",
+    "client": "engine.io-client"
+  },
+  "browserchannel": {
+    "server": "browserchannel",
+    "client": "browserchannel"
+  },
+  "sockjs": {
+    "server": "sockjs",
+    "client": "sockjs-client"
+  },
+  "faye": {
+    "server": "faye-websocket",
+    "client": "faye-websocket"
+  },
+  "uws": {
+    "server": "uws",
+    "client": "ws"
+  }
+}