overleaf/services/real-time/app/js/WebsocketLoadBalancer.js

/* eslint-disable
    camelcase,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS205: Consider reworking code to avoid use of IIFEs
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
let WebsocketLoadBalancer;
const Settings = require('settings-sharelatex');
const logger = require('logger-sharelatex');
const RedisClientManager = require("./RedisClientManager");
const SafeJsonParse = require("./SafeJsonParse");
const EventLogger = require("./EventLogger");
const HealthCheckManager = require("./HealthCheckManager");
const RoomManager = require("./RoomManager");
const ChannelManager = require("./ChannelManager");
const ConnectedUsersManager = require("./ConnectedUsersManager");

const RESTRICTED_USER_MESSAGE_TYPE_PASS_LIST = [
	'connectionAccepted',
	'otUpdateApplied',
	'otUpdateError',
	'joinDoc',
	'reciveNewDoc',
	'reciveNewFile',
	'reciveNewFolder',
	'removeEntity'
];

module.exports = (WebsocketLoadBalancer = {
	rclientPubList: RedisClientManager.createClientList(Settings.redis.pubsub),
	rclientSubList: RedisClientManager.createClientList(Settings.redis.pubsub),

	emitToRoom(room_id, message, ...payload) {
		if ((room_id == null)) {
			logger.warn({message, payload}, "no room_id provided, ignoring emitToRoom");
			return;
		}
		const data = JSON.stringify({
			room_id,
			message,
			payload
		});
		logger.log({room_id, message, payload, length: data.length}, "emitting to room");

		return Array.from(this.rclientPubList).map((rclientPub) =>
			ChannelManager.publish(rclientPub, "editor-events", room_id, data));
	},

	emitToAll(message, ...payload) {
		return this.emitToRoom("all", message, ...Array.from(payload));
	},

	listenForEditorEvents(io) {
		logger.log({rclients: this.rclientPubList.length}, "publishing editor events");
		logger.log({rclients: this.rclientSubList.length}, "listening for editor events");
		for (const rclientSub of Array.from(this.rclientSubList)) {
			rclientSub.subscribe("editor-events");
			rclientSub.on("message", function(channel, message) {
				if (Settings.debugEvents > 0) { EventLogger.debugEvent(channel, message); }
				return WebsocketLoadBalancer._processEditorEvent(io, channel, message);
			});
		}
		return this.handleRoomUpdates(this.rclientSubList);
	},

	handleRoomUpdates(rclientSubList) {
		const roomEvents = RoomManager.eventSource();
		roomEvents.on('project-active', function(project_id) {
			const subscribePromises = Array.from(rclientSubList).map((rclient) =>
				ChannelManager.subscribe(rclient, "editor-events", project_id));
			return RoomManager.emitOnCompletion(subscribePromises, `project-subscribed-${project_id}`);
		});
		return roomEvents.on('project-empty', project_id => Array.from(rclientSubList).map((rclient) =>
            ChannelManager.unsubscribe(rclient, "editor-events", project_id)));
	},

	_processEditorEvent(io, channel, message) {
		return SafeJsonParse.parse(message, function(error, message) {
			let clientList;
			let client;
			if (error != null) {
				logger.error({err: error, channel}, "error parsing JSON");
				return;
			}
			if (message.room_id === "all") {
				return io.sockets.emit(message.message, ...Array.from(message.payload));
			} else if ((message.message === 'clientTracking.refresh') && (message.room_id != null)) {
				clientList = io.sockets.clients(message.room_id);
				logger.log({channel, message: message.message, room_id: message.room_id, message_id: message._id, socketIoClients: ((() => {
					const result = [];
					for (client of Array.from(clientList)) { 						result.push(client.id);
					}
					return result;
				})())}, "refreshing client list");
				return (() => {
					const result1 = [];
					for (client of Array.from(clientList)) {
						result1.push(ConnectedUsersManager.refreshClient(message.room_id, client.publicId));
					}
					return result1;
				})();
			} else if (message.room_id != null) {
				if ((message._id != null) && Settings.checkEventOrder) {
					const status = EventLogger.checkEventOrder("editor-events", message._id, message);
					if (status === "duplicate") {
						return; // skip duplicate events
					}
				}

				const is_restricted_message = !Array.from(RESTRICTED_USER_MESSAGE_TYPE_PASS_LIST).includes(message.message);

				// send messages only to unique clients (due to duplicate entries in io.sockets.clients)
				clientList = io.sockets.clients(message.room_id)
				.filter(client => !(is_restricted_message && client.ol_context.is_restricted_user));

				// avoid unnecessary work if no clients are connected
				if (clientList.length === 0) { return; }
				logger.log({
					channel,
					message: message.message,
					room_id: message.room_id,
					message_id: message._id,
					socketIoClients: ((() => {
						const result2 = [];
						for (client of Array.from(clientList)) { 							result2.push(client.id);
						}
						return result2;
					})())
				}, "distributing event to clients");
				const seen = {};
				return (() => {
					const result3 = [];
					for (client of Array.from(clientList)) {
						if (!seen[client.id]) {
							seen[client.id] = true;
							result3.push(client.emit(message.message, ...Array.from(message.payload)));
						} else {
							result3.push(undefined);
						}
					}
					return result3;
				})();
			} else if (message.health_check != null) {
				logger.debug({message}, "got health check message in editor events channel");
				return HealthCheckManager.check(channel, message.key);
			}
		});
	}
});