X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=4f72d6dfdffef0ca7a65cb24a2103f19558ced6f;hb=3b09e788c6dab8e5a8b3314e8e69ede16ff82fcc;hp=4e8b43a9dffb309dc2558cbb909d47ad359185da;hpb=1d8f226b47637e80c74106799208da5df93b2a04;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 4e8b43a9..4f72d6df 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,33 +1,36 @@ -// 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 { fileURLToPath } from 'node:url'; -import { isMainThread } from 'node:worker_threads'; +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 chalk from 'chalk' +import { availableParallelism, type MessageHandler } from 'poolifier' +import type { Worker } from 'worker_threads' -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 { 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 ChargingStationWorkerEventError, type ChargingStationWorkerMessage, type ChargingStationWorkerMessageData, ChargingStationWorkerMessageEvents, ConfigurationSection, ProcedureName, - type StationTemplateUrl, + type SimulatorState, type Statistics, type StorageConfiguration, + type TemplateStatistics, type UIServerConfiguration, - type WorkerConfiguration, -} from '../types'; + type WorkerConfiguration +} from '../types/index.js' import { Configuration, Constants, @@ -35,371 +38,557 @@ import { generateUUID, handleUncaughtException, handleUnhandledRejection, + isAsyncFunction, isNotEmptyArray, - isNullOrUndefined, - logPrefix, logger, -} from '../utils'; -import { type WorkerAbstract, WorkerFactory } from '../worker'; + logPrefix +} from '../utils/index.js' +import { 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'; +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 | 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 starting: boolean; - private stopping: boolean; - private readonly workerScript: string; + private static instance: Bootstrap | null = null + private workerImplementation?: WorkerAbstract + private readonly uiServer: AbstractUIServer + private storage?: Storage + private readonly templateStatistics: Map + private readonly version: string = version + private started: boolean + private starting: boolean + private stopping: boolean + private uiServerStarted: boolean - private constructor() { - super(); + private constructor () { + super() for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) { - process.on(signal, this.gracefulShutdown); + process.on(signal, this.gracefulShutdown.bind(this)) } // Enable unconditionally for now - handleUnhandledRejection(); - handleUncaughtException(); - this.started = false; - 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.configurationChangeCallback = async () => Bootstrap.getInstance().restart(); + handleUnhandledRejection() + handleUncaughtException() + this.started = false + this.starting = false + this.stopping = false + 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 () => { + if (isMainThread) { + await Bootstrap.getInstance().restart() + } + } } - public static getInstance(): Bootstrap { + public static getInstance (): Bootstrap { if (Bootstrap.instance === null) { - Bootstrap.instance = new Bootstrap(); + Bootstrap.instance = new Bootstrap() } - return Bootstrap.instance; + return Bootstrap.instance } - public async start(): Promise { - if (!isMainThread) { - throw new BaseError('Cannot start charging stations simulator from worker thread'); + public get numberOfChargingStationTemplates (): number { + return this.templateStatistics.size + } + + public get numberOfConfiguredChargingStations (): number { + return [...this.templateStatistics.values()].reduce( + (accumulator, value) => accumulator + value.configured, + 0 + ) + } + + public getState (): SimulatorState { + return { + version: this.version, + started: this.started, + templateStatistics: this.templateStatistics } - 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(); + } + + 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) + this.on( + ChargingStationWorkerMessageEvents.performanceStatistics, + this.workerEventPerformanceStatistics + ) + this.on( + ChargingStationWorkerMessageEvents.workerElementError, + (eventError: ChargingStationWorkerEventError) => { + logger.error( + `${this.logPrefix()} ${moduleName}.start: Error occurred while handling '${eventError.event}' event on worker:`, + eventError + ) + } + ) + // 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 + ) + if (performanceStorageConfiguration.enabled === true) { + this.storage = StorageFactory.getStorage( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + performanceStorageConfiguration.type!, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + performanceStorageConfiguration.uri!, + this.logPrefix() + ) + await this.storage?.open() + } + 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 ?? 0; + 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( chalk.red( - `Error at starting charging station with template file ${stationTemplateUrl.file}: `, + `Error at starting charging station with template file ${stationTemplateUrl.file}: ` ), - error, - ); + error + ) } } + 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 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)` : '' - }`, - ), - ); + }` + ) + ) 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 fixed pool or worker set mode instead', - ), - ); - console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info); - this.started = true; - this.starting = false; + 'Charging stations simulator is using dynamic pool mode. This is an experimental feature with known issues.\nPlease consider using fixed pool or worker set mode instead' + ) + ) + console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info) + this.started = true + this.starting = false } else { - console.error(chalk.red('Cannot start an already starting charging stations simulator')); + 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')); + console.error(chalk.red('Cannot start an already started charging stations simulator')) } } - public async stop(): Promise { - 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( + public async stop (): Promise { + if (this.started) { + if (!this.stopping) { + this.stopping = true + await this.uiServer.sendInternalRequest( this.uiServer.buildProtocolRequest( generateUUID(), ProcedureName.STOP_CHARGING_STATION, - Constants.EMPTY_FROZEN_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; + Constants.EMPTY_FROZEN_OBJECT + ) + ) + try { + await this.waitChargingStationsStopped() + } catch (error) { + console.error(chalk.red('Error while waiting for charging stations to stop: '), error) + } + await this.workerImplementation?.stop() + this.removeAllListeners() + this.uiServer.clearCaches() + await this.storage?.close() + delete this.storage + this.started = false + this.stopping = false } else { - console.error(chalk.red('Cannot stop an already stopping charging stations simulator')); + 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')); + console.error(chalk.red('Cannot stop an already stopped charging stations simulator')) + } + } + + 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() } - public async restart(): Promise { - await this.stop(); - await this.start(); + private async waitChargingStationsStopped (): Promise { + return await new Promise((resolve, reject: (reason?: unknown) => void) => { + const waitTimeout = setTimeout(() => { + const timeoutMessage = `Timeout ${formatDurationMilliSeconds( + Constants.STOP_CHARGING_STATIONS_TIMEOUT + )} reached at stopping charging stations` + console.warn(chalk.yellow(timeoutMessage)) + reject(new Error(timeoutMessage)) + }, Constants.STOP_CHARGING_STATIONS_TIMEOUT) + waitChargingStationEvents( + this, + ChargingStationWorkerMessageEvents.stopped, + this.numberOfStartedChargingStations + ) + .then(() => { + resolve('Charging stations stopped') + }) + .catch(reject) + .finally(() => { + clearTimeout(waitTimeout) + }) + }) } - 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; + private initializeWorkerImplementation (workerConfiguration: WorkerConfiguration): void { + if (!isMainThread) { + return + } + let elementsPerWorker: number + switch (workerConfiguration.elementsPerWorker) { + case 'all': + elementsPerWorker = this.numberOfConfiguredChargingStations + break + case 'auto': + default: + elementsPerWorker = + this.numberOfConfiguredChargingStations > availableParallelism() + ? Math.round(this.numberOfConfiguredChargingStations / (availableParallelism() * 1.5)) + : 1 + break } - this.workerImplementation === null && - (this.workerImplementation = WorkerFactory.getWorkerImplementation( - this.workerScript, - workerConfiguration.processType!, - { - workerStartDelay: workerConfiguration.startDelay, - elementStartDelay: workerConfiguration.elementStartDelay, - poolMaxSize: workerConfiguration.poolMaxSize!, - poolMinSize: workerConfiguration.poolMinSize!, - elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number), - poolOptions: { - messageHandler: this.messageHandler.bind(this) as (message: unknown) => void, - }, - }, - )); + this.workerImplementation = WorkerFactory.getWorkerImplementation< + ChargingStationWorkerData, + ChargingStationInfo + >( + join( + dirname(fileURLToPath(import.meta.url)), + `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}` + ), + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + workerConfiguration.processType!, + { + workerStartDelay: workerConfiguration.startDelay, + 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, + poolOptions: { + messageHandler: this.messageHandler.bind(this) as MessageHandler, + ...(workerConfiguration.resourceLimits != null && { + workerOptions: { resourceLimits: workerConfiguration.resourceLimits } + }) + } + } + ) } - private messageHandler( - msg: ChargingStationWorkerMessage, + private messageHandler ( + msg: ChargingStationWorkerMessage ): void { // logger.debug( // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( // msg, - // null, - // 2, - // )}`, - // ); + // undefined, + // 2 + // )}` + // ) try { switch (msg.event) { + case ChargingStationWorkerMessageEvents.added: + this.emit(ChargingStationWorkerMessageEvents.added, msg.data) + break + case ChargingStationWorkerMessageEvents.deleted: + this.emit(ChargingStationWorkerMessageEvents.deleted, msg.data) + break case ChargingStationWorkerMessageEvents.started: - this.workerEventStarted(msg.data as ChargingStationData); - this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData); - break; + this.emit(ChargingStationWorkerMessageEvents.started, msg.data) + break case ChargingStationWorkerMessageEvents.stopped: - this.workerEventStopped(msg.data as ChargingStationData); - this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData); - break; + this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data) + break case ChargingStationWorkerMessageEvents.updated: - this.workerEventUpdated(msg.data as ChargingStationData); - this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData); - break; + this.emit(ChargingStationWorkerMessageEvents.updated, msg.data) + 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; + this.emit(ChargingStationWorkerMessageEvents.performanceStatistics, msg.data) + break + case ChargingStationWorkerMessageEvents.addedWorkerElement: + this.emit(ChargingStationWorkerMessageEvents.addWorkerElement, msg.data) + break + case ChargingStationWorkerMessageEvents.workerElementError: + this.emit(ChargingStationWorkerMessageEvents.workerElementError, msg.data) + break default: throw new BaseError( `Unknown charging station worker event: '${ msg.event - }' received with data: ${JSON.stringify(msg.data, null, 2)}`, - ); + }' received with data: ${JSON.stringify(msg.data, undefined, 2)}` + ) } } catch (error) { logger.error( `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ msg.event }' event:`, - error, - ); + error + ) } } - private workerEventStarted = (data: ChargingStationData) => { - this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); - ++this.numberOfStartedChargingStations; + 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 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 charging station(s))` + ) + } + + private readonly workerEventStarted = (data: ChargingStationData): void => { + 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 workerEventStopped = (data: ChargingStationData) => { - this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); - --this.numberOfStartedChargingStations; + private readonly workerEventStopped = (data: ChargingStationData): void => { + 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 workerEventUpdated = (data: ChargingStationData) => { - this.uiServer?.chargingStations.set(data.stationInfo.hashId, data); - }; + private readonly workerEventUpdated = (data: ChargingStationData): void => { + this.uiServer.chargingStations.set(data.stationInfo.hashId, data) + } - private workerEventPerformanceStatistics = (data: Statistics) => { - this.storage.storePerformanceStatistics(data) as void; - }; + private readonly workerEventPerformanceStatistics = (data: Statistics): void => { + // 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() { - 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); + private initializeCounters (): void { + // 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, + 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'), - ); - process.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 => { - console.info(`${chalk.green('Graceful shutdown')}`); + private gracefulShutdown (): void { this.stop() .then(() => { - process.exit(exitCodes.succeeded); + console.info(chalk.green('Graceful shutdown')) + this.uiServer.stop() + this.uiServerStarted = false + this.waitChargingStationsStopped() + .then(() => { + exit(exitCodes.succeeded) + }) + .catch(() => { + exit(exitCodes.gracefulShutdownError) + }) + }) + .catch((error: unknown) => { + console.error(chalk.red('Error while shutdowning charging stations simulator: '), error) + exit(exitCodes.gracefulShutdownError) }) - .catch((error) => { - console.error(chalk.red('Error while shutdowning charging stations simulator: '), error); - process.exit(exitCodes.gracefulShutdownError); - }); - }; + } - private logPrefix = (): string => { - return logPrefix(' Bootstrap |'); - }; + private readonly logPrefix = (): string => { + return logPrefix(' Bootstrap |') + } }