overleaf/services/clsi/app/js/ProjectPersistenceManager.js

219 lines
6.2 KiB
JavaScript
Raw Normal View History

/* 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
* DS207: Consider shorter variations of null checks
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
*/
let ProjectPersistenceManager
const UrlCache = require('./UrlCache')
const CompileManager = require('./CompileManager')
const async = require('async')
const logger = require('@overleaf/logger')
const oneDay = 24 * 60 * 60 * 1000
const Settings = require('@overleaf/settings')
const diskusage = require('diskusage')
const { callbackify } = require('util')
const Path = require('path')
const fs = require('fs')
// projectId -> timestamp mapping.
const LAST_ACCESS = new Map()
2014-02-12 12:27:43 -05:00
async function refreshExpiryTimeout() {
const paths = [
Settings.path.compilesDir,
Settings.path.outputDir,
2021-07-13 07:04:48 -04:00
Settings.path.clsiCacheDir,
]
for (const path of paths) {
try {
const stats = await diskusage.check(path)
const lowDisk = stats.available / stats.total < 0.1
const lowerExpiry = ProjectPersistenceManager.EXPIRY_TIMEOUT * 0.9
if (lowDisk && Settings.project_cache_length_ms / 2 < lowerExpiry) {
logger.warn(
{
stats,
2021-07-13 07:04:48 -04:00
newExpiryTimeoutInDays: (lowerExpiry / oneDay).toFixed(2),
},
'disk running low on space, modifying EXPIRY_TIMEOUT'
)
ProjectPersistenceManager.EXPIRY_TIMEOUT = lowerExpiry
break
}
} catch (err) {
logger.err({ err, path }, 'error getting disk usage')
}
}
}
module.exports = ProjectPersistenceManager = {
EXPIRY_TIMEOUT: Settings.project_cache_length_ms || oneDay * 2.5,
promises: {
2021-07-13 07:04:48 -04:00
refreshExpiryTimeout,
},
refreshExpiryTimeout: callbackify(refreshExpiryTimeout),
init() {
fs.readdir(Settings.path.compilesDir, (err, dirs) => {
if (err) {
logger.warn({ err }, 'cannot get project listing')
dirs = []
}
async.eachLimit(
dirs,
10,
(projectAndUserId, cb) => {
const compileDir = Path.join(
Settings.path.compilesDir,
projectAndUserId
)
const projectId = projectAndUserId.slice(0, 24)
fs.stat(compileDir, (err, stats) => {
if (err) {
// Schedule for immediate cleanup
LAST_ACCESS.set(projectId, 0)
} else {
// Cleanup eventually.
LAST_ACCESS.set(projectId, stats.mtime.getTime())
}
cb()
})
},
() => {
setInterval(() => {
ProjectPersistenceManager.refreshExpiryTimeout(() => {
ProjectPersistenceManager.clearExpiredProjects(err => {
if (err) {
logger.error({ err }, 'clearing expired projects failed')
}
})
})
}, 10 * 60 * 1000)
}
)
})
},
2014-02-12 12:27:43 -05:00
markProjectAsJustAccessed(project_id, callback) {
LAST_ACCESS.set(project_id, Date.now())
callback()
},
clearExpiredProjects(callback) {
if (callback == null) {
callback = function () {}
}
2020-08-10 12:01:11 -04:00
return ProjectPersistenceManager._findExpiredProjectIds(function (
error,
project_ids
) {
if (error != null) {
return callback(error)
}
logger.log({ project_ids }, 'clearing expired projects')
2021-07-13 07:04:48 -04:00
const jobs = Array.from(project_ids || []).map(project_id =>
(
project_id => callback =>
ProjectPersistenceManager.clearProjectFromCache(
project_id,
function (err) {
if (err != null) {
logger.error({ err, project_id }, 'error clearing project')
}
return callback()
}
)
)(project_id)
)
2020-08-10 12:01:11 -04:00
return async.series(jobs, function (error) {
if (error != null) {
return callback(error)
}
return CompileManager.clearExpiredProjects(
ProjectPersistenceManager.EXPIRY_TIMEOUT,
error => callback(error)
)
})
})
}, // ignore any errors from deleting directories
clearProject(project_id, user_id, callback) {
if (callback == null) {
callback = function () {}
}
logger.log({ project_id, user_id }, 'clearing project for user')
2020-08-10 12:01:11 -04:00
return CompileManager.clearProject(project_id, user_id, function (error) {
if (error != null) {
return callback(error)
}
return ProjectPersistenceManager.clearProjectFromCache(
project_id,
2020-08-10 12:01:11 -04:00
function (error) {
if (error != null) {
return callback(error)
}
return callback()
}
)
})
},
2014-02-12 12:27:43 -05:00
clearProjectFromCache(project_id, callback) {
if (callback == null) {
callback = function () {}
}
logger.log({ project_id }, 'clearing project from cache')
2020-08-10 12:01:11 -04:00
return UrlCache.clearProject(project_id, function (error) {
if (error != null) {
logger.err({ error, project_id }, 'error clearing project from cache')
return callback(error)
}
return ProjectPersistenceManager._clearProjectFromDatabase(
project_id,
2020-08-10 12:01:11 -04:00
function (error) {
if (error != null) {
logger.err(
{ error, project_id },
'error clearing project from database'
)
}
return callback(error)
}
)
})
},
2014-02-12 12:27:43 -05:00
_clearProjectFromDatabase(project_id, callback) {
LAST_ACCESS.delete(project_id)
callback()
},
_findExpiredProjectIds(callback) {
const expiredFrom = Date.now() - ProjectPersistenceManager.EXPIRY_TIMEOUT
const expiredProjectsIds = []
for (const [projectId, lastAccess] of LAST_ACCESS.entries()) {
if (lastAccess < expiredFrom) {
expiredProjectsIds.push(projectId)
}
}
// ^ may be a fairly busy loop, continue detached.
setTimeout(() => callback(null, expiredProjectsIds), 0)
2021-07-13 07:04:48 -04:00
},
}
logger.log(
{ EXPIRY_TIMEOUT: ProjectPersistenceManager.EXPIRY_TIMEOUT },
'project assets kept timeout'
)