const Path = require('path') const fs = require('fs') const logger = require('@overleaf/logger') const Errors = require('./Errors') const SafeReader = require('./SafeReader') module.exports = { // 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) { 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') fs.unlink(stateFile, function (err) { if (err && err.code !== 'ENOENT') { return callback(err) } else { return callback() } }) } else { logger.log({ state, basePath }, 'writing sync state') const resourceList = resources.map(resource => resource.path) fs.writeFile( stateFile, [...resourceList, `stateHash:${state}`].join('\n'), callback ) } }, checkProjectStateMatches(state, basePath, callback) { const stateFile = Path.join(basePath, this.SYNC_STATE_FILE) const size = this.SYNC_STATE_MAX_SIZE SafeReader.readFile( stateFile, size, 'utf8', function (err, result, bytesRead) { if (err) { return callback(err) } if (bytesRead === size) { logger.error( { file: stateFile, size, bytesRead }, 'project state file truncated' ) } const array = result ? result.toString().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 = resourceList.map(path => ({ path })) callback(null, resources) } } ) }, checkResourceFiles(resources, allFiles, basePath, callback) { // check the paths are all relative to current directory const containsRelativePath = resource => { const dirs = resource.path.split('/') return dirs.indexOf('..') !== -1 } if (resources.some(containsRelativePath)) { 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 seenFiles = new Set(allFiles) const missingFiles = resources .map(resource => resource.path) .filter(path => !seenFiles.has(path)) if (missingFiles.length > 0) { logger.err( { missingFiles, basePath, allFiles, resources }, 'missing input files for project' ) return callback( new Errors.FilesOutOfSyncError( 'resource files missing in incremental update' ) ) } else { callback() } }, }