mirror of
https://github.com/yu-i-i/overleaf-cep.git
synced 2026-05-23 17:19:37 +02:00
6117feef1b
* [project-history] add best effort flush when cloning project * [web] update labels in clone project modal for admins * [project-history] do not shadow history flush failure * [web] fix accessible label for 'Add comment' button * [chat] clone comment threads when cloning project with ranges GitOrigin-RevId: ef30204c8a94b3d6204d56dcca2f62a46319996b
996 lines
27 KiB
JavaScript
996 lines
27 KiB
JavaScript
import logger from '@overleaf/logger'
|
|
import OError from '@overleaf/o-error'
|
|
import * as UpdatesProcessor from './UpdatesProcessor.js'
|
|
import * as SummarizedUpdatesManager from './SummarizedUpdatesManager.js'
|
|
import * as DiffManager from './DiffManager.js'
|
|
import * as HistoryStoreManager from './HistoryStoreManager.js'
|
|
import * as WebApiManager from './WebApiManager.js'
|
|
import * as SnapshotManager from './SnapshotManager.js'
|
|
import * as HealthChecker from './HealthChecker.js'
|
|
import * as SyncManager from './SyncManager.js'
|
|
import * as ErrorRecorder from './ErrorRecorder.js'
|
|
import * as RedisManager from './RedisManager.js'
|
|
import * as LabelsManager from './LabelsManager.js'
|
|
import * as HistoryApiManager from './HistoryApiManager.js'
|
|
import * as RetryManager from './RetryManager.js'
|
|
import * as FlushManager from './FlushManager.js'
|
|
import Stream, { pipeline } from 'node:stream'
|
|
import { fetchNothing, RequestFailedError } from '@overleaf/fetch-utils'
|
|
import { z, zz, parseReq } from '@overleaf/validation-tools'
|
|
import { IncrementalResponse } from '@overleaf/stream-utils'
|
|
|
|
const ONE_DAY_IN_SECONDS = 24 * 60 * 60
|
|
|
|
const cloneProjectSchema = z.object({
|
|
body: z.object({
|
|
targetProjectId: z.string(),
|
|
}),
|
|
|
|
params: z.object({
|
|
project_id: z.string(),
|
|
}),
|
|
})
|
|
|
|
export function cloneProject(req, res) {
|
|
const {
|
|
params: { project_id: sourceProjectId },
|
|
body: { targetProjectId },
|
|
} = parseReq(req, cloneProjectSchema)
|
|
const incrResp = new IncrementalResponse({
|
|
res,
|
|
timeout: 10 * 60_000 - 5_000,
|
|
logger,
|
|
label: 'clone history in project-history',
|
|
info: { targetProjectId, sourceProjectId },
|
|
})
|
|
|
|
incrResp.sendUpdate('best effort history flush: pending')
|
|
UpdatesProcessor.processUpdatesForProject(sourceProjectId, err => {
|
|
if (err) {
|
|
logger.warn(
|
|
{ err, sourceProjectId },
|
|
'failed to flush during history clone'
|
|
)
|
|
incrResp.sendUpdate(
|
|
'best effort history flush: failed, a resync will be required'
|
|
)
|
|
} else {
|
|
incrResp.sendUpdate('best effort history flush: done')
|
|
}
|
|
|
|
WebApiManager.getHistoryId(targetProjectId, (err, targetHistoryId) => {
|
|
if (err) return incrResp.fail(OError.tag(err, 'get target historyId'))
|
|
WebApiManager.getHistoryId(sourceProjectId, (err, sourceHistoryId) => {
|
|
if (err) return incrResp.fail(OError.tag(err, 'get source historyId'))
|
|
|
|
incrResp.sendUpdate('cloning full project history data: pending')
|
|
HistoryStoreManager.cloneProject(
|
|
sourceHistoryId.toString(),
|
|
targetHistoryId.toString(),
|
|
incrResp.signal(),
|
|
(err, stream) => {
|
|
if (err) {
|
|
incrResp.fail(OError.tag(err, 'clone history-v1 data'))
|
|
return
|
|
}
|
|
|
|
// aborted. pipeline() would throw.
|
|
if (res.destroyed) {
|
|
stream.destroy()
|
|
incrResp.fail(new Error('request aborted'))
|
|
return
|
|
}
|
|
|
|
// The stream.pipeline callback API does not support options.
|
|
Stream.promises.pipeline(stream, res, { end: false }).then(
|
|
() => {
|
|
incrResp.sendUpdate('clone labels: pending')
|
|
LabelsManager.cloneLabels(
|
|
sourceProjectId,
|
|
targetProjectId,
|
|
err => {
|
|
if (err) {
|
|
incrResp.fail(OError.tag(err, 'clone labels'))
|
|
return
|
|
}
|
|
incrResp.sendUpdate('clone labels: done')
|
|
|
|
incrResp.sendUpdate('clone resync state: pending')
|
|
SyncManager.cloneResyncState(
|
|
sourceProjectId,
|
|
targetProjectId,
|
|
err => {
|
|
if (err) {
|
|
incrResp.fail(OError.tag(err, 'clone resync state'))
|
|
return
|
|
}
|
|
incrResp.sendUpdate('clone resync state: done')
|
|
|
|
incrResp.sendUpdate('clone failure record: pending')
|
|
ErrorRecorder.cloneFailure(
|
|
sourceProjectId,
|
|
targetProjectId,
|
|
err => {
|
|
if (err) {
|
|
incrResp.fail(OError.tag(err, 'clone failure'))
|
|
return
|
|
}
|
|
incrResp.sendUpdate('clone failure record: done')
|
|
|
|
incrResp.sendUpdate('done')
|
|
incrResp.end()
|
|
}
|
|
)
|
|
}
|
|
)
|
|
}
|
|
)
|
|
},
|
|
err => {
|
|
incrResp.fail(OError.tag(err, 'stream history-v1 response'))
|
|
}
|
|
)
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
const getProjectBlobSchema = z.object({
|
|
params: z.object({
|
|
history_id: zz.objectId().or(z.coerce.number()),
|
|
hash: z.string(),
|
|
}),
|
|
})
|
|
|
|
export function getProjectBlob(req, res, next) {
|
|
const { params } = parseReq(req, getProjectBlobSchema)
|
|
const historyId = params.history_id
|
|
const blobHash = params.hash
|
|
HistoryStoreManager.getProjectBlobStream(
|
|
historyId,
|
|
blobHash,
|
|
(err, stream) => {
|
|
if (err != null) {
|
|
if (err instanceof RequestFailedError && err.response.status === 404) {
|
|
return res.status(404).end()
|
|
}
|
|
return next(OError.tag(err))
|
|
}
|
|
res.setHeader('Cache-Control', `private, max-age=${ONE_DAY_IN_SECONDS}`)
|
|
pipeline(stream, res, err => {
|
|
if (err) next(err)
|
|
// res.end() is already called via 'end' event by pipeline.
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
export function initializeProject(req, res, next) {
|
|
const { historyId } = req.body
|
|
HistoryStoreManager.initializeProject(historyId, (error, id) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.json({ project: { id } })
|
|
})
|
|
}
|
|
|
|
const flushProjectSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
debug: z.stringbool().default(false),
|
|
bisect: z.stringbool().default(false),
|
|
}),
|
|
})
|
|
|
|
export function flushProject(req, res, next) {
|
|
const { query, params } = parseReq(req, flushProjectSchema)
|
|
const projectId = params.project_id
|
|
if (query.debug) {
|
|
logger.debug(
|
|
{ projectId },
|
|
'compressing project history in single-step mode'
|
|
)
|
|
UpdatesProcessor.processSingleUpdateForProject(projectId, error => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
} else if (query.bisect) {
|
|
logger.debug({ projectId }, 'compressing project history in bisect mode')
|
|
UpdatesProcessor.processUpdatesForProjectUsingBisect(
|
|
projectId,
|
|
UpdatesProcessor.REDIS_READ_BATCH_SIZE,
|
|
error => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.sendStatus(204)
|
|
}
|
|
)
|
|
} else {
|
|
logger.debug({ projectId }, 'compressing project history')
|
|
UpdatesProcessor.processUpdatesForProject(projectId, error => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
}
|
|
}
|
|
|
|
const dumpProjectSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
count: z.coerce.number().int().optional(),
|
|
}),
|
|
})
|
|
|
|
export function dumpProject(req, res, next) {
|
|
const { query, params } = parseReq(req, dumpProjectSchema)
|
|
const projectId = params.project_id
|
|
const batchSize = query.count || UpdatesProcessor.REDIS_READ_BATCH_SIZE
|
|
logger.debug({ projectId }, 'retrieving raw updates')
|
|
UpdatesProcessor.getRawUpdates(projectId, batchSize, (error, rawUpdates) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.json(rawUpdates)
|
|
})
|
|
}
|
|
|
|
const flushOldSchema = z.object({
|
|
query: z.object({
|
|
// flush projects with queued ops older than this
|
|
maxAge: z.coerce
|
|
.number()
|
|
.int()
|
|
.default(6 * 3600),
|
|
// pause this amount of time between checking queues
|
|
queueDelay: z.coerce.number().int().default(100),
|
|
// maximum number of queues to check
|
|
limit: z.coerce.number().int().default(1000),
|
|
// maximum amount of time allowed
|
|
timeout: z.coerce
|
|
.number()
|
|
.int()
|
|
.default(60 * 1000),
|
|
// whether to run in the background
|
|
background: z.stringbool().default(false),
|
|
}),
|
|
})
|
|
|
|
export function flushOld(req, res, next) {
|
|
const { query } = parseReq(req, flushOldSchema)
|
|
const { maxAge, queueDelay, limit, timeout, background } = query
|
|
const options = { maxAge, queueDelay, limit, timeout, background }
|
|
FlushManager.flushOldOps(options, (error, results) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.send(results)
|
|
})
|
|
}
|
|
|
|
const getDiffSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
pathname: z.string(),
|
|
from: z.coerce.number().int(),
|
|
to: z.coerce.number().int(),
|
|
}),
|
|
})
|
|
|
|
export function getDiff(req, res, next) {
|
|
const { query, params } = parseReq(req, getDiffSchema)
|
|
const { pathname, from, to } = query
|
|
const projectId = params.project_id
|
|
|
|
logger.debug({ projectId, pathname, from, to }, 'getting diff')
|
|
DiffManager.getDiff(projectId, pathname, from, to, (error, diff) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.json({ diff })
|
|
})
|
|
}
|
|
|
|
const getFileTreeDiffSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
from: z.coerce.number().int(),
|
|
to: z.coerce.number().int(),
|
|
}),
|
|
})
|
|
|
|
export function getFileTreeDiff(req, res, next) {
|
|
const { query, params } = parseReq(req, getFileTreeDiffSchema)
|
|
const { from, to } = query
|
|
const projectId = params.project_id
|
|
|
|
DiffManager.getFileTreeDiff(projectId, from, to, (error, diff) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.json({ diff })
|
|
})
|
|
}
|
|
|
|
const getUpdatesSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
before: z.coerce.number().int().optional(),
|
|
min_count: z.coerce.number().int().optional(),
|
|
}),
|
|
})
|
|
|
|
export function getUpdates(req, res, next) {
|
|
const { query, params } = parseReq(req, getUpdatesSchema)
|
|
const projectId = params.project_id
|
|
const { before, min_count: minCount } = query
|
|
SummarizedUpdatesManager.getSummarizedProjectUpdates(
|
|
projectId,
|
|
{ before, min_count: minCount },
|
|
(error, updates, nextBeforeTimestamp) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
for (const update of updates) {
|
|
// Sets don't JSONify, so convert to arrays
|
|
update.pathnames = Array.from(update.pathnames || []).sort()
|
|
}
|
|
res.json({
|
|
updates,
|
|
nextBeforeTimestamp,
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
const getResyncPendingSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId(),
|
|
}),
|
|
})
|
|
|
|
export function getResyncPending(req, res, next) {
|
|
const {
|
|
params: { project_id: projectId },
|
|
} = parseReq(req, getResyncPendingSchema)
|
|
SyncManager.getResyncState(projectId, (err, state) => {
|
|
if (err) return next(err)
|
|
res.json({
|
|
resyncPending: state.isSyncOngoing(),
|
|
})
|
|
})
|
|
}
|
|
|
|
const getDebugInfoSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId(),
|
|
}),
|
|
})
|
|
|
|
export function getDebugInfo(req, res, next) {
|
|
const {
|
|
params: { project_id: projectId },
|
|
} = parseReq(req, getDebugInfoSchema)
|
|
SyncManager.getResyncState(projectId, (err, state) => {
|
|
if (err) return next(err)
|
|
ErrorRecorder.getFailureRecord(projectId, (err, failureRecord) => {
|
|
if (err) return next(err)
|
|
res.json({
|
|
failureRecord,
|
|
syncState: {
|
|
resyncPending: state.isSyncOngoing(),
|
|
resyncCount: state.resyncCount,
|
|
resyncPendingSince: state.resyncPendingSince,
|
|
lastUpdated: state.lastUpdated,
|
|
history: state.history,
|
|
...state.toRaw(),
|
|
},
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
const latestVersionSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
})
|
|
|
|
export function latestVersion(req, res, next) {
|
|
const { params } = parseReq(req, latestVersionSchema)
|
|
const projectId = params.project_id
|
|
logger.debug({ projectId }, 'compressing project history and getting version')
|
|
UpdatesProcessor.processUpdatesForProject(projectId, error => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
WebApiManager.getHistoryId(projectId, (error, historyId) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
HistoryStoreManager.getMostRecentVersion(
|
|
projectId,
|
|
historyId,
|
|
(error, version, projectStructureAndDocVersions, lastChange) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
res.json({
|
|
version,
|
|
timestamp: lastChange != null ? lastChange.timestamp : undefined,
|
|
v2Authors: lastChange != null ? lastChange.v2Authors : undefined,
|
|
})
|
|
}
|
|
)
|
|
})
|
|
})
|
|
}
|
|
|
|
const getFileSnapshotSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
version: z.coerce.number().int(),
|
|
pathname: z.string(),
|
|
}),
|
|
})
|
|
|
|
export function getFileSnapshot(req, res, next) {
|
|
const { params } = parseReq(req, getFileSnapshotSchema)
|
|
const { project_id: projectId, version, pathname } = params
|
|
SnapshotManager.getFileSnapshotStream(
|
|
projectId,
|
|
version,
|
|
pathname,
|
|
(error, stream) => {
|
|
if (error != null) {
|
|
return next(OError.tag(error))
|
|
}
|
|
pipeline(stream, res, err => {
|
|
if (err) next(err)
|
|
// res.end() is already called via 'end' event by pipeline.
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
const getRangesSnapshotSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
version: z.coerce.number().int(),
|
|
pathname: z.string(),
|
|
}),
|
|
})
|
|
|
|
export function getRangesSnapshot(req, res, next) {
|
|
const { params } = parseReq(req, getRangesSnapshotSchema)
|
|
const { project_id: projectId, version, pathname } = params
|
|
SnapshotManager.getRangesSnapshot(
|
|
projectId,
|
|
version,
|
|
pathname,
|
|
(err, ranges) => {
|
|
if (err) {
|
|
return next(OError.tag(err))
|
|
}
|
|
res.json(ranges)
|
|
}
|
|
)
|
|
}
|
|
|
|
const getFileMetadataSnapshotSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
version: z.coerce.number().int(),
|
|
pathname: z.string(),
|
|
}),
|
|
})
|
|
|
|
export function getFileMetadataSnapshot(req, res, next) {
|
|
const { params } = parseReq(req, getFileMetadataSnapshotSchema)
|
|
const { project_id: projectId, version, pathname } = params
|
|
SnapshotManager.getFileMetadataSnapshot(
|
|
projectId,
|
|
version,
|
|
pathname,
|
|
(err, data) => {
|
|
if (err) {
|
|
return next(OError.tag(err))
|
|
}
|
|
res.json(data)
|
|
}
|
|
)
|
|
}
|
|
|
|
const getLatestSnapshotSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
})
|
|
|
|
export function getLatestSnapshot(req, res, next) {
|
|
const { params } = parseReq(req, getLatestSnapshotSchema)
|
|
const { project_id: projectId } = params
|
|
WebApiManager.getHistoryId(projectId, (error, historyId) => {
|
|
if (error) return next(OError.tag(error))
|
|
SnapshotManager.getLatestSnapshot(
|
|
projectId,
|
|
historyId,
|
|
(error, details) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
const { snapshot, version } = details
|
|
res.json({ snapshot: snapshot.toRaw(), version })
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
const getChangesInChunkSinceSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
since: z.coerce.number().int().min(0),
|
|
}),
|
|
})
|
|
|
|
export function getChangesInChunkSince(req, res, next) {
|
|
const { query, params } = parseReq(req, getChangesInChunkSinceSchema)
|
|
const { project_id: projectId } = params
|
|
const { since } = query
|
|
WebApiManager.getHistoryId(projectId, (error, historyId) => {
|
|
if (error) return next(OError.tag(error))
|
|
SnapshotManager.getChangesInChunkSince(
|
|
projectId,
|
|
historyId,
|
|
since,
|
|
(error, details) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
const { latestStartVersion, changes } = details
|
|
res.json({
|
|
latestStartVersion,
|
|
changes: changes.map(c => c.toRaw()),
|
|
})
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
const getProjectSnapshotSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
version: z.coerce.number().int(),
|
|
}),
|
|
})
|
|
|
|
export function getProjectSnapshot(req, res, next) {
|
|
const { params } = parseReq(req, getProjectSnapshotSchema)
|
|
const { project_id: projectId, version } = params
|
|
SnapshotManager.getProjectSnapshot(
|
|
projectId,
|
|
version,
|
|
(error, snapshotData) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.json(snapshotData)
|
|
}
|
|
)
|
|
}
|
|
|
|
const getPathsAtVersionSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
version: z.coerce.number().int(),
|
|
}),
|
|
})
|
|
|
|
export function getPathsAtVersion(req, res, next) {
|
|
const { params } = parseReq(req, getPathsAtVersionSchema)
|
|
const { project_id: projectId, version } = params
|
|
SnapshotManager.getPathsAtVersion(projectId, version, (error, result) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.json(result)
|
|
})
|
|
}
|
|
|
|
export function healthCheck(req, res) {
|
|
HealthChecker.check(err => {
|
|
if (err != null) {
|
|
logger.err({ err }, 'error performing health check')
|
|
res.sendStatus(500)
|
|
} else {
|
|
res.sendStatus(200)
|
|
}
|
|
})
|
|
}
|
|
|
|
export function checkLock(req, res) {
|
|
HealthChecker.checkLock(err => {
|
|
if (err != null) {
|
|
logger.err({ err }, 'error performing lock check')
|
|
res.sendStatus(500)
|
|
} else {
|
|
res.sendStatus(200)
|
|
}
|
|
})
|
|
}
|
|
|
|
const resyncProjectSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
force: z.stringbool().default(false),
|
|
}),
|
|
body: z.object({
|
|
force: z.boolean().default(false),
|
|
origin: z
|
|
.object({
|
|
kind: z.string(),
|
|
})
|
|
.optional(),
|
|
historyRangesMigration: z.enum(['forwards', 'backwards']).optional(),
|
|
}),
|
|
})
|
|
|
|
export function resyncProject(req, res, next) {
|
|
const { query, params, body } = parseReq(req, resyncProjectSchema)
|
|
const projectId = params.project_id
|
|
const options = {}
|
|
if (body.origin) {
|
|
options.origin = body.origin
|
|
}
|
|
if (body.historyRangesMigration) {
|
|
options.historyRangesMigration = body.historyRangesMigration
|
|
}
|
|
if (query.force || body.force) {
|
|
// this will delete the queue and clear the sync state
|
|
// use if the project is completely broken
|
|
SyncManager.startHardResync(projectId, options, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
// flush the sync operations
|
|
UpdatesProcessor.processUpdatesForProject(projectId, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
})
|
|
} else {
|
|
SyncManager.startResync(projectId, options, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
// flush the sync operations
|
|
UpdatesProcessor.processUpdatesForProject(projectId, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
const forceDebugProjectSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
query: z.object({
|
|
clear: z.stringbool().default(false),
|
|
}),
|
|
})
|
|
|
|
export function forceDebugProject(req, res, next) {
|
|
const { query, params } = parseReq(req, forceDebugProjectSchema)
|
|
const projectId = params.project_id
|
|
// set the debug flag to true unless we see ?clear=true
|
|
const state = !query.clear
|
|
ErrorRecorder.setForceDebug(projectId, state, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
// display the failure record to help debugging
|
|
ErrorRecorder.getFailureRecord(projectId, (error, result) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.send(result)
|
|
})
|
|
})
|
|
}
|
|
|
|
export function getFailures(req, res, next) {
|
|
ErrorRecorder.getFailures((error, result) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.send({ failures: result })
|
|
})
|
|
}
|
|
|
|
export function getFailuresFull(req, res, next) {
|
|
ErrorRecorder.getFailuresFull((error, result) => {
|
|
if (error) return next(error)
|
|
res.send(result)
|
|
})
|
|
}
|
|
|
|
export function getQueueCounts(req, res, next) {
|
|
RedisManager.getProjectIdsWithHistoryOpsCount((err, queuedProjectsCount) => {
|
|
if (err != null) {
|
|
return next(err)
|
|
}
|
|
res.send({ queuedProjects: queuedProjectsCount })
|
|
})
|
|
}
|
|
|
|
const getLabelsSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
})
|
|
|
|
export function getLabels(req, res, next) {
|
|
const { params } = parseReq(req, getLabelsSchema)
|
|
const projectId = params.project_id
|
|
HistoryApiManager.shouldUseProjectHistory(
|
|
projectId,
|
|
(error, shouldUseProjectHistory) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
if (shouldUseProjectHistory) {
|
|
LabelsManager.getLabels(projectId, (error, labels) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.json(labels)
|
|
})
|
|
} else {
|
|
res.sendStatus(409)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
const createLabelSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
user_id: zz.objectId().optional(),
|
|
}),
|
|
body: z.object({
|
|
version: z.number().int(),
|
|
comment: z.string(),
|
|
created_at: z.string().optional(),
|
|
validate_exists: z.boolean().default(true),
|
|
user_id: zz.objectId().nullable().optional(),
|
|
}),
|
|
})
|
|
|
|
export function createLabel(req, res, next) {
|
|
const { params, body } = parseReq(req, createLabelSchema)
|
|
const { project_id: projectId, user_id: userIdParam } = params
|
|
const {
|
|
version,
|
|
comment,
|
|
user_id: userIdBody,
|
|
created_at: createdAt,
|
|
validate_exists: validateExists,
|
|
} = body
|
|
|
|
// Temporarily looking up both params and body while rolling out changes
|
|
// in the router path - https://github.com/overleaf/internal/pull/20200
|
|
const userId = userIdParam || userIdBody
|
|
|
|
HistoryApiManager.shouldUseProjectHistory(
|
|
projectId,
|
|
(error, shouldUseProjectHistory) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
if (shouldUseProjectHistory) {
|
|
LabelsManager.createLabel(
|
|
projectId,
|
|
userId,
|
|
version,
|
|
comment,
|
|
createdAt,
|
|
validateExists,
|
|
(error, label) => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.json(label)
|
|
}
|
|
)
|
|
} else {
|
|
logger.error(
|
|
{
|
|
projectId,
|
|
userId,
|
|
version,
|
|
comment,
|
|
createdAt,
|
|
validateExists,
|
|
},
|
|
'not using v2 history'
|
|
)
|
|
res.sendStatus(409)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
/**
|
|
* This will delete a label if it is owned by the current user. If you wish to
|
|
* delete a label regardless of the current user, then use `deleteLabel` instead.
|
|
*/
|
|
const deleteLabelForUserSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
user_id: zz.objectId(),
|
|
label_id: zz.objectId(),
|
|
}),
|
|
})
|
|
|
|
export function deleteLabelForUser(req, res, next) {
|
|
const { params } = parseReq(req, deleteLabelForUserSchema)
|
|
const { project_id: projectId, user_id: userId, label_id: labelId } = params
|
|
|
|
LabelsManager.deleteLabelForUser(projectId, userId, labelId, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
}
|
|
|
|
const deleteLabelSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
label_id: zz.objectId(),
|
|
}),
|
|
})
|
|
|
|
export function deleteLabel(req, res, next) {
|
|
const { params } = parseReq(req, deleteLabelSchema)
|
|
const { project_id: projectId, label_id: labelId } = params
|
|
|
|
LabelsManager.deleteLabel(projectId, labelId, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
}
|
|
|
|
const retryFailuresSchema = z.object({
|
|
query: z.object({
|
|
failureType: z.enum(['soft', 'hard']).optional(),
|
|
// bail out after this time limit
|
|
timeout: z.coerce.number().int().default(300),
|
|
// maximum number of projects to check
|
|
limit: z.coerce.number().int().default(100),
|
|
callbackUrl: z.string().optional(),
|
|
}),
|
|
})
|
|
|
|
export function retryFailures(req, res, next) {
|
|
const { query } = parseReq(req, retryFailuresSchema)
|
|
const { failureType, timeout, limit, callbackUrl } = query
|
|
if (callbackUrl) {
|
|
// send response but run in background when callbackUrl provided
|
|
res.send({ retryStatus: 'running retryFailures in background' })
|
|
}
|
|
RetryManager.retryFailures(
|
|
{ failureType, timeout, limit },
|
|
(error, result) => {
|
|
if (callbackUrl) {
|
|
// if present, notify the callbackUrl on success
|
|
if (!error) {
|
|
// Needs Node 12
|
|
// const callbackHeaders = Object.fromEntries(Object.entries(req.headers || {}).filter(([k,v]) => k.match(/^X-CALLBACK-/i)))
|
|
const callbackHeaders = {}
|
|
for (const key of Object.getOwnPropertyNames(
|
|
req.headers || {}
|
|
).filter(key => key.match(/^X-CALLBACK-/i))) {
|
|
const found = key.match(/^X-CALLBACK-(.*)/i)
|
|
callbackHeaders[found[1]] = req.headers[key]
|
|
}
|
|
fetchNothing(callbackUrl, { headers: callbackHeaders }).catch(err => {
|
|
logger.warn({ err }, 'failed to ping callback url')
|
|
})
|
|
}
|
|
} else {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.send({ retryStatus: result })
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
const transferLabelsSchema = z.object({
|
|
params: z.object({
|
|
from_user: zz.objectId(),
|
|
to_user: zz.objectId(),
|
|
}),
|
|
})
|
|
|
|
export function transferLabels(req, res, next) {
|
|
const { params } = parseReq(req, transferLabelsSchema)
|
|
const { from_user: fromUser, to_user: toUser } = params
|
|
LabelsManager.transferLabels(fromUser, toUser, error => {
|
|
if (error != null) {
|
|
return next(error)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
}
|
|
|
|
const deleteProjectSchema = z.object({
|
|
params: z.object({
|
|
project_id: zz.objectId().or(z.coerce.number()),
|
|
}),
|
|
})
|
|
|
|
export function deleteProject(req, res, next) {
|
|
const { params } = parseReq(req, deleteProjectSchema)
|
|
const { project_id: projectId } = params
|
|
// clear the timestamp before clearing the queue,
|
|
// because the queue location is used in the migration
|
|
RedisManager.clearFirstOpTimestamp(projectId, err => {
|
|
if (err) {
|
|
return next(err)
|
|
}
|
|
RedisManager.clearCachedHistoryId(projectId, err => {
|
|
if (err) {
|
|
return next(err)
|
|
}
|
|
RedisManager.destroyDocUpdatesQueue(projectId, err => {
|
|
if (err) {
|
|
return next(err)
|
|
}
|
|
SyncManager.clearResyncState(projectId, err => {
|
|
if (err) {
|
|
return next(err)
|
|
}
|
|
ErrorRecorder.clearError(projectId, err => {
|
|
if (err) {
|
|
return next(err)
|
|
}
|
|
res.sendStatus(204)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}
|