@fabrix/spool-broadcast
Version:
Spool: broadcast for Fabrix to implement CQRS and Event Sourcing
273 lines • 12.4 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const index_1 = require("./utils/index");
const Client_1 = require("./Client");
const BroadcastObjectModel_1 = require("./BroadcastObjectModel");
const rabbot_1 = __importDefault(require("rabbot"));
exports.broadcaster = {
configure: (app) => {
if (app.config.get('log.level') === 'silly') {
rabbot_1.default.log({ level: 'debug', stream: process.stdout });
}
exports.broadcaster.registerOnUnhandled(app, rabbot_1.default);
exports.broadcaster.registerOnReturned(app, rabbot_1.default);
return;
},
registerOnUnhandled(app, _rabbit) {
_rabbit.onUnhandled(function (message) {
index_1.utils.onUnhandled(app, message);
});
return _rabbit;
},
registerOnReturned(app, _rabbit) {
_rabbit.onReturned(function (message) {
index_1.utils.onReturned(app, message);
});
return _rabbit;
},
addModelHooks: (app) => {
Object.keys(app.models).forEach(k => {
const model = app.models[k];
if (model instanceof BroadcastObjectModel_1.BroadcastObjectModel) {
model.instance.addHook('afterSave', 'isReloaded', (obj, options) => {
obj.isReloaded = true;
return obj;
});
}
});
return;
},
copyDefaults: (app) => {
app.config.set('broadcastDefaults', lodash_1.clone(app.config.get('broadcast')));
return Promise.resolve({});
},
buildBroadcaster: (app) => {
let broadcasterConfig = app.config.get('broadcast');
if (broadcasterConfig.enabled === false) {
return Promise.resolve();
}
const profileName = app.config.get('broadcast.profile');
const profile = index_1.utils.getWorkerProfile(profileName, broadcasterConfig);
broadcasterConfig = index_1.utils.configureExchangesAndQueues(profile, broadcasterConfig);
app.spools.broadcast.broadcaster = new Client_1.Client(app, rabbot_1.default, broadcasterConfig);
return index_1.utils.registerBroadcasts(app, rabbot_1.default, profile, broadcasterConfig);
},
addBroadcasts: (app) => {
let broadcasterConfig = app.config.get('broadcast');
if (broadcasterConfig.enabled === false) {
return Promise.resolve();
}
rabbot_1.default.configure(broadcasterConfig);
return Promise.resolve();
},
discoverChannels: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.channels || {}).forEach(p => {
if (app.channels[p] && app.channels[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.channels[p].name} channel to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addChannel(app.channels[p]);
}
});
});
return Promise.resolve();
},
discoverPipelines: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.pipelines || {}).forEach(p => {
if (app.pipelines[p] && app.pipelines[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.pipelines[p].name} pipeline to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addPipeline(app.pipelines[p]);
}
});
});
return Promise.resolve();
},
discoverHooks: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.hooks || {}).forEach(p => {
if (app.hooks[p] && app.hooks[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.hooks[p].name} hook to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addHookIn(app.hooks[p]);
}
});
});
return Promise.resolve();
},
discoverProcessors: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.processors || {}).forEach(p => {
if (app.processors[p] && app.processors[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.processors[p].name} processor to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addProcessor(app.processors[p]);
}
});
});
return Promise.resolve();
},
discoverDispatchers: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.dispatchers || {}).forEach(p => {
if (app.dispatchers[p] && app.dispatchers[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.dispatchers[p].name} dispatcher to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addDispatcher(app.dispatchers[p]);
}
});
});
return Promise.resolve();
},
discoverProjectors: (app) => {
Object.keys(app.broadcasts || {}).forEach(r => {
Object.keys(app.projectors || {}).forEach(p => {
if (app.projectors[p] && app.projectors[p].hasBroadcaster(app.broadcasts[r])) {
app.log.debug(`Adding ${app.projectors[p].name} projection to ${app.broadcasts[r].name} broadcaster`);
app.broadcasts[r].addProjector(app.projectors[p]);
}
});
});
return Promise.resolve();
},
makeChannelMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.channelMap.set(app.broadcasts[bk].constructor.name, new Map());
const channels = app.broadcasts[bk].channels();
channels.forEach(channel => {
app.spools.broadcast.channelMap.get(app.broadcasts[bk].constructor.name).set(channel.name, channel.subscribers);
});
});
return app.spools.broadcast.channelMap;
},
makePipelineMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.pipelineMap.set(app.broadcasts[bk].constructor.name, app.broadcasts[bk].pipes());
});
return app.spools.broadcast.pipelineMap;
},
makeProjectorMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.projectorMap.set(app.broadcasts[bk].constructor.name, new Map());
const projectors = app.broadcasts[bk].projectors();
projectors.forEach(projector => {
app.spools.broadcast.projectorMap.get(app.broadcasts[bk].constructor.name).set(projector.name, projector.managers);
});
});
return app.spools.broadcast.projectorMap;
},
makeProcessorMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.processorMap.set(app.broadcasts[bk].constructor.name, new Map());
const processors = app.broadcasts[bk].processors();
processors.forEach(processor => {
app.spools.broadcast.processorMap.get(app.broadcasts[bk].constructor.name).set(processor.name, processor.managers);
});
});
return app.spools.broadcast.processorMap;
},
makeDispatcherMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.dispatcherMap.set(app.broadcasts[bk].constructor.name, new Map());
const dispatchers = app.broadcasts[bk].dispatchers();
dispatchers.forEach(dispatcher => {
app.spools.broadcast.dispatcherMap.get(app.broadcasts[bk].constructor.name).set(dispatcher.name, dispatcher.managers);
});
});
return app.spools.broadcast.dispatcherMap;
},
makeHookMap: (app) => {
Object.keys((app.broadcasts || {})).forEach(bk => {
app.spools.broadcast.hookMap.set(app.broadcasts[bk].constructor.name, new Map());
const hooks = app.broadcasts[bk].hooks();
hooks.forEach(hook => {
app.spools.broadcast.hookMap.get(app.broadcasts[bk].constructor.name).set(hook.name, hook.handlers);
});
});
return app.spools.broadcast.hookMap;
},
makeBroadcastChannelResources: (app) => {
Object.keys(app.channels).forEach((value, key) => {
const channel = app.channels[value];
const broadcasters = channel.broadcasters;
if (channel) {
channel.initialize();
channel._channel = app.sockets.on('connection', function (spark) {
spark.on('disconnection', function (data) {
channel.disonnect(spark, data);
});
spark.on('data', function (data) {
if (data
&& data.channel
&& data.subscribe
&& data.subscribe.length > 0
&& data.channel === channel.name) {
const _channel = data.channel;
const subscribe = data.subscribe;
const _rooms = subscribe.map(ev => {
return `${_channel}.${ev}`;
});
_rooms.forEach(room => {
if (spark.rooms().includes(room)) {
}
else {
spark.join(room, function () {
channel.subscribed(spark, room);
});
}
});
spark.write({
subscribed: spark.rooms()
});
}
else if (data
&& data.channel
&& data.unsubscribe
&& data.unsubscribe.length > 0
&& data.channel === channel.name) {
const _channel = data.channel;
const unsubscribe = data.unsubscribe;
const _rooms = unsubscribe.map(ev => {
return `${_channel}.${ev}`;
});
_rooms.forEach(room => {
if (spark.rooms().includes(room)) {
spark.leave(room, function () {
channel.unsubscribed(spark, room);
});
}
else {
}
});
spark.write({
unsubscribed: _rooms,
subscribed: spark.rooms()
});
}
});
});
}
});
return Promise.resolve();
},
shutdownBroadcaster: (app) => {
let broadcasterConfig = app.config.get('broadcast');
if (broadcasterConfig.enabled === false) {
return Promise.resolve();
}
app.log.debug('still active, need to move to interrupt', app.broadcaster.active_broadcasts);
const active = [];
app.broadcaster.active_broadcasts.forEach((value, key, map) => {
value.forEach((projector) => {
if (projector && projector.message && projector.message.interrupt) {
active.push(projector.message.interupt());
}
});
});
return Promise.all(active)
.then(res => {
return rabbot_1.default.shutdown();
});
},
};
//# sourceMappingURL=broadcaster.js.map