X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=2c7f56fe4de94c1d7524e99957e68c1b8503c83c;hb=f23be6aad227f8942bb140d286585423fe84f60b;hp=5f20e74b6ca320224e374bc4cbfe63e55dd70dec;hpb=01f4001e733ebc61423d3023d87b1399b6afa215;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 5f20e74b..2c7f56fe 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,12 +1,16 @@ // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. -import path from 'node:path'; +import { EventEmitter } from 'node:events'; +import { dirname, extname, join } from 'node:path'; +import process, { exit } from 'node:process'; import { fileURLToPath } from 'node:url'; -import { type Worker, isMainThread } from 'node:worker_threads'; import chalk from 'chalk'; +import { availableParallelism } from 'poolifier'; -import { type AbstractUIServer, ChargingStationUtils, UIServerFactory } from './internal'; +import { waitChargingStationEvents } from './Helpers'; +import type { AbstractUIServer } from './ui-server/AbstractUIServer'; +import { UIServerFactory } from './ui-server/UIServerFactory'; import { version } from '../../package.json'; import { BaseError } from '../exception'; import { type Storage, StorageFactory } from '../performance'; @@ -16,54 +20,84 @@ import { type ChargingStationWorkerMessage, type ChargingStationWorkerMessageData, ChargingStationWorkerMessageEvents, + ConfigurationSection, + ProcedureName, type StationTemplateUrl, type Statistics, + type StorageConfiguration, + type UIServerConfiguration, + type WorkerConfiguration, } from '../types'; -import { Configuration, Utils, logger } from '../utils'; -import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker'; +import { + Configuration, + Constants, + formatDurationMilliSeconds, + generateUUID, + handleUncaughtException, + handleUnhandledRejection, + isNotEmptyArray, + isNullOrUndefined, + logPrefix, + logger, +} from '../utils'; +import { type WorkerAbstract, WorkerFactory } from '../worker'; const moduleName = 'Bootstrap'; enum exitCodes { + succeeded = 0, missingChargingStationsConfiguration = 1, noChargingStationTemplates = 2, + gracefulShutdownError = 3, } -export class Bootstrap { +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 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 constructor() { + super(); + for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) { + process.on(signal, this.gracefulShutdown.bind(this)); + } // Enable unconditionally for now - this.logUnhandledRejection(); - this.logUncaughtException(); - this.initializedCounters = false; + handleUnhandledRejection(); + handleUncaughtException(); this.started = false; + this.starting = false; + this.stopping = false; + this.initializedCounters = false; this.initializeCounters(); 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.workerScript = join( + dirname(fileURLToPath(import.meta.url)), + `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`, + ); + this.uiServer = UIServerFactory.getUIServerImplementation( + Configuration.getConfigurationSection(ConfigurationSection.uiServer), ); - Configuration.getUIServer().enabled === true && - (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer())); - Configuration.getPerformanceStorage().enabled === true && + const performanceStorageConfiguration = + Configuration.getConfigurationSection( + ConfigurationSection.performanceStorage, + ); + performanceStorageConfiguration.enabled === true && (this.storage = StorageFactory.getStorage( - Configuration.getPerformanceStorage().type, - Configuration.getPerformanceStorage().uri, - this.logPrefix() + performanceStorageConfiguration.type!, + performanceStorageConfiguration.uri!, + this.logPrefix(), )); - Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart()); + Configuration.configurationChangeCallback = async () => Bootstrap.getInstance().restart(false); } public static getInstance(): Bootstrap { @@ -74,125 +108,202 @@ export class Bootstrap { } public async start(): Promise { - if (isMainThread && this.started === false) { - this.initializeCounters(); - this.initializeWorkerImplementation(); - 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); + 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(); + Configuration.getConfigurationSection(ConfigurationSection.uiServer) + .enabled === true && 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, + ); } - } catch (error) { - console.error( - chalk.red( - `Error at starting charging station with template file ${stationTemplateUrl.file}: ` + } + 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 fixed pool or worker set mode instead', ), - error ); - } + 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.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${ - !Utils.isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker) - ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)` - : '' - }` - ) - ); - this.started = true; } else { console.error(chalk.red('Cannot start an already started charging stations simulator')); } } - public async stop(): Promise { - if (isMainThread && this.started === true) { - await this.workerImplementation?.stop(); - this.workerImplementation = null; - this.uiServer?.stop(); - await this.storage?.close(); - this.initializedCounters = false; - this.started = false; + public async stop(stopChargingStations = true): Promise { + if (this.started === true) { + if (this.stopping === false) { + this.stopping = true; + if (stopChargingStations === true) { + await this.uiServer?.sendInternalRequest( + this.uiServer.buildProtocolRequest( + generateUUID(), + ProcedureName.STOP_CHARGING_STATION, + Constants.EMPTY_FROZEN_OBJECT, + ), + ); + await this.waitChargingStationsStopped(); + } + 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 a not started charging stations simulator')); + console.error(chalk.red('Cannot stop an already stopped charging stations simulator')); } } - public async restart(): Promise { - await this.stop(); + public async restart(stopChargingStations?: boolean): Promise { + await this.stop(stopChargingStations); await this.start(); } - private initializeWorkerImplementation(): void { + private async waitChargingStationsStopped(): Promise { + await Promise.race([ + waitChargingStationEvents( + this, + ChargingStationWorkerMessageEvents.stopped, + this.numberOfChargingStations, + ), + new Promise((resolve) => { + setTimeout(() => { + const message = `Timeout ${formatDurationMilliSeconds( + Constants.STOP_SIMULATOR_TIMEOUT, + )} reached at stopping charging stations simulator`; + console.warn(chalk.yellow(message)); + resolve(message); + }, Constants.STOP_SIMULATOR_TIMEOUT); + }), + ]); + } + + 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, - Configuration.getWorker().processType, + workerConfiguration.processType!, { - workerStartDelay: Configuration.getWorker().startDelay, - elementStartDelay: Configuration.getWorker().elementStartDelay, - poolMaxSize: Configuration.getWorker().poolMaxSize, - poolMinSize: Configuration.getWorker().poolMinSize, - elementsPerWorker: Configuration.getWorker().elementsPerWorker, + workerStartDelay: workerConfiguration.startDelay, + elementStartDelay: workerConfiguration.elementStartDelay, + poolMaxSize: workerConfiguration.poolMaxSize!, + poolMinSize: workerConfiguration.poolMinSize!, + elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number), poolOptions: { - workerChoiceStrategy: Configuration.getWorker().poolStrategy, + messageHandler: this.messageHandler.bind(this) as (message: unknown) => void, }, - messageHandler: this.messageHandler.bind(this) as MessageHandler, - } + }, )); } private messageHandler( - msg: ChargingStationWorkerMessage + msg: ChargingStationWorkerMessage, ): void { // logger.debug( // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( // msg, - // null, - // 2 - // )}` + // undefined, + // 2, + // )}`, // ); try { - switch (msg.id) { - case ChargingStationWorkerMessageEvents.STARTED: + switch (msg.event) { + case ChargingStationWorkerMessageEvents.started: this.workerEventStarted(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData); break; - case ChargingStationWorkerMessageEvents.STOPPED: + case ChargingStationWorkerMessageEvents.stopped: this.workerEventStopped(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData); break; - case ChargingStationWorkerMessageEvents.UPDATED: + case ChargingStationWorkerMessageEvents.updated: this.workerEventUpdated(msg.data as ChargingStationData); + this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData); break; - case ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS: + 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 event type: '${msg.id}' for data: ${JSON.stringify(msg.data, null, 2)}` + `Unknown charging station worker event: '${ + msg.event + }' received with data: ${JSON.stringify(msg.data, undefined, 2)}`, ); } } catch (error) { logger.error( `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ - msg.id + msg.event }' event:`, - error + error, ); } } @@ -205,7 +316,7 @@ export class Bootstrap { data.stationInfo.chargingStationId } (hashId: ${data.stationInfo.hashId}) started (${ this.numberOfStartedChargingStations - } started from ${this.numberOfChargingStations})` + } started from ${this.numberOfChargingStations})`, ); }; @@ -217,7 +328,7 @@ export class Bootstrap { data.stationInfo.chargingStationId } (hashId: ${data.stationInfo.hashId}) stopped (${ this.numberOfStartedChargingStations - } started from ${this.numberOfChargingStations})` + } started from ${this.numberOfChargingStations})`, ); }; @@ -231,59 +342,71 @@ export class Bootstrap { private initializeCounters() { if (this.initializedCounters === false) { - this.numberOfChargingStationTemplates = 0; - this.numberOfChargingStations = 0; - const stationTemplateUrls = Configuration.getStationTemplateUrls(); - if (Utils.isNotEmptyArray(stationTemplateUrls)) { + this.resetCounters(); + const stationTemplateUrls = Configuration.getStationTemplateUrls()!; + if (isNotEmptyArray(stationTemplateUrls)) { this.numberOfChargingStationTemplates = stationTemplateUrls.length; - stationTemplateUrls.forEach((stationTemplateUrl) => { + for (const stationTemplateUrl of stationTemplateUrls) { this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0; - }); + } } else { console.warn( - chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting") + chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting"), ); - process.exit(exitCodes.missingChargingStationsConfiguration); + exit(exitCodes.missingChargingStationsConfiguration); } if (this.numberOfChargingStations === 0) { console.warn( - chalk.yellow('No charging station template enabled in configuration, exiting') + chalk.yellow('No charging station template enabled in configuration, exiting'), ); - process.exit(exitCodes.noChargingStationTemplates); + exit(exitCodes.noChargingStationTemplates); } - this.numberOfStartedChargingStations = 0; this.initializedCounters = true; } } - 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 resetCounters(): void { + this.numberOfChargingStationTemplates = 0; + this.numberOfChargingStations = 0; + this.numberOfStartedChargingStations = 0; } private async startChargingStation( index: number, - stationTemplateUrl: StationTemplateUrl + stationTemplateUrl: StationTemplateUrl, ): Promise { await this.workerImplementation?.addElement({ index, - templateFile: path.join( - path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'), + templateFile: join( + dirname(fileURLToPath(import.meta.url)), 'assets', 'station-templates', - stationTemplateUrl.file + stationTemplateUrl.file, ), }); } + private gracefulShutdown(): void { + this.stop() + .then(() => { + console.info(`${chalk.green('Graceful shutdown')}`); + // stop() asks for charging stations to stop by default + this.waitChargingStationsStopped() + .then(() => { + exit(exitCodes.succeeded); + }) + .catch((error) => { + console.error(chalk.red('Error while waiting for charging stations to stop: '), error); + exit(exitCodes.gracefulShutdownError); + }); + }) + .catch((error) => { + console.error(chalk.red('Error while shutdowning charging stations simulator: '), error); + exit(exitCodes.gracefulShutdownError); + }); + } + private logPrefix = (): string => { - return Utils.logPrefix(' Bootstrap |'); + return logPrefix(' Bootstrap |'); }; }