overleaf/services/clsi/app/js/ResourceStateManager.js

/* eslint-disable
    handle-callback-err,
    no-unused-vars,
*/
// 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
 * DS103: Rewrite code to no longer use __guard__
 * DS201: Simplify complex destructure assignments
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
let ResourceStateManager;
const Path = require("path");
const fs = require("fs");
const logger = require("logger-sharelatex");
const settings = require("settings-sharelatex");
const Errors = require("./Errors");
const SafeReader = require("./SafeReader");

module.exports = (ResourceStateManager = {

	// The sync state is an identifier which must match for an
	// incremental update to be allowed.
	//
	// The initial value is passed in and stored on a full
	// compile, along with the list of resources..
	//
	// Subsequent incremental compiles must come with the same value - if
	// not they will be rejected with a 409 Conflict response. The
	// previous list of resources is returned.
	//
	// An incremental compile can only update existing files with new
	// content.  The sync state identifier must change if any docs or
	// files are moved, added, deleted or renamed.

	SYNC_STATE_FILE: ".project-sync-state",
	SYNC_STATE_MAX_SIZE: 128*1024,

	saveProjectState(state, resources, basePath, callback) {
		if (callback == null) { callback = function(error) {}; }
		const stateFile = Path.join(basePath, this.SYNC_STATE_FILE);
		if ((state == null)) { // remove the file if no state passed in
			logger.log({state, basePath}, "clearing sync state");
			return fs.unlink(stateFile, function(err) {
				if ((err != null) && (err.code !== 'ENOENT')) {
					return callback(err);
				} else {
					return callback();
				}
			});
		} else {
			logger.log({state, basePath}, "writing sync state");
			const resourceList = (Array.from(resources).map((resource) => resource.path));
			return fs.writeFile(stateFile, [...Array.from(resourceList), `stateHash:${state}`].join("\n"), callback);
		}
	},

	checkProjectStateMatches(state, basePath, callback) {
		if (callback == null) { callback = function(error, resources) {}; }
		const stateFile = Path.join(basePath, this.SYNC_STATE_FILE);
		const size = this.SYNC_STATE_MAX_SIZE;
		return SafeReader.readFile(stateFile, size, 'utf8', function(err, result, bytesRead) {
			if (err != null) { return callback(err); }
			if (bytesRead === size) {
				logger.error({file:stateFile, size, bytesRead}, "project state file truncated");
			}
			const array = __guard__(result != null ? result.toString() : undefined, x => x.split("\n")) || [];
				const adjustedLength = Math.max(array.length, 1);
				const resourceList = array.slice(0, adjustedLength - 1);
				const oldState = array[adjustedLength - 1];
			const newState = `stateHash:${state}`;
			logger.log({state, oldState, basePath, stateMatches: (newState === oldState)}, "checking sync state");
			if (newState !== oldState) {
				return callback(new Errors.FilesOutOfSyncError("invalid state for incremental update"));
			} else {
				const resources = (Array.from(resourceList).map((path) => ({path})));
				return callback(null, resources);
			}
		});
	},

	checkResourceFiles(resources, allFiles, basePath, callback) {
		// check the paths are all relative to current directory
		let file;
		if (callback == null) { callback = function(error) {}; }
		for (file of Array.from(resources || [])) {
			for (const dir of Array.from(__guard__(file != null ? file.path : undefined, x => x.split('/')))) {
				if (dir === '..') {
					return callback(new Error("relative path in resource file list"));
				}
			}
		}
		// check if any of the input files are not present in list of files
		const seenFile = {};
		for (file of Array.from(allFiles)) {
			seenFile[file] = true;
		}
		const missingFiles = (Array.from(resources).filter((resource) => !seenFile[resource.path]).map((resource) => resource.path));
		if ((missingFiles != null ? missingFiles.length : undefined) > 0) {
			logger.err({missingFiles, basePath, allFiles, resources}, "missing input files for project");
			return callback(new Errors.FilesOutOfSyncError("resource files missing in incremental update"));
		} else {
			return callback();
		}
	}
});

function __guard__(value, transform) {
  return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
}