@bpanel/bpanel-utils/dist/proxysocket.js

Utilities for bpanel

/*!
 * proxysocket.js - wsproxy socket for bcoin
 * Copyright (c) 2016-2017, Christopher Jeffrey (MIT License).
 * https://github.com/bcoin-org/bcoin
 */

'use strict';

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var EventEmitter = require('events');
var bsock = require('bsock');

class ProxySocket extends EventEmitter {
  constructor(uri, apiKey) {
    super();

    this.socket = bsock.socket();
    this.socket.reconnection = false;
    this.socket.connect(uri);

    this.sendBuffer = [];
    this.recvBuffer = [];
    this.paused = false;
    this.bytesWritten = 0;
    this.bytesRead = 0;
    this.remoteAddress = null;
    this.remotePort = 0;
    this.apiKey = apiKey;

    this.closed = false;

    this.init();
  }

  init() {
    var _this = this;

    this.socket.on('error', function (err) {
      console.error(err);
    });

    this.socket.bind('tcp connect', function (addr, port) {
      if (_this.closed) return;
      _this.remoteAddress = addr;
      _this.remotePort = port;
      _this.emit('connect');
    });

    this.socket.bind('tcp data', function (data) {
      data = Buffer.from(data, 'hex');
      if (_this.paused) {
        _this.recvBuffer.push(data);
        return;
      }
      _this.bytesRead += data.length;
      _this.emit('data', data);
    });

    this.socket.bind('tcp close', function () {
      if (_this.closed) return;
      _this.closed = true;
      _this.emit('close');
    });

    this.socket.bind('tcp error', function (e) {
      var err = new Error(e.message);
      err.code = e.code;
      _this.emit('error', err);
    });

    this.socket.bind('tcp timeout', function () {
      _this.emit('timeout');
    });

    this.socket.on('disconnect', function () {
      if (_this.closed) return;
      _this.closed = true;
      _this.emit('close');
    });
  }

  connect(port, host) {
    var _this2 = this;

    return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
      var _iterator, _isArray, _i, _ref, chunk;

      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _this2.remoteAddress = host;
              _this2.remotePort = port;

              if (!_this2.closed) {
                _context.next = 5;
                break;
              }

              _this2.sendBuffer.length = 0;
              return _context.abrupt('return');

            case 5:
              _context.next = 7;
              return _this2.socket.call('auth', _this2.apiKey);

            case 7:
              _this2.socket.fire('tcp connect', port, host);

              _iterator = _this2.sendBuffer, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);

            case 9:
              if (!_isArray) {
                _context.next = 15;
                break;
              }

              if (!(_i >= _iterator.length)) {
                _context.next = 12;
                break;
              }

              return _context.abrupt('break', 23);

            case 12:
              _ref = _iterator[_i++];
              _context.next = 19;
              break;

            case 15:
              _i = _iterator.next();

              if (!_i.done) {
                _context.next = 18;
                break;
              }

              return _context.abrupt('break', 23);

            case 18:
              _ref = _i.value;

            case 19:
              chunk = _ref;
              _this2.write(chunk);

            case 21:
              _context.next = 9;
              break;

            case 23:
              _this2.sendBuffer.length = 0;

            case 24:
            case 'end':
              return _context.stop();
          }
        }
      }, _callee, _this2);
    }))();
  }

  setKeepAlive(enable, delay) {
    this.socket.fire('tcp keep alive', enable, delay);
  }

  setNoDelay(enable) {
    this.socket.fire('tcp no delay', enable);
  }

  setTimeout(timeout, callback) {
    this.socket.fire('tcp set timeout', timeout);
    if (callback) this.on('timeout', callback);
  }

  write(data, callback) {
    this.bytesWritten += data.length;

    this.socket.fire('tcp data', data.toString('hex'));

    if (callback) callback();

    return true;
  }

  pause() {
    this.paused = true;
  }

  resume() {
    var recv = this.recvBuffer;

    this.paused = false;
    this.recvBuffer = [];

    for (var _iterator2 = recv, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
      var _ref2;

      if (_isArray2) {
        if (_i2 >= _iterator2.length) break;
        _ref2 = _iterator2[_i2++];
      } else {
        _i2 = _iterator2.next();
        if (_i2.done) break;
        _ref2 = _i2.value;
      }

      var data = _ref2;

      this.bytesRead += data.length;
      this.emit('data', data);
    }
  }

  destroy() {
    if (this.closed) return;
    this.closed = true;
    this.socket.destroy();
  }

  static connect(uri, port, host) {
    var socket = new this(uri);
    socket.connect(port, host);
    return socket;
  }
}

module.exports = ProxySocket;