server/lib/activitypub/videos.ts

   1 import * as Bluebird from 'bluebird'
   2 import * as sequelize from 'sequelize'
   3 import * as magnetUtil from 'magnet-uri'
   4 import { join } from 'path'
   5 import * as request from 'request'
   6 import { ActivityIconObject, ActivityUrlObject, ActivityVideoUrlObject, VideoState } from '../../../shared/index'
   7 import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
   8 import { VideoPrivacy } from '../../../shared/models/videos'
   9 import { sanitizeAndCheckVideoTorrentObject } from '../../helpers/custom-validators/activitypub/videos'
  10 import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
  11 import { resetSequelizeInstance, retryTransactionWrapper } from '../../helpers/database-utils'
  12 import { logger } from '../../helpers/logger'
  13 import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
  14 import { ACTIVITY_PUB, CONFIG, REMOTE_SCHEME, sequelizeTypescript, VIDEO_MIMETYPE_EXT } from '../../initializers'
  15 import { ActorModel } from '../../models/activitypub/actor'
  16 import { TagModel } from '../../models/video/tag'
  17 import { VideoModel } from '../../models/video/video'
  18 import { VideoChannelModel } from '../../models/video/video-channel'
  19 import { VideoFileModel } from '../../models/video/video-file'
  20 import { getOrCreateActorAndServerAndModel } from './actor'
  21 import { addVideoComments } from './video-comments'
  22 import { crawlCollectionPage } from './crawl'
  23 import { sendCreateVideo, sendUpdateVideo } from './send'
  24 import { isArray } from '../../helpers/custom-validators/misc'
  25 import { VideoCaptionModel } from '../../models/video/video-caption'
  26 import { JobQueue } from '../job-queue'
  27 import { ActivitypubHttpFetcherPayload } from '../job-queue/handlers/activitypub-http-fetcher'
  28 import { createRates } from './video-rates'
  29 import { addVideoShares, shareVideoByServerAndChannel } from './share'
  30 import { AccountModel } from '../../models/account/account'
  31 import { fetchVideoByUrl, VideoFetchByUrlType } from '../../helpers/video'
  32
  33 async function federateVideoIfNeeded (video: VideoModel, isNewVideo: boolean, transaction?: sequelize.Transaction) {
  34   // If the video is not private and published, we federate it
  35   if (video.privacy !== VideoPrivacy.PRIVATE && video.state === VideoState.PUBLISHED) {
  36     // Fetch more attributes that we will need to serialize in AP object
  37     if (isArray(video.VideoCaptions) === false) {
  38       video.VideoCaptions = await video.$get('VideoCaptions', {
  39         attributes: [ 'language' ],
  40         transaction
  41       }) as VideoCaptionModel[]
  42     }
  43
  44     if (isNewVideo) {
  45       // Now we'll add the video's meta data to our followers
  46       await sendCreateVideo(video, transaction)
  47       await shareVideoByServerAndChannel(video, transaction)
  48     } else {
  49       await sendUpdateVideo(video, transaction)
  50     }
  51   }
  52 }
  53
  54 async function fetchRemoteVideo (videoUrl: string): Promise<{ response: request.RequestResponse, videoObject: VideoTorrentObject }> {
  55   const options = {
  56     uri: videoUrl,
  57     method: 'GET',
  58     json: true,
  59     activityPub: true
  60   }
  61
  62   logger.info('Fetching remote video %s.', videoUrl)
  63
  64   const { response, body } = await doRequest(options)
  65
  66   if (sanitizeAndCheckVideoTorrentObject(body) === false) {
  67     logger.debug('Remote video JSON is not valid.', { body })
  68     return { response, videoObject: undefined }
  69   }
  70
  71   return { response, videoObject: body }
  72 }
  73
  74 async function fetchRemoteVideoDescription (video: VideoModel) {
  75   const host = video.VideoChannel.Account.Actor.Server.host
  76   const path = video.getDescriptionAPIPath()
  77   const options = {
  78     uri: REMOTE_SCHEME.HTTP + '://' + host + path,
  79     json: true
  80   }
  81
  82   const { body } = await doRequest(options)
  83   return body.description ? body.description : ''
  84 }
  85
  86 function fetchRemoteVideoStaticFile (video: VideoModel, path: string, reject: Function) {
  87   const host = video.VideoChannel.Account.Actor.Server.host
  88
  89   // We need to provide a callback, if no we could have an uncaught exception
  90   return request.get(REMOTE_SCHEME.HTTP + '://' + host + path, err => {
  91     if (err) reject(err)
  92   })
  93 }
  94
  95 function generateThumbnailFromUrl (video: VideoModel, icon: ActivityIconObject) {
  96   const thumbnailName = video.getThumbnailName()
  97   const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, thumbnailName)
  98
  99   const options = {
 100     method: 'GET',
 101     uri: icon.url
 102   }
 103   return doRequestAndSaveToFile(options, thumbnailPath)
 104 }
 105
 106 function getOrCreateVideoChannelFromVideoObject (videoObject: VideoTorrentObject) {
 107   const channel = videoObject.attributedTo.find(a => a.type === 'Group')
 108   if (!channel) throw new Error('Cannot find associated video channel to video ' + videoObject.url)
 109
 110   return getOrCreateActorAndServerAndModel(channel.id, 'all')
 111 }
 112
 113 type SyncParam = {
 114   likes: boolean
 115   dislikes: boolean
 116   shares: boolean
 117   comments: boolean
 118   thumbnail: boolean
 119   refreshVideo: boolean
 120 }
 121 async function syncVideoExternalAttributes (video: VideoModel, fetchedVideo: VideoTorrentObject, syncParam: SyncParam) {
 122   logger.info('Adding likes/dislikes/shares/comments of video %s.', video.uuid)
 123
 124   const jobPayloads: ActivitypubHttpFetcherPayload[] = []
 125
 126   if (syncParam.likes === true) {
 127     await crawlCollectionPage<string>(fetchedVideo.likes, items => createRates(items, video, 'like'))
 128       .catch(err => logger.error('Cannot add likes of video %s.', video.uuid, { err }))
 129   } else {
 130     jobPayloads.push({ uri: fetchedVideo.likes, videoId: video.id, type: 'video-likes' as 'video-likes' })
 131   }
 132
 133   if (syncParam.dislikes === true) {
 134     await crawlCollectionPage<string>(fetchedVideo.dislikes, items => createRates(items, video, 'dislike'))
 135       .catch(err => logger.error('Cannot add dislikes of video %s.', video.uuid, { err }))
 136   } else {
 137     jobPayloads.push({ uri: fetchedVideo.dislikes, videoId: video.id, type: 'video-dislikes' as 'video-dislikes' })
 138   }
 139
 140   if (syncParam.shares === true) {
 141     await crawlCollectionPage<string>(fetchedVideo.shares, items => addVideoShares(items, video))
 142       .catch(err => logger.error('Cannot add shares of video %s.', video.uuid, { err }))
 143   } else {
 144     jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
 145   }
 146
 147   if (syncParam.comments === true) {
 148     await crawlCollectionPage<string>(fetchedVideo.comments, items => addVideoComments(items, video))
 149       .catch(err => logger.error('Cannot add comments of video %s.', video.uuid, { err }))
 150   } else {
 151     jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
 152   }
 153
 154   await Bluebird.map(jobPayloads, payload => JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload }))
 155 }
 156
 157 async function getOrCreateVideoAndAccountAndChannel (options: {
 158   videoObject: VideoTorrentObject | string,
 159   syncParam?: SyncParam,
 160   fetchType?: VideoFetchByUrlType,
 161   refreshViews?: boolean
 162 }) {
 163   // Default params
 164   const syncParam = options.syncParam || { likes: true, dislikes: true, shares: true, comments: true, thumbnail: true, refreshVideo: false }
 165   const fetchType = options.fetchType || 'all'
 166   const refreshViews = options.refreshViews || false
 167
 168   // Get video url
 169   const videoUrl = typeof options.videoObject === 'string' ? options.videoObject : options.videoObject.id
 170
 171   let videoFromDatabase = await fetchVideoByUrl(videoUrl, fetchType)
 172   if (videoFromDatabase) {
 173     const refreshOptions = {
 174       video: videoFromDatabase,
 175       fetchedType: fetchType,
 176       syncParam,
 177       refreshViews
 178     }
 179     const p = refreshVideoIfNeeded(refreshOptions)
 180     if (syncParam.refreshVideo === true) videoFromDatabase = await p
 181
 182     return { video: videoFromDatabase }
 183   }
 184
 185   const { videoObject: fetchedVideo } = await fetchRemoteVideo(videoUrl)
 186   if (!fetchedVideo) throw new Error('Cannot fetch remote video with url: ' + videoUrl)
 187
 188   const channelActor = await getOrCreateVideoChannelFromVideoObject(fetchedVideo)
 189   const video = await retryTransactionWrapper(createVideo, fetchedVideo, channelActor, syncParam.thumbnail)
 190
 191   await syncVideoExternalAttributes(video, fetchedVideo, syncParam)
 192
 193   return { video }
 194 }
 195
 196 async function updateVideoFromAP (options: {
 197   video: VideoModel,
 198   videoObject: VideoTorrentObject,
 199   account: AccountModel,
 200   channel: VideoChannelModel,
 201   updateViews: boolean,
 202   overrideTo?: string[]
 203 }) {
 204   logger.debug('Updating remote video "%s".', options.videoObject.uuid)
 205   let videoFieldsSave: any
 206
 207   try {
 208     await sequelizeTypescript.transaction(async t => {
 209       const sequelizeOptions = {
 210         transaction: t
 211       }
 212
 213       videoFieldsSave = options.video.toJSON()
 214
 215       // Check actor has the right to update the video
 216       const videoChannel = options.video.VideoChannel
 217       if (videoChannel.Account.id !== options.account.id) {
 218         throw new Error('Account ' + options.account.Actor.url + ' does not own video channel ' + videoChannel.Actor.url)
 219       }
 220
 221       const to = options.overrideTo ? options.overrideTo : options.videoObject.to
 222       const videoData = await videoActivityObjectToDBAttributes(options.channel, options.videoObject, to)
 223       options.video.set('name', videoData.name)
 224       options.video.set('uuid', videoData.uuid)
 225       options.video.set('url', videoData.url)
 226       options.video.set('category', videoData.category)
 227       options.video.set('licence', videoData.licence)
 228       options.video.set('language', videoData.language)
 229       options.video.set('description', videoData.description)
 230       options.video.set('support', videoData.support)
 231       options.video.set('nsfw', videoData.nsfw)
 232       options.video.set('commentsEnabled', videoData.commentsEnabled)
 233       options.video.set('waitTranscoding', videoData.waitTranscoding)
 234       options.video.set('state', videoData.state)
 235       options.video.set('duration', videoData.duration)
 236       options.video.set('createdAt', videoData.createdAt)
 237       options.video.set('publishedAt', videoData.publishedAt)
 238       options.video.set('privacy', videoData.privacy)
 239       options.video.set('channelId', videoData.channelId)
 240
 241       if (options.updateViews === true) options.video.set('views', videoData.views)
 242       await options.video.save(sequelizeOptions)
 243
 244       // Don't block on request
 245       generateThumbnailFromUrl(options.video, options.videoObject.icon)
 246         .catch(err => logger.warn('Cannot generate thumbnail of %s.', options.videoObject.id, { err }))
 247
 248       {
 249         const videoFileAttributes = videoFileActivityUrlToDBAttributes(options.video, options.videoObject)
 250         const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
 251
 252         // Remove video files that do not exist anymore
 253         const destroyTasks = options.video.VideoFiles
 254                                     .filter(f => !newVideoFiles.find(newFile => newFile.hasSameUniqueKeysThan(f)))
 255                                     .map(f => f.destroy(sequelizeOptions))
 256         await Promise.all(destroyTasks)
 257
 258         // Update or add other one
 259         const upsertTasks = videoFileAttributes.map(a => {
 260           return VideoFileModel.upsert<VideoFileModel>(a, { returning: true, transaction: t })
 261             .then(([ file ]) => file)
 262         })
 263
 264         options.video.VideoFiles = await Promise.all(upsertTasks)
 265       }
 266
 267       {
 268         // Update Tags
 269         const tags = options.videoObject.tag.map(tag => tag.name)
 270         const tagInstances = await TagModel.findOrCreateTags(tags, t)
 271         await options.video.$set('Tags', tagInstances, sequelizeOptions)
 272       }
 273
 274       {
 275         // Update captions
 276         await VideoCaptionModel.deleteAllCaptionsOfRemoteVideo(options.video.id, t)
 277
 278         const videoCaptionsPromises = options.videoObject.subtitleLanguage.map(c => {
 279           return VideoCaptionModel.insertOrReplaceLanguage(options.video.id, c.identifier, t)
 280         })
 281         options.video.VideoCaptions = await Promise.all(videoCaptionsPromises)
 282       }
 283     })
 284
 285     logger.info('Remote video with uuid %s updated', options.videoObject.uuid)
 286   } catch (err) {
 287     if (options.video !== undefined && videoFieldsSave !== undefined) {
 288       resetSequelizeInstance(options.video, videoFieldsSave)
 289     }
 290
 291     // This is just a debug because we will retry the insert
 292     logger.debug('Cannot update the remote video.', { err })
 293     throw err
 294   }
 295 }
 296
 297 export {
 298   updateVideoFromAP,
 299   federateVideoIfNeeded,
 300   fetchRemoteVideo,
 301   getOrCreateVideoAndAccountAndChannel,
 302   fetchRemoteVideoStaticFile,
 303   fetchRemoteVideoDescription,
 304   generateThumbnailFromUrl,
 305   getOrCreateVideoChannelFromVideoObject
 306 }
 307
 308 // ---------------------------------------------------------------------------
 309
 310 function isActivityVideoUrlObject (url: ActivityUrlObject): url is ActivityVideoUrlObject {
 311   const mimeTypes = Object.keys(VIDEO_MIMETYPE_EXT)
 312
 313   return mimeTypes.indexOf(url.mimeType) !== -1 && url.mimeType.startsWith('video/')
 314 }
 315
 316 async function createVideo (videoObject: VideoTorrentObject, channelActor: ActorModel, waitThumbnail = false) {
 317   logger.debug('Adding remote video %s.', videoObject.id)
 318
 319   const videoCreated: VideoModel = await sequelizeTypescript.transaction(async t => {
 320     const sequelizeOptions = { transaction: t }
 321
 322     const videoData = await videoActivityObjectToDBAttributes(channelActor.VideoChannel, videoObject, videoObject.to)
 323     const video = VideoModel.build(videoData)
 324
 325     const videoCreated = await video.save(sequelizeOptions)
 326
 327     // Process files
 328     const videoFileAttributes = videoFileActivityUrlToDBAttributes(videoCreated, videoObject)
 329     if (videoFileAttributes.length === 0) {
 330       throw new Error('Cannot find valid files for video %s ' + videoObject.url)
 331     }
 332
 333     const videoFilePromises = videoFileAttributes.map(f => VideoFileModel.create(f, { transaction: t }))
 334     await Promise.all(videoFilePromises)
 335
 336     // Process tags
 337     const tags = videoObject.tag.map(t => t.name)
 338     const tagInstances = await TagModel.findOrCreateTags(tags, t)
 339     await videoCreated.$set('Tags', tagInstances, sequelizeOptions)
 340
 341     // Process captions
 342     const videoCaptionsPromises = videoObject.subtitleLanguage.map(c => {
 343       return VideoCaptionModel.insertOrReplaceLanguage(videoCreated.id, c.identifier, t)
 344     })
 345     await Promise.all(videoCaptionsPromises)
 346
 347     logger.info('Remote video with uuid %s inserted.', videoObject.uuid)
 348
 349     videoCreated.VideoChannel = channelActor.VideoChannel
 350     return videoCreated
 351   })
 352
 353   const p = generateThumbnailFromUrl(videoCreated, videoObject.icon)
 354     .catch(err => logger.warn('Cannot generate thumbnail of %s.', videoObject.id, { err }))
 355
 356   if (waitThumbnail === true) await p
 357
 358   return videoCreated
 359 }
 360
 361 async function refreshVideoIfNeeded (options: {
 362   video: VideoModel,
 363   fetchedType: VideoFetchByUrlType,
 364   syncParam: SyncParam,
 365   refreshViews: boolean
 366 }): Promise<VideoModel> {
 367   if (!options.video.isOutdated()) return options.video
 368
 369   // We need more attributes if the argument video was fetched with not enough joints
 370   const video = options.fetchedType === 'all' ? options.video : await VideoModel.loadByUrlAndPopulateAccount(options.video.url)
 371
 372   try {
 373     const { response, videoObject } = await fetchRemoteVideo(video.url)
 374     if (response.statusCode === 404) {
 375       logger.info('Cannot refresh remote video %s: video does not exist anymore. Deleting it.', video.url)
 376
 377       // Video does not exist anymore
 378       await video.destroy()
 379       return undefined
 380     }
 381
 382     if (videoObject === undefined) {
 383       logger.warn('Cannot refresh remote video %s: invalid body.', video.url)
 384       return video
 385     }
 386
 387     const channelActor = await getOrCreateVideoChannelFromVideoObject(videoObject)
 388     const account = await AccountModel.load(channelActor.VideoChannel.accountId)
 389
 390     const updateOptions = {
 391       video,
 392       videoObject,
 393       account,
 394       channel: channelActor.VideoChannel,
 395       updateViews: options.refreshViews
 396     }
 397     await retryTransactionWrapper(updateVideoFromAP, updateOptions)
 398     await syncVideoExternalAttributes(video, videoObject, options.syncParam)
 399
 400     return video
 401   } catch (err) {
 402     logger.warn('Cannot refresh video %s.', options.video.url, { err })
 403     return video
 404   }
 405 }
 406
 407 async function videoActivityObjectToDBAttributes (
 408   videoChannel: VideoChannelModel,
 409   videoObject: VideoTorrentObject,
 410   to: string[] = []
 411 ) {
 412   const privacy = to.indexOf(ACTIVITY_PUB.PUBLIC) !== -1 ? VideoPrivacy.PUBLIC : VideoPrivacy.UNLISTED
 413   const duration = videoObject.duration.replace(/[^\d]+/, '')
 414
 415   let language: string | undefined
 416   if (videoObject.language) {
 417     language = videoObject.language.identifier
 418   }
 419
 420   let category: number | undefined
 421   if (videoObject.category) {
 422     category = parseInt(videoObject.category.identifier, 10)
 423   }
 424
 425   let licence: number | undefined
 426   if (videoObject.licence) {
 427     licence = parseInt(videoObject.licence.identifier, 10)
 428   }
 429
 430   const description = videoObject.content || null
 431   const support = videoObject.support || null
 432
 433   return {
 434     name: videoObject.name,
 435     uuid: videoObject.uuid,
 436     url: videoObject.id,
 437     category,
 438     licence,
 439     language,
 440     description,
 441     support,
 442     nsfw: videoObject.sensitive,
 443     commentsEnabled: videoObject.commentsEnabled,
 444     waitTranscoding: videoObject.waitTranscoding,
 445     state: videoObject.state,
 446     channelId: videoChannel.id,
 447     duration: parseInt(duration, 10),
 448     createdAt: new Date(videoObject.published),
 449     publishedAt: new Date(videoObject.published),
 450     // FIXME: updatedAt does not seems to be considered by Sequelize
 451     updatedAt: new Date(videoObject.updated),
 452     views: videoObject.views,
 453     likes: 0,
 454     dislikes: 0,
 455     remote: true,
 456     privacy
 457   }
 458 }
 459
 460 function videoFileActivityUrlToDBAttributes (video: VideoModel, videoObject: VideoTorrentObject) {
 461   const fileUrls = videoObject.url.filter(u => isActivityVideoUrlObject(u)) as ActivityVideoUrlObject[]
 462
 463   if (fileUrls.length === 0) {
 464     throw new Error('Cannot find video files for ' + video.url)
 465   }
 466
 467   const attributes: VideoFileModel[] = []
 468   for (const fileUrl of fileUrls) {
 469     // Fetch associated magnet uri
 470     const magnet = videoObject.url.find(u => {
 471       return u.mimeType === 'application/x-bittorrent;x-scheme-handler/magnet' && u.height === fileUrl.height
 472     })
 473
 474     if (!magnet) throw new Error('Cannot find associated magnet uri for file ' + fileUrl.href)
 475
 476     const parsed = magnetUtil.decode(magnet.href)
 477     if (!parsed || isVideoFileInfoHashValid(parsed.infoHash) === false) {
 478       throw new Error('Cannot parse magnet URI ' + magnet.href)
 479     }
 480
 481     const attribute = {
 482       extname: VIDEO_MIMETYPE_EXT[ fileUrl.mimeType ],
 483       infoHash: parsed.infoHash,
 484       resolution: fileUrl.height,
 485       size: fileUrl.size,
 486       videoId: video.id,
 487       fps: fileUrl.fps || -1
 488     } as VideoFileModel
 489     attributes.push(attribute)
 490   }
 491
 492   return attributes
 493 }