@sex-pomelo/sex-pomelo/lib/connectors/hybridconnector.js

[![NPM version][npm-image-pomelo]][npm-url-pomelo] [![NPM version][npm-image-down]][npm-url-pomelo]

"use strict";

const net = require('net');
const tls = require('tls');
const EventEmitter = require('events').EventEmitter;

const HybridSocket = require('./hybridsocket');
const Switcher = require('./hybrid/switcher');

const Handshake = require('./commands/handshake');
const Heartbeat = require('./commands/heartbeat');
const Kick = require('./commands/kick');
const coder = require('./common/coder');

let curId = 1;
let gConn = null;

/**
 * @namespace hybridConnector
 */


/**
 * Connector that manager low level connection and protocol bewteen server and client.
 * Develper can provide their own connector to switch the low level prototol, such as tcp or probuf.
 * @class
 * @constructor
 * @memberof hybridConnector
 */
class hybridConnector extends EventEmitter
{
  constructor(port, host, opts) {
    super();
  
    this.opts = opts || {};
    this.port = port;
    this.host = host;
    this.useDict = opts.useDict;
    this.useProtobuf = opts.useProtobuf;
    this.handshake = new Handshake(opts);
    this.heartbeat = new Heartbeat(opts);
    this.distinctHost = opts.distinctHost;
    this.ssl = opts.ssl;
  
    this.switcher = null;

    this.decode = coder.decode;
    this.encode = coder.encode;
  }


  /**
   * Start connector to listen the specified port
   */
  start(cb) {
    let app = require('../pomelo').app;
    let self = this;

    let gensocket = function(socket) {
      let hybridsocket = new HybridSocket(curId++, socket);
      hybridsocket.on('handshake', self.handshake.handle.bind(self.handshake, hybridsocket));
      hybridsocket.on('heartbeat', self.heartbeat.handle.bind(self.heartbeat, hybridsocket));
      hybridsocket.on('disconnect', self.heartbeat.clear.bind(self.heartbeat, hybridsocket.id));
      hybridsocket.on('closing', Kick.handle.bind(null, hybridsocket));
      self.emit('connection', hybridsocket);
    };

    this.connector = app.components.__connector__.connector;
    this.dictionary = app.components.__dictionary__;
    this.protobuf = app.components.__protobuf__;
    this.decodeIO_protobuf = app.components.__decodeIO__protobuf__;

    if(!this.ssl) {
      this.listeningServer = net.createServer();
    } else {
      this.listeningServer = tls.createServer(this.ssl);
    }
    this.switcher = new Switcher(this.listeningServer, self.opts);

    this.switcher.on('connection', function(socket) {
      gensocket(socket);
    });

    if(!!this.distinctHost) {
      this.listeningServer.listen(this.port, this.host);
    } else {
      this.listeningServer.listen(this.port);
    }

    process.nextTick(cb);
  }

  stop(force, cb) {
    this.switcher.close();
    this.listeningServer.close();

    process.nextTick(cb);
  }

}


module.exports = function(port, host, opts) {
  if (gConn === null) {
    gConn = new hybridConnector(port, host, opts)

    return gConn;
  }

  return gConn;
};