'use strict';
|
|
const co = require('co');
|
const util = require('util');
|
const is = require('is-type-of');
|
const assert = require('assert');
|
const awaitEvent = require('await-event');
|
const awaitFirst = require('await-first');
|
const EventEmitter = require('events').EventEmitter;
|
const CLOSE_PROMISE = Symbol('base#closePromise');
|
|
class Base extends EventEmitter {
|
constructor(options) {
|
super();
|
|
if (options && options.initMethod) {
|
assert(is.function(this[options.initMethod]),
|
`[sdk-base] this.${options.initMethod} should be a function.`);
|
|
process.nextTick(() => {
|
if (is.generatorFunction(this[options.initMethod])) {
|
this[options.initMethod] = co.wrap(this[options.initMethod]);
|
}
|
const ret = this[options.initMethod]();
|
assert(is.promise(ret), `[sdk-base] this.${options.initMethod} should return either a promise or a generator`);
|
ret.then(() => this.ready(true))
|
.catch(err => this.ready(err));
|
});
|
}
|
this.options = options || {};
|
this._ready = false;
|
this._readyError = null;
|
this._readyCallbacks = [];
|
this._closed = false;
|
|
// support `yield this.await('event')`
|
this.await = awaitEvent;
|
this.awaitFirst = awaitFirst;
|
|
this.on('error', err => { this._defaultErrorHandler(err); });
|
}
|
|
_wrapListener(eventName, listener) {
|
if (is.generatorFunction(listener)) {
|
assert(eventName !== 'error', '[sdk-base] `error` event should not have a generator listener.');
|
|
const newListener = (...args) => {
|
co(function* () {
|
yield listener(...args);
|
}).catch(err => {
|
err.name = 'EventListenerProcessError';
|
this.emit('error', err);
|
});
|
};
|
newListener.original = listener;
|
return newListener;
|
}
|
return listener;
|
}
|
|
addListener(eventName, listener) {
|
return super.addListener(eventName, this._wrapListener(eventName, listener));
|
}
|
|
on(eventName, listener) {
|
return super.on(eventName, this._wrapListener(eventName, listener));
|
}
|
|
once(eventName, listener) {
|
return super.once(eventName, this._wrapListener(eventName, listener));
|
}
|
|
prependListener(eventName, listener) {
|
return super.prependListener(eventName, this._wrapListener(eventName, listener));
|
}
|
|
prependOnceListener(eventName, listener) {
|
return super.prependOnceListener(eventName, this._wrapListener(eventName, listener));
|
}
|
|
removeListener(eventName, listener) {
|
let target = listener;
|
if (is.generatorFunction(listener)) {
|
const listeners = this.listeners(eventName);
|
for (const fn of listeners) {
|
if (fn.original === listener) {
|
target = fn;
|
break;
|
}
|
}
|
}
|
return super.removeListener(eventName, target);
|
}
|
|
/**
|
* detect sdk start ready or not
|
* @return {Boolean} ready status
|
*/
|
get isReady() {
|
return this._ready;
|
}
|
|
/**
|
* set ready state or onready callback
|
*
|
* @param {Boolean|Error|Function} flagOrFunction - ready state or callback function
|
* @return {void|Promise} ready promise
|
*/
|
ready(flagOrFunction) {
|
if (arguments.length === 0) {
|
// return a promise
|
// support `this.ready().then(onready);` and `yield this.ready()`;
|
return new Promise((resolve, reject) => {
|
if (this._ready) {
|
return resolve();
|
} else if (this._readyError) {
|
return reject(this._readyError);
|
}
|
this._readyCallbacks.push(err => {
|
if (err) {
|
reject(err);
|
} else {
|
resolve();
|
}
|
});
|
});
|
} else if (is.function(flagOrFunction)) {
|
this._readyCallbacks.push(flagOrFunction);
|
} else if (flagOrFunction instanceof Error) {
|
this._ready = false;
|
this._readyError = flagOrFunction;
|
if (!this._readyCallbacks.length) {
|
this.emit('error', flagOrFunction);
|
}
|
} else {
|
this._ready = flagOrFunction;
|
}
|
|
if (this._ready || this._readyError) {
|
this._readyCallbacks.splice(0, Infinity).forEach(callback => {
|
process.nextTick(() => {
|
callback(this._readyError);
|
});
|
});
|
}
|
}
|
|
_defaultErrorHandler(err) {
|
if (this.listeners('error').length > 1) {
|
// ignore defaultErrorHandler
|
return;
|
}
|
console.error('\n[%s][pid: %s][%s] %s: %s \nError Stack:\n %s',
|
Date(), process.pid, this.constructor.name, err.name,
|
err.message, err.stack);
|
|
// try to show addition property on the error object
|
// e.g.: `err.data = {url: '/foo'};`
|
const additions = [];
|
for (const key in err) {
|
if (key === 'name' || key === 'message') {
|
continue;
|
}
|
|
additions.push(util.format(' %s: %j', key, err[key]));
|
}
|
if (additions.length) {
|
console.error('Error Additions:\n%s', additions.join('\n'));
|
}
|
console.error();
|
}
|
|
close() {
|
if (this._closed) {
|
return Promise.resolve();
|
}
|
if (this[CLOSE_PROMISE]) {
|
return this[CLOSE_PROMISE];
|
}
|
if (!this._close) {
|
this._closed = true;
|
return Promise.resolve();
|
}
|
let closeFunc = this._close;
|
if (is.generatorFunction(closeFunc)) {
|
closeFunc = co.wrap(closeFunc);
|
}
|
this[CLOSE_PROMISE] = closeFunc.apply(this);
|
assert(is.promise(this[CLOSE_PROMISE]), '[sdk-base] this._close should return either a promise or a generator');
|
return this[CLOSE_PROMISE]
|
.then(() => {
|
this._closed = true;
|
})
|
.catch(err => {
|
this._closed = true;
|
this.emit('error', err);
|
});
|
}
|
}
|
|
module.exports = Base;
|
// support es module
|
module.exports.default = Base;
|
