overleaf/services/web/frontend/js/features/pdf-preview/util/compiler.js

270 lines
7.8 KiB
JavaScript
Raw Normal View History

import { isMainFile } from './editor-files'
import getMeta from '../../../utils/meta'
import { deleteJSON, postJSON } from '../../../infrastructure/fetch-json'
import { debounce } from 'lodash'
import { trackPdfDownload } from './metrics'
import { enablePdfCaching } from './pdf-caching-flags'
import { debugConsole } from '@/utils/debugging'
const AUTO_COMPILE_MAX_WAIT = 5000
// We add a 2 second debounce to sending user changes to server if they aren't
// collaborating with anyone. This needs to be higher than SINGLE_USER_FLUSH_DELAY, and allow for
// client to server latency, otherwise we compile before the op reaches the server
// and then again on ack.
const AUTO_COMPILE_DEBOUNCE = 2500
// If there is a pending op, wait for it to be saved before compiling
const PENDING_OP_MAX_WAIT = 10000
const searchParams = new URLSearchParams(window.location.search)
export default class DocumentCompiler {
constructor({
compilingRef,
projectId,
setChangedAt,
setCompiling,
setData,
setFirstRenderDone,
setDeliveryLatencies,
setError,
cleanupCompileResult,
signal,
}) {
this.compilingRef = compilingRef
this.projectId = projectId
this.setChangedAt = setChangedAt
this.setCompiling = setCompiling
this.setData = setData
this.setFirstRenderDone = setFirstRenderDone
this.setDeliveryLatencies = setDeliveryLatencies
this.setError = setError
this.cleanupCompileResult = cleanupCompileResult
this.signal = signal
this.projectRootDocId = null
this.clsiServerId = null
this.currentDoc = null
this.error = undefined
this.timer = 0
this.defaultOptions = {
draft: false,
stopOnFirstError: false,
}
this.debouncedAutoCompile = debounce(
() => {
this.compile({ isAutoCompileOnChange: true })
},
AUTO_COMPILE_DEBOUNCE,
{
maxWait: AUTO_COMPILE_MAX_WAIT,
}
)
this._onDocSavedCallback = null
}
async _awaitBufferedOps() {
const removeEventListener = () => {
clearTimeout(this.pendingOpTimeout)
if (this._onDocSavedCallback) {
window.removeEventListener('doc:saved', this._onDocSavedCallback)
this._onDocSavedCallback = null
}
}
removeEventListener()
return new Promise(resolve => {
if (!this.currentDoc?.hasBufferedOps?.()) {
return resolve()
}
this._onDocSavedCallback = () => {
// TODO: it's possible that there's more than one doc open with buffered ops, and ideally we'd wait for all docs to be flushed
removeEventListener()
resolve()
}
clearTimeout(this.pendingOpTimeout)
this.pendingOpTimeout = setTimeout(() => {
removeEventListener()
resolve()
}, PENDING_OP_MAX_WAIT)
window.addEventListener('doc:saved', this._onDocSavedCallback)
window.dispatchEvent(new CustomEvent('flush-changes'))
})
}
// The main "compile" function.
// Call this directly to run a compile now, otherwise call debouncedAutoCompile.
async compile(options = {}) {
options = { ...this.defaultOptions, ...options }
if (options.isAutoCompileOnLoad && getMeta('ol-preventCompileOnLoad')) {
return
}
// set "compiling" to true (in the React component's state), and return if it was already true
const wasCompiling = this.compilingRef.current
this.setCompiling(true)
if (wasCompiling) {
if (options.isAutoCompileOnChange) {
this.debouncedAutoCompile()
}
return
}
try {
await this._awaitBufferedOps()
// reset values
this.setChangedAt(0) // TODO: wait for doc:saved?
this.validationIssues = undefined
const params = this.buildCompileParams(options)
const t0 = performance.now()
const rootDocId = this.getRootDocOverrideId()
const body = {
rootDoc_id: rootDocId,
draft: options.draft,
check: 'silent', // NOTE: 'error' and 'validate' are possible, but unused
// use incremental compile for all users but revert to a full compile
// if there was previously a server error
incrementalCompilesEnabled: !this.error,
stopOnFirstError: options.stopOnFirstError,
}
const data = await postJSON(
`/project/${this.projectId}/compile?${params}`,
{ body, signal: this.signal }
)
const compileTimeClientE2E = Math.ceil(performance.now() - t0)
const { deliveryLatencies, firstRenderDone } = trackPdfDownload(
data,
compileTimeClientE2E,
t0
)
this.setDeliveryLatencies(() => deliveryLatencies)
this.setFirstRenderDone(() => firstRenderDone)
// unset the error before it's set again later, so that components are recreated and events are tracked
this.setError(undefined)
data.options = options
data.rootDocId = rootDocId
if (data.clsiServerId) {
this.clsiServerId = data.clsiServerId
}
this.setData(data)
} catch (error) {
debugConsole.error(error)
this.cleanupCompileResult()
this.setError(error.info?.statusCode === 429 ? 'rate-limited' : 'error')
} finally {
this.setCompiling(false)
}
}
// parse the text of the current doc in the editor
// if it contains "\documentclass" then use this as the root doc
getRootDocOverrideId() {
// only override when not in the root doc itself
if (this.currentDoc.doc_id !== this.projectRootDocId) {
const snapshot = this.currentDoc.getSnapshot()
if (snapshot && isMainFile(snapshot)) {
return this.currentDoc.doc_id
}
}
return null
}
// build the query parameters added to post-compile requests
buildPostCompileParams() {
const params = new URLSearchParams()
// the id of the CLSI server that processed the previous compile request
if (this.clsiServerId) {
params.set('clsiserverid', this.clsiServerId)
}
return params
}
// build the query parameters for the compile request
buildCompileParams(options) {
const params = new URLSearchParams()
// note: no clsiserverid query param is set on "compile" requests,
// as this is added in the backend by the web api
// tell the server whether this is an automatic or manual compile request
if (options.isAutoCompileOnLoad || options.isAutoCompileOnChange) {
params.set('auto_compile', 'true')
}
// use the feature flag to enable PDF caching
if (enablePdfCaching) {
params.set('enable_pdf_caching', 'true')
}
// use the feature flag to enable "file line errors"
if (searchParams.get('file_line_errors') === 'true') {
params.file_line_errors = 'true'
}
// temporary override to force the new compile timeout
const newCompileTimeoutOverride = new URLSearchParams(
window.location.search
).get('force_new_compile_timeout')
if (newCompileTimeoutOverride) {
params.set('force_new_compile_timeout', newCompileTimeoutOverride)
}
return params
}
// send a request to stop the current compile
stopCompile() {
// NOTE: no stoppingCompile state, as this should happen fairly quickly
// and doesn't matter if it runs twice.
const params = this.buildPostCompileParams()
return postJSON(`/project/${this.projectId}/compile/stop?${params}`, {
signal: this.signal,
})
.catch(error => {
debugConsole.error(error)
this.setError('error')
})
.finally(() => {
this.setCompiling(false)
})
}
// send a request to clear the cache
clearCache() {
const params = this.buildPostCompileParams()
return deleteJSON(`/project/${this.projectId}/output?${params}`, {
signal: this.signal,
}).catch(error => {
debugConsole.error(error)
this.setError('clear-cache')
})
}
setOption(option, value) {
this.defaultOptions[option] = value
}
}