fix notepack's encoding problems

[Domiii]

Big Notepack Problems

• encoding of symbol type not supported; workaround:
  • open file code node_modules/notepack.io/lib/encode.js, line 255
  • insert: case 'symbol': return _encode(bytes, defers, value.toString());
  • NOTE: once patched, you have to let webpack know that things changed:
    • either restart webpack
    • or force a version change to trigger a webpack rebuild
      • code node_modules/notepack.io/package.json -> change version
• When working with large applications (millions of traces), we run out of memory when when Client sends runtime data back to the server.
  • -> Client uses socket.io with socket.io-msgpack-parser, which in turn uses notepack.io where encoding uses up way too much memory
  • Issue already reported with notepack.io: encode is a crazy memory hog darrachequesne/notepack#27

Solution #1

• use https://github.com/msgpack/msgpack-javascript instead
  • in socket.io-msgpack-parser, replace notepack.io with @msgpack/msgpack (using webpack.NormalModuleReplacementPlugin)
• make sure, it works in the browser (since its documentation states that it requires node despite being tagged as universal)
• implement new custom parser
  • The original parser socket.io-msgpack-parser wants to send undefined, while msgpack-javascript coerces undefined to null
  • Discussed here: undefined becomes null after deserializing msgpack/msgpack-javascript#150
• add custom codec for missing data types (such as symbol)
• compare performance on big loads (e.g. webpack with pw=.*)
  • -> can deal with very large buffer sizes (unlike notepack)
  • -> less than 20s for 1gb buffer size

Finalize it

• for now, we (temporarily) put it in dbux-common\src\msgpackParser.js, but it should go into a new, more dedicated library (maybe dbux-net etc.)
• get rid of notepack.io completely

NOTEs

• socket.io does not handle decode errors gracefully. It does not report the error. It does not notify the client of a connect error apparently.

[Domiii]

var msgpack = require('@msgpack/msgpack');
var Emitter = require('component-emitter');

exports.protocol = 5;

/**
 * Packet types (see https://github.com/socketio/socket.io-protocol)
 */

var PacketType = (exports.PacketType = {
  CONNECT: 0,
  DISCONNECT: 1,
  EVENT: 2,
  ACK: 3,
  CONNECT_ERROR: 4,
});

var isInteger =
  Number.isInteger ||
  function (value) {
    return (
      typeof value === "number" &&
      isFinite(value) &&
      Math.floor(value) === value
    );
  };

var isString = function (value) {
  return typeof value === "string";
};

var isObject = function (value) {
  return Object.prototype.toString.call(value) === "[object Object]";
};

function Encoder() { }

Encoder.prototype.encode = function (packet) {
  console.warn(`msgpack ENCODE`, packet);
  return [msgpack.encode(packet)];
};

function Decoder() { }

Emitter(Decoder.prototype);

Decoder.prototype.add = function (obj) {
  console.warn(`msgpack DECODE`);
  try {
    var decoded = msgpack.decode(obj);
    this.checkPacket(decoded);
    this.emit("decoded", decoded);
  }
  catch (err) {
    console.error(`DECODE error -`, err);
  }
};

function exists(x) {
  return x !== null && x !== undefined;
}

function isDataValid(decoded) {
  switch (decoded.type) {
    case PacketType.CONNECT:
      return !exists(decoded.data) || isObject(decoded.data);
    case PacketType.DISCONNECT:
      return !exists(decoded.data);
    case PacketType.CONNECT_ERROR:
      return isString(decoded.data) || isObject(decoded.data);
    default:
      return Array.isArray(decoded.data);
  }
}

Decoder.prototype.checkPacket = function (decoded) {
  var isTypeValid =
    isInteger(decoded.type) &&
    decoded.type >= PacketType.CONNECT &&
    decoded.type <= PacketType.CONNECT_ERROR;
  if (!isTypeValid) {
    throw new Error("invalid packet type");
  }

  if (!isString(decoded.nsp)) {
    throw new Error("invalid namespace");
  }

  if (!isDataValid(decoded)) {
    throw new Error("invalid payload");
  }

  var isAckValid = !exists(decoded.id) || isInteger(decoded.id);
  if (!isAckValid) {
    throw new Error("invalid packet id");
  }
};

Decoder.prototype.destroy = function () { };

exports.Encoder = Encoder;
exports.Decoder = Decoder;