overleaf/services/document-updater/app/js/DocumentManager.js
Eric Mc Sween 9f4541c266 Merge pull request #4761 from overleaf/em-peek-doc
Do not unarchive docs when resyncing project history

GitOrigin-RevId: c7df75789c01e6c85b464a9b94b14654d8568407
2021-08-20 08:03:50 +00:00

809 lines
21 KiB
JavaScript

/* eslint-disable
camelcase,
handle-callback-err,
no-unused-vars,
*/
// 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 DocumentManager
const RedisManager = require('./RedisManager')
const ProjectHistoryRedisManager = require('./ProjectHistoryRedisManager')
const PersistenceManager = require('./PersistenceManager')
const DiffCodec = require('./DiffCodec')
const logger = require('logger-sharelatex')
const Metrics = require('./Metrics')
const HistoryManager = require('./HistoryManager')
const RealTimeRedisManager = require('./RealTimeRedisManager')
const Errors = require('./Errors')
const RangesManager = require('./RangesManager')
const async = require('async')
const MAX_UNFLUSHED_AGE = 300 * 1000 // 5 mins, document should be flushed to mongo this time after a change
module.exports = DocumentManager = {
getDoc(project_id, doc_id, _callback) {
if (_callback == null) {
_callback = function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime,
alreadyLoaded
) {}
}
const timer = new Metrics.Timer('docManager.getDoc')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return RedisManager.getDoc(
project_id,
doc_id,
function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime
) {
if (error != null) {
return callback(error)
}
if (lines == null || version == null) {
logger.log(
{ project_id, doc_id },
'doc not in redis so getting from persistence API'
)
return PersistenceManager.getDoc(
project_id,
doc_id,
function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId,
projectHistoryType
) {
if (error != null) {
return callback(error)
}
logger.log(
{
project_id,
doc_id,
lines,
version,
pathname,
projectHistoryId,
projectHistoryType,
},
'got doc from persistence API'
)
return RedisManager.putDocInMemory(
project_id,
doc_id,
lines,
version,
ranges,
pathname,
projectHistoryId,
function (error) {
if (error != null) {
return callback(error)
}
return RedisManager.setHistoryType(
doc_id,
projectHistoryType,
function (error) {
if (error != null) {
return callback(error)
}
return callback(
null,
lines,
version,
ranges || {},
pathname,
projectHistoryId,
null,
false
)
}
)
}
)
}
)
} else {
return callback(
null,
lines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime,
true
)
}
}
)
},
getDocAndRecentOps(project_id, doc_id, fromVersion, _callback) {
if (_callback == null) {
_callback = function (
error,
lines,
version,
ops,
ranges,
pathname,
projectHistoryId
) {}
}
const timer = new Metrics.Timer('docManager.getDocAndRecentOps')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return DocumentManager.getDoc(
project_id,
doc_id,
function (error, lines, version, ranges, pathname, projectHistoryId) {
if (error != null) {
return callback(error)
}
if (fromVersion === -1) {
return callback(
null,
lines,
version,
[],
ranges,
pathname,
projectHistoryId
)
} else {
return RedisManager.getPreviousDocOps(
doc_id,
fromVersion,
version,
function (error, ops) {
if (error != null) {
return callback(error)
}
return callback(
null,
lines,
version,
ops,
ranges,
pathname,
projectHistoryId
)
}
)
}
}
)
},
setDoc(project_id, doc_id, newLines, source, user_id, undoing, _callback) {
if (_callback == null) {
_callback = function (error) {}
}
const timer = new Metrics.Timer('docManager.setDoc')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
if (newLines == null) {
return callback(new Error('No lines were provided to setDoc'))
}
const UpdateManager = require('./UpdateManager')
return DocumentManager.getDoc(
project_id,
doc_id,
function (
error,
oldLines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime,
alreadyLoaded
) {
if (error != null) {
return callback(error)
}
if (
oldLines != null &&
oldLines.length > 0 &&
oldLines[0].text != null
) {
logger.log(
{ doc_id, project_id, oldLines, newLines },
'document is JSON so not updating'
)
return callback(null)
}
logger.log(
{ doc_id, project_id, oldLines, newLines },
'setting a document via http'
)
return DiffCodec.diffAsShareJsOp(
oldLines,
newLines,
function (error, op) {
if (error != null) {
return callback(error)
}
if (undoing) {
for (const o of Array.from(op || [])) {
o.u = true
} // Turn on undo flag for each op for track changes
}
const update = {
doc: doc_id,
op,
v: version,
meta: {
type: 'external',
source,
user_id,
},
}
return UpdateManager.applyUpdate(
project_id,
doc_id,
update,
function (error) {
if (error != null) {
return callback(error)
}
// If the document was loaded already, then someone has it open
// in a project, and the usual flushing mechanism will happen.
// Otherwise we should remove it immediately since nothing else
// is using it.
if (alreadyLoaded) {
return DocumentManager.flushDocIfLoaded(
project_id,
doc_id,
function (error) {
if (error != null) {
return callback(error)
}
return callback(null)
}
)
} else {
return DocumentManager.flushAndDeleteDoc(
project_id,
doc_id,
{},
function (error) {
// There is no harm in flushing project history if the previous
// call failed and sometimes it is required
HistoryManager.flushProjectChangesAsync(project_id)
if (error != null) {
return callback(error)
}
return callback(null)
}
)
}
}
)
}
)
}
)
},
flushDocIfLoaded(project_id, doc_id, _callback) {
if (_callback == null) {
_callback = function (error) {}
}
const timer = new Metrics.Timer('docManager.flushDocIfLoaded')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return RedisManager.getDoc(
project_id,
doc_id,
function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime,
lastUpdatedAt,
lastUpdatedBy
) {
if (error != null) {
return callback(error)
}
if (lines == null || version == null) {
logger.log(
{ project_id, doc_id },
'doc is not loaded so not flushing'
)
return callback(null) // TODO: return a flag to bail out, as we go on to remove doc from memory?
} else {
logger.log({ project_id, doc_id, version }, 'flushing doc')
return PersistenceManager.setDoc(
project_id,
doc_id,
lines,
version,
ranges,
lastUpdatedAt,
lastUpdatedBy,
function (error) {
if (error != null) {
return callback(error)
}
return RedisManager.clearUnflushedTime(doc_id, callback)
}
)
}
}
)
},
flushAndDeleteDoc(project_id, doc_id, options, _callback) {
const timer = new Metrics.Timer('docManager.flushAndDeleteDoc')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return DocumentManager.flushDocIfLoaded(
project_id,
doc_id,
function (error) {
if (error != null) {
if (options.ignoreFlushErrors) {
logger.warn(
{ project_id, doc_id, err: error },
'ignoring flush error while deleting document'
)
} else {
return callback(error)
}
}
// Flush in the background since it requires a http request
HistoryManager.flushDocChangesAsync(project_id, doc_id)
return RedisManager.removeDocFromMemory(
project_id,
doc_id,
function (error) {
if (error != null) {
return callback(error)
}
return callback(null)
}
)
}
)
},
acceptChanges(project_id, doc_id, change_ids, _callback) {
if (change_ids == null) {
change_ids = []
}
if (_callback == null) {
_callback = function (error) {}
}
const timer = new Metrics.Timer('docManager.acceptChanges')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return DocumentManager.getDoc(
project_id,
doc_id,
function (error, lines, version, ranges) {
if (error != null) {
return callback(error)
}
if (lines == null || version == null) {
return callback(
new Errors.NotFoundError(`document not found: ${doc_id}`)
)
}
return RangesManager.acceptChanges(
change_ids,
ranges,
function (error, new_ranges) {
if (error != null) {
return callback(error)
}
return RedisManager.updateDocument(
project_id,
doc_id,
lines,
version,
[],
new_ranges,
{},
function (error) {
if (error != null) {
return callback(error)
}
return callback()
}
)
}
)
}
)
},
deleteComment(project_id, doc_id, comment_id, _callback) {
if (_callback == null) {
_callback = function (error) {}
}
const timer = new Metrics.Timer('docManager.deleteComment')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return DocumentManager.getDoc(
project_id,
doc_id,
function (error, lines, version, ranges) {
if (error != null) {
return callback(error)
}
if (lines == null || version == null) {
return callback(
new Errors.NotFoundError(`document not found: ${doc_id}`)
)
}
return RangesManager.deleteComment(
comment_id,
ranges,
function (error, new_ranges) {
if (error != null) {
return callback(error)
}
return RedisManager.updateDocument(
project_id,
doc_id,
lines,
version,
[],
new_ranges,
{},
function (error) {
if (error != null) {
return callback(error)
}
return callback()
}
)
}
)
}
)
},
renameDoc(project_id, doc_id, user_id, update, projectHistoryId, _callback) {
if (_callback == null) {
_callback = function (error) {}
}
const timer = new Metrics.Timer('docManager.updateProject')
const callback = function (...args) {
timer.done()
return _callback(...Array.from(args || []))
}
return RedisManager.renameDoc(
project_id,
doc_id,
user_id,
update,
projectHistoryId,
callback
)
},
getDocAndFlushIfOld(project_id, doc_id, callback) {
if (callback == null) {
callback = function (error, doc) {}
}
return DocumentManager.getDoc(
project_id,
doc_id,
function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId,
unflushedTime,
alreadyLoaded
) {
if (error != null) {
return callback(error)
}
// if doc was already loaded see if it needs to be flushed
if (
alreadyLoaded &&
unflushedTime != null &&
Date.now() - unflushedTime > MAX_UNFLUSHED_AGE
) {
return DocumentManager.flushDocIfLoaded(
project_id,
doc_id,
function (error) {
if (error != null) {
return callback(error)
}
return callback(null, lines, version)
}
)
} else {
return callback(null, lines, version)
}
}
)
},
resyncDocContents(project_id, doc_id, callback) {
logger.log({ project_id, doc_id }, 'start resyncing doc contents')
return RedisManager.getDoc(
project_id,
doc_id,
function (error, lines, version, ranges, pathname, projectHistoryId) {
if (error != null) {
return callback(error)
}
if (lines == null || version == null) {
logger.log(
{ project_id, doc_id },
'resyncing doc contents - not found in redis - retrieving from web'
)
return PersistenceManager.getDoc(
project_id,
doc_id,
{ peek: true },
function (
error,
lines,
version,
ranges,
pathname,
projectHistoryId
) {
if (error != null) {
logger.error(
{ project_id, doc_id, getDocError: error },
'resyncing doc contents - error retrieving from web'
)
return callback(error)
}
return ProjectHistoryRedisManager.queueResyncDocContent(
project_id,
projectHistoryId,
doc_id,
lines,
version,
pathname,
callback
)
}
)
} else {
logger.log(
{ project_id, doc_id },
'resyncing doc contents - doc in redis - will queue in redis'
)
return ProjectHistoryRedisManager.queueResyncDocContent(
project_id,
projectHistoryId,
doc_id,
lines,
version,
pathname,
callback
)
}
}
)
},
getDocWithLock(project_id, doc_id, callback) {
if (callback == null) {
callback = function (error, lines, version) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.getDoc,
project_id,
doc_id,
callback
)
},
getDocAndRecentOpsWithLock(project_id, doc_id, fromVersion, callback) {
if (callback == null) {
callback = function (
error,
lines,
version,
ops,
ranges,
pathname,
projectHistoryId
) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.getDocAndRecentOps,
project_id,
doc_id,
fromVersion,
callback
)
},
getDocAndFlushIfOldWithLock(project_id, doc_id, callback) {
if (callback == null) {
callback = function (error, doc) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.getDocAndFlushIfOld,
project_id,
doc_id,
callback
)
},
setDocWithLock(
project_id,
doc_id,
lines,
source,
user_id,
undoing,
callback
) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.setDoc,
project_id,
doc_id,
lines,
source,
user_id,
undoing,
callback
)
},
flushDocIfLoadedWithLock(project_id, doc_id, callback) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.flushDocIfLoaded,
project_id,
doc_id,
callback
)
},
flushAndDeleteDocWithLock(project_id, doc_id, options, callback) {
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.flushAndDeleteDoc,
project_id,
doc_id,
options,
callback
)
},
acceptChangesWithLock(project_id, doc_id, change_ids, callback) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.acceptChanges,
project_id,
doc_id,
change_ids,
callback
)
},
deleteCommentWithLock(project_id, doc_id, thread_id, callback) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.deleteComment,
project_id,
doc_id,
thread_id,
callback
)
},
renameDocWithLock(
project_id,
doc_id,
user_id,
update,
projectHistoryId,
callback
) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.renameDoc,
project_id,
doc_id,
user_id,
update,
projectHistoryId,
callback
)
},
resyncDocContentsWithLock(project_id, doc_id, callback) {
if (callback == null) {
callback = function (error) {}
}
const UpdateManager = require('./UpdateManager')
return UpdateManager.lockUpdatesAndDo(
DocumentManager.resyncDocContents,
project_id,
doc_id,
callback
)
},
}