X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Futils%2FConfiguration.ts;h=bf691fa8c1d96ffcb2da9ed44fc6f62ca977e098;hb=d7b57c65075000d84a930fad15d98217c4695337;hp=491c377e9372cf7543406c67e49cda1d6f454005;hpb=662710925f570077ed9af59519912546f9bb8eaa;p=e-mobility-charging-stations-simulator.git diff --git a/src/utils/Configuration.ts b/src/utils/Configuration.ts index 491c377e..bf691fa8 100644 --- a/src/utils/Configuration.ts +++ b/src/utils/Configuration.ts @@ -1,355 +1,548 @@ -import ConfigurationData, { - ServerOptions, - StationTemplateUrl, - StorageConfiguration, - SupervisionUrlDistribution, - UIServerConfiguration, -} from '../types/ConfigurationData'; +import { type FSWatcher, readFileSync, watch } from 'node:fs'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; -import Constants from './Constants'; -import { EmptyObject } from '../types/EmptyObject'; -import { FileType } from '../types/FileType'; -import { HandleErrorParams } from '../types/Error'; -import { StorageType } from '../types/Storage'; -import type { WorkerChoiceStrategy } from 'poolifier'; -import WorkerConstants from '../worker/WorkerConstants'; -import { WorkerProcessType } from '../types/Worker'; import chalk from 'chalk'; -import fs from 'fs'; -import path from 'path'; - -export default class Configuration { - private static configurationFile = path.join( - path.resolve(__dirname, '../'), +import merge from 'just-merge'; + +import { Constants } from './Constants'; +import { + hasOwnProp, + isCFEnvironment, + isNotEmptyString, + isUndefined, + logPrefix, + once, +} from './Utils'; +import { + ApplicationProtocol, + type ConfigurationData, + ConfigurationSection, + FileType, + type LogConfiguration, + type StationTemplateUrl, + type StorageConfiguration, + StorageType, + SupervisionUrlDistribution, + type UIServerConfiguration, + type WorkerConfiguration, +} from '../types'; +import { + DEFAULT_ELEMENT_START_DELAY, + DEFAULT_POOL_MAX_SIZE, + DEFAULT_POOL_MIN_SIZE, + DEFAULT_WORKER_START_DELAY, + WorkerProcessType, +} from '../worker'; + +type ConfigurationSectionType = + | LogConfiguration + | StorageConfiguration + | WorkerConfiguration + | UIServerConfiguration; + +export class Configuration { + private static configurationFile = join( + dirname(fileURLToPath(import.meta.url)), 'assets', - 'config.json' + 'config.json', ); - private static configurationFileWatcher: fs.FSWatcher; - private static configuration: ConfigurationData | null = null; - private static configurationChangeCallback: () => Promise; + private static configurationData?: ConfigurationData; + private static configurationFileWatcher?: FSWatcher; + private static configurationSectionCache = new Map< + ConfigurationSection, + ConfigurationSectionType + >([ + [ConfigurationSection.log, Configuration.buildLogSection()], + [ConfigurationSection.performanceStorage, Configuration.buildPerformanceStorageSection()], + [ConfigurationSection.worker, Configuration.buildWorkerSection()], + [ConfigurationSection.uiServer, Configuration.buildUIServerSection()], + ]); + + private static configurationChangeCallback?: () => Promise; + + private constructor() { + // This is intentional + } - static setConfigurationChangeCallback(cb: () => Promise): void { + public static setConfigurationChangeCallback(cb: () => Promise): void { Configuration.configurationChangeCallback = cb; } - static getLogStatisticsInterval(): number { - Configuration.warnDeprecatedConfigurationKey( - 'statisticsDisplayInterval', - null, - "Use 'logStatisticsInterval' instead" - ); - // Read conf - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logStatisticsInterval') - ? Configuration.getConfig().logStatisticsInterval - : Constants.DEFAULT_LOG_STATISTICS_INTERVAL; + public static getConfigurationSection( + sectionName: ConfigurationSection, + ): T { + if (!Configuration.isConfigurationSectionCached(sectionName)) { + Configuration.cacheConfigurationSection(sectionName); + } + return Configuration.configurationSectionCache.get(sectionName) as T; } - static getUIServer(): UIServerConfiguration { - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'uiWebSocketServer')) { - console.error( - chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration section 'uiWebSocketServer' usage. Use 'uiServer' instead}` - ); + public static getStationTemplateUrls(): StationTemplateUrl[] | undefined { + const checkDeprecatedConfigurationKeysOnce = once( + Configuration.checkDeprecatedConfigurationKeys.bind(Configuration), + Configuration, + ); + checkDeprecatedConfigurationKeysOnce(); + return Configuration.getConfigurationData()?.stationTemplateUrls; + } + + public static getSupervisionUrls(): string | string[] | undefined { + if ( + !isUndefined( + Configuration.getConfigurationData()?.['supervisionURLs' as keyof ConfigurationData], + ) + ) { + Configuration.getConfigurationData()!.supervisionUrls = Configuration.getConfigurationData()![ + 'supervisionURLs' as keyof ConfigurationData + ] as string | string[]; } - let options: ServerOptions = { - host: Constants.DEFAULT_UI_WEBSOCKET_SERVER_HOST, - port: Constants.DEFAULT_UI_WEBSOCKET_SERVER_PORT, - }; + return Configuration.getConfigurationData()?.supervisionUrls; + } + + public static getSupervisionUrlDistribution(): SupervisionUrlDistribution | undefined { + return hasOwnProp(Configuration.getConfigurationData(), 'supervisionUrlDistribution') + ? Configuration.getConfigurationData()?.supervisionUrlDistribution + : SupervisionUrlDistribution.ROUND_ROBIN; + } + + public static workerPoolInUse(): boolean { + return [WorkerProcessType.dynamicPool, WorkerProcessType.staticPool].includes( + Configuration.getConfigurationSection(ConfigurationSection.worker) + .processType!, + ); + } + + public static workerDynamicPoolInUse(): boolean { + return ( + Configuration.getConfigurationSection(ConfigurationSection.worker) + .processType === WorkerProcessType.dynamicPool + ); + } + + private static logPrefix = (): string => { + return logPrefix(' Simulator configuration |'); + }; + + private static isConfigurationSectionCached(sectionName: ConfigurationSection): boolean { + return Configuration.configurationSectionCache.has(sectionName); + } + + private static cacheConfigurationSection(sectionName: ConfigurationSection): void { + switch (sectionName) { + case ConfigurationSection.log: + Configuration.configurationSectionCache.set(sectionName, Configuration.buildLogSection()); + break; + case ConfigurationSection.performanceStorage: + Configuration.configurationSectionCache.set( + sectionName, + Configuration.buildPerformanceStorageSection(), + ); + break; + case ConfigurationSection.worker: + Configuration.configurationSectionCache.set( + sectionName, + Configuration.buildWorkerSection(), + ); + break; + case ConfigurationSection.uiServer: + Configuration.configurationSectionCache.set( + sectionName, + Configuration.buildUIServerSection(), + ); + break; + default: + // eslint-disable-next-line @typescript-eslint/restrict-template-expressions + throw new Error(`Unknown configuration section '${sectionName}'`); + } + } + + private static buildUIServerSection(): UIServerConfiguration { let uiServerConfiguration: UIServerConfiguration = { - enabled: true, - options, + enabled: false, + type: ApplicationProtocol.WS, + options: { + host: Constants.DEFAULT_UI_SERVER_HOST, + port: Constants.DEFAULT_UI_SERVER_PORT, + }, }; - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'uiServer')) { - if (Configuration.objectHasOwnProperty(Configuration.getConfig().uiServer, 'options')) { - options = { - ...options, - ...(Configuration.objectHasOwnProperty( - Configuration.getConfig().uiServer.options, - 'host' - ) && { host: Configuration.getConfig().uiServer.options.host }), - ...(Configuration.objectHasOwnProperty( - Configuration.getConfig().uiServer.options, - 'port' - ) && { port: Configuration.getConfig().uiServer.options.port }), - }; - } - uiServerConfiguration = { - ...uiServerConfiguration, - ...(Configuration.objectHasOwnProperty(Configuration.getConfig().uiServer, 'enabled') && { - enabled: Configuration.getConfig().uiServer.enabled, - }), - options, - }; + if (hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.uiServer)) { + uiServerConfiguration = merge( + uiServerConfiguration, + Configuration.getConfigurationData()!.uiServer!, + ); + } + if (isCFEnvironment() === true) { + delete uiServerConfiguration.options?.host; + uiServerConfiguration.options!.port = parseInt(process.env.PORT!); } return uiServerConfiguration; } - static getPerformanceStorage(): StorageConfiguration { - Configuration.warnDeprecatedConfigurationKey('URI', 'performanceStorage', "Use 'uri' instead"); + private static buildPerformanceStorageSection(): StorageConfiguration { let storageConfiguration: StorageConfiguration = { enabled: false, type: StorageType.JSON_FILE, - uri: this.getDefaultPerformanceStorageUri(StorageType.JSON_FILE), + uri: Configuration.getDefaultPerformanceStorageUri(StorageType.JSON_FILE), }; - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'performanceStorage')) { + if (hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.performanceStorage)) { storageConfiguration = { ...storageConfiguration, - ...(Configuration.objectHasOwnProperty( - Configuration.getConfig().performanceStorage, - 'enabled' - ) && { enabled: Configuration.getConfig().performanceStorage.enabled }), - ...(Configuration.objectHasOwnProperty( - Configuration.getConfig().performanceStorage, - 'type' - ) && { type: Configuration.getConfig().performanceStorage.type }), - ...(Configuration.objectHasOwnProperty( - Configuration.getConfig().performanceStorage, - 'uri' - ) && { - uri: this.getDefaultPerformanceStorageUri( - Configuration.getConfig()?.performanceStorage?.type ?? StorageType.JSON_FILE - ), - }), + ...Configuration.getConfigurationData()?.performanceStorage, + ...(Configuration.getConfigurationData()?.performanceStorage?.type === + StorageType.JSON_FILE && + Configuration.getConfigurationData()?.performanceStorage?.uri && { + uri: Configuration.buildPerformanceUriFilePath( + new URL(Configuration.getConfigurationData()!.performanceStorage!.uri!).pathname, + ), + }), }; } return storageConfiguration; } - static getAutoReconnectMaxRetries(): number { + private static buildLogSection(): LogConfiguration { + const defaultLogConfiguration: LogConfiguration = { + enabled: true, + file: 'logs/combined.log', + errorFile: 'logs/error.log', + statisticsInterval: Constants.DEFAULT_LOG_STATISTICS_INTERVAL, + level: 'info', + format: 'simple', + rotate: true, + }; + const deprecatedLogConfiguration: LogConfiguration = { + ...(hasOwnProp(Configuration.getConfigurationData(), 'logEnabled') && { + enabled: Configuration.getConfigurationData()?.logEnabled, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logFile') && { + file: Configuration.getConfigurationData()?.logFile, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logErrorFile') && { + errorFile: Configuration.getConfigurationData()?.logErrorFile, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logStatisticsInterval') && { + statisticsInterval: Configuration.getConfigurationData()?.logStatisticsInterval, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logLevel') && { + level: Configuration.getConfigurationData()?.logLevel, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logConsole') && { + console: Configuration.getConfigurationData()?.logConsole, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logFormat') && { + format: Configuration.getConfigurationData()?.logFormat, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logRotate') && { + rotate: Configuration.getConfigurationData()?.logRotate, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logMaxFiles') && { + maxFiles: Configuration.getConfigurationData()?.logMaxFiles, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'logMaxSize') && { + maxSize: Configuration.getConfigurationData()?.logMaxSize, + }), + }; + const logConfiguration: LogConfiguration = { + ...defaultLogConfiguration, + ...deprecatedLogConfiguration, + ...(hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.log) && + Configuration.getConfigurationData()?.log), + }; + return logConfiguration; + } + + private static buildWorkerSection(): WorkerConfiguration { + const defaultWorkerConfiguration: WorkerConfiguration = { + processType: WorkerProcessType.workerSet, + startDelay: DEFAULT_WORKER_START_DELAY, + elementsPerWorker: 'auto', + elementStartDelay: DEFAULT_ELEMENT_START_DELAY, + poolMinSize: DEFAULT_POOL_MIN_SIZE, + poolMaxSize: DEFAULT_POOL_MAX_SIZE, + }; + const deprecatedWorkerConfiguration: WorkerConfiguration = { + ...(hasOwnProp(Configuration.getConfigurationData(), 'workerProcess') && { + processType: Configuration.getConfigurationData()?.workerProcess, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'workerStartDelay') && { + startDelay: Configuration.getConfigurationData()?.workerStartDelay, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'chargingStationsPerWorker') && { + elementsPerWorker: Configuration.getConfigurationData()?.chargingStationsPerWorker, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'elementStartDelay') && { + elementStartDelay: Configuration.getConfigurationData()?.elementStartDelay, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'workerPoolMinSize') && { + poolMinSize: Configuration.getConfigurationData()?.workerPoolMinSize, + }), + ...(hasOwnProp(Configuration.getConfigurationData(), 'workerPoolMaxSize') && { + poolMaxSize: Configuration.getConfigurationData()?.workerPoolMaxSize, + }), + }; + hasOwnProp(Configuration.getConfigurationData(), 'workerPoolStrategy') && + delete Configuration.getConfigurationData()?.workerPoolStrategy; + const workerConfiguration: WorkerConfiguration = { + ...defaultWorkerConfiguration, + ...deprecatedWorkerConfiguration, + ...(hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.worker) && + Configuration.getConfigurationData()?.worker), + }; + if (!Object.values(WorkerProcessType).includes(workerConfiguration.processType!)) { + throw new SyntaxError( + `Invalid worker process type '${workerConfiguration.processType}' defined in configuration`, + ); + } + return workerConfiguration; + } + + private static checkDeprecatedConfigurationKeys() { + // connection timeout Configuration.warnDeprecatedConfigurationKey( 'autoReconnectTimeout', - null, - "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead" + undefined, + "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead", ); Configuration.warnDeprecatedConfigurationKey( 'connectionTimeout', - null, - "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead" + undefined, + "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead", ); + // connection retries Configuration.warnDeprecatedConfigurationKey( 'autoReconnectMaxRetries', - null, - 'Use it in charging station template instead' + undefined, + 'Use it in charging station template instead', ); - // Read conf - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'autoReconnectMaxRetries')) { - return Configuration.getConfig().autoReconnectMaxRetries; - } - } - - static getStationTemplateUrls(): StationTemplateUrl[] { + // station template url(s) Configuration.warnDeprecatedConfigurationKey( 'stationTemplateURLs', - null, - "Use 'stationTemplateUrls' instead" - ); - !Configuration.isUndefined(Configuration.getConfig()['stationTemplateURLs']) && - (Configuration.getConfig().stationTemplateUrls = Configuration.getConfig()[ - 'stationTemplateURLs' - ] as StationTemplateUrl[]); - Configuration.getConfig().stationTemplateUrls.forEach((stationUrl: StationTemplateUrl) => { - if (!Configuration.isUndefined(stationUrl['numberOfStation'])) { - console.error( - chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration key 'numberOfStation' usage for template file '${ - stationUrl.file - }' in 'stationTemplateUrls'. Use 'numberOfStations' instead}` - ); - } - }); - // Read conf - return Configuration.getConfig().stationTemplateUrls; - } - - static getWorkerProcess(): WorkerProcessType { + undefined, + "Use 'stationTemplateUrls' instead", + ); + !isUndefined( + Configuration.getConfigurationData()?.['stationTemplateURLs' as keyof ConfigurationData], + ) && + (Configuration.getConfigurationData()!.stationTemplateUrls = + Configuration.getConfigurationData()![ + 'stationTemplateURLs' as keyof ConfigurationData + ] as StationTemplateUrl[]); + Configuration.getConfigurationData()?.stationTemplateUrls.forEach( + (stationTemplateUrl: StationTemplateUrl) => { + if (!isUndefined(stationTemplateUrl?.['numberOfStation' as keyof StationTemplateUrl])) { + console.error( + `${chalk.green(Configuration.logPrefix())} ${chalk.red( + `Deprecated configuration key 'numberOfStation' usage for template file '${stationTemplateUrl.file}' in 'stationTemplateUrls'. Use 'numberOfStations' instead`, + )}`, + ); + } + }, + ); + // supervision url(s) + Configuration.warnDeprecatedConfigurationKey( + 'supervisionURLs', + undefined, + "Use 'supervisionUrls' instead", + ); + // supervision urls distribution + Configuration.warnDeprecatedConfigurationKey( + 'distributeStationToTenantEqually', + undefined, + "Use 'supervisionUrlDistribution' instead", + ); + Configuration.warnDeprecatedConfigurationKey( + 'distributeStationsToTenantsEqually', + undefined, + "Use 'supervisionUrlDistribution' instead", + ); + // worker section Configuration.warnDeprecatedConfigurationKey( 'useWorkerPool', - null, - "Use 'workerProcess' to define the type of worker process model to use instead" + undefined, + `Use '${ConfigurationSection.worker}' section to define the type of worker process model instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerProcess', + undefined, + `Use '${ConfigurationSection.worker}' section to define the type of worker process model instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerStartDelay', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker start delay instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'chargingStationsPerWorker', + undefined, + `Use '${ConfigurationSection.worker}' section to define the number of element(s) per worker instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'elementStartDelay', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker's element start delay instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerPoolMinSize', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool minimum size instead`, ); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerProcess') - ? Configuration.getConfig().workerProcess - : WorkerProcessType.WORKER_SET; - } - - static getWorkerStartDelay(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerStartDelay') - ? Configuration.getConfig().workerStartDelay - : WorkerConstants.DEFAULT_WORKER_START_DELAY; - } - - static getElementStartDelay(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'elementStartDelay') - ? Configuration.getConfig().elementStartDelay - : WorkerConstants.DEFAULT_ELEMENT_START_DELAY; - } - - static getWorkerPoolMinSize(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerPoolMinSize') - ? Configuration.getConfig().workerPoolMinSize - : WorkerConstants.DEFAULT_POOL_MIN_SIZE; - } - - static getWorkerPoolMaxSize(): number { Configuration.warnDeprecatedConfigurationKey( 'workerPoolSize;', - null, - "Use 'workerPoolMaxSize' instead" + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`, ); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerPoolMaxSize') - ? Configuration.getConfig().workerPoolMaxSize - : WorkerConstants.DEFAULT_POOL_MAX_SIZE; - } - - static getWorkerPoolStrategy(): WorkerChoiceStrategy { - return Configuration.getConfig().workerPoolStrategy; - } - - static getChargingStationsPerWorker(): number { - return Configuration.objectHasOwnProperty( - Configuration.getConfig(), - 'chargingStationsPerWorker' - ) - ? Configuration.getConfig().chargingStationsPerWorker - : WorkerConstants.DEFAULT_ELEMENTS_PER_WORKER; - } - - static getLogConsole(): boolean { - Configuration.warnDeprecatedConfigurationKey('consoleLog', null, "Use 'logConsole' instead"); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logConsole') - ? Configuration.getConfig().logConsole - : false; - } - - static getLogFormat(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logFormat') - ? Configuration.getConfig().logFormat - : 'simple'; - } - - static getLogRotate(): boolean { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logRotate') - ? Configuration.getConfig().logRotate - : true; - } - - static getLogMaxFiles(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logMaxFiles') - ? Configuration.getConfig().logMaxFiles - : 7; - } - - static getLogLevel(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logLevel') - ? Configuration.getConfig().logLevel.toLowerCase() - : 'info'; - } - - static getLogFile(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logFile') - ? Configuration.getConfig().logFile - : 'combined.log'; - } - - static getLogErrorFile(): string { - Configuration.warnDeprecatedConfigurationKey('errorFile', null, "Use 'logErrorFile' instead"); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logErrorFile') - ? Configuration.getConfig().logErrorFile - : 'error.log'; - } - - static getSupervisionUrls(): string | string[] { Configuration.warnDeprecatedConfigurationKey( - 'supervisionURLs', - null, - "Use 'supervisionUrls' instead" - ); - !Configuration.isUndefined(Configuration.getConfig()['supervisionURLs']) && - (Configuration.getConfig().supervisionUrls = Configuration.getConfig()[ - 'supervisionURLs' - ] as string[]); - // Read conf - return Configuration.getConfig().supervisionUrls; - } - - static getSupervisionUrlDistribution(): SupervisionUrlDistribution { + 'workerPoolMaxSize;', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`, + ); Configuration.warnDeprecatedConfigurationKey( - 'distributeStationToTenantEqually', - null, - "Use 'supervisionUrlDistribution' instead" + 'workerPoolStrategy;', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool strategy instead`, ); Configuration.warnDeprecatedConfigurationKey( - 'distributeStationsToTenantsEqually', - null, - "Use 'supervisionUrlDistribution' instead" - ); - return Configuration.objectHasOwnProperty( - Configuration.getConfig(), - 'supervisionUrlDistribution' - ) - ? Configuration.getConfig().supervisionUrlDistribution - : SupervisionUrlDistribution.ROUND_ROBIN; - } - - private static logPrefix(): string { - return new Date().toLocaleString() + ' Simulator configuration |'; + 'poolStrategy', + ConfigurationSection.worker, + 'Not publicly exposed to end users', + ); + // log section + Configuration.warnDeprecatedConfigurationKey( + 'logEnabled', + undefined, + `Use '${ConfigurationSection.log}' section to define the logging enablement instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logFile', + undefined, + `Use '${ConfigurationSection.log}' section to define the log file instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logErrorFile', + undefined, + `Use '${ConfigurationSection.log}' section to define the log error file instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logConsole', + undefined, + `Use '${ConfigurationSection.log}' section to define the console logging enablement instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logStatisticsInterval', + undefined, + `Use '${ConfigurationSection.log}' section to define the log statistics interval instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logLevel', + undefined, + `Use '${ConfigurationSection.log}' section to define the log level instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logFormat', + undefined, + `Use '${ConfigurationSection.log}' section to define the log format instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logRotate', + undefined, + `Use '${ConfigurationSection.log}' section to define the log rotation enablement instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logMaxFiles', + undefined, + `Use '${ConfigurationSection.log}' section to define the log maximum files instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'logMaxSize', + undefined, + `Use '${ConfigurationSection.log}' section to define the log maximum size instead`, + ); + // performanceStorage section + Configuration.warnDeprecatedConfigurationKey( + 'URI', + ConfigurationSection.performanceStorage, + "Use 'uri' instead", + ); + // uiServer section + if (hasOwnProp(Configuration.getConfigurationData(), 'uiWebSocketServer')) { + console.error( + `${chalk.green(Configuration.logPrefix())} ${chalk.red( + `Deprecated configuration section 'uiWebSocketServer' usage. Use '${ConfigurationSection.uiServer}' instead`, + )}`, + ); + } } private static warnDeprecatedConfigurationKey( key: string, sectionName?: string, - logMsgToAppend = '' + logMsgToAppend = '', ) { if ( sectionName && - !Configuration.isUndefined(Configuration.getConfig()[sectionName]) && - !Configuration.isUndefined( - (Configuration.getConfig()[sectionName] as Record)[key] + !isUndefined( + Configuration.getConfigurationData()?.[sectionName as keyof ConfigurationData], + ) && + !isUndefined( + ( + Configuration.getConfigurationData()?.[sectionName as keyof ConfigurationData] as Record< + string, + unknown + > + )?.[key], ) ) { console.error( - chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration key '${key}' usage in section '${sectionName}'${ - logMsgToAppend && '. ' + logMsgToAppend - }}` + `${chalk.green(Configuration.logPrefix())} ${chalk.red( + `Deprecated configuration key '${key}' usage in section '${sectionName}'${ + logMsgToAppend.trim().length > 0 ? `. ${logMsgToAppend}` : '' + }`, + )}`, ); - } else if (!Configuration.isUndefined(Configuration.getConfig()[key])) { + } else if ( + !isUndefined(Configuration.getConfigurationData()?.[key as keyof ConfigurationData]) + ) { console.error( - chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration key '${key}' usage${ - logMsgToAppend && '. ' + logMsgToAppend - }}` + `${chalk.green(Configuration.logPrefix())} ${chalk.red( + `Deprecated configuration key '${key}' usage${ + logMsgToAppend.trim().length > 0 ? `. ${logMsgToAppend}` : '' + }`, + )}`, ); } } - // Read the config file - private static getConfig(): ConfigurationData { - if (!Configuration.configuration) { + private static getConfigurationData(): ConfigurationData | undefined { + if (!Configuration.configurationData) { try { - Configuration.configuration = JSON.parse( - fs.readFileSync(Configuration.configurationFile, 'utf8') + Configuration.configurationData = JSON.parse( + readFileSync(Configuration.configurationFile, 'utf8'), ) as ConfigurationData; + if (!Configuration.configurationFileWatcher) { + Configuration.configurationFileWatcher = Configuration.getConfigurationFileWatcher(); + } } catch (error) { Configuration.handleFileException( - Configuration.logPrefix(), - FileType.Configuration, Configuration.configurationFile, - error as NodeJS.ErrnoException + FileType.Configuration, + error as NodeJS.ErrnoException, + Configuration.logPrefix(), ); } - if (!Configuration.configurationFileWatcher) { - Configuration.configurationFileWatcher = Configuration.getConfigurationFileWatcher(); - } } - return Configuration.configuration; + return Configuration.configurationData; } - private static getConfigurationFileWatcher(): fs.FSWatcher { + private static getConfigurationFileWatcher(): FSWatcher | undefined { try { - return fs.watch(Configuration.configurationFile, (event, filename): void => { - if (filename && event === 'change') { - // Nullify to force configuration file reading - Configuration.configuration = null; - if (!Configuration.isUndefined(Configuration.configurationChangeCallback)) { - Configuration.configurationChangeCallback().catch((error) => { + return watch(Configuration.configurationFile, (event, filename): void => { + if (filename!.trim()!.length > 0 && event === 'change') { + delete Configuration.configurationData; + Configuration.configurationSectionCache.clear(); + if (!isUndefined(Configuration.configurationChangeCallback)) { + Configuration.configurationChangeCallback!().catch((error) => { throw typeof error === 'string' ? new Error(error) : error; }); } @@ -357,68 +550,58 @@ export default class Configuration { }); } catch (error) { Configuration.handleFileException( - Configuration.logPrefix(), - FileType.Configuration, Configuration.configurationFile, - error as NodeJS.ErrnoException + FileType.Configuration, + error as NodeJS.ErrnoException, + Configuration.logPrefix(), ); } } + private static handleFileException( + file: string, + fileType: FileType, + error: NodeJS.ErrnoException, + logPfx: string, + ): void { + const prefix = isNotEmptyString(logPfx) ? `${logPfx} ` : ''; + let logMsg: string; + switch (error.code) { + case 'ENOENT': + logMsg = `${fileType} file ${file} not found:`; + break; + case 'EEXIST': + logMsg = `${fileType} file ${file} already exists:`; + break; + case 'EACCES': + logMsg = `${fileType} file ${file} access denied:`; + break; + case 'EPERM': + logMsg = `${fileType} file ${file} permission denied:`; + break; + default: + logMsg = `${fileType} file ${file} error:`; + } + console.error(`${chalk.green(prefix)}${chalk.red(`${logMsg} `)}`, error); + throw error; + } + private static getDefaultPerformanceStorageUri(storageType: StorageType) { - const SQLiteFileName = `${Constants.DEFAULT_PERFORMANCE_RECORDS_DB_NAME}.db`; switch (storageType) { case StorageType.JSON_FILE: - return `file://${path.join( - path.resolve(__dirname, '../../'), - Constants.DEFAULT_PERFORMANCE_RECORDS_FILENAME - )}`; + return Configuration.buildPerformanceUriFilePath( + `${Constants.DEFAULT_PERFORMANCE_DIRECTORY}/${Constants.DEFAULT_PERFORMANCE_RECORDS_FILENAME}`, + ); case StorageType.SQLITE: - return `file://${path.join(path.resolve(__dirname, '../../'), SQLiteFileName)}`; + return Configuration.buildPerformanceUriFilePath( + `${Constants.DEFAULT_PERFORMANCE_DIRECTORY}/${Constants.DEFAULT_PERFORMANCE_RECORDS_DB_NAME}.db`, + ); default: - throw new Error(`Performance storage URI is mandatory with storage type '${storageType}'`); + throw new Error(`Unsupported storage type '${storageType}'`); } } - private static objectHasOwnProperty(object: unknown, property: string): boolean { - return Object.prototype.hasOwnProperty.call(object, property) as boolean; - } - - private static isUndefined(obj: unknown): boolean { - return typeof obj === 'undefined'; - } - - private static handleFileException( - logPrefix: string, - fileType: FileType, - filePath: string, - error: NodeJS.ErrnoException, - params: HandleErrorParams = { throwError: true } - ): void { - const prefix = logPrefix.length !== 0 ? logPrefix + ' ' : ''; - if (error.code === 'ENOENT') { - console.error( - chalk.green(prefix) + chalk.red(fileType + ' file ' + filePath + ' not found: '), - error - ); - } else if (error.code === 'EEXIST') { - console.error( - chalk.green(prefix) + chalk.red(fileType + ' file ' + filePath + ' already exists: '), - error - ); - } else if (error.code === 'EACCES') { - console.error( - chalk.green(prefix) + chalk.red(fileType + ' file ' + filePath + ' access denied: '), - error - ); - } else { - console.error( - chalk.green(prefix) + chalk.red(fileType + ' file ' + filePath + ' error: '), - error - ); - } - if (params?.throwError) { - throw error; - } + private static buildPerformanceUriFilePath(file: string) { + return `file://${join(resolve(dirname(fileURLToPath(import.meta.url)), '../'), file)}`; } }