@allgemein/eventbus
Version:
139 lines • 4.55 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisEventBusAdapter = void 0;
const AbstractEventBusAdapter_1 = require("../AbstractEventBusAdapter");
const RedisObject_1 = require("./RedisObject");
const logging_1 = require("@allgemein/logging");
const Serializer_1 = require("../../utils/Serializer");
const lodash_1 = require("lodash");
class RedisEventBusAdapter extends AbstractEventBusAdapter_1.AbstractEventBusAdapter {
constructor(nodeId, name, clazz, options) {
super(nodeId, name, clazz, options);
this._connecting = false;
this._ready = false;
this._subscribed = false;
this.loadDependencies();
this.getEmitter().on('connect', this.connect.bind(this));
}
async connect() {
if (!this._connecting) {
this._connecting = true;
}
else {
return;
}
const sub = this.getSubscriber();
await sub.open();
this.getEmitter().emit('ready');
this._ready = true;
}
async open() {
if (!this._connecting) {
this.getEmitter().emit('connect');
}
if (this._ready) {
return null;
}
return new Promise((resolve, reject) => {
this.getEmitter().once('ready', resolve);
});
}
loadDependencies() {
try {
if (!RedisEventBusAdapter.Reader && !RedisEventBusAdapter.Writer) {
require('redis');
RedisEventBusAdapter.Reader = require('./RedisReader').RedisReader;
RedisEventBusAdapter.Writer = require('./RedisWriter').RedisWriter;
}
}
catch (err) {
const msg = 'EventBus adapter redis can\'t be loaded, because modul redis is not installed. :(';
logging_1.Logger.warn(msg);
throw new Error(msg);
}
}
getSubscriber() {
if (this.reader) {
return this.reader;
}
this.reader = Reflect.construct(RedisEventBusAdapter.Reader, [this.name, this.nodeId, this.options.extra]);
try {
this.reader.subscribe(this.onMessage.bind(this));
}
catch (err) {
throw err;
}
return this.reader;
}
async getPublisher() {
if (this.writer && this.writer.isOpened()) {
return this.writer;
}
this.writer = Reflect.construct(RedisEventBusAdapter.Writer, [this.options.extra]);
try {
await this.writer.open();
}
catch (err) {
throw err;
}
return this.writer;
}
onMessage(message) {
const data = message.message;
if ((0, lodash_1.has)(data, 'status')) {
if (data.status === 'work') {
this.getEmitter().emit(this.eventID(), data.uuid, data);
}
else if (data.status === 'done') {
this.getEmitter().emit([this.eventID(), data.uuid, 'done'].join('_'), data.error, data.result);
}
}
else if ((0, lodash_1.has)(data, 'source')) {
}
}
isSubscribed() {
return this._subscribed;
}
async publish(object) {
await this.open();
const obj = new RedisObject_1.RedisObject(this, this.eventID(), object);
await obj.fire();
return obj;
}
unsubscribe() {
this.getEmitter().removeAllListeners(this.eventID());
this._subscribed = false;
}
async subscribe(fn) {
await this.open();
this._subscribed = true;
this.getEmitter().on(this.eventID(), async (uuid, data) => {
let res = null;
let err = null;
try {
res = await fn(data.object);
}
catch (err2) {
err = err2;
}
const writer = await this.getPublisher();
const _msp = {
source: this.nodeId,
dest: data.source,
status: 'done',
uuid: uuid,
event: data.event,
result: res,
error: err
};
const msg = {
topic: this.name,
message: Serializer_1.Serializer.serialize(_msp)
};
await writer.publish(msg, data.source);
});
}
}
exports.RedisEventBusAdapter = RedisEventBusAdapter;
RedisEventBusAdapter.ADAPTER_NAME = 'redis';
//# sourceMappingURL=RedisEventBusAdapter.js.map