mirror of
https://github.com/overleaf/overleaf.git
synced 2024-11-29 01:53:39 -05:00
5d472e9b38
GitOrigin-RevId: 17909a4dd0717ea4a75288f734ddef19c7d6592e
260 lines
7 KiB
JavaScript
260 lines
7 KiB
JavaScript
const RequestParser = require('./RequestParser')
|
|
const CompileManager = require('./CompileManager')
|
|
const Settings = require('@overleaf/settings')
|
|
const Metrics = require('./Metrics')
|
|
const ProjectPersistenceManager = require('./ProjectPersistenceManager')
|
|
const logger = require('@overleaf/logger')
|
|
const Errors = require('./Errors')
|
|
|
|
let lastSuccessfulCompileTimestamp = 0
|
|
|
|
function timeSinceLastSuccessfulCompile() {
|
|
return Date.now() - lastSuccessfulCompileTimestamp
|
|
}
|
|
|
|
function compile(req, res, next) {
|
|
const timer = new Metrics.Timer('compile-request')
|
|
RequestParser.parse(req.body, function (error, request) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
timer.opts = request.metricsOpts
|
|
request.project_id = req.params.project_id
|
|
if (req.params.user_id != null) {
|
|
request.user_id = req.params.user_id
|
|
}
|
|
ProjectPersistenceManager.markProjectAsJustAccessed(
|
|
request.project_id,
|
|
function (error) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
CompileManager.doCompileWithLock(request, (error, result) => {
|
|
let { buildId, outputFiles, stats, timings } = result || {}
|
|
let code, status
|
|
if (outputFiles == null) {
|
|
outputFiles = []
|
|
}
|
|
if (error instanceof Errors.AlreadyCompilingError) {
|
|
code = 423 // Http 423 Locked
|
|
status = 'compile-in-progress'
|
|
} else if (error instanceof Errors.FilesOutOfSyncError) {
|
|
code = 409 // Http 409 Conflict
|
|
status = 'retry'
|
|
logger.warn(
|
|
{
|
|
projectId: request.project_id,
|
|
userId: request.user_id,
|
|
},
|
|
'files out of sync, please retry'
|
|
)
|
|
} else if (
|
|
error?.code === 'EPIPE' ||
|
|
error instanceof Errors.TooManyCompileRequestsError
|
|
) {
|
|
// docker returns EPIPE when shutting down
|
|
code = 503 // send 503 Unavailable response
|
|
status = 'unavailable'
|
|
} else if (error?.terminated) {
|
|
status = 'terminated'
|
|
} else if (error?.validate) {
|
|
status = `validation-${error.validate}`
|
|
} else if (error?.timedout) {
|
|
status = 'timedout'
|
|
logger.debug(
|
|
{ err: error, projectId: request.project_id },
|
|
'timeout running compile'
|
|
)
|
|
} else if (error) {
|
|
status = 'error'
|
|
code = 500
|
|
logger.error(
|
|
{ err: error, projectId: request.project_id },
|
|
'error running compile'
|
|
)
|
|
} else {
|
|
if (
|
|
outputFiles.some(
|
|
file => file.path === 'output.pdf' && file.size > 0
|
|
)
|
|
) {
|
|
status = 'success'
|
|
lastSuccessfulCompileTimestamp = Date.now()
|
|
} else if (request.stopOnFirstError) {
|
|
status = 'stopped-on-first-error'
|
|
} else {
|
|
status = 'failure'
|
|
logger.warn(
|
|
{ projectId: request.project_id, outputFiles },
|
|
'project failed to compile successfully, no output.pdf generated'
|
|
)
|
|
}
|
|
|
|
// log an error if any core files are found
|
|
if (outputFiles.some(file => file.path === 'core')) {
|
|
logger.error(
|
|
{ projectId: request.project_id, req, outputFiles },
|
|
'core file found in output'
|
|
)
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
outputFiles = error.outputFiles || []
|
|
buildId = error.buildId
|
|
}
|
|
|
|
timer.done()
|
|
res.status(code || 200).send({
|
|
compile: {
|
|
status,
|
|
error: error?.message || error,
|
|
stats,
|
|
timings,
|
|
buildId,
|
|
outputUrlPrefix: Settings.apis.clsi.outputUrlPrefix,
|
|
outputFiles: outputFiles.map(file => ({
|
|
url:
|
|
`${Settings.apis.clsi.url}/project/${request.project_id}` +
|
|
(request.user_id != null ? `/user/${request.user_id}` : '') +
|
|
(file.build != null ? `/build/${file.build}` : '') +
|
|
`/output/${file.path}`,
|
|
...file,
|
|
})),
|
|
},
|
|
})
|
|
})
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
function stopCompile(req, res, next) {
|
|
const { project_id: projectId, user_id: userId } = req.params
|
|
CompileManager.stopCompile(projectId, userId, function (error) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
}
|
|
|
|
function clearCache(req, res, next) {
|
|
ProjectPersistenceManager.clearProject(
|
|
req.params.project_id,
|
|
req.params.user_id,
|
|
function (error) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
// No content
|
|
res.sendStatus(204)
|
|
}
|
|
)
|
|
}
|
|
|
|
function syncFromCode(req, res, next) {
|
|
const { file } = req.query
|
|
const line = parseInt(req.query.line, 10)
|
|
const column = parseInt(req.query.column, 10)
|
|
const { imageName } = req.query
|
|
const projectId = req.params.project_id
|
|
const userId = req.params.user_id
|
|
|
|
if (imageName && !_isImageNameAllowed(imageName)) {
|
|
return res.status(400).send('invalid image')
|
|
}
|
|
|
|
CompileManager.syncFromCode(
|
|
projectId,
|
|
userId,
|
|
file,
|
|
line,
|
|
column,
|
|
imageName,
|
|
function (error, pdfPositions) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
res.json({
|
|
pdf: pdfPositions,
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
function syncFromPdf(req, res, next) {
|
|
const page = parseInt(req.query.page, 10)
|
|
const h = parseFloat(req.query.h)
|
|
const v = parseFloat(req.query.v)
|
|
const { imageName } = req.query
|
|
const projectId = req.params.project_id
|
|
const userId = req.params.user_id
|
|
|
|
if (imageName && !_isImageNameAllowed(imageName)) {
|
|
return res.status(400).send('invalid image')
|
|
}
|
|
CompileManager.syncFromPdf(
|
|
projectId,
|
|
userId,
|
|
page,
|
|
h,
|
|
v,
|
|
imageName,
|
|
function (error, codePositions) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
res.json({
|
|
code: codePositions,
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
function wordcount(req, res, next) {
|
|
const file = req.query.file || 'main.tex'
|
|
const projectId = req.params.project_id
|
|
const userId = req.params.user_id
|
|
const { image } = req.query
|
|
if (image && !_isImageNameAllowed(image)) {
|
|
return res.status(400).send('invalid image')
|
|
}
|
|
logger.debug({ image, file, projectId }, 'word count request')
|
|
|
|
CompileManager.wordcount(
|
|
projectId,
|
|
userId,
|
|
file,
|
|
image,
|
|
function (error, result) {
|
|
if (error) {
|
|
return next(error)
|
|
}
|
|
res.json({
|
|
texcount: result,
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
function status(req, res, next) {
|
|
res.send('OK')
|
|
}
|
|
|
|
function _isImageNameAllowed(imageName) {
|
|
const ALLOWED_IMAGES =
|
|
Settings.clsi && Settings.clsi.docker && Settings.clsi.docker.allowedImages
|
|
return !ALLOWED_IMAGES || ALLOWED_IMAGES.includes(imageName)
|
|
}
|
|
|
|
module.exports = {
|
|
compile,
|
|
stopCompile,
|
|
clearCache,
|
|
syncFromCode,
|
|
syncFromPdf,
|
|
wordcount,
|
|
status,
|
|
timeSinceLastSuccessfulCompile,
|
|
}
|