Move to promises

Closes https://github.com/Chocobozzz/PeerTube/issues/74

1 files changed, 163 insertions, 218 deletions

diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 5e8cf2d25..ed1f21d66 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -1,9 +1,7 @@
 import * as express from 'express'
-import * as Sequelize from 'sequelize'
-import * as fs from 'fs'
+import * as Promise from 'bluebird'
 import * as multer from 'multer'
 import * as path from 'path'
-import { waterfall } from 'async'
 
 import { database as db } from '../../../initializers/database'
 import {
@@ -35,13 +33,12 @@ import {
 } from '../../../middlewares'
 import {
   logger,
-  commitTransaction,
   retryTransactionWrapper,
-  rollbackTransaction,
-  startSerializableTransaction,
   generateRandomString,
-  getFormatedObjects
+  getFormatedObjects,
+  renamePromise
 } from '../../../helpers'
+import { TagInstance } from '../../../models'
 
 import { abuseVideoRouter } from './abuse'
 import { blacklistRouter } from './blacklist'
@@ -60,10 +57,15 @@ const storage = multer.diskStorage({
     if (file.mimetype === 'video/webm') extension = 'webm'
     else if (file.mimetype === 'video/mp4') extension = 'mp4'
     else if (file.mimetype === 'video/ogg') extension = 'ogv'
-    generateRandomString(16, function (err, randomString) {
-      const fieldname = err ? undefined : randomString
-      cb(null, fieldname + '.' + extension)
-    })
+    generateRandomString(16)
+      .then(randomString => {
+        const filename = randomString
+        cb(null, filename + '.' + extension)
+      })
+      .catch(err => {
+        logger.error('Cannot generate random string for file name.', { error: err })
+        throw err
+      })
   }
 })
 
@@ -144,125 +146,97 @@ function addVideoRetryWrapper (req: express.Request, res: express.Response, next
     errorMessage: 'Cannot insert the video with many retries.'
   }
 
-  retryTransactionWrapper(addVideo, options, function (err) {
-    if (err) return next(err)
-
-    // TODO : include Location of the new video -> 201
-    return res.type('json').status(204).end()
-  })
+  retryTransactionWrapper(addVideo, options)
+    .then(() => {
+      // TODO : include Location of the new video -> 201
+      res.type('json').status(204).end()
+    })
+    .catch(err => next(err))
 }
 
-function addVideo (req: express.Request, res: express.Response, videoFile: Express.Multer.File, finalCallback: (err: Error) => void) {
+function addVideo (req: express.Request, res: express.Response, videoFile: Express.Multer.File) {
   const videoInfos = req.body
 
-  waterfall([
-
-    startSerializableTransaction,
+  return db.sequelize.transaction(t => {
+    const user = res.locals.oauth.token.User
 
-    function findOrCreateAuthor (t, callback) {
-      const user = res.locals.oauth.token.User
+    const name = user.username
+    // null because it is OUR pod
+    const podId = null
+    const userId = user.id
 
-      const name = user.username
-      // null because it is OUR pod
-      const podId = null
-      const userId = user.id
+    return db.Author.findOrCreateAuthor(name, podId, userId, t)
+      .then(author => {
+        const tags = videoInfos.tags
+        if (!tags) return { author, tagInstances: undefined }
 
-      db.Author.findOrCreateAuthor(name, podId, userId, t, function (err, authorInstance) {
-        return callback(err, t, authorInstance)
+        return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
       })
-    },
-
-    function findOrCreateTags (t, author, callback) {
-      const tags = videoInfos.tags
-
-      db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
-        return callback(err, t, author, tagInstances)
+      .then(({ author, tagInstances }) => {
+        const videoData = {
+          name: videoInfos.name,
+          remoteId: null,
+          extname: path.extname(videoFile.filename),
+          category: videoInfos.category,
+          licence: videoInfos.licence,
+          language: videoInfos.language,
+          nsfw: videoInfos.nsfw,
+          description: videoInfos.description,
+          duration: videoFile['duration'], // duration was added by a previous middleware
+          authorId: author.id
+        }
+
+        const video = db.Video.build(videoData)
+        return { author, tagInstances, video }
       })
-    },
-
-    function createVideoObject (t, author, tagInstances, callback) {
-      const videoData = {
-        name: videoInfos.name,
-        remoteId: null,
-        extname: path.extname(videoFile.filename),
-        category: videoInfos.category,
-        licence: videoInfos.licence,
-        language: videoInfos.language,
-        nsfw: videoInfos.nsfw,
-        description: videoInfos.description,
-        duration: videoFile['duration'], // duration was added by a previous middleware
-        authorId: author.id
-      }
-
-      const video = db.Video.build(videoData)
-
-      return callback(null, t, author, tagInstances, video)
-    },
-
-     // Set the videoname the same as the id
-    function renameVideoFile (t, author, tagInstances, video, callback) {
-      const videoDir = CONFIG.STORAGE.VIDEOS_DIR
-      const source = path.join(videoDir, videoFile.filename)
-      const destination = path.join(videoDir, video.getVideoFilename())
-
-      fs.rename(source, destination, function (err) {
-        if (err) return callback(err)
-
-        // This is important in case if there is another attempt
-        videoFile.filename = video.getVideoFilename()
-        return callback(null, t, author, tagInstances, video)
+      .then(({ author, tagInstances, video }) => {
+        const videoDir = CONFIG.STORAGE.VIDEOS_DIR
+        const source = path.join(videoDir, videoFile.filename)
+        const destination = path.join(videoDir, video.getVideoFilename())
+
+        return renamePromise(source, destination)
+          .then(() => {
+            // This is important in case if there is another attempt in the retry process
+            videoFile.filename = video.getVideoFilename()
+            return { author, tagInstances, video }
+          })
       })
-    },
-
-    function insertVideoIntoDB (t, author, tagInstances, video, callback) {
-      const options = { transaction: t }
-
-      // Add tags association
-      video.save(options).asCallback(function (err, videoCreated) {
-        if (err) return callback(err)
+      .then(({ author, tagInstances, video }) => {
+        const options = { transaction: t }
 
-        // Do not forget to add Author informations to the created video
-        videoCreated.Author = author
+        return video.save(options)
+          .then(videoCreated => {
+            // Do not forget to add Author informations to the created video
+            videoCreated.Author = author
 
-        return callback(err, t, tagInstances, videoCreated)
+            return { tagInstances, video: videoCreated }
+          })
       })
-    },
-
-    function associateTagsToVideo (t, tagInstances, video, callback) {
-      const options = { transaction: t }
+      .then(({ tagInstances, video }) => {
+        if (!tagInstances) return video
 
-      video.setTags(tagInstances, options).asCallback(function (err) {
-        video.Tags = tagInstances
-
-        return callback(err, t, video)
+        const options = { transaction: t }
+        return video.setTags(tagInstances, options)
+          .then(() => {
+            video.Tags = tagInstances
+            return video
+          })
       })
-    },
-
-    function sendToFriends (t, video, callback) {
-      // Let transcoding job send the video to friends because the videofile extension might change
-      if (CONFIG.TRANSCODING.ENABLED === true) return callback(null, t)
-
-      video.toAddRemoteJSON(function (err, remoteVideo) {
-        if (err) return callback(err)
-
-        // Now we'll add the video's meta data to our friends
-        addVideoToFriends(remoteVideo, t, function (err) {
-          return callback(err, t)
-        })
+      .then(video => {
+        // Let transcoding job send the video to friends because the videofile extension might change
+        if (CONFIG.TRANSCODING.ENABLED === true) return undefined
+
+        return video.toAddRemoteJSON()
+          .then(remoteVideo => {
+            // Now we'll add the video's meta data to our friends
+            return addVideoToFriends(remoteVideo, t)
+          })
       })
-    },
-
-    commitTransaction
-
-  ], function andFinally (err: Error, t: Sequelize.Transaction) {
-    if (err) {
-      // This is just a debug because we will retry the insert
-      logger.debug('Cannot insert the video.', { error: err })
-      return rollbackTransaction(err, t, finalCallback)
-    }
-
-    logger.info('Video with name %s created.', videoInfos.name)
-    return finalCallback(null)
+  })
+  .then(() => logger.info('Video with name %s created.', videoInfos.name))
+  .catch((err: Error) => {
+    logger.debug('Cannot insert the video.', { error: err.stack })
+    throw err
   })
 }
 
@@ -272,92 +246,75 @@ function updateVideoRetryWrapper (req: express.Request, res: express.Response, n
     errorMessage: 'Cannot update the video with many retries.'
   }
 
-  retryTransactionWrapper(updateVideo, options, function (err) {
-    if (err) return next(err)
-
-    // TODO : include Location of the new video -> 201
-    return res.type('json').status(204).end()
-  })
+  retryTransactionWrapper(updateVideo, options)
+    .then(() => {
+      // TODO : include Location of the new video -> 201
+      return res.type('json').status(204).end()
+    })
+    .catch(err => next(err))
 }
 
-function updateVideo (req: express.Request, res: express.Response, finalCallback: (err: Error) => void) {
+function updateVideo (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video
   const videoFieldsSave = videoInstance.toJSON()
   const videoInfosToUpdate = req.body
 
-  waterfall([
-
-    startSerializableTransaction,
-
-    function findOrCreateTags (t, callback) {
-      if (videoInfosToUpdate.tags) {
-        db.Tag.findOrCreateTags(videoInfosToUpdate.tags, t, function (err, tagInstances) {
-          return callback(err, t, tagInstances)
-        })
-      } else {
-        return callback(null, t, null)
-      }
-    },
-
-    function updateVideoIntoDB (t, tagInstances, callback) {
-      const options = {
-        transaction: t
-      }
-
-      if (videoInfosToUpdate.name !== undefined) videoInstance.set('name', videoInfosToUpdate.name)
-      if (videoInfosToUpdate.category !== undefined) videoInstance.set('category', videoInfosToUpdate.category)
-      if (videoInfosToUpdate.licence !== undefined) videoInstance.set('licence', videoInfosToUpdate.licence)
-      if (videoInfosToUpdate.language !== undefined) videoInstance.set('language', videoInfosToUpdate.language)
-      if (videoInfosToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfosToUpdate.nsfw)
-      if (videoInfosToUpdate.description !== undefined) videoInstance.set('description', videoInfosToUpdate.description)
-
-      videoInstance.save(options).asCallback(function (err) {
-        return callback(err, t, tagInstances)
-      })
-    },
-
-    function associateTagsToVideo (t, tagInstances, callback) {
-      if (tagInstances) {
-        const options = { transaction: t }
-
-        videoInstance.setTags(tagInstances, options).asCallback(function (err) {
-          videoInstance.Tags = tagInstances
+  return db.sequelize.transaction(t => {
+    let tagsPromise: Promise<TagInstance[]>
+    if (!videoInfosToUpdate.tags) {
+      tagsPromise = Promise.resolve(null)
+    } else {
+      tagsPromise = db.Tag.findOrCreateTags(videoInfosToUpdate.tags, t)
+    }
 
-          return callback(err, t)
-        })
-      } else {
-        return callback(null, t)
-      }
-    },
+    return tagsPromise
+      .then(tagInstances => {
+        const options = {
+          transaction: t
+        }
 
-    function sendToFriends (t, callback) {
-      const json = videoInstance.toUpdateRemoteJSON()
+        if (videoInfosToUpdate.name !== undefined) videoInstance.set('name', videoInfosToUpdate.name)
+        if (videoInfosToUpdate.category !== undefined) videoInstance.set('category', videoInfosToUpdate.category)
+        if (videoInfosToUpdate.licence !== undefined) videoInstance.set('licence', videoInfosToUpdate.licence)
+        if (videoInfosToUpdate.language !== undefined) videoInstance.set('language', videoInfosToUpdate.language)
+        if (videoInfosToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfosToUpdate.nsfw)
+        if (videoInfosToUpdate.description !== undefined) videoInstance.set('description', videoInfosToUpdate.description)
 
-      // Now we'll update the video's meta data to our friends
-      updateVideoToFriends(json, t, function (err) {
-        return callback(err, t)
+        return videoInstance.save(options).then(() => tagInstances)
       })
-    },
-
-    commitTransaction
+      .then(tagInstances => {
+        if (!tagInstances) return
 
-  ], function andFinally (err: Error, t: Sequelize.Transaction) {
-    if (err) {
-      logger.debug('Cannot update the video.', { error: err })
+        const options = { transaction: t }
+        return videoInstance.setTags(tagInstances, options)
+          .then(() => {
+            videoInstance.Tags = tagInstances
 
-      // Force fields we want to update
-      // If the transaction is retried, sequelize will think the object has not changed
-      // So it will skip the SQL request, even if the last one was ROLLBACKed!
-      Object.keys(videoFieldsSave).forEach(function (key) {
-        const value = videoFieldsSave[key]
-        videoInstance.set(key, value)
+            return
+          })
       })
+      .then(() => {
+        const json = videoInstance.toUpdateRemoteJSON()
 
-      return rollbackTransaction(err, t, finalCallback)
-    }
-
+        // Now we'll update the video's meta data to our friends
+        return updateVideoToFriends(json, t)
+      })
+  })
+  .then(() => {
     logger.info('Video with name %s updated.', videoInstance.name)
-    return finalCallback(null)
+  })
+  .catch(err => {
+    logger.debug('Cannot update the video.', { error: err })
+
+    // Force fields we want to update
+    // If the transaction is retried, sequelize will think the object has not changed
+    // So it will skip the SQL request, even if the last one was ROLLBACKed!
+    Object.keys(videoFieldsSave).forEach(function (key) {
+      const value = videoFieldsSave[key]
+      videoInstance.set(key, value)
+    })
+
+    throw err
   })
 }
 
@@ -366,20 +323,17 @@ function getVideo (req: express.Request, res: express.Response, next: express.Ne
 
   if (videoInstance.isOwned()) {
     // The increment is done directly in the database, not using the instance value
-    videoInstance.increment('views').asCallback(function (err) {
-      if (err) {
-        logger.error('Cannot add view to video %d.', videoInstance.id)
-        return
-      }
-
-      // FIXME: make a real view system
-      // For example, only add a view when a user watch a video during 30s etc
-      const qaduParams = {
-        videoId: videoInstance.id,
-        type: REQUEST_VIDEO_QADU_TYPES.VIEWS
-      }
-      quickAndDirtyUpdateVideoToFriends(qaduParams)
-    })
+    videoInstance.increment('views')
+      .then(() => {
+        // FIXME: make a real view system
+        // For example, only add a view when a user watch a video during 30s etc
+        const qaduParams = {
+          videoId: videoInstance.id,
+          type: REQUEST_VIDEO_QADU_TYPES.VIEWS
+        }
+        return quickAndDirtyUpdateVideoToFriends(qaduParams)
+      })
+      .catch(err => logger.error('Cannot add view to video %d.', videoInstance.id, { error: err }))
   } else {
     // Just send the event to our friends
     const eventParams = {
@@ -394,33 +348,24 @@ function getVideo (req: express.Request, res: express.Response, next: express.Ne
 }
 
 function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.Video.listForApi(req.query.start, req.query.count, req.query.sort, function (err, videosList, videosTotal) {
-    if (err) return next(err)
-
-    res.json(getFormatedObjects(videosList, videosTotal))
-  })
+  db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
+    .then(result => res.json(getFormatedObjects(result.data, result.total)))
+    .catch(err => next(err))
 }
 
 function removeVideo (req: express.Request, res: express.Response, next: express.NextFunction) {
   const videoInstance = res.locals.video
 
-  videoInstance.destroy().asCallback(function (err) {
-    if (err) {
+  videoInstance.destroy()
+    .then(() => res.type('json').status(204).end())
+    .catch(err => {
       logger.error('Errors when removed the video.', { error: err })
       return next(err)
-    }
-
-    return res.type('json').status(204).end()
-  })
+    })
 }
 
 function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.Video.searchAndPopulateAuthorAndPodAndTags(
-    req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
-    function (err, videosList, videosTotal) {
-      if (err) return next(err)
-
-      res.json(getFormatedObjects(videosList, videosTotal))
-    }
-  )
+  db.Video.searchAndPopulateAuthorAndPodAndTags(req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort)
+    .then(result => res.json(getFormatedObjects(result.data, result.total)))
+    .catch(err => next(err))
 }