X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=82aef5cd28c65a1c4be1246c6a6a2ac9fc2b6443;hb=44a95b7fc8487ae8116f89820ca03cb108dfada8;hp=52e1242f3973d45d6a6b430260509ba8f5e3b780;hpb=8df3f0a9d9fb9796c093a0e040b13dca8aaa3234;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts index 52e1242f..82aef5cd 100644 --- a/src/charging-station/Bootstrap.ts +++ b/src/charging-station/Bootstrap.ts @@ -1,23 +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 { fileURLToPath } from 'url'; import { isMainThread } from 'worker_threads'; import path from 'path'; import { version } from '../../package.json'; export default class Bootstrap { - private static instance: Bootstrap; - private version: string = version; + 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 workerImplementation: WorkerAbstract | null = null; + private readonly workerScript: string; private constructor() { this.started = false; - this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'StationWorker.js'); + this.workerScript = path.join( + path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'), + 'charging-station', + 'ChargingStationWorker' + path.extname(fileURLToPath(import.meta.url)) + ); + 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()); } @@ -31,66 +69,137 @@ export default class Bootstrap { public async start(): Promise { if (isMainThread && !this.started) { try { - let numStationsTotal = 0; + 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 (!Utils.isEmptyArray(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.workerImplementation.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("'stationTemplateUrls' not defined or empty 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 ${this.version} started with ${numStationsTotal.toString()} charging station(s) and ${Utils.workerDynamicPoolInUse() ? `${Configuration.getWorkerPoolMinSize().toString()}/` : ''}${this.workerImplementation.size}${Utils.workerPoolInUse() ? `/${Configuration.getWorkerPoolMaxSize().toString()}` : ''} worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${this.workerImplementation.maxElementsPerWorker ? ` (${this.workerImplementation.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.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.initWorkerImplementation(true); + this.initialize(); + this.initWorkerImplementation(); await this.start(); } - private initWorkerImplementation(forceInstantiation = false) { - this.workerImplementation = WorkerFactory.getWorkerImplementation(this.workerScript, Configuration.getWorkerProcess(), + private initWorkerImplementation(): void { + this.workerImplementation = WorkerFactory.getWorkerImplementation( + this.workerScript, + Configuration.getWorkerProcess(), { - startDelay: Configuration.getWorkerStartDelay(), + workerStartDelay: Configuration.getWorkerStartDelay(), + elementStartDelay: Configuration.getElementStartDelay(), poolMaxSize: Configuration.getWorkerPoolMaxSize(), poolMinSize: Configuration.getWorkerPoolMinSize(), elementsPerWorker: Configuration.getChargingStationsPerWorker(), poolOptions: { - workerChoiceStrategy: Configuration.getWorkerPoolStrategy() - } - }, forceInstantiation); - if (!this.workerImplementation) { - throw new Error('Worker implementation not found'); - } + 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); + } + }, + } + ); + } + + 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(path.dirname(fileURLToPath(import.meta.url)), '../'), + 'assets', + 'station-templates', + path.basename(stationTemplateUrl.file) + ), + }; + await this.workerImplementation.addElement(workerData); + this.numberOfChargingStations++; + } + + private logPrefix(): string { + return Utils.logPrefix(' Bootstrap |'); } }