AccountManager/backend/index.js

'use strict';

const util = require("util");

process.env.NODE_CONFIG_DIR = `${__dirname}/config`;

const config = require("config");

process.on('uncaughtException', err => {
	if (err.code === 'ECONNREFUSED' || err.code === 'UNCERTAIN_STATE') return;
	console.log(`UNCAUGHT EXCEPTION: ${err.stack}`);
});

const fancyConsole = config.get("fancyConsole");

class ModuleManager {
	constructor() {
		this.modules = {};
		this.modulesInitialized = 0;
		this.totalModules = 0;
		this.modulesLeft = [];
		this.i = 0;
		this.lockdown = false;
		this.fancyConsole = fancyConsole;
	}

	addModule(moduleName) {
		console.log("add module", moduleName);
		const moduleClass = new require(`./logic/${moduleName}`);
		this.modules[moduleName] = new moduleClass(moduleName, this);
		this.totalModules++;
		this.modulesLeft.push(moduleName);
	}

	initialize() {
		if (!this.modules["logger"]) return console.error("There is no logger module");
		this.logger = this.modules["logger"];
		if (this.fancyConsole) {
			this.replaceConsoleWithLogger();
			this.logger.reservedLines = Object.keys(this.modules).length + 5;
		}
		
		for (let moduleName in this.modules) {
			let module = this.modules[moduleName];
			if (this.lockdown) break;

			module._onInitialize().then(() => {
				this.moduleInitialized(moduleName);
			});

			let dependenciesInitializedPromises = [];
			
			module.dependsOn.forEach(dependencyName => {
				let dependency = this.modules[dependencyName];
				dependenciesInitializedPromises.push(dependency._onInitialize());
			});

			module.lastTime = Date.now();

			Promise.all(dependenciesInitializedPromises).then((res, res2) => {
				if (this.lockdown) return;
				this.logger.info("MODULE_MANAGER", `${moduleName} dependencies have been completed`);
				module._initialize();
			});
		}
	}

	async printStatus() {
		try { await Promise.race([this.logger._onInitialize(), this.logger._isInitialized()]); } catch { return; }
		if (!this.fancyConsole) return;
		
		let colors = this.logger.colors;

		const rows = process.stdout.rows;

		process.stdout.cursorTo(0, rows - this.logger.reservedLines);
		process.stdout.clearScreenDown();

		process.stdout.cursorTo(0, (rows - this.logger.reservedLines) + 2);

		process.stdout.write(`${colors.FgYellow}Modules${colors.FgWhite}:\n`);

		for (let moduleName in this.modules) {
			let module = this.modules[moduleName];
			let tabsAmount = Math.max(0, Math.ceil(2 - (moduleName.length / 8)));

			let tabs = Array(tabsAmount).fill(`\t`).join("");

			let timing = module.timeDifferences.map((timeDifference) => {
				return `${colors.FgMagenta}${timeDifference}${colors.FgCyan}ms${colors.FgWhite}`;
			}).join(", ");

			let stateColor;
			if (module.state === "NOT_INITIALIZED") stateColor = colors.FgWhite;
			else if (module.state === "INITIALIZED") stateColor = colors.FgGreen;
			else if (module.state === "LOCKDOWN" && !module.failed) stateColor = colors.FgRed;
			else if (module.state === "LOCKDOWN" && module.failed) stateColor = colors.FgMagenta;
			else stateColor = colors.FgYellow;
			
			process.stdout.write(`${moduleName}${tabs}${stateColor}${module.state}\t${colors.FgYellow}Stage: ${colors.FgRed}${module.stage}${colors.FgWhite}. ${colors.FgYellow}Timing${colors.FgWhite}: [${timing}]${colors.FgWhite}${colors.FgWhite}. ${colors.FgYellow}Total time${colors.FgWhite}: ${colors.FgRed}${module.totalTimeInitialize}${colors.FgCyan}ms${colors.Reset}\n`);
		}
	}

	moduleInitialized(moduleName) {
		this.modulesInitialized++;
		this.modulesLeft.splice(this.modulesLeft.indexOf(moduleName), 1);

		this.logger.info("MODULE_MANAGER", `Initialized: ${this.modulesInitialized}/${this.totalModules}.`);

		if (this.modulesLeft.length === 0) this.allModulesInitialized();
	}

	allModulesInitialized() {
		this.logger.success("MODULE_MANAGER", "All modules have started!");
	}

	aModuleFailed(failedModule) {
		this.logger.error("MODULE_MANAGER", `A module has failed, locking down. Module: ${failedModule.name}`);

		this._lockdown();
	}

	replaceConsoleWithLogger() {
		this.oldConsole = {
			log: console.log,
			debug: console.debug,
			info: console.info,
			warn: console.warn,
			error: console.error
		};
		console.log = (...args) => this.logger.debug(args.map(arg => util.format(arg)));
		console.debug = (...args) => this.logger.debug(args.map(arg => util.format(arg)));
		console.info = (...args) => this.logger.debug(args.map(arg => util.format(arg)));
		console.warn = (...args) => this.logger.debug(args.map(arg => util.format(arg)));
		console.error = (...args) => this.logger.error("CONSOLE", args.map(arg => util.format(arg)));
	}

	replaceLoggerWithConsole() {
		console.log = this.oldConsole.log;
		console.debug = this.oldConsole.debug;
		console.info = this.oldConsole.info;
		console.warn = this.oldConsole.warn;
		console.error = this.oldConsole.error;
	}

	_lockdown() {
		this.lockdown = true;
		
		for (let moduleName in this.modules) {
			let module = this.modules[moduleName];
			if (module.lockdownImmune) continue;
			module._lockdown();
		}
	}
}

const moduleManager = new ModuleManager();

module.exports = moduleManager;

moduleManager.addModule("logger");
moduleManager.addModule("io");
moduleManager.addModule("util");
moduleManager.addModule("mongo");
moduleManager.addModule("account");
moduleManager.addModule("accountSchema");
moduleManager.addModule("convertSchema");

moduleManager.initialize();

process.stdin.on("data", function (data) {
    if(data.toString() === "lockdown\r\n"){
        console.log("Locking down.");
       	moduleManager._lockdown();
    }
});


if (fancyConsole) {
	const rows = process.stdout.rows;

	for(let i = 0; i < rows; i++) {
		process.stdout.write("\n");
	}
}