X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=ba4d14a8369b36e6a0696027d66ec9fb7906e2ca;hb=b2b606263e2676354259164d532ff9aa91ccdf87;hp=dc1e2f1cab9c360b673d06d30382add0f02b6827;hpb=82e9c15a91568d8a391677f11c315f4b253336ce;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index dc1e2f1c..ba4d14a8 100644
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -1,15 +1,16 @@
 // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
 
 import { EventEmitter } from 'node:events';
-import path from 'node:path';
+import { dirname, extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { type Worker, isMainThread } from 'node:worker_threads';
+import { isMainThread } from 'node:worker_threads';
 
 import chalk from 'chalk';
 
+import { waitChargingStationEvents } from './ChargingStationUtils';
 import type { AbstractUIServer } from './ui-server/AbstractUIServer';
 import { UIServerFactory } from './ui-server/UIServerFactory';
-import packageJson from '../../package.json' assert { type: 'json' };
+import { version } from '../../package.json' assert { type: 'json' };
 import { BaseError } from '../exception';
 import { type Storage, StorageFactory } from '../performance';
 import {
@@ -25,12 +26,16 @@ import {
 import {
   Configuration,
   Constants,
-  Utils,
+  formatDurationMilliSeconds,
+  generateUUID,
   handleUncaughtException,
   handleUnhandledRejection,
+  isNotEmptyArray,
+  isNullOrUndefined,
+  logPrefix,
   logger,
 } from '../utils';
-import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker';
+import { type WorkerAbstract, WorkerFactory } from '../worker';
 
 const moduleName = 'Bootstrap';
 
@@ -47,7 +52,7 @@ export class Bootstrap extends EventEmitter {
   private readonly uiServer!: AbstractUIServer | null;
   private readonly storage!: Storage;
   private numberOfStartedChargingStations!: number;
-  private readonly version: string = packageJson.version;
+  private readonly version: string = version;
   private initializedCounters: boolean;
   private started: boolean;
   private starting: boolean;
@@ -68,9 +73,9 @@ export class Bootstrap extends EventEmitter {
     this.initializedCounters = false;
     this.initializeCounters();
     this.workerImplementation = null;
-    this.workerScript = path.join(
-      path.dirname(fileURLToPath(import.meta.url)),
-      `ChargingStationWorker${path.extname(fileURLToPath(import.meta.url))}`
+    this.workerScript = join(
+      dirname(fileURLToPath(import.meta.url)),
+      `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`
     );
     Configuration.getUIServer().enabled === true &&
       (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
@@ -91,7 +96,10 @@ export class Bootstrap extends EventEmitter {
   }
 
   public async start(): Promise<void> {
-    if (isMainThread && this.started === false) {
+    if (!isMainThread) {
+      throw new Error('Cannot start charging stations simulator from worker thread');
+    }
+    if (this.started === false) {
       if (this.starting === false) {
         this.starting = true;
         this.initializeCounters();
@@ -128,12 +136,19 @@ export class Bootstrap extends EventEmitter {
                 ? `/${Configuration.getWorker().poolMaxSize?.toString()}`
                 : ''
             } worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${
-              !Utils.isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
+              !isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
                 ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)`
                 : ''
             }`
           )
         );
+        Configuration.workerDynamicPoolInUse() &&
+          console.warn(
+            chalk.yellow(
+              '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'
+            )
+          );
+        console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info);
         this.started = true;
         this.starting = false;
       } else {
@@ -145,17 +160,35 @@ export class Bootstrap extends EventEmitter {
   }
 
   public async stop(): Promise<void> {
-    if (isMainThread && this.started === true) {
+    if (!isMainThread) {
+      throw new Error('Cannot stop charging stations simulator from worker thread');
+    }
+    if (this.started === true) {
       if (this.stopping === false) {
         this.stopping = true;
         await this.uiServer?.sendInternalRequest(
           this.uiServer.buildProtocolRequest(
-            Utils.generateUUID(),
+            generateUUID(),
             ProcedureName.STOP_CHARGING_STATION,
             Constants.EMPTY_FREEZED_OBJECT
           )
         );
-        await this.waitForChargingStationsStopped();
+        await Promise.race([
+          waitChargingStationEvents(
+            this,
+            ChargingStationWorkerMessageEvents.stopped,
+            this.numberOfChargingStations
+          ),
+          new Promise<string>((resolve) => {
+            setTimeout(() => {
+              const message = `Timeout reached ${formatDurationMilliSeconds(
+                Constants.STOP_SIMULATOR_TIMEOUT
+              )} at stopping charging stations simulator`;
+              console.warn(chalk.yellow(message));
+              resolve(message);
+            }, Constants.STOP_SIMULATOR_TIMEOUT);
+          }),
+        ]);
         await this.workerImplementation?.stop();
         this.workerImplementation = null;
         this.uiServer?.stop();
@@ -190,8 +223,8 @@ export class Bootstrap extends EventEmitter {
           elementsPerWorker: Configuration.getWorker().elementsPerWorker,
           poolOptions: {
             workerChoiceStrategy: Configuration.getWorker().poolStrategy,
+            messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
           },
-          messageHandler: this.messageHandler.bind(this) as MessageHandler<Worker>,
         }
       ));
   }
@@ -278,7 +311,7 @@ export class Bootstrap extends EventEmitter {
     if (this.initializedCounters === false) {
       this.resetCounters();
       const stationTemplateUrls = Configuration.getStationTemplateUrls();
-      if (Utils.isNotEmptyArray(stationTemplateUrls)) {
+      if (isNotEmptyArray(stationTemplateUrls)) {
         this.numberOfChargingStationTemplates = stationTemplateUrls.length;
         for (const stationTemplateUrl of stationTemplateUrls) {
           this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0;
@@ -311,8 +344,8 @@ export class Bootstrap extends EventEmitter {
   ): Promise<void> {
     await this.workerImplementation?.addElement({
       index,
-      templateFile: path.join(
-        path.dirname(fileURLToPath(import.meta.url)),
+      templateFile: join(
+        dirname(fileURLToPath(import.meta.url)),
         'assets',
         'station-templates',
         stationTemplateUrl.file
@@ -332,24 +365,7 @@ export class Bootstrap extends EventEmitter {
       });
   };
 
-  private waitForChargingStationsStopped = async (
-    stoppedEventsToWait = this.numberOfStartedChargingStations
-  ): Promise<number> => {
-    return new Promise((resolve) => {
-      let stoppedEvents = 0;
-      if (stoppedEventsToWait === 0) {
-        resolve(stoppedEvents);
-      }
-      this.on(ChargingStationWorkerMessageEvents.stopped, () => {
-        ++stoppedEvents;
-        if (stoppedEvents === stoppedEventsToWait) {
-          resolve(stoppedEvents);
-        }
-      });
-    });
-  };
-
   private logPrefix = (): string => {
-    return Utils.logPrefix(' Bootstrap |');
+    return logPrefix(' Bootstrap |');
   };
 }