X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcharging-station%2FBootstrap.ts;h=2c1b0f43b3443f8f239888b7f4e507ad6eefd584;hb=a66bbcfe85550dc01a2e32bd17a52f5980a78193;hp=731cc477d7a406d8165c8764ea851bc06115bafe;hpb=66a7748ddeda8c94d7562a1ce58d440319654a4c;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 731cc477..2c1b0f43 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,12 +1,14 @@ -// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. +// Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved. import { EventEmitter } from 'node:events' -import { dirname, extname, join } from 'node:path' +import { dirname, extname, join, parse } from 'node:path' import process, { exit } from 'node:process' import { fileURLToPath } from 'node:url' +import { isMainThread } from 'node:worker_threads' +import type { Worker } from 'worker_threads' import chalk from 'chalk' -import { availableParallelism } from 'poolifier' +import { type MessageHandler, availableParallelism } from 'poolifier' import { waitChargingStationEvents } from './Helpers.js' import type { AbstractUIServer } from './ui-server/AbstractUIServer.js' @@ -17,12 +19,12 @@ import { type Storage, StorageFactory } from '../performance/index.js' import { type ChargingStationData, type ChargingStationWorkerData, + type ChargingStationWorkerEventError, type ChargingStationWorkerMessage, type ChargingStationWorkerMessageData, ChargingStationWorkerMessageEvents, ConfigurationSection, ProcedureName, - type StationTemplateUrl, type Statistics, type StorageConfiguration, type UIServerConfiguration, @@ -35,10 +37,11 @@ import { generateUUID, handleUncaughtException, handleUnhandledRejection, + isAsyncFunction, isNotEmptyArray, - isNullOrUndefined, logPrefix, - logger + logger, + max } from '../utils/index.js' import { type WorkerAbstract, WorkerFactory } from '../worker/index.js' @@ -47,18 +50,24 @@ const moduleName = 'Bootstrap' enum exitCodes { succeeded = 0, missingChargingStationsConfiguration = 1, - noChargingStationTemplates = 2, - gracefulShutdownError = 3 + duplicateChargingStationTemplateUrls = 2, + noChargingStationTemplates = 3, + gracefulShutdownError = 4 +} + +interface TemplateChargingStations { + configured: number + added: number + started: number + lastIndex: number } export class Bootstrap extends EventEmitter { private static instance: Bootstrap | null = null - public numberOfChargingStations!: number - public numberOfChargingStationTemplates!: number private workerImplementation?: WorkerAbstract private readonly uiServer?: AbstractUIServer private storage?: Storage - private numberOfStartedChargingStations!: number + private readonly chargingStationsByTemplate: Map private readonly version: string = version private initializedCounters: boolean private started: boolean @@ -76,13 +85,16 @@ export class Bootstrap extends EventEmitter { this.started = false this.starting = false this.stopping = false - this.initializedCounters = false - this.initializeCounters() + this.chargingStationsByTemplate = new Map() this.uiServer = UIServerFactory.getUIServerImplementation( Configuration.getConfigurationSection(ConfigurationSection.uiServer) ) + this.initializedCounters = false + this.initializeCounters() Configuration.configurationChangeCallback = async () => { - await Bootstrap.getInstance().restart(false) + if (isMainThread) { + await Bootstrap.getInstance().restart() + } } } @@ -93,10 +105,44 @@ export class Bootstrap extends EventEmitter { return Bootstrap.instance } + public get numberOfChargingStationTemplates (): number { + return this.chargingStationsByTemplate.size + } + + public get numberOfConfiguredChargingStations (): number { + return [...this.chargingStationsByTemplate.values()].reduce( + (accumulator, value) => accumulator + value.configured, + 0 + ) + } + + public getLastIndex (templateName: string): number { + return this.chargingStationsByTemplate.get(templateName)?.lastIndex ?? 0 + } + + public getPerformanceStatistics (): IterableIterator | undefined { + return this.storage?.getPerformanceStatistics() + } + + private get numberOfAddedChargingStations (): number { + return [...this.chargingStationsByTemplate.values()].reduce( + (accumulator, value) => accumulator + value.added, + 0 + ) + } + + private get numberOfStartedChargingStations (): number { + return [...this.chargingStationsByTemplate.values()].reduce( + (accumulator, value) => accumulator + value.started, + 0 + ) + } + public async start (): Promise { if (!this.started) { if (!this.starting) { this.starting = true + this.on(ChargingStationWorkerMessageEvents.added, this.workerEventAdded) this.on(ChargingStationWorkerMessageEvents.started, this.workerEventStarted) this.on(ChargingStationWorkerMessageEvents.stopped, this.workerEventStopped) this.on(ChargingStationWorkerMessageEvents.updated, this.workerEventUpdated) @@ -130,9 +176,11 @@ export class Bootstrap extends EventEmitter { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) { try { - const nbStations = stationTemplateUrl.numberOfStations ?? 0 + const nbStations = + this.chargingStationsByTemplate.get(parse(stationTemplateUrl.file).name) + ?.configured ?? stationTemplateUrl.numberOfStations for (let index = 1; index <= nbStations; index++) { - await this.startChargingStation(index, stationTemplateUrl) + await this.addChargingStation(index, stationTemplateUrl.file) } } catch (error) { console.error( @@ -147,17 +195,13 @@ export class Bootstrap extends EventEmitter { 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()}/` - : '' + } started with ${this.numberOfConfiguredChargingStations} configured charging station(s) from ${this.numberOfChargingStationTemplates} charging station template(s) and ${ + Configuration.workerDynamicPoolInUse() ? `${workerConfiguration.poolMinSize}/` : '' }${this.workerImplementation?.size}${ - Configuration.workerPoolInUse() - ? `/${workerConfiguration.poolMaxSize?.toString()}` - : '' + Configuration.workerPoolInUse() ? `/${workerConfiguration.poolMaxSize}` : '' } worker(s) concurrently running in '${workerConfiguration.processType}' mode${ - !isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker) - ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)` + this.workerImplementation?.maxElementsPerWorker != null + ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` : '' }` ) @@ -179,31 +223,27 @@ export class Bootstrap extends EventEmitter { } } - public async stop (stopChargingStations = true): Promise { + public async stop (): Promise { if (this.started) { if (!this.stopping) { this.stopping = true - if (stopChargingStations) { - await this.uiServer?.sendInternalRequest( - this.uiServer.buildProtocolRequest( - generateUUID(), - ProcedureName.STOP_CHARGING_STATION, - Constants.EMPTY_FROZEN_OBJECT - ) + await this.uiServer?.sendInternalRequest( + this.uiServer.buildProtocolRequest( + generateUUID(), + ProcedureName.STOP_CHARGING_STATION, + Constants.EMPTY_FROZEN_OBJECT ) - try { - await this.waitChargingStationsStopped() - } catch (error) { - console.error(chalk.red('Error while waiting for charging stations to stop: '), error) - } + ) + try { + await this.waitChargingStationsStopped() + } catch (error) { + console.error(chalk.red('Error while waiting for charging stations to stop: '), error) } await this.workerImplementation?.stop() delete this.workerImplementation this.removeAllListeners() await this.storage?.close() delete this.storage - this.resetCounters() - this.initializedCounters = false this.started = false this.stopping = false } else { @@ -214,26 +254,27 @@ export class Bootstrap extends EventEmitter { } } - public async restart (stopChargingStations?: boolean): Promise { - await this.stop(stopChargingStations) + private async restart (): Promise { + await this.stop() Configuration.getConfigurationSection(ConfigurationSection.uiServer) - .enabled === false && this.uiServer?.stop() + .enabled !== true && this.uiServer?.stop() + this.initializedCounters = false await this.start() } private async waitChargingStationsStopped (): Promise { return await new Promise((resolve, reject) => { const waitTimeout = setTimeout(() => { - const message = `Timeout ${formatDurationMilliSeconds( + const timeoutMessage = `Timeout ${formatDurationMilliSeconds( Constants.STOP_CHARGING_STATIONS_TIMEOUT )} reached at stopping charging stations` - console.warn(chalk.yellow(message)) - reject(new Error(message)) + console.warn(chalk.yellow(timeoutMessage)) + reject(new Error(timeoutMessage)) }, Constants.STOP_CHARGING_STATIONS_TIMEOUT) waitChargingStationEvents( this, ChargingStationWorkerMessageEvents.stopped, - this.numberOfChargingStations + this.numberOfStartedChargingStations ) .then(() => { resolve('Charging stations stopped') @@ -246,16 +287,19 @@ export class Bootstrap extends EventEmitter { } private initializeWorkerImplementation (workerConfiguration: WorkerConfiguration): void { + if (!isMainThread) { + return + } let elementsPerWorker: number | undefined - switch (workerConfiguration?.elementsPerWorker) { + switch (workerConfiguration.elementsPerWorker) { case 'auto': elementsPerWorker = - this.numberOfChargingStations > availableParallelism() - ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5)) + this.numberOfConfiguredChargingStations > availableParallelism() + ? Math.round(this.numberOfConfiguredChargingStations / (availableParallelism() * 1.5)) : 1 break case 'all': - elementsPerWorker = this.numberOfChargingStations + elementsPerWorker = this.numberOfConfiguredChargingStations break } this.workerImplementation = WorkerFactory.getWorkerImplementation( @@ -274,7 +318,7 @@ export class Bootstrap extends EventEmitter { poolMinSize: workerConfiguration.poolMinSize!, elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number), poolOptions: { - messageHandler: this.messageHandler.bind(this) as (message: unknown) => void, + messageHandler: this.messageHandler.bind(this) as MessageHandler, workerOptions: { resourceLimits: workerConfiguration.resourceLimits } } } @@ -293,6 +337,9 @@ export class Bootstrap extends EventEmitter { // ) try { switch (msg.event) { + case ChargingStationWorkerMessageEvents.added: + this.emit(ChargingStationWorkerMessageEvents.added, msg.data as ChargingStationData) + break case ChargingStationWorkerMessageEvents.started: this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData) break @@ -308,14 +355,14 @@ export class Bootstrap extends EventEmitter { msg.data as Statistics ) break - case ChargingStationWorkerMessageEvents.startWorkerElementError: + case ChargingStationWorkerMessageEvents.addedWorkerElement: + break + case ChargingStationWorkerMessageEvents.workerElementError: logger.error( - `${this.logPrefix()} ${moduleName}.messageHandler: Error occured while starting worker element:`, + `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${(msg.data as ChargingStationWorkerEventError).event}' event on worker:`, msg.data ) - this.emit(ChargingStationWorkerMessageEvents.startWorkerElementError, msg.data) - break - case ChargingStationWorkerMessageEvents.startedWorkerElement: + this.emit(ChargingStationWorkerMessageEvents.workerElementError, msg.data) break default: throw new BaseError( @@ -334,27 +381,42 @@ export class Bootstrap extends EventEmitter { } } + private readonly workerEventAdded = (data: ChargingStationData): void => { + this.uiServer?.chargingStations.set(data.stationInfo.hashId, data) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ++this.chargingStationsByTemplate.get(data.stationInfo.templateName)!.added + logger.info( + `${this.logPrefix()} ${moduleName}.workerEventAdded: Charging station ${ + data.stationInfo.chargingStationId + } (hashId: ${data.stationInfo.hashId}) added (${ + this.numberOfAddedChargingStations + } added from ${this.numberOfConfiguredChargingStations} configured charging station(s))` + ) + } + private readonly workerEventStarted = (data: ChargingStationData): void => { this.uiServer?.chargingStations.set(data.stationInfo.hashId, data) - ++this.numberOfStartedChargingStations + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ++this.chargingStationsByTemplate.get(data.stationInfo.templateName)!.started logger.info( `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${ data.stationInfo.chargingStationId } (hashId: ${data.stationInfo.hashId}) started (${ this.numberOfStartedChargingStations - } started from ${this.numberOfChargingStations})` + } started from ${this.numberOfAddedChargingStations} added charging station(s))` ) } private readonly workerEventStopped = (data: ChargingStationData): void => { this.uiServer?.chargingStations.set(data.stationInfo.hashId, data) - --this.numberOfStartedChargingStations + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + --this.chargingStationsByTemplate.get(data.stationInfo.templateName)!.started logger.info( `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${ data.stationInfo.chargingStationId } (hashId: ${data.stationInfo.hashId}) stopped (${ this.numberOfStartedChargingStations - } started from ${this.numberOfChargingStations})` + } started from ${this.numberOfAddedChargingStations} added charging station(s))` ) } @@ -363,60 +425,87 @@ export class Bootstrap extends EventEmitter { } private readonly workerEventPerformanceStatistics = (data: Statistics): void => { - this.storage?.storePerformanceStatistics(data) as undefined + // eslint-disable-next-line @typescript-eslint/unbound-method + if (isAsyncFunction(this.storage?.storePerformanceStatistics)) { + ( + this.storage.storePerformanceStatistics as ( + performanceStatistics: Statistics + ) => Promise + )(data).catch(Constants.EMPTY_FUNCTION) + } else { + (this.storage?.storePerformanceStatistics as (performanceStatistics: Statistics) => void)( + data + ) + } } private initializeCounters (): void { if (!this.initializedCounters) { - this.resetCounters() // eslint-disable-next-line @typescript-eslint/no-non-null-assertion const stationTemplateUrls = Configuration.getStationTemplateUrls()! if (isNotEmptyArray(stationTemplateUrls)) { - this.numberOfChargingStationTemplates = stationTemplateUrls.length for (const stationTemplateUrl of stationTemplateUrls) { - this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0 + const templateName = parse(stationTemplateUrl.file).name + this.chargingStationsByTemplate.set(templateName, { + configured: stationTemplateUrl.numberOfStations, + added: 0, + started: 0, + lastIndex: 0 + }) + this.uiServer?.chargingStationTemplates.add(templateName) + } + if (this.chargingStationsByTemplate.size !== stationTemplateUrls.length) { + console.error( + chalk.red( + "'stationTemplateUrls' contains duplicate entries, please check your configuration" + ) + ) + exit(exitCodes.duplicateChargingStationTemplateUrls) } } else { - console.warn( - chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting") + console.error( + chalk.red("'stationTemplateUrls' not defined or empty, please check your configuration") ) exit(exitCodes.missingChargingStationsConfiguration) } - if (this.numberOfChargingStations === 0) { - console.warn(chalk.yellow('No charging station template enabled in configuration, exiting')) + if ( + this.numberOfConfiguredChargingStations === 0 && + Configuration.getConfigurationSection(ConfigurationSection.uiServer) + .enabled !== true + ) { + console.error( + chalk.red( + "'stationTemplateUrls' has no charging station enabled and UI server is disabled, please check your configuration" + ) + ) 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 { + public async addChargingStation (index: number, stationTemplateFile: string): Promise { await this.workerImplementation?.addElement({ index, templateFile: join( dirname(fileURLToPath(import.meta.url)), 'assets', 'station-templates', - stationTemplateUrl.file + stationTemplateFile ) }) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + this.chargingStationsByTemplate.get(parse(stationTemplateFile).name)!.lastIndex = max( + index, + this.chargingStationsByTemplate.get(parse(stationTemplateFile).name)?.lastIndex ?? -Infinity + ) } private gracefulShutdown (): void { this.stop() .then(() => { - console.info(`${chalk.green('Graceful shutdown')}`) + console.info(chalk.green('Graceful shutdown')) this.uiServer?.stop() - // stop() asks for charging stations to stop by default this.waitChargingStationsStopped() .then(() => { exit(exitCodes.succeeded) @@ -425,7 +514,7 @@ export class Bootstrap extends EventEmitter { exit(exitCodes.gracefulShutdownError) }) }) - .catch((error) => { + .catch(error => { console.error(chalk.red('Error while shutdowning charging stations simulator: '), error) exit(exitCodes.gracefulShutdownError) })