server: use async functions instead of callbacks

This makes the code more readable.
Also add the automatic deletion of empty board files.

server/boardData.js

@@ -159,30 +159,39 @@ BoardData.prototype.delaySave = function (file) {
 /** Saves the data in the board to a file.
  * @param {string} [file=this.file] - Path to the file where the board data will be saved.
 */
-BoardData.prototype.save = function (file) {
+BoardData.prototype.save = async function (file) {
 	this.lastSaveDate = Date.now();
 	this.clean();
 	if (!file) file = this.file;
 	var tmp_file = backupFileName(file);
 	var board_txt = JSON.stringify(this.board);
-	var that = this;
-	function afterSave(err) {
-		if (err) {
+	if (board_txt === "{}") { // empty board
+		try {
+			await fs.promises.unlink(file);
+			log("removed empty board", { 'name': this.name });
+		} catch (err) {
+			if (err.code !== "ENOENT") {
+				// If the file already wasn't saved, this is not an error
+				log("board deletion error", { "e": err })
+			}
+		}
+	} else {
+		try {
+			await fs.promises.writeFile(tmp_file, board_txt);
+			await fs.promises.rename(tmp_file, file);
+			log("saved board", {
+				'name': this.name,
+				'size': board_txt.length,
+				'delay_ms': (Date.now() - this.lastSaveDate),
+			});
+		} catch (err) {
 			log("board saving error", {
-				'err': err,
+				'err': err.toString(),
 				'tmp_file': tmp_file,
 			});
-		} else {
-			log("saved board", {
-				'name': that.name,
-				'delay_ms': (Date.now() - that.lastSaveDate)
-			});
+			return;
 		}
 	}
-	fs.writeFile(tmp_file, board_txt, function onBoardSaved(err) {
-		if (err) afterSave(err);
-		else fs.rename(tmp_file, file, afterSave);
-	});
 };
 
 /** Remove old elements from the board */
@@ -231,31 +240,32 @@ BoardData.prototype.validate = function validate(item, parent) {
 /** Load the data in the board from a file.
  * @param {string} file - Path to the file where the board data will be read.
 */
-BoardData.load = function loadBoard(name) {
-	var boardData = new BoardData(name);
-	return new Promise((accept) => {
-		fs.readFile(boardData.file, function (err, data) {
+BoardData.load = async function loadBoard(name) {
+	var boardData = new BoardData(name), data;
+	try {
+		data = await fs.promises.readFile(boardData.file);
+		boardData.board = JSON.parse(data);
+		for (id in boardData.board) boardData.validate(boardData.board[id]);
+		log('disk load', { 'board': boardData.name });
+	} catch (e) {
+		log('empty board creation', {
+			'board': boardData.name,
+			// If the file doesn't exist, this is not an error
+			"error": e.code !== "ENOENT" && e.toString(),
+		});
+		boardData.board = {}
+		if (data) {
+			// There was an error loading the board, but some data was still read
+			var backup = backupFileName(boardData.file);
+			log("Writing the corrupted file to " + backup);
 			try {
-				if (err) throw err;
-				boardData.board = JSON.parse(data);
-				for (id in boardData.board) boardData.validate(boardData.board[id]);
-				log('disk load', { 'board': boardData.name });
-			} catch (e) {
-				console.error("Unable to read history from " + boardData.file + ". The following error occured: " + e);
-				log('empty board creation', { 'board': boardData.name });
-				boardData.board = {}
-				if (data) {
-					// There was an error loading the board, but some data was still read
-					var backup = backupFileName(boardData.file);
-					log("Writing the corrupted file to " + backup);
-					fs.writeFile(backup, data, function (err) {
-						if (err) log("Error writing " + backup + ": " + err);
-					});
-				}
+				await fs.promises.writeFile(backup, data);
+			} catch (err) {
+				log("Error writing " + backup + ": " + err);
 			}
-			accept(boardData);
-		});
-	});
+		}
+	}
+	return boardData;
 };
 
 function backupFileName(baseName) {

server/sockets.js

@@ -5,7 +5,9 @@ var iolib = require('socket.io')
 var MAX_EMIT_COUNT = 64; // Maximum number of draw operations before getting banned
 var MAX_EMIT_COUNT_PERIOD = 5000; // Duration (in ms) after which the emit count is reset
 
-// Map from name to *promises* of BoardData
+/** Map from name to *promises* of BoardData
+	@type {Object<string, Promise<BoardData>>}
+*/
 var boards = {};
 
 function noFail(fn) {
@@ -24,7 +26,9 @@ function startIO(app) {
 	return io;
 }
 
-/** Returns a promise to a BoardData with the given name*/
+/** Returns a promise to a BoardData with the given name
+ * @returns {Promise<BoardData>}
+*/
 function getBoard(name) {
 	if (boards.hasOwnProperty(name)) {
 		return boards[name];
@@ -37,30 +41,28 @@ function getBoard(name) {
 
 function socketConnection(socket) {
 
-	function joinBoard(name) {
+	async function joinBoard(name) {
 		// Default to the public board
 		if (!name) name = "anonymous";
 
 		// Join the board
 		socket.join(name);
 
-		return getBoard(name).then(board => {
-			board.users.add(socket.id);
-			log('board joined', { 'board': board.name, 'users': board.users.size });
-			return board;
-		});
+		var board = await getBoard(name);
+		board.users.add(socket.id);
+		log('board joined', { 'board': board.name, 'users': board.users.size });
+		return board;
 	}
 
 	socket.on("error", noFail(function onError(error) {
 		log("ERROR", error);
 	}));
 
-	socket.on("getboard", noFail(function onGetBoard(name) {
-		joinBoard(name).then(board => {
-			//Send all the board's data as soon as it's loaded
-			socket.emit("broadcast", { _children: board.getAll() });
-		});
-	}));
+	socket.on("getboard", async function onGetBoard(name) {
+		var board = await joinBoard(name);
+		//Send all the board's data as soon as it's loaded
+		socket.emit("broadcast", { _children: board.getAll() });
+	});
 
 	socket.on("joinboard", noFail(joinBoard));
 
@@ -102,41 +104,39 @@ function socketConnection(socket) {
 	}));
 
 	socket.on('disconnecting', function onDisconnecting(reason) {
-		Object.keys(socket.rooms).forEach(function disconnectFrom(room) {
+		Object.keys(socket.rooms).forEach(async function disconnectFrom(room) {
 			if (boards.hasOwnProperty(room)) {
-				boards[room].then(board => {
-					board.users.delete(socket.id);
-					var userCount = board.users.size;
-					log('disconnection', { 'board': board.name, 'users': board.users.size });
-					if (userCount === 0) {
-						board.save();
-						delete boards[room];
-					}
-				});
+				var board = await boards[room];
+				board.users.delete(socket.id);
+				var userCount = board.users.size;
+				log('disconnection', { 'board': board.name, 'users': board.users.size });
+				if (userCount === 0) {
+					board.save();
+					delete boards[room];
+				}
 			}
 		});
 	});
 }
 
-function saveHistory(boardName, message) {
+async function saveHistory(boardName, message) {
 	var id = message.id;
-	getBoard(boardName).then(board => {
-		switch (message.type) {
-			case "delete":
-				if (id) board.delete(id);
-				break;
-			case "update":
-				delete message.type;
-				if (id) board.update(id, message);
-				break;
-			case "child":
-				board.addChild(message.parent, message);
-				break;
-			default: //Add data
-				if (!id) throw new Error("Invalid message: ", message);
-				board.set(id, message);
-		}
-	});
+	var board = await getBoard(boardName);
+	switch (message.type) {
+		case "delete":
+			if (id) board.delete(id);
+			break;
+		case "update":
+			delete message.type;
+			if (id) board.update(id, message);
+			break;
+		case "child":
+			board.addChild(message.parent, message);
+			break;
+		default: //Add data
+			if (!id) throw new Error("Invalid message: ", message);
+			board.set(id, message);
+	}
 }
 
 function generateUID(prefix, suffix) {