src/charging-station/Bootstrap.ts

   1 // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
   2
   3 import { EventEmitter } from 'node:events';
   4 import { dirname, extname, join } from 'node:path';
   5 import { fileURLToPath } from 'node:url';
   6 import { isMainThread } from 'node:worker_threads';
   7
   8 import chalk from 'chalk';
   9 import { availableParallelism } from 'poolifier';
  10
  11 import { waitChargingStationEvents } from './ChargingStationUtils';
  12 import type { AbstractUIServer } from './ui-server/AbstractUIServer';
  13 import { UIServerFactory } from './ui-server/UIServerFactory';
  14 import { version } from '../../package.json' assert { type: 'json' };
  15 import { BaseError } from '../exception';
  16 import { type Storage, StorageFactory } from '../performance';
  17 import {
  18   type ChargingStationData,
  19   type ChargingStationWorkerData,
  20   type ChargingStationWorkerMessage,
  21   type ChargingStationWorkerMessageData,
  22   ChargingStationWorkerMessageEvents,
  23   ConfigurationSection,
  24   ProcedureName,
  25   type StationTemplateUrl,
  26   type Statistics,
  27   type StorageConfiguration,
  28   type UIServerConfiguration,
  29   type WorkerConfiguration,
  30 } from '../types';
  31 import {
  32   Configuration,
  33   Constants,
  34   formatDurationMilliSeconds,
  35   generateUUID,
  36   handleUncaughtException,
  37   handleUnhandledRejection,
  38   isNotEmptyArray,
  39   isNullOrUndefined,
  40   logPrefix,
  41   logger,
  42 } from '../utils';
  43 import { type WorkerAbstract, WorkerFactory } from '../worker';
  44
  45 const moduleName = 'Bootstrap';
  46
  47 enum exitCodes {
  48   missingChargingStationsConfiguration = 1,
  49   noChargingStationTemplates = 2,
  50 }
  51
  52 export class Bootstrap extends EventEmitter {
  53   private static instance: Bootstrap | null = null;
  54   public numberOfChargingStations!: number;
  55   public numberOfChargingStationTemplates!: number;
  56   private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null;
  57   private readonly uiServer!: AbstractUIServer | null;
  58   private readonly storage!: Storage;
  59   private numberOfStartedChargingStations!: number;
  60   private readonly version: string = version;
  61   private initializedCounters: boolean;
  62   private started: boolean;
  63   private starting: boolean;
  64   private stopping: boolean;
  65   private readonly workerScript: string;
  66
  67   private constructor() {
  68     super();
  69     for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) {
  70       process.on(signal, this.gracefulShutdown);
  71     }
  72     // Enable unconditionally for now
  73     handleUnhandledRejection();
  74     handleUncaughtException();
  75     this.started = false;
  76     this.starting = false;
  77     this.stopping = false;
  78     this.initializedCounters = false;
  79     this.initializeCounters();
  80     this.workerImplementation = null;
  81     this.workerScript = join(
  82       dirname(fileURLToPath(import.meta.url)),
  83       `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`,
  84     );
  85     const uiServerConfiguration = Configuration.getConfigurationSection<UIServerConfiguration>(
  86       ConfigurationSection.uiServer,
  87     );
  88     uiServerConfiguration.enabled === true &&
  89       (this.uiServer = UIServerFactory.getUIServerImplementation(uiServerConfiguration));
  90     const performanceStorageConfiguration =
  91       Configuration.getConfigurationSection<StorageConfiguration>(
  92         ConfigurationSection.performanceStorage,
  93       );
  94     performanceStorageConfiguration.enabled === true &&
  95       (this.storage = StorageFactory.getStorage(
  96         performanceStorageConfiguration.type!,
  97         performanceStorageConfiguration.uri!,
  98         this.logPrefix(),
  99       ));
 100     Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart());
 101   }
 102
 103   public static getInstance(): Bootstrap {
 104     if (Bootstrap.instance === null) {
 105       Bootstrap.instance = new Bootstrap();
 106     }
 107     return Bootstrap.instance;
 108   }
 109
 110   public async start(): Promise<void> {
 111     if (!isMainThread) {
 112       throw new Error('Cannot start charging stations simulator from worker thread');
 113     }
 114     if (this.started === false) {
 115       if (this.starting === false) {
 116         this.starting = true;
 117         this.initializeCounters();
 118         const workerConfiguration = Configuration.getConfigurationSection<WorkerConfiguration>(
 119           ConfigurationSection.worker,
 120         );
 121         this.initializeWorkerImplementation(workerConfiguration);
 122         await this.workerImplementation?.start();
 123         await this.storage?.open();
 124         this.uiServer?.start();
 125         // Start ChargingStation object instance in worker thread
 126         for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) {
 127           try {
 128             const nbStations = stationTemplateUrl.numberOfStations ?? 0;
 129             for (let index = 1; index <= nbStations; index++) {
 130               await this.startChargingStation(index, stationTemplateUrl);
 131             }
 132           } catch (error) {
 133             console.error(
 134               chalk.red(
 135                 `Error at starting charging station with template file ${stationTemplateUrl.file}: `,
 136               ),
 137               error,
 138             );
 139           }
 140         }
 141         console.info(
 142           chalk.green(
 143             `Charging stations simulator ${
 144               this.version
 145             } started with ${this.numberOfChargingStations.toString()} charging station(s) from ${this.numberOfChargingStationTemplates.toString()} configured charging station template(s) and ${
 146               Configuration.workerDynamicPoolInUse()
 147                 ? `${workerConfiguration.poolMinSize?.toString()}/`
 148                 : ''
 149             }${this.workerImplementation?.size}${
 150               Configuration.workerPoolInUse()
 151                 ? `/${workerConfiguration.poolMaxSize?.toString()}`
 152                 : ''
 153             } worker(s) concurrently running in '${workerConfiguration.processType}' mode${
 154               !isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
 155                 ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)`
 156                 : ''
 157             }`,
 158           ),
 159         );
 160         Configuration.workerDynamicPoolInUse() &&
 161           console.warn(
 162             chalk.yellow(
 163               'Charging stations simulator is using dynamic pool mode. This is an experimental feature with known issues.\nPlease consider using static pool or worker set mode instead',
 164             ),
 165           );
 166         console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info);
 167         this.started = true;
 168         this.starting = false;
 169       } else {
 170         console.error(chalk.red('Cannot start an already starting charging stations simulator'));
 171       }
 172     } else {
 173       console.error(chalk.red('Cannot start an already started charging stations simulator'));
 174     }
 175   }
 176
 177   public async stop(): Promise<void> {
 178     if (!isMainThread) {
 179       throw new Error('Cannot stop charging stations simulator from worker thread');
 180     }
 181     if (this.started === true) {
 182       if (this.stopping === false) {
 183         this.stopping = true;
 184         await this.uiServer?.sendInternalRequest(
 185           this.uiServer.buildProtocolRequest(
 186             generateUUID(),
 187             ProcedureName.STOP_CHARGING_STATION,
 188             Constants.EMPTY_FREEZED_OBJECT,
 189           ),
 190         );
 191         await Promise.race([
 192           waitChargingStationEvents(
 193             this,
 194             ChargingStationWorkerMessageEvents.stopped,
 195             this.numberOfChargingStations,
 196           ),
 197           new Promise<string>((resolve) => {
 198             setTimeout(() => {
 199               const message = `Timeout reached ${formatDurationMilliSeconds(
 200                 Constants.STOP_SIMULATOR_TIMEOUT,
 201               )} at stopping charging stations simulator`;
 202               console.warn(chalk.yellow(message));
 203               resolve(message);
 204             }, Constants.STOP_SIMULATOR_TIMEOUT);
 205           }),
 206         ]);
 207         await this.workerImplementation?.stop();
 208         this.workerImplementation = null;
 209         this.uiServer?.stop();
 210         await this.storage?.close();
 211         this.resetCounters();
 212         this.initializedCounters = false;
 213         this.started = false;
 214         this.stopping = false;
 215       } else {
 216         console.error(chalk.red('Cannot stop an already stopping charging stations simulator'));
 217       }
 218     } else {
 219       console.error(chalk.red('Cannot stop an already stopped charging stations simulator'));
 220     }
 221   }
 222
 223   public async restart(): Promise<void> {
 224     await this.stop();
 225     await this.start();
 226   }
 227
 228   private initializeWorkerImplementation(workerConfiguration: WorkerConfiguration): void {
 229     let elementsPerWorker: number | undefined;
 230     if (workerConfiguration?.elementsPerWorker === 'auto') {
 231       elementsPerWorker =
 232         this.numberOfChargingStations > availableParallelism()
 233           ? Math.round(this.numberOfChargingStations / availableParallelism())
 234           : 1;
 235     }
 236     this.workerImplementation === null &&
 237       (this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
 238         this.workerScript,
 239         workerConfiguration.processType!,
 240         {
 241           workerStartDelay: workerConfiguration.startDelay,
 242           elementStartDelay: workerConfiguration.elementStartDelay,
 243           poolMaxSize: workerConfiguration.poolMaxSize!,
 244           poolMinSize: workerConfiguration.poolMinSize!,
 245           elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number),
 246           poolOptions: {
 247             messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
 248           },
 249         },
 250       ));
 251   }
 252
 253   private messageHandler(
 254     msg: ChargingStationWorkerMessage<ChargingStationWorkerMessageData>,
 255   ): void {
 256     // logger.debug(
 257     //   `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify(
 258     //     msg,
 259     //     null,
 260     //     2,
 261     //   )}`,
 262     // );
 263     try {
 264       switch (msg.event) {
 265         case ChargingStationWorkerMessageEvents.started:
 266           this.workerEventStarted(msg.data as ChargingStationData);
 267           this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData);
 268           break;
 269         case ChargingStationWorkerMessageEvents.stopped:
 270           this.workerEventStopped(msg.data as ChargingStationData);
 271           this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData);
 272           break;
 273         case ChargingStationWorkerMessageEvents.updated:
 274           this.workerEventUpdated(msg.data as ChargingStationData);
 275           this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData);
 276           break;
 277         case ChargingStationWorkerMessageEvents.performanceStatistics:
 278           this.workerEventPerformanceStatistics(msg.data as Statistics);
 279           this.emit(
 280             ChargingStationWorkerMessageEvents.performanceStatistics,
 281             msg.data as Statistics,
 282           );
 283           break;
 284         default:
 285           throw new BaseError(
 286             `Unknown event type: '${msg.event}' for data: ${JSON.stringify(msg.data, null, 2)}`,
 287           );
 288       }
 289     } catch (error) {
 290       logger.error(
 291         `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${
 292           msg.event
 293         }' event:`,
 294         error,
 295       );
 296     }
 297   }
 298
 299   private workerEventStarted = (data: ChargingStationData) => {
 300     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 301     ++this.numberOfStartedChargingStations;
 302     logger.info(
 303       `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${
 304         data.stationInfo.chargingStationId
 305       } (hashId: ${data.stationInfo.hashId}) started (${
 306         this.numberOfStartedChargingStations
 307       } started from ${this.numberOfChargingStations})`,
 308     );
 309   };
 310
 311   private workerEventStopped = (data: ChargingStationData) => {
 312     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 313     --this.numberOfStartedChargingStations;
 314     logger.info(
 315       `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${
 316         data.stationInfo.chargingStationId
 317       } (hashId: ${data.stationInfo.hashId}) stopped (${
 318         this.numberOfStartedChargingStations
 319       } started from ${this.numberOfChargingStations})`,
 320     );
 321   };
 322
 323   private workerEventUpdated = (data: ChargingStationData) => {
 324     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 325   };
 326
 327   private workerEventPerformanceStatistics = (data: Statistics) => {
 328     this.storage.storePerformanceStatistics(data) as void;
 329   };
 330
 331   private initializeCounters() {
 332     if (this.initializedCounters === false) {
 333       this.resetCounters();
 334       const stationTemplateUrls = Configuration.getStationTemplateUrls()!;
 335       if (isNotEmptyArray(stationTemplateUrls)) {
 336         this.numberOfChargingStationTemplates = stationTemplateUrls.length;
 337         for (const stationTemplateUrl of stationTemplateUrls) {
 338           this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0;
 339         }
 340       } else {
 341         console.warn(
 342           chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting"),
 343         );
 344         process.exit(exitCodes.missingChargingStationsConfiguration);
 345       }
 346       if (this.numberOfChargingStations === 0) {
 347         console.warn(
 348           chalk.yellow('No charging station template enabled in configuration, exiting'),
 349         );
 350         process.exit(exitCodes.noChargingStationTemplates);
 351       }
 352       this.initializedCounters = true;
 353     }
 354   }
 355
 356   private resetCounters(): void {
 357     this.numberOfChargingStationTemplates = 0;
 358     this.numberOfChargingStations = 0;
 359     this.numberOfStartedChargingStations = 0;
 360   }
 361
 362   private async startChargingStation(
 363     index: number,
 364     stationTemplateUrl: StationTemplateUrl,
 365   ): Promise<void> {
 366     await this.workerImplementation?.addElement({
 367       index,
 368       templateFile: join(
 369         dirname(fileURLToPath(import.meta.url)),
 370         'assets',
 371         'station-templates',
 372         stationTemplateUrl.file,
 373       ),
 374     });
 375   }
 376
 377   private gracefulShutdown = (): void => {
 378     console.info(`${chalk.green('Graceful shutdown')}`);
 379     this.stop()
 380       .then(() => {
 381         process.exit(0);
 382       })
 383       .catch((error) => {
 384         console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
 385         process.exit(1);
 386       });
 387   };
 388
 389   private logPrefix = (): string => {
 390     return logPrefix(' Bootstrap |');
 391   };
 392 }