server/controllers/api/remote/videos.ts

   1 import * as express from 'express'
   2 import * as Promise from 'bluebird'
   3
   4 import { database as db } from '../../../initializers/database'
   5 import {
   6   REQUEST_ENDPOINT_ACTIONS,
   7   REQUEST_ENDPOINTS,
   8   REQUEST_VIDEO_EVENT_TYPES,
   9   REQUEST_VIDEO_QADU_TYPES
  10 } from '../../../initializers'
  11 import {
  12   checkSignature,
  13   signatureValidator,
  14   remoteVideosValidator,
  15   remoteQaduVideosValidator,
  16   remoteEventsVideosValidator
  17 } from '../../../middlewares'
  18 import { logger, retryTransactionWrapper } from '../../../helpers'
  19 import { quickAndDirtyUpdatesVideoToFriends } from '../../../lib'
  20 import { PodInstance } from '../../../models'
  21 import {
  22   RemoteVideoRequest,
  23   RemoteVideoCreateData,
  24   RemoteVideoUpdateData,
  25   RemoteVideoRemoveData,
  26   RemoteVideoReportAbuseData,
  27   RemoteQaduVideoRequest,
  28   RemoteQaduVideoData,
  29   RemoteVideoEventRequest,
  30   RemoteVideoEventData
  31 } from '../../../../shared'
  32
  33 const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
  34
  35 // Functions to call when processing a remote request
  36 const functionsHash: { [ id: string ]: (...args) => Promise<any> } = {}
  37 functionsHash[ENDPOINT_ACTIONS.ADD] = addRemoteVideoRetryWrapper
  38 functionsHash[ENDPOINT_ACTIONS.UPDATE] = updateRemoteVideoRetryWrapper
  39 functionsHash[ENDPOINT_ACTIONS.REMOVE] = removeRemoteVideo
  40 functionsHash[ENDPOINT_ACTIONS.REPORT_ABUSE] = reportAbuseRemoteVideo
  41
  42 const remoteVideosRouter = express.Router()
  43
  44 remoteVideosRouter.post('/',
  45   signatureValidator,
  46   checkSignature,
  47   remoteVideosValidator,
  48   remoteVideos
  49 )
  50
  51 remoteVideosRouter.post('/qadu',
  52   signatureValidator,
  53   checkSignature,
  54   remoteQaduVideosValidator,
  55   remoteVideosQadu
  56 )
  57
  58 remoteVideosRouter.post('/events',
  59   signatureValidator,
  60   checkSignature,
  61   remoteEventsVideosValidator,
  62   remoteVideosEvents
  63 )
  64
  65 // ---------------------------------------------------------------------------
  66
  67 export {
  68   remoteVideosRouter
  69 }
  70
  71 // ---------------------------------------------------------------------------
  72
  73 function remoteVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
  74   const requests: RemoteVideoRequest[] = req.body.data
  75   const fromPod = res.locals.secure.pod
  76
  77   // We need to process in the same order to keep consistency
  78   Promise.each(requests, request => {
  79     const data = request.data
  80
  81     // Get the function we need to call in order to process the request
  82     const fun = functionsHash[request.type]
  83     if (fun === undefined) {
  84       logger.error('Unkown remote request type %s.', request.type)
  85       return
  86     }
  87
  88     return fun.call(this, data, fromPod)
  89   })
  90   .catch(err => logger.error('Error managing remote videos.', err))
  91
  92   // Don't block the other pod
  93   return res.type('json').status(204).end()
  94 }
  95
  96 function remoteVideosQadu (req: express.Request, res: express.Response, next: express.NextFunction) {
  97   const requests: RemoteQaduVideoRequest[] = req.body.data
  98   const fromPod = res.locals.secure.pod
  99
 100   Promise.each(requests, request => {
 101     const videoData = request.data
 102
 103     return quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod)
 104   })
 105   .catch(err => logger.error('Error managing remote videos.', err))
 106
 107   return res.type('json').status(204).end()
 108 }
 109
 110 function remoteVideosEvents (req: express.Request, res: express.Response, next: express.NextFunction) {
 111   const requests: RemoteVideoEventRequest[] = req.body.data
 112   const fromPod = res.locals.secure.pod
 113
 114   Promise.each(requests, request => {
 115     const eventData = request.data
 116
 117     return processVideosEventsRetryWrapper(eventData, fromPod)
 118   })
 119   .catch(err => logger.error('Error managing remote videos.', err))
 120
 121   return res.type('json').status(204).end()
 122 }
 123
 124 function processVideosEventsRetryWrapper (eventData: RemoteVideoEventData, fromPod: PodInstance) {
 125   const options = {
 126     arguments: [ eventData, fromPod ],
 127     errorMessage: 'Cannot process videos events with many retries.'
 128   }
 129
 130   return retryTransactionWrapper(processVideosEvents, options)
 131 }
 132
 133 function processVideosEvents (eventData: RemoteVideoEventData, fromPod: PodInstance) {
 134
 135   return db.sequelize.transaction(t => {
 136     return fetchVideoByUUID(eventData.uuid)
 137       .then(videoInstance => {
 138         const options = { transaction: t }
 139
 140         let columnToUpdate
 141         let qaduType
 142
 143         switch (eventData.eventType) {
 144         case REQUEST_VIDEO_EVENT_TYPES.VIEWS:
 145           columnToUpdate = 'views'
 146           qaduType = REQUEST_VIDEO_QADU_TYPES.VIEWS
 147           break
 148
 149         case REQUEST_VIDEO_EVENT_TYPES.LIKES:
 150           columnToUpdate = 'likes'
 151           qaduType = REQUEST_VIDEO_QADU_TYPES.LIKES
 152           break
 153
 154         case REQUEST_VIDEO_EVENT_TYPES.DISLIKES:
 155           columnToUpdate = 'dislikes'
 156           qaduType = REQUEST_VIDEO_QADU_TYPES.DISLIKES
 157           break
 158
 159         default:
 160           throw new Error('Unknown video event type.')
 161         }
 162
 163         const query = {}
 164         query[columnToUpdate] = eventData.count
 165
 166         return videoInstance.increment(query, options).then(() => ({ videoInstance, qaduType }))
 167       })
 168       .then(({ videoInstance, qaduType }) => {
 169         const qadusParams = [
 170           {
 171             videoId: videoInstance.id,
 172             type: qaduType
 173           }
 174         ]
 175
 176         return quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
 177       })
 178   })
 179   .then(() => logger.info('Remote video event processed for video %s.', eventData.uuid))
 180   .catch(err => {
 181     logger.debug('Cannot process a video event.', err)
 182     throw err
 183   })
 184 }
 185
 186 function quickAndDirtyUpdateVideoRetryWrapper (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
 187   const options = {
 188     arguments: [ videoData, fromPod ],
 189     errorMessage: 'Cannot update quick and dirty the remote video with many retries.'
 190   }
 191
 192   return retryTransactionWrapper(quickAndDirtyUpdateVideo, options)
 193 }
 194
 195 function quickAndDirtyUpdateVideo (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
 196   let videoName
 197
 198   return db.sequelize.transaction(t => {
 199     return fetchVideoByHostAndUUID(fromPod.host, videoData.uuid)
 200       .then(videoInstance => {
 201         const options = { transaction: t }
 202
 203         videoName = videoInstance.name
 204
 205         if (videoData.views) {
 206           videoInstance.set('views', videoData.views)
 207         }
 208
 209         if (videoData.likes) {
 210           videoInstance.set('likes', videoData.likes)
 211         }
 212
 213         if (videoData.dislikes) {
 214           videoInstance.set('dislikes', videoData.dislikes)
 215         }
 216
 217         return videoInstance.save(options)
 218       })
 219   })
 220   .then(() => logger.info('Remote video %s quick and dirty updated', videoName))
 221   .catch(err => logger.debug('Cannot quick and dirty update the remote video.', err))
 222 }
 223
 224 // Handle retries on fail
 225 function addRemoteVideoRetryWrapper (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
 226   const options = {
 227     arguments: [ videoToCreateData, fromPod ],
 228     errorMessage: 'Cannot insert the remote video with many retries.'
 229   }
 230
 231   return retryTransactionWrapper(addRemoteVideo, options)
 232 }
 233
 234 function addRemoteVideo (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
 235   logger.debug('Adding remote video "%s".', videoToCreateData.uuid)
 236
 237   return db.sequelize.transaction(t => {
 238     return db.Video.loadByUUID(videoToCreateData.uuid)
 239       .then(video => {
 240         if (video) throw new Error('UUID already exists.')
 241
 242         return undefined
 243       })
 244       .then(() => {
 245         const name = videoToCreateData.author
 246         const podId = fromPod.id
 247         // This author is from another pod so we do not associate a user
 248         const userId = null
 249
 250         return db.Author.findOrCreateAuthor(name, podId, userId, t)
 251       })
 252       .then(author => {
 253         const tags = videoToCreateData.tags
 254
 255         return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
 256       })
 257       .then(({ author, tagInstances }) => {
 258         const videoData = {
 259           name: videoToCreateData.name,
 260           uuid: videoToCreateData.uuid,
 261           category: videoToCreateData.category,
 262           licence: videoToCreateData.licence,
 263           language: videoToCreateData.language,
 264           nsfw: videoToCreateData.nsfw,
 265           description: videoToCreateData.description,
 266           authorId: author.id,
 267           duration: videoToCreateData.duration,
 268           createdAt: videoToCreateData.createdAt,
 269           // FIXME: updatedAt does not seems to be considered by Sequelize
 270           updatedAt: videoToCreateData.updatedAt,
 271           views: videoToCreateData.views,
 272           likes: videoToCreateData.likes,
 273           dislikes: videoToCreateData.dislikes,
 274           remote: true
 275         }
 276
 277         const video = db.Video.build(videoData)
 278         return { tagInstances, video }
 279       })
 280       .then(({ tagInstances, video }) => {
 281         return db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData).then(() => ({ tagInstances, video }))
 282       })
 283       .then(({ tagInstances, video }) => {
 284         const options = {
 285           transaction: t
 286         }
 287
 288         return video.save(options).then(videoCreated => ({ tagInstances, videoCreated }))
 289       })
 290       .then(({ tagInstances, videoCreated }) => {
 291         const tasks = []
 292         const options = {
 293           transaction: t
 294         }
 295
 296         videoToCreateData.files.forEach(fileData => {
 297           const videoFileInstance = db.VideoFile.build({
 298             extname: fileData.extname,
 299             infoHash: fileData.infoHash,
 300             resolution: fileData.resolution,
 301             size: fileData.size,
 302             videoId: videoCreated.id
 303           })
 304
 305           tasks.push(videoFileInstance.save(options))
 306         })
 307
 308         return Promise.all(tasks).then(() => ({ tagInstances, videoCreated }))
 309       })
 310       .then(({ tagInstances, videoCreated }) => {
 311         const options = {
 312           transaction: t
 313         }
 314
 315         return videoCreated.setTags(tagInstances, options)
 316       })
 317   })
 318   .then(() => logger.info('Remote video %s inserted.', videoToCreateData.name))
 319   .catch(err => {
 320     logger.debug('Cannot insert the remote video.', err)
 321     throw err
 322   })
 323 }
 324
 325 // Handle retries on fail
 326 function updateRemoteVideoRetryWrapper (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
 327   const options = {
 328     arguments: [ videoAttributesToUpdate, fromPod ],
 329     errorMessage: 'Cannot update the remote video with many retries'
 330   }
 331
 332   return retryTransactionWrapper(updateRemoteVideo, options)
 333 }
 334
 335 function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
 336   logger.debug('Updating remote video "%s".', videoAttributesToUpdate.uuid)
 337
 338   return db.sequelize.transaction(t => {
 339     return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid)
 340       .then(videoInstance => {
 341         const tags = videoAttributesToUpdate.tags
 342
 343         return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoInstance, tagInstances }))
 344       })
 345       .then(({ videoInstance, tagInstances }) => {
 346         const options = { transaction: t }
 347
 348         videoInstance.set('name', videoAttributesToUpdate.name)
 349         videoInstance.set('category', videoAttributesToUpdate.category)
 350         videoInstance.set('licence', videoAttributesToUpdate.licence)
 351         videoInstance.set('language', videoAttributesToUpdate.language)
 352         videoInstance.set('nsfw', videoAttributesToUpdate.nsfw)
 353         videoInstance.set('description', videoAttributesToUpdate.description)
 354         videoInstance.set('duration', videoAttributesToUpdate.duration)
 355         videoInstance.set('createdAt', videoAttributesToUpdate.createdAt)
 356         videoInstance.set('updatedAt', videoAttributesToUpdate.updatedAt)
 357         videoInstance.set('views', videoAttributesToUpdate.views)
 358         videoInstance.set('likes', videoAttributesToUpdate.likes)
 359         videoInstance.set('dislikes', videoAttributesToUpdate.dislikes)
 360
 361         return videoInstance.save(options).then(() => ({ videoInstance, tagInstances }))
 362       })
 363       .then(({ tagInstances, videoInstance }) => {
 364         const tasks = []
 365         const options = {
 366           transaction: t
 367         }
 368
 369         videoAttributesToUpdate.files.forEach(fileData => {
 370           const videoFileInstance = db.VideoFile.build({
 371             extname: fileData.extname,
 372             infoHash: fileData.infoHash,
 373             resolution: fileData.resolution,
 374             size: fileData.size,
 375             videoId: videoInstance.id
 376           })
 377
 378           tasks.push(videoFileInstance.save(options))
 379         })
 380
 381         return Promise.all(tasks).then(() => ({ tagInstances, videoInstance }))
 382       })
 383       .then(({ videoInstance, tagInstances }) => {
 384         const options = { transaction: t }
 385
 386         return videoInstance.setTags(tagInstances, options)
 387       })
 388   })
 389   .then(() => logger.info('Remote video %s updated', videoAttributesToUpdate.name))
 390   .catch(err => {
 391     // This is just a debug because we will retry the insert
 392     logger.debug('Cannot update the remote video.', err)
 393     throw err
 394   })
 395 }
 396
 397 function removeRemoteVideo (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
 398   // We need the instance because we have to remove some other stuffs (thumbnail etc)
 399   return fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid)
 400     .then(video => {
 401       logger.debug('Removing remote video %s.', video.uuid)
 402       return video.destroy()
 403     })
 404     .catch(err => {
 405       logger.debug('Could not fetch remote video.', { host: fromPod.host, uuid: videoToRemoveData.uuid, error: err.stack })
 406     })
 407 }
 408
 409 function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
 410   return fetchVideoByUUID(reportData.videoUUID)
 411     .then(video => {
 412       logger.debug('Reporting remote abuse for video %s.', video.id)
 413
 414       const videoAbuseData = {
 415         reporterUsername: reportData.reporterUsername,
 416         reason: reportData.reportReason,
 417         reporterPodId: fromPod.id,
 418         videoId: video.id
 419       }
 420
 421       return db.VideoAbuse.create(videoAbuseData)
 422     })
 423     .catch(err => logger.error('Cannot create remote abuse video.', err))
 424 }
 425
 426 function fetchVideoByUUID (id: string) {
 427   return db.Video.loadByUUID(id)
 428     .then(video => {
 429       if (!video) throw new Error('Video not found')
 430
 431       return video
 432     })
 433     .catch(err => {
 434       logger.error('Cannot load owned video from id.', { error: err.stack, id })
 435       throw err
 436     })
 437 }
 438
 439 function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
 440   return db.Video.loadByHostAndUUID(podHost, uuid)
 441     .then(video => {
 442       if (!video) throw new Error('Video not found')
 443
 444       return video
 445     })
 446     .catch(err => {
 447       logger.error('Cannot load video from host and uuid.', { error: err.stack, podHost, uuid })
 448       throw err
 449     })
 450 }