Add sqlite logging and reloading messages

defaults/config.js

@@ -148,6 +148,19 @@ module.exports = {
 	// @default  null
 	webirc: null,
 
+	//
+	// Message logging
+	// Logging is also controlled per user individually (logs variable)
+	// Leave the array empty to disable all logging globally
+	//
+	// text: Text file per network/channel in user folder
+	// sqlite: Messages are stored in SQLite, this allows them to be reloaded on server restart
+	//
+	// @type     array
+	// @default  ["sqlite", "text"]
+	//
+	messageStorage: ["sqlite", "text"],
+
 	//
 	// Log settings
 	//

package.json

@@ -56,9 +56,11 @@
     "semver": "5.5.0",
     "socket.io": "2.0.4",
     "spdy": "3.4.7",
+    "sqlite3": "3.1.13",
     "thelounge-ldapjs-non-maintained-fork": "1.0.2",
     "ua-parser-js": "0.7.17",
     "urijs": "1.19.1",
+    "uuid": "3.2.1",
     "web-push": "3.3.0",
     "yarn": "1.5.1"
   },

src/client.js

@@ -10,6 +10,7 @@ const Network = require("./models/network");
 const ircFramework = require("irc-framework");
 const Helper = require("./helper");
 const UAParser = require("ua-parser-js");
+const MessageStorage = require("./plugins/sqlite");
 
 module.exports = Client;
 
@@ -78,8 +79,16 @@ function Client(manager, name, config = {}) {
 	});
 
 	const client = this;
-
 	let delay = 0;
+
+	if (!Helper.config.public) {
+		client.messageStorage = new MessageStorage();
+
+		if (client.config.log && Helper.config.messageStorage.includes("sqlite")) {
+			client.messageStorage.enable(client.name);
+		}
+	}
+
 	(client.config.networks || []).forEach((n) => {
 		setTimeout(function() {
 			client.connect(n);
@@ -174,6 +183,7 @@ Client.prototype.connect = function(args) {
 	args.hostname = args.hostname || (client.config && client.config.hostname) || client.hostname;
 
 	const network = new Network({
+		uuid: args.uuid,
 		name: args.name || (Helper.config.displayNetwork ? "" : Helper.config.defaults.name) || "",
 		host: args.host || "",
 		port: parseInt(args.port, 10) || (args.tls ? 6697 : 6667),
@@ -261,6 +271,7 @@ Client.prototype.connect = function(args) {
 
 	network.irc.requestCap([
 		"znc.in/self-message", // Legacy echo-message for ZNc
+		"znc.in/playback", // http://wiki.znc.in/Playback
 	]);
 
 	events.forEach((plugin) => {
@@ -273,6 +284,8 @@ Client.prototype.connect = function(args) {
 	network.irc.connect();
 
 	client.save();
+
+	channels.forEach((channel) => channel.loadMessages(client, network));
 };
 
 Client.prototype.generateToken = function(callback) {

src/models/chan.js

@@ -63,11 +63,7 @@ Chan.prototype.pushMessage = function(client, msg, increasesUnread) {
 		return;
 	}
 
-	this.messages.push(msg);
-
-	if (client.config.log === true) {
-		writeUserLog.call(this, client, msg);
-	}
+	this.writeUserLog(client, msg);
 
 	if (Helper.config.maxHistory >= 0 && this.messages.length > Helper.config.maxHistory) {
 		const deleted = this.messages.splice(0, this.messages.length - Helper.config.maxHistory);
@@ -183,21 +179,86 @@ Chan.prototype.getFilteredClone = function(lastActiveChannel, lastMessage) {
 	}, {});
 };
 
-function writeUserLog(client, msg) {
-	if (!msg.isLoggable()) {
-		return false;
+Chan.prototype.writeUserLog = function(client, msg) {
+	this.messages.push(msg);
+
+	// Does this user have logs disabled
+	if (!client.config.log) {
+		return;
+	}
+
+	// Are logs disabled server-wide
+	if (Helper.config.messageStorage.length === 0) {
+		return;
 	}
 
+	// Is this particular message or channel loggable
+	if (!msg.isLoggable() || !this.isLoggable()) {
+		return;
+	}
+
+	// Find the parent network where this channel is in
 	const target = client.find(this.id);
 
 	if (!target) {
-		return false;
+		return;
+	}
+
+	// TODO: Something more pluggable
+	if (Helper.config.messageStorage.includes("sqlite")) {
+		client.messageStorage.index(target.network.uuid, this.name, msg);
+	}
+
+	if (Helper.config.messageStorage.includes("text")) {
+		userLog.write(
+			client.name,
+			target.network.host, // TODO: Fix #1392, multiple connections to same server results in duplicate logs
+			this.type === Chan.Type.LOBBY ? target.network.host : this.name,
+			msg
+		);
 	}
+};
+
+Chan.prototype.loadMessages = function(client, network) {
+	if (!client.messageStorage || !this.isLoggable()) {
+		return;
+	}
+
+	client.messageStorage
+		.getMessages(network, this)
+		.then((messages) => {
+			if (messages.length === 0) {
+				if (network.irc.network.cap.isEnabled("znc.in/playback")) {
+					requestZncPlayback(this, network, 0);
+				}
+
+				return;
+			}
+
+			this.messages.unshift(...messages);
+
+			if (!this.firstUnread) {
+				this.firstUnread = messages[messages.length - 1].id;
+			}
+
+			client.emit("more", {
+				chan: this.id,
+				messages: messages.slice(-100),
+			});
+
+			if (network.irc.network.cap.isEnabled("znc.in/playback")) {
+				const from = Math.floor(messages[messages.length - 1].time.getTime() / 1000);
+
+				requestZncPlayback(this, network, from);
+			}
+		})
+		.catch((err) => log.error(`Failed to load messages: ${err}`));
+};
+
+Chan.prototype.isLoggable = function() {
+	return this.type === Chan.Type.CHANNEL || this.type === Chan.Type.QUERY;
+};
 
-	userLog.write(
-		client.name,
-		target.network.host, // TODO: Fix #1392, multiple connections to same server results in duplicate logs
-		this.type === Chan.Type.LOBBY ? target.network.host : this.name,
-		msg
-	);
+function requestZncPlayback(channel, network, from) {
+	network.irc.raw("ZNC", "*playback", "PLAY", channel.name, from.toString());
 }

src/models/msg.js

@@ -40,6 +40,7 @@ class Msg {
 
 	isLoggable() {
 		return this.type !== Msg.Type.MOTD &&
+			this.type !== Msg.Type.ERROR &&
 			this.type !== Msg.Type.BANLIST &&
 			this.type !== Msg.Type.WHOIS;
 	}

src/models/network.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const _ = require("lodash");
+const uuidv4 = require("uuid/v4");
 const Chan = require("./chan");
 
 module.exports = Network;
@@ -42,6 +43,10 @@ function Network(attr) {
 		chanCache: [],
 	});
 
+	if (!this.uuid) {
+		this.uuid = uuidv4();
+	}
+
 	if (!this.name) {
 		this.name = this.host;
 	}
@@ -125,6 +130,7 @@ Network.prototype.getNetworkStatus = function() {
 
 Network.prototype.export = function() {
 	const network = _.pick(this, [
+		"uuid",
 		"awayMessage",
 		"nick",
 		"name",

src/plugins/inputs/query.js

@@ -54,4 +54,5 @@ exports.input = function(network, chan, cmd, args) {
 		shouldOpen: true,
 	});
 	this.save();
+	newChan.loadMessages(this, network);
 };

src/plugins/irc-events/join.js

@@ -22,6 +22,8 @@ module.exports = function(irc, network) {
 				chan: chan.getFilteredClone(true),
 			});
 
+			chan.loadMessages(client, network);
+
 			// Request channels' modes
 			network.irc.raw("MODE", chan.name);
 		} else if (data.nick === irc.user.nick) {

src/plugins/irc-events/message.js

@@ -72,6 +72,7 @@ module.exports = function(irc, network) {
 						network: network.id,
 						chan: chan.getFilteredClone(true),
 					});
+					chan.loadMessages(client, network);
 				}
 			}
 

src/plugins/irc-events/whois.js

@@ -19,6 +19,7 @@ module.exports = function(irc, network) {
 				network: network.id,
 				chan: chan.getFilteredClone(true),
 			});
+			chan.loadMessages(client, network);
 		}
 
 		let msg;

src/plugins/sqlite.js

@@ -0,0 +1,126 @@
+"use strict";
+
+const path = require("path");
+const fsextra = require("fs-extra");
+const sqlite3 = require("sqlite3");
+const Helper = require("../helper");
+const Msg = require("../models/msg");
+
+const currentSchemaVersion = 1520239200;
+
+const schema = [
+	// Schema version #1
+	"CREATE TABLE IF NOT EXISTS options (name TEXT, value TEXT, CONSTRAINT name_unique UNIQUE (name))",
+	"CREATE TABLE IF NOT EXISTS messages (network TEXT, channel TEXT, time INTEGER, type TEXT, msg TEXT)",
+	"CREATE INDEX IF NOT EXISTS network_channel ON messages (network, channel)",
+	"CREATE INDEX IF NOT EXISTS time ON messages (time)",
+];
+
+class MessageStorage {
+	constructor() {
+		this.isEnabled = false;
+	}
+
+	enable(name) {
+		const logsPath = path.join(Helper.getHomePath(), "logs");
+		const sqlitePath = path.join(logsPath, `${name}.sqlite3`);
+
+		try {
+			fsextra.ensureDirSync(logsPath);
+		} catch (e) {
+			log.error("Unable to create logs directory", e);
+
+			return;
+		}
+
+		this.isEnabled = true;
+
+		this.database = new sqlite3.cached.Database(sqlitePath);
+		this.database.serialize(() => {
+			schema.forEach((line) => this.database.run(line));
+
+			this.database.get("SELECT value FROM options WHERE name = 'schema_version'", (err, row) => {
+				if (err) {
+					return log.error(`Failed to retrieve schema version: ${err}`);
+				}
+
+				// New table
+				if (row === undefined) {
+					this.database.serialize(() => this.database.run("INSERT INTO options (name, value) VALUES ('schema_version', ?)", currentSchemaVersion));
+
+					return;
+				}
+
+				const storedSchemaVersion = parseInt(row.value, 10);
+
+				if (storedSchemaVersion === currentSchemaVersion) {
+					return;
+				}
+
+				if (storedSchemaVersion > currentSchemaVersion) {
+					return log.error(`sqlite messages schema version is higher than expected (${storedSchemaVersion} > ${currentSchemaVersion}). Is The Lounge out of date?`);
+				}
+
+				log.info(`sqlite messages schema version is out of date (${storedSchemaVersion} < ${currentSchemaVersion}). Running migrations if any.`);
+
+				this.database.serialize(() => this.database.run("UPDATE options SET value = ? WHERE name = 'schema_version'", currentSchemaVersion));
+			});
+		});
+	}
+
+	index(network, channel, msg) {
+		if (!this.isEnabled) {
+			return;
+		}
+
+		const clonedMsg = Object.keys(msg).reduce((newMsg, prop) => {
+			// id is regenerated when messages are retrieved
+			// previews are not stored because storage is cleared on lounge restart
+			// type and time are stored in a separate column
+			if (prop !== "id" && prop !== "previews" && prop !== "type" && prop !== "time") {
+				newMsg[prop] = msg[prop];
+			}
+
+			return newMsg;
+		}, {});
+
+		this.database.serialize(() => this.database.run(
+			"INSERT INTO messages(network, channel, time, type, msg) VALUES(?, ?, ?, ?, ?)",
+			network, channel.toLowerCase(), msg.time.getTime(), msg.type, JSON.stringify(clonedMsg)
+		));
+	}
+
+	/**
+	 * Load messages for given channel on a given network and resolve a promise with loaded messages.
+	 *
+	 * @param Network network - Network object where the channel is
+	 * @param Chan channel - Channel object for which to load messages for
+	 */
+	getMessages(network, channel) {
+		if (!this.isEnabled || Helper.config.maxHistory < 1) {
+			return Promise.resolve([]);
+		}
+
+		return new Promise((resolve, reject) => {
+			this.database.parallelize(() => this.database.all(
+				"SELECT msg, type, time FROM messages WHERE network = ? AND channel = ? ORDER BY time DESC LIMIT ?",
+				[network.uuid, channel.name.toLowerCase(), Helper.config.maxHistory],
+				(err, rows) => {
+					if (err) {
+						return reject(err);
+					}
+
+					resolve(rows.map((row) => {
+						const msg = JSON.parse(row.msg);
+						msg.time = row.time;
+						msg.type = row.type;
+
+						return new Msg(msg);
+					}).reverse());
+				}
+			));
+		});
+	}
+}
+
+module.exports = MessageStorage;

src/server.js

@@ -306,6 +306,7 @@ function initializeClient(socket, client, token, lastMessage) {
 			// prevent people from overriding webirc settings
 			data.ip = null;
 			data.hostname = null;
+			data.uuid = null;
 
 			client.connect(data);
 		}