X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=5293a9a83c28a9a1791f166606d3ca275f2cbb67;hb=8f8f87c4fd9a0863d0aeb4a9a8671d1a2b4308e0;hp=6ee606862cb170e8204faa60086bcc1100158543;hpb=be0a4d4d8bd085fcfb86db9ad025de3f270bc31d;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 6ee60686..5293a9a8 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -4,27 +4,29 @@ import { EventEmitter } from 'node:events' import { dirname, extname, join } from 'node:path' import process, { exit } from 'node:process' import { fileURLToPath } from 'node:url' +import { isMainThread } from 'node:worker_threads' import chalk from 'chalk' -import { availableParallelism } from 'poolifier' +import { availableParallelism, type MessageHandler } from 'poolifier' +import type { Worker } from 'worker_threads' -import { waitChargingStationEvents } from './Helpers.js' -import type { AbstractUIServer } from './ui-server/AbstractUIServer.js' -import { UIServerFactory } from './ui-server/UIServerFactory.js' import { version } from '../../package.json' import { BaseError } from '../exception/index.js' import { type Storage, StorageFactory } from '../performance/index.js' import { type ChargingStationData, + type ChargingStationInfo, + type ChargingStationOptions, type ChargingStationWorkerData, type ChargingStationWorkerMessage, type ChargingStationWorkerMessageData, ChargingStationWorkerMessageEvents, ConfigurationSection, ProcedureName, - type StationTemplateUrl, + type SimulatorState, type Statistics, type StorageConfiguration, + type TemplateStatistics, type UIServerConfiguration, type WorkerConfiguration } from '../types/index.js' @@ -37,33 +39,35 @@ import { handleUnhandledRejection, isAsyncFunction, isNotEmptyArray, - logPrefix, - logger + logger, + logPrefix } from '../utils/index.js' -import { type WorkerAbstract, WorkerFactory } from '../worker/index.js' +import { DEFAULT_ELEMENTS_PER_WORKER, type WorkerAbstract, WorkerFactory } from '../worker/index.js' +import { buildTemplateName, waitChargingStationEvents } from './Helpers.js' +import type { AbstractUIServer } from './ui-server/AbstractUIServer.js' +import { UIServerFactory } from './ui-server/UIServerFactory.js' const moduleName = 'Bootstrap' enum exitCodes { succeeded = 0, missingChargingStationsConfiguration = 1, - noChargingStationTemplates = 2, - gracefulShutdownError = 3 + duplicateChargingStationTemplateUrls = 2, + noChargingStationTemplates = 3, + gracefulShutdownError = 4 } 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 workerImplementation?: WorkerAbstract + private readonly uiServer: AbstractUIServer private storage?: Storage - private numberOfStartedChargingStations!: number + private readonly templateStatistics: Map private readonly version: string = version - private initializedCounters: boolean private started: boolean private starting: boolean private stopping: boolean + private uiServerStarted: boolean private constructor () { super() @@ -76,13 +80,19 @@ export class Bootstrap extends EventEmitter { this.started = false this.starting = false this.stopping = false - this.initializedCounters = false - this.initializeCounters() + this.uiServerStarted = false + this.templateStatistics = new Map() this.uiServer = UIServerFactory.getUIServerImplementation( Configuration.getConfigurationSection(ConfigurationSection.uiServer) ) + this.initializeCounters() + this.initializeWorkerImplementation( + Configuration.getConfigurationSection(ConfigurationSection.worker) + ) Configuration.configurationChangeCallback = async () => { - await Bootstrap.getInstance().restart(false) + if (isMainThread) { + await Bootstrap.getInstance().restart() + } } } @@ -93,10 +103,70 @@ export class Bootstrap extends EventEmitter { return Bootstrap.instance } + public get numberOfChargingStationTemplates (): number { + return this.templateStatistics.size + } + + public get numberOfConfiguredChargingStations (): number { + return [...this.templateStatistics.values()].reduce( + (accumulator, value) => accumulator + value.configured, + 0 + ) + } + + public get numberOfProvisionedChargingStations (): number { + return [...this.templateStatistics.values()].reduce( + (accumulator, value) => accumulator + value.provisioned, + 0 + ) + } + + public getState (): SimulatorState { + return { + version: this.version, + configuration: Configuration.getConfigurationData(), + started: this.started, + templateStatistics: this.templateStatistics + } + } + + public getLastIndex (templateName: string): number { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const indexes = [...this.templateStatistics.get(templateName)!.indexes] + .concat(0) + .sort((a, b) => a - b) + for (let i = 0; i < indexes.length - 1; i++) { + if (indexes[i + 1] - indexes[i] !== 1) { + return indexes[i] + } + } + return indexes[indexes.length - 1] + } + + public getPerformanceStatistics (): IterableIterator | undefined { + return this.storage?.getPerformanceStatistics() + } + + private get numberOfAddedChargingStations (): number { + return [...this.templateStatistics.values()].reduce( + (accumulator, value) => accumulator + value.added, + 0 + ) + } + + private get numberOfStartedChargingStations (): number { + return [...this.templateStatistics.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.deleted, this.workerEventDeleted) this.on(ChargingStationWorkerMessageEvents.started, this.workerEventStarted) this.on(ChargingStationWorkerMessageEvents.stopped, this.workerEventStopped) this.on(ChargingStationWorkerMessageEvents.updated, this.workerEventUpdated) @@ -104,12 +174,12 @@ export class Bootstrap extends EventEmitter { ChargingStationWorkerMessageEvents.performanceStatistics, this.workerEventPerformanceStatistics ) - this.initializeCounters() - const workerConfiguration = Configuration.getConfigurationSection( - ConfigurationSection.worker - ) - this.initializeWorkerImplementation(workerConfiguration) - await this.workerImplementation?.start() + // eslint-disable-next-line @typescript-eslint/unbound-method + if (isAsyncFunction(this.workerImplementation?.start)) { + await this.workerImplementation.start() + } else { + (this.workerImplementation?.start as () => void)() + } const performanceStorageConfiguration = Configuration.getConfigurationSection( ConfigurationSection.performanceStorage @@ -124,15 +194,22 @@ export class Bootstrap extends EventEmitter { ) await this.storage?.open() } - Configuration.getConfigurationSection(ConfigurationSection.uiServer) - .enabled === true && this.uiServer?.start() + if ( + !this.uiServerStarted && + Configuration.getConfigurationSection( + ConfigurationSection.uiServer + ).enabled === true + ) { + this.uiServer.start() + this.uiServerStarted = true + } // Start ChargingStation object instance in worker thread // eslint-disable-next-line @typescript-eslint/no-non-null-assertion for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) { try { const nbStations = stationTemplateUrl.numberOfStations for (let index = 1; index <= nbStations; index++) { - await this.startChargingStation(index, stationTemplateUrl) + await this.addChargingStation(index, stationTemplateUrl.file) } } catch (error) { console.error( @@ -143,18 +220,17 @@ export class Bootstrap extends EventEmitter { ) } } + const workerConfiguration = Configuration.getConfigurationSection( + ConfigurationSection.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()}/` - : '' + } started with ${this.numberOfConfiguredChargingStations} configured and ${this.numberOfProvisionedChargingStations} provisioned 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${ this.workerImplementation?.maxElementsPerWorker != null ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` @@ -179,31 +255,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() + this.uiServer.clearCaches() await this.storage?.close() delete this.storage - this.resetCounters() - this.initializedCounters = false this.started = false this.stopping = false } else { @@ -214,15 +286,26 @@ export class Bootstrap extends EventEmitter { } } - public async restart (stopChargingStations?: boolean): Promise { - await this.stop(stopChargingStations) - Configuration.getConfigurationSection(ConfigurationSection.uiServer) - .enabled === false && this.uiServer?.stop() + private async restart (): Promise { + await this.stop() + if ( + this.uiServerStarted && + Configuration.getConfigurationSection(ConfigurationSection.uiServer) + .enabled !== true + ) { + this.uiServer.stop() + this.uiServerStarted = false + } + this.initializeCounters() + // FIXME: initialize worker implementation only if the worker section has changed + this.initializeWorkerImplementation( + Configuration.getConfigurationSection(ConfigurationSection.worker) + ) await this.start() } private async waitChargingStationsStopped (): Promise { - return await new Promise((resolve, reject) => { + return await new Promise((resolve, reject: (reason?: unknown) => void) => { const waitTimeout = setTimeout(() => { const timeoutMessage = `Timeout ${formatDurationMilliSeconds( Constants.STOP_CHARGING_STATIONS_TIMEOUT @@ -246,19 +329,33 @@ export class Bootstrap extends EventEmitter { } private initializeWorkerImplementation (workerConfiguration: WorkerConfiguration): void { - let elementsPerWorker: number | undefined + if (!isMainThread) { + return + } + let elementsPerWorker: number switch (workerConfiguration.elementsPerWorker) { + case 'all': + elementsPerWorker = + this.numberOfConfiguredChargingStations + this.numberOfProvisionedChargingStations + break case 'auto': elementsPerWorker = - this.numberOfChargingStations > availableParallelism() - ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5)) + this.numberOfConfiguredChargingStations + this.numberOfProvisionedChargingStations > + availableParallelism() + ? Math.round( + (this.numberOfConfiguredChargingStations + + this.numberOfProvisionedChargingStations) / + (availableParallelism() * 1.5) + ) : 1 break - case 'all': - elementsPerWorker = this.numberOfChargingStations - break + default: + elementsPerWorker = workerConfiguration.elementsPerWorker ?? DEFAULT_ELEMENTS_PER_WORKER } - this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerImplementation = WorkerFactory.getWorkerImplementation< + ChargingStationWorkerData, + ChargingStationInfo + >( join( dirname(fileURLToPath(import.meta.url)), `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}` @@ -267,15 +364,17 @@ export class Bootstrap extends EventEmitter { workerConfiguration.processType!, { workerStartDelay: workerConfiguration.startDelay, - elementStartDelay: workerConfiguration.elementStartDelay, + elementAddDelay: workerConfiguration.elementAddDelay, // eslint-disable-next-line @typescript-eslint/no-non-null-assertion poolMaxSize: workerConfiguration.poolMaxSize!, // eslint-disable-next-line @typescript-eslint/no-non-null-assertion poolMinSize: workerConfiguration.poolMinSize!, - elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number), + elementsPerWorker, poolOptions: { - messageHandler: this.messageHandler.bind(this) as (message: unknown) => void, - workerOptions: { resourceLimits: workerConfiguration.resourceLimits } + messageHandler: this.messageHandler.bind(this) as MessageHandler, + ...(workerConfiguration.resourceLimits != null && { + workerOptions: { resourceLimits: workerConfiguration.resourceLimits } + }) } } ) @@ -285,81 +384,105 @@ export class Bootstrap extends EventEmitter { msg: ChargingStationWorkerMessage ): void { // logger.debug( - // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( + // `${this.logPrefix()} ${moduleName}.messageHandler: Charging station worker message received: ${JSON.stringify( // msg, // undefined, // 2 // )}` // ) + // Skip worker message events processing + // eslint-disable-next-line @typescript-eslint/dot-notation + if (msg['uuid'] != null) { + return + } + const { event, data } = msg try { - switch (msg.event) { + switch (event) { + case ChargingStationWorkerMessageEvents.added: + this.emit(ChargingStationWorkerMessageEvents.added, data) + break + case ChargingStationWorkerMessageEvents.deleted: + this.emit(ChargingStationWorkerMessageEvents.deleted, data) + break case ChargingStationWorkerMessageEvents.started: - this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData) + this.emit(ChargingStationWorkerMessageEvents.started, data) break case ChargingStationWorkerMessageEvents.stopped: - this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData) + this.emit(ChargingStationWorkerMessageEvents.stopped, data) break case ChargingStationWorkerMessageEvents.updated: - this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData) + this.emit(ChargingStationWorkerMessageEvents.updated, data) break case ChargingStationWorkerMessageEvents.performanceStatistics: - 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: + this.emit(ChargingStationWorkerMessageEvents.performanceStatistics, data) break default: throw new BaseError( - `Unknown charging station worker event: '${ - msg.event - }' received with data: ${JSON.stringify(msg.data, undefined, 2)}` + `Unknown charging station worker message event: '${event}' received with data: ${JSON.stringify(data, undefined, 2)}` ) } } catch (error) { logger.error( - `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ - msg.event - }' event:`, + `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling charging station worker message event '${event}':`, error ) } } + private readonly workerEventAdded = (data: ChargingStationData): void => { + this.uiServer.chargingStations.set(data.stationInfo.hashId, data) + logger.info( + `${this.logPrefix()} ${moduleName}.workerEventAdded: Charging station ${ + data.stationInfo.chargingStationId + } (hashId: ${data.stationInfo.hashId}) added (${ + this.numberOfAddedChargingStations + } added from ${this.numberOfConfiguredChargingStations} configured and ${this.numberOfProvisionedChargingStations} provisioned charging station(s))` + ) + } + + private readonly workerEventDeleted = (data: ChargingStationData): void => { + this.uiServer.chargingStations.delete(data.stationInfo.hashId) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const templateStatistics = this.templateStatistics.get(data.stationInfo.templateName)! + --templateStatistics.added + templateStatistics.indexes.delete(data.stationInfo.templateIndex) + logger.info( + `${this.logPrefix()} ${moduleName}.workerEventDeleted: Charging station ${ + data.stationInfo.chargingStationId + } (hashId: ${data.stationInfo.hashId}) deleted (${ + this.numberOfAddedChargingStations + } added from ${this.numberOfConfiguredChargingStations} configured and ${this.numberOfProvisionedChargingStations} provisioned charging station(s))` + ) + } + private readonly workerEventStarted = (data: ChargingStationData): void => { - this.uiServer?.chargingStations.set(data.stationInfo.hashId, data) - ++this.numberOfStartedChargingStations + this.uiServer.chargingStations.set(data.stationInfo.hashId, data) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ++this.templateStatistics.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 + this.uiServer.chargingStations.set(data.stationInfo.hashId, data) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + --this.templateStatistics.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))` ) } private readonly workerEventUpdated = (data: ChargingStationData): void => { - this.uiServer?.chargingStations.set(data.stationInfo.hashId, data) + this.uiServer.chargingStations.set(data.stationInfo.hashId, data) } private readonly workerEventPerformanceStatistics = (data: Statistics): void => { @@ -378,56 +501,81 @@ export class Bootstrap extends EventEmitter { } 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 - } - } else { - console.warn( - chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting") - ) - exit(exitCodes.missingChargingStationsConfiguration) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const stationTemplateUrls = Configuration.getStationTemplateUrls()! + if (isNotEmptyArray(stationTemplateUrls)) { + for (const stationTemplateUrl of stationTemplateUrls) { + const templateName = buildTemplateName(stationTemplateUrl.file) + this.templateStatistics.set(templateName, { + configured: stationTemplateUrl.numberOfStations, + provisioned: stationTemplateUrl.provisionedNumberOfStations ?? 0, + added: 0, + started: 0, + indexes: new Set() + }) + this.uiServer.chargingStationTemplates.add(templateName) } - if (this.numberOfChargingStations === 0) { - console.warn(chalk.yellow('No charging station template enabled in configuration, exiting')) - exit(exitCodes.noChargingStationTemplates) + if (this.templateStatistics.size !== stationTemplateUrls.length) { + console.error( + chalk.red( + "'stationTemplateUrls' contains duplicate entries, please check your configuration" + ) + ) + exit(exitCodes.duplicateChargingStationTemplateUrls) } - this.initializedCounters = true + } else { + console.error( + chalk.red("'stationTemplateUrls' not defined or empty, please check your configuration") + ) + exit(exitCodes.missingChargingStationsConfiguration) + } + 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) } } - private resetCounters (): void { - this.numberOfChargingStationTemplates = 0 - this.numberOfChargingStations = 0 - this.numberOfStartedChargingStations = 0 - } - - private async startChargingStation ( + public async addChargingStation ( index: number, - stationTemplateUrl: StationTemplateUrl - ): Promise { - await this.workerImplementation?.addElement({ + templateFile: string, + options?: ChargingStationOptions + ): Promise { + if (!this.started && !this.starting) { + throw new BaseError( + 'Cannot add charging station while the charging stations simulator is not started' + ) + } + const stationInfo = await this.workerImplementation?.addElement({ index, templateFile: join( dirname(fileURLToPath(import.meta.url)), 'assets', 'station-templates', - stationTemplateUrl.file - ) + templateFile + ), + options }) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const templateStatistics = this.templateStatistics.get(buildTemplateName(templateFile))! + ++templateStatistics.added + templateStatistics.indexes.add(index) + return stationInfo } private gracefulShutdown (): void { this.stop() .then(() => { console.info(chalk.green('Graceful shutdown')) - this.uiServer?.stop() - // stop() asks for charging stations to stop by default + this.uiServer.stop() + this.uiServerStarted = false this.waitChargingStationsStopped() .then(() => { exit(exitCodes.succeeded) @@ -436,7 +584,7 @@ export class Bootstrap extends EventEmitter { exit(exitCodes.gracefulShutdownError) }) }) - .catch(error => { + .catch((error: unknown) => { console.error(chalk.red('Error while shutdowning charging stations simulator: '), error) exit(exitCodes.gracefulShutdownError) })