X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=27f4a6073c8c5159c1bfa2b134688e6d6027325a;hb=acfa5fd10b8489f5d85654e654356e65bfd1e0d0;hp=a6eb4939cf4f6cd0bf612362fbbc6744cd0cd53b;hpb=101196c654ddcd686e4992f58864f591ceea6c00;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index a6eb4939..27f4a607 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,74 +1,223 @@ -import Configuration from '../utils/Configuration'; -import { StationWorkerData } from '../types/Worker'; -import Utils from '../utils/Utils'; -import WorkerAbstract from '../worker/WorkerAbstract'; -import WorkerFactory from '../worker/WorkerFactory'; -import { isMainThread } from 'worker_threads'; -import path from 'path'; - -export default class Bootstrap { - private static instance: Bootstrap; +// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. + +import { EventEmitter } from 'node:events'; +import { dirname, extname, join } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { isMainThread } from 'node:worker_threads'; + +import chalk from 'chalk'; +import { availableParallelism } from 'poolifier'; + +import { waitChargingStationEvents } from './Helpers'; +import type { AbstractUIServer } from './ui-server/AbstractUIServer'; +import { UIServerFactory } from './ui-server/UIServerFactory'; +import { version } from '../../package.json' assert { type: 'json' }; +import { BaseError } from '../exception'; +import { type Storage, StorageFactory } from '../performance'; +import { + type ChargingStationData, + type ChargingStationWorkerData, + type ChargingStationWorkerMessage, + type ChargingStationWorkerMessageData, + ChargingStationWorkerMessageEvents, + ConfigurationSection, + ProcedureName, + type StationTemplateUrl, + type Statistics, + type StorageConfiguration, + type UIServerConfiguration, + type WorkerConfiguration, +} from '../types'; +import { + Configuration, + Constants, + formatDurationMilliSeconds, + generateUUID, + handleUncaughtException, + handleUnhandledRejection, + isNotEmptyArray, + isNullOrUndefined, + logPrefix, + logger, +} from '../utils'; +import { type WorkerAbstract, WorkerFactory } from '../worker'; + +const moduleName = 'Bootstrap'; + +enum exitCodes { + missingChargingStationsConfiguration = 1, + noChargingStationTemplates = 2, +} + +export class Bootstrap extends EventEmitter { + private static instance: Bootstrap | null = null; + public numberOfChargingStations!: number; + public numberOfChargingStationTemplates!: number; + private workerImplementation: WorkerAbstract | null; + private readonly uiServer!: AbstractUIServer | null; + private readonly storage!: Storage; + private numberOfStartedChargingStations!: number; + private readonly version: string = version; + private initializedCounters: boolean; private started: boolean; - private workerScript: string; - private workerImplementationInstance: WorkerAbstract | null = null; + private starting: boolean; + private stopping: boolean; + private readonly workerScript: string; private constructor() { + super(); + for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) { + process.on(signal, this.gracefulShutdown); + } + // Enable unconditionally for now + handleUnhandledRejection(); + handleUncaughtException(); this.started = false; - this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'StationWorker.js'); - Configuration.setConfigurationChangeCallback(async () => this.restart()); + this.starting = false; + this.stopping = false; + this.initializedCounters = false; + this.initializeCounters(); + this.workerImplementation = null; + this.workerScript = join( + dirname(fileURLToPath(import.meta.url)), + `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`, + ); + const uiServerConfiguration = Configuration.getConfigurationSection( + ConfigurationSection.uiServer, + ); + uiServerConfiguration.enabled === true && + (this.uiServer = UIServerFactory.getUIServerImplementation(uiServerConfiguration)); + const performanceStorageConfiguration = + Configuration.getConfigurationSection( + ConfigurationSection.performanceStorage, + ); + performanceStorageConfiguration.enabled === true && + (this.storage = StorageFactory.getStorage( + performanceStorageConfiguration.type!, + performanceStorageConfiguration.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) { - try { - let numStationsTotal = 0; - await this.getWorkerImplementationInstance()?.start(); - // Start ChargingStation object in worker thread - if (Configuration.getStationTemplateURLs()) { - for (const stationURL of Configuration.getStationTemplateURLs()) { - try { - const nbStations = stationURL.numberOfStations ? stationURL.numberOfStations : 0; - for (let index = 1; index <= nbStations; index++) { - const workerData: StationWorkerData = { - index, - templateFile: path.join(path.resolve(__dirname, '../'), 'assets', 'station-templates', path.basename(stationURL.file)) - }; - await this.getWorkerImplementationInstance()?.addElement(workerData); - numStationsTotal++; - } - } catch (error) { - console.error('Charging station start with template file ' + stationURL.file + ' error ', error); + if (!isMainThread) { + throw new BaseError('Cannot start charging stations simulator from worker thread'); + } + if (this.started === false) { + if (this.starting === false) { + this.starting = true; + this.initializeCounters(); + const workerConfiguration = Configuration.getConfigurationSection( + ConfigurationSection.worker, + ); + this.initializeWorkerImplementation(workerConfiguration); + await this.workerImplementation?.start(); + await this.storage?.open(); + this.uiServer?.start(); + // Start ChargingStation object instance in worker thread + for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) { + try { + const nbStations = stationTemplateUrl.numberOfStations ?? 0; + for (let index = 1; index <= nbStations; index++) { + await this.startChargingStation(index, stationTemplateUrl); } + } catch (error) { + console.error( + chalk.red( + `Error at starting charging station with template file ${stationTemplateUrl.file}: `, + ), + error, + ); } - } else { - console.log('No stationTemplateURLs defined in configuration, exiting'); - } - if (numStationsTotal === 0) { - console.log('No charging station template enabled in configuration, exiting'); - } else { - console.log(`Charging station simulator started with ${numStationsTotal.toString()} charging station(s) and ${Utils.workerDynamicPoolInUse() ? `${Configuration.getWorkerPoolMinSize().toString()}/` : ''}${this.getWorkerImplementationInstance().size}${Utils.workerPoolInUse() ? `/${Configuration.getWorkerPoolMaxSize().toString()}` : ''} worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${this.getWorkerImplementationInstance().maxElementsPerWorker ? ` (${this.getWorkerImplementationInstance().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 ${ + Configuration.workerDynamicPoolInUse() + ? `${workerConfiguration.poolMinSize?.toString()}/` + : '' + }${this.workerImplementation?.size}${ + Configuration.workerPoolInUse() + ? `/${workerConfiguration.poolMaxSize?.toString()}` + : '' + } worker(s) concurrently running in '${workerConfiguration.processType}' mode${ + !isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker) + ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)` + : '' + }`, + ), + ); + Configuration.workerDynamicPoolInUse() && + console.warn( + chalk.yellow( + 'Charging stations simulator is using dynamic pool mode. This is an experimental feature with known issues.\nPlease consider using static pool or worker set mode instead', + ), + ); + console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info); this.started = true; - } catch (error) { - console.error('Bootstrap start error ', error); + this.starting = false; + } else { + console.error(chalk.red('Cannot start an already starting charging stations simulator')); } + } else { + console.error(chalk.red('Cannot start an already started charging stations simulator')); } } public async stop(): Promise { - if (isMainThread && this.started) { - await this.getWorkerImplementationInstance()?.stop(); - // Nullify to force worker implementation instance creation - this.workerImplementationInstance = null; + if (!isMainThread) { + throw new BaseError('Cannot stop charging stations simulator from worker thread'); + } + if (this.started === true) { + if (this.stopping === false) { + this.stopping = true; + await this.uiServer?.sendInternalRequest( + this.uiServer.buildProtocolRequest( + generateUUID(), + ProcedureName.STOP_CHARGING_STATION, + Constants.EMPTY_FREEZED_OBJECT, + ), + ); + await Promise.race([ + waitChargingStationEvents( + this, + ChargingStationWorkerMessageEvents.stopped, + this.numberOfChargingStations, + ), + new Promise((resolve) => { + setTimeout(() => { + const message = `Timeout reached ${formatDurationMilliSeconds( + Constants.STOP_SIMULATOR_TIMEOUT, + )} at stopping charging stations simulator`; + console.warn(chalk.yellow(message)); + resolve(message); + }, Constants.STOP_SIMULATOR_TIMEOUT); + }), + ]); + await this.workerImplementation?.stop(); + this.workerImplementation = null; + this.uiServer?.stop(); + await this.storage?.close(); + this.resetCounters(); + this.initializedCounters = false; + this.started = false; + this.stopping = false; + } else { + console.error(chalk.red('Cannot stop an already stopping charging stations simulator')); + } + } else { + console.error(chalk.red('Cannot stop an already stopped charging stations simulator')); } - this.started = false; } public async restart(): Promise { @@ -76,19 +225,179 @@ export default class Bootstrap { await this.start(); } - private getWorkerImplementationInstance(): WorkerAbstract | null { - if (!this.workerImplementationInstance) { - this.workerImplementationInstance = WorkerFactory.getWorkerImplementation(this.workerScript, Configuration.getWorkerProcess(), + private initializeWorkerImplementation(workerConfiguration: WorkerConfiguration): void { + let elementsPerWorker: number | undefined; + if (workerConfiguration?.elementsPerWorker === 'auto') { + elementsPerWorker = + this.numberOfChargingStations > availableParallelism() + ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5)) + : 1; + } + this.workerImplementation === null && + (this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerScript, + workerConfiguration.processType!, { - startDelay: Configuration.getWorkerStartDelay(), - poolMaxSize: Configuration.getWorkerPoolMaxSize(), - poolMinSize: Configuration.getWorkerPoolMinSize(), - elementsPerWorker: Configuration.getChargingStationsPerWorker(), + workerStartDelay: workerConfiguration.startDelay, + elementStartDelay: workerConfiguration.elementStartDelay, + poolMaxSize: workerConfiguration.poolMaxSize!, + poolMinSize: workerConfiguration.poolMinSize!, + elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number), poolOptions: { - workerChoiceStrategy: Configuration.getWorkerPoolStrategy() - } - }); + messageHandler: this.messageHandler.bind(this) as (message: unknown) => void, + }, + }, + )); + } + + private messageHandler( + msg: ChargingStationWorkerMessage, + ): void { + // logger.debug( + // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( + // msg, + // null, + // 2, + // )}`, + // ); + try { + switch (msg.event) { + case ChargingStationWorkerMessageEvents.started: + this.workerEventStarted(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.stopped: + this.workerEventStopped(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.updated: + this.workerEventUpdated(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.performanceStatistics: + this.workerEventPerformanceStatistics(msg.data as Statistics); + this.emit( + ChargingStationWorkerMessageEvents.performanceStatistics, + msg.data as Statistics, + ); + break; + case ChargingStationWorkerMessageEvents.startWorkerElementError: + logger.error( + `${this.logPrefix()} ${moduleName}.messageHandler: Error occured while starting worker element:`, + msg.data, + ); + this.emit(ChargingStationWorkerMessageEvents.startWorkerElementError, msg.data); + break; + case ChargingStationWorkerMessageEvents.startedWorkerElement: + break; + default: + throw new BaseError( + `Unknown charging station worker event: '${ + msg.event + }' received with data: ${JSON.stringify(msg.data, null, 2)}`, + ); + } + } catch (error) { + logger.error( + `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ + msg.event + }' event:`, + error, + ); } - return this.workerImplementationInstance; } + + 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 initializeCounters() { + if (this.initializedCounters === false) { + this.resetCounters(); + const stationTemplateUrls = Configuration.getStationTemplateUrls()!; + if (isNotEmptyArray(stationTemplateUrls)) { + this.numberOfChargingStationTemplates = stationTemplateUrls.length; + for (const stationTemplateUrl of stationTemplateUrls) { + this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0; + } + } else { + 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'), + ); + process.exit(exitCodes.noChargingStationTemplates); + } + this.initializedCounters = true; + } + } + + private resetCounters(): void { + this.numberOfChargingStationTemplates = 0; + this.numberOfChargingStations = 0; + this.numberOfStartedChargingStations = 0; + } + + private async startChargingStation( + index: number, + stationTemplateUrl: StationTemplateUrl, + ): Promise { + await this.workerImplementation?.addElement({ + index, + templateFile: join( + dirname(fileURLToPath(import.meta.url)), + 'assets', + 'station-templates', + stationTemplateUrl.file, + ), + }); + } + + private gracefulShutdown = (): void => { + console.info(`${chalk.green('Graceful shutdown')}`); + this.stop() + .then(() => { + process.exit(0); + }) + .catch((error) => { + console.error(chalk.red('Error while shutdowning charging stations simulator: '), error); + process.exit(1); + }); + }; + + private logPrefix = (): string => { + return logPrefix(' Bootstrap |'); + }; }