@depup/primus 8.0.9-depup.0

package/transformer.js

@@ -0,0 +1,237 @@
+'use strict';
+
+var log = require('diagnostics')('primus:transformer')
+  , middlewareError = require('./middleware/error')
+  , url = require('url').parse
+  , Ultron = require('ultron')
+  , fuse = require('fusing');
+
+function noop() {}
+
+/**
+ * Transformer skeleton
+ *
+ * @constructor
+ * @param {Primus} primus Reference to the Primus instance.
+ * @api public
+ */
+function Transformer(primus) {
+  this.fuse();
+
+  this.ultron = new Ultron(primus.server);  // Handles listeners with ease.
+  this.Spark = primus.Spark;                // Reference to the Spark constructor.
+  this.primus = primus;                     // Reference to the Primus instance.
+  this.service = null;                      // Stores the real-time service.
+
+  this.initialise();
+}
+
+fuse(Transformer, require('eventemitter3'));
+
+//
+// Simple logger shortcut.
+//
+Object.defineProperty(Transformer.prototype, 'logger', {
+  get: function logger() {
+    return {
+      error: this.primus.emits('log', 'error'), // Log error <line>.
+      warn:  this.primus.emits('log', 'warn'),  // Log warn <line>.
+      info:  this.primus.emits('log', 'info'),  // Log info <line>.
+      debug: this.primus.emits('log', 'debug'), // Log debug <line>.
+      log:   this.primus.emits('log', 'log'),   // Log log <line>.
+      plain: this.primus.emits('log', 'log')    // Log log <line>.
+    };
+  }
+});
+
+/**
+ * Create the server and attach the appropriate event listeners.
+ *
+ * @api private
+ */
+Transformer.readable('initialise', function initialise() {
+  if (this.server) this.server();
+
+  var server = this.primus.server
+    , transformer = this;
+
+  server.listeners('request').forEach(function each(fn) {
+    log('found existing request handlers on the HTTP server, moving Primus as first');
+    transformer.on('previous::request', fn, server);
+  });
+
+  server.listeners('upgrade').forEach(function each(fn) {
+    log('found existing upgrade handlers on the HTTP server, moving Primus as first');
+    transformer.on('previous::upgrade', fn, server);
+  });
+
+  //
+  // Remove the old listeners as we want to be the first request handler for all
+  // events.
+  //
+  server.removeAllListeners('request');
+  server.removeAllListeners('upgrade');
+
+  //
+  // Emit a close event.
+  //
+  this.ultron.on('close', function close() {
+    log('the HTTP server is closing');
+    transformer.emit('close');
+  });
+
+  //
+  // Start listening for incoming requests if we have a listener assigned to us.
+  //
+  if (this.listeners('request').length || this.listeners('previous::request').length) {
+    server.on('request', this.request.bind(this));
+  }
+
+  if (this.listeners('upgrade').length || this.listeners('previous::upgrade').length) {
+    server.on('upgrade', this.upgrade.bind(this));
+  }
+});
+
+/**
+ * Iterate all the middleware layers that we're set on our Primus instance.
+ *
+ * @param {String} type Either `http` or `upgrade`
+ * @param {Request} req HTTP request.
+ * @param {Response} res HTTP response.
+ * @param {Function} next Continuation callback.
+ * @api private
+ */
+Transformer.readable('forEach', function forEach(type, req, res, next) {
+  var transformer = this
+    , layers = transformer.primus.layers
+    , primus = transformer.primus;
+
+  req.query = req.uri.query || {};
+
+  //
+  // Add some silly HTTP properties for connect.js compatibility.
+  //
+  req.originalUrl = req.url;
+
+  if (!layers.length) {
+    next();
+    return transformer;
+  }
+
+  //
+  // Async or sync call the middleware layer.
+  //
+  (function iterate(index) {
+    var layer = layers[index++];
+
+    if (!layer) return next();
+    if (!layer.enabled || layer.fn[type] === false) return iterate(index);
+
+    if (layer.length === 2) {
+      log('executing middleware (%s) synchronously', layer.name);
+
+      if (layer.fn.call(primus, req, res)) return;
+      return iterate(index);
+    }
+
+    log('executing middleware (%s) asynchronously', layer.name);
+    layer.fn.call(primus, req, res, function done(err) {
+      if (err) return middlewareError(err, req, res);
+
+      iterate(index);
+    });
+  }(0));
+
+  return transformer;
+});
+
+/**
+ * Start listening for incoming requests and check if we need to forward them to
+ * the transformers.
+ *
+ * @param {Request} req HTTP request.
+ * @param {Response} res HTTP response.
+ * @api private
+ */
+Transformer.readable('request', function request(req, res) {
+  if (!this.test(req)) return this.emit('previous::request', req, res);
+
+  req.headers['primus::req::backup'] = req;
+  res.once('end', function gc() {
+    delete req.headers['primus::req::backup'];
+  });
+
+  //
+  // I want to see you're face when you're looking at the lines of code above
+  // while you think, WTF what is this shit, you mad bro!? Let me take a moment
+  // to explain this mad and sadness.
+  //
+  // There are some real-time transformers that do not give us access to the
+  // HTTP request that initiated their `socket` connection. They only give us
+  // access to the information that they think is useful, we're greedy, we want
+  // everything and let developers decide what they want to use instead and
+  // therefor want to expose this HTTP request on our `spark` object.
+  //
+  // The reason it's added to the headers is because it's currently the only
+  // field that is accessible through all transformers.
+  //
+
+  log('handling HTTP request for url: %s', req.url);
+  this.forEach('http', req, res, this.emits('request', req, res));
+});
+
+/**
+ * Starting listening for incoming upgrade requests and check if we need to
+ * forward them to the transformers.
+ *
+ * @param {Request} req HTTP request.
+ * @param {Socket} socket Socket.
+ * @param {Buffer} head Buffered data.
+ * @api private
+ */
+Transformer.readable('upgrade', function upgrade(req, socket, head) {
+  if (!this.test(req)) return this.emit('previous::upgrade', req, socket, head);
+
+  //
+  // See Transformer#request for an explanation of this madness.
+  //
+  req.headers['primus::req::backup'] = req;
+  socket.once('end', function gc() {
+    delete req.headers['primus::req::backup'];
+  });
+
+  log('handling HTTP upgrade for url: %s', req.url);
+
+  //
+  // Add a listener for the `'error'` event before running middleware as there
+  // isn't a default one in Node.js >= 10. The socket is destroyed when an error
+  // occurs so there is no need to do anything.
+  //
+  socket.on('error', noop);
+
+  this.forEach('upgrade', req, socket, () => {
+    socket.removeListener('error', noop);
+    this.emit('upgrade', req, socket, head);
+  });
+});
+
+/**
+ * Check if we should accept this request.
+ *
+ * @param {Request} req HTTP Request.
+ * @returns {Boolean} Do we need to accept this request.
+ * @api private
+ */
+Transformer.readable('test', function test(req) {
+  req.uri = url(req.url, true);
+
+  var pathname = req.uri.pathname || '/'
+    , route = this.primus.pathname;
+
+  return pathname.slice(0, route.length) === route;
+});
+
+//
+// Expose the transformer's skeleton.
+//
+module.exports = Transformer;

package/transformers/browserchannel/client.js

@@ -0,0 +1,92 @@
+'use strict';
+/*globals BCSocket*/
+
+/**
+ * Minimum viable BrowserChannel 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 BrowserChannel factory.
+  //
+  var Factory = (function factory() {
+    if ('undefined' !== typeof BCSocket) return BCSocket;
+
+    try { return Primus.requires('browserchannel').BCSocket; }
+    catch (e) {}
+
+    return undefined;
+  })();
+
+  if (!Factory) return primus.critical(new Error(
+    'Missing required `browserchannel` module. ' +
+    'Please run `npm install --save browserchannel`'
+  ));
+
+  //
+  // Connect to the given URL.
+  //
+  primus.on('outgoing::open', function connect() {
+    primus.emit('outgoing::end');
+
+    var url = primus.uri({ protocol: 'http:' });
+
+    primus.socket = socket = new Factory(url, primus.merge(primus.transport, {
+      extraParams: primus.querystring(primus.url.query),
+      reconnect: false
+    }));
+
+    //
+    // 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.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 () {};
+
+    //
+    // Bug: BrowserChannel cannot close the connection if it's already
+    // connecting. Bypass this behaviour by checking the readyState and
+    // defer the close call.
+    //
+    if (socket.readyState === socket.CONNECTING) {
+      socket.onopen = function onopen() {
+        this.close();
+      };
+    } else {
+      socket.close();
+    }
+    socket = null;
+  });
+};

package/transformers/browserchannel/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var path = require('path')
+  , directory = require.resolve('browserchannel')
+  , library = path.join(path.dirname(directory), 'dist/bcsocket-uncompressed.js');
+
+//
+// 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 the browserchannel.
+  library: require('fs').readFileSync(library, 'utf-8')
+});

package/transformers/browserchannel/server.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var browserchannel = require('browserchannel')
+  , http = require('http');
+
+/**
+ * Minimum viable BrowserChannel server for Node.js that works through the
+ * primus interface.
+ *
+ * @runat server
+ * @api private
+ */
+module.exports = function server() {
+  var primus = this.primus
+    , Spark = this.Spark;
+
+  //
+  // 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 = browserchannel.server(Object.assign(primus.options.transport, {
+    base: primus.pathname
+  }), function connection(socket) {
+    var spark = new Spark(
+        socket.headers                    // HTTP request headers.
+      , {                                 // IP address Location.
+          remoteAddress: socket.address,
+          remotePort: 1337
+        }
+      , socket.query                      // Optional query string.
+      , socket.id                         // Unique connection id.
+      , null                              // We don't have have a HTTP request.
+      , socket                            // Reference to the BrowserChannel socket.
+    );
+
+    spark.on('outgoing::end', function end() {
+      if (socket) socket.stop();
+    }).on('outgoing::data', function write(data) {
+      socket.send(data);
+    });
+
+    socket.on('message', spark.emits('incoming::data'));
+    socket.on('error', spark.emits('incoming::error'));
+    socket.on('close', spark.emits('incoming::end', function parser(next) {
+      socket.removeAllListeners();
+      socket = null;
+      next();
+    }));
+  });
+
+  //
+  // Listen to upgrade requests.
+  //
+  this.on('request', function request(req, res) {
+    //
+    // The browser.channel returns a middleware layer.
+    //
+    this.service(req, res, function next() {
+      res.writeHead(404, {'content-type': 'text/plain'});
+      res.end(http.STATUS_CODES[404]);
+    });
+  });
+};

package/transformers/engine.io/README.md

@@ -0,0 +1,34 @@
+# Transformer: Engine.IO
+
+A transformer abstraction for the Engine.IO framework. To enable this
+transformer inside of `Primus` you need to add `engine.io` to your package.json:
+
+```
+npm install engine.io --save
+```
+
+And tell primus to use `engine.io` as transformer.
+
+```js
+var Primus = require('primus');
+
+var primus = new Primus(server, { transformer: 'engine.io' });
+
+primus.on('connection', function connection(spark) {
+
+});
+```
+
+# Compiling the Engine.IO library
+
+We cannot depend on the `engine.io.js` file because it uses a UMD wrapper
+that doesn't work with Primus when using RequireJS. To compile the
+`engine.io-client` correctly use the `update.sh` utility which will build the
+library and expose it as a property of the global object.
+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/engine.io/` and run `./update.sh`
+4. Commit the changes to the Primus main repository
+5. Profit

package/transformers/engine.io/client.js

@@ -0,0 +1,111 @@
+'use strict';
+/*globals eio*/
+
+/**
+ * Minimum viable Engine.IO client. This function is stringified and added in
+ * our client-side library.
+ *
+ * @runat client
+ * @api private
+ */
+module.exports = function client() {
+  var onmessage = this.emits('incoming::data')
+    , onerror = this.emits('incoming::error')
+    , onopen = this.emits('incoming::open')
+    , onclose = this.emits('incoming::end')
+    , primus = this
+    , socket;
+
+  //
+  // Select an available Engine.IO factory.
+  //
+  var factory = (function factory() {
+    if ('undefined' !== typeof eio) return eio;
+
+    try {
+      var Socket = Primus.requires('engine.io-client').Socket;
+
+      return function eio(options) {
+        return new Socket(options);
+      }
+    } catch (e) {}
+
+    return undefined;
+  })();
+
+  if (!factory) return primus.critical(new Error(
+    'Missing required `engine.io-client` module. ' +
+    'Please run `npm install --save engine.io-client`'
+  ));
+
+  //
+  // Connect to the given URL.
+  //
+  primus.on('outgoing::open', function opening() {
+    primus.emit('outgoing::end');
+
+    primus.socket = socket = factory(primus.merge(primus.transport,
+      primus.url,
+      primus.uri({ protocol: 'http:', query: true, object: true }), {
+      //
+      // Never remember upgrades as switching from a WIFI to a 3G connection
+      // could still get your connection blocked as 3G connections are usually
+      // behind a reverse proxy so ISP's can optimize mobile traffic by
+      // caching requests.
+      //
+      rememberUpgrade: false,
+
+      //
+      // Binary support in Engine.IO breaks a shit things. Turn it off for now.
+      //
+      forceBase64: true,
+
+      //
+      // Force timestamps on every single connection. Engine.IO only does this
+      // for polling by default, but WebSockets require an explicit `true`
+      // boolean.
+      //
+      timestampRequests: true,
+      path: this.pathname,
+      transports: !primus.AVOID_WEBSOCKETS
+        ? ['polling', 'websocket']
+        : ['polling']
+    }));
+
+    //
+    // Setup the Event handlers.
+    //
+    socket.on('message', onmessage);
+    socket.on('error', onerror);
+    socket.on('close', onclose);
+    socket.on('open', onopen);
+  });
+
+  //
+  // 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.removeListener('message', onmessage);
+    socket.removeListener('error', onerror);
+    socket.removeListener('close', onclose);
+    socket.removeListener('open', onopen);
+    socket.close();
+    socket = null;
+  });
+};

package/transformers/engine.io/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 engine.io.
+  library: require('fs').readFileSync(__dirname + '/library.js', 'utf-8')
+});