src/charging-station/Bootstrap.ts

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import { ChargingStationWorkerData, WorkerMessage, WorkerMessageEvents } from '../types/Worker';
   4
   5 import Configuration from '../utils/Configuration';
   6 import { Storage } from '../performance/storage/Storage';
   7 import { StorageFactory } from '../performance/storage/StorageFactory';
   8 import Utils from '../utils/Utils';
   9 import WorkerAbstract from '../worker/WorkerAbstract';
  10 import WorkerFactory from '../worker/WorkerFactory';
  11 import chalk from 'chalk';
  12 import { isMainThread } from 'worker_threads';
  13 import path from 'path';
  14 import { version } from '../../package.json';
  15
  16 export default class Bootstrap {
  17   private static instance: Bootstrap | null = null;
  18   private static workerImplementation: WorkerAbstract | null = null;
  19   private static storage: Storage;
  20   private version: string = version;
  21   private started: boolean;
  22   private workerScript: string;
  23
  24   private constructor() {
  25     this.started = false;
  26     this.workerScript = path.join(path.resolve(__dirname, '../'), 'charging-station', 'ChargingStationWorker.js');
  27     this.initWorkerImplementation();
  28     Bootstrap.storage = StorageFactory.getStorage(Configuration.getPerformanceStorage().type, Configuration.getPerformanceStorage().URI, this.logPrefix());
  29     Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart());
  30   }
  31
  32   public static getInstance(): Bootstrap {
  33     if (!Bootstrap.instance) {
  34       Bootstrap.instance = new Bootstrap();
  35     }
  36     return Bootstrap.instance;
  37   }
  38
  39   public async start(): Promise<void> {
  40     if (isMainThread && !this.started) {
  41       try {
  42         let numStationsTotal = 0;
  43         await Bootstrap.storage.open();
  44         await Bootstrap.workerImplementation.start();
  45         // Start ChargingStation object in worker thread
  46         if (Configuration.getStationTemplateURLs()) {
  47           for (const stationURL of Configuration.getStationTemplateURLs()) {
  48             try {
  49               const nbStations = stationURL.numberOfStations ? stationURL.numberOfStations : 0;
  50               for (let index = 1; index <= nbStations; index++) {
  51                 const workerData: ChargingStationWorkerData = {
  52                   index,
  53                   templateFile: path.join(path.resolve(__dirname, '../'), 'assets', 'station-templates', path.basename(stationURL.file))
  54                 };
  55                 await Bootstrap.workerImplementation.addElement(workerData);
  56                 numStationsTotal++;
  57               }
  58             } catch (error) {
  59               console.error(chalk.red('Charging station start with template file ' + stationURL.file + ' error '), error);
  60             }
  61           }
  62         } else {
  63           console.warn(chalk.yellow('No stationTemplateURLs defined in configuration, exiting'));
  64         }
  65         if (numStationsTotal === 0) {
  66           console.warn(chalk.yellow('No charging station template enabled in configuration, exiting'));
  67         } else {
  68           console.log(chalk.green(`Charging stations simulator ${this.version} started with ${numStationsTotal.toString()} charging station(s) and ${Utils.workerDynamicPoolInUse() ? `${Configuration.getWorkerPoolMinSize().toString()}/` : ''}${Bootstrap.workerImplementation.size}${Utils.workerPoolInUse() ? `/${Configuration.getWorkerPoolMaxSize().toString()}` : ''} worker(s) concurrently running in '${Configuration.getWorkerProcess()}' mode${Bootstrap.workerImplementation.maxElementsPerWorker ? ` (${Bootstrap.workerImplementation.maxElementsPerWorker} charging station(s) per worker)` : ''}`));
  69         }
  70         this.started = true;
  71       } catch (error) {
  72         console.error(chalk.red('Bootstrap start error '), error);
  73       }
  74     }
  75   }
  76
  77   public async stop(): Promise<void> {
  78     if (isMainThread && this.started) {
  79       await Bootstrap.workerImplementation.stop();
  80       await Bootstrap.storage.close();
  81     }
  82     this.started = false;
  83   }
  84
  85   public async restart(): Promise<void> {
  86     await this.stop();
  87     this.initWorkerImplementation();
  88     await this.start();
  89   }
  90
  91   private initWorkerImplementation(): void {
  92     Bootstrap.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(this.workerScript, Configuration.getWorkerProcess(),
  93       {
  94         startDelay: Configuration.getWorkerStartDelay(),
  95         poolMaxSize: Configuration.getWorkerPoolMaxSize(),
  96         poolMinSize: Configuration.getWorkerPoolMinSize(),
  97         elementsPerWorker: Configuration.getChargingStationsPerWorker(),
  98         poolOptions: {
  99           workerChoiceStrategy: Configuration.getWorkerPoolStrategy()
 100         },
 101         messageHandler: async (msg: WorkerMessage) => {
 102           if (msg.id === WorkerMessageEvents.PERFORMANCE_STATISTICS) {
 103             await Bootstrap.storage.storePerformanceStatistics(msg.data);
 104           }
 105         }
 106       });
 107   }
 108
 109   private logPrefix(): string {
 110     return Utils.logPrefix(' Bootstrap |');
 111   }
 112 }