mirror of
https://github.com/MisskeyIO/misskey
synced 2024-12-23 02:58:18 +09:00
f68b646878
* Fix #8387 * update changelog Co-authored-by: Johann150 <johann.galle@protonmail.com> Co-authored-by: syuilo <Syuilotan@yahoo.co.jp>
195 lines
5.8 KiB
TypeScript
195 lines
5.8 KiB
TypeScript
import * as fs from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { dirname } from 'node:path';
|
|
import * as os from 'node:os';
|
|
import cluster from 'node:cluster';
|
|
import chalk from 'chalk';
|
|
import chalkTemplate from 'chalk-template';
|
|
import * as portscanner from 'portscanner';
|
|
import semver from 'semver';
|
|
import { getConnection } from 'typeorm';
|
|
|
|
import Logger from '@/services/logger.js';
|
|
import loadConfig from '@/config/load.js';
|
|
import { Config } from '@/config/types.js';
|
|
import { lessThan } from '@/prelude/array.js';
|
|
import { envOption } from '../env.js';
|
|
import { showMachineInfo } from '@/misc/show-machine-info.js';
|
|
import { initDb } from '../db/postgre.js';
|
|
|
|
const _filename = fileURLToPath(import.meta.url);
|
|
const _dirname = dirname(_filename);
|
|
|
|
const meta = JSON.parse(fs.readFileSync(`${_dirname}/../../../../built/meta.json`, 'utf-8'));
|
|
|
|
const logger = new Logger('core', 'cyan');
|
|
const bootLogger = logger.createSubLogger('boot', 'magenta', false);
|
|
|
|
const themeColor = chalk.hex('#86b300');
|
|
|
|
function greet() {
|
|
if (!envOption.quiet) {
|
|
//#region Misskey logo
|
|
const v = `v${meta.version}`;
|
|
console.log(themeColor(' _____ _ _ '));
|
|
console.log(themeColor(' | |_|___ ___| |_ ___ _ _ '));
|
|
console.log(themeColor(' | | | | |_ -|_ -| \'_| -_| | |'));
|
|
console.log(themeColor(' |_|_|_|_|___|___|_,_|___|_ |'));
|
|
console.log(' ' + chalk.gray(v) + themeColor(' |___|\n'.substr(v.length)));
|
|
//#endregion
|
|
|
|
console.log(' Misskey is an open-source decentralized microblogging platform.');
|
|
console.log(chalk.rgb(255, 136, 0)(' If you like Misskey, please donate to support development. https://www.patreon.com/syuilo'));
|
|
|
|
console.log('');
|
|
console.log(chalkTemplate`--- ${os.hostname()} {gray (PID: ${process.pid.toString()})} ---`);
|
|
}
|
|
|
|
bootLogger.info('Welcome to Misskey!');
|
|
bootLogger.info(`Misskey v${meta.version}`, null, true);
|
|
}
|
|
|
|
function isRoot() {
|
|
// maybe process.getuid will be undefined under not POSIX environment (e.g. Windows)
|
|
return process.getuid != null && process.getuid() === 0;
|
|
}
|
|
|
|
/**
|
|
* Init master process
|
|
*/
|
|
export async function masterMain() {
|
|
let config!: Config;
|
|
|
|
// initialize app
|
|
try {
|
|
greet();
|
|
showEnvironment();
|
|
await showMachineInfo(bootLogger);
|
|
showNodejsVersion();
|
|
config = loadConfigBoot();
|
|
await connectDb();
|
|
await validatePort(config);
|
|
} catch (e) {
|
|
bootLogger.error('Fatal error occurred during initialization', null, true);
|
|
process.exit(1);
|
|
}
|
|
|
|
bootLogger.succ('Misskey initialized');
|
|
|
|
if (!envOption.disableClustering) {
|
|
await spawnWorkers(config.clusterLimit);
|
|
}
|
|
|
|
bootLogger.succ(`Now listening on port ${config.port} on ${config.url}`, null, true);
|
|
|
|
if (!envOption.noDaemons) {
|
|
import('../daemons/server-stats.js').then(x => x.default());
|
|
import('../daemons/queue-stats.js').then(x => x.default());
|
|
import('../daemons/janitor.js').then(x => x.default());
|
|
}
|
|
}
|
|
|
|
function showEnvironment(): void {
|
|
const env = process.env.NODE_ENV;
|
|
const logger = bootLogger.createSubLogger('env');
|
|
logger.info(typeof env === 'undefined' ? 'NODE_ENV is not set' : `NODE_ENV: ${env}`);
|
|
|
|
if (env !== 'production') {
|
|
logger.warn('The environment is not in production mode.');
|
|
logger.warn('DO NOT USE FOR PRODUCTION PURPOSE!', null, true);
|
|
}
|
|
|
|
logger.info(`You ${isRoot() ? '' : 'do not '}have root privileges`);
|
|
}
|
|
|
|
function showNodejsVersion(): void {
|
|
const nodejsLogger = bootLogger.createSubLogger('nodejs');
|
|
|
|
nodejsLogger.info(`Version ${process.version} detected.`);
|
|
|
|
const minVersion = fs.readFileSync(`${_dirname}/../../../../.node-version`, 'utf-8').trim();
|
|
if (semver.lt(process.version, minVersion)) {
|
|
nodejsLogger.error(`At least Node.js ${minVersion} required!`);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
function loadConfigBoot(): Config {
|
|
const configLogger = bootLogger.createSubLogger('config');
|
|
let config;
|
|
|
|
try {
|
|
config = loadConfig();
|
|
} catch (exception) {
|
|
if (typeof exception === 'string') {
|
|
configLogger.error(exception);
|
|
process.exit(1);
|
|
}
|
|
if (exception.code === 'ENOENT') {
|
|
configLogger.error('Configuration file not found', null, true);
|
|
process.exit(1);
|
|
}
|
|
throw exception;
|
|
}
|
|
|
|
configLogger.succ('Loaded');
|
|
|
|
return config;
|
|
}
|
|
|
|
async function connectDb(): Promise<void> {
|
|
const dbLogger = bootLogger.createSubLogger('db');
|
|
|
|
// Try to connect to DB
|
|
try {
|
|
dbLogger.info('Connecting...');
|
|
await initDb();
|
|
const v = await getConnection().query('SHOW server_version').then(x => x[0].server_version);
|
|
dbLogger.succ(`Connected: v${v}`);
|
|
} catch (e) {
|
|
dbLogger.error('Cannot connect', null, true);
|
|
dbLogger.error(e);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
async function validatePort(config: Config): Promise<void> {
|
|
const isWellKnownPort = (port: number) => port < 1024;
|
|
|
|
async function isPortAvailable(port: number): Promise<boolean> {
|
|
return await portscanner.checkPortStatus(port, '127.0.0.1') === 'closed';
|
|
}
|
|
|
|
if (config.port == null || Number.isNaN(config.port)) {
|
|
bootLogger.error('The port is not configured. Please configure port.', null, true);
|
|
process.exit(1);
|
|
}
|
|
|
|
if (process.platform === 'linux' && isWellKnownPort(config.port) && !isRoot()) {
|
|
bootLogger.error('You need root privileges to listen on well-known port on Linux', null, true);
|
|
process.exit(1);
|
|
}
|
|
|
|
if (!await isPortAvailable(config.port)) {
|
|
bootLogger.error(`Port ${config.port} is already in use`, null, true);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
async function spawnWorkers(limit: number = 1) {
|
|
const workers = Math.min(limit, os.cpus().length);
|
|
bootLogger.info(`Starting ${workers} worker${workers === 1 ? '' : 's'}...`);
|
|
await Promise.all([...Array(workers)].map(spawnWorker));
|
|
bootLogger.succ('All workers started');
|
|
}
|
|
|
|
function spawnWorker(): Promise<void> {
|
|
return new Promise(res => {
|
|
const worker = cluster.fork();
|
|
worker.on('message', message => {
|
|
if (message !== 'ready') return;
|
|
res();
|
|
});
|
|
});
|
|
}
|