src/charging-station/Bootstrap.ts

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import {
   4   ChargingStationWorkerData,
   5   ChargingStationWorkerMessage,
   6   ChargingStationWorkerMessageEvents,
   7 } from '../types/ChargingStationWorker';
   8
   9 import Configuration from '../utils/Configuration';
  10 import { StationTemplateUrl } from '../types/ConfigurationData';
  11 import Statistics from '../types/Statistics';
  12 import { Storage } from '../performance/storage/Storage';
  13 import { StorageFactory } from '../performance/storage/StorageFactory';
  14 import { UIServiceUtils } from './ui-server/ui-services/UIServiceUtils';
  15 import UIWebSocketServer from './ui-server/UIWebSocketServer';
  16 import Utils from '../utils/Utils';
  17 import WorkerAbstract from '../worker/WorkerAbstract';
  18 import WorkerFactory from '../worker/WorkerFactory';
  19 import chalk from 'chalk';
  20 import { isMainThread } from 'worker_threads';
  21 import path from 'path';
  22 import { version } from '../../package.json';
  23
  24 export default class Bootstrap {
  25   private static instance: Bootstrap | null = null;
  26   private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null = null;
  27   private readonly uiServer!: UIWebSocketServer;
  28   private readonly storage!: Storage;
  29   private numberOfChargingStations: number;
  30   private readonly version: string = version;
  31   private started: boolean;
  32   private readonly workerScript: string;
  33
  34   private constructor() {
  35     this.started = false;
  36     this.workerScript = path.join(
  37       path.resolve(__dirname, '../'),
  38       'charging-station',
  39       'ChargingStationWorker.js'
  40     );
  41     this.initWorkerImplementation();
  42     Configuration.getUIServer().enabled &&
  43       (this.uiServer = new UIWebSocketServer({
  44         ...Configuration.getUIServer().options,
  45         handleProtocols: UIServiceUtils.handleProtocols,
  46       }));
  47     Configuration.getPerformanceStorage().enabled &&
  48       (this.storage = StorageFactory.getStorage(
  49         Configuration.getPerformanceStorage().type,
  50         Configuration.getPerformanceStorage().uri,
  51         this.logPrefix()
  52       ));
  53     Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart());
  54   }
  55
  56   public static getInstance(): Bootstrap {
  57     if (!Bootstrap.instance) {
  58       Bootstrap.instance = new Bootstrap();
  59     }
  60     return Bootstrap.instance;
  61   }
  62
  63   public async start(): Promise<void> {
  64     if (isMainThread && !this.started) {
  65       try {
  66         this.numberOfChargingStations = 0;
  67         await this.storage?.open();
  68         await this.workerImplementation.start();
  69         this.uiServer?.start();
  70         const stationTemplateUrls = Configuration.getStationTemplateUrls();
  71         // Start ChargingStation object in worker thread
  72         if (stationTemplateUrls) {
  73           for (const stationTemplateUrl of stationTemplateUrls) {
  74             try {
  75               const nbStations = stationTemplateUrl.numberOfStations ?? 0;
  76               for (let index = 1; index <= nbStations; index++) {
  77                 await this.startChargingStation(index, stationTemplateUrl);
  78               }
  79             } catch (error) {
  80               console.error(
  81                 chalk.red(
  82                   'Error at starting charging station with template file ' +
  83                     stationTemplateUrl.file +
  84                     ': '
  85                 ),
  86                 error
  87               );
  88             }
  89           }
  90         } else {
  91           console.warn(chalk.yellow("No 'stationTemplateUrls' defined in configuration, exiting"));
  92         }
  93         if (this.numberOfChargingStations === 0) {
  94           console.warn(
  95             chalk.yellow('No charging station template enabled in configuration, exiting')
  96           );
  97         } else {
  98           console.log(
  99             chalk.green(
 100               `Charging stations simulator ${
 101                 this.version
 102               } started with ${this.numberOfChargingStations.toString()} charging station(s) and ${
 103                 Utils.workerDynamicPoolInUse()
 104                   ? `${Configuration.getWorkerPoolMinSize().toString()}/`
 105                   : ''
 106               }${this.workerImplementation.size}${
 107                 Utils.workerPoolInUse() ? `/${Configuration.getWorkerPoolMaxSize().toString()}` : ''
 108               } worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${
 109                 this.workerImplementation.maxElementsPerWorker
 110                   ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)`
 111                   : ''
 112               }`
 113             )
 114           );
 115         }
 116         this.started = true;
 117       } catch (error) {
 118         console.error(chalk.red('Bootstrap start error '), error);
 119       }
 120     } else {
 121       console.error(chalk.red('Cannot start an already started charging stations simulator'));
 122     }
 123   }
 124
 125   public async stop(): Promise<void> {
 126     if (isMainThread && this.started) {
 127       await this.workerImplementation.stop();
 128       this.uiServer?.stop();
 129       await this.storage?.close();
 130     } else {
 131       console.error(chalk.red('Trying to stop the charging stations simulator while not started'));
 132     }
 133     this.started = false;
 134   }
 135
 136   public async restart(): Promise<void> {
 137     await this.stop();
 138     this.initWorkerImplementation();
 139     await this.start();
 140   }
 141
 142   private initWorkerImplementation(): void {
 143     this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
 144       this.workerScript,
 145       Configuration.getWorkerProcess(),
 146       {
 147         workerStartDelay: Configuration.getWorkerStartDelay(),
 148         elementStartDelay: Configuration.getElementStartDelay(),
 149         poolMaxSize: Configuration.getWorkerPoolMaxSize(),
 150         poolMinSize: Configuration.getWorkerPoolMinSize(),
 151         elementsPerWorker: Configuration.getChargingStationsPerWorker(),
 152         poolOptions: {
 153           workerChoiceStrategy: Configuration.getWorkerPoolStrategy(),
 154         },
 155         messageHandler: async (msg: ChargingStationWorkerMessage) => {
 156           if (msg.id === ChargingStationWorkerMessageEvents.STARTED) {
 157             this.uiServer.chargingStations.add(msg.data.id as string);
 158           } else if (msg.id === ChargingStationWorkerMessageEvents.STOPPED) {
 159             this.uiServer.chargingStations.delete(msg.data.id as string);
 160           } else if (msg.id === ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS) {
 161             await this.storage.storePerformanceStatistics(msg.data as unknown as Statistics);
 162           }
 163         },
 164       }
 165     );
 166   }
 167
 168   private async startChargingStation(
 169     index: number,
 170     stationTemplateUrl: StationTemplateUrl
 171   ): Promise<void> {
 172     const workerData: ChargingStationWorkerData = {
 173       index,
 174       templateFile: path.join(
 175         path.resolve(__dirname, '../'),
 176         'assets',
 177         'station-templates',
 178         path.basename(stationTemplateUrl.file)
 179       ),
 180     };
 181     await this.workerImplementation.addElement(workerData);
 182     this.numberOfChargingStations++;
 183   }
 184
 185   private logPrefix(): string {
 186     return Utils.logPrefix(' Bootstrap |');
 187   }
 188 }