@bazilio-san/af-stream
Version:
Data stream from database table
159 lines • 6.47 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint-disable class-methods-use-this,no-await-in-loop */
const socket_io_client_1 = require("socket.io-client");
const utils_1 = require("../utils/utils");
const AbstractSender_1 = require("./AbstractSender");
const color_1 = require("../utils/color");
const AWAIT_SOCKET_TIMEOUT = 10000;
const LOOP_SLEEP_MILLIS = 1000;
class WSSender extends AbstractSender_1.default {
constructor(options) {
super(options);
this.lastConfigServiceAddress = '';
const { senderConfig, eventEmitter } = options;
const { host, port } = senderConfig;
const ap = senderConfig.accessPoint;
this.address = `http://${host}:${port}`;
this.mConsulServiceName = `${color_1.cyan}${ap.consulServiceName}${color_1.reset}`;
this.socketClient = null;
this.accessPointId = ap.id;
this.token = ap.token;
this.socketRequestId = ap.socketRequestId;
eventEmitter.on('access-point-updated', ({ accessPoint }) => {
if (accessPoint.id === this.accessPointId) {
this.reconnect().then(() => 0);
}
});
this.reconnect().then(() => 0);
}
isConnected() {
var _a, _b;
return Boolean(((_a = this.socketClient) === null || _a === void 0 ? void 0 : _a.emit) && ((_b = this.socketClient) === null || _b === void 0 ? void 0 : _b.connected));
}
async connect() {
const { address, mConsulServiceName, token, options } = this;
const { echo, logger, serviceName } = options;
const mAddress = `${color_1.lBlue}${address}${color_1.reset}`;
echo.info(`Connect to ${color_1.cyan}WEB SOCKET${color_1.reset} on ${color_1.lBlue}${address}${color_1.reset}`);
const opt = {
query: { fromService: serviceName },
auth: { token },
extraHeaders: { authorization: token },
};
const socketClient = (0, socket_io_client_1.io)(address, opt);
this.socketClient = socketClient;
return new Promise((resolve) => {
socketClient.on('connect', () => {
echo.info(`
====================== Web Socket Sender =======================
Connection established with WEBSOCKET ${mConsulServiceName} on ${mAddress}
================================================================`);
resolve(true);
});
socketClient.on('unauthorized', (reason, callback) => {
logger.error(`Error on "unauthorized" event while connecting to config service via socket. Reason: ${reason}`);
resolve(false);
callback();
});
socketClient.on('disconnect', () => {
logger.warn(`Config service instance ${mConsulServiceName} disconnected`);
resolve(false);
});
socketClient.on('error', (err) => {
logger.error(err);
resolve(false);
});
});
}
async reconnect(force) {
const { options: { senderConfig: { port, host } }, lastConfigServiceAddress } = this;
if (!host || !port) {
return this.isConnected();
}
const address = `http://${host}:${port}`;
if (force || (lastConfigServiceAddress !== address)) {
this.lastConfigServiceAddress = address;
this.address = address;
return this.connect();
}
return false;
}
async awaitSocket() {
if (this.isConnected()) {
return true;
}
const { logger } = this.options;
const start = Date.now();
while (!this.isConnected() && (Date.now() - start < AWAIT_SOCKET_TIMEOUT)) {
if (Date.now() - start < LOOP_SLEEP_MILLIS) {
logger.silly('Try to connect to the socket...');
}
else {
logger.warn('Socket is not still connected...');
}
await this.reconnect(true);
await (0, utils_1.sleep)(LOOP_SLEEP_MILLIS);
}
return this.isConnected();
}
async remoteSocket(rqId, ...args) {
const self = this;
const { logger } = this.options;
const error = `NOT connected to the socket. Request id: ${rqId}`;
if (await this.awaitSocket()) {
return new Promise((resolve) => {
var _a;
if (!self.isConnected()) {
logger.error(error);
resolve({ error });
return;
}
args.push((a) => {
resolve(a);
});
(_a = this.socketClient) === null || _a === void 0 ? void 0 : _a.emit(rqId, ...args);
});
}
return { error };
}
async sendEvents(recordsComposite) {
const MAX_PACKET_SIZE = 100; // Max number of events in a batch
const { eventsPacket, first } = recordsComposite;
if (!eventsPacket.length) {
return false;
}
const { logger } = this.options;
let stop = false;
recordsComposite.sentBufferLength = 0;
recordsComposite.sendCount = 0;
recordsComposite.last = first;
while (!stop && eventsPacket.length > 0) {
const packet = eventsPacket.splice(0, MAX_PACKET_SIZE);
const pl = packet.length;
if (pl) {
/*
// receiving side signature:
socket.on(socketRequestId, (request, callback) => {
callback({ result: true });
});
*/
const { error, result } = await this.remoteSocket(this.socketRequestId, packet);
stop = !result;
if (stop) {
if (error) {
logger.error(error);
}
eventsPacket.splice(0, 0, ...packet);
}
else {
recordsComposite.sendCount += pl;
recordsComposite.last = packet[pl - 1];
}
}
}
return true;
}
}
exports.default = WSSender;
//# sourceMappingURL=WSSender.js.map