fix: ensure firmware update simulation always run as async resource

[e-mobility-charging-stations-simulator.git] / src / charging-station / Bootstrap.ts

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index db884ed874285adae8c532ff6b3fccb175ec5fbb..df0bb8e98cda7c85b30104ba9ed9fac37fceb610 100644 (file)
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -22,7 +22,14 @@ import {
   type StationTemplateUrl,
   type Statistics,
 } from '../types';
-import { Configuration, Constants, ErrorUtils, Utils, logger } from '../utils';
+import {
+  Configuration,
+  Constants,
+  Utils,
+  handleUncaughtException,
+  handleUnhandledRejection,
+  logger,
+} from '../utils';
 import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker';
 
 const moduleName = 'Bootstrap';
@@ -43,6 +50,8 @@ export class Bootstrap extends EventEmitter {
   private readonly version: string = packageJson.version;
   private initializedCounters: boolean;
   private started: boolean;
+  private starting: boolean;
+  private stopping: boolean;
   private readonly workerScript: string;
 
   private constructor() {
@@ -51,10 +60,12 @@ export class Bootstrap extends EventEmitter {
       process.on(signal, this.gracefulShutdown);
     }
     // Enable unconditionally for now
-    ErrorUtils.handleUnhandledRejection();
-    ErrorUtils.handleUncaughtException();
-    this.initializedCounters = false;
+    handleUnhandledRejection();
+    handleUncaughtException();
     this.started = false;
+    this.starting = false;
+    this.stopping = false;
+    this.initializedCounters = false;
     this.initializeCounters();
     this.workerImplementation = null;
     this.workerScript = path.join(
@@ -80,71 +91,90 @@ export class Bootstrap extends EventEmitter {
   }
 
   public async start(): Promise<void> {
-    if (isMainThread && this.started === false) {
-      this.initializeCounters();
-      this.initializeWorkerImplementation();
-      await this.workerImplementation?.start();
-      await this.storage?.open();
-      this.uiServer?.start();
-      // Start ChargingStation object instance in worker thread
-      for (const stationTemplateUrl of Configuration.getStationTemplateUrls()) {
-        try {
-          const nbStations = stationTemplateUrl.numberOfStations ?? 0;
-          for (let index = 1; index <= nbStations; index++) {
-            await this.startChargingStation(index, stationTemplateUrl);
+    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();
+        this.initializeWorkerImplementation();
+        await this.workerImplementation?.start();
+        await this.storage?.open();
+        this.uiServer?.start();
+        // Start ChargingStation object instance in worker thread
+        for (const stationTemplateUrl of Configuration.getStationTemplateUrls()) {
+          try {
+            const nbStations = stationTemplateUrl.numberOfStations ?? 0;
+            for (let index = 1; index <= nbStations; index++) {
+              await this.startChargingStation(index, stationTemplateUrl);
+            }
+          } catch (error) {
+            console.error(
+              chalk.red(
+                `Error at starting charging station with template file ${stationTemplateUrl.file}: `
+              ),
+              error
+            );
           }
-        } catch (error) {
-          console.error(
-            chalk.red(
-              `Error at starting charging station with template file ${stationTemplateUrl.file}: `
-            ),
-            error
-          );
         }
+        console.info(
+          chalk.green(
+            `Charging stations simulator ${
+              this.version
+            } started with ${this.numberOfChargingStations.toString()} charging station(s) from ${this.numberOfChargingStationTemplates.toString()} configured charging station template(s) and ${
+              Configuration.workerDynamicPoolInUse()
+                ? `${Configuration.getWorker().poolMinSize?.toString()}/`
+                : ''
+            }${this.workerImplementation?.size}${
+              Configuration.workerPoolInUse()
+                ? `/${Configuration.getWorker().poolMaxSize?.toString()}`
+                : ''
+            } worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${
+              !Utils.isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
+                ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)`
+                : ''
+            }`
+          )
+        );
+        this.started = true;
+        this.starting = false;
+      } else {
+        console.error(chalk.red('Cannot start an already starting charging stations simulator'));
       }
-      console.info(
-        chalk.green(
-          `Charging stations simulator ${
-            this.version
-          } started with ${this.numberOfChargingStations.toString()} charging station(s) from ${this.numberOfChargingStationTemplates.toString()} configured charging station template(s) and ${
-            Configuration.workerDynamicPoolInUse()
-              ? `${Configuration.getWorker().poolMinSize?.toString()}/`
-              : ''
-          }${this.workerImplementation?.size}${
-            Configuration.workerPoolInUse()
-              ? `/${Configuration.getWorker().poolMaxSize?.toString()}`
-              : ''
-          } worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${
-            !Utils.isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
-              ? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)`
-              : ''
-          }`
-        )
-      );
-      this.started = true;
     } else {
       console.error(chalk.red('Cannot start an already started charging stations simulator'));
     }
   }
 
   public async stop(): Promise<void> {
-    if (isMainThread && this.started === true) {
-      await this.uiServer?.sendBroadcastChannelRequest(
-        this.uiServer.buildProtocolRequest(
-          Utils.generateUUID(),
-          ProcedureName.STOP_CHARGING_STATION,
-          Constants.EMPTY_FREEZED_OBJECT
-        )
-      );
-      await this.waitForChargingStationsStopped();
-      await this.workerImplementation?.stop();
-      this.workerImplementation = null;
-      this.uiServer?.stop();
-      await this.storage?.close();
-      this.initializedCounters = false;
-      this.started = false;
+    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(),
+            ProcedureName.STOP_CHARGING_STATION,
+            Constants.EMPTY_FREEZED_OBJECT
+          )
+        );
+        await this.waitForChargingStationsStopped();
+        await this.workerImplementation?.stop();
+        this.workerImplementation = null;
+        this.uiServer?.stop();
+        await this.storage?.close();
+        this.resetCounters();
+        this.initializedCounters = false;
+        this.started = false;
+        this.stopping = false;
+      } else {
+        console.error(chalk.red('Cannot stop an already stopping charging stations simulator'));
+      }
     } else {
-      console.error(chalk.red('Cannot stop a not started charging stations simulator'));
+      console.error(chalk.red('Cannot stop an already stopped charging stations simulator'));
     }
   }
 
@@ -252,8 +282,7 @@ export class Bootstrap extends EventEmitter {
 
   private initializeCounters() {
     if (this.initializedCounters === false) {
-      this.numberOfChargingStationTemplates = 0;
-      this.numberOfChargingStations = 0;
+      this.resetCounters();
       const stationTemplateUrls = Configuration.getStationTemplateUrls();
       if (Utils.isNotEmptyArray(stationTemplateUrls)) {
         this.numberOfChargingStationTemplates = stationTemplateUrls.length;
@@ -272,11 +301,16 @@ export class Bootstrap extends EventEmitter {
         );
         process.exit(exitCodes.noChargingStationTemplates);
       }
-      this.numberOfStartedChargingStations = 0;
       this.initializedCounters = true;
     }
   }
 
+  private resetCounters(): void {
+    this.numberOfChargingStationTemplates = 0;
+    this.numberOfChargingStations = 0;
+    this.numberOfStartedChargingStations = 0;
+  }
+
   private async startChargingStation(
     index: number,
     stationTemplateUrl: StationTemplateUrl
@@ -299,18 +333,23 @@ export class Bootstrap extends EventEmitter {
         process.exit(0);
       })
       .catch((error) => {
-        console.error(chalk.red('Error while stopping charging stations simulator:'), error);
+        console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
         process.exit(1);
       });
   };
 
-  private waitForChargingStationsStopped = async (): Promise<void> => {
+  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 === this.numberOfChargingStations) {
-          resolve();
+        if (stoppedEvents === stoppedEventsToWait) {
+          resolve(stoppedEvents);
         }
       });
     });