mirror of
https://github.com/Ride-The-Lightning/RTL
synced 2024-11-03 23:15:24 +00:00
275 lines
9.5 KiB
JavaScript
275 lines
9.5 KiB
JavaScript
var fs = require('fs');
|
|
var crypto = require('crypto');
|
|
var clArgs = require('optimist').argv;
|
|
var ini = require('ini');
|
|
var common = require('./common');
|
|
var path = require('path');
|
|
var upperCase = require('upper-case');
|
|
var logger = require('./controllers/logger');
|
|
var connect = {};
|
|
|
|
const setDefaultConfig = () => {
|
|
var macaroonPath = '';
|
|
var lndConfigPath = '';
|
|
var bitcoindConfigPath = '';
|
|
return {
|
|
Authentication: {
|
|
macaroonPath: macaroonPath,
|
|
nodeAuthType: 'DEFAULT',
|
|
lndConfigPath: lndConfigPath,
|
|
rtlPass: ''
|
|
},
|
|
Settings: {
|
|
flgSidenavOpened: true,
|
|
flgSidenavPinned: true,
|
|
menu: 'Vertical',
|
|
menuType: 'Regular',
|
|
theme: 'dark-blue',
|
|
satsToBTC: false,
|
|
lndServerUrl: 'https://localhost:8080/v1',
|
|
bitcoindConfigPath: bitcoindConfigPath,
|
|
enableLogging: false,
|
|
port: 3000
|
|
},
|
|
SSO: {
|
|
rtlSSO: 0,
|
|
rtlCookiePath: '',
|
|
logoutRedirectLink: '/login'
|
|
}
|
|
};
|
|
}
|
|
|
|
const normalizePort = val => {
|
|
var port = parseInt(val, 10);
|
|
if (isNaN(port)) {
|
|
return val;
|
|
}
|
|
if (port >= 0) {
|
|
return port;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
const setMacaroonPath = (clArgs, config) => {
|
|
if(undefined !== clArgs.lndir) {
|
|
common.macaroon_path = clArgs.lndir;
|
|
} else if (undefined !== process.env.MACAROON_PATH) {
|
|
common.macaroon_path = process.env.MACAROON_PATH;
|
|
} else {
|
|
if(undefined !== config.Authentication.macroonPath && config.Authentication.macroonPath !== '') {
|
|
common.macaroon_path = config.Authentication.macroonPath;
|
|
} else if(undefined !== config.Authentication.macaroonPath && config.Authentication.macaroonPath !== '') {
|
|
common.macaroon_path = config.Authentication.macaroonPath;
|
|
}
|
|
}
|
|
}
|
|
|
|
const validateConfigFile = (config) => {
|
|
if(common.macaroon_path === '' || undefined === common.macaroon_path) {
|
|
errMsg = 'Please set macaroon path through environment or RTL.conf!';
|
|
}
|
|
|
|
if(undefined !== process.env.LND_SERVER_URL) {
|
|
common.lnd_server_url = process.env.LND_SERVER_URL;
|
|
} else {
|
|
if((config.Authentication.lndServerUrl === '' || undefined === config.Authentication.lndServerUrl) && (config.Settings.lndServerUrl === '' || undefined === config.Settings.lndServerUrl)) {
|
|
errMsg = errMsg + '\nPlease set LND Server URL through environment or RTL.conf!';
|
|
} else {
|
|
if (config.Settings.lndServerUrl !== '' && undefined !== config.Settings.lndServerUrl) {
|
|
common.lnd_server_url = config.Settings.lndServerUrl;
|
|
} else if (config.Authentication.lndServerUrl !== '' && undefined !== config.Authentication.lndServerUrl) {
|
|
common.lnd_server_url = config.Authentication.lndServerUrl;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(undefined !== process.env.NODE_AUTH_TYPE) {
|
|
common.node_auth_type = process.env.NODE_AUTH_TYPE;
|
|
} else {
|
|
if(config.Authentication.nodeAuthType === '' || undefined === config.Authentication.nodeAuthType) {
|
|
errMsg = errMsg + '\nPlease set Node Auth Type through environment/RTL.conf!';
|
|
} else {
|
|
common.node_auth_type = config.Authentication.nodeAuthType;
|
|
}
|
|
}
|
|
|
|
if(undefined !== process.env.LND_CONFIG_PATH) {
|
|
common.lnd_config_path = process.env.LND_CONFIG_PATH;
|
|
} else {
|
|
if(config.Authentication.lndConfigPath !== '' && undefined !== config.Authentication.lndConfigPath) {
|
|
common.lnd_config_path = config.Authentication.lndConfigPath;
|
|
} else {
|
|
if(upperCase(common.node_auth_type) === 'DEFAULT') {
|
|
errMsg = errMsg + '\nDefault Node Authentication can be set with LND Config Path only. Please set LND Config Path through environment or RTL.conf!';
|
|
}
|
|
}
|
|
}
|
|
|
|
if(undefined !== process.env.BITCOIND_CONFIG_PATH) {
|
|
common.bitcoind_config_path = process.env.BITCOIND_CONFIG_PATH;
|
|
} else {
|
|
if(config.Settings.bitcoindConfigPath !== '' || undefined !== config.Settings.bitcoindConfigPath) {
|
|
common.bitcoind_config_path = config.Settings.bitcoindConfigPath;
|
|
} else if(config.Authentication.bitcoindConfigPath !== '' || undefined !== config.Authentication.bitcoindConfigPath) {
|
|
common.bitcoind_config_path = config.Authentication.bitcoindConfigPath;
|
|
}
|
|
}
|
|
|
|
if (undefined !== process.env.RTL_PASS) {
|
|
common.rtl_pass = process.env.RTL_PASS;
|
|
} else if (config.Authentication.rtlPass !== '' || undefined !== config.Authentication.rtlPass) {
|
|
common.rtl_pass = config.Authentication.rtlPass;
|
|
|
|
}
|
|
|
|
if (upperCase(common.node_auth_type) === 'CUSTOM' && (common.rtl_pass === '' || undefined === common.rtl_pass)) {
|
|
errMsg = errMsg + '\nCustom Node Authentication can be set with RTL password only. Please set RTL Password through environment/RTL.conf';
|
|
}
|
|
|
|
if (undefined !== process.env.ENABLE_LOGGING) {
|
|
common.enable_logging = process.env.ENABLE_LOGGING;
|
|
} else if (undefined !== config.Settings.enableLogging) {
|
|
common.enable_logging = config.Settings.enableLogging;
|
|
} else if (undefined !== config.Authentication.enableLogging) {
|
|
common.enable_logging = config.Authentication.enableLogging;
|
|
}
|
|
if (common.enable_logging) {
|
|
common.log_file = common.rtl_conf_file_path + '/logs/RTL.log';
|
|
let exists = fs.existsSync(common.log_file);
|
|
if (exists) {
|
|
fs.writeFile(common.log_file, '', () => { });
|
|
} else if (!exists && config.Authentication.enableLogging) {
|
|
try {
|
|
var dirname = path.dirname(common.log_file);
|
|
createDirectory(dirname);
|
|
var createStream = fs.createWriteStream(common.log_file);
|
|
createStream.end();
|
|
}
|
|
catch (err) {
|
|
console.error('Something went wrong: \n' + err);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (undefined !== process.env.PORT) {
|
|
common.port = normalizePort(process.env.PORT);
|
|
} else if (undefined !== config.Settings.port) {
|
|
common.port = normalizePort(config.Settings.port);
|
|
}
|
|
|
|
setSSOParams(config);
|
|
if (errMsg !== '') {
|
|
throw new Error(errMsg);
|
|
}
|
|
}
|
|
|
|
const setSSOParams = (config) => {
|
|
if (undefined !== process.env.RTL_SSO) {
|
|
common.rtl_sso = process.env.RTL_SSO;
|
|
} else if (undefined !== config.SSO && undefined !== config.SSO.rtlSSO) {
|
|
common.rtl_sso = config.SSO.rtlSSO;
|
|
}
|
|
|
|
if (+common.rtl_sso) {
|
|
if (undefined !== process.env.LOGOUT_REDIRECT_LINK) {
|
|
common.logout_redirect_link = process.env.LOGOUT_REDIRECT_LINK;
|
|
} else if (undefined !== config.SSO && undefined !== config.SSO.logoutRedirectLink) {
|
|
common.logout_redirect_link = config.SSO.logoutRedirectLink;
|
|
}
|
|
|
|
|
|
if (undefined !== process.env.RTL_COOKIE_PATH) {
|
|
common.rtl_cookie_path = process.env.RTL_COOKIE_PATH;
|
|
} else if (undefined !== config.SSO && undefined !== config.SSO.rtlCookiePath) {
|
|
common.rtl_cookie_path = config.SSO.rtlCookiePath;
|
|
} else {
|
|
common.rtl_cookie_path = common.rtl_conf_file_path + '/cookies/auth.cookie';
|
|
}
|
|
readCookie(common.rtl_cookie_path);
|
|
}
|
|
};
|
|
|
|
const createDirectory = (dirname) => {
|
|
try {
|
|
fs.mkdirSync(dirname);
|
|
} catch (err) {
|
|
if (err.code === 'EEXIST') {
|
|
return dirname;
|
|
}
|
|
if (err.code === 'ENOENT') {
|
|
throw new Error(`EACCES: permission denied, mkdir '${dirname}'`);
|
|
}
|
|
}
|
|
}
|
|
|
|
const readCookie = (cookieFile) => {
|
|
let exists = fs.existsSync(cookieFile);
|
|
if (exists) {
|
|
common.cookie = fs.readFileSync(cookieFile, 'utf-8');
|
|
} else {
|
|
try {
|
|
var dirname = path.dirname(cookieFile);
|
|
createDirectory(dirname);
|
|
fs.writeFileSync(cookieFile, crypto.randomBytes(64).toString('hex'));
|
|
common.cookie = fs.readFileSync(cookieFile, 'utf-8');
|
|
}
|
|
catch(err) {
|
|
console.error('Something went wrong: \n' + err);
|
|
throw new Error(err);
|
|
}
|
|
}
|
|
}
|
|
|
|
String.random = function (length) {
|
|
let radom13chars = function () {
|
|
return Math.random().toString(16).substring(2, 15).toUpperCase();
|
|
}
|
|
let loops = Math.ceil(length / 13);
|
|
return new Array(loops).fill(radom13chars).reduce((string, func) => {
|
|
return string + func();
|
|
}, '').substring(-length);
|
|
}
|
|
|
|
const logEnvVariables = () => {
|
|
if (!common.enable_logging) {
|
|
return;
|
|
}
|
|
logger.info('\r\nConfig Setup Variable PORT: ' + common.port);
|
|
logger.info('\r\nConfig Setup Variable LND_SERVER_URL: ' + common.lnd_server_url);
|
|
logger.info('\r\nConfig Setup Variable MACAROON_PATH: ' + common.macaroon_path);
|
|
logger.info('\r\nConfig Setup Variable NODE_AUTH_TYPE: ' + common.node_auth_type);
|
|
logger.info('\r\nConfig Setup Variable LND_CONFIG_PATH: ' + common.lnd_config_path);
|
|
logger.info('\r\nConfig Setup Variable RTL_CONFIG_PATH: ' + common.rtl_conf_file_path);
|
|
logger.info('\r\nConfig Setup Variable BITCOIND_CONFIG_PATH: ' + common.bitcoind_config_path);
|
|
logger.info('\r\nConfig Setup Variable RTL_SSO: ' + common.rtl_sso);
|
|
logger.info('\r\nConfig Setup Variable RTL_COOKIE_PATH: ' + common.rtl_cookie_path);
|
|
logger.info('\r\nConfig Setup Variable LOGOUT_REDIRECT_LINK: ' + common.logout_redirect_link);
|
|
}
|
|
|
|
var errMsg = '';
|
|
connect.configFileExists = () => {
|
|
common.rtl_conf_file_path = (undefined !== process.env.RTL_CONFIG_PATH) ? process.env.RTL_CONFIG_PATH.substring(0, process.env.RTL_CONFIG_PATH.length - 9) : path.normalize(__dirname);
|
|
RTLConfFile = common.rtl_conf_file_path + '/RTL.conf';
|
|
let exists = fs.existsSync(RTLConfFile);
|
|
if (exists) {
|
|
var config = ini.parse(fs.readFileSync(RTLConfFile, 'utf-8'));
|
|
setMacaroonPath(clArgs, config)
|
|
validateConfigFile(config);
|
|
logEnvVariables();
|
|
} else {
|
|
try {
|
|
fs.writeFileSync(RTLConfFile, ini.stringify(setDefaultConfig()));
|
|
var config = ini.parse(fs.readFileSync(RTLConfFile, 'utf-8'));
|
|
setMacaroonPath(clArgs, config)
|
|
validateConfigFile(config);
|
|
logEnvVariables();
|
|
}
|
|
catch(err) {
|
|
console.error('Something went wrong: \n' + err);
|
|
throw new Error(err);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = connect.configFileExists();
|