3 files changed, 60 insertions, 65 deletions

diff --git a/server/helpers/peertube-crypto.ts b/server/helpers/peertube-crypto.ts
index 89aef99c4..47f0243e7 100644
--- a/server/helpers/peertube-crypto.ts
+++ b/server/helpers/peertube-crypto.ts
@@ -1,5 +1,4 @@
 import * as crypto from 'crypto'
-import * as Promise from 'bluebird'
 import { join } from 'path'
 
 import {
@@ -41,7 +40,7 @@ function checkSignature (publicKey: string, data: string, hexSignature: string)
   return isValid
 }
 
-function sign (data: string|Object) {
+async function sign (data: string|Object) {
   const sign = crypto.createSign(SIGNATURE_ALGORITHM)
 
   let dataString: string
@@ -52,33 +51,33 @@ function sign (data: string|Object) {
       dataString = JSON.stringify(data)
     } catch (err) {
       logger.error('Cannot sign data.', err)
-      return Promise.resolve('')
+      return ''
     }
   }
 
   sign.update(dataString, 'utf8')
 
-  return getMyPrivateCert().then(myKey => {
-    return sign.sign(myKey, SIGNATURE_ENCODING)
-  })
+  const myKey = await getMyPrivateCert()
+  return await sign.sign(myKey, SIGNATURE_ENCODING)
 }
 
 function comparePassword (plainPassword: string, hashPassword: string) {
   return bcryptComparePromise(plainPassword, hashPassword)
 }
 
-function createCertsIfNotExist () {
-  return certsExist().then(exist => {
-    if (exist === true) {
-      return undefined
-    }
+async function createCertsIfNotExist () {
+  const exist = await certsExist()
+  if (exist === true) {
+    return undefined
+  }
 
-    return createCerts()
-  })
+  return await createCerts()
 }
 
-function cryptPassword (password: string) {
-  return bcryptGenSaltPromise(BCRYPT_SALT_SIZE).then(salt => bcryptHashPromise(password, salt))
+async function cryptPassword (password: string) {
+  const salt = await bcryptGenSaltPromise(BCRYPT_SALT_SIZE)
+
+  return await bcryptHashPromise(password, salt)
 }
 
 function getMyPrivateCert () {
@@ -105,51 +104,45 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function certsExist () {
+async function certsExist () {
   const certPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
 
   // If there is an error the certificates do not exist
-  return accessPromise(certPath)
-    .then(() => true)
-    .catch(() => false)
+  try {
+    await accessPromise(certPath)
+
+    return true
+  } catch {
+    return false
+  }
 }
 
-function createCerts () {
-  return certsExist().then(exist => {
-    if (exist === true) {
-      const errorMessage = 'Certs already exist.'
-      logger.warning(errorMessage)
-      throw new Error(errorMessage)
-    }
+async function createCerts () {
+  const exist = await certsExist()
+  if (exist === true) {
+    const errorMessage = 'Certs already exist.'
+    logger.warning(errorMessage)
+    throw new Error(errorMessage)
+  }
 
-    logger.info('Generating a RSA key...')
+  logger.info('Generating a RSA key...')
 
-    const privateCertPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
-    const genRsaOptions = {
-      'out': privateCertPath,
-      '2048': false
-    }
-    return opensslExecPromise('genrsa', genRsaOptions)
-      .then(() => {
-        logger.info('RSA key generated.')
-        logger.info('Managing public key...')
-
-        const publicCertPath = join(CONFIG.STORAGE.CERT_DIR, 'peertube.pub')
-        const rsaOptions = {
-          'in': privateCertPath,
-          'pubout': true,
-          'out': publicCertPath
-        }
-        return opensslExecPromise('rsa', rsaOptions)
-          .then(() => logger.info('Public key managed.'))
-          .catch(err => {
-            logger.error('Cannot create public key on this pod.')
-            throw err
-          })
-      })
-      .catch(err => {
-        logger.error('Cannot create private key on this pod.')
-        throw err
-      })
-  })
+  const privateCertPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
+  const genRsaOptions = {
+    'out': privateCertPath,
+    '2048': false
+  }
+
+  await opensslExecPromise('genrsa', genRsaOptions)
+  logger.info('RSA key generated.')
+  logger.info('Managing public key...')
+
+  const publicCertPath = join(CONFIG.STORAGE.CERT_DIR, 'peertube.pub')
+  const rsaOptions = {
+    'in': privateCertPath,
+    'pubout': true,
+    'out': publicCertPath
+  }
+
+  await opensslExecPromise('rsa', rsaOptions)
 }
diff --git a/server/helpers/requests.ts b/server/helpers/requests.ts
index d67d46044..8c5d848f3 100644
--- a/server/helpers/requests.ts
+++ b/server/helpers/requests.ts
@@ -73,7 +73,7 @@ function makeSecureRequest (params: MakeSecureRequestParams) {
         signature
       }
 
-      // If there are data informations
+      // If there are data information
       if (params.data) {
         requestParams.json.data = params.data
       }
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index 6cabe117c..8b81a61e1 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -8,11 +8,13 @@ import { ResultList } from '../../shared'
 import { VideoResolution } from '../../shared/models/videos/video-resolution.enum'
 
 function badRequest (req: express.Request, res: express.Response, next: express.NextFunction) {
-  res.type('json').status(400).end()
+  return res.type('json').status(400).end()
 }
 
-function generateRandomString (size: number) {
-  return pseudoRandomBytesPromise(size).then(raw => raw.toString('hex'))
+async function generateRandomString (size: number) {
+  const raw = await pseudoRandomBytesPromise(size)
+
+  return raw.toString('hex')
 }
 
 interface FormattableToJSON {
@@ -34,19 +36,19 @@ function getFormattedObjects<U, T extends FormattableToJSON> (objects: T[], obje
   return res
 }
 
-function isSignupAllowed () {
+async function isSignupAllowed () {
   if (CONFIG.SIGNUP.ENABLED === false) {
-    return Promise.resolve(false)
+    return false
   }
 
   // No limit and signup is enabled
   if (CONFIG.SIGNUP.LIMIT === -1) {
-    return Promise.resolve(true)
+    return true
   }
 
-  return db.User.countTotal().then(totalUsers => {
-    return totalUsers < CONFIG.SIGNUP.LIMIT
-  })
+  const totalUsers = await db.User.countTotal()
+
+  return totalUsers < CONFIG.SIGNUP.LIMIT
 }
 
 function computeResolutionsToTranscode (videoFileHeight: number) {