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