X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=3312224278521fe7e98fc128b58c2ad5bc887fb6;hb=b63b4a73f7869a2ff31e5bd259d056faaa53a5de;hp=486b4fcd8445b805eb92f8eabeb4298b97db96b0;hpb=05745045efc825738ba9ba4b30d4d4ec932a5dd3;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 486b4fcd..33122242 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,77 +1,137 @@ -import Configuration from '../utils/Configuration'; -import { StationWorkerData } from '../types/Worker'; -import Utils from '../utils/Utils'; -import WorkerFactory from '../worker/WorkerFactory'; -import Wrk from '../worker/Wrk'; -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 path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { type Worker, isMainThread } from 'node:worker_threads'; + +import chalk from 'chalk'; + +import type { AbstractUIServer } from './ui-server/AbstractUIServer'; +import { UIServerFactory } from './ui-server/UIServerFactory'; +import packageJson 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, + type StationTemplateUrl, + type Statistics, +} from '../types'; +import { Configuration, ErrorUtils, Utils, logger } from '../utils'; +import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker'; + +const moduleName = 'Bootstrap'; + +enum exitCodes { + missingChargingStationsConfiguration = 1, + noChargingStationTemplates = 2, +} + +export class Bootstrap { + 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 = packageJson.version; + private initializedCounters: boolean; private started: boolean; - private workerScript: string; - private workerImplementationInstance: Wrk; + private readonly workerScript: string; private constructor() { + // Enable unconditionally for now + ErrorUtils.handleUnhandledRejection(); + ErrorUtils.handleUncaughtException(); + this.initializedCounters = false; this.started = false; - this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'StationWorker.js'); + this.initializeCounters(); + this.workerImplementation = null; + this.workerScript = path.join( + path.dirname(fileURLToPath(import.meta.url)), + `ChargingStationWorker${path.extname(fileURLToPath(import.meta.url))}` + ); + Configuration.getUIServer().enabled === true && + (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer())); + Configuration.getPerformanceStorage().enabled === true && + (this.storage = StorageFactory.getStorage( + Configuration.getPerformanceStorage().type, + Configuration.getPerformanceStorage().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) { - // eslint-disable-next-line no-console - console.error('Charging station start with template file ' + stationURL.file + ' error ', error); - } + 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); } - } else { - console.log('No stationTemplateURLs defined in configuration, exiting'); + } catch (error) { + console.error( + chalk.red( + `Error at starting charging station with template file ${stationTemplateUrl.file}: ` + ), + error + ); } - 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} charging station(s) per worker)`); - } - this.started = true; - } catch (error) { - // eslint-disable-next-line no-console - console.error('Bootstrap start error ', error); } + 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() + ? `${Configuration.getWorker().poolMinSize?.toString()}/` + : '' + }${this.workerImplementation?.size}${ + Configuration.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) { - if (this.getWorkerImplementationInstance()) { - await this.getWorkerImplementationInstance().stop(); - // Nullify to force worker implementation instance creation - this.workerImplementationInstance = null; - } + 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; + } else { + console.error(chalk.red('Cannot stop a not started charging stations simulator')); } - this.started = false; } public async restart(): Promise { @@ -79,14 +139,139 @@ export default class Bootstrap { await this.start(); } - private getWorkerImplementationInstance(): Wrk { - if (!this.workerImplementationInstance) { - this.workerImplementationInstance = WorkerFactory.getWorkerImplementation(this.workerScript, Configuration.getWorkerProcess(), { - poolMaxSize: Configuration.getWorkerPoolMaxSize(), - poolMinSize: Configuration.getWorkerPoolMinSize(), - elementsPerWorker: Configuration.getChargingStationsPerWorker() - }); + private initializeWorkerImplementation(): void { + this.workerImplementation === null && + (this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerScript, + Configuration.getWorker().processType, + { + workerStartDelay: Configuration.getWorker().startDelay, + elementStartDelay: Configuration.getWorker().elementStartDelay, + poolMaxSize: Configuration.getWorker().poolMaxSize, + poolMinSize: Configuration.getWorker().poolMinSize, + elementsPerWorker: Configuration.getWorker().elementsPerWorker, + poolOptions: { + workerChoiceStrategy: Configuration.getWorker().poolStrategy, + }, + messageHandler: this.messageHandler.bind(this) as MessageHandler, + } + )); + } + + private messageHandler( + msg: ChargingStationWorkerMessage + ): void { + // logger.debug( + // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify( + // msg, + // null, + // 2 + // )}` + // ); + try { + switch (msg.id) { + case ChargingStationWorkerMessageEvents.started: + this.workerEventStarted(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.stopped: + this.workerEventStopped(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.updated: + this.workerEventUpdated(msg.data as ChargingStationData); + break; + case ChargingStationWorkerMessageEvents.performanceStatistics: + this.workerEventPerformanceStatistics(msg.data as Statistics); + break; + default: + throw new BaseError( + `Unknown event type: '${msg.id}' for data: ${JSON.stringify(msg.data, null, 2)}` + ); + } + } catch (error) { + logger.error( + `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${ + msg.id + }' 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.numberOfChargingStationTemplates = 0; + this.numberOfChargingStations = 0; + const stationTemplateUrls = Configuration.getStationTemplateUrls(); + if (Utils.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.numberOfStartedChargingStations = 0; + this.initializedCounters = true; + } + } + + private async startChargingStation( + index: number, + stationTemplateUrl: StationTemplateUrl + ): Promise { + await this.workerImplementation?.addElement({ + index, + templateFile: path.join( + path.dirname(fileURLToPath(import.meta.url)), + 'assets', + 'station-templates', + stationTemplateUrl.file + ), + }); + } + + private logPrefix = (): string => { + return Utils.logPrefix(' Bootstrap |'); + }; }