X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Futils%2FConfiguration.ts;h=b564cd6252ea4366993f24bb5e9961132bd9ad4d;hb=3fb26594ef01e3f443bcc0bbf81401c6e38fdc01;hp=519f0465b1580f2bbb4f781777d0ff080849a0e2;hpb=6114e6f11b3fb12439d464e142fdf93866982b6c;p=e-mobility-charging-stations-simulator.git diff --git a/src/utils/Configuration.ts b/src/utils/Configuration.ts index 519f0465..b564cd62 100644 --- a/src/utils/Configuration.ts +++ b/src/utils/Configuration.ts @@ -1,244 +1,588 @@ -import ConfigurationData, { StationTemplateUrl, StorageConfiguration, SupervisionUrlDistribution, UIWebSocketServerConfiguration } 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 { ServerOptions } from 'ws'; -import { StorageType } from '../types/Storage'; -import type { WorkerChoiceStrategy } from 'poolifier'; -import { WorkerProcessType } from '../types/Worker'; import chalk from 'chalk'; -import fs from 'fs'; -import path from 'path'; +import merge from 'just-merge'; -export default class Configuration { - private static configurationFilePath = path.join(path.resolve(__dirname, '../'), 'assets', 'config.json'); - private static configurationFileWatcher: fs.FSWatcher; - private static configuration: ConfigurationData | null = null; - private static configurationChangeCallback: () => Promise; +import { Constants } from './Constants'; +import { hasOwnProp, isCFEnvironment, isNotEmptyString, isUndefined } 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'; - static setConfigurationChangeCallback(cb: () => Promise): void { - Configuration.configurationChangeCallback = cb; - } +type ConfigurationSectionType = + | LogConfiguration + | StorageConfiguration + | WorkerConfiguration + | UIServerConfiguration; - static getLogStatisticsInterval(): number { - Configuration.warnDeprecatedConfigurationKey('statisticsDisplayInterval', null, 'Use \'logStatisticsInterval\' instead'); - // Read conf - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logStatisticsInterval') ? Configuration.getConfig().logStatisticsInterval : 60; - } - - static getUIWebSocketServer(): UIWebSocketServerConfiguration { - let options: ServerOptions = { - host: Constants.DEFAULT_UI_WEBSOCKET_SERVER_HOST, - port: Constants.DEFAULT_UI_WEBSOCKET_SERVER_PORT - }; - let uiWebSocketServerConfiguration: UIWebSocketServerConfiguration = { - enabled: true, - options - }; - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'uiWebSocketServer')) { - if (Configuration.objectHasOwnProperty(Configuration.getConfig().uiWebSocketServer, 'options')) { - options = { - ...options, - ...Configuration.objectHasOwnProperty(Configuration.getConfig().uiWebSocketServer.options, 'host') && { host: Configuration.getConfig().uiWebSocketServer.options.host }, - ...Configuration.objectHasOwnProperty(Configuration.getConfig().uiWebSocketServer.options, 'port') && { port: Configuration.getConfig().uiWebSocketServer.options.port } - }; - } - uiWebSocketServerConfiguration = - { - ...uiWebSocketServerConfiguration, - ...Configuration.objectHasOwnProperty(Configuration.getConfig().uiWebSocketServer, 'enabled') && { enabled: Configuration.getConfig().uiWebSocketServer.enabled }, - options - }; - } - return uiWebSocketServerConfiguration; - } - - static getPerformanceStorage(): StorageConfiguration { - Configuration.warnDeprecatedConfigurationKey('URI', 'performanceStorage', 'Use \'uri\' instead'); - let storageConfiguration: StorageConfiguration = { - enabled: false, - type: StorageType.JSON_FILE, - uri: this.getDefaultPerformanceStorageUri(StorageType.JSON_FILE) - }; - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), '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) } - }; - } - return storageConfiguration; - } +export class Configuration { + private static configurationFile = join( + dirname(fileURLToPath(import.meta.url)), + 'assets', + 'config.json', + ); - static getAutoReconnectMaxRetries(): number { - Configuration.warnDeprecatedConfigurationKey('autoReconnectTimeout', null, 'Use \'ConnectionTimeOut\' OCPP parameter in charging station template instead'); - Configuration.warnDeprecatedConfigurationKey('connectionTimeout', null, 'Use \'ConnectionTimeOut\' OCPP parameter in charging station template instead'); - Configuration.warnDeprecatedConfigurationKey('autoReconnectMaxRetries', null, 'Use it in charging station template instead'); - // Read conf - if (Configuration.objectHasOwnProperty(Configuration.getConfig(), 'autoReconnectMaxRetries')) { - return Configuration.getConfig().autoReconnectMaxRetries; - } - } + private static configurationFileWatcher?: FSWatcher; + private static configurationData?: ConfigurationData; + private static configurationSectionCache = new Map< + ConfigurationSection, + ConfigurationSectionType + >([ + [ConfigurationSection.log, Configuration.buildLogSection()], + [ConfigurationSection.performanceStorage, Configuration.buildPerformanceStorageSection()], + [ConfigurationSection.worker, Configuration.buildWorkerSection()], + [ConfigurationSection.uiServer, Configuration.buildUIServerSection()], + ]); - static getStationTemplateUrls(): StationTemplateUrl[] { - 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; - } + private static configurationChangeCallback?: () => Promise; - static getWorkerProcess(): WorkerProcessType { - Configuration.warnDeprecatedConfigurationKey('useWorkerPool;', null, 'Use \'workerProcess\' to define the type of worker process to use instead'); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerProcess') ? Configuration.getConfig().workerProcess : WorkerProcessType.WORKER_SET; + private constructor() { + // This is intentional } - static getWorkerStartDelay(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerStartDelay') ? Configuration.getConfig().workerStartDelay : Constants.WORKER_START_DELAY; + public static setConfigurationChangeCallback(cb: () => Promise): void { + Configuration.configurationChangeCallback = cb; } - static getWorkerPoolMinSize(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerPoolMinSize') ? Configuration.getConfig().workerPoolMinSize : Constants.DEFAULT_WORKER_POOL_MIN_SIZE; + public static getConfigurationSection( + sectionName: ConfigurationSection, + ): T { + if (!Configuration.isConfigurationSectionCached(sectionName)) { + Configuration.cacheConfigurationSection(sectionName); + } + return Configuration.configurationSectionCache.get(sectionName) as T; } - static getWorkerPoolMaxSize(): number { - Configuration.warnDeprecatedConfigurationKey('workerPoolSize;', null, 'Use \'workerPoolMaxSize\' instead'); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'workerPoolMaxSize') ? Configuration.getConfig().workerPoolMaxSize : Constants.DEFAULT_WORKER_POOL_MAX_SIZE; + public static getAutoReconnectMaxRetries(): number | undefined { + Configuration.warnDeprecatedConfigurationKey( + 'autoReconnectTimeout', + undefined, + "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead", + ); + Configuration.warnDeprecatedConfigurationKey( + 'connectionTimeout', + undefined, + "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead", + ); + Configuration.warnDeprecatedConfigurationKey( + 'autoReconnectMaxRetries', + undefined, + 'Use it in charging station template instead', + ); + if (hasOwnProp(Configuration.getConfigurationData(), 'autoReconnectMaxRetries')) { + return Configuration.getConfigurationData()?.autoReconnectMaxRetries; + } } - static getWorkerPoolStrategy(): WorkerChoiceStrategy { - return Configuration.getConfig().workerPoolStrategy; + public static getStationTemplateUrls(): StationTemplateUrl[] | undefined { + Configuration.warnDeprecatedConfigurationKey( + 'stationTemplateURLs', + undefined, + "Use 'stationTemplateUrls' instead", + ); + // eslint-disable-next-line @typescript-eslint/dot-notation + !isUndefined( + Configuration.getConfigurationData()!['stationTemplateURLs' as keyof ConfigurationData], + ) && + (Configuration.getConfigurationData()!.stationTemplateUrls = + Configuration.getConfigurationData()![ + // eslint-disable-next-line @typescript-eslint/dot-notation + 'stationTemplateURLs' as keyof ConfigurationData + ] as StationTemplateUrl[]); + Configuration.getConfigurationData()!.stationTemplateUrls.forEach( + (stationTemplateUrl: StationTemplateUrl) => { + // eslint-disable-next-line @typescript-eslint/dot-notation + 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`, + )}`, + ); + } + }, + ); + return Configuration.getConfigurationData()?.stationTemplateUrls; } - static getChargingStationsPerWorker(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'chargingStationsPerWorker') ? Configuration.getConfig().chargingStationsPerWorker : Constants.DEFAULT_CHARGING_STATIONS_PER_WORKER; + public static getSupervisionUrls(): string | string[] | undefined { + Configuration.warnDeprecatedConfigurationKey( + 'supervisionURLs', + undefined, + "Use 'supervisionUrls' instead", + ); + // eslint-disable-next-line @typescript-eslint/dot-notation + if ( + !isUndefined( + Configuration.getConfigurationData()!['supervisionURLs' as keyof ConfigurationData], + ) + ) { + Configuration.getConfigurationData()!.supervisionUrls = Configuration.getConfigurationData()![ + // eslint-disable-next-line @typescript-eslint/dot-notation + 'supervisionURLs' as keyof ConfigurationData + ] as string | string[]; + } + return Configuration.getConfigurationData()?.supervisionUrls; } - static getLogConsole(): boolean { - Configuration.warnDeprecatedConfigurationKey('consoleLog', null, 'Use \'logConsole\' instead'); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logConsole') ? Configuration.getConfig().logConsole : false; + public static getSupervisionUrlDistribution(): SupervisionUrlDistribution | undefined { + Configuration.warnDeprecatedConfigurationKey( + 'distributeStationToTenantEqually', + undefined, + "Use 'supervisionUrlDistribution' instead", + ); + Configuration.warnDeprecatedConfigurationKey( + 'distributeStationsToTenantsEqually', + undefined, + "Use 'supervisionUrlDistribution' instead", + ); + return hasOwnProp(Configuration.getConfigurationData(), 'supervisionUrlDistribution') + ? Configuration.getConfigurationData()?.supervisionUrlDistribution + : SupervisionUrlDistribution.ROUND_ROBIN; } - static getLogFormat(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logFormat') ? Configuration.getConfig().logFormat : 'simple'; + public static workerPoolInUse(): boolean { + return [WorkerProcessType.dynamicPool, WorkerProcessType.staticPool].includes( + Configuration.buildWorkerSection().processType!, + ); } - static getLogRotate(): boolean { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logRotate') ? Configuration.getConfig().logRotate : true; + public static workerDynamicPoolInUse(): boolean { + return Configuration.buildWorkerSection().processType === WorkerProcessType.dynamicPool; } - static getLogMaxFiles(): number { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logMaxFiles') ? Configuration.getConfig().logMaxFiles : 7; + private static isConfigurationSectionCached(sectionName: ConfigurationSection): boolean { + return Configuration.configurationSectionCache.has(sectionName); } - static getLogLevel(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logLevel') ? Configuration.getConfig().logLevel.toLowerCase() : 'info'; + 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}'`); + } } - static getLogFile(): string { - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logFile') ? Configuration.getConfig().logFile : 'combined.log'; + private static buildUIServerSection(): UIServerConfiguration { + if (hasOwnProp(Configuration.getConfigurationData(), 'uiWebSocketServer')) { + console.error( + `${chalk.green(Configuration.logPrefix())} ${chalk.red( + `Deprecated configuration section 'uiWebSocketServer' usage. Use '${ConfigurationSection.uiServer}' instead`, + )}`, + ); + } + let uiServerConfiguration: UIServerConfiguration = { + enabled: false, + type: ApplicationProtocol.WS, + options: { + host: Constants.DEFAULT_UI_SERVER_HOST, + port: Constants.DEFAULT_UI_SERVER_PORT, + }, + }; + 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 getLogErrorFile(): string { - Configuration.warnDeprecatedConfigurationKey('errorFile', null, 'Use \'logErrorFile\' instead'); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'logErrorFile') ? Configuration.getConfig().logErrorFile : 'error.log'; + private static buildPerformanceStorageSection(): StorageConfiguration { + Configuration.warnDeprecatedConfigurationKey( + 'URI', + ConfigurationSection.performanceStorage, + "Use 'uri' instead", + ); + let storageConfiguration: StorageConfiguration = { + enabled: false, + type: StorageType.JSON_FILE, + uri: Configuration.getDefaultPerformanceStorageUri(StorageType.JSON_FILE), + }; + if (hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.performanceStorage)) { + storageConfiguration = { + ...storageConfiguration, + ...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 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; + private static buildLogSection(): LogConfiguration { + 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`, + ); + 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; } - static getSupervisionUrlDistribution(): SupervisionUrlDistribution { - Configuration.warnDeprecatedConfigurationKey('distributeStationToTenantEqually', null, 'Use \'supervisionUrlDistribution\' instead'); - Configuration.warnDeprecatedConfigurationKey('distributeStationsToTenantsEqually', null, 'Use \'supervisionUrlDistribution\' instead'); - return Configuration.objectHasOwnProperty(Configuration.getConfig(), 'supervisionUrlDistribution') ? Configuration.getConfig().supervisionUrlDistribution : SupervisionUrlDistribution.ROUND_ROBIN; + private static buildWorkerSection(): WorkerConfiguration { + Configuration.warnDeprecatedConfigurationKey( + 'useWorkerPool', + 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`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerPoolSize;', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerPoolMaxSize;', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`, + ); + Configuration.warnDeprecatedConfigurationKey( + 'workerPoolStrategy;', + undefined, + `Use '${ConfigurationSection.worker}' section to define the worker pool strategy instead`, + ); + 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, + }; + hasOwnProp(Configuration.getConfigurationData(), 'workerPoolStrategy') && + delete Configuration.getConfigurationData()?.workerPoolStrategy; + 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, + }), + }; + Configuration.warnDeprecatedConfigurationKey( + 'poolStrategy', + ConfigurationSection.worker, + 'Not publicly exposed to end users', + ); + 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 logPrefix(): string { - return new Date().toLocaleString() + ' Simulator configuration |'; - } + private static logPrefix = (): string => { + return `${new Date().toLocaleString()} Simulator configuration |`; + }; - private static warnDeprecatedConfigurationKey(key: string, sectionName?: string, logMsgToAppend = '') { - // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access - if (sectionName && !Configuration.isUndefined(Configuration.getConfig()[sectionName]) && !Configuration.isUndefined(Configuration.getConfig()[sectionName][key])) { - console.error(chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration key '${key}' usage in section '${sectionName}'${logMsgToAppend && '. ' + logMsgToAppend}}`); - } else if (!Configuration.isUndefined(Configuration.getConfig()[key])) { - console.error(chalk`{green ${Configuration.logPrefix()}} {red Deprecated configuration key '${key}' usage${logMsgToAppend && '. ' + logMsgToAppend}}`); + private static warnDeprecatedConfigurationKey( + key: string, + sectionName?: string, + logMsgToAppend = '', + ) { + if ( + sectionName && + !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())} ${chalk.red( + `Deprecated configuration key '${key}' usage in section '${sectionName}'${ + logMsgToAppend.trim().length > 0 ? `. ${logMsgToAppend}` : '' + }`, + )}`, + ); + } else if ( + !isUndefined(Configuration.getConfigurationData()![key as keyof ConfigurationData]) + ) { + console.error( + `${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.configurationFilePath, 'utf8')) as ConfigurationData; + Configuration.configurationData = JSON.parse( + readFileSync(Configuration.configurationFile, 'utf8'), + ) as ConfigurationData; + if (!Configuration.configurationFileWatcher) { + Configuration.configurationFileWatcher = Configuration.getConfigurationFileWatcher(); + } } catch (error) { - Configuration.handleFileException(Configuration.logPrefix(), 'Configuration', Configuration.configurationFilePath, error); - } - if (!Configuration.configurationFileWatcher) { - Configuration.configurationFileWatcher = Configuration.getConfigurationFileWatcher(); + Configuration.handleFileException( + Configuration.configurationFile, + FileType.Configuration, + error as NodeJS.ErrnoException, + Configuration.logPrefix(), + ); } } - return Configuration.configuration; + return Configuration.configurationData; } - private static getConfigurationFileWatcher(): fs.FSWatcher { + private static getConfigurationFileWatcher(): FSWatcher | undefined { try { - return fs.watch(Configuration.configurationFilePath, (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; }); } } }); } catch (error) { - Configuration.handleFileException(Configuration.logPrefix(), 'Configuration', Configuration.configurationFilePath, error as Error); + Configuration.handleFileException( + Configuration.configurationFile, + FileType.Configuration, + error as NodeJS.ErrnoException, + Configuration.logPrefix(), + ); + } + } + + private static handleFileException( + file: string, + fileType: FileType, + error: NodeJS.ErrnoException, + logPrefix: string, + ): void { + const prefix = isNotEmptyString(logPrefix) ? `${logPrefix} ` : ''; + 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: string, filePath: string, error: NodeJS.ErrnoException): 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); - } - throw error; + private static buildPerformanceUriFilePath(file: string) { + return `file://${join(resolve(dirname(fileURLToPath(import.meta.url)), '../'), file)}`; } }