X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=7b2db1c795033a2f697f2989c3f69a7a5eb9ed30;hb=78202038ffd2aca15aa97f45bc66ba42f40f2ec4;hp=143bb5c4298ee229fe3c0d8d66ad69eebda37bf6;hpb=c3ee95af4edd541595e3873c8aa4c93d38e59474;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 143bb5c4..7b2db1c7 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,89 +1,146 @@ -// Partial Copyright Jerome Benoit. 2021. All Rights Reserved. +// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. -import { ChargingStationWorkerData, ChargingStationWorkerMessage, ChargingStationWorkerMessageEvents } from '../types/ChargingStationWorker'; +import path from 'path'; +import { fileURLToPath } from 'url'; +import { type Worker, isMainThread } from 'worker_threads'; -import Configuration from '../utils/Configuration'; -import Statistics from '../types/Statistics'; -import { Storage } from '../performance/storage/Storage'; +import chalk from 'chalk'; + +import { ChargingStationUtils } from './ChargingStationUtils'; +import type { AbstractUIServer } from './ui-server/AbstractUIServer'; +import UIServerFactory from './ui-server/UIServerFactory'; +import { version } from '../../package.json'; +import BaseError from '../exception/BaseError'; +import type { Storage } from '../performance/storage/Storage'; import { StorageFactory } from '../performance/storage/StorageFactory'; -import { UIServiceUtils } from './ui-websocket-services/UIServiceUtils'; -import UIWebSocketServer from './UIWebSocketServer'; +import { + type ChargingStationData, + type ChargingStationWorkerData, + type ChargingStationWorkerMessage, + type ChargingStationWorkerMessageData, + ChargingStationWorkerMessageEvents, +} from '../types/ChargingStationWorker'; +import type { StationTemplateUrl } from '../types/ConfigurationData'; +import type { Statistics } from '../types/Statistics'; +import type { MessageHandler } from '../types/Worker'; +import Configuration from '../utils/Configuration'; +import logger from '../utils/Logger'; import Utils from '../utils/Utils'; -import WorkerAbstract from '../worker/WorkerAbstract'; +import type WorkerAbstract from '../worker/WorkerAbstract'; import WorkerFactory from '../worker/WorkerFactory'; -import chalk from 'chalk'; -import { isMainThread } from 'worker_threads'; -import path from 'path'; -import { version } from '../../package.json'; -export default class Bootstrap { +const moduleName = 'Bootstrap'; + +enum exitCodes { + missingChargingStationsConfiguration = 1, + noChargingStationTemplates = 2, +} + +export class Bootstrap { private static instance: Bootstrap | null = null; - private workerImplementation: WorkerAbstract | null = null; - private readonly uiWebSocketServer!: UIWebSocketServer; + private workerImplementation: WorkerAbstract | null; + private readonly uiServer!: AbstractUIServer; private readonly storage!: Storage; - private numberOfChargingStations: number; + private numberOfChargingStationTemplates!: number; + private numberOfChargingStations!: number; + private numberOfStartedChargingStations!: number; private readonly version: string = version; private started: boolean; private readonly workerScript: string; private constructor() { this.started = false; - this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'ChargingStationWorker.js'); - this.initWorkerImplementation(); - Configuration.getUIWebSocketServer().enabled && (this.uiWebSocketServer = new UIWebSocketServer({ - ...Configuration.getUIWebSocketServer().options, handleProtocols: UIServiceUtils.handleProtocols - })); - Configuration.getPerformanceStorage().enabled && (this.storage = StorageFactory.getStorage( - Configuration.getPerformanceStorage().type, - Configuration.getPerformanceStorage().uri, - this.logPrefix() - )); + this.workerImplementation = null; + this.workerScript = path.join( + path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'), + 'charging-station', + 'ChargingStationWorker' + path.extname(fileURLToPath(import.meta.url)) + ); + this.initialize(); + Configuration.getUIServer().enabled === true && + (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer())); + Configuration.getPerformanceStorage().enabled === true && + (this.storage = StorageFactory.getStorage( + Configuration.getPerformanceStorage().type, + Configuration.getPerformanceStorage().uri, + this.logPrefix() + )); Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart()); } public static getInstance(): Bootstrap { - if (!Bootstrap.instance) { + if (Bootstrap.instance === null) { Bootstrap.instance = new Bootstrap(); } return Bootstrap.instance; } public async start(): Promise { - if (isMainThread && !this.started) { + if (isMainThread && this.started === false) { try { - this.numberOfChargingStations = 0; + // Enable unconditionally for now + this.logUnhandledRejection(); + this.logUncaughtException(); + this.initialize(); await this.storage?.open(); await this.workerImplementation.start(); - this.uiWebSocketServer?.start(); + this.uiServer?.start(); const stationTemplateUrls = Configuration.getStationTemplateUrls(); + this.numberOfChargingStationTemplates = stationTemplateUrls.length; // Start ChargingStation object in worker thread - if (stationTemplateUrls) { + if (!Utils.isEmptyArray(stationTemplateUrls)) { for (const stationTemplateUrl of stationTemplateUrls) { try { const nbStations = stationTemplateUrl.numberOfStations ?? 0; for (let index = 1; index <= nbStations; index++) { - const workerData: ChargingStationWorkerData = { - index, - templateFile: path.join(path.resolve(__dirname, '../'), 'assets', 'station-templates', path.basename(stationTemplateUrl.file)) - }; - await this.workerImplementation.addElement(workerData); - this.numberOfChargingStations++; + await this.startChargingStation(index, stationTemplateUrl); } } catch (error) { - console.error(chalk.red('Charging station start with template file ' + stationTemplateUrl.file + ' error '), error); + console.error( + chalk.red( + 'Error at starting charging station with template file ' + + stationTemplateUrl.file + + ': ' + ), + error + ); } } } else { - console.warn(chalk.yellow('No stationTemplateUrls defined in configuration, exiting')); + console.warn( + chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting") + ); + process.exit(exitCodes.missingChargingStationsConfiguration); } if (this.numberOfChargingStations === 0) { - console.warn(chalk.yellow('No charging station template enabled in configuration, exiting')); + console.warn( + chalk.yellow('No charging station template enabled in configuration, exiting') + ); + process.exit(exitCodes.noChargingStationTemplates); } else { - console.log(chalk.green(`Charging stations simulator ${this.version} started with ${this.numberOfChargingStations.toString()} charging station(s) and ${Utils.workerDynamicPoolInUse() ? `${Configuration.getWorkerPoolMinSize().toString()}/` : ''}${this.workerImplementation.size}${Utils.workerPoolInUse() ? `/${Configuration.getWorkerPoolMaxSize().toString()}` : ''} worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${this.workerImplementation.maxElementsPerWorker ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` : ''}`)); + console.info( + chalk.green( + `Charging stations simulator ${ + this.version + } started with ${this.numberOfChargingStations.toString()} charging station(s) from ${this.numberOfChargingStationTemplates.toString()} configured charging station template(s) and ${ + ChargingStationUtils.workerDynamicPoolInUse() + ? `${Configuration.getWorker().poolMinSize.toString()}/` + : '' + }${this.workerImplementation.size}${ + ChargingStationUtils.workerPoolInUse() + ? `/${Configuration.getWorker().poolMaxSize.toString()}` + : '' + } worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${ + this.workerImplementation.maxElementsPerWorker + ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` + : '' + }` + ) + ); } this.started = true; } catch (error) { - console.error(chalk.red('Bootstrap start error '), error); + console.error(chalk.red('Bootstrap start error: '), error); } } else { console.error(chalk.red('Cannot start an already started charging stations simulator')); @@ -91,42 +148,147 @@ export default class Bootstrap { } public async stop(): Promise { - if (isMainThread && this.started) { + if (isMainThread && this.started === true) { await this.workerImplementation.stop(); - this.uiWebSocketServer?.stop(); + this.workerImplementation = null; + this.uiServer?.stop(); await this.storage?.close(); + this.started = false; } else { - console.error(chalk.red('Trying to stop the charging stations simulator while not started')); + console.error(chalk.red('Cannot stop a not started charging stations simulator')); } - this.started = false; } public async restart(): Promise { await this.stop(); - this.initWorkerImplementation(); + this.initialize(); await this.start(); } - private initWorkerImplementation(): void { - this.workerImplementation = WorkerFactory.getWorkerImplementation(this.workerScript, Configuration.getWorkerProcess(), - { - startDelay: Configuration.getWorkerStartDelay(), - poolMaxSize: Configuration.getWorkerPoolMaxSize(), - poolMinSize: Configuration.getWorkerPoolMinSize(), - elementsPerWorker: Configuration.getChargingStationsPerWorker(), - poolOptions: { - workerChoiceStrategy: Configuration.getWorkerPoolStrategy() - }, - messageHandler: async (msg: ChargingStationWorkerMessage) => { - if (msg.id === ChargingStationWorkerMessageEvents.STARTED) { - this.uiWebSocketServer.chargingStations.add(msg.data.id as string); - } else if (msg.id === ChargingStationWorkerMessageEvents.STOPPED) { - this.uiWebSocketServer.chargingStations.delete(msg.data.id as string); - } else if (msg.id === ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS) { - await this.storage.storePerformanceStatistics(msg.data as unknown as Statistics); - } + private initializeWorkerImplementation(): void { + this.workerImplementation === null && + (this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerScript, + Configuration.getWorker().processType, + { + workerStartDelay: Configuration.getWorker().startDelay, + elementStartDelay: Configuration.getWorker().elementStartDelay, + poolMaxSize: Configuration.getWorker().poolMaxSize, + poolMinSize: Configuration.getWorker().poolMinSize, + elementsPerWorker: Configuration.getWorker().elementsPerWorker, + poolOptions: { + workerChoiceStrategy: Configuration.getWorker().poolStrategy, + }, + messageHandler: this.messageHandler.bind(this) as MessageHandler, } - }); + )); + } + + private messageHandler( + msg: ChargingStationWorkerMessage + ): void { + // logger.debug( + // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( + // msg, + // null, + // 2 + // )}` + // ); + try { + switch (msg.id) { + case ChargingStationWorkerMessageEvents.STARTED: + this.workerEventStarted(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.STOPPED: + this.workerEventStopped(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.UPDATED: + this.workerEventUpdated(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS: + this.workerEventPerformanceStatistics(msg.data as Statistics); + break; + default: + throw new BaseError( + `Unknown event type: '${msg.id}' for data: ${JSON.stringify(msg.data, null, 2)}` + ); + } + } catch (error) { + logger.error( + `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ + msg.id + }' event:`, + error + ); + } + } + + private workerEventStarted = (data: ChargingStationData) => { + this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); + ++this.numberOfStartedChargingStations; + logger.info( + `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${ + data.stationInfo.chargingStationId + } (hashId: ${data.stationInfo.hashId}) started (${ + this.numberOfStartedChargingStations + } started from ${this.numberOfChargingStations})` + ); + }; + + private workerEventStopped = (data: ChargingStationData) => { + this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); + --this.numberOfStartedChargingStations; + logger.info( + `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${ + data.stationInfo.chargingStationId + } (hashId: ${data.stationInfo.hashId}) stopped (${ + this.numberOfStartedChargingStations + } started from ${this.numberOfChargingStations})` + ); + }; + + private workerEventUpdated = (data: ChargingStationData) => { + this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); + }; + + private workerEventPerformanceStatistics = (data: Statistics) => { + this.storage.storePerformanceStatistics(data) as void; + }; + + private initialize() { + this.numberOfChargingStationTemplates = 0; + this.numberOfChargingStations = 0; + this.numberOfStartedChargingStations = 0; + this.initializeWorkerImplementation(); + } + + private logUncaughtException(): void { + process.on('uncaughtException', (error: Error) => { + console.error(chalk.red('Uncaught exception: '), error); + }); + } + + private logUnhandledRejection(): void { + process.on('unhandledRejection', (reason: unknown) => { + console.error(chalk.red('Unhandled rejection: '), reason); + }); + } + + private async startChargingStation( + index: number, + stationTemplateUrl: StationTemplateUrl + ): Promise { + const workerData: ChargingStationWorkerData = { + index, + templateFile: path.join( + path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'), + 'assets', + 'station-templates', + stationTemplateUrl.file + ), + }; + await this.workerImplementation.addElement(workerData); + ++this.numberOfChargingStations; } private logPrefix(): string {