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, VideoInstance } 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           extname: videoToCreateData.extname,
 262           infoHash: videoToCreateData.infoHash,
 263           category: videoToCreateData.category,
 264           licence: videoToCreateData.licence,
 265           language: videoToCreateData.language,
 266           nsfw: videoToCreateData.nsfw,
 267           description: videoToCreateData.description,
 268           authorId: author.id,
 269           duration: videoToCreateData.duration,
 270           createdAt: videoToCreateData.createdAt,
 271           // FIXME: updatedAt does not seems to be considered by Sequelize
 272           updatedAt: videoToCreateData.updatedAt,
 273           views: videoToCreateData.views,
 274           likes: videoToCreateData.likes,
 275           dislikes: videoToCreateData.dislikes,
 276           remote: true
 277         }
 278
 279         const video = db.Video.build(videoData)
 280         return { tagInstances, video }
 281       })
 282       .then(({ tagInstances, video }) => {
 283         return db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData).then(() => ({ tagInstances, video }))
 284       })
 285       .then(({ tagInstances, video }) => {
 286         const options = {
 287           transaction: t
 288         }
 289
 290         return video.save(options).then(videoCreated => ({ tagInstances, videoCreated }))
 291       })
 292       .then(({ tagInstances, videoCreated }) => {
 293         const options = {
 294           transaction: t
 295         }
 296
 297         return videoCreated.setTags(tagInstances, options)
 298       })
 299   })
 300   .then(() => logger.info('Remote video %s inserted.', videoToCreateData.name))
 301   .catch(err => {
 302     logger.debug('Cannot insert the remote video.', err)
 303     throw err
 304   })
 305 }
 306
 307 // Handle retries on fail
 308 function updateRemoteVideoRetryWrapper (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
 309   const options = {
 310     arguments: [ videoAttributesToUpdate, fromPod ],
 311     errorMessage: 'Cannot update the remote video with many retries'
 312   }
 313
 314   return retryTransactionWrapper(updateRemoteVideo, options)
 315 }
 316
 317 function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
 318   logger.debug('Updating remote video "%s".', videoAttributesToUpdate.uuid)
 319
 320   return db.sequelize.transaction(t => {
 321     return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid)
 322       .then(videoInstance => {
 323         const tags = videoAttributesToUpdate.tags
 324
 325         return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoInstance, tagInstances }))
 326       })
 327       .then(({ videoInstance, tagInstances }) => {
 328         const options = { transaction: t }
 329
 330         videoInstance.set('name', videoAttributesToUpdate.name)
 331         videoInstance.set('category', videoAttributesToUpdate.category)
 332         videoInstance.set('licence', videoAttributesToUpdate.licence)
 333         videoInstance.set('language', videoAttributesToUpdate.language)
 334         videoInstance.set('nsfw', videoAttributesToUpdate.nsfw)
 335         videoInstance.set('description', videoAttributesToUpdate.description)
 336         videoInstance.set('infoHash', videoAttributesToUpdate.infoHash)
 337         videoInstance.set('duration', videoAttributesToUpdate.duration)
 338         videoInstance.set('createdAt', videoAttributesToUpdate.createdAt)
 339         videoInstance.set('updatedAt', videoAttributesToUpdate.updatedAt)
 340         videoInstance.set('extname', videoAttributesToUpdate.extname)
 341         videoInstance.set('views', videoAttributesToUpdate.views)
 342         videoInstance.set('likes', videoAttributesToUpdate.likes)
 343         videoInstance.set('dislikes', videoAttributesToUpdate.dislikes)
 344
 345         return videoInstance.save(options).then(() => ({ videoInstance, tagInstances }))
 346       })
 347       .then(({ videoInstance, tagInstances }) => {
 348         const options = { transaction: t }
 349
 350         return videoInstance.setTags(tagInstances, options)
 351       })
 352   })
 353   .then(() => logger.info('Remote video %s updated', videoAttributesToUpdate.name))
 354   .catch(err => {
 355     // This is just a debug because we will retry the insert
 356     logger.debug('Cannot update the remote video.', err)
 357     throw err
 358   })
 359 }
 360
 361 function removeRemoteVideo (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
 362   // We need the instance because we have to remove some other stuffs (thumbnail etc)
 363   return fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid)
 364     .then(video => {
 365       logger.debug('Removing remote video %s.', video.uuid)
 366       return video.destroy()
 367     })
 368     .catch(err => {
 369       logger.debug('Could not fetch remote video.', { host: fromPod.host, uuid: videoToRemoveData.uuid, error: err.stack })
 370     })
 371 }
 372
 373 function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
 374   return fetchVideoByUUID(reportData.videoUUID)
 375     .then(video => {
 376       logger.debug('Reporting remote abuse for video %s.', video.id)
 377
 378       const videoAbuseData = {
 379         reporterUsername: reportData.reporterUsername,
 380         reason: reportData.reportReason,
 381         reporterPodId: fromPod.id,
 382         videoId: video.id
 383       }
 384
 385       return db.VideoAbuse.create(videoAbuseData)
 386     })
 387     .catch(err => logger.error('Cannot create remote abuse video.', err))
 388 }
 389
 390 function fetchVideoByUUID (id: string) {
 391   return db.Video.loadByUUID(id)
 392     .then(video => {
 393       if (!video) throw new Error('Video not found')
 394
 395       return video
 396     })
 397     .catch(err => {
 398       logger.error('Cannot load owned video from id.', { error: err.stack, id })
 399       throw err
 400     })
 401 }
 402
 403 function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
 404   return db.Video.loadByHostAndUUID(podHost, uuid)
 405     .then(video => {
 406       if (!video) throw new Error('Video not found')
 407
 408       return video
 409     })
 410     .catch(err => {
 411       logger.error('Cannot load video from host and uuid.', { error: err.stack, podHost, uuid })
 412       throw err
 413     })
 414 }