Use async/await in controllers

5 files changed, 361 insertions, 461 deletions

diff --git a/server/controllers/api/videos/abuse.ts b/server/controllers/api/videos/abuse.ts
index c9313d5f5..4c7abf395 100644
--- a/server/controllers/api/videos/abuse.ts
+++ b/server/controllers/api/videos/abuse.ts
@@ -14,7 +14,8 @@ import {
   videoAbuseReportValidator,
   videoAbusesSortValidator,
   setVideoAbusesSort,
-  setPagination
+  setPagination,
+  asyncMiddleware
 } from '../../../middlewares'
 import { VideoInstance } from '../../../models'
 import { VideoAbuseCreate } from '../../../../shared'
@@ -28,12 +29,12 @@ abuseVideoRouter.get('/abuse',
   videoAbusesSortValidator,
   setVideoAbusesSort,
   setPagination,
-  listVideoAbuses
+  asyncMiddleware(listVideoAbuses)
 )
 abuseVideoRouter.post('/:id/abuse',
   authenticate,
   videoAbuseReportValidator,
-  reportVideoAbuseRetryWrapper
+  asyncMiddleware(reportVideoAbuseRetryWrapper)
 )
 
 // ---------------------------------------------------------------------------
@@ -44,55 +45,48 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function listVideoAbuses (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.VideoAbuse.listForApi(req.query.start, req.query.count, req.query.sort)
-    .then(result => res.json(getFormattedObjects(result.data, result.total)))
-    .catch(err => next(err))
+async function listVideoAbuses (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.VideoAbuse.listForApi(req.query.start, req.query.count, req.query.sort)
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-function reportVideoAbuseRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function reportVideoAbuseRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot report abuse to the video with many retries.'
   }
 
-  retryTransactionWrapper(reportVideoAbuse, options)
-    .then(() => res.type('json').status(204).end())
-    .catch(err => next(err))
+  await retryTransactionWrapper(reportVideoAbuse, options)
+
+  return res.type('json').status(204).end()
 }
 
-function reportVideoAbuse (req: express.Request, res: express.Response) {
+async function reportVideoAbuse (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video as VideoInstance
   const reporterUsername = res.locals.oauth.token.User.username
   const body: VideoAbuseCreate = req.body
 
-  const abuse = {
+  const abuseToCreate = {
     reporterUsername,
     reason: body.reason,
     videoId: videoInstance.id,
     reporterPodId: null // This is our pod that reported this abuse
   }
 
-  return db.sequelize.transaction(t => {
-    return db.VideoAbuse.create(abuse, { transaction: t })
-      .then(abuse => {
-        // We send the information to the destination pod
-        if (videoInstance.isOwned() === false) {
-          const reportData = {
-            reporterUsername,
-            reportReason: abuse.reason,
-            videoUUID: videoInstance.uuid
-          }
-
-          return friends.reportAbuseVideoToFriend(reportData, videoInstance, t).then(() => videoInstance)
-        }
-
-        return videoInstance
-      })
-  })
-  .then((videoInstance: VideoInstance) => logger.info('Abuse report for video %s created.', videoInstance.name))
-  .catch(err => {
-    logger.debug('Cannot update the video.', err)
-    throw err
+  await db.sequelize.transaction(async t => {
+    const abuse = await db.VideoAbuse.create(abuseToCreate, { transaction: t })
+    // We send the information to the destination pod
+    if (videoInstance.isOwned() === false) {
+      const reportData = {
+        reporterUsername,
+        reportReason: abuse.reason,
+        videoUUID: videoInstance.uuid
+      }
+
+      await friends.reportAbuseVideoToFriend(reportData, videoInstance, t)
+    }
   })
+
+  logger.info('Abuse report for video %s created.', videoInstance.name)
 }
diff --git a/server/controllers/api/videos/blacklist.ts b/server/controllers/api/videos/blacklist.ts
index 66311598e..5a2c3fd80 100644
--- a/server/controllers/api/videos/blacklist.ts
+++ b/server/controllers/api/videos/blacklist.ts
@@ -10,7 +10,8 @@ import {
   paginationValidator,
   blacklistSortValidator,
   setBlacklistSort,
-  setPagination
+  setPagination,
+  asyncMiddleware
 } from '../../../middlewares'
 import { BlacklistedVideoInstance } from '../../../models'
 import { BlacklistedVideo } from '../../../../shared'
@@ -21,7 +22,7 @@ blacklistRouter.post('/:videoId/blacklist',
   authenticate,
   ensureIsAdmin,
   videosBlacklistAddValidator,
-  addVideoToBlacklist
+  asyncMiddleware(addVideoToBlacklist)
 )
 
 blacklistRouter.get('/blacklist',
@@ -31,14 +32,14 @@ blacklistRouter.get('/blacklist',
   blacklistSortValidator,
   setBlacklistSort,
   setPagination,
-  listBlacklist
+  asyncMiddleware(listBlacklist)
 )
 
 blacklistRouter.delete('/:videoId/blacklist',
   authenticate,
   ensureIsAdmin,
   videosBlacklistRemoveValidator,
-  removeVideoFromBlacklistController
+  asyncMiddleware(removeVideoFromBlacklistController)
 )
 
 // ---------------------------------------------------------------------------
@@ -49,37 +50,34 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function addVideoToBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function addVideoToBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
   const videoInstance = res.locals.video
 
   const toCreate = {
     videoId: videoInstance.id
   }
 
-  db.BlacklistedVideo.create(toCreate)
-    .then(() => res.type('json').status(204).end())
-    .catch(err => {
-      logger.error('Errors when blacklisting video ', err)
-      return next(err)
-    })
+  await db.BlacklistedVideo.create(toCreate)
+  return res.type('json').status(204).end()
 }
 
-function listBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.BlacklistedVideo.listForApi(req.query.start, req.query.count, req.query.sort)
-    .then(resultList => res.json(getFormattedObjects<BlacklistedVideo, BlacklistedVideoInstance>(resultList.data, resultList.total)))
-    .catch(err => next(err))
+async function listBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.BlacklistedVideo.listForApi(req.query.start, req.query.count, req.query.sort)
+
+  return res.json(getFormattedObjects<BlacklistedVideo, BlacklistedVideoInstance>(resultList.data, resultList.total))
 }
 
-function removeVideoFromBlacklistController (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function removeVideoFromBlacklistController (req: express.Request, res: express.Response, next: express.NextFunction) {
   const blacklistedVideo = res.locals.blacklistedVideo as BlacklistedVideoInstance
 
-  blacklistedVideo.destroy()
-    .then(() => {
-      logger.info('Video %s removed from blacklist.', res.locals.video.uuid)
-      res.sendStatus(204)
-    })
-    .catch(err => {
-      logger.error('Some error while removing video %s from blacklist.', res.locals.video.uuid, err)
-      next(err)
-    })
+  try {
+    await blacklistedVideo.destroy()
+
+    logger.info('Video %s removed from blacklist.', res.locals.video.uuid)
+
+    return res.sendStatus(204)
+  } catch (err) {
+    logger.error('Some error while removing video %s from blacklist.', res.locals.video.uuid, err)
+    throw err
+  }
 }
diff --git a/server/controllers/api/videos/channel.ts b/server/controllers/api/videos/channel.ts
index 630fc4f53..ab54eedee 100644
--- a/server/controllers/api/videos/channel.ts
+++ b/server/controllers/api/videos/channel.ts
@@ -4,7 +4,8 @@ import { database as db } from '../../../initializers'
 import {
   logger,
   getFormattedObjects,
-  retryTransactionWrapper
+  retryTransactionWrapper,
+  resetSequelizeInstance
 } from '../../../helpers'
 import {
   authenticate,
@@ -16,7 +17,8 @@ import {
   videoChannelsRemoveValidator,
   videoChannelGetValidator,
   videoChannelsUpdateValidator,
-  listVideoAuthorChannelsValidator
+  listVideoAuthorChannelsValidator,
+  asyncMiddleware
 } from '../../../middlewares'
 import {
   createVideoChannel,
@@ -32,18 +34,18 @@ videoChannelRouter.get('/channels',
   videoChannelsSortValidator,
   setVideoChannelsSort,
   setPagination,
-  listVideoChannels
+  asyncMiddleware(listVideoChannels)
 )
 
 videoChannelRouter.get('/authors/:authorId/channels',
   listVideoAuthorChannelsValidator,
-  listVideoAuthorChannels
+  asyncMiddleware(listVideoAuthorChannels)
 )
 
 videoChannelRouter.post('/channels',
   authenticate,
   videoChannelsAddValidator,
-  addVideoChannelRetryWrapper
+  asyncMiddleware(addVideoChannelRetryWrapper)
 )
 
 videoChannelRouter.put('/channels/:id',
@@ -55,12 +57,12 @@ videoChannelRouter.put('/channels/:id',
 videoChannelRouter.delete('/channels/:id',
   authenticate,
   videoChannelsRemoveValidator,
-  removeVideoChannelRetryWrapper
+  asyncMiddleware(removeVideoChannelRetryWrapper)
 )
 
 videoChannelRouter.get('/channels/:id',
   videoChannelGetValidator,
-  getVideoChannel
+  asyncMiddleware(getVideoChannel)
 )
 
 // ---------------------------------------------------------------------------
@@ -71,126 +73,113 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function listVideoChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.VideoChannel.listForApi(req.query.start, req.query.count, req.query.sort)
-    .then(result => res.json(getFormattedObjects(result.data, result.total)))
-    .catch(err => next(err))
+async function listVideoChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.VideoChannel.listForApi(req.query.start, req.query.count, req.query.sort)
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-function listVideoAuthorChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.VideoChannel.listByAuthor(res.locals.author.id)
-    .then(result => res.json(getFormattedObjects(result.data, result.total)))
-    .catch(err => next(err))
+async function listVideoAuthorChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.VideoChannel.listByAuthor(res.locals.author.id)
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-// Wrapper to video channel add that retry the function if there is a database error
+// Wrapper to video channel add that retry the async function if there is a database error
 // We need this because we run the transaction in SERIALIZABLE isolation that can fail
-function addVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function addVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot insert the video video channel with many retries.'
   }
 
-  retryTransactionWrapper(addVideoChannel, options)
-    .then(() => {
-      // TODO : include Location of the new video channel -> 201
-      res.type('json').status(204).end()
-    })
-    .catch(err => next(err))
+  await retryTransactionWrapper(addVideoChannel, options)
+
+  // TODO : include Location of the new video channel -> 201
+  return res.type('json').status(204).end()
 }
 
-function addVideoChannel (req: express.Request, res: express.Response) {
+async function addVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelInfo: VideoChannelCreate = req.body
   const author: AuthorInstance = res.locals.oauth.token.User.Author
+  let videoChannelCreated: VideoChannelInstance
 
-  return db.sequelize.transaction(t => {
-    return createVideoChannel(videoChannelInfo, author, t)
-  })
-  .then(videoChannelUUID => logger.info('Video channel with uuid %s created.', videoChannelUUID))
-  .catch((err: Error) => {
-    logger.debug('Cannot insert the video channel.', err)
-    throw err
+  await db.sequelize.transaction(async t => {
+    videoChannelCreated = await createVideoChannel(videoChannelInfo, author, t)
   })
+
+  logger.info('Video channel with uuid %s created.', videoChannelCreated.uuid)
 }
 
-function updateVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot update the video with many retries.'
   }
 
-  retryTransactionWrapper(updateVideoChannel, options)
-    .then(() => res.type('json').status(204).end())
-    .catch(err => next(err))
+  await retryTransactionWrapper(updateVideoChannel, options)
+
+  return res.type('json').status(204).end()
 }
 
-function updateVideoChannel (req: express.Request, res: express.Response) {
+async function updateVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelInstance: VideoChannelInstance = res.locals.videoChannel
   const videoChannelFieldsSave = videoChannelInstance.toJSON()
   const videoChannelInfoToUpdate: VideoChannelUpdate = req.body
 
-  return db.sequelize.transaction(t => {
-    const options = {
-      transaction: t
-    }
+  try {
+    await db.sequelize.transaction(async t => {
+      const sequelizeOptions = {
+        transaction: t
+      }
 
-    if (videoChannelInfoToUpdate.name !== undefined) videoChannelInstance.set('name', videoChannelInfoToUpdate.name)
-    if (videoChannelInfoToUpdate.description !== undefined) videoChannelInstance.set('description', videoChannelInfoToUpdate.description)
+      if (videoChannelInfoToUpdate.name !== undefined) videoChannelInstance.set('name', videoChannelInfoToUpdate.name)
+      if (videoChannelInfoToUpdate.description !== undefined) videoChannelInstance.set('description', videoChannelInfoToUpdate.description)
 
-    return videoChannelInstance.save(options)
-      .then(() => {
-        const json = videoChannelInstance.toUpdateRemoteJSON()
+      await videoChannelInstance.save(sequelizeOptions)
+      const json = videoChannelInstance.toUpdateRemoteJSON()
+
+      // Now we'll update the video channel's meta data to our friends
+      return updateVideoChannelToFriends(json, t)
 
-        // Now we'll update the video channel's meta data to our friends
-        return updateVideoChannelToFriends(json, t)
-      })
-  })
-    .then(() => {
-      logger.info('Video channel with name %s and uuid %s updated.', videoChannelInstance.name, videoChannelInstance.uuid)
-    })
-    .catch(err => {
-      logger.debug('Cannot update the video channel.', 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(videoChannelFieldsSave).forEach(key => {
-        const value = videoChannelFieldsSave[key]
-        videoChannelInstance.set(key, value)
-      })
-
-      throw err
     })
+
+    logger.info('Video channel with name %s and uuid %s updated.', videoChannelInstance.name, videoChannelInstance.uuid)
+  } catch (err) {
+    logger.debug('Cannot update the video channel.', 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!
+    resetSequelizeInstance(videoChannelInstance, videoChannelFieldsSave)
+
+    throw err
+  }
 }
 
-function removeVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function removeVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot remove the video channel with many retries.'
   }
 
-  retryTransactionWrapper(removeVideoChannel, options)
-    .then(() => res.type('json').status(204).end())
-    .catch(err => next(err))
+  await retryTransactionWrapper(removeVideoChannel, options)
+
+  return res.type('json').status(204).end()
 }
 
-function removeVideoChannel (req: express.Request, res: express.Response) {
+async function removeVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelInstance: VideoChannelInstance = res.locals.videoChannel
 
-  return db.sequelize.transaction(t => {
-    return videoChannelInstance.destroy({ transaction: t })
-  })
-  .then(() => {
-    logger.info('Video channel with name %s and uuid %s deleted.', videoChannelInstance.name, videoChannelInstance.uuid)
-  })
-  .catch(err => {
-    logger.error('Errors when removed the video channel.', err)
-    throw err
+  await db.sequelize.transaction(async t => {
+    await videoChannelInstance.destroy({ transaction: t })
   })
+
+  logger.info('Video channel with name %s and uuid %s deleted.', videoChannelInstance.name, videoChannelInstance.uuid)
 }
 
-function getVideoChannel (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.VideoChannel.loadAndPopulateAuthorAndVideos(res.locals.videoChannel.id)
-    .then(videoChannelWithVideos => res.json(videoChannelWithVideos.toFormattedJSON()))
-    .catch(err => next(err))
+async function getVideoChannel (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const videoChannelWithVideos = await db.VideoChannel.loadAndPopulateAuthorAndVideos(res.locals.videoChannel.id)
+
+  return res.json(videoChannelWithVideos.toFormattedJSON())
 }
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index ec855ee8e..7ebbf4d6e 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -1,5 +1,4 @@
 import * as express from 'express'
-import * as Promise from 'bluebird'
 import * as multer from 'multer'
 import { extname, join } from 'path'
 
@@ -30,7 +29,8 @@ import {
   videosSearchValidator,
   videosAddValidator,
   videosGetValidator,
-  videosRemoveValidator
+  videosRemoveValidator,
+  asyncMiddleware
 } from '../../../middlewares'
 import {
   logger,
@@ -38,7 +38,8 @@ import {
   generateRandomString,
   getFormattedObjects,
   renamePromise,
-  getVideoFileHeight
+  getVideoFileHeight,
+  resetSequelizeInstance
 } from '../../../helpers'
 import { TagInstance, VideoInstance } from '../../../models'
 import { VideoCreate, VideoUpdate } from '../../../../shared'
@@ -88,18 +89,18 @@ videosRouter.get('/',
   videosSortValidator,
   setVideosSort,
   setPagination,
-  listVideos
+  asyncMiddleware(listVideos)
 )
 videosRouter.put('/:id',
   authenticate,
   videosUpdateValidator,
-  updateVideoRetryWrapper
+  asyncMiddleware(updateVideoRetryWrapper)
 )
 videosRouter.post('/upload',
   authenticate,
   reqFiles,
   videosAddValidator,
-  addVideoRetryWrapper
+  asyncMiddleware(addVideoRetryWrapper)
 )
 videosRouter.get('/:id',
   videosGetValidator,
@@ -109,7 +110,7 @@ videosRouter.get('/:id',
 videosRouter.delete('/:id',
   authenticate,
   videosRemoveValidator,
-  removeVideoRetryWrapper
+  asyncMiddleware(removeVideoRetryWrapper)
 )
 
 videosRouter.get('/search/:value',
@@ -119,7 +120,7 @@ videosRouter.get('/search/:value',
   setVideosSort,
   setPagination,
   setVideosSearch,
-  searchVideos
+  asyncMiddleware(searchVideos)
 )
 
 // ---------------------------------------------------------------------------
@@ -144,220 +145,157 @@ function listVideoLanguages (req: express.Request, res: express.Response) {
 
 // Wrapper to video add that retry the function if there is a database error
 // We need this because we run the transaction in SERIALIZABLE isolation that can fail
-function addVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function addVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res, req.files['videofile'][0] ],
     errorMessage: 'Cannot insert the video with many retries.'
   }
 
-  retryTransactionWrapper(addVideo, options)
-    .then(() => {
-      // TODO : include Location of the new video -> 201
-      res.type('json').status(204).end()
-    })
-    .catch(err => next(err))
+  await retryTransactionWrapper(addVideo, options)
+
+  // TODO : include Location of the new video -> 201
+  res.type('json').status(204).end()
 }
 
-function addVideo (req: express.Request, res: express.Response, videoPhysicalFile: Express.Multer.File) {
+async function addVideo (req: express.Request, res: express.Response, videoPhysicalFile: Express.Multer.File) {
   const videoInfo: VideoCreate = req.body
   let videoUUID = ''
 
-  return db.sequelize.transaction(t => {
-    let p: Promise<TagInstance[]>
-
-    if (!videoInfo.tags) p = Promise.resolve(undefined)
-    else p = db.Tag.findOrCreateTags(videoInfo.tags, t)
-
-    return p
-      .then(tagInstances => {
-        const videoData = {
-          name: videoInfo.name,
-          remote: false,
-          extname: extname(videoPhysicalFile.filename),
-          category: videoInfo.category,
-          licence: videoInfo.licence,
-          language: videoInfo.language,
-          nsfw: videoInfo.nsfw,
-          description: videoInfo.description,
-          duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
-          channelId: res.locals.videoChannel.id
-        }
+  await db.sequelize.transaction(async t => {
+    const sequelizeOptions = { transaction: t }
+
+    const videoData = {
+      name: videoInfo.name,
+      remote: false,
+      extname: extname(videoPhysicalFile.filename),
+      category: videoInfo.category,
+      licence: videoInfo.licence,
+      language: videoInfo.language,
+      nsfw: videoInfo.nsfw,
+      description: videoInfo.description,
+      duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
+      channelId: res.locals.videoChannel.id
+    }
+    const video = db.Video.build(videoData)
 
-        const video = db.Video.build(videoData)
-        return { tagInstances, video }
-      })
-      .then(({ tagInstances, video }) => {
-        const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
-        return getVideoFileHeight(videoFilePath)
-          .then(height => ({ tagInstances, video, videoFileHeight: height }))
-      })
-      .then(({ tagInstances, video, videoFileHeight }) => {
-        const videoFileData = {
-          extname: extname(videoPhysicalFile.filename),
-          resolution: videoFileHeight,
-          size: videoPhysicalFile.size
-        }
+    const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
+    const videoFileHeight = await getVideoFileHeight(videoFilePath)
 
-        const videoFile = db.VideoFile.build(videoFileData)
-        return { tagInstances, video, videoFile }
-      })
-      .then(({ tagInstances, video, videoFile }) => {
-        const videoDir = CONFIG.STORAGE.VIDEOS_DIR
-        const source = join(videoDir, videoPhysicalFile.filename)
-        const destination = join(videoDir, video.getVideoFilename(videoFile))
-
-        return renamePromise(source, destination)
-          .then(() => {
-            // This is important in case if there is another attempt in the retry process
-            videoPhysicalFile.filename = video.getVideoFilename(videoFile)
-            return { tagInstances, video, videoFile }
-          })
-      })
-      .then(({ tagInstances, video, videoFile }) => {
-        const tasks = []
-
-        tasks.push(
-          video.createTorrentAndSetInfoHash(videoFile),
-          video.createThumbnail(videoFile),
-          video.createPreview(videoFile)
-        )
-
-        if (CONFIG.TRANSCODING.ENABLED === true) {
-          // Put uuid because we don't have id auto incremented for now
-          const dataInput = {
-            videoUUID: video.uuid
-          }
-
-          tasks.push(
-            JobScheduler.Instance.createJob(t, 'videoFileOptimizer', dataInput)
-          )
-        }
+    const videoFileData = {
+      extname: extname(videoPhysicalFile.filename),
+      resolution: videoFileHeight,
+      size: videoPhysicalFile.size
+    }
+    const videoFile = db.VideoFile.build(videoFileData)
+    const videoDir = CONFIG.STORAGE.VIDEOS_DIR
+    const source = join(videoDir, videoPhysicalFile.filename)
+    const destination = join(videoDir, video.getVideoFilename(videoFile))
+
+    await renamePromise(source, destination)
+    // This is important in case if there is another attempt in the retry process
+    videoPhysicalFile.filename = video.getVideoFilename(videoFile)
+
+    const tasks = []
+
+    tasks.push(
+      video.createTorrentAndSetInfoHash(videoFile),
+      video.createThumbnail(videoFile),
+      video.createPreview(videoFile)
+    )
+
+    if (CONFIG.TRANSCODING.ENABLED === true) {
+      // Put uuid because we don't have id auto incremented for now
+      const dataInput = {
+        videoUUID: video.uuid
+      }
+
+      tasks.push(
+        JobScheduler.Instance.createJob(t, 'videoFileOptimizer', dataInput)
+      )
+    }
+    await Promise.all(tasks)
 
-        return Promise.all(tasks).then(() => ({ tagInstances, video, videoFile }))
-      })
-      .then(({ tagInstances, video, videoFile }) => {
-        const options = { transaction: t }
+    const videoCreated = await video.save(sequelizeOptions)
+    // Do not forget to add video channel information to the created video
+    videoCreated.VideoChannel = res.locals.videoChannel
+    videoUUID = videoCreated.uuid
 
-        return video.save(options)
-          .then(videoCreated => {
-            // Do not forget to add video channel information to the created video
-            videoCreated.VideoChannel = res.locals.videoChannel
-            videoUUID = videoCreated.uuid
+    videoFile.videoId = video.id
 
-            return { tagInstances, video: videoCreated, videoFile }
-          })
-      })
-      .then(({ tagInstances, video, videoFile }) => {
-        const options = { transaction: t }
-        videoFile.videoId = video.id
+    await videoFile.save(sequelizeOptions)
+    video.VideoFiles = [videoFile]
 
-        return videoFile.save(options)
-          .then(() => video.VideoFiles = [ videoFile ])
-          .then(() => ({ tagInstances, video }))
-      })
-      .then(({ tagInstances, video }) => {
-        if (!tagInstances) return video
-
-        const options = { transaction: t }
-        return video.setTags(tagInstances, options)
-          .then(() => {
-            video.Tags = tagInstances
-            return video
-          })
-      })
-      .then(video => {
-        // Let transcoding job send the video to friends because the video file 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)
-          })
-      })
-  })
-  .then(() => logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoUUID))
-  .catch((err: Error) => {
-    logger.debug('Cannot insert the video.', err)
-    throw err
+    if (videoInfo.tags) {
+      const tagInstances = await db.Tag.findOrCreateTags(videoInfo.tags, t)
+
+      await video.setTags(tagInstances, sequelizeOptions)
+      video.Tags = tagInstances
+    }
+
+    // Let transcoding job send the video to friends because the video file extension might change
+    if (CONFIG.TRANSCODING.ENABLED === true) return undefined
+
+    const remoteVideo = await video.toAddRemoteJSON()
+    // Now we'll add the video's meta data to our friends
+    return addVideoToFriends(remoteVideo, t)
   })
+
+  logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoUUID)
 }
 
-function updateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot update the video with many retries.'
   }
 
-  retryTransactionWrapper(updateVideo, options)
-    .then(() => {
-      return res.type('json').status(204).end()
-    })
-    .catch(err => next(err))
+  await retryTransactionWrapper(updateVideo, options)
+
+  return res.type('json').status(204).end()
 }
 
-function updateVideo (req: express.Request, res: express.Response) {
+async function updateVideo (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video
   const videoFieldsSave = videoInstance.toJSON()
   const videoInfoToUpdate: VideoUpdate = req.body
 
-  return db.sequelize.transaction(t => {
-    let tagsPromise: Promise<TagInstance[]>
-    if (!videoInfoToUpdate.tags) {
-      tagsPromise = Promise.resolve(null)
-    } else {
-      tagsPromise = db.Tag.findOrCreateTags(videoInfoToUpdate.tags, t)
-    }
+  try {
+    await db.sequelize.transaction(async t => {
+      const sequelizeOptions = {
+        transaction: t
+      }
 
-    return tagsPromise
-      .then(tagInstances => {
-        const options = {
-          transaction: t
-        }
+      if (videoInfoToUpdate.name !== undefined) videoInstance.set('name', videoInfoToUpdate.name)
+      if (videoInfoToUpdate.category !== undefined) videoInstance.set('category', videoInfoToUpdate.category)
+      if (videoInfoToUpdate.licence !== undefined) videoInstance.set('licence', videoInfoToUpdate.licence)
+      if (videoInfoToUpdate.language !== undefined) videoInstance.set('language', videoInfoToUpdate.language)
+      if (videoInfoToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfoToUpdate.nsfw)
+      if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
 
-        if (videoInfoToUpdate.name !== undefined) videoInstance.set('name', videoInfoToUpdate.name)
-        if (videoInfoToUpdate.category !== undefined) videoInstance.set('category', videoInfoToUpdate.category)
-        if (videoInfoToUpdate.licence !== undefined) videoInstance.set('licence', videoInfoToUpdate.licence)
-        if (videoInfoToUpdate.language !== undefined) videoInstance.set('language', videoInfoToUpdate.language)
-        if (videoInfoToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfoToUpdate.nsfw)
-        if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
+      await videoInstance.save(sequelizeOptions)
 
-        return videoInstance.save(options).then(() => tagInstances)
-      })
-      .then(tagInstances => {
-        if (!tagInstances) return
+      if (videoInfoToUpdate.tags) {
+        const tagInstances = await db.Tag.findOrCreateTags(videoInfoToUpdate.tags, t)
 
-        const options = { transaction: t }
-        return videoInstance.setTags(tagInstances, options)
-          .then(() => {
-            videoInstance.Tags = tagInstances
+        await videoInstance.setTags(tagInstances, sequelizeOptions)
+        videoInstance.Tags = tagInstances
+      }
 
-            return
-          })
-      })
-      .then(() => {
-        const json = videoInstance.toUpdateRemoteJSON()
+      const json = videoInstance.toUpdateRemoteJSON()
 
-        // Now we'll update the video's meta data to our friends
-        return updateVideoToFriends(json, t)
-      })
-  })
-  .then(() => {
-    logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid)
-  })
-  .catch(err => {
-    logger.debug('Cannot update the video.', err)
+      // Now we'll update the video's meta data to our friends
+      return updateVideoToFriends(json, t)
+    })
 
+    logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid)
+  } catch (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(key => {
-      const value = videoFieldsSave[key]
-      videoInstance.set(key, value)
-    })
+    resetSequelizeInstance(videoInstance, videoFieldsSave)
 
     throw err
-  })
+  }
 }
 
 function getVideo (req: express.Request, res: express.Response) {
@@ -365,17 +303,17 @@ function getVideo (req: express.Request, res: express.Response) {
 
   if (videoInstance.isOwned()) {
     // The increment is done directly in the database, not using the instance value
+    // FIXME: make a real view system
+    // For example, only add a view when a user watch a video during 30s etc
     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, err))
+      .catch(err => logger.error('Cannot add view to video %s.', videoInstance.uuid, err))
   } else {
     // Just send the event to our friends
     const eventParams = {
@@ -383,48 +321,48 @@ function getVideo (req: express.Request, res: express.Response) {
       type: REQUEST_VIDEO_EVENT_TYPES.VIEWS
     }
     addEventToRemoteVideo(eventParams)
+      .catch(err => logger.error('Cannot add event to remote video %s.', videoInstance.uuid, err))
   }
 
   // Do not wait the view system
-  res.json(videoInstance.toFormattedDetailsJSON())
+  return res.json(videoInstance.toFormattedDetailsJSON())
 }
 
-function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
-    .then(result => res.json(getFormattedObjects(result.data, result.total)))
-    .catch(err => next(err))
+async function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-function removeVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function removeVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot remove the video with many retries.'
   }
 
-  retryTransactionWrapper(removeVideo, options)
-    .then(() => {
-      return res.type('json').status(204).end()
-    })
-    .catch(err => next(err))
+  await retryTransactionWrapper(removeVideo, options)
+
+  return res.type('json').status(204).end()
 }
 
-function removeVideo (req: express.Request, res: express.Response) {
+async function removeVideo (req: express.Request, res: express.Response) {
   const videoInstance: VideoInstance = res.locals.video
 
-  return db.sequelize.transaction(t => {
-    return videoInstance.destroy({ transaction: t })
-  })
-  .then(() => {
-    logger.info('Video with name %s and uuid %s deleted.', videoInstance.name, videoInstance.uuid)
-  })
-  .catch(err => {
-    logger.error('Errors when removed the video.', err)
-    throw err
+  await db.sequelize.transaction(async t => {
+    await videoInstance.destroy({ transaction: t })
   })
+
+  logger.info('Video with name %s and uuid %s deleted.', videoInstance.name, videoInstance.uuid)
 }
 
-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)
-    .then(result => res.json(getFormattedObjects(result.data, result.total)))
-    .catch(err => next(err))
+async function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const resultList = await db.Video.searchAndPopulateAuthorAndPodAndTags(
+    req.params.value,
+    req.query.field,
+    req.query.start,
+    req.query.count,
+    req.query.sort
+  )
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
diff --git a/server/controllers/api/videos/rate.ts b/server/controllers/api/videos/rate.ts
index 6ddc69817..354c3d8f9 100644
--- a/server/controllers/api/videos/rate.ts
+++ b/server/controllers/api/videos/rate.ts
@@ -1,5 +1,4 @@
 import * as express from 'express'
-import * as Promise from 'bluebird'
 
 import { database as db } from '../../../initializers/database'
 import {
@@ -17,7 +16,8 @@ import {
 } from '../../../lib'
 import {
   authenticate,
-  videoRateValidator
+  videoRateValidator,
+  asyncMiddleware
 } from '../../../middlewares'
 import { UserVideoRateUpdate, VideoRateType } from '../../../../shared'
 
@@ -26,7 +26,7 @@ const rateVideoRouter = express.Router()
 rateVideoRouter.put('/:id/rate',
   authenticate,
   videoRateValidator,
-  rateVideoRetryWrapper
+  asyncMiddleware(rateVideoRetryWrapper)
 )
 
 // ---------------------------------------------------------------------------
@@ -37,126 +37,107 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function rateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function rateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
   const options = {
     arguments: [ req, res ],
     errorMessage: 'Cannot update the user video rate.'
   }
 
-  retryTransactionWrapper(rateVideo, options)
-    .then(() => res.type('json').status(204).end())
-    .catch(err => next(err))
+  await retryTransactionWrapper(rateVideo, options)
+
+  return res.type('json').status(204).end()
 }
 
-function rateVideo (req: express.Request, res: express.Response) {
+async function rateVideo (req: express.Request, res: express.Response) {
   const body: UserVideoRateUpdate = req.body
   const rateType = body.rating
   const videoInstance = res.locals.video
   const userInstance = res.locals.oauth.token.User
 
-  return db.sequelize.transaction(t => {
-    return db.UserVideoRate.load(userInstance.id, videoInstance.id, t)
-      .then(previousRate => {
-        const options = { transaction: t }
-
-        let likesToIncrement = 0
-        let dislikesToIncrement = 0
-
-        if (rateType === VIDEO_RATE_TYPES.LIKE) likesToIncrement++
-        else if (rateType === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement++
-
-        let promise: Promise<any>
-
-        // There was a previous rate, update it
-        if (previousRate) {
-          // We will remove the previous rate, so we will need to update the video count attribute
-          if (previousRate.type === VIDEO_RATE_TYPES.LIKE) likesToIncrement--
-          else if (previousRate.type === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement--
-
-          if (rateType === 'none') { // Destroy previous rate
-            promise = previousRate.destroy()
-          } else { // Update previous rate
-            previousRate.type = rateType as VideoRateType
-
-            promise = previousRate.save()
-          }
-        } else if (rateType !== 'none') { // There was not a previous rate, insert a new one if there is a rate
-          const query = {
-            userId: userInstance.id,
-            videoId: videoInstance.id,
-            type: rateType
-          }
-
-          promise = db.UserVideoRate.create(query, options)
-        } else {
-          promise = Promise.resolve()
-        }
-
-        return promise.then(() => ({ likesToIncrement, dislikesToIncrement }))
-      })
-      .then(({ likesToIncrement, dislikesToIncrement }) => {
-        const options = { transaction: t }
-        const incrementQuery = {
-          likes: likesToIncrement,
-          dislikes: dislikesToIncrement
-        }
-
-        // Even if we do not own the video we increment the attributes
-        // It is usefull for the user to have a feedback
-        return videoInstance.increment(incrementQuery, options).then(() => ({ likesToIncrement, dislikesToIncrement }))
-      })
-      .then(({ likesToIncrement, dislikesToIncrement }) => {
-        // No need for an event type, we own the video
-        if (videoInstance.isOwned()) return { likesToIncrement, dislikesToIncrement }
-
-        const eventsParams = []
-
-        if (likesToIncrement !== 0) {
-          eventsParams.push({
-            videoId: videoInstance.id,
-            type: REQUEST_VIDEO_EVENT_TYPES.LIKES,
-            count: likesToIncrement
-          })
-        }
-
-        if (dislikesToIncrement !== 0) {
-          eventsParams.push({
-            videoId: videoInstance.id,
-            type: REQUEST_VIDEO_EVENT_TYPES.DISLIKES,
-            count: dislikesToIncrement
-          })
-        }
-
-        return addEventsToRemoteVideo(eventsParams, t).then(() => ({ likesToIncrement, dislikesToIncrement }))
-      })
-      .then(({ likesToIncrement, dislikesToIncrement }) => {
-        // We do not own the video, there is no need to send a quick and dirty update to friends
-        // Our rate was already sent by the addEvent function
-        if (videoInstance.isOwned() === false) return undefined
-
-        const qadusParams = []
-
-        if (likesToIncrement !== 0) {
-          qadusParams.push({
-            videoId: videoInstance.id,
-            type: REQUEST_VIDEO_QADU_TYPES.LIKES
-          })
-        }
-
-        if (dislikesToIncrement !== 0) {
-          qadusParams.push({
-            videoId: videoInstance.id,
-            type: REQUEST_VIDEO_QADU_TYPES.DISLIKES
-          })
-        }
-
-        return quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
-      })
-  })
-  .then(() => logger.info('User video rate for video %s of user %s updated.', videoInstance.name, userInstance.username))
-  .catch(err => {
-    // This is just a debug because we will retry the insert
-    logger.debug('Cannot add the user video rate.', err)
-    throw err
+  await db.sequelize.transaction(async t => {
+    const sequelizeOptions = { transaction: t }
+    const previousRate = await db.UserVideoRate.load(userInstance.id, videoInstance.id, t)
+
+    let likesToIncrement = 0
+    let dislikesToIncrement = 0
+
+    if (rateType === VIDEO_RATE_TYPES.LIKE) likesToIncrement++
+    else if (rateType === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement++
+
+    // There was a previous rate, update it
+    if (previousRate) {
+      // We will remove the previous rate, so we will need to update the video count attribute
+      if (previousRate.type === VIDEO_RATE_TYPES.LIKE) likesToIncrement--
+      else if (previousRate.type === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement--
+
+      if (rateType === 'none') { // Destroy previous rate
+        await previousRate.destroy()
+      } else { // Update previous rate
+        previousRate.type = rateType as VideoRateType
+
+        await previousRate.save()
+      }
+    } else if (rateType !== 'none') { // There was not a previous rate, insert a new one if there is a rate
+      const query = {
+        userId: userInstance.id,
+        videoId: videoInstance.id,
+        type: rateType
+      }
+
+      await db.UserVideoRate.create(query, sequelizeOptions)
+    }
+
+    const incrementQuery = {
+      likes: likesToIncrement,
+      dislikes: dislikesToIncrement
+    }
+
+    // Even if we do not own the video we increment the attributes
+    // It is useful for the user to have a feedback
+    await videoInstance.increment(incrementQuery, sequelizeOptions)
+
+    // Send a event to original pod
+    if (videoInstance.isOwned() === false) {
+
+      const eventsParams = []
+
+      if (likesToIncrement !== 0) {
+        eventsParams.push({
+          videoId: videoInstance.id,
+          type: REQUEST_VIDEO_EVENT_TYPES.LIKES,
+          count: likesToIncrement
+        })
+      }
+
+      if (dislikesToIncrement !== 0) {
+        eventsParams.push({
+          videoId: videoInstance.id,
+          type: REQUEST_VIDEO_EVENT_TYPES.DISLIKES,
+          count: dislikesToIncrement
+        })
+      }
+
+      await addEventsToRemoteVideo(eventsParams, t)
+    } else { // We own the video, we need to send a quick and dirty update to friends to notify the counts changed
+      const qadusParams = []
+
+      if (likesToIncrement !== 0) {
+        qadusParams.push({
+          videoId: videoInstance.id,
+          type: REQUEST_VIDEO_QADU_TYPES.LIKES
+        })
+      }
+
+      if (dislikesToIncrement !== 0) {
+        qadusParams.push({
+          videoId: videoInstance.id,
+          type: REQUEST_VIDEO_QADU_TYPES.DISLIKES
+        })
+      }
+
+      await quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
+    }
   })
+
+  logger.info('User video rate for video %s of user %s updated.', videoInstance.name, userInstance.username)
 }