refactor: rewrite src/install with async/await

install/databases.js

@@ -1,58 +1,51 @@
 'use strict';
 
-var async = require('async');
+const prompt = require('prompt');
-var prompt = require('prompt');
+const winston = require('winston');
-var winston = require('winston');
 
-var questions = {
+const util = require('util');
+
+const promptGet = util.promisify((schema, callback) => prompt.get(schema, callback));
+
+const questions = {
 	redis: require('../src/database/redis').questions,
 	mongo: require('../src/database/mongo').questions,
 	postgres: require('../src/database/postgres').questions,
 };
 
-module.exports = function (config, callback) {
+module.exports = async function (config) {
-	async.waterfall([
-		function (next) {
 	winston.info('\nNow configuring ' + config.database + ' database:');
-			getDatabaseConfig(config, next);
+	const databaseConfig = await getDatabaseConfig(config);
-		},
+	return saveDatabaseConfig(config, databaseConfig);
-		function (databaseConfig, next) {
-			saveDatabaseConfig(config, databaseConfig, next);
-		},
-	], callback);
 };
 
-function getDatabaseConfig(config, callback) {
+async function getDatabaseConfig(config) {
 	if (!config) {
-		return callback(new Error('aborted'));
+		throw new Error('invalid config, aborted');
 	}
 
 	if (config.database === 'redis') {
 		if (config['redis:host'] && config['redis:port']) {
-			callback(null, config);
+			return config;
-		} else {
-			prompt.get(questions.redis, callback);
 		}
+		return await promptGet(questions.redis);
 	} else if (config.database === 'mongo') {
 		if ((config['mongo:host'] && config['mongo:port']) || config['mongo:uri']) {
-			callback(null, config);
+			return config;
-		} else {
-			prompt.get(questions.mongo, callback);
 		}
+		return await promptGet(questions.mongo);
 	} else if (config.database === 'postgres') {
 		if (config['postgres:host'] && config['postgres:port']) {
-			callback(null, config);
+			return config;
-		} else {
-			prompt.get(questions.postgres, callback);
 		}
-	} else {
+		return await promptGet(questions.postgres);
-		return callback(new Error('unknown database : ' + config.database));
 	}
+	throw new Error('unknown database : ' + config.database);
 }
 
-function saveDatabaseConfig(config, databaseConfig, callback) {
+function saveDatabaseConfig(config, databaseConfig) {
 	if (!databaseConfig) {
-		return callback(new Error('aborted'));
+		throw new Error('invalid config, aborted');
 	}
 
 	// Translate redis properties into redis object
@@ -86,13 +79,13 @@ function saveDatabaseConfig(config, databaseConfig, callback) {
 			ssl: databaseConfig['postgres:ssl'],
 		};
 	} else {
-		return callback(new Error('unknown database : ' + config.database));
+		throw new Error('unknown database : ' + config.database);
 	}
 
-	var allQuestions = questions.redis.concat(questions.mongo).concat(questions.postgres);
+	const allQuestions = questions.redis.concat(questions.mongo).concat(questions.postgres);
 	for (var x = 0; x < allQuestions.length; x += 1) {
 		delete config[allQuestions[x].name];
 	}
 
-	callback(null, config);
+	return config;
 }

src/cli/setup.js

@@ -23,7 +23,9 @@ function setup(initConfig) {
 	install.values = initConfig;
 
 	async.series([
-		install.setup,
+		async function () {
+			return await install.setup();
+		},
 		function (next) {
 			var configFile = paths.config;
 			if (nconf.get('config')) {

src/install.js

@@ -1,18 +1,20 @@
 'use strict';
 
-var async = require('async');
+const fs = require('fs');
-var fs = require('fs');
+const url = require('url');
-var url = require('url');
+const path = require('path');
-var path = require('path');
+const prompt = require('prompt');
-var prompt = require('prompt');
+const winston = require('winston');
-var winston = require('winston');
+const nconf = require('nconf');
-var nconf = require('nconf');
+const _ = require('lodash');
-var _ = require('lodash');
+const util = require('util');
 
-var utils = require('./utils.js');
+const promptGet = util.promisify((schema, callback) => prompt.get(schema, callback));
 
-var install = module.exports;
+const utils = require('./utils.js');
-var questions = {};
+
+const install = module.exports;
+const questions = {};
 
 questions.main = [
 	{
@@ -47,8 +49,8 @@ questions.optional = [
 	},
 ];
 
-function checkSetupFlag(next) {
+function checkSetupFlag() {
-	var setupVal = install.values;
+	let setupVal = install.values;
 
 	try {
 		if (nconf.get('setup')) {
@@ -61,7 +63,6 @@ function checkSetupFlag(next) {
 	if (setupVal && typeof setupVal === 'object') {
 		if (setupVal['admin:username'] && setupVal['admin:password'] && setupVal['admin:password:confirm'] && setupVal['admin:email']) {
 			install.values = setupVal;
-			next();
 		} else {
 			winston.error('Required values are missing for automated setup:');
 			if (!setupVal['admin:username']) {
@@ -82,13 +83,10 @@ function checkSetupFlag(next) {
 	} else if (nconf.get('database')) {
 		install.values = install.values || {};
 		install.values.database = nconf.get('database');
-		next();
-	} else {
-		next();
 	}
 }
 
-function checkCIFlag(next) {
+function checkCIFlag() {
 	var ciVals;
 	try {
 		ciVals = JSON.parse(nconf.get('ci'));
@@ -99,7 +97,6 @@ function checkCIFlag(next) {
 	if (ciVals && ciVals instanceof Object) {
 		if (ciVals.hasOwnProperty('host') && ciVals.hasOwnProperty('port') && ciVals.hasOwnProperty('database')) {
 			install.ciVals = ciVals;
-			next();
 		} else {
 			winston.error('Required values are missing for automated CI integration:');
 			if (!ciVals.hasOwnProperty('host')) {
@@ -114,29 +111,25 @@ function checkCIFlag(next) {
 
 			process.exit();
 		}
-	} else {
-		next();
 	}
 }
 
-function setupConfig(next) {
+async function setupConfig() {
-	var configureDatabases = require('../install/databases');
+	const configureDatabases = require('../install/databases');
 
 	// prompt prepends "prompt: " to questions, let's clear that.
 	prompt.start();
 	prompt.message = '';
 	prompt.delimiter = '';
 	prompt.colors = false;
+	let config = {};
 
-	async.waterfall([
-		function (next) {
 	if (install.values) {
 		// Use provided values, fall back to defaults
-				var config = {};
+		const redisQuestions = require('./database/redis').questions;
-				var redisQuestions = require('./database/redis').questions;
+		const mongoQuestions = require('./database/mongo').questions;
-				var mongoQuestions = require('./database/mongo').questions;
+		const postgresQuestions = require('./database/postgres').questions;
-				var postgresQuestions = require('./database/postgres').questions;
+		const allQuestions = questions.main.concat(questions.optional).concat(redisQuestions).concat(mongoQuestions).concat(postgresQuestions);
-				var allQuestions = questions.main.concat(questions.optional).concat(redisQuestions).concat(mongoQuestions).concat(postgresQuestions);
 
 		allQuestions.forEach(function (question) {
 			if (install.values.hasOwnProperty(question.name)) {
@@ -147,21 +140,14 @@ function setupConfig(next) {
 				config[question.name] = undefined;
 			}
 		});
-				setImmediate(next, null, config);
 	} else {
-				prompt.get(questions.main, next);
+		config = await promptGet(questions.main);
 	}
-		},
+	await configureDatabases(config);
-		function (config, next) {
+	await completeConfigSetup(config);
-			configureDatabases(config, next);
-		},
-		function (config, next) {
-			completeConfigSetup(config, next);
-		},
-	], next);
 }
 
-function completeConfigSetup(config, next) {
+async function completeConfigSetup(config) {
 	// Add CI object
 	if (install.ciVals) {
 		config.test_database = {};
@@ -177,14 +163,10 @@ function completeConfigSetup(config, next) {
 		config.package_manager = nconf.get('package_manager');
 	}
 	nconf.overrides(config);
-	async.waterfall([
+	const db = require('./database');
-		function (next) {
+	await db.init();
-			require('./database').init(next);
+	await db.createIndices();
-		},
+
-		function (next) {
-			require('./database').createIndices(next);
-		},
-		function (next) {
 	// Sanity-check/fix url/port
 	if (!/^http(?:s)?:\/\//.test(config.url)) {
 		config.url = 'http://' + config.url;
@@ -205,73 +187,57 @@ function completeConfigSetup(config, next) {
 	// ref: https://github.com/indexzero/nconf/issues/300
 	delete config.type;
 
-			var meta = require('./meta');
+	const meta = require('./meta');
-			meta.configs.set('submitPluginUsage', config.submitPluginUsage === 'yes' ? 1 : 0, function (err) {
+	await meta.configs.set('submitPluginUsage', config.submitPluginUsage === 'yes' ? 1 : 0);
-				next(err, config);
-			});
-		},
-		function (config, next) {
 	delete config.submitPluginUsage;
 
-			install.save(config, next);
+	await install.save(config);
-		},
-	], next);
 }
 
-function setupDefaultConfigs(next) {
+async function setupDefaultConfigs() {
 	console.log('Populating database with default configs, if not already set...');
-	var meta = require('./meta');
+	const meta = require('./meta');
-	var defaults = require(path.join(__dirname, '../', 'install/data/defaults.json'));
+	const defaults = require(path.join(__dirname, '../', 'install/data/defaults.json'));
 
-	meta.configs.setOnEmpty(defaults, function (err) {
+	await meta.configs.setOnEmpty(defaults);
-		if (err) {
+	await meta.configs.init();
-			return next(err);
-		}
-
-		meta.configs.init(next);
-	});
 }
 
-function enableDefaultTheme(next) {
+async function enableDefaultTheme() {
-	var meta = require('./meta');
+	const meta = require('./meta');
 
-	meta.configs.get('theme:id', function (err, id) {
+	const id = await meta.configs.get('theme:id');
-		if (err || id) {
+	if (id) {
 		console.log('Previous theme detected, skipping enabling default theme');
-			return next(err);
+		return;
 	}
-		var defaultTheme = nconf.get('defaultTheme') || 'nodebb-theme-persona';
+
+	const defaultTheme = nconf.get('defaultTheme') || 'nodebb-theme-persona';
 	console.log('Enabling default theme: ' + defaultTheme);
-		meta.themes.set({
+	await meta.themes.set({
 		type: 'local',
 		id: defaultTheme,
-		}, next);
 	});
 }
 
-function createAdministrator(next) {
+async function createAdministrator() {
-	var Groups = require('./groups');
+	const Groups = require('./groups');
-	Groups.getMemberCount('administrators', function (err, memberCount) {
+	const memberCount = await Groups.getMemberCount('administrators');
-		if (err) {
-			return next(err);
-		}
 	if (memberCount > 0) {
 		console.log('Administrator found, skipping Admin setup');
-			next();
+		return;
-		} else {
-			createAdmin(next);
 	}
-	});
+	return await createAdmin();
 }
 
-function createAdmin(callback) {
+async function createAdmin() {
-	var User = require('./user');
+	const User = require('./user');
-	var Groups = require('./groups');
+	const Groups = require('./groups');
-	var password;
+	let password;
 
 	winston.warn('No administrators have been detected, running initial user setup\n');
 
-	var questions = [{
+	let questions = [{
 		name: 'username',
 		description: 'Administrator username',
 		required: true,
@@ -282,7 +248,7 @@ function createAdmin(callback) {
 		pattern: /.+@.+/,
 		required: true,
 	}];
-	var passwordQuestions = [{
+	const passwordQuestions = [{
 		name: 'password',
 		description: 'Password',
 		required: true,
@@ -295,213 +261,160 @@ function createAdmin(callback) {
 		hidden: true,
 		type: 'string',
 	}];
-	function success(err, results) {
+
-		if (err) {
+	async function success(results) {
-			return callback(err);
-		}
 		if (!results) {
-			return callback(new Error('aborted'));
+			throw new Error('aborted');
 		}
 
 		if (results['password:confirm'] !== results.password) {
 			winston.warn('Passwords did not match, please try again');
-			return retryPassword(results);
+			return await retryPassword(results);
 		}
 
 		try {
 			User.isPasswordValid(results.password);
 		} catch (err) {
 			winston.warn('Password error, please try again. ' + err.message);
-			return retryPassword(results);
+			return await retryPassword(results);
 		}
 
-		var adminUid;
+		const adminUid = await User.create({
-		async.waterfall([
+			username: results.username,
-			function (next) {
+			password: results.password,
-				User.create({ username: results.username, password: results.password, email: results.email }, next);
+			email: results.email,
-			},
-			function (uid, next) {
-				adminUid = uid;
-				Groups.join('administrators', uid, next);
-			},
-			function (next) {
-				Groups.show('administrators', next);
-			},
-			function (next) {
-				Groups.ownership.grant(adminUid, 'administrators', next);
-			},
-		], function (err) {
-			if (err) {
-				return callback(err);
-			}
-			callback(null, password ? results : undefined);
 		});
+		await Groups.join('administrators', adminUid);
+		await Groups.show('administrators');
+		await Groups.ownership.grant(adminUid, 'administrators');
+
+		return password ? results : undefined;
 	}
-	function retryPassword(originalResults) {
+
+	async function retryPassword(originalResults) {
 		// Ask only the password questions
-		prompt.get(passwordQuestions, function (err, results) {
+		const results = await promptGet(passwordQuestions);
-			if (!results) {
-				return callback(new Error('aborted'));
-			}
 
 		// Update the original data with newly collected password
 		originalResults.password = results.password;
 		originalResults['password:confirm'] = results['password:confirm'];
 
 		// Send back to success to handle
-			success(err, originalResults);
+		return await success(originalResults);
-		});
 	}
 
 	// Add the password questions
 	questions = questions.concat(passwordQuestions);
 
 	if (!install.values) {
-		prompt.get(questions, success);
+		const results = await promptGet(questions);
-	} else {
+		return await success(results);
+	}
 	// If automated setup did not provide a user password, generate one, it will be shown to the user upon setup completion
 	if (!install.values.hasOwnProperty('admin:password') && !nconf.get('admin:password')) {
 		console.log('Password was not provided during automated setup, generating one...');
 		password = utils.generateUUID().slice(0, 8);
 	}
 
-		var results = {
+	const results = {
 		username: install.values['admin:username'] || nconf.get('admin:username') || 'admin',
 		email: install.values['admin:email'] || nconf.get('admin:email') || '',
 		password: install.values['admin:password'] || nconf.get('admin:password') || password,
 		'password:confirm': install.values['admin:password:confirm'] || nconf.get('admin:password') || password,
 	};
 
-		success(null, results);
+	return await success(results);
-	}
 }
 
-function createGlobalModeratorsGroup(next) {
+async function createGlobalModeratorsGroup() {
-	var groups = require('./groups');
+	const groups = require('./groups');
-	async.waterfall([
+	const exists = await groups.exists('Global Moderators');
-		function (next) {
-			groups.exists('Global Moderators', next);
-		},
-		function (exists, next) {
 	if (exists) {
 		winston.info('Global Moderators group found, skipping creation!');
-				return next(null, null);
+	} else {
-			}
+		await groups.create({
-			groups.create({
 			name: 'Global Moderators',
 			userTitle: 'Global Moderator',
 			description: 'Forum wide moderators',
 			hidden: 0,
 			private: 1,
 			disableJoinRequests: 1,
-			}, next);
+		});
-		},
+	}
-		function (groupData, next) {
+	await groups.show('Global Moderators');
-			groups.show('Global Moderators', next);
-		},
-	], next);
 }
 
-function giveGlobalPrivileges(next) {
+async function giveGlobalPrivileges() {
-	var privileges = require('./privileges');
+	const privileges = require('./privileges');
-	var defaultPrivileges = [
+	const defaultPrivileges = [
 		'groups:chat', 'groups:upload:post:image', 'groups:signature', 'groups:search:content',
 		'groups:search:users', 'groups:search:tags', 'groups:view:users', 'groups:view:tags', 'groups:view:groups',
 		'groups:local:login',
 	];
-	async.waterfall([
+	await privileges.global.give(defaultPrivileges, 'registered-users');
-		function (next) {
+	await privileges.global.give(defaultPrivileges.concat([
-			privileges.global.give(defaultPrivileges, 'registered-users', next);
+		'groups:ban', 'groups:upload:post:file', 'groups:view:users:info',
-		},
+	]), 'Global Moderators');
-		function (next) {
+	await privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'guests');
-			privileges.global.give(defaultPrivileges.concat(['groups:ban', 'groups:upload:post:file', 'groups:view:users:info']), 'Global Moderators', next);
+	await privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'spiders');
-		},
+}
-		function (next) {
+
-			privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'guests', next);
+async function createCategories() {
-		},
+	const Categories = require('./categories');
-		function (next) {
+	const db = require('./database');
-			privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'spiders', next);
+	const cids = await db.getSortedSetRange('categories:cid', 0, -1);
-		},
-	], next);
-}
-
-function createCategories(next) {
-	var Categories = require('./categories');
-	var db = require('./database');
-	db.getSortedSetRange('categories:cid', 0, -1, function (err, cids) {
-		if (err) {
-			return next(err);
-		}
-
 	if (Array.isArray(cids) && cids.length) {
 		console.log('Categories OK. Found ' + cids.length + ' categories.');
-			return next();
+		return;
 	}
 
 	console.log('No categories found, populating instance with default categories');
 
-		fs.readFile(path.join(__dirname, '../', 'install/data/categories.json'), 'utf8', function (err, default_categories) {
+	const default_categories = JSON.parse(
-			if (err) {
+		await fs.promises.readFile(path.join(__dirname, '../', 'install/data/categories.json'), 'utf8')
-				return next(err);
+	);
+	for (const categoryData of default_categories) {
+		// eslint-disable-next-line no-await-in-loop
+		await Categories.create(categoryData);
 	}
-			default_categories = JSON.parse(default_categories);
-
-			async.eachSeries(default_categories, Categories.create, next);
-		});
-	});
 }
 
-function createMenuItems(next) {
+async function createMenuItems() {
-	var db = require('./database');
+	const db = require('./database');
 
-	db.exists('navigation:enabled', function (err, exists) {
+	const exists = await db.exists('navigation:enabled');
-		if (err || exists) {
+	if (exists) {
-			return next(err);
+		return;
 	}
-		var navigation = require('./navigation/admin');
+	const navigation = require('./navigation/admin');
-		var data = require('../install/data/navigation.json');
+	const data = require('../install/data/navigation.json');
-
+	await navigation.save(data);
-		navigation.save(data, next);
-	});
 }
 
-function createWelcomePost(next) {
+async function createWelcomePost() {
-	var db = require('./database');
+	const db = require('./database');
-	var Topics = require('./topics');
+	const Topics = require('./topics');
-
-	async.parallel([
-		function (next) {
-			fs.readFile(path.join(__dirname, '../', 'install/data/welcome.md'), 'utf8', next);
-		},
-		function (next) {
-			db.getObjectField('global', 'topicCount', next);
-		},
-	], function (err, results) {
-		if (err) {
-			return next(err);
-		}
 
-		var content = results[0];
+	const [content, numTopics] = await Promise.all([
-		var numTopics = results[1];
+		fs.promises.readFile(path.join(__dirname, '../', 'install/data/welcome.md'), 'utf8'),
+		db.getObjectField('global', 'topicCount'),
+	]);
 
 	if (!parseInt(numTopics, 10)) {
 		console.log('Creating welcome post!');
-			Topics.post({
+		await Topics.post({
 			uid: 1,
 			cid: 2,
 			title: 'Welcome to your NodeBB!',
 			content: content,
-			}, next);
-		} else {
-			next();
-		}
 		});
 	}
+}
 
-function enableDefaultPlugins(next) {
+async function enableDefaultPlugins() {
 	console.log('Enabling default plugins');
 
-	var defaultEnabled = [
+	let defaultEnabled = [
 		'nodebb-plugin-composer-default',
 		'nodebb-plugin-markdown',
 		'nodebb-plugin-mentions',
@@ -511,7 +424,7 @@ function enableDefaultPlugins(next) {
 		'nodebb-plugin-emoji',
 		'nodebb-plugin-emoji-android',
 	];
-	var customDefaults = nconf.get('defaultplugins') || nconf.get('defaultPlugins');
+	let customDefaults = nconf.get('defaultplugins') || nconf.get('defaultPlugins');
 
 	winston.info('[install/defaultPlugins] customDefaults', customDefaults);
 
@@ -529,95 +442,75 @@ function enableDefaultPlugins(next) {
 
 	winston.info('[install/enableDefaultPlugins] activating default plugins', defaultEnabled);
 
-	var db = require('./database');
+	const db = require('./database');
-	var order = defaultEnabled.map((plugin, index) => index);
+	const order = defaultEnabled.map((plugin, index) => index);
-	db.sortedSetAdd('plugins:active', order, defaultEnabled, next);
+	await db.sortedSetAdd('plugins:active', order, defaultEnabled);
 }
 
-function setCopyrightWidget(next) {
+async function setCopyrightWidget() {
-	var db = require('./database');
+	const db = require('./database');
-	async.parallel({
+	const [footerJSON, footer] = await Promise.all([
-		footerJSON: function (next) {
+		fs.promises.readFile(path.join(__dirname, '../', 'install/data/footer.json'), 'utf8'),
-			fs.readFile(path.join(__dirname, '../', 'install/data/footer.json'), 'utf8', next);
+		db.getObjectField('widgets:global', 'footer'),
-		},
+	]);
-		footer: function (next) {
-			db.getObjectField('widgets:global', 'footer', next);
-		},
-	}, function (err, results) {
-		if (err) {
-			return next(err);
-		}
 
-		if (!results.footer && results.footerJSON) {
+	if (!footer && footerJSON) {
-			db.setObjectField('widgets:global', 'footer', results.footerJSON, next);
+		await db.setObjectField('widgets:global', 'footer', footerJSON);
-		} else {
-			next();
 	}
-	});
 }
 
-install.setup = function (callback) {
+async function checkUpgrade() {
-	async.series([
+	const upgrade = require('./upgrade');
-		checkSetupFlag,
+	try {
-		checkCIFlag,
+		await upgrade.check();
-		setupConfig,
+	} catch (err) {
-		setupDefaultConfigs,
+		if (err.message === 'schema-out-of-date') {
-		enableDefaultTheme,
+			await upgrade.run();
-		createCategories,
+			return;
-		createAdministrator,
-		createGlobalModeratorsGroup,
-		giveGlobalPrivileges,
-		createMenuItems,
-		createWelcomePost,
-		enableDefaultPlugins,
-		setCopyrightWidget,
-		function (next) {
-			var upgrade = require('./upgrade');
-			upgrade.check(function (err) {
-				if (err && err.message === 'schema-out-of-date') {
-					upgrade.run(next);
-				} else if (err) {
-					return next(err);
-				} else {
-					next();
 		}
-			});
+		throw err;
-		},
+	}
-	], function (err, results) {
+}
+
+install.setup = async function () {
+	try {
+		checkSetupFlag();
+		checkCIFlag();
+		await setupConfig();
+		await setupDefaultConfigs();
+		await enableDefaultTheme();
+		await createCategories();
+		const adminInfo = await createAdministrator();
+		await createGlobalModeratorsGroup();
+		await giveGlobalPrivileges();
+		await createMenuItems();
+		await createWelcomePost();
+		await enableDefaultPlugins();
+		await setCopyrightWidget();
+		await checkUpgrade();
+
+		const data = {
+			...adminInfo,
+		};
+		return data;
+	} catch (err) {
 		if (err) {
 			winston.warn('NodeBB Setup Aborted.\n ' + err.stack);
 			process.exit(1);
-		} else {
-			var data = {};
-			if (results[6]) {
-				data.username = results[6].username;
-				data.password = results[6].password;
 		}
-
-			callback(null, data);
 	}
-	});
 };
 
-install.save = function (server_conf, callback) {
+install.save = async function (server_conf) {
-	var serverConfigPath = path.join(__dirname, '../config.json');
+	let serverConfigPath = path.join(__dirname, '../config.json');
 
 	if (nconf.get('config')) {
 		serverConfigPath = path.resolve(__dirname, '../', nconf.get('config'));
 	}
 
-	fs.writeFile(serverConfigPath, JSON.stringify(server_conf, null, 4), function (err) {
+	await fs.promises.writeFile(serverConfigPath, JSON.stringify(server_conf, null, 4));
-		if (err) {
-			winston.error('Error saving server configuration!', err.stack);
-			return callback(err);
-		}
-
 	console.log('Configuration Saved OK');
-
 	nconf.file({
 		file: serverConfigPath,
 	});
-
-		callback();
-	});
 };