438 lines
17 KiB
JavaScript
438 lines
17 KiB
JavaScript
// node modules
|
|
import { unlink as fileDelete } from 'fs'
|
|
import { promisify } from 'util'
|
|
import path from 'path'
|
|
// npmjs modules
|
|
import mkdir from 'make-dir'
|
|
import btc from 'better-try-catch'
|
|
import _ON_DEATH from 'death' //this is intentionally ugly
|
|
import JSONStream from './json-stream'
|
|
import clone from 'clone'
|
|
// uci modules
|
|
import logger from '@uci-utils/logger'
|
|
let log = {} // must declare here and set later for module wide access
|
|
|
|
export default function socketClass(Server) {
|
|
|
|
// TODO change default pipe dir depending on OS linux,windows,mac
|
|
/** @constant {String} DEFAULT_PIPE_DIR
|
|
* @description SOCKETS_DIR environment variable or '/tmp/UCI'
|
|
*/
|
|
const DEFAULT_PIPE_DIR = process.env.SOCKETS_DIR || '/tmp/UCI'
|
|
/** @constant {String} DEFAULT_SOCKET_NAME
|
|
* @description for named pipe 'uci-sock' if not set in options */
|
|
const DEFAULT_SOCKET_NAME = 'uci-sock'
|
|
|
|
/**
|
|
* UCI Socket - class used to create a socket (server) that supports passing json packets
|
|
* supports both named pipes and tcp sockets
|
|
* also supports push of packets to all connected consumers (clients)
|
|
* is extended from {@link https://nodejs.org/api/net.html#net_class_net_server | nodejs net.Server }
|
|
* @extends Server
|
|
*/
|
|
|
|
|
|
return class Socket extends Server {
|
|
/**
|
|
* UCI Socket class constructor
|
|
* @param {Object} opts hash of options
|
|
* @param {String} options.host a tcp host name nornally not used as 0.0.0.0 is set by default
|
|
* @param {String} options.port a tcp
|
|
* @param {String | Boolean} options.path xeither full path to where socket should be created or if just 'true' then use default
|
|
* @param {Boolean} options.consumerTracking track connected consumers for push notifications - default: true
|
|
* @param {Object} options.conPacket A json operson's property
|
|
*
|
|
*/
|
|
constructor(opts = {}) {
|
|
super(opts)
|
|
delete opts.key
|
|
delete opts.cert
|
|
this.id = opts.id || opts.name || 'socket:' + new Date().getTime()
|
|
if (!opts.path) {
|
|
opts.host = opts.host || '0.0.0.0'
|
|
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) === '.') // relative path sent
|
|
opts.path = path.join(DEFAULT_PIPE_DIR, opts.path)
|
|
}
|
|
this.defaultReturnCmd = opts.defaultReturnCmd
|
|
this.allowAnonymous = (!opts.tokens || !!process.env.UCI_ANON || opts.allowAnonymous) ? true : false
|
|
this.tokens = opts.tokens || []
|
|
this.keepAlive = 'keepAlive' in opts ? opts.keepAlive : true
|
|
this.pingInterval = opts.pingInterval === false ? 0 : (opts.pingInterval * 1000 || 5000)
|
|
this.consumers = new Map() // track consumers (i.e. clients) TODO use a Map
|
|
this.nextConsumerID = 0 // incrementer for default initial consumer ID
|
|
this.opts = opts // for use to recover from selected errors
|
|
this.errorCount = 0
|
|
//self bindings
|
|
this.create = this.create.bind(this)
|
|
this.authenticateConsumer = this.authenticateConsumer.bind(this)
|
|
this._authenticate = this._authenticate.bind(this)
|
|
this.close = promisify(this.close).bind(this)
|
|
log = logger({
|
|
package:'@uci/socket',
|
|
file: 'src/socket.js',
|
|
class: 'Socket',
|
|
id: this.id
|
|
})
|
|
} // end constructor
|
|
|
|
|
|
get active() { return this.listening }
|
|
|
|
/**
|
|
* create - Description
|
|
*
|
|
* @returns {type} Description
|
|
*/
|
|
async create() {
|
|
return new Promise(async (resolve, reject) => {
|
|
_ON_DEATH(async () => {
|
|
log.error({method:'create', line:84, msg:'\nhe\'s dead jim'})
|
|
await this._destroy()
|
|
})
|
|
process.once('SIGUSR2', async () => {
|
|
await this._destroy()
|
|
process.kill(process.pid, 'SIGUSR2')
|
|
})
|
|
|
|
this.once('error', async err => {
|
|
// recover from socket file that was not removed
|
|
if (err.code === 'EADDRINUSE') {
|
|
if (this.opts.path) {
|
|
// if TCP socket should already be dead
|
|
let [err, res] = await btc(promisify(fileDelete))(this.opts.path)
|
|
if (!err) {
|
|
log.info({method:'create', line:99, res: res, socket: this.opts.path, msg:'socket already exists.....deleted'})
|
|
// try again
|
|
this.removeAllListeners('listening')
|
|
return await this.create()
|
|
}
|
|
log.error({method:'create', line:102, err: err, msg:'error deleting socket. Can not establish a socket'})
|
|
}
|
|
}
|
|
if (err.code === 'EACCES') {
|
|
log.debug({method:'create', line:107, socket: this.opts.path, msg:'directory does not exist...creating'})
|
|
await mkdir(path.dirname(this.opts.path))
|
|
log.debug({method:'create', line:109, socket: this.opts.path, msg:'directory created'})
|
|
this.removeAllListeners('listening')
|
|
return await this.create()
|
|
}
|
|
// otherwise fatally exit
|
|
log.error({method:'create', line:113, err:err, opts:this.opts, msg:`error creating socket server ${this.name}`})
|
|
reject(err)
|
|
})
|
|
|
|
this.once('listening', () => {
|
|
this.on('error', err => {
|
|
this.errorCount +=1 // log errors here
|
|
this.errors.push(err)
|
|
if(this.errorCount>2 && this.errorCount<6) {
|
|
let errors= {level:'warn',msg:'something bad maybe going on, 3 errors', errors:this.errors}
|
|
this.emit('log', errors)
|
|
log.error(errors)
|
|
}
|
|
if(this.errorCount>5) {
|
|
let errors = {level:'fatal',msg:'something fatal is going on, 6 errors', errors:this.errors}
|
|
log.fatal(errors)
|
|
this.listening=false
|
|
this.emit('log', errors)
|
|
}
|
|
})
|
|
let msg = `socket ready and listening ${typeof this.address() ==='string' ? `at ${this.address()}` : `on port ${this.address().port}`}`
|
|
let obj = {method:'create', line:54, msg:msg}
|
|
log.info(obj)
|
|
this.on('connection', this._connectionHandler.bind(this))
|
|
this.emit('log:',)
|
|
resolve(msg)
|
|
})
|
|
|
|
super.listen(this.opts)
|
|
this.enablePing()
|
|
|
|
}) // end creeate promise
|
|
} // end create
|
|
|
|
/**
|
|
* registerPacketProcessor - Description
|
|
* @public
|
|
* @param {func} Description
|
|
*
|
|
*/
|
|
registerPacketProcessor(func) {
|
|
this._packetProcess = func
|
|
}
|
|
|
|
enablePing () {
|
|
if (this.pingInterval > 499) {
|
|
this._ping = setInterval( async () =>{
|
|
if (this.consumers.size > 0) this.push({pingInterval:this.pingInterval},'ping')
|
|
},this.pingInterval)
|
|
}
|
|
}
|
|
|
|
disablePing() {
|
|
clearInterval(this._ping)
|
|
}
|
|
|
|
addTokens(tokens) {
|
|
if (typeof tokens ==='string'){
|
|
tokens = tokens.split(',')
|
|
}
|
|
this.tokens = this.tokens.concat(tokens)
|
|
if (this.tokens.length>0) this.allowAnonymous = false
|
|
}
|
|
|
|
removeTokens(tokens) {
|
|
if (typeof tokens ==='string'){
|
|
if (tokens === 'all') {
|
|
this.tokens = []
|
|
this.allowAnonymous = true
|
|
return
|
|
}
|
|
tokens = tokens.split(',')
|
|
}
|
|
this.tokens = this.tokens.filter(token => !tokens.includes(token))
|
|
if (this.tokens.length===0) {
|
|
log.warn({msg:'all tokens have been removed, switching to allow anonymous connections'})
|
|
this.allowAnonymous = true
|
|
}
|
|
}
|
|
|
|
registerTokenValidator (func) {
|
|
this.allowAnonymous = false
|
|
this._validateToken = func
|
|
}
|
|
|
|
registerAuthenticator (func) {
|
|
this.allowAnonymous = false
|
|
this._authenticate = func
|
|
}
|
|
|
|
|
|
/**
|
|
* push - pushes a supplied UCI object packet to all connected consumers
|
|
*
|
|
* @param {object} packet Description
|
|
* @param {string} id the header id string of the pushed packet, default: 'pushed'
|
|
*
|
|
*/
|
|
async push(packet={},id) {
|
|
packet._header = {id: id || 'pushed'}
|
|
if (this.consumers.size > 0) {
|
|
log.trace({method:'push', line:142, id:packet._header.id, opts: this.opts, packet: packet, msg:'pushing a packet to all connected consumers'})
|
|
// TODO should do a map and single promise
|
|
this.consumers.forEach(async consumer => {
|
|
if (consumer.writable) {
|
|
let [err] = await btc(this._send)(consumer,packet)
|
|
if (err) log.error({msg:err, error:err})
|
|
}
|
|
})
|
|
} else {
|
|
log.debug({method:'push', line:165, id:packet._header.id, opts: this.opts, packet: packet, msg:'no connected consumers, push ignored'})
|
|
}
|
|
}
|
|
|
|
|
|
removeConsumer (sid) {
|
|
let consumer=this.consumers.get(sid)
|
|
this.emit('log',{level:'info', msg:'a consumer disconnected', consumer:consumer.data, sid:consumer.sid})
|
|
this.emit('connection:consumer',{state:'disconnected', msg:'a consumer disconnected', consumer:consumer.data, sid:consumer.sid})
|
|
consumer.removeAllListeners()
|
|
consumer.stream.removeAllListeners()
|
|
this.consumers.delete(sid)
|
|
log.warn({msg:'consumer removed from tracking',sid:sid, curConsumerCount:this.consumers.size})
|
|
}
|
|
|
|
async authenticateConsumer(consumer) {
|
|
return new Promise(async (resolve, reject) => {
|
|
// when consumer gets the handshake they must follow with authentication
|
|
consumer.stream.on('message', authenticate.bind(this,consumer))
|
|
let [err] = await btc(this._send)(consumer,{_handshake: true, sid:consumer.sid})
|
|
if (err) {
|
|
log.error({msg:'error in handshake send', error:err})
|
|
reject(err)
|
|
}
|
|
|
|
async function authenticate (consumer,packet) {
|
|
log.debug({msg:`authentication packet from consumer ${consumer.name}:${consumer.id}:${consumer.sid}`, packet:packet})
|
|
consumer.stream.removeAllListeners('message')
|
|
if (!packet._authenticate) reject('first consumer packet was not authentication')
|
|
else {
|
|
let [err, res] = await btc(this._authenticate)(packet)
|
|
consumer.authenticated = this.allowAnonymous ? 'anonymous' : (err ? false : res)
|
|
consumer.data = packet.data
|
|
packet.authenticated = consumer.authenticated
|
|
packet.reason = err || null
|
|
log.debug({msg:'sending authorization result to consumer', packet:packet})
|
|
await this._send(consumer,packet) // send either way
|
|
if (err && !this.allowAnonymous) {
|
|
log.info({msg:`consumer ${consumer.data.name} authentication failed`, consumer:consumer.data, consumer_sid:consumer.sid, reason:err})
|
|
reject(packet.reason)
|
|
}
|
|
else {
|
|
log.info({msg:`consumer ${consumer.data.name} authenticated successfuly`, consumer:consumer.data})
|
|
if (this.allowAnonymous) log.warn({msg:`consumer ${consumer.data.name}, connected anonymously`, consumer:consumer.data})
|
|
resolve(consumer.authenticated)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// private methods
|
|
|
|
|
|
// default validator
|
|
_validateToken (token) {
|
|
if (token) return this.tokens.includes(token)
|
|
return false
|
|
}
|
|
|
|
// default authenticator - reject value should be reason which is returned to consumer
|
|
async _authenticate (packet) {
|
|
if (!this._validateToken(packet.token)) return Promise.reject('invalid token')
|
|
return true
|
|
}
|
|
|
|
|
|
// async _connectionHandler({consumer, server}) { // this gets called for each consumer connection and is unique to
|
|
async _connectionHandler(consumer) { // this gets called for each consumer connection and is unique to each
|
|
|
|
const stream = new JSONStream()
|
|
consumer.stream = stream
|
|
consumer.data = {}
|
|
consumer.connected = true
|
|
|
|
// add listeners
|
|
consumer.on('error', (err) => {
|
|
log.error({msg:'consumer connection error',error:err})
|
|
// TODO do more handling than just logging
|
|
})
|
|
|
|
consumer.on('end', (err) => {
|
|
log.error({msg:`'consumer connection ended: ${consumer.data.name}`, error:err})
|
|
if (consumer.sid) this.removeConsumer(consumer.sid)
|
|
else {
|
|
consumer.removeAllListeners()
|
|
consumer.stream.removeAllListeners()
|
|
}
|
|
})
|
|
|
|
consumer.on('data', stream.onData) // send data to
|
|
|
|
stream.on('error', (err) => {
|
|
log.error({msg:'consumer stream error during listen',error:err})
|
|
// TODO do more handling than just logging
|
|
})
|
|
|
|
// consumer.authenticated = true
|
|
|
|
let [err] = await btc(this.authenticateConsumer)(consumer)
|
|
if (!this.allowAnonymous) {
|
|
if (err) {
|
|
consumer.removeAllListeners()
|
|
consumer.stream.removeAllListeners()
|
|
consumer.end()// abort new connection consumer, cleanup, remove listeners
|
|
consumer.emit('end',err)
|
|
return
|
|
}
|
|
}
|
|
// authenticated consumer, add to list of consumers
|
|
consumer.sid = ++this.nextConsumerID // server assigned ID
|
|
// consumer.authenticated = true
|
|
this.consumers.set(consumer.sid, consumer) // add current consumer to consumers
|
|
consumer.setKeepAlive(this.keepAlive,30)
|
|
const consumerCloseHandler = (sid) => {
|
|
log.warn({msg:'consumer connection was closed',sid:sid})
|
|
this.removeConsumer(sid)
|
|
}
|
|
consumer.on('close', consumerCloseHandler.bind(this,consumer.sid))
|
|
log.debug({method:'_listen', line:364, msg:'new consumer connected/authenticated', cname:consumer.name, cid:consumer.id, totalConsumers:this.consumers.size})
|
|
// all's set enable main incoming message processor
|
|
stream.on('message', messageProcess.bind(this, consumer))
|
|
|
|
if (this.opts.conPacket) {
|
|
this.opts.conPacket._header = { id: 'pushed' }
|
|
log.debug({method:'_listen', line:171, conPacket: this.opts.conPacket, msg:'pushing a preset command to just connected consumer'})
|
|
this._send(consumer,this.opts.conPacket) // send a packet command on to consumer on connection
|
|
}
|
|
|
|
this.emit('log',{level:'info', msg:'a consumer connected and authenticated', name:consumer.name, id:consumer.id})
|
|
this.emit('connection:consumer',{state:'connected', msg:`consumer ${(consumer.data ||{}).name} connected and authenticated to socket ${this.id}`,
|
|
name:(consumer.data ||{}).name ||(consumer.data ||{}).id || consumer.sid,
|
|
sid:consumer.sid,
|
|
data:consumer.data,
|
|
authenticated:consumer.authenticated
|
|
})
|
|
|
|
// that's it. Connection is active
|
|
|
|
async function messageProcess(consumer, packet) {
|
|
log.debug({method:'_listen', line:179, packet: packet, consumer:consumer.data, msg:'incoming packet on socket side'})
|
|
let res = (await this._packetProcess(clone(packet))) || {}
|
|
if (Object.keys(res).length === 0)
|
|
res = {
|
|
error:
|
|
'socket packet command function likely did not return a promise',
|
|
packet: packet
|
|
}
|
|
if (packet) {
|
|
res._header = clone(packet._header, false) || {} //make sure return packet has header with id in case it was removed in processing
|
|
delete packet._header // remove before adding to response header as request
|
|
} else res._header = {}
|
|
res._header.request = clone(packet, false)
|
|
res._header.responder = { name: this.name, instanceID: this.id }
|
|
res._header.socket = this.address()
|
|
if (!res.cmd) res.cmd = this.defaultReturnCmd || 'reply' // by default return command is 'reply'
|
|
let [err] = await btc(this._send)(consumer,res)
|
|
if (err) log.error({msg:err, error:err})
|
|
} // end message process
|
|
|
|
} // end listen
|
|
|
|
// call when socket server is going down
|
|
async _destroy() {
|
|
log.fatal({method:'_destroy', line:217, msg:'closing down socket server'})
|
|
// this.push()
|
|
clearInterval(this._ping)
|
|
await this.close()
|
|
this.consumers.forEach(consumer => {
|
|
consumer.removeAllListeners()
|
|
consumer.stream.removeAllListeners()
|
|
})
|
|
log.debug({method:'_destroy', line:219, msg:'all connections closed....exiting'})
|
|
process.exit()
|
|
}
|
|
|
|
// default packet process, just a simple echo, override with registerPacketProcessor
|
|
async _packetProcess(packet) {
|
|
return new Promise(resolve => {
|
|
resolve(packet)
|
|
})
|
|
}
|
|
|
|
async _send(consumer, packet) {
|
|
log.trace({msg:`sending to consumer:${consumer.sid}:${consumer.data.name}`, consumer:consumer.data, packet:packet})
|
|
return new Promise(async (resolve, reject) => {
|
|
if (!consumer.writable) {
|
|
reject('socket stream closed can not send packet')
|
|
return
|
|
}
|
|
let [err,ser] = await btc(consumer.stream.serialize)(packet)
|
|
if (err) reject('unable to serialze the packet')
|
|
const cb = () => resolve('packet written to socket stream')
|
|
if (!consumer.write(ser)) {
|
|
consumer.once('drain', cb)
|
|
} else {
|
|
process.nextTick(cb)
|
|
}
|
|
|
|
})
|
|
}
|
|
} // end class
|
|
|
|
} // end function makeSocketClass
|