11 files changed, 456 insertions, 451 deletions

diff --git a/server/lib/cache/videos-preview-cache.ts b/server/lib/cache/videos-preview-cache.ts
index fecdca6ef..0fe4d2f78 100644
--- a/server/lib/cache/videos-preview-cache.ts
+++ b/server/lib/cache/videos-preview-cache.ts
@@ -1,7 +1,6 @@
 import * as asyncLRU from 'async-lru'
 import { join } from 'path'
 import { createWriteStream } from 'fs'
-import * as Promise from 'bluebird'
 
 import { database as db, CONFIG, CACHE } from '../../initializers'
 import { logger, unlinkPromise } from '../../helpers'
@@ -43,15 +42,15 @@ class VideosPreviewCache {
     })
   }
 
-  private loadPreviews (key: string) {
-    return db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(key)
-      .then(video => {
-        if (!video) return undefined
+  private async loadPreviews (key: string) {
+    const video = await db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(key)
+    if (!video) return undefined
 
-        if (video.isOwned()) return join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName())
+    if (video.isOwned()) return join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName())
 
-        return this.saveRemotePreviewAndReturnPath(video)
-      })
+    const res = await this.saveRemotePreviewAndReturnPath(video)
+
+    return res
   }
 
   private saveRemotePreviewAndReturnPath (video: VideoInstance) {
diff --git a/server/lib/friends.ts b/server/lib/friends.ts
index f035b099b..a33432dc1 100644
--- a/server/lib/friends.ts
+++ b/server/lib/friends.ts
@@ -1,6 +1,6 @@
 import * as request from 'request'
 import * as Sequelize from 'sequelize'
-import * as Promise from 'bluebird'
+import * as Bluebird from 'bluebird'
 import { join } from 'path'
 
 import { database as db } from '../initializers/database'
@@ -188,159 +188,158 @@ function addEventToRemoteVideo (eventParam: EventParam, transaction?: Sequelize.
 function addEventsToRemoteVideo (eventsParams: EventParam[], transaction: Sequelize.Transaction) {
   const tasks = []
 
-  eventsParams.forEach(eventParams => {
+  for (const eventParams of eventsParams) {
     tasks.push(addEventToRemoteVideo(eventParams, transaction))
-  })
+  }
 
   return Promise.all(tasks)
 }
 
-function hasFriends () {
-  return db.Pod.countAll().then(count => count !== 0)
+async function hasFriends () {
+  const count = await db.Pod.countAll()
+
+  return count !== 0
 }
 
-function makeFriends (hosts: string[]) {
+async function makeFriends (hosts: string[]) {
   const podsScore = {}
 
   logger.info('Make friends!')
-  return getMyPublicCert()
-    .then(cert => {
-      return Promise.each(hosts, host => computeForeignPodsList(host, podsScore)).then(() => cert)
-    })
-    .then(cert => {
-      logger.debug('Pods scores computed.', { podsScore: podsScore })
-      const podsList = computeWinningPods(hosts, podsScore)
-      logger.debug('Pods that we keep.', { podsToKeep: podsList })
+  const cert = await getMyPublicCert()
 
-      return makeRequestsToWinningPods(cert, podsList)
-    })
+  for (const host of hosts) {
+    await computeForeignPodsList(host, podsScore)
+  }
+
+  logger.debug('Pods scores computed.', { podsScore: podsScore })
+
+  const podsList = computeWinningPods(hosts, podsScore)
+  logger.debug('Pods that we keep.', { podsToKeep: podsList })
+
+  return makeRequestsToWinningPods(cert, podsList)
 }
 
-function quitFriends () {
+async function quitFriends () {
   // Stop pool requests
   requestScheduler.deactivate()
 
-  return requestScheduler.flush()
-    .then(() => {
-      return requestVideoQaduScheduler.flush()
-    })
-    .then(() => {
-      return db.Pod.list()
-    })
-    .then(pods => {
-      const requestParams = {
-        method: 'POST' as 'POST',
-        path: '/api/' + API_VERSION + '/remote/pods/remove',
-        toPod: null
-      }
+  try {
+    await requestScheduler.flush()
+
+    await requestVideoQaduScheduler.flush()
+
+    const pods = await db.Pod.list()
+    const requestParams = {
+      method: 'POST' as 'POST',
+      path: '/api/' + API_VERSION + '/remote/pods/remove',
+      toPod: null
+    }
 
-      // Announce we quit them
-      // We don't care if the request fails
-      // The other pod will exclude us automatically after a while
-      return Promise.map(pods, pod => {
+    // Announce we quit them
+    // We don't care if the request fails
+    // The other pod will exclude us automatically after a while
+    try {
+      await Bluebird.map(pods, pod => {
         requestParams.toPod = pod
 
         return makeSecureRequest(requestParams)
       }, { concurrency: REQUESTS_IN_PARALLEL })
-      .then(() => pods)
-      .catch(err => {
-        logger.error('Some errors while quitting friends.', err)
-        // Don't stop the process
-        return pods
-      })
-    })
-    .then(pods => {
-      const tasks = []
-      pods.forEach(pod => tasks.push(pod.destroy()))
+    } catch (err) { // Don't stop the process
+      logger.error('Some errors while quitting friends.', err)
+    }
 
-      return Promise.all(pods)
-    })
-    .then(() => {
-      logger.info('Removed all remote videos.')
-      // Don't forget to re activate the scheduler, even if there was an error
-      return requestScheduler.activate()
-    })
-    .finally(() => requestScheduler.activate())
+    const tasks = []
+    for (const pod of pods) {
+      tasks.push(pod.destroy())
+    }
+    await Promise.all(pods)
+
+    logger.info('Removed all remote videos.')
+
+    requestScheduler.activate()
+  } catch (err) {
+    // Don't forget to re activate the scheduler, even if there was an error
+    requestScheduler.activate()
+
+    throw err
+  }
 }
 
-function sendOwnedDataToPod (podId: number) {
+async function sendOwnedDataToPod (podId: number) {
   // First send authors
-  return sendOwnedAuthorsToPod(podId)
-    .then(() => sendOwnedChannelsToPod(podId))
-    .then(() => sendOwnedVideosToPod(podId))
+  await sendOwnedAuthorsToPod(podId)
+  await sendOwnedChannelsToPod(podId)
+  await sendOwnedVideosToPod(podId)
+}
+
+async function sendOwnedChannelsToPod (podId: number) {
+  const videoChannels = await db.VideoChannel.listOwned()
+
+  const tasks: Promise<any>[] = []
+  for (const videoChannel of videoChannels) {
+    const remoteVideoChannel = videoChannel.toAddRemoteJSON()
+    const options = {
+      type: 'add-channel' as 'add-channel',
+      endpoint: REQUEST_ENDPOINTS.VIDEOS,
+      data: remoteVideoChannel,
+      toIds: [ podId ],
+      transaction: null
+    }
+
+    const p = createRequest(options)
+    tasks.push(p)
+  }
+
+  await Promise.all(tasks)
 }
 
-function sendOwnedChannelsToPod (podId: number) {
-  return db.VideoChannel.listOwned()
-    .then(videoChannels => {
-      const tasks = []
-      videoChannels.forEach(videoChannel => {
-        const remoteVideoChannel = videoChannel.toAddRemoteJSON()
-        const options = {
-          type: 'add-channel' as 'add-channel',
-          endpoint: REQUEST_ENDPOINTS.VIDEOS,
-          data: remoteVideoChannel,
-          toIds: [ podId ],
-          transaction: null
-        }
+async function sendOwnedAuthorsToPod (podId: number) {
+  const authors = await db.Author.listOwned()
+  const tasks: Promise<any>[] = []
 
-        const p = createRequest(options)
-        tasks.push(p)
-      })
+  for (const author of authors) {
+    const remoteAuthor = author.toAddRemoteJSON()
+    const options = {
+      type: 'add-author' as 'add-author',
+      endpoint: REQUEST_ENDPOINTS.VIDEOS,
+      data: remoteAuthor,
+      toIds: [ podId ],
+      transaction: null
+    }
 
-      return Promise.all(tasks)
-    })
+    const p = createRequest(options)
+    tasks.push(p)
+  }
+
+  await Promise.all(tasks)
 }
 
-function sendOwnedAuthorsToPod (podId: number) {
-  return db.Author.listOwned()
-    .then(authors => {
-      const tasks = []
-      authors.forEach(author => {
-        const remoteAuthor = author.toAddRemoteJSON()
+async function sendOwnedVideosToPod (podId: number) {
+  const videosList = await db.Video.listOwnedAndPopulateAuthorAndTags()
+  const tasks: Bluebird<any>[] = []
+
+  for (const video of videosList) {
+    const promise = video.toAddRemoteJSON()
+      .then(remoteVideo => {
         const options = {
-          type: 'add-author' as 'add-author',
+          type: 'add-video' as 'add-video',
           endpoint: REQUEST_ENDPOINTS.VIDEOS,
-          data: remoteAuthor,
+          data: remoteVideo,
           toIds: [ podId ],
           transaction: null
         }
-
-        const p = createRequest(options)
-        tasks.push(p)
+        return createRequest(options)
       })
-
-      return Promise.all(tasks)
-    })
-}
-
-function sendOwnedVideosToPod (podId: number) {
-  return db.Video.listOwnedAndPopulateAuthorAndTags()
-    .then(videosList => {
-      const tasks = []
-      videosList.forEach(video => {
-        const promise = video.toAddRemoteJSON()
-          .then(remoteVideo => {
-            const options = {
-              type: 'add-video' as 'add-video',
-              endpoint: REQUEST_ENDPOINTS.VIDEOS,
-              data: remoteVideo,
-              toIds: [ podId ],
-              transaction: null
-            }
-            return createRequest(options)
-          })
-          .catch(err => {
-            logger.error('Cannot convert video to remote.', err)
-            // Don't break the process
-            return undefined
-          })
-
-        tasks.push(promise)
+      .catch(err => {
+        logger.error('Cannot convert video to remote.', err)
+        // Don't break the process
+        return undefined
       })
 
-      return Promise.all(tasks)
-    })
+    tasks.push(promise)
+  }
+
+  await Promise.all(tasks)
 }
 
 function fetchRemotePreview (video: VideoInstance) {
@@ -350,18 +349,26 @@ function fetchRemotePreview (video: VideoInstance) {
   return request.get(REMOTE_SCHEME.HTTP + '://' + host + path)
 }
 
-function removeFriend (pod: PodInstance) {
+async function removeFriend (pod: PodInstance) {
   const requestParams = {
     method: 'POST' as 'POST',
     path: '/api/' + API_VERSION + '/remote/pods/remove',
     toPod: pod
   }
 
-  return makeSecureRequest(requestParams)
-    .catch(err => logger.warn('Cannot notify friends %s we are quitting him.', pod.host, err))
-    .then(() => pod.destroy())
-    .then(() => logger.info('Removed friend %s.', pod.host))
-    .catch(err => logger.error('Cannot destroy friend %s.', pod.host, err))
+  try {
+    await makeSecureRequest(requestParams)
+  } catch (err) {
+    logger.warn('Cannot notify friends %s we are quitting him.', pod.host, err)
+  }
+
+  try {
+    await pod.destroy()
+
+    logger.info('Removed friend %s.', pod.host)
+  } catch (err) {
+    logger.error('Cannot destroy friend %s.', pod.host, err)
+  }
 }
 
 function getRequestScheduler () {
@@ -406,23 +413,21 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function computeForeignPodsList (host: string, podsScore: { [ host: string ]: number }) {
-  // TODO: type res
-  return getForeignPodsList(host).then(res => {
-    const foreignPodsList: { host: string }[] = res.data
+async function computeForeignPodsList (host: string, podsScore: { [ host: string ]: number }) {
+  const result = await getForeignPodsList(host)
+  const foreignPodsList: { host: string }[] = result.data
 
-    // Let's give 1 point to the pod we ask the friends list
-    foreignPodsList.push({ host })
+  // Let's give 1 point to the pod we ask the friends list
+  foreignPodsList.push({ host })
 
-    foreignPodsList.forEach(foreignPod => {
-      const foreignPodHost = foreignPod.host
+  for (const foreignPod of foreignPodsList) {
+    const foreignPodHost = foreignPod.host
 
-      if (podsScore[foreignPodHost]) podsScore[foreignPodHost]++
-      else podsScore[foreignPodHost] = 1
-    })
+    if (podsScore[foreignPodHost]) podsScore[foreignPodHost]++
+    else podsScore[foreignPodHost] = 1
+  }
 
-    return undefined
-  })
+  return undefined
 }
 
 function computeWinningPods (hosts: string[], podsScore: { [ host: string ]: number }) {
@@ -431,12 +436,12 @@ function computeWinningPods (hosts: string[], podsScore: { [ host: string ]: num
   const podsList = []
   const baseScore = hosts.length / 2
 
-  Object.keys(podsScore).forEach(podHost => {
+  for (const podHost of Object.keys(podsScore)) {
     // If the pod is not me and with a good score we add it
     if (isMe(podHost) === false && podsScore[podHost] > baseScore) {
       podsList.push({ host: podHost })
     }
-  })
+  }
 
   return podsList
 }
@@ -449,7 +454,7 @@ function getForeignPodsList (host: string) {
       if (err) return rej(err)
 
       try {
-        const json = JSON.parse(body)
+        const json: ResultList<FormattedPod> = JSON.parse(body)
         return res(json)
       } catch (err) {
         return rej(err)
@@ -458,53 +463,53 @@ function getForeignPodsList (host: string) {
   })
 }
 
-function makeRequestsToWinningPods (cert: string, podsList: PodInstance[]) {
+async function makeRequestsToWinningPods (cert: string, podsList: PodInstance[]) {
   // Stop pool requests
   requestScheduler.deactivate()
   // Flush pool requests
   requestScheduler.forceSend()
 
-  return Promise.map(podsList, pod => {
-    const params = {
-      url: REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + API_VERSION + '/remote/pods/add',
-      method: 'POST' as 'POST',
-      json: {
-        host: CONFIG.WEBSERVER.HOST,
-        email: CONFIG.ADMIN.EMAIL,
-        publicKey: cert
+  try {
+    await Bluebird.map(podsList, async pod => {
+      const params = {
+        url: REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + API_VERSION + '/remote/pods/add',
+        method: 'POST' as 'POST',
+        json: {
+          host: CONFIG.WEBSERVER.HOST,
+          email: CONFIG.ADMIN.EMAIL,
+          publicKey: cert
+        }
       }
-    }
 
-    return makeRetryRequest(params)
-      .then(({ response, body }) => {
-        body = body as { cert: string, email: string }
-
-        if (response.statusCode === 200) {
-          const podObj = db.Pod.build({ host: pod.host, publicKey: body.cert, email: body.email })
-          return podObj.save()
-            .then(podCreated => {
-
-              // Add our videos to the request scheduler
-              sendOwnedDataToPod(podCreated.id)
-            })
-            .catch(err => {
-              logger.error('Cannot add friend %s pod.', pod.host, err)
-            })
-        } else {
-          logger.error('Status not 200 for %s pod.', pod.host)
+      const { response, body } = await makeRetryRequest(params)
+      const typedBody = body as { cert: string, email: string }
+
+      if (response.statusCode === 200) {
+        const podObj = db.Pod.build({ host: pod.host, publicKey: typedBody.cert, email: typedBody.email })
+
+        let podCreated: PodInstance
+        try {
+          podCreated = await podObj.save()
+        } catch (err) {
+          logger.error('Cannot add friend %s pod.', pod.host, err)
         }
-      })
-      .catch(err => {
-        logger.error('Error with adding %s pod.', pod.host, { error: err.stack })
-        // Don't break the process
-      })
-  }, { concurrency: REQUESTS_IN_PARALLEL })
-  .then(() => logger.debug('makeRequestsToWinningPods finished.'))
-  .finally(() => {
+
+        // Add our videos to the request scheduler
+        sendOwnedDataToPod(podCreated.id)
+          .catch(err => logger.warn('Cannot send owned data to pod %d.', podCreated.id, err))
+      } else {
+        logger.error('Status not 200 for %s pod.', pod.host)
+      }
+    }, { concurrency: REQUESTS_IN_PARALLEL })
+
+    logger.debug('makeRequestsToWinningPods finished.')
+
+    requestScheduler.activate()
+  } catch (err) {
     // Final callback, we've ended all the requests
     // Now we made new friends, we can re activate the pool of requests
     requestScheduler.activate()
-  })
+  }
 }
 
 // Wrapper that populate "toIds" argument with all our friends if it is not specified
@@ -515,14 +520,19 @@ type CreateRequestOptions = {
   toIds?: number[]
   transaction: Sequelize.Transaction
 }
-function createRequest (options: CreateRequestOptions) {
-  if (options.toIds !== undefined) return requestScheduler.createRequest(options as RequestSchedulerOptions)
+async function createRequest (options: CreateRequestOptions) {
+  if (options.toIds !== undefined) {
+    await requestScheduler.createRequest(options as RequestSchedulerOptions)
+    return undefined
+  }
 
   // If the "toIds" pods is not specified, we send the request to all our friends
-  return db.Pod.listAllIds(options.transaction).then(podIds => {
-    const newOptions = Object.assign(options, { toIds: podIds })
-    return requestScheduler.createRequest(newOptions)
-  })
+  const podIds = await db.Pod.listAllIds(options.transaction)
+
+  const newOptions = Object.assign(options, { toIds: podIds })
+  await requestScheduler.createRequest(newOptions)
+
+  return undefined
 }
 
 function createVideoQaduRequest (options: RequestVideoQaduSchedulerOptions) {
diff --git a/server/lib/jobs/handlers/video-file-optimizer.ts b/server/lib/jobs/handlers/video-file-optimizer.ts
index 63a51064c..799ba8b01 100644
--- a/server/lib/jobs/handlers/video-file-optimizer.ts
+++ b/server/lib/jobs/handlers/video-file-optimizer.ts
@@ -1,4 +1,4 @@
-import * as Promise from 'bluebird'
+import * as Bluebird from 'bluebird'
 
 import { database as db } from '../../../initializers/database'
 import { logger, computeResolutionsToTranscode } from '../../../helpers'
@@ -6,16 +6,17 @@ import { VideoInstance } from '../../../models'
 import { addVideoToFriends } from '../../friends'
 import { JobScheduler } from '../job-scheduler'
 
-function process (data: { videoUUID: string }, jobId: number) {
-  return db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(data.videoUUID).then(video => {
-    // No video, maybe deleted?
-    if (!video) {
-      logger.info('Do not process job %d, video does not exist.', jobId, { videoUUID: video.uuid })
-      return undefined
-    }
+async function process (data: { videoUUID: string }, jobId: number) {
+  const video = await db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(data.videoUUID)
+  // No video, maybe deleted?
+  if (!video) {
+    logger.info('Do not process job %d, video does not exist.', jobId, { videoUUID: video.uuid })
+    return undefined
+  }
+
+  await video.optimizeOriginalVideofile()
 
-    return video.optimizeOriginalVideofile().then(() => video)
-  })
+  return video
 }
 
 function onError (err: Error, jobId: number) {
@@ -23,33 +24,31 @@ function onError (err: Error, jobId: number) {
   return Promise.resolve()
 }
 
-function onSuccess (jobId: number, video: VideoInstance) {
+async function onSuccess (jobId: number, video: VideoInstance) {
   if (video === undefined) return undefined
 
   logger.info('Job %d is a success.', jobId)
 
-  video.toAddRemoteJSON()
-    .then(remoteVideo => {
-      // Now we'll add the video's meta data to our friends
-      return addVideoToFriends(remoteVideo, null)
-    })
-    .then(() => {
-      return video.getOriginalFileHeight()
-    })
-    .then(originalFileHeight => {
-      // Create transcoding jobs if there are enabled resolutions
-      const resolutionsEnabled = computeResolutionsToTranscode(originalFileHeight)
-      logger.info(
-        'Resolutions computed for video %s and origin file height of %d.', video.uuid, originalFileHeight,
-        { resolutions: resolutionsEnabled }
-      )
-
-      if (resolutionsEnabled.length === 0) return undefined
-
-      return db.sequelize.transaction(t => {
-        const tasks: Promise<any>[] = []
-
-        resolutionsEnabled.forEach(resolution => {
+  const remoteVideo = await video.toAddRemoteJSON()
+
+  // Now we'll add the video's meta data to our friends
+  await addVideoToFriends(remoteVideo, null)
+
+  const originalFileHeight = await video.getOriginalFileHeight()
+  // Create transcoding jobs if there are enabled resolutions
+
+  const resolutionsEnabled = computeResolutionsToTranscode(originalFileHeight)
+  logger.info(
+    'Resolutions computed for video %s and origin file height of %d.', video.uuid, originalFileHeight,
+    { resolutions: resolutionsEnabled }
+  )
+
+  if (resolutionsEnabled.length !== 0) {
+    try {
+      await db.sequelize.transaction(async t => {
+        const tasks: Bluebird<any>[] = []
+
+        for (const resolution of resolutionsEnabled) {
           const dataInput = {
             videoUUID: video.uuid,
             resolution
@@ -57,24 +56,19 @@ function onSuccess (jobId: number, video: VideoInstance) {
 
           const p = JobScheduler.Instance.createJob(t, 'videoFileTranscoder', dataInput)
           tasks.push(p)
-        })
+        }
 
-        return Promise.all(tasks).then(() => resolutionsEnabled)
+        await Promise.all(tasks)
       })
-    })
-    .then(resolutionsEnabled => {
-      if (resolutionsEnabled === undefined) {
-        logger.info('No transcoding jobs created for video %s (no resolutions enabled).')
-        return undefined
-      }
 
       logger.info('Transcoding jobs created for uuid %s.', video.uuid, { resolutionsEnabled })
-    })
-    .catch((err: Error) => {
-      logger.debug('Cannot transcode the video.', err)
-      throw err
-    })
-
+    } catch (err) {
+      logger.warn('Cannot transcode the video.', err)
+    }
+  } else {
+    logger.info('No transcoding jobs created for video %s (no resolutions enabled).')
+    return undefined
+  }
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/jobs/handlers/video-file-transcoder.ts b/server/lib/jobs/handlers/video-file-transcoder.ts
index 0dafee566..b240ff58a 100644
--- a/server/lib/jobs/handlers/video-file-transcoder.ts
+++ b/server/lib/jobs/handlers/video-file-transcoder.ts
@@ -4,16 +4,17 @@ import { logger } from '../../../helpers'
 import { VideoInstance } from '../../../models'
 import { VideoResolution } from '../../../../shared'
 
-function process (data: { videoUUID: string, resolution: VideoResolution }, jobId: number) {
-  return db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(data.videoUUID).then(video => {
-    // No video, maybe deleted?
-    if (!video) {
-      logger.info('Do not process job %d, video does not exist.', jobId, { videoUUID: video.uuid })
-      return undefined
-    }
-
-    return video.transcodeOriginalVideofile(data.resolution).then(() => video)
-  })
+async function process (data: { videoUUID: string, resolution: VideoResolution }, jobId: number) {
+  const video = await db.Video.loadByUUIDAndPopulateAuthorAndPodAndTags(data.videoUUID)
+  // No video, maybe deleted?
+  if (!video) {
+    logger.info('Do not process job %d, video does not exist.', jobId, { videoUUID: video.uuid })
+    return undefined
+  }
+
+  await video.transcodeOriginalVideofile(data.resolution)
+
+  return video
 }
 
 function onError (err: Error, jobId: number) {
diff --git a/server/lib/jobs/job-scheduler.ts b/server/lib/jobs/job-scheduler.ts
index c2409d20c..61d483268 100644
--- a/server/lib/jobs/job-scheduler.ts
+++ b/server/lib/jobs/job-scheduler.ts
@@ -23,7 +23,7 @@ class JobScheduler {
     return this.instance || (this.instance = new this())
   }
 
-  activate () {
+  async activate () {
     const limit = JOBS_FETCH_LIMIT_PER_CYCLE
 
     logger.info('Jobs scheduler activated.')
@@ -32,32 +32,36 @@ class JobScheduler {
 
     // Finish processing jobs from a previous start
     const state = JOB_STATES.PROCESSING
-    db.Job.listWithLimit(limit, state)
-      .then(jobs => {
-        this.enqueueJobs(jobsQueue, jobs)
-
-        forever(
-          next => {
-            if (jobsQueue.length() !== 0) {
-              // Finish processing the queue first
-              return setTimeout(next, JOBS_FETCHING_INTERVAL)
-            }
-
-            const state = JOB_STATES.PENDING
-            db.Job.listWithLimit(limit, state)
-              .then(jobs => {
-                this.enqueueJobs(jobsQueue, jobs)
-
-                // Optimization: we could use "drain" from queue object
-                return setTimeout(next, JOBS_FETCHING_INTERVAL)
-              })
-              .catch(err => logger.error('Cannot list pending jobs.', err))
-          },
-
-          err => logger.error('Error in job scheduler queue.', err)
-        )
-      })
-      .catch(err => logger.error('Cannot list pending jobs.', err))
+    try {
+      const jobs = await db.Job.listWithLimit(limit, state)
+
+      this.enqueueJobs(jobsQueue, jobs)
+    } catch (err) {
+      logger.error('Cannot list pending jobs.', err)
+    }
+
+    forever(
+      async next => {
+        if (jobsQueue.length() !== 0) {
+          // Finish processing the queue first
+          return setTimeout(next, JOBS_FETCHING_INTERVAL)
+        }
+
+        const state = JOB_STATES.PENDING
+        try {
+          const jobs = await db.Job.listWithLimit(limit, state)
+
+          this.enqueueJobs(jobsQueue, jobs)
+        } catch (err) {
+          logger.error('Cannot list pending jobs.', err)
+        }
+
+        // Optimization: we could use "drain" from queue object
+        return setTimeout(next, JOBS_FETCHING_INTERVAL)
+      },
+
+      err => logger.error('Error in job scheduler queue.', err)
+    )
   }
 
   createJob (transaction: Sequelize.Transaction, handlerName: string, handlerInputData: object) {
@@ -75,7 +79,7 @@ class JobScheduler {
     jobs.forEach(job => jobsQueue.push(job))
   }
 
-  private processJob (job: JobInstance, callback: (err: Error) => void) {
+  private async processJob (job: JobInstance, callback: (err: Error) => void) {
     const jobHandler = jobHandlers[job.handlerName]
     if (jobHandler === undefined) {
       logger.error('Unknown job handler for job %s.', job.handlerName)
@@ -85,41 +89,45 @@ class JobScheduler {
     logger.info('Processing job %d with handler %s.', job.id, job.handlerName)
 
     job.state = JOB_STATES.PROCESSING
-    return job.save()
-      .then(() => {
-        return jobHandler.process(job.handlerInputData, job.id)
-      })
-      .then(
-        result => {
-          return this.onJobSuccess(jobHandler, job, result)
-        },
-
-        err => {
-          logger.error('Error in job handler %s.', job.handlerName, err)
-          return this.onJobError(jobHandler, job, err)
-        }
-      )
-      .then(() => callback(null))
-      .catch(err => {
-        this.cannotSaveJobError(err)
-        return callback(err)
-      })
+    await job.save()
+
+    try {
+      const result = await jobHandler.process(job.handlerInputData, job.id)
+      await this.onJobSuccess(jobHandler, job, result)
+    } catch (err) {
+      logger.error('Error in job handler %s.', job.handlerName, err)
+
+      try {
+        await this.onJobError(jobHandler, job, err)
+      } catch (innerErr) {
+        this.cannotSaveJobError(innerErr)
+        return callback(innerErr)
+      }
+    }
+
+    callback(null)
   }
 
-  private onJobError (jobHandler: JobHandler<any>, job: JobInstance, err: Error) {
+  private async onJobError (jobHandler: JobHandler<any>, job: JobInstance, err: Error) {
     job.state = JOB_STATES.ERROR
 
-    return job.save()
-      .then(() => jobHandler.onError(err, job.id))
-      .catch(err => this.cannotSaveJobError(err))
+    try {
+      await job.save()
+      await jobHandler.onError(err, job.id)
+    } catch (err) {
+      this.cannotSaveJobError(err)
+    }
   }
 
-  private onJobSuccess (jobHandler: JobHandler<any>, job: JobInstance, jobResult: any) {
+  private async onJobSuccess (jobHandler: JobHandler<any>, job: JobInstance, jobResult: any) {
     job.state = JOB_STATES.SUCCESS
 
-    return job.save()
-      .then(() => jobHandler.onSuccess(job.id, jobResult))
-      .catch(err => this.cannotSaveJobError(err))
+    try {
+      await job.save()
+      jobHandler.onSuccess(job.id, jobResult)
+    } catch (err) {
+      this.cannotSaveJobError(err)
+    }
   }
 
   private cannotSaveJobError (err: Error) {
diff --git a/server/lib/oauth-model.ts b/server/lib/oauth-model.ts
index 9aa3ea52f..d91b00c55 100644
--- a/server/lib/oauth-model.ts
+++ b/server/lib/oauth-model.ts
@@ -24,39 +24,36 @@ function getRefreshToken (refreshToken: string) {
   return db.OAuthToken.getByRefreshTokenAndPopulateClient(refreshToken)
 }
 
-function getUser (username: string, password: string) {
+async function getUser (username: string, password: string) {
   logger.debug('Getting User (username: ' + username + ', password: ******).')
 
-  return db.User.getByUsername(username).then(user => {
-    if (!user) return null
+  const user = await db.User.getByUsername(username)
+  if (!user) return null
 
-    return user.isPasswordMatch(password).then(passwordMatch => {
-      if (passwordMatch === false) return null
+  const passwordMatch = await user.isPasswordMatch(password)
+  if (passwordMatch === false) return null
 
-      return user
-    })
-  })
+  return user
 }
 
-function revokeToken (token: TokenInfo) {
-  return db.OAuthToken.getByRefreshTokenAndPopulateUser(token.refreshToken).then(tokenDB => {
-    if (tokenDB) tokenDB.destroy()
-
-    /*
-      * Thanks to https://github.com/manjeshpv/node-oauth2-server-implementation/blob/master/components/oauth/mongo-models.js
-      * "As per the discussion we need set older date
-      * revokeToken will expected return a boolean in future version
-      * https://github.com/oauthjs/node-oauth2-server/pull/274
-      * https://github.com/oauthjs/node-oauth2-server/issues/290"
-    */
-    const expiredToken = tokenDB
-    expiredToken.refreshTokenExpiresAt = new Date('2015-05-28T06:59:53.000Z')
-
-    return expiredToken
-  })
+async function revokeToken (tokenInfo: TokenInfo) {
+  const token = await db.OAuthToken.getByRefreshTokenAndPopulateUser(tokenInfo.refreshToken)
+  if (token) token.destroy()
+
+  /*
+    * Thanks to https://github.com/manjeshpv/node-oauth2-server-implementation/blob/master/components/oauth/mongo-models.js
+    * "As per the discussion we need set older date
+    * revokeToken will expected return a boolean in future version
+    * https://github.com/oauthjs/node-oauth2-server/pull/274
+    * https://github.com/oauthjs/node-oauth2-server/issues/290"
+  */
+  const expiredToken = token
+  expiredToken.refreshTokenExpiresAt = new Date('2015-05-28T06:59:53.000Z')
+
+  return expiredToken
 }
 
-function saveToken (token: TokenInfo, client: OAuthClientInstance, user: UserInstance) {
+async function saveToken (token: TokenInfo, client: OAuthClientInstance, user: UserInstance) {
   logger.debug('Saving token ' + token.accessToken + ' for client ' + client.id + ' and user ' + user.id + '.')
 
   const tokenToCreate = {
@@ -68,11 +65,10 @@ function saveToken (token: TokenInfo, client: OAuthClientInstance, user: UserIns
     userId: user.id
   }
 
-  return db.OAuthToken.create(tokenToCreate).then(tokenCreated => {
-    const tokenToReturn = Object.assign(tokenCreated, { client, user })
+  const tokenCreated = await db.OAuthToken.create(tokenToCreate)
+  const tokenToReturn = Object.assign(tokenCreated, { client, user })
 
-    return tokenToReturn
-  })
+  return tokenToReturn
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/request/abstract-request-scheduler.ts b/server/lib/request/abstract-request-scheduler.ts
index ce4e2ffd2..f46682824 100644
--- a/server/lib/request/abstract-request-scheduler.ts
+++ b/server/lib/request/abstract-request-scheduler.ts
@@ -1,5 +1,5 @@
 import { isEmpty } from 'lodash'
-import * as Promise from 'bluebird'
+import * as Bluebird from 'bluebird'
 
 import { database as db } from '../../initializers/database'
 import { logger, makeSecureRequest } from '../../helpers'
@@ -76,7 +76,7 @@ abstract class AbstractRequestScheduler <T> {
   // ---------------------------------------------------------------------------
 
   // Make a requests to friends of a certain type
-  protected makeRequest (toPod: PodInstance, requestEndpoint: string, requestsToMake: any) {
+  protected async makeRequest (toPod: PodInstance, requestEndpoint: string, requestsToMake: any) {
     const params = {
       toPod: toPod,
       method: 'POST' as 'POST',
@@ -86,72 +86,75 @@ abstract class AbstractRequestScheduler <T> {
 
     // Make multiple retry requests to all of pods
     // The function fire some useful callbacks
-    return makeSecureRequest(params)
-      .then(({ response, body }) => {
-        if (response.statusCode !== 200 && response.statusCode !== 201 && response.statusCode !== 204) {
-          throw new Error('Status code not 20x : ' + response.statusCode)
-        }
-      })
-      .catch(err => {
-        logger.error('Error sending secure request to %s pod.', toPod.host, err)
-
-        throw err
-      })
+    try {
+      const { response } = await makeSecureRequest(params)
+      if (response.statusCode !== 200 && response.statusCode !== 201 && response.statusCode !== 204) {
+        throw new Error('Status code not 20x : ' + response.statusCode)
+      }
+    } catch (err) {
+      logger.error('Error sending secure request to %s pod.', toPod.host, err)
+
+      throw err
+    }
   }
 
     // Make all the requests of the scheduler
-  protected makeRequests () {
-    return this.getRequestModel().listWithLimitAndRandom(this.limitPods, this.limitPerPod)
-      .then((requestsGrouped: T) => {
-        // We want to group requests by destinations pod and endpoint
-        const requestsToMake = this.buildRequestsObjects(requestsGrouped)
-
-        // If there are no requests, abort
-        if (isEmpty(requestsToMake) === true) {
-          logger.info('No "%s" to make.', this.description)
-          return { goodPods: [], badPods: [] }
-        }
-
-        logger.info('Making "%s" to friends.', this.description)
-
-        const goodPods: number[] = []
-        const badPods: number[] = []
-
-        return Promise.map(Object.keys(requestsToMake), hashKey => {
-          const requestToMake = requestsToMake[hashKey]
-          const toPod: PodInstance = requestToMake.toPod
-
-          return this.makeRequest(toPod, requestToMake.endpoint, requestToMake.datas)
-            .then(() => {
-              logger.debug('Removing requests for pod %s.', requestToMake.toPod.id, { requestsIds: requestToMake.ids })
-              goodPods.push(requestToMake.toPod.id)
-
-              this.afterRequestHook()
-
-              // Remove the pod id of these request ids
-              return this.getRequestToPodModel().removeByRequestIdsAndPod(requestToMake.ids, requestToMake.toPod.id)
-            })
-            .catch(err => {
-              badPods.push(requestToMake.toPod.id)
-              logger.info('Cannot make request to %s.', toPod.host, err)
-            })
-        }, { concurrency: REQUESTS_IN_PARALLEL }).then(() => ({ goodPods, badPods }))
-      })
-      .then(({ goodPods, badPods }) => {
-        this.afterRequestsHook()
-
-        // All the requests were made, we update the pods score
-        return db.Pod.updatePodsScore(goodPods, badPods)
-      })
-      .catch(err => logger.error('Cannot get the list of "%s".', this.description, { error: err.stack }))
+  protected async makeRequests () {
+    let requestsGrouped: T
+
+    try {
+      requestsGrouped = await this.getRequestModel().listWithLimitAndRandom(this.limitPods, this.limitPerPod)
+    } catch (err) {
+      logger.error('Cannot get the list of "%s".', this.description, { error: err.stack })
+      throw err
+    }
+
+    // We want to group requests by destinations pod and endpoint
+    const requestsToMake = this.buildRequestsObjects(requestsGrouped)
+
+    // If there are no requests, abort
+    if (isEmpty(requestsToMake) === true) {
+      logger.info('No "%s" to make.', this.description)
+      return { goodPods: [], badPods: [] }
+    }
+
+    logger.info('Making "%s" to friends.', this.description)
+
+    const goodPods: number[] = []
+    const badPods: number[] = []
+
+    await Bluebird.map(Object.keys(requestsToMake), async hashKey => {
+      const requestToMake = requestsToMake[hashKey]
+      const toPod: PodInstance = requestToMake.toPod
+
+      try {
+        await this.makeRequest(toPod, requestToMake.endpoint, requestToMake.datas)
+        logger.debug('Removing requests for pod %s.', requestToMake.toPod.id, { requestsIds: requestToMake.ids })
+        goodPods.push(requestToMake.toPod.id)
+
+        this.afterRequestHook()
+
+        // Remove the pod id of these request ids
+        await this.getRequestToPodModel()
+          .removeByRequestIdsAndPod(requestToMake.ids, requestToMake.toPod.id)
+      } catch (err) {
+        badPods.push(requestToMake.toPod.id)
+        logger.info('Cannot make request to %s.', toPod.host, err)
+      }
+    }, { concurrency: REQUESTS_IN_PARALLEL })
+
+    this.afterRequestsHook()
+
+    // All the requests were made, we update the pods score
+    await db.Pod.updatePodsScore(goodPods, badPods)
   }
 
   protected afterRequestHook () {
-   // Nothing to do, let children reimplement it
+   // Nothing to do, let children re-implement it
   }
 
   protected afterRequestsHook () {
-   // Nothing to do, let children reimplement it
+   // Nothing to do, let children re-implement it
   }
 }
 
diff --git a/server/lib/request/request-scheduler.ts b/server/lib/request/request-scheduler.ts
index 696875dcf..c3f7f6429 100644
--- a/server/lib/request/request-scheduler.ts
+++ b/server/lib/request/request-scheduler.ts
@@ -37,8 +37,8 @@ class RequestScheduler extends AbstractRequestScheduler<RequestsGrouped> {
   buildRequestsObjects (requestsGrouped: RequestsGrouped) {
     const requestsToMakeGrouped: RequestsObjects<RemoteVideoRequest> = {}
 
-    Object.keys(requestsGrouped).forEach(toPodId => {
-      requestsGrouped[toPodId].forEach(data => {
+    for (const toPodId of Object.keys(requestsGrouped)) {
+      for (const data of requestsGrouped[toPodId]) {
         const request = data.request
         const pod = data.pod
         const hashKey = toPodId + request.endpoint
@@ -54,13 +54,13 @@ class RequestScheduler extends AbstractRequestScheduler<RequestsGrouped> {
 
         requestsToMakeGrouped[hashKey].ids.push(request.id)
         requestsToMakeGrouped[hashKey].datas.push(request.request)
-      })
-    })
+      }
+    }
 
     return requestsToMakeGrouped
   }
 
-  createRequest ({ type, endpoint, data, toIds, transaction }: RequestSchedulerOptions) {
+  async createRequest ({ type, endpoint, data, toIds, transaction }: RequestSchedulerOptions) {
     // If there are no destination pods abort
     if (toIds.length === 0) return undefined
 
@@ -76,10 +76,8 @@ class RequestScheduler extends AbstractRequestScheduler<RequestsGrouped> {
       transaction
     }
 
-    return db.Request.create(createQuery, dbRequestOptions)
-      .then(request => {
-        return request.setPods(toIds, dbRequestOptions)
-      })
+    const request = await db.Request.create(createQuery, dbRequestOptions)
+    await request.setPods(toIds, dbRequestOptions)
   }
 
   // ---------------------------------------------------------------------------
diff --git a/server/lib/request/request-video-event-scheduler.ts b/server/lib/request/request-video-event-scheduler.ts
index 680232732..5f21287f0 100644
--- a/server/lib/request/request-video-event-scheduler.ts
+++ b/server/lib/request/request-video-event-scheduler.ts
@@ -59,8 +59,8 @@ class RequestVideoEventScheduler extends AbstractRequestScheduler<RequestsVideoE
 
     // We group video events per video and per pod
     // We add the counts of the same event types
-    Object.keys(eventRequests).forEach(toPodId => {
-      eventRequests[toPodId].forEach(eventToProcess => {
+    for (const toPodId of Object.keys(eventRequests)) {
+      for (const eventToProcess of eventRequests[toPodId]) {
         if (!eventsPerVideoPerPod[toPodId]) eventsPerVideoPerPod[toPodId] = {}
 
         if (!requestsToMakeGrouped[toPodId]) {
@@ -81,17 +81,17 @@ class RequestVideoEventScheduler extends AbstractRequestScheduler<RequestsVideoE
         if (!events[eventToProcess.type]) events[eventToProcess.type] = 0
 
         events[eventToProcess.type] += eventToProcess.count
-      })
-    })
+      }
+    }
 
     // Now we build our requests array per pod
-    Object.keys(eventsPerVideoPerPod).forEach(toPodId => {
+    for (const toPodId of Object.keys(eventsPerVideoPerPod)) {
       const eventsForPod = eventsPerVideoPerPod[toPodId]
 
-      Object.keys(eventsForPod).forEach(uuid => {
+      for (const uuid of Object.keys(eventsForPod)) {
         const eventsForVideo = eventsForPod[uuid]
 
-        Object.keys(eventsForVideo).forEach(eventType => {
+        for (const eventType of Object.keys(eventsForVideo)) {
           requestsToMakeGrouped[toPodId].datas.push({
             data: {
               uuid,
@@ -99,9 +99,9 @@ class RequestVideoEventScheduler extends AbstractRequestScheduler<RequestsVideoE
               count: +eventsForVideo[eventType]
             }
           })
-        })
-      })
-    })
+        }
+      }
+    }
 
     return requestsToMakeGrouped
   }
diff --git a/server/lib/request/request-video-qadu-scheduler.ts b/server/lib/request/request-video-qadu-scheduler.ts
index d7e1d5e31..a54efc111 100644
--- a/server/lib/request/request-video-qadu-scheduler.ts
+++ b/server/lib/request/request-video-qadu-scheduler.ts
@@ -59,8 +59,8 @@ class RequestVideoQaduScheduler extends AbstractRequestScheduler<RequestsVideoQa
   buildRequestsObjects (requests: RequestsVideoQaduGrouped) {
     const requestsToMakeGrouped: RequestsObjectsCustom<RemoteQaduVideoRequest> = {}
 
-    Object.keys(requests).forEach(toPodId => {
-      requests[toPodId].forEach(data => {
+    for (const toPodId of Object.keys(requests)) {
+      for (const data of requests[toPodId]) {
         const request = data.request
         const video = data.video
         const pod = data.pod
@@ -105,39 +105,39 @@ class RequestVideoQaduScheduler extends AbstractRequestScheduler<RequestsVideoQa
         // Maybe there are multiple quick and dirty update for the same video
         // We use this hash map to dedupe them
         requestsToMakeGrouped[hashKey].videos[video.id] = videoData
-      })
-    })
+      }
+    }
 
     // Now we deduped similar quick and dirty updates, we can build our requests data
-    Object.keys(requestsToMakeGrouped).forEach(hashKey => {
-      Object.keys(requestsToMakeGrouped[hashKey].videos).forEach(videoUUID => {
+    for (const hashKey of Object.keys(requestsToMakeGrouped)) {
+      for (const videoUUID of Object.keys(requestsToMakeGrouped[hashKey].videos)) {
         const videoData = requestsToMakeGrouped[hashKey].videos[videoUUID]
 
         requestsToMakeGrouped[hashKey].datas.push({
           data: videoData
         })
-      })
+      }
 
       // We don't need it anymore, it was just to build our data array
       delete requestsToMakeGrouped[hashKey].videos
-    })
+    }
 
     return requestsToMakeGrouped
   }
 
-  createRequest ({ type, videoId, transaction }: RequestVideoQaduSchedulerOptions) {
+  async createRequest ({ type, videoId, transaction }: RequestVideoQaduSchedulerOptions) {
     const dbRequestOptions: Sequelize.BulkCreateOptions = {}
     if (transaction) dbRequestOptions.transaction = transaction
 
     // Send the update to all our friends
-    return db.Pod.listAllIds(transaction).then(podIds => {
-      const queries = []
-      podIds.forEach(podId => {
-        queries.push({ type, videoId, podId })
-      })
-
-      return db.RequestVideoQadu.bulkCreate(queries, dbRequestOptions)
-    })
+    const podIds = await db.Pod.listAllIds(transaction)
+    const queries = []
+    for (const podId of podIds) {
+      queries.push({ type, videoId, podId })
+    }
+
+    await db.RequestVideoQadu.bulkCreate(queries, dbRequestOptions)
+    return undefined
   }
 }
 
diff --git a/server/lib/user.ts b/server/lib/user.ts
index 8609e72d8..a92f4777b 100644
--- a/server/lib/user.ts
+++ b/server/lib/user.ts
@@ -3,40 +3,36 @@ import { UserInstance } from '../models'
 import { addVideoAuthorToFriends } from './friends'
 import { createVideoChannel } from './video-channel'
 
-function createUserAuthorAndChannel (user: UserInstance, validateUser = true) {
-  return db.sequelize.transaction(t => {
+async function createUserAuthorAndChannel (user: UserInstance, validateUser = true) {
+  const res = await db.sequelize.transaction(async t => {
     const userOptions = {
       transaction: t,
       validate: validateUser
     }
 
-    return user.save(userOptions)
-      .then(user => {
-        const author = db.Author.build({
-          name: user.username,
-          podId: null, // It is our pod
-          userId: user.id
-        })
-
-        return author.save({ transaction: t })
-          .then(author => ({ author, user }))
-      })
-      .then(({ author, user }) => {
-        const remoteVideoAuthor = author.toAddRemoteJSON()
-
-        // Now we'll add the video channel's meta data to our friends
-        return addVideoAuthorToFriends(remoteVideoAuthor, t)
-          .then(() => ({ author, user }))
-      })
-      .then(({ author, user }) => {
-        const videoChannelInfo = {
-          name: `Default ${user.username} channel`
-        }
-
-        return createVideoChannel(videoChannelInfo, author, t)
-          .then(videoChannel => ({ author, user, videoChannel }))
-      })
+    const userCreated = await user.save(userOptions)
+    const authorInstance = db.Author.build({
+      name: userCreated.username,
+      podId: null, // It is our pod
+      userId: userCreated.id
+    })
+
+    const authorCreated = await authorInstance.save({ transaction: t })
+
+    const remoteVideoAuthor = authorCreated.toAddRemoteJSON()
+
+    // Now we'll add the video channel's meta data to our friends
+    const author = await addVideoAuthorToFriends(remoteVideoAuthor, t)
+
+    const videoChannelInfo = {
+      name: `Default ${userCreated.username} channel`
+    }
+    const videoChannel = await createVideoChannel(videoChannelInfo, authorCreated, t)
+
+    return { author, videoChannel }
   })
+
+  return res
 }
 
 // ---------------------------------------------------------------------------