1 import * as express from 'express'
2 import * as Promise from 'bluebird'
4 import { database as db } from '../../../initializers/database'
6 REQUEST_ENDPOINT_ACTIONS,
8 REQUEST_VIDEO_EVENT_TYPES,
9 REQUEST_VIDEO_QADU_TYPES
10 } from '../../../initializers'
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'
23 RemoteVideoCreateData,
24 RemoteVideoUpdateData,
25 RemoteVideoRemoveData,
26 RemoteVideoReportAbuseData,
27 RemoteQaduVideoRequest,
29 RemoteVideoEventRequest,
31 } from '../../../../shared'
33 const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
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
42 const remoteVideosRouter = express.Router()
44 remoteVideosRouter.post('/',
47 remoteVideosValidator,
51 remoteVideosRouter.post('/qadu',
54 remoteQaduVideosValidator,
58 remoteVideosRouter.post('/events',
61 remoteEventsVideosValidator,
65 // ---------------------------------------------------------------------------
71 // ---------------------------------------------------------------------------
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
77 // We need to process in the same order to keep consistency
78 Promise.each(requests, request => {
79 const data = request.data
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)
88 return fun.call(this, data, fromPod)
90 .catch(err => logger.error('Error managing remote videos.', err))
92 // Don't block the other pod
93 return res.type('json').status(204).end()
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
100 Promise.each(requests, request => {
101 const videoData = request.data
103 return quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod)
105 .catch(err => logger.error('Error managing remote videos.', err))
107 return res.type('json').status(204).end()
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
114 Promise.each(requests, request => {
115 const eventData = request.data
117 return processVideosEventsRetryWrapper(eventData, fromPod)
119 .catch(err => logger.error('Error managing remote videos.', err))
121 return res.type('json').status(204).end()
124 function processVideosEventsRetryWrapper (eventData: RemoteVideoEventData, fromPod: PodInstance) {
126 arguments: [ eventData, fromPod ],
127 errorMessage: 'Cannot process videos events with many retries.'
130 return retryTransactionWrapper(processVideosEvents, options)
133 function processVideosEvents (eventData: RemoteVideoEventData, fromPod: PodInstance) {
135 return db.sequelize.transaction(t => {
136 return fetchOwnedVideo(eventData.remoteId)
137 .then(videoInstance => {
138 const options = { transaction: t }
143 switch (eventData.eventType) {
144 case REQUEST_VIDEO_EVENT_TYPES.VIEWS:
145 columnToUpdate = 'views'
146 qaduType = REQUEST_VIDEO_QADU_TYPES.VIEWS
149 case REQUEST_VIDEO_EVENT_TYPES.LIKES:
150 columnToUpdate = 'likes'
151 qaduType = REQUEST_VIDEO_QADU_TYPES.LIKES
154 case REQUEST_VIDEO_EVENT_TYPES.DISLIKES:
155 columnToUpdate = 'dislikes'
156 qaduType = REQUEST_VIDEO_QADU_TYPES.DISLIKES
160 throw new Error('Unknown video event type.')
164 query[columnToUpdate] = eventData.count
166 return videoInstance.increment(query, options).then(() => ({ videoInstance, qaduType }))
168 .then(({ videoInstance, qaduType }) => {
169 const qadusParams = [
171 videoId: videoInstance.id,
176 return quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
179 .then(() => logger.info('Remote video event processed for video %s.', eventData.remoteId))
181 logger.debug('Cannot process a video event.', err)
186 function quickAndDirtyUpdateVideoRetryWrapper (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
188 arguments: [ videoData, fromPod ],
189 errorMessage: 'Cannot update quick and dirty the remote video with many retries.'
192 return retryTransactionWrapper(quickAndDirtyUpdateVideo, options)
195 function quickAndDirtyUpdateVideo (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
198 return db.sequelize.transaction(t => {
199 return fetchRemoteVideo(fromPod.host, videoData.remoteId)
200 .then(videoInstance => {
201 const options = { transaction: t }
203 videoName = videoInstance.name
205 if (videoData.views) {
206 videoInstance.set('views', videoData.views)
209 if (videoData.likes) {
210 videoInstance.set('likes', videoData.likes)
213 if (videoData.dislikes) {
214 videoInstance.set('dislikes', videoData.dislikes)
217 return videoInstance.save(options)
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))
224 // Handle retries on fail
225 function addRemoteVideoRetryWrapper (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
227 arguments: [ videoToCreateData, fromPod ],
228 errorMessage: 'Cannot insert the remote video with many retries.'
231 return retryTransactionWrapper(addRemoteVideo, options)
234 function addRemoteVideo (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
235 logger.debug('Adding remote video "%s".', videoToCreateData.remoteId)
237 return db.sequelize.transaction(t => {
238 return db.Video.loadByHostAndRemoteId(fromPod.host, videoToCreateData.remoteId)
240 if (video) throw new Error('RemoteId and host pair is not unique.')
245 const name = videoToCreateData.author
246 const podId = fromPod.id
247 // This author is from another pod so we do not associate a user
250 return db.Author.findOrCreateAuthor(name, podId, userId, t)
253 const tags = videoToCreateData.tags
255 return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
257 .then(({ author, tagInstances }) => {
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,
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
278 const video = db.Video.build(videoData)
279 return { tagInstances, video }
281 .then(({ tagInstances, video }) => {
282 return db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData).then(() => ({ tagInstances, video }))
284 .then(({ tagInstances, video }) => {
289 return video.save(options).then(videoCreated => ({ tagInstances, videoCreated }))
291 .then(({ tagInstances, videoCreated }) => {
296 return videoCreated.setTags(tagInstances, options)
299 .then(() => logger.info('Remote video %s inserted.', videoToCreateData.name))
301 logger.debug('Cannot insert the remote video.', err)
306 // Handle retries on fail
307 function updateRemoteVideoRetryWrapper (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
309 arguments: [ videoAttributesToUpdate, fromPod ],
310 errorMessage: 'Cannot update the remote video with many retries'
313 return retryTransactionWrapper(updateRemoteVideo, options)
316 function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
317 logger.debug('Updating remote video "%s".', videoAttributesToUpdate.remoteId)
319 return db.sequelize.transaction(t => {
320 return fetchRemoteVideo(fromPod.host, videoAttributesToUpdate.remoteId)
321 .then(videoInstance => {
322 const tags = videoAttributesToUpdate.tags
324 return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoInstance, tagInstances }))
326 .then(({ videoInstance, tagInstances }) => {
327 const options = { transaction: t }
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)
344 return videoInstance.save(options).then(() => ({ videoInstance, tagInstances }))
346 .then(({ videoInstance, tagInstances }) => {
347 const options = { transaction: t }
349 return videoInstance.setTags(tagInstances, options)
352 .then(() => logger.info('Remote video %s updated', videoAttributesToUpdate.name))
354 // This is just a debug because we will retry the insert
355 logger.debug('Cannot update the remote video.', err)
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)
364 logger.debug('Removing remote video %s.', video.remoteId)
365 return video.destroy()
368 logger.debug('Could not fetch remote video.', { host: fromPod.host, remoteId: videoToRemoveData.remoteId, error: err.stack })
372 function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
373 return fetchOwnedVideo(reportData.videoRemoteId)
375 logger.debug('Reporting remote abuse for video %s.', video.id)
377 const videoAbuseData = {
378 reporterUsername: reportData.reporterUsername,
379 reason: reportData.reportReason,
380 reporterPodId: fromPod.id,
384 return db.VideoAbuse.create(videoAbuseData)
386 .catch(err => logger.error('Cannot create remote abuse video.', err))
389 function fetchOwnedVideo (id: string) {
390 return db.Video.load(id)
392 if (!video) throw new Error('Video not found')
397 logger.error('Cannot load owned video from id.', { error: err.stack, id })
402 function fetchRemoteVideo (podHost: string, remoteId: string) {
403 return db.Video.loadByHostAndRemoteId(podHost, remoteId)
405 if (!video) throw new Error('Video not found')
410 logger.error('Cannot load video from host and remote id.', { error: err.stack, podHost, remoteId })