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()) * 1.5)
 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         case ChargingStationWorkerMessageEvents.startWorkerElementError:
 285           logger.error(
 286             `${this.logPrefix()} ${moduleName}.messageHandler: Error occured while starting worker element:`,
 287             msg.data,
 288           );
 289           this.emit(ChargingStationWorkerMessageEvents.startWorkerElementError, msg.data);
 290           break;
 291         case ChargingStationWorkerMessageEvents.startedWorkerElement:
 292           break;
 293         default:
 294           throw new BaseError(
 295             `Unknown charging station worker event: '${
 296               msg.event
 297             }' received with data: ${JSON.stringify(msg.data, null, 2)}`,
 298           );
 299       }
 300     } catch (error) {
 301       logger.error(
 302         `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${
 303           msg.event
 304         }' event:`,
 305         error,
 306       );
 307     }
 308   }
 309
 310   private workerEventStarted = (data: ChargingStationData) => {
 311     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 312     ++this.numberOfStartedChargingStations;
 313     logger.info(
 314       `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${
 315         data.stationInfo.chargingStationId
 316       } (hashId: ${data.stationInfo.hashId}) started (${
 317         this.numberOfStartedChargingStations
 318       } started from ${this.numberOfChargingStations})`,
 319     );
 320   };
 321
 322   private workerEventStopped = (data: ChargingStationData) => {
 323     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 324     --this.numberOfStartedChargingStations;
 325     logger.info(
 326       `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${
 327         data.stationInfo.chargingStationId
 328       } (hashId: ${data.stationInfo.hashId}) stopped (${
 329         this.numberOfStartedChargingStations
 330       } started from ${this.numberOfChargingStations})`,
 331     );
 332   };
 333
 334   private workerEventUpdated = (data: ChargingStationData) => {
 335     this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
 336   };
 337
 338   private workerEventPerformanceStatistics = (data: Statistics) => {
 339     this.storage.storePerformanceStatistics(data) as void;
 340   };
 341
 342   private initializeCounters() {
 343     if (this.initializedCounters === false) {
 344       this.resetCounters();
 345       const stationTemplateUrls = Configuration.getStationTemplateUrls()!;
 346       if (isNotEmptyArray(stationTemplateUrls)) {
 347         this.numberOfChargingStationTemplates = stationTemplateUrls.length;
 348         for (const stationTemplateUrl of stationTemplateUrls) {
 349           this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0;
 350         }
 351       } else {
 352         console.warn(
 353           chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting"),
 354         );
 355         process.exit(exitCodes.missingChargingStationsConfiguration);
 356       }
 357       if (this.numberOfChargingStations === 0) {
 358         console.warn(
 359           chalk.yellow('No charging station template enabled in configuration, exiting'),
 360         );
 361         process.exit(exitCodes.noChargingStationTemplates);
 362       }
 363       this.initializedCounters = true;
 364     }
 365   }
 366
 367   private resetCounters(): void {
 368     this.numberOfChargingStationTemplates = 0;
 369     this.numberOfChargingStations = 0;
 370     this.numberOfStartedChargingStations = 0;
 371   }
 372
 373   private async startChargingStation(
 374     index: number,
 375     stationTemplateUrl: StationTemplateUrl,
 376   ): Promise<void> {
 377     await this.workerImplementation?.addElement({
 378       index,
 379       templateFile: join(
 380         dirname(fileURLToPath(import.meta.url)),
 381         'assets',
 382         'station-templates',
 383         stationTemplateUrl.file,
 384       ),
 385     });
 386   }
 387
 388   private gracefulShutdown = (): void => {
 389     console.info(`${chalk.green('Graceful shutdown')}`);
 390     this.stop()
 391       .then(() => {
 392         process.exit(0);
 393       })
 394       .catch((error) => {
 395         console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
 396         process.exit(1);
 397       });
 398   };
 399
 400   private logPrefix = (): string => {
 401     return logPrefix(' Bootstrap |');
 402   };
 403 }