X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Finitializers%2Finstaller.ts;h=4c04290fc455542728504eae71322883b8d529a9;hb=f5028693a896a3076dd286ac0030e3d8f78f5ebf;hp=2f9b589916b9bc6e28c0f50b945639f70cd31656;hpb=4d4e5cd4dca78480ec7f40e747f424cd107376a4;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/initializers/installer.ts b/server/initializers/installer.ts
index 2f9b58991..4c04290fc 100644
--- a/server/initializers/installer.ts
+++ b/server/initializers/installer.ts
@@ -1,37 +1,19 @@
-import { join } from 'path'
-import * as config from 'config'
-import { each, series } from 'async'
-import * as mkdirp from 'mkdirp'
 import * as passwordGenerator from 'password-generator'
+import * as Bluebird from 'bluebird'
 
 import { database as db } from './database'
-import { USER_ROLES, CONFIG, LAST_MIGRATION_VERSION } from './constants'
+import { USER_ROLES, CONFIG, LAST_MIGRATION_VERSION, CACHE } from './constants'
 import { clientsExist, usersExist } from './checker'
-import { logger, createCertsIfNotExist, root } from '../helpers'
-
-function installApplication (callback) {
-  series([
-    function createDatabase (callbackAsync) {
-      db.sequelize.sync().asCallback(callbackAsync)
-      // db.sequelize.sync({ force: true }).asCallback(callbackAsync)
-    },
-
-    function createDirectories (callbackAsync) {
-      createDirectoriesIfNotExist(callbackAsync)
-    },
-
-    function createCertificates (callbackAsync) {
-      createCertsIfNotExist(callbackAsync)
-    },
-
-    function createOAuthClient (callbackAsync) {
-      createOAuthClientIfNotExist(callbackAsync)
-    },
-
-    function createOAuthUser (callbackAsync) {
-      createOAuthAdminIfNotExist(callbackAsync)
-    }
-  ], callback)
+import { logger, createCertsIfNotExist, mkdirpPromise, rimrafPromise } from '../helpers'
+import { createUserAuthorAndChannel } from '../lib'
+
+async function installApplication () {
+  await db.sequelize.sync()
+  await removeCacheDirectories()
+  await createDirectoriesIfNotExist()
+  await createCertsIfNotExist()
+  await createOAuthClientIfNotExist()
+  await createOAuthAdminIfNotExist()
 }
 
 // ---------------------------------------------------------------------------
@@ -42,88 +24,102 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function createDirectoriesIfNotExist (callback) {
-  const storages = config.get('storage')
-
-  each(Object.keys(storages), function (key, callbackEach) {
-    const dir = storages[key]
-    mkdirp(join(root(), dir), callbackEach)
-  }, callback)
-}
+function removeCacheDirectories () {
+  const cacheDirectories = CACHE.DIRECTORIES
 
-function createOAuthClientIfNotExist (callback) {
-  clientsExist(function (err, exist) {
-    if (err) return callback(err)
+  const tasks: Bluebird<any>[] = []
 
-    // Nothing to do, clients already exist
-    if (exist === true) return callback(null)
+  // Cache directories
+  for (const key of Object.keys(cacheDirectories)) {
+    const dir = cacheDirectories[key]
+    tasks.push(rimrafPromise(dir))
+  }
 
-    logger.info('Creating a default OAuth Client.')
+  return Promise.all(tasks)
+}
 
-    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 createDirectoriesIfNotExist () {
+  const storage = CONFIG.STORAGE
+  const cacheDirectories = CACHE.DIRECTORIES
 
-    client.save().asCallback(function (err, createdClient) {
-      if (err) return callback(err)
+  const tasks = []
+  for (const key of Object.keys(storage)) {
+    const dir = storage[key]
+    tasks.push(mkdirpPromise(dir))
+  }
 
-      logger.info('Client id: ' + createdClient.clientId)
-      logger.info('Client secret: ' + createdClient.clientSecret)
+  // Cache directories
+  for (const key of Object.keys(cacheDirectories)) {
+    const dir = cacheDirectories[key]
+    tasks.push(mkdirpPromise(dir))
+  }
 
-      return callback(null)
-    })
-  })
+  return Promise.all(tasks)
 }
 
-function createOAuthAdminIfNotExist (callback) {
-  usersExist(function (err, exist) {
-    if (err) return callback(err)
+async function createOAuthClientIfNotExist () {
+  const exist = await clientsExist(db.OAuthClient)
+  // Nothing to do, clients already exist
+  if (exist === true) return undefined
 
-    // Nothing to do, users already exist
-    if (exist === true) return callback(null)
+  logger.info('Creating a default OAuth Client.')
 
-    logger.info('Creating the administrator.')
+  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
+  })
 
-    const username = 'root'
-    const role = USER_ROLES.ADMIN
-    const email = CONFIG.ADMIN.EMAIL
-    const createOptions: { validate?: boolean } = {}
-    let password = ''
+  const createdClient = await client.save()
+  logger.info('Client id: ' + createdClient.clientId)
+  logger.info('Client secret: ' + createdClient.clientSecret)
 
-    // Do not generate a random password for tests
-    if (process.env.NODE_ENV === 'test') {
-      password = 'test'
+  return undefined
+}
 
-      if (process.env.NODE_APP_INSTANCE) {
-        password += process.env.NODE_APP_INSTANCE
-      }
+async function createOAuthAdminIfNotExist () {
+  const exist = await usersExist(db.User)
+  // Nothing to do, users already exist
+  if (exist === true) return undefined
 
-      // Our password is weak so do not validate it
-      createOptions.validate = false
-    } else {
-      password = passwordGenerator(8, true)
-    }
+  logger.info('Creating the administrator.')
 
-    const userData = {
-      username,
-      email,
-      password,
-      role
-    }
+  const username = 'root'
+  const role = USER_ROLES.ADMIN
+  const email = CONFIG.ADMIN.EMAIL
+  let validatePassword = true
+  let password = ''
 
-    db.User.create(userData, createOptions).asCallback(function (err, createdUser) {
-      if (err) return callback(err)
+  // Do not generate a random password for tests
+  if (process.env.NODE_ENV === 'test') {
+    password = 'test'
 
-      logger.info('Username: ' + username)
-      logger.info('User password: ' + password)
+    if (process.env.NODE_APP_INSTANCE) {
+      password += process.env.NODE_APP_INSTANCE
+    }
 
-      logger.info('Creating Application table.')
-      db.Application.create({ migrationVersion: LAST_MIGRATION_VERSION }).asCallback(callback)
-    })
-  })
+    // 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 })
 }