@depup/primus 8.0.9-depup.0

package/transformers/engine.io/server.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const engine = require('engine.io');
+
+/**
+ * Minimum viable Engine.IO server for Node.js that works through the primus
+ * interface.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  this.service = new engine.Server(Object.assign({
+    perMessageDeflate: !!this.primus.options.compression,
+    httpCompression: !!this.primus.options.compression,
+    maxHttpBufferSize: this.primus.options.maxLength
+  }, this.primus.options.transport));
+
+  //
+  // 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) => {
+    const spark = new this.Spark(
+        socket.request.headers  // HTTP request headers.
+      , socket.request.primus   // IP Address location.
+      , socket.request.query    // Optional query string.
+      , socket.id               // Unique connection id.
+      , socket.request          // Reference to the HTTP req.
+      , socket                  // Reference to the Engine.IO 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 upgrade requests.
+  //
+  this.on('upgrade', (req, socket, head) => {
+    this.service.handleUpgrade(req, socket, head);
+  }).on('request', (req, res) => {
+    //
+    // Engine.IO closes the handshake socket before we receive a `connection`
+    // event. And as the socket is already answered it can be undefined.
+    //
+    req.primus = {
+      remoteAddress: req.socket.remoteAddress,
+      remotePort: req.socket.remotePort
+    };
+
+    this.service.handleRequest(req, res);
+  }).once('close',  () => this.service.close());
+};

package/transformers/faye/client.js

@@ -0,0 +1,103 @@
+'use strict';
+/*globals MozWebSocket */
+
+/**
+ * Minimum viable Faye-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 Faye-WebSocket factory.
+  //
+  var Factory = (function factory() {
+    if ('undefined' !== typeof WebSocket) return WebSocket;
+    if ('undefined' !== typeof MozWebSocket) return MozWebSocket;
+
+    try { return Primus.requires('faye-websocket').Client; }
+    catch (e) {}
+
+    return undefined;
+  })();
+
+  if (!Factory) return primus.critical(new Error(
+    'Missing required `faye-websocket` module. ' +
+    'Please run `npm install --save faye-websocket`'
+  ));
+
+  //
+  // 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 {
+      //
+      // 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) {
+        primus.socket = socket = new Factory(
+          primus.uri({ protocol: 'ws:', query: true }),  // URL
+          [],                                           // Sub protocols
+          primus.transport                              // options.
+        );
+      } else {
+        primus.socket = socket = new Factory(primus.uri({
+          protocol: 'ws:',
+          query: true
+        }));
+        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 !== 1) 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/faye/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/faye/server.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const Faye = require('faye-websocket');
+const http = require('http');
+const url = require('url');
+
+const PrimusError = require('../../errors').PrimusError;
+
+/**
+ * Minimum viable WebSocket server that works through the Primus interface.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  let options = { maxLength: this.primus.options.maxLength };
+
+  if (this.primus.options.compression) {
+    try {
+      options.extensions = [ require('permessage-deflate') ];
+    } catch (e) {
+      [
+        '',
+        'Missing required npm dependency for faye',
+        'To use the permessage-deflate extension with the faye 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: "faye"',
+        this.primus
+      );
+    }
+  }
+
+  options = Object.assign(options, this.primus.options.transport);
+
+  //
+  // Listen to upgrade requests.
+  //
+  this.on('upgrade', (req, socket, head) => {
+    if (!Faye.isWebSocket(req)) return socket.destroy();
+
+    let websocket = new Faye(req, socket, head, null, options);
+
+    //
+    // The WebSocket handshake is complete only when the `open` event is fired.
+    //
+    websocket.on('open', () => {
+      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.
+        , websocket                 // Reference to the WebSocket.
+      );
+
+      spark.on('outgoing::end', () => websocket && websocket.close());
+      spark.on('outgoing::data', (data) => websocket.send(data));
+
+      websocket.on('error', spark.emits('incoming::error'));
+      websocket.on('message', spark.emits('incoming::data', (next, evt) => {
+        next(undefined, evt.data);
+      }));
+      websocket.on('close', spark.emits('incoming::end', (next) => {
+        websocket.removeAllListeners();
+        websocket = 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]);
+  });
+};

package/transformers/sockjs/README.md

@@ -0,0 +1,31 @@
+# Transformer: SockJS
+
+A transformer abstraction for the SockJS framework. To enable this
+transformer inside of `Primus` you need to add `sockjs` to your package.json:
+
+```
+npm install sockjs --save
+```
+
+And tell primus to use `sockjs` as transformer.
+
+```js
+var Primus = require('primus');
+
+var primus = new Primus(server, { transformer: 'sockjs' });
+
+primus.on('connection', function connection(spark) {
+
+});
+```
+
+# Compiling the SockJS library
+
+To build the library use the `update.sh` utility. The steps required are the
+following:
+
+1. Fork or clone Primus
+2. cd in the directory and run `npm install`
+3. cd in the directory `transformers/sockjs/` and run `./update.sh`
+4. Commit the changes to the Primus main repository
+5. Profit

package/transformers/sockjs/client.js

@@ -0,0 +1,86 @@
+'use strict';
+/*globals SockJS*/
+
+/**
+ * Minimum viable SockJS 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 SockJS factory.
+  //
+  var Factory = (function Factory() {
+    if ('undefined' !== typeof SockJS) return SockJS;
+
+    try { return Primus.requires('sockjs-client'); }
+    catch (e) {}
+
+    return undefined;
+  })();
+
+  if (!Factory) return primus.critical(new Error(
+    'Missing required `sockjs-client` module. ' +
+    'Please run `npm install --save sockjs-client`'
+  ));
+
+  //
+  // Connect to the given URL.
+  //
+  primus.on('outgoing::open', function opening() {
+    primus.emit('outgoing::end');
+
+    primus.socket = socket = new Factory(
+      primus.uri({ protocol: 'http:', query: true }),
+      null,
+      primus.merge(primus.transport, {
+      info: {
+        websocket: !primus.AVOID_WEBSOCKETS,  // Prevent WebSocket crashes
+        cookie_needed: true                   // Disables xdomainrequest bugs
+      }
+    }));
+
+    //
+    // Setup the Event handlers.
+    //
+    socket.onopen = primus.emits('incoming::open');
+    socket.onerror = primus.emits('incoming::error');
+    socket.onclose = function (e) {
+      if (e && e.code > 1000) primus.emit('incoming::error', e);
+      primus.emit('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.send(message);
+  });
+
+  //
+  // 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/sockjs/index.js

@@ -0,0 +1,15 @@
+'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 a server.
+  client: require('./client'),
+
+  // The client-side library of sockjs.
+  library: require('fs').readFileSync(__dirname + '/library.js', 'utf-8')
+});