// 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.clientTracking track connected clients 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 ? opts.pingInterval : (opts.pingInterval * 1000 || 5000) this.clients = [] // track consumers (i.e. clients) TODO use a Map this.nextClientID = 0 // incrementer for default initial client ID this.opts = opts // for use to recover from selected errors this.errorCount = 0 //self bindings this.create = this.create.bind(this) this.authenticateClient = this.authenticateClient.bind(this) this._authenticate = this._authenticate.bind(this) this.close = promisify(this.close).bind(this) log = logger({ file: 'src/socket.js', class: 'Socket', name: 'socket', id: this.id }) } // end constructor /** * 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:'warning',msg:'something bad maybe going on, 3 errors', errors:this.errors} this.emit('status', 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.emit('status', errors) } }) log.info({method:'create', line:54, msg:'socket server created and listening at', address:this.address()}) this.on('connection', this._connectionHandler.bind(this)) resolve(`socket ready and listening at ${this.address().address}:${this.address().port}`) }) 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.clients.length > 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 clients * * @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.clients.length > 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.clients.forEach(async client => { if (client.writable) { let [err] = await btc(this._send)(client,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'}) } } // TODO won't need this if moving to a Map getClientIndex(id) { return this.clients.findIndex(client => {return client.id === id }) } getClient(id) { return this.clients[this._getClientIndex(id)] } removeClient (id) { let index = this.getClientIndex(id) let client=this.clients[index] this.emit('consumer-connection',{state:'disconnected', id:client.id, name:client.name, socketSide:true}) client.removeAllListeners() client.stream.removeAllListeners() this.clients.splice(index,1) log.warn({msg:'client removed from tracking',id:id, curClientCount:this.clients.length}) } async authenticateClient(client) { // let server = this return new Promise(async function(resolve, reject) { // when consumer gets the handshake they must follow with authentication client.stream.on('message', authenticate.bind(this,client)) let [err] = await btc(this._send)(client,{_handshake: true, id:client.id}) if (err) { log.error({msg:'error in handshake send', error:err}) reject(err) } async function authenticate (client,packet) { log.debug({msg:`authentication packet from client ${client.id}`, packet:packet}) client.stream.removeAllListeners('message') if (!packet._authenticate) reject('first client packet was not authentication') else { let [err, res] = await btc(this._authenticate)(packet) client.authenticated = this.allowAnonymous ? 'anonymous' : (err ? false : res) client.name = packet.clientName packet.authenticated = client.authenticated packet.reason = err || null log.debug({msg:'sending authorization result to client', packet:packet}) await this._send(client,packet) // send either way if (err && !this.allowAnonymous) { log.info({msg:'client authentication failed', client:client.name, client_id:client.id, reason:err}) reject(packet.reason) } else { log.info({msg:'client authenticated successfuly', client:client.name, client_id:client.id}) if (this.allowAnonymous) log.warn({msg:'client connected anonymously', client:client.name, client_id:client.id}) resolve(client.authenticated) } } } }.bind(this)) } // 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 client async _authenticate (packet) { if (!this._validateToken(packet.token)) return Promise.reject('invalid token') return true } async _connectionHandler(consumer) { // this gets called for each client connection and is unique to each consumer.id = ++this.nextClientID // server assigned ID log.debug({method:'_listen', line:167, msg:'new consumer connecting', id:consumer.id, totalConsumers:this.clients.length}) consumer.socketSide = true consumer.authenticated = false this.clients.push(consumer) // add client to list const stream = new JSONStream() consumer.stream = stream console.log('new consumer connecting', consumer.id, this.clients.length) consumer.setKeepAlive(this.keepAlive,3000) // add listeners const clientCloseHandler = (id) => { log.warn({msg:'client connection closed during listen,',id:id}) this.removeClient(id) } consumer.on('close', clientCloseHandler.bind(this,consumer.id) ) consumer.on('error', (err) => { log.error({msg:'client connection error during listen',error:err}) // TODO do more handling than just logging }) 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 }) let [err] = await btc(this.authenticateClient)(consumer) if (!this.allowAnonymous) { if (err) { consumer.end()// abort new connection consumer, cleanup, remove listeners this.removeClient(consumer.id) return } } // all's set main 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('consumer-connection',{state:'connected', id:consumer.id, name:consumer.name, socketSide:true}) this.emit('status',{level:'info', msg:'a consumer connected', name:consumer.name, id:consumer.id}) // that's it. Connection is active async function messageProcess(client, packet) { log.debug({method:'_listen', line:179, packet: packet, client:client.name, 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)(client,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.clients.forEach(client => { client.removeAllListeners() client.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(client, packet) { log.trace({msg:`sending to client:${client.id}`, packet:packet}) return new Promise(async (resolve, reject) => { let [err,ser] = await btc(client.stream.serialize)(packet) if (err) reject('unable to serialze the packet') const cb = () => resolve('packet written to socket stream') if (!client.write(ser)) { client.once('drain', cb) } else { process.nextTick(cb) } }) } } // end class } // end function makeSocketClass