120 lines
3.5 KiB
JavaScript
120 lines
3.5 KiB
JavaScript
|
|
import WebSocket from 'ws'
|
|
import btc from 'better-try-catch'
|
|
import _ON_DEATH from 'death' //this is intentionally ugly
|
|
import clone from 'clone'
|
|
|
|
import logger from '@uci/logger'
|
|
let log = {}
|
|
|
|
export default class Socket extends WebSocket.Server {
|
|
constructor (opts = {}) {
|
|
opts.host = opts.host || '0.0.0.0'
|
|
opts.port = opts.port || 8080
|
|
super(opts)
|
|
this.id = opts.id || opts.name || 'Websocket:'+ new Date().getTime()
|
|
this.opts = opts // for use to recover from selected errors
|
|
//self bindings
|
|
this._listen = this._listen.bind(this)
|
|
this.create = this.create.bind(this)
|
|
log = logger.child(
|
|
{
|
|
repo:'uci-websocket',
|
|
npm:'@uci/websocket',
|
|
file:'src/socket.mjs',
|
|
class:'Socket',
|
|
id:this.id,
|
|
instance_created:new Date().getTime()
|
|
})
|
|
|
|
} // end constructor
|
|
|
|
async create () {
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
_ON_DEATH( async () => {
|
|
log.info('\nhe\'s dead jim')
|
|
await this._destroy()
|
|
})
|
|
process.once('SIGUSR2', async () => {
|
|
await this._destroy
|
|
process.kill(process.pid, 'SIGUSR2')
|
|
})
|
|
|
|
this.on('error', async (err) => {
|
|
log.fatal(err, 'socket server error')
|
|
console.error(err, 'socket server error')
|
|
reject(err)
|
|
})
|
|
|
|
this.on('listening', async () => {
|
|
this._listen()
|
|
log.info('websocket server created and listening at', this.address())
|
|
resolve('websocket ready and listening')
|
|
})
|
|
|
|
})
|
|
|
|
} // end create
|
|
|
|
registerPacketProcessor (func) {
|
|
this._packetProcess = func
|
|
}
|
|
|
|
_listen () {
|
|
|
|
this.on('connection', async (socket) => {
|
|
const send = this._send.bind(socket)
|
|
log.info('new consumer connecting')
|
|
socket.on('message', messageProcess.bind(this))
|
|
|
|
async function messageProcess (strPacket) {
|
|
log.info(' incoming packet on socket side')
|
|
let res = {}
|
|
let [err, packet] = btc(JSON.parse)(strPacket)
|
|
if (err) { res = {error: `Could not parse JSON: ${packet}`} }
|
|
else {
|
|
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}
|
|
}
|
|
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
|
|
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 = 'reply' // by default return command is 'reply'
|
|
log.info(await send(res))
|
|
}
|
|
|
|
}) // end connected consumer
|
|
log.info('socket created')
|
|
} // end listen
|
|
|
|
async _destroy () {
|
|
log.info('closing down socket')
|
|
await this.close()
|
|
log.info('all connections closed....exiting')
|
|
process.exit()
|
|
}
|
|
|
|
// default packet process, just a simple echo - replace
|
|
async _packetProcess (packet) {
|
|
return new Promise(resolve => {
|
|
resolve(packet)
|
|
})
|
|
}
|
|
|
|
// must have a consumer socket instance bound to call this!!
|
|
async _send (packet) {
|
|
return new Promise( (resolve,reject) => {
|
|
if (this.readyState !== 1 ) reject (`Connection not Ready, CODE:${this.readyState}`)
|
|
let [err,message] = btc(JSON.stringify)(packet)
|
|
if (err) reject(`Could not JSON stringify: ${packet}`)
|
|
this.send(message)
|
|
resolve('sent packet', packet)
|
|
})
|
|
}
|
|
|
|
} // end class
|