ActivityPub-federated video streaming platform using P2P directly in your web browser
import { HttpStatusCode, VideoCommentPolicy } from '@peertube/peertube-models'
import { CONFIG } from '@server/initializers/config.js'
import Bluebird from 'bluebird'
import { sanitizeAndCheckVideoCommentObject } from '../../helpers/custom-validators/activitypub/video-comments.js'
import { createLogger } from '../../helpers/logger.js'
import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants.js'
import { VideoCommentModel } from '../../models/video/video-comment.js'
import {
MComment,
MCommentOwner,
MCommentOwnerVideo,
MVideoAccountLight,
MVideoAccountLightBlacklistAllFiles
} from '../../types/models/video/index.js'
import { createCommentAutomaticTagsJob } from '../automatic-tags/automatic-tags.js'
import { isRemoteVideoCommentAccepted } from '../moderation.js'
import { Hooks } from '../plugins/hooks.js'
import { CommentHoldStatus, getCommentHoldStatus } from '../video-comment.js'
import { fetchAP } from './activity.js'
import { getOrCreateAPActor } from './actors/index.js'
import { checkUrlsSameHost } from './url.js'
import { canVideoBeFederated, getOrCreateAPVideo } from './videos/index.js'
const logger = createLogger()
type ResolveThreadParams = {
url: string
comments?: MCommentOwner[]
isVideo?: boolean
commentCreated?: boolean
}
type ResolveThreadResult = Promise<{
video: MVideoAccountLightBlacklistAllFiles
comment: MCommentOwnerVideo
commentCreated: boolean
heldForAutoTags: boolean
}>
export async function addVideoComments (commentUrls: string[]) {
if (CONFIG.VIDEO_COMMENTS.ACCEPT_REMOTE_COMMENTS !== true) return
return Bluebird.map(commentUrls, async commentUrl => {
await logger.withContext([ commentUrl ], async () => {
try {
await resolveThread({ url: commentUrl, isVideo: false })
} catch (err) {
if (err.statusCode === HttpStatusCode.NOT_FOUND_404 || err.statusCode === HttpStatusCode.GONE_410) {
logger.debug(`Cannot resolve thread ${commentUrl} that does not exist anymore`, { err })
return
}
logger.info(`Cannot resolve thread ${commentUrl}`, { err })
}
})
}, { concurrency: CRAWL_REQUEST_CONCURRENCY })
}
// Resolves a full AP comment thread starting from `url`, walking up the `inReplyTo` chain until it hits
// either a comment already stored locally or the video the thread is attached to.
//
// `params.comments` accumulates the chain: index 0 ends up being the comment `url` originally pointed to
// and the last index is the comment directly replying to the video (the thread root)
export async function resolveThread (params: ResolveThreadParams): ResolveThreadResult {
const { url, isVideo } = params
if (params.commentCreated === undefined) params.commentCreated = false
if (params.comments === undefined) params.comments = []
// If it is not a video, or if we don't know if it's a video, try to get the thread from DB
if (isVideo === false || isVideo === undefined) {
const result = await resolveCommentFromDB(params)
if (result) return result
}
try {
// If it is a video, or if we don't know if it's a video
if (isVideo === true || isVideo === undefined) {
// Keep await so we catch the exception
return await tryToResolveThreadFromVideo(params)
}
} catch (err) {
logger.debug('Cannot resolve thread from video %s, maybe because it was not a video', url, { err })
}
return resolveRemoteParentComment(params)
}
// ---------------------------------------------------------------------------
// Private
// ---------------------------------------------------------------------------
async function resolveCommentFromDB (params: ResolveThreadParams) {
const { url, comments, commentCreated } = params
const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateAccountAndVideoAndReply(url)
if (!commentFromDatabase) return undefined
let parentComments = comments.concat([ commentFromDatabase ])
// The rest of the thread above this comment is already in DB too: append it instead of re-fetching each ancestor from the remote instance
if (commentFromDatabase.InReplyToVideoComment) {
const data = await VideoCommentModel.listThreadParentComments({ comment: commentFromDatabase, order: 'DESC' })
parentComments = parentComments.concat(data)
}
// We know the video already, so skip straight to it instead of walking inReplyTo comment by comment
return resolveThread({
url: commentFromDatabase.Video.url,
comments: parentComments,
isVideo: true,
commentCreated
})
}
// ---------------------------------------------------------------------------
// Once the video is reached the whole chain is known and gets persisted root-first
async function tryToResolveThreadFromVideo (params: ResolveThreadParams) {
const { url, comments, commentCreated } = params
// Maybe it's a reply to a video?
// If yes, it's done: we resolved all the thread
const syncParam = { rates: true, shares: true, comments: false, refreshVideo: false }
const { video } = await getOrCreateAPVideo({ videoObject: url, syncParam })
if (video.isLocal() && !canVideoBeFederated(video)) {
throw new Error('Cannot resolve thread of video that is not compatible with federation')
}
if (video.commentsPolicy === VideoCommentPolicy.DISABLED) {
return undefined
}
let resultComment: MCommentOwnerVideo
// comments[0] is the comment the thread was resolved for: only its held status is reported back to the caller,
// the other comments in the array are ancestors synthesized to complete the thread
let resultCommentHeldForAutoTags = false
if (comments.length !== 0) {
// Process root-first (comments.length - 1 down to 0): each comment needs its parent's real DB id for
// inReplyToCommentId/originCommentId, which only exists once the parent has been saved
const firstReply = comments[comments.length - 1] as MCommentOwnerVideo
firstReply.inReplyToCommentId = null
firstReply.originCommentId = null
firstReply.videoId = video.id
firstReply.changed('updatedAt', true)
firstReply.Video = video
if (await isRemoteCommentAccepted(firstReply) !== true) {
return undefined
}
const { isNew: firstReplyIsNew, holdStatus: firstReplyHoldStatus } = await assignReviewIfNew(firstReply, video)
comments[comments.length - 1] = await firstReply.save()
// New comment: process auto tags
if (firstReplyIsNew) {
if (comments.length === 1) resultCommentHeldForAutoTags = firstReplyHoldStatus === 'held-for-auto-tags'
createCommentAutomaticTagsJob({
comment: firstReply,
moderation: firstReplyHoldStatus === 'held-for-auto-tags'
? 'release-hold'
: 'none',
// Only the comment the thread was resolved for (comments[0]) must notify the video owner: the other ones
// are ancestors synthesized to complete the thread, not what the Create activity was actually about
notify: comments.length === 1
})
}
for (let i = comments.length - 2; i >= 0; i--) {
const comment = comments[i] as MCommentOwnerVideo
comment.originCommentId = firstReply.id
comment.inReplyToCommentId = comments[i + 1].id
comment.videoId = video.id
comment.changed('updatedAt', true)
comment.Video = video
if (await isRemoteCommentAccepted(comment) !== true) {
return undefined
}
const { isNew, holdStatus } = await assignReviewIfNew(comment, video)
comments[i] = await comment.save()
// New comment: process auto tags
if (isNew) {
if (i === 0) resultCommentHeldForAutoTags = holdStatus === 'held-for-auto-tags'
createCommentAutomaticTagsJob({
comment,
moderation: holdStatus === 'held-for-auto-tags'
? 'release-hold'
: 'none',
// comments[0] is the comment the thread was resolved for: only it must notify the video owner
notify: i === 0
})
}
}
resultComment = comments[0] as MCommentOwnerVideo
}
return { video, comment: resultComment, commentCreated, heldForAutoTags: resultCommentHeldForAutoTags }
}
// Assign the held for review status of the comment if it's a new one
// `holdStatus` is only set for a new comment: an existing one keeps the status it already has in database
// Automatic tags are built by a job, so a comment is held as soon as the account has a review policy
// The job then releases it if the tags it ends up with don't match any of them
async function assignReviewIfNew (comment: MComment, video: MVideoAccountLight): Promise<{
isNew: boolean
holdStatus?: CommentHoldStatus
}> {
// Remote comment already exists in database -> we don't need to rebuild automatic tags
if (comment.id) return { isNew: false }
// Third parties rely on origin, so if origin has the comment it's not held for review
const holdStatus: CommentHoldStatus = video.isLocal() || comment.isLocal()
? await getCommentHoldStatus({ user: null, video, holdIfAutoTagPolicy: true })
: 'not-held'
comment.heldForReview = holdStatus !== 'not-held'
return { isNew: true, holdStatus }
}
// ---------------------------------------------------------------------------
// Despite the name, this also resolves the original leaf/target comment on the first call, not just
// its ancestors: it's the fallback once DB lookup and video resolution have both failed for `url`
async function resolveRemoteParentComment (params: ResolveThreadParams) {
const { url, comments } = params
// Guard against unbounded/malicious inReplyTo chains
if (comments.length > ACTIVITY_PUB.MAX_RECURSION_COMMENTS) {
throw new Error('Recursion limit reached when resolving a thread')
}
const { body } = await fetchAP<any>(url)
if (sanitizeAndCheckVideoCommentObject(body) === false) {
throw new Error(`Remote video comment JSON ${url} is not valid:` + JSON.stringify(body))
}
const actorUrl = body.attributedTo
if (!actorUrl && body.type !== 'Tombstone') throw new Error('Miss attributed to in comment')
// An actor hosted on another server can't author a comment on this one (identity spoofing guard)
if (actorUrl && checkUrlsSameHost(url, actorUrl) !== true) {
throw new Error(`Actor url ${actorUrl} has not the same host than the comment url ${url}`)
}
// The fetched object must claim an id on the same host it was fetched from
if (checkUrlsSameHost(body.id, url) !== true) {
throw new Error(`Comment url ${url} host is different from the AP object id ${body.id}`)
}
const actor = actorUrl
? await getOrCreateAPActor(actorUrl, 'all')
: null
const comment = new VideoCommentModel({
url: body.id,
text: body.content ? body.content : '',
videoId: null,
accountId: actor ? actor.Account.id : null,
inReplyToCommentId: null,
originCommentId: null,
createdAt: new Date(body.published),
updatedAt: new Date(body.updated),
replyApproval: body.replyApproval,
deletedAt: body.deleted
? new Date(body.deleted)
: null
}) as MCommentOwner
comment.Account = actor ? actor.Account : null
logger.debug('Created remote comment %s', comment.url, { comment })
return resolveThread({
url: body.inReplyTo,
comments: comments.concat([ comment ]),
commentCreated: true
})
}
async function isRemoteCommentAccepted (comment: MComment) {
// Already created
if (comment.id) return true
const acceptParameters = {
comment
}
const acceptedResult = await Hooks.wrapFun(
isRemoteVideoCommentAccepted,
acceptParameters,
'filter:activity-pub.remote-video-comment.create.accept.result'
)
if (acceptedResult?.accepted !== true) {
logger.info('Refused to create a remote comment.', { acceptedResult, acceptParameters })
return false
}
return true
}