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 fetchVideoByUUID(eventData.uuid)
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.uuid))
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 fetchVideoByHostAndUUID(fromPod.host, videoData.uuid)
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.uuid)
237 return db.sequelize.transaction(t => {
238 return db.Video.loadByUUID(videoToCreateData.uuid)
240 if (video) throw new Error('UUID already exists.')
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 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,
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,
279 const video = db.Video.build(videoData)
280 return { tagInstances, video }
282 .then(({ tagInstances, video }) => {
283 return db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData).then(() => ({ tagInstances, video }))
285 .then(({ tagInstances, video }) => {
290 return video.save(options).then(videoCreated => ({ tagInstances, videoCreated }))
292 .then(({ tagInstances, videoCreated }) => {
297 return videoCreated.setTags(tagInstances, options)
300 .then(() => logger.info('Remote video %s inserted.', videoToCreateData.name))
302 logger.debug('Cannot insert the remote video.', err)
307 // Handle retries on fail
308 function updateRemoteVideoRetryWrapper (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
310 arguments: [ videoAttributesToUpdate, fromPod ],
311 errorMessage: 'Cannot update the remote video with many retries'
314 return retryTransactionWrapper(updateRemoteVideo, options)
317 function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
318 logger.debug('Updating remote video "%s".', videoAttributesToUpdate.uuid)
320 return db.sequelize.transaction(t => {
321 return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid)
322 .then(videoInstance => {
323 const tags = videoAttributesToUpdate.tags
325 return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoInstance, tagInstances }))
327 .then(({ videoInstance, tagInstances }) => {
328 const options = { transaction: t }
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)
345 return videoInstance.save(options).then(() => ({ videoInstance, tagInstances }))
347 .then(({ videoInstance, tagInstances }) => {
348 const options = { transaction: t }
350 return videoInstance.setTags(tagInstances, options)
353 .then(() => logger.info('Remote video %s updated', videoAttributesToUpdate.name))
355 // This is just a debug because we will retry the insert
356 logger.debug('Cannot update the remote video.', err)
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)
365 logger.debug('Removing remote video %s.', video.uuid)
366 return video.destroy()
369 logger.debug('Could not fetch remote video.', { host: fromPod.host, uuid: videoToRemoveData.uuid, error: err.stack })
373 function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
374 return fetchVideoByUUID(reportData.videoUUID)
376 logger.debug('Reporting remote abuse for video %s.', video.id)
378 const videoAbuseData = {
379 reporterUsername: reportData.reporterUsername,
380 reason: reportData.reportReason,
381 reporterPodId: fromPod.id,
385 return db.VideoAbuse.create(videoAbuseData)
387 .catch(err => logger.error('Cannot create remote abuse video.', err))
390 function fetchVideoByUUID (id: string) {
391 return db.Video.loadByUUID(id)
393 if (!video) throw new Error('Video not found')
398 logger.error('Cannot load owned video from id.', { error: err.stack, id })
403 function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
404 return db.Video.loadByHostAndUUID(podHost, uuid)
406 if (!video) throw new Error('Video not found')
411 logger.error('Cannot load video from host and uuid.', { error: err.stack, podHost, uuid })