import * as express from 'express'
-import { eachSeries, waterfall } from 'async'
+import * as Promise from 'bluebird'
import { database as db } from '../../../initializers/database'
import {
remoteQaduVideosValidator,
remoteEventsVideosValidator
} from '../../../middlewares'
-import {
- logger,
- commitTransaction,
- retryTransactionWrapper,
- rollbackTransaction,
- startSerializableTransaction
-} from '../../../helpers'
+import { logger, retryTransactionWrapper } from '../../../helpers'
import { quickAndDirtyUpdatesVideoToFriends } from '../../../lib'
+import { PodInstance, VideoFileInstance } from '../../../models'
+import {
+ RemoteVideoRequest,
+ RemoteVideoCreateData,
+ RemoteVideoUpdateData,
+ RemoteVideoRemoveData,
+ RemoteVideoReportAbuseData,
+ RemoteQaduVideoRequest,
+ RemoteQaduVideoData,
+ RemoteVideoEventRequest,
+ RemoteVideoEventData
+} from '../../../../shared'
const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
// Functions to call when processing a remote request
-const functionsHash = {}
+const functionsHash: { [ id: string ]: (...args) => Promise<any> } = {}
functionsHash[ENDPOINT_ACTIONS.ADD] = addRemoteVideoRetryWrapper
functionsHash[ENDPOINT_ACTIONS.UPDATE] = updateRemoteVideoRetryWrapper
functionsHash[ENDPOINT_ACTIONS.REMOVE] = removeRemoteVideo
// ---------------------------------------------------------------------------
-function remoteVideos (req, res, next) {
- const requests = req.body.data
+function remoteVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const requests: RemoteVideoRequest[] = req.body.data
const fromPod = res.locals.secure.pod
// We need to process in the same order to keep consistency
- // TODO: optimization
- eachSeries(requests, function (request: any, callbackEach) {
+ Promise.each(requests, request => {
const data = request.data
// Get the function we need to call in order to process the request
const fun = functionsHash[request.type]
if (fun === undefined) {
- logger.error('Unkown remote request type %s.', request.type)
- return callbackEach(null)
+ logger.error('Unknown remote request type %s.', request.type)
+ return
}
- fun.call(this, data, fromPod, callbackEach)
- }, function (err) {
- if (err) logger.error('Error managing remote videos.', { error: err })
+ return fun.call(this, data, fromPod)
})
+ .catch(err => logger.error('Error managing remote videos.', err))
- // We don't need to keep the other pod waiting
+ // Don't block the other pod
return res.type('json').status(204).end()
}
-function remoteVideosQadu (req, res, next) {
- const requests = req.body.data
+function remoteVideosQadu (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const requests: RemoteQaduVideoRequest[] = req.body.data
const fromPod = res.locals.secure.pod
- eachSeries(requests, function (request: any, callbackEach) {
+ Promise.each(requests, request => {
const videoData = request.data
- quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod, callbackEach)
- }, function (err) {
- if (err) logger.error('Error managing remote videos.', { error: err })
+ return quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod)
})
+ .catch(err => logger.error('Error managing remote videos.', err))
return res.type('json').status(204).end()
}
-function remoteVideosEvents (req, res, next) {
- const requests = req.body.data
+function remoteVideosEvents (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const requests: RemoteVideoEventRequest[] = req.body.data
const fromPod = res.locals.secure.pod
- eachSeries(requests, function (request: any, callbackEach) {
+ Promise.each(requests, request => {
const eventData = request.data
- processVideosEventsRetryWrapper(eventData, fromPod, callbackEach)
- }, function (err) {
- if (err) logger.error('Error managing remote videos.', { error: err })
+ return processVideosEventsRetryWrapper(eventData, fromPod)
})
+ .catch(err => logger.error('Error managing remote videos.', err))
return res.type('json').status(204).end()
}
-function processVideosEventsRetryWrapper (eventData, fromPod, finalCallback) {
+function processVideosEventsRetryWrapper (eventData: RemoteVideoEventData, fromPod: PodInstance) {
const options = {
arguments: [ eventData, fromPod ],
errorMessage: 'Cannot process videos events with many retries.'
}
- retryTransactionWrapper(processVideosEvents, options, finalCallback)
+ return retryTransactionWrapper(processVideosEvents, options)
}
-function processVideosEvents (eventData, fromPod, finalCallback) {
- waterfall([
- startSerializableTransaction,
+function processVideosEvents (eventData: RemoteVideoEventData, fromPod: PodInstance) {
- function findVideo (t, callback) {
- fetchOwnedVideo(eventData.remoteId, function (err, videoInstance) {
- return callback(err, t, videoInstance)
- })
- },
+ return db.sequelize.transaction(t => {
+ return fetchVideoByUUID(eventData.uuid)
+ .then(videoInstance => {
+ const options = { transaction: t }
- function updateVideoIntoDB (t, videoInstance, callback) {
- const options = { transaction: t }
+ let columnToUpdate
+ let qaduType
- let columnToUpdate
- let qaduType
-
- switch (eventData.eventType) {
+ switch (eventData.eventType) {
case REQUEST_VIDEO_EVENT_TYPES.VIEWS:
columnToUpdate = 'views'
qaduType = REQUEST_VIDEO_QADU_TYPES.VIEWS
break
default:
- return callback(new Error('Unknown video event type.'))
- }
+ throw new Error('Unknown video event type.')
+ }
- const query = {}
- query[columnToUpdate] = eventData.count
+ const query = {}
+ query[columnToUpdate] = eventData.count
- videoInstance.increment(query, options).asCallback(function (err) {
- return callback(err, t, videoInstance, qaduType)
+ return videoInstance.increment(query, options).then(() => ({ videoInstance, qaduType }))
})
- },
-
- function sendQaduToFriends (t, videoInstance, qaduType, callback) {
- const qadusParams = [
- {
- videoId: videoInstance.id,
- type: qaduType
- }
- ]
-
- quickAndDirtyUpdatesVideoToFriends(qadusParams, t, function (err) {
- return callback(err, t)
+ .then(({ videoInstance, qaduType }) => {
+ const qadusParams = [
+ {
+ videoId: videoInstance.id,
+ type: qaduType
+ }
+ ]
+
+ return quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
})
- },
-
- commitTransaction
-
- ], function (err, t) {
- if (err) {
- logger.debug('Cannot process a video event.', { error: err })
- return rollbackTransaction(err, t, finalCallback)
- }
-
- logger.info('Remote video event processed for video %s.', eventData.remoteId)
- return finalCallback(null)
+ })
+ .then(() => logger.info('Remote video event processed for video with uuid %s.', eventData.uuid))
+ .catch(err => {
+ logger.debug('Cannot process a video event.', err)
+ throw err
})
}
-function quickAndDirtyUpdateVideoRetryWrapper (videoData, fromPod, finalCallback) {
+function quickAndDirtyUpdateVideoRetryWrapper (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
const options = {
arguments: [ videoData, fromPod ],
errorMessage: 'Cannot update quick and dirty the remote video with many retries.'
}
- retryTransactionWrapper(quickAndDirtyUpdateVideo, options, finalCallback)
+ return retryTransactionWrapper(quickAndDirtyUpdateVideo, options)
}
-function quickAndDirtyUpdateVideo (videoData, fromPod, finalCallback) {
- let videoName
-
- waterfall([
- startSerializableTransaction,
+function quickAndDirtyUpdateVideo (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
+ let videoUUID = ''
- function findVideo (t, callback) {
- fetchRemoteVideo(fromPod.host, videoData.remoteId, function (err, videoInstance) {
- return callback(err, t, videoInstance)
- })
- },
-
- function updateVideoIntoDB (t, videoInstance, callback) {
- const options = { transaction: t }
+ return db.sequelize.transaction(t => {
+ return fetchVideoByHostAndUUID(fromPod.host, videoData.uuid)
+ .then(videoInstance => {
+ const options = { transaction: t }
- videoName = videoInstance.name
+ videoUUID = videoInstance.uuid
- if (videoData.views) {
- videoInstance.set('views', videoData.views)
- }
+ if (videoData.views) {
+ videoInstance.set('views', videoData.views)
+ }
- if (videoData.likes) {
- videoInstance.set('likes', videoData.likes)
- }
+ if (videoData.likes) {
+ videoInstance.set('likes', videoData.likes)
+ }
- if (videoData.dislikes) {
- videoInstance.set('dislikes', videoData.dislikes)
- }
+ if (videoData.dislikes) {
+ videoInstance.set('dislikes', videoData.dislikes)
+ }
- videoInstance.save(options).asCallback(function (err) {
- return callback(err, t)
+ return videoInstance.save(options)
})
- },
-
- commitTransaction
-
- ], function (err, t) {
- if (err) {
- logger.debug('Cannot quick and dirty update the remote video.', { error: err })
- return rollbackTransaction(err, t, finalCallback)
- }
-
- logger.info('Remote video %s quick and dirty updated', videoName)
- return finalCallback(null)
})
+ .then(() => logger.info('Remote video with uuid %s quick and dirty updated', videoUUID))
+ .catch(err => logger.debug('Cannot quick and dirty update the remote video.', err))
}
// Handle retries on fail
-function addRemoteVideoRetryWrapper (videoToCreateData, fromPod, finalCallback) {
+function addRemoteVideoRetryWrapper (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
const options = {
arguments: [ videoToCreateData, fromPod ],
errorMessage: 'Cannot insert the remote video with many retries.'
}
- retryTransactionWrapper(addRemoteVideo, options, finalCallback)
+ return retryTransactionWrapper(addRemoteVideo, options)
}
-function addRemoteVideo (videoToCreateData, fromPod, finalCallback) {
- logger.debug('Adding remote video "%s".', videoToCreateData.remoteId)
-
- waterfall([
-
- startSerializableTransaction,
-
- function assertRemoteIdAndHostUnique (t, callback) {
- db.Video.loadByHostAndRemoteId(fromPod.host, videoToCreateData.remoteId, function (err, video) {
- if (err) return callback(err)
+function addRemoteVideo (videoToCreateData: RemoteVideoCreateData, fromPod: PodInstance) {
+ logger.debug('Adding remote video "%s".', videoToCreateData.uuid)
- if (video) return callback(new Error('RemoteId and host pair is not unique.'))
+ return db.sequelize.transaction(t => {
+ return db.Video.loadByUUID(videoToCreateData.uuid)
+ .then(video => {
+ if (video) throw new Error('UUID already exists.')
- return callback(null, t)
+ return undefined
})
- },
+ .then(() => {
+ const name = videoToCreateData.author
+ const podId = fromPod.id
+ // This author is from another pod so we do not associate a user
+ const userId = null
- function findOrCreateAuthor (t, callback) {
- const name = videoToCreateData.author
- const podId = fromPod.id
- // This author is from another pod so we do not associate a user
- const userId = null
-
- db.Author.findOrCreateAuthor(name, podId, userId, t, function (err, authorInstance) {
- return callback(err, t, authorInstance)
+ return db.Author.findOrCreateAuthor(name, podId, userId, t)
})
- },
-
- function findOrCreateTags (t, author, callback) {
- const tags = videoToCreateData.tags
+ .then(author => {
+ const tags = videoToCreateData.tags
- db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
- return callback(err, t, author, tagInstances)
+ return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
})
- },
-
- function createVideoObject (t, author, tagInstances, callback) {
- const videoData = {
- name: videoToCreateData.name,
- remoteId: videoToCreateData.remoteId,
- extname: videoToCreateData.extname,
- infoHash: videoToCreateData.infoHash,
- category: videoToCreateData.category,
- licence: videoToCreateData.licence,
- language: videoToCreateData.language,
- nsfw: videoToCreateData.nsfw,
- description: videoToCreateData.description,
- authorId: author.id,
- duration: videoToCreateData.duration,
- createdAt: videoToCreateData.createdAt,
- // FIXME: updatedAt does not seems to be considered by Sequelize
- updatedAt: videoToCreateData.updatedAt,
- views: videoToCreateData.views,
- likes: videoToCreateData.likes,
- dislikes: videoToCreateData.dislikes
- }
-
- const video = db.Video.build(videoData)
-
- return callback(null, t, tagInstances, video)
- },
-
- function generateThumbnail (t, tagInstances, video, callback) {
- db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData, function (err) {
- if (err) {
- logger.error('Cannot generate thumbnail from data.', { error: err })
- return callback(err)
+ .then(({ author, tagInstances }) => {
+ const videoData = {
+ name: videoToCreateData.name,
+ uuid: videoToCreateData.uuid,
+ category: videoToCreateData.category,
+ licence: videoToCreateData.licence,
+ language: videoToCreateData.language,
+ nsfw: videoToCreateData.nsfw,
+ description: videoToCreateData.description,
+ authorId: author.id,
+ duration: videoToCreateData.duration,
+ createdAt: videoToCreateData.createdAt,
+ // FIXME: updatedAt does not seems to be considered by Sequelize
+ updatedAt: videoToCreateData.updatedAt,
+ views: videoToCreateData.views,
+ likes: videoToCreateData.likes,
+ dislikes: videoToCreateData.dislikes,
+ remote: true
}
- return callback(err, t, tagInstances, video)
+ const video = db.Video.build(videoData)
+ return { tagInstances, video }
})
- },
-
- function insertVideoIntoDB (t, tagInstances, video, callback) {
- const options = {
- transaction: t
- }
-
- video.save(options).asCallback(function (err, videoCreated) {
- return callback(err, t, tagInstances, videoCreated)
+ .then(({ tagInstances, video }) => {
+ return db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData).then(() => ({ tagInstances, video }))
})
- },
-
- function associateTagsToVideo (t, tagInstances, video, callback) {
- const options = {
- transaction: t
- }
+ .then(({ tagInstances, video }) => {
+ const options = {
+ transaction: t
+ }
- video.setTags(tagInstances, options).asCallback(function (err) {
- return callback(err, t)
+ return video.save(options).then(videoCreated => ({ tagInstances, videoCreated }))
})
- },
+ .then(({ tagInstances, videoCreated }) => {
+ const tasks = []
+ const options = {
+ transaction: t
+ }
- commitTransaction
+ videoToCreateData.files.forEach(fileData => {
+ const videoFileInstance = db.VideoFile.build({
+ extname: fileData.extname,
+ infoHash: fileData.infoHash,
+ resolution: fileData.resolution,
+ size: fileData.size,
+ videoId: videoCreated.id
+ })
- ], function (err, t) {
- if (err) {
- // This is just a debug because we will retry the insert
- logger.debug('Cannot insert the remote video.', { error: err })
- return rollbackTransaction(err, t, finalCallback)
- }
+ tasks.push(videoFileInstance.save(options))
+ })
+
+ return Promise.all(tasks).then(() => ({ tagInstances, videoCreated }))
+ })
+ .then(({ tagInstances, videoCreated }) => {
+ const options = {
+ transaction: t
+ }
- logger.info('Remote video %s inserted.', videoToCreateData.name)
- return finalCallback(null)
+ return videoCreated.setTags(tagInstances, options)
+ })
+ })
+ .then(() => logger.info('Remote video with uuid %s inserted.', videoToCreateData.uuid))
+ .catch(err => {
+ logger.debug('Cannot insert the remote video.', err)
+ throw err
})
}
// Handle retries on fail
-function updateRemoteVideoRetryWrapper (videoAttributesToUpdate, fromPod, finalCallback) {
+function updateRemoteVideoRetryWrapper (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
const options = {
arguments: [ videoAttributesToUpdate, fromPod ],
errorMessage: 'Cannot update the remote video with many retries'
}
- retryTransactionWrapper(updateRemoteVideo, options, finalCallback)
+ return retryTransactionWrapper(updateRemoteVideo, options)
}
-function updateRemoteVideo (videoAttributesToUpdate, fromPod, finalCallback) {
- logger.debug('Updating remote video "%s".', videoAttributesToUpdate.remoteId)
-
- waterfall([
+function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, fromPod: PodInstance) {
+ logger.debug('Updating remote video "%s".', videoAttributesToUpdate.uuid)
- startSerializableTransaction,
+ return db.sequelize.transaction(t => {
+ return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid)
+ .then(videoInstance => {
+ const tags = videoAttributesToUpdate.tags
- function findVideo (t, callback) {
- fetchRemoteVideo(fromPod.host, videoAttributesToUpdate.remoteId, function (err, videoInstance) {
- return callback(err, t, videoInstance)
+ return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoInstance, tagInstances }))
})
- },
-
- function findOrCreateTags (t, videoInstance, callback) {
- const tags = videoAttributesToUpdate.tags
-
- db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
- return callback(err, t, videoInstance, tagInstances)
- })
- },
-
- function updateVideoIntoDB (t, videoInstance, tagInstances, callback) {
- const options = { transaction: t }
-
- videoInstance.set('name', videoAttributesToUpdate.name)
- videoInstance.set('category', videoAttributesToUpdate.category)
- videoInstance.set('licence', videoAttributesToUpdate.licence)
- videoInstance.set('language', videoAttributesToUpdate.language)
- videoInstance.set('nsfw', videoAttributesToUpdate.nsfw)
- videoInstance.set('description', videoAttributesToUpdate.description)
- videoInstance.set('infoHash', videoAttributesToUpdate.infoHash)
- videoInstance.set('duration', videoAttributesToUpdate.duration)
- videoInstance.set('createdAt', videoAttributesToUpdate.createdAt)
- videoInstance.set('updatedAt', videoAttributesToUpdate.updatedAt)
- videoInstance.set('extname', videoAttributesToUpdate.extname)
- videoInstance.set('views', videoAttributesToUpdate.views)
- videoInstance.set('likes', videoAttributesToUpdate.likes)
- videoInstance.set('dislikes', videoAttributesToUpdate.dislikes)
-
- videoInstance.save(options).asCallback(function (err) {
- return callback(err, t, videoInstance, tagInstances)
+ .then(({ videoInstance, tagInstances }) => {
+ const options = { transaction: t }
+
+ videoInstance.set('name', videoAttributesToUpdate.name)
+ videoInstance.set('category', videoAttributesToUpdate.category)
+ videoInstance.set('licence', videoAttributesToUpdate.licence)
+ videoInstance.set('language', videoAttributesToUpdate.language)
+ videoInstance.set('nsfw', videoAttributesToUpdate.nsfw)
+ videoInstance.set('description', videoAttributesToUpdate.description)
+ videoInstance.set('duration', videoAttributesToUpdate.duration)
+ videoInstance.set('createdAt', videoAttributesToUpdate.createdAt)
+ videoInstance.set('updatedAt', videoAttributesToUpdate.updatedAt)
+ videoInstance.set('views', videoAttributesToUpdate.views)
+ videoInstance.set('likes', videoAttributesToUpdate.likes)
+ videoInstance.set('dislikes', videoAttributesToUpdate.dislikes)
+
+ return videoInstance.save(options).then(() => ({ videoInstance, tagInstances }))
})
- },
+ .then(({ tagInstances, videoInstance }) => {
+ const tasks: Promise<void>[] = []
- function associateTagsToVideo (t, videoInstance, tagInstances, callback) {
- const options = { transaction: t }
+ // Remove old video files
+ videoInstance.VideoFiles.forEach(videoFile => {
+ tasks.push(videoFile.destroy())
+ })
- videoInstance.setTags(tagInstances, options).asCallback(function (err) {
- return callback(err, t)
+ return Promise.all(tasks).then(() => ({ tagInstances, videoInstance }))
})
- },
+ .then(({ tagInstances, videoInstance }) => {
+ const tasks: Promise<VideoFileInstance>[] = []
+ const options = {
+ transaction: t
+ }
- commitTransaction
+ videoAttributesToUpdate.files.forEach(fileData => {
+ const videoFileInstance = db.VideoFile.build({
+ extname: fileData.extname,
+ infoHash: fileData.infoHash,
+ resolution: fileData.resolution,
+ size: fileData.size,
+ videoId: videoInstance.id
+ })
- ], function (err, t) {
- if (err) {
- // This is just a debug because we will retry the insert
- logger.debug('Cannot update the remote video.', { error: err })
- return rollbackTransaction(err, t, finalCallback)
- }
+ tasks.push(videoFileInstance.save(options))
+ })
- logger.info('Remote video %s updated', videoAttributesToUpdate.name)
- return finalCallback(null)
+ return Promise.all(tasks).then(() => ({ tagInstances, videoInstance }))
+ })
+ .then(({ videoInstance, tagInstances }) => {
+ const options = { transaction: t }
+
+ return videoInstance.setTags(tagInstances, options)
+ })
+ })
+ .then(() => logger.info('Remote video with uuid %s updated', videoAttributesToUpdate.uuid))
+ .catch(err => {
+ // This is just a debug because we will retry the insert
+ logger.debug('Cannot update the remote video.', err)
+ throw err
})
}
-function removeRemoteVideo (videoToRemoveData, fromPod, callback) {
+function removeRemoteVideo (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
// We need the instance because we have to remove some other stuffs (thumbnail etc)
- fetchRemoteVideo(fromPod.host, videoToRemoveData.remoteId, function (err, video) {
- // Do not return the error, continue the process
- if (err) return callback(null)
-
- logger.debug('Removing remote video %s.', video.remoteId)
- video.destroy().asCallback(function (err) {
- // Do not return the error, continue the process
- if (err) {
- logger.error('Cannot remove remote video with id %s.', videoToRemoveData.remoteId, { error: err })
- }
-
- return callback(null)
+ return fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid)
+ .then(video => {
+ logger.debug('Removing remote video with uuid %s.', video.uuid)
+ return video.destroy()
+ })
+ .catch(err => {
+ logger.debug('Could not fetch remote video.', { host: fromPod.host, uuid: videoToRemoveData.uuid, error: err.stack })
})
- })
}
-function reportAbuseRemoteVideo (reportData, fromPod, callback) {
- fetchOwnedVideo(reportData.videoRemoteId, function (err, video) {
- if (err || !video) {
- if (!err) err = new Error('video not found')
-
- logger.error('Cannot load video from id.', { error: err, id: reportData.videoRemoteId })
- // Do not return the error, continue the process
- return callback(null)
- }
-
- logger.debug('Reporting remote abuse for video %s.', video.id)
-
- const videoAbuseData = {
- reporterUsername: reportData.reporterUsername,
- reason: reportData.reportReason,
- reporterPodId: fromPod.id,
- videoId: video.id
- }
+function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
+ return fetchVideoByUUID(reportData.videoUUID)
+ .then(video => {
+ logger.debug('Reporting remote abuse for video %s.', video.id)
- db.VideoAbuse.create(videoAbuseData).asCallback(function (err) {
- if (err) {
- logger.error('Cannot create remote abuse video.', { error: err })
+ const videoAbuseData = {
+ reporterUsername: reportData.reporterUsername,
+ reason: reportData.reportReason,
+ reporterPodId: fromPod.id,
+ videoId: video.id
}
- return callback(null)
+ return db.VideoAbuse.create(videoAbuseData)
})
- })
+ .catch(err => logger.error('Cannot create remote abuse video.', err))
}
-function fetchOwnedVideo (id, callback) {
- db.Video.load(id, function (err, video) {
- if (err || !video) {
- if (!err) err = new Error('video not found')
+function fetchVideoByUUID (id: string) {
+ return db.Video.loadByUUID(id)
+ .then(video => {
+ if (!video) throw new Error('Video not found')
- logger.error('Cannot load owned video from id.', { error: err, id })
- return callback(err)
- }
-
- return callback(null, video)
- })
+ return video
+ })
+ .catch(err => {
+ logger.error('Cannot load owned video from id.', { error: err.stack, id })
+ throw err
+ })
}
-function fetchRemoteVideo (podHost, remoteId, callback) {
- db.Video.loadByHostAndRemoteId(podHost, remoteId, function (err, video) {
- if (err || !video) {
- if (!err) err = new Error('video not found')
+function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
+ return db.Video.loadByHostAndUUID(podHost, uuid)
+ .then(video => {
+ if (!video) throw new Error('Video not found')
- logger.error('Cannot load video from host and remote id.', { error: err, podHost, remoteId })
- return callback(err)
- }
-
- return callback(null, video)
- })
+ return video
+ })
+ .catch(err => {
+ logger.error('Cannot load video from host and uuid.', { error: err.stack, podHost, uuid })
+ throw err
+ })
}
projects / github / Chocobozzz / PeerTube.git / blobdiff