Use async/await in lib and initializers

1 files changed, 68 insertions, 73 deletions

diff --git a/server/initializers/installer.ts b/server/initializers/installer.ts
index b997de07f..4c04290fc 100644
--- a/server/initializers/installer.ts
+++ b/server/initializers/installer.ts
@@ -1,5 +1,5 @@
 import * as passwordGenerator from 'password-generator'
-import * as Promise from 'bluebird'
+import * as Bluebird from 'bluebird'
 
 import { database as db } from './database'
 import { USER_ROLES, CONFIG, LAST_MIGRATION_VERSION, CACHE } from './constants'
@@ -7,13 +7,13 @@ import { clientsExist, usersExist } from './checker'
 import { logger, createCertsIfNotExist, mkdirpPromise, rimrafPromise } from '../helpers'
 import { createUserAuthorAndChannel } from '../lib'
 
-function installApplication () {
-  return db.sequelize.sync()
-    .then(() => removeCacheDirectories())
-    .then(() => createDirectoriesIfNotExist())
-    .then(() => createCertsIfNotExist())
-    .then(() => createOAuthClientIfNotExist())
-    .then(() => createOAuthAdminIfNotExist())
+async function installApplication () {
+  await db.sequelize.sync()
+  await removeCacheDirectories()
+  await createDirectoriesIfNotExist()
+  await createCertsIfNotExist()
+  await createOAuthClientIfNotExist()
+  await createOAuthAdminIfNotExist()
 }
 
 // ---------------------------------------------------------------------------
@@ -27,13 +27,13 @@ export {
 function removeCacheDirectories () {
   const cacheDirectories = CACHE.DIRECTORIES
 
-  const tasks = []
+  const tasks: Bluebird<any>[] = []
 
   // Cache directories
-  Object.keys(cacheDirectories).forEach(key => {
+  for (const key of Object.keys(cacheDirectories)) {
     const dir = cacheDirectories[key]
     tasks.push(rimrafPromise(dir))
-  })
+  }
 
   return Promise.all(tasks)
 }
@@ -43,88 +43,83 @@ function createDirectoriesIfNotExist () {
   const cacheDirectories = CACHE.DIRECTORIES
 
   const tasks = []
-  Object.keys(storage).forEach(key => {
+  for (const key of Object.keys(storage)) {
     const dir = storage[key]
     tasks.push(mkdirpPromise(dir))
-  })
+  }
 
   // Cache directories
-  Object.keys(cacheDirectories).forEach(key => {
+  for (const key of Object.keys(cacheDirectories)) {
     const dir = cacheDirectories[key]
     tasks.push(mkdirpPromise(dir))
-  })
+  }
 
   return Promise.all(tasks)
 }
 
-function createOAuthClientIfNotExist () {
-  return clientsExist(db.OAuthClient).then(exist => {
-    // Nothing to do, clients already exist
-    if (exist === true) return undefined
-
-    logger.info('Creating a default OAuth Client.')
-
-    const id = passwordGenerator(32, false, /[a-z0-9]/)
-    const secret = passwordGenerator(32, false, /[a-zA-Z0-9]/)
-    const client = db.OAuthClient.build({
-      clientId: id,
-      clientSecret: secret,
-      grants: [ 'password', 'refresh_token' ],
-      redirectUris: null
-    })
+async function createOAuthClientIfNotExist () {
+  const exist = await clientsExist(db.OAuthClient)
+  // Nothing to do, clients already exist
+  if (exist === true) return undefined
 
-    return client.save().then(createdClient => {
-      logger.info('Client id: ' + createdClient.clientId)
-      logger.info('Client secret: ' + createdClient.clientSecret)
+  logger.info('Creating a default OAuth Client.')
 
-      return undefined
-    })
+  const id = passwordGenerator(32, false, /[a-z0-9]/)
+  const secret = passwordGenerator(32, false, /[a-zA-Z0-9]/)
+  const client = db.OAuthClient.build({
+    clientId: id,
+    clientSecret: secret,
+    grants: [ 'password', 'refresh_token' ],
+    redirectUris: null
   })
-}
 
-function createOAuthAdminIfNotExist () {
-  return usersExist(db.User).then(exist => {
-    // Nothing to do, users already exist
-    if (exist === true) return undefined
+  const createdClient = await client.save()
+  logger.info('Client id: ' + createdClient.clientId)
+  logger.info('Client secret: ' + createdClient.clientSecret)
 
-    logger.info('Creating the administrator.')
+  return undefined
+}
 
-    const username = 'root'
-    const role = USER_ROLES.ADMIN
-    const email = CONFIG.ADMIN.EMAIL
-    let validatePassword = true
-    let password = ''
+async function createOAuthAdminIfNotExist () {
+  const exist = await usersExist(db.User)
+  // Nothing to do, users already exist
+  if (exist === true) return undefined
 
-    // Do not generate a random password for tests
-    if (process.env.NODE_ENV === 'test') {
-      password = 'test'
+  logger.info('Creating the administrator.')
 
-      if (process.env.NODE_APP_INSTANCE) {
-        password += process.env.NODE_APP_INSTANCE
-      }
+  const username = 'root'
+  const role = USER_ROLES.ADMIN
+  const email = CONFIG.ADMIN.EMAIL
+  let validatePassword = true
+  let password = ''
 
-      // Our password is weak so do not validate it
-      validatePassword = false
-    } else {
-      password = passwordGenerator(8, true)
-    }
+  // Do not generate a random password for tests
+  if (process.env.NODE_ENV === 'test') {
+    password = 'test'
 
-    const userData = {
-      username,
-      email,
-      password,
-      role,
-      videoQuota: -1
+    if (process.env.NODE_APP_INSTANCE) {
+      password += process.env.NODE_APP_INSTANCE
     }
-    const user = db.User.build(userData)
 
-    return createUserAuthorAndChannel(user, validatePassword)
-      .then(({ user }) => {
-        logger.info('Username: ' + username)
-        logger.info('User password: ' + password)
-
-        logger.info('Creating Application table.')
-        return db.Application.create({ migrationVersion: LAST_MIGRATION_VERSION })
-      })
-  })
+    // Our password is weak so do not validate it
+    validatePassword = false
+  } else {
+    password = passwordGenerator(8, true)
+  }
+
+  const userData = {
+    username,
+    email,
+    password,
+    role,
+    videoQuota: -1
+  }
+  const user = db.User.build(userData)
+
+  await createUserAuthorAndChannel(user, validatePassword)
+  logger.info('Username: ' + username)
+  logger.info('User password: ' + password)
+
+  logger.info('Creating Application table.')
+  await db.Application.create({ migrationVersion: LAST_MIGRATION_VERSION })
 }