mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-16 02:52:31 -04:00
301 lines
7.7 KiB
JavaScript
301 lines
7.7 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 TrackChangesClient
|
|
const async = require('async')
|
|
const zlib = require('zlib')
|
|
const request = require('request')
|
|
const Settings = require('@overleaf/settings')
|
|
const rclient = require('@overleaf/redis-wrapper').createClient(
|
|
Settings.redis.history
|
|
) // Only works locally for now
|
|
const Keys = Settings.redis.history.key_schema
|
|
const { db, ObjectId } = require('../../../../app/js/mongodb')
|
|
|
|
const aws = require('aws-sdk')
|
|
const s3 = new aws.S3({
|
|
accessKeyId: Settings.trackchanges.s3.key,
|
|
secretAccessKey: Settings.trackchanges.s3.secret,
|
|
endpoint: Settings.trackchanges.s3.endpoint,
|
|
s3ForcePathStyle: Settings.trackchanges.s3.pathStyle
|
|
})
|
|
const S3_BUCKET = Settings.trackchanges.stores.doc_history
|
|
|
|
module.exports = TrackChangesClient = {
|
|
flushAndGetCompressedUpdates(project_id, doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, updates) {}
|
|
}
|
|
return TrackChangesClient.flushDoc(project_id, doc_id, (error) => {
|
|
if (error != null) {
|
|
return callback(error)
|
|
}
|
|
return TrackChangesClient.getCompressedUpdates(doc_id, callback)
|
|
})
|
|
},
|
|
|
|
flushDoc(project_id, doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return request.post(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/doc/${doc_id}/flush`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(204)
|
|
return callback(error)
|
|
}
|
|
)
|
|
},
|
|
|
|
flushProject(project_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return request.post(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/flush`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(204)
|
|
return callback(error)
|
|
}
|
|
)
|
|
},
|
|
|
|
getCompressedUpdates(doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, updates) {}
|
|
}
|
|
return db.docHistory
|
|
.find({ doc_id: ObjectId(doc_id) })
|
|
.sort({ 'meta.end_ts': 1 })
|
|
.toArray(callback)
|
|
},
|
|
|
|
getProjectMetaData(project_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, updates) {}
|
|
}
|
|
return db.projectHistoryMetaData.findOne(
|
|
{
|
|
project_id: ObjectId(project_id)
|
|
},
|
|
callback
|
|
)
|
|
},
|
|
|
|
setPreserveHistoryForProject(project_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return db.projectHistoryMetaData.updateOne(
|
|
{
|
|
project_id: ObjectId(project_id)
|
|
},
|
|
{
|
|
$set: { preserveHistory: true }
|
|
},
|
|
{
|
|
upsert: true
|
|
},
|
|
callback
|
|
)
|
|
},
|
|
|
|
pushRawUpdates(project_id, doc_id, updates, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return rclient.sadd(
|
|
Keys.docsWithHistoryOps({ project_id }),
|
|
doc_id,
|
|
(error) => {
|
|
if (error != null) {
|
|
return callback(error)
|
|
}
|
|
return rclient.rpush(
|
|
Keys.uncompressedHistoryOps({ doc_id }),
|
|
...Array.from(Array.from(updates).map((u) => JSON.stringify(u))),
|
|
callback
|
|
)
|
|
}
|
|
)
|
|
},
|
|
|
|
getDiff(project_id, doc_id, from, to, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, diff) {}
|
|
}
|
|
return request.get(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/doc/${doc_id}/diff?from=${from}&to=${to}`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(200)
|
|
return callback(null, JSON.parse(body))
|
|
}
|
|
)
|
|
},
|
|
|
|
getUpdates(project_id, options, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, body) {}
|
|
}
|
|
return request.get(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/updates?before=${options.before}&min_count=${options.min_count}`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(200)
|
|
return callback(null, JSON.parse(body))
|
|
}
|
|
)
|
|
},
|
|
|
|
exportProject(project_id, callback) {
|
|
request.get(
|
|
{ url: `http://localhost:3015/project/${project_id}/export`, json: true },
|
|
(error, response, updates) => {
|
|
if (error) return callback(error)
|
|
response.statusCode.should.equal(200)
|
|
callback(null, updates, JSON.parse(response.trailers['x-user-ids']))
|
|
}
|
|
)
|
|
},
|
|
|
|
restoreDoc(project_id, doc_id, version, user_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return request.post(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/doc/${doc_id}/version/${version}/restore`,
|
|
headers: {
|
|
'X-User-Id': user_id
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(204)
|
|
return callback(null)
|
|
}
|
|
)
|
|
},
|
|
|
|
pushDocHistory(project_id, doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return request.post(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/doc/${doc_id}/push`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(204)
|
|
return callback(error)
|
|
}
|
|
)
|
|
},
|
|
|
|
pullDocHistory(project_id, doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error) {}
|
|
}
|
|
return request.post(
|
|
{
|
|
url: `http://localhost:3015/project/${project_id}/doc/${doc_id}/pull`
|
|
},
|
|
(error, response, body) => {
|
|
response.statusCode.should.equal(204)
|
|
return callback(error)
|
|
}
|
|
)
|
|
},
|
|
|
|
waitForS3(done, retries) {
|
|
if (retries == null) {
|
|
retries = 42
|
|
}
|
|
if (!Settings.trackchanges.s3.endpoint) {
|
|
return done()
|
|
}
|
|
|
|
return request.get(`${Settings.trackchanges.s3.endpoint}/`, (err, res) => {
|
|
if (res && res.statusCode < 500) {
|
|
return done()
|
|
}
|
|
|
|
if (retries === 0) {
|
|
return done(err || new Error(`s3 returned ${res.statusCode}`))
|
|
}
|
|
|
|
return setTimeout(
|
|
() => TrackChangesClient.waitForS3(done, --retries),
|
|
1000
|
|
)
|
|
})
|
|
},
|
|
|
|
getS3Doc(project_id, doc_id, pack_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, body) {}
|
|
}
|
|
const params = {
|
|
Bucket: S3_BUCKET,
|
|
Key: `${project_id}/changes-${doc_id}/pack-${pack_id}`
|
|
}
|
|
|
|
return s3.getObject(params, (error, data) => {
|
|
if (error != null) {
|
|
return callback(error)
|
|
}
|
|
const body = data.Body
|
|
if (body == null) {
|
|
return callback(new Error('empty response from s3'))
|
|
}
|
|
return zlib.gunzip(body, (err, result) => {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
return callback(null, JSON.parse(result.toString()))
|
|
})
|
|
})
|
|
},
|
|
|
|
removeS3Doc(project_id, doc_id, callback) {
|
|
if (callback == null) {
|
|
callback = function (error, res, body) {}
|
|
}
|
|
let params = {
|
|
Bucket: S3_BUCKET,
|
|
Prefix: `${project_id}/changes-${doc_id}`
|
|
}
|
|
|
|
return s3.listObjects(params, (error, data) => {
|
|
if (error != null) {
|
|
return callback(error)
|
|
}
|
|
|
|
params = {
|
|
Bucket: S3_BUCKET,
|
|
Delete: {
|
|
Objects: data.Contents.map((s3object) => ({ Key: s3object.Key }))
|
|
}
|
|
}
|
|
|
|
return s3.deleteObjects(params, callback)
|
|
})
|
|
}
|
|
}
|