consumer.js

import { Socket } from 'net'
import path from 'path'
import btc from 'better-try-catch'
import JsonStream from './json-stream'

import logger from '@uci/logger'

let log = {}

const DEFAULT_PIPE_DIR = (process.env.SOCKETS_DIR || '/tmp/UCI')
const DEFAULT_SOCKET_NAME = 'uci-sock'

export default class Consumer extends Socket {
  constructor (opts={}) {
    super()
    log = logger({file:'src/consumer.js',class:'Consumer',name:'socket',id:this.id})
    this.id = opts.id || opts.name || 'socket:'+ new Date().getTime()
    if (!opts.path) {
      log.warn({opts:opts},'no host supplied using localhost...use named piped instead')
      opts.host = opts.host || '127.0.0.1'
      opts.port = opts.port || 8080
    } else {
      if (typeof opts.path === 'boolean') opts.path = path.join(DEFAULT_PIPE_DIR,DEFAULT_SOCKET_NAME )
      if (path.dirname(opts.path)==='.') opts.path = path.join(DEFAULT_PIPE_DIR,opts.path )
    }
    this.opts=opts
    this.keepAlive = 'keepAlive' in opts ? opts.keepAlive : true
    this._ready = false
    this.timeout = opts.timeout || 30
    this.wait = opts.wait || 1
    this.stream = new JsonStream()

    this.connect = this.connect.bind(this)
    this.__ready = this.__ready.bind(this)

  }

  async connect () {

    return new Promise( (resolve,reject) => {

      const connect = () => {
        if (this.opts.host ==='127.0.0.1') log.warn('tcp consumer on same machine as host, use named Pipe(Unix) Socket Instead')
        log.info({opts:this.opts},`attempting to connect ${this.id} to socket`)
        super.connect(this.opts)
      }

      let reconnect = {}
      const timeout = setTimeout(() =>{
        clearTimeout(reconnect)
        log.fatal({opts:this.opts},`unable to connect in ${this.timeout}s`)
        reject({opts:this.opts},`unable to connect to socket server in ${this.timeout}secs`)
      }
        ,this.timeout*1000)

      this.once('connect', async () => {
        clearTimeout(timeout)
        this._listen()
        log.info({opts:this.opts},'connected waiting for socket ready handshake')
        this.setKeepAlive(this.keepAlive,100)
        let [err, res] = await btc(isReady).bind(this)(this.__ready, this.wait, this.timeout)
        if (err) reject(err)
        log.info('handshake done, authenticating')

        resolve(res)
      })

      this.on('error', async (err) => {
        log.warn({error:err.code},`connect error ${err.code}`)
        if (err.code === 'EISCONN') {
          return resolve('ready')
        }

        reconnect = setTimeout( () =>{ connect()
        },this.wait*1000 )

      })

      this.on('end', async () => {
        log.warn('socket (server) terminated unexpectantly')
        if (this.keepAlive) {
          log.info('keep alive was set, so waiting on server to come online for reconnect')
          this.destroy()
          this.emit('error', {code:'DISCONNECTED'})
        }
      })

      connect()  // initial connect request

    }) //end promise

  }


  async send(ipacket) {
    return new Promise( async (resolve) => {

      let packet = Object.assign({},ipacket)
      setTimeout(() => {resolve({error:'no response from socket in 10sec'})},10000)
      packet._header =
      { id:Math.random().toString().slice(2), // need this for when multiple sends for different consumers use same packet instanceack
        sender:{ name:this.name, instanceID:this.id },
        path: this.opts.path,
        port: this.opts.port,
        host: this.opts.host
      }
      let [err, res] = await btc(this.stream.serialize)(packet)
      if (err) resolve({error:'unable to serialize packet for sending', packet:packet})
      await this.__write(res)
      this.once(packet._header.id,async function(reply){
        let res = await this._packetProcess(reply)
        if (!res) {   // if process was not promise returning like just logged to console
          res = reply

        }
        resolve(res)
      }) //end listener
    })
  }

  registerPacketProcessor (func) {
    this._packetProcess = func
  }

  async __write(packet) {

    return new Promise(resolve => {
      const cb = () => resolve('packet written to consumer side socket stream ')
      if (!super.write(packet)) {
        this.once('drain',cb )
      } else {
        process.nextTick(cb)
      }

    })
  }

  __ready() {return this._ready}

  async _listen () {
    log.info('listening for incoming packets from socket')

    this.on('pushed',async function(packet){

      let res = await this._packetProcess(packet)
      if (!res) {   // if process was not promise returning like just logged to console

      }
    })

    this.on('data', this.stream.onData)
    this.stream.on('message', messageProcess.bind(this))

    async function messageProcess (packet) {

      if (packet._handshake) {
        this._ready = true
        return }

      this.emit(packet._header.id, packet)
    }
  }

  _packetProcess (packet) {
    console.log('default consumer processor -- log packet from socket to console')
    console.dir(packet)
  }

}  // end class

function isReady(ready, wait=30, timeout=1000) {
  let time = 0
  return new Promise((resolve, reject) => {
    (function waitReady(){
      if (time > timeout) return reject(`timeout waiting for socket ready handshake - ${timeout}ms`)
      if (ready()) return resolve('ready')
      log.info(`waiting ${wait}ms for handshake`)
      time += wait
      setTimeout(waitReady, wait)
    })()
  })
}