X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=211cf02079230624a525dc92d4a26e2d9cb904ca;hb=6cd85def67fcc51dfa978127ec4a7a776427b135;hp=a6eb4939cf4f6cd0bf612362fbbc6744cd0cd53b;hpb=6e0964c8dff48691f7155d12096e777a8f9389f4;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index a6eb4939..211cf020 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,21 +1,61 @@ +// Partial Copyright Jerome Benoit. 2021. All Rights Reserved. + +import { + ChargingStationWorkerData, + ChargingStationWorkerMessage, + ChargingStationWorkerMessageEvents, +} from '../types/ChargingStationWorker'; + +import { AbstractUIServer } from './ui-server/AbstractUIServer'; +import { ApplicationProtocol } from '../types/UIProtocol'; +import { ChargingStationUtils } from './ChargingStationUtils'; import Configuration from '../utils/Configuration'; -import { StationWorkerData } from '../types/Worker'; +import { StationTemplateUrl } from '../types/ConfigurationData'; +import Statistics from '../types/Statistics'; +import { Storage } from '../performance/storage/Storage'; +import { StorageFactory } from '../performance/storage/StorageFactory'; +import UIServerFactory from './ui-server/UIServerFactory'; +import { UIServiceUtils } from './ui-server/ui-services/UIServiceUtils'; import Utils from '../utils/Utils'; import WorkerAbstract from '../worker/WorkerAbstract'; import WorkerFactory from '../worker/WorkerFactory'; +import chalk from 'chalk'; import { isMainThread } from 'worker_threads'; import path from 'path'; +import { version } from '../../package.json'; export default class Bootstrap { - private static instance: Bootstrap; + private static instance: Bootstrap | null = null; + private workerImplementation: WorkerAbstract | null = null; + private readonly uiServer!: AbstractUIServer; + private readonly storage!: Storage; + private numberOfChargingStationTemplates!: number; + private numberOfChargingStations!: number; + private readonly version: string = version; private started: boolean; - private workerScript: string; - private workerImplementationInstance: WorkerAbstract | null = null; + private readonly workerScript: string; private constructor() { this.started = false; - this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'StationWorker.js'); - Configuration.setConfigurationChangeCallback(async () => this.restart()); + this.workerScript = path.join( + path.resolve(__dirname, '../'), + 'charging-station', + 'ChargingStationWorker.js' + ); + this.initialize(); + this.initWorkerImplementation(); + Configuration.getUIServer().enabled && + (this.uiServer = UIServerFactory.getUIServerImplementation(ApplicationProtocol.WS, { + ...Configuration.getUIServer().options, + handleProtocols: UIServiceUtils.handleProtocols, + })); + Configuration.getPerformanceStorage().enabled && + (this.storage = StorageFactory.getStorage( + Configuration.getPerformanceStorage().type, + Configuration.getPerformanceStorage().uri, + this.logPrefix() + )); + Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart()); } public static getInstance(): Bootstrap { @@ -28,67 +68,135 @@ export default class Bootstrap { public async start(): Promise { if (isMainThread && !this.started) { try { - let numStationsTotal = 0; - await this.getWorkerImplementationInstance()?.start(); + this.initialize(); + await this.storage?.open(); + await this.workerImplementation.start(); + this.uiServer?.start(); + const stationTemplateUrls = Configuration.getStationTemplateUrls(); + this.numberOfChargingStationTemplates = stationTemplateUrls.length; // Start ChargingStation object in worker thread - if (Configuration.getStationTemplateURLs()) { - for (const stationURL of Configuration.getStationTemplateURLs()) { + if (stationTemplateUrls) { + for (const stationTemplateUrl of stationTemplateUrls) { try { - const nbStations = stationURL.numberOfStations ? stationURL.numberOfStations : 0; + const nbStations = stationTemplateUrl.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++; + await this.startChargingStation(index, stationTemplateUrl); } } catch (error) { - console.error('Charging station start with template file ' + stationURL.file + ' error ', error); + console.error( + chalk.red( + 'Error at starting charging station with template file ' + + stationTemplateUrl.file + + ': ' + ), + error + ); } } } else { - console.log('No stationTemplateURLs defined in configuration, exiting'); + console.warn(chalk.yellow("No 'stationTemplateUrls' defined in configuration, exiting")); } - if (numStationsTotal === 0) { - console.log('No charging station template enabled in configuration, exiting'); + if (this.numberOfChargingStations === 0) { + console.warn( + chalk.yellow('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 ? ` (${this.getWorkerImplementationInstance().maxElementsPerWorker} charging station(s) per worker)` : ''}`); + console.log( + 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.getWorkerPoolMinSize().toString()}/` + : '' + }${this.workerImplementation.size}${ + ChargingStationUtils.workerPoolInUse() + ? `/${Configuration.getWorkerPoolMaxSize().toString()}` + : '' + } worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${ + this.workerImplementation.maxElementsPerWorker + ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` + : '' + }` + ) + ); } this.started = true; } catch (error) { - console.error('Bootstrap start error ', error); + console.error(chalk.red('Bootstrap start error '), error); } + } else { + console.error(chalk.red('Cannot start an already started charging stations simulator')); } } public async stop(): Promise { if (isMainThread && this.started) { - await this.getWorkerImplementationInstance()?.stop(); - // Nullify to force worker implementation instance creation - this.workerImplementationInstance = null; + await this.workerImplementation.stop(); + this.uiServer?.stop(); + await this.storage?.close(); + } else { + console.error(chalk.red('Trying to stop the charging stations simulator while not started')); } this.started = false; } public async restart(): Promise { await this.stop(); + this.initialize(); + this.initWorkerImplementation(); await this.start(); } - private getWorkerImplementationInstance(): WorkerAbstract | null { - if (!this.workerImplementationInstance) { - this.workerImplementationInstance = WorkerFactory.getWorkerImplementation(this.workerScript, Configuration.getWorkerProcess(), - { - startDelay: Configuration.getWorkerStartDelay(), - poolMaxSize: Configuration.getWorkerPoolMaxSize(), - poolMinSize: Configuration.getWorkerPoolMinSize(), - elementsPerWorker: Configuration.getChargingStationsPerWorker(), - poolOptions: { - workerChoiceStrategy: Configuration.getWorkerPoolStrategy() + private initWorkerImplementation(): void { + this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerScript, + Configuration.getWorkerProcess(), + { + workerStartDelay: Configuration.getWorkerStartDelay(), + elementStartDelay: Configuration.getElementStartDelay(), + poolMaxSize: Configuration.getWorkerPoolMaxSize(), + poolMinSize: Configuration.getWorkerPoolMinSize(), + elementsPerWorker: Configuration.getChargingStationsPerWorker(), + poolOptions: { + workerChoiceStrategy: Configuration.getWorkerPoolStrategy(), + }, + messageHandler: async (msg: ChargingStationWorkerMessage) => { + if (msg.id === ChargingStationWorkerMessageEvents.STARTED) { + this.uiServer.chargingStations.add(msg.data.id as string); + } else if (msg.id === ChargingStationWorkerMessageEvents.STOPPED) { + this.uiServer.chargingStations.delete(msg.data.id as string); + } else if (msg.id === ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS) { + await this.storage.storePerformanceStatistics(msg.data as unknown as Statistics); } - }); - } - return this.workerImplementationInstance; + }, + } + ); + } + + private initialize() { + this.numberOfChargingStations = 0; + this.numberOfChargingStationTemplates = 0; + } + + private async startChargingStation( + index: number, + stationTemplateUrl: StationTemplateUrl + ): Promise { + const workerData: ChargingStationWorkerData = { + index, + templateFile: path.join( + path.resolve(__dirname, '../'), + 'assets', + 'station-templates', + path.basename(stationTemplateUrl.file) + ), + }; + await this.workerImplementation.addElement(workerData); + this.numberOfChargingStations++; + } + + private logPrefix(): string { + return Utils.logPrefix(' Bootstrap |'); } }