X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=e29c6445fefcccb383b4387f93d670a948c57326;hb=45c0ae82dee8cf065f6303c4853c8adfe239dee1;hp=80e14d151bef4897d4f4ec541e967529572d2003;hpb=e4cb2c14d14e95090cca15518594af1c3f369d2b;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index 80e14d15..e29c6445 100644
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -2,13 +2,13 @@
 
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isMainThread } from 'worker_threads';
+import { type Worker, isMainThread } from 'worker_threads';
 
 import chalk from 'chalk';
 
 import { version } from '../../package.json';
 import BaseError from '../exception/BaseError';
-import { Storage } from '../performance/storage/Storage';
+import type { Storage } from '../performance/storage/Storage';
 import { StorageFactory } from '../performance/storage/StorageFactory';
 import {
   ChargingStationData,
@@ -17,27 +17,27 @@ import {
   ChargingStationWorkerMessageData,
   ChargingStationWorkerMessageEvents,
 } from '../types/ChargingStationWorker';
-import { StationTemplateUrl } from '../types/ConfigurationData';
-import Statistics from '../types/Statistics';
-import { ApplicationProtocol } from '../types/UIProtocol';
+import type { StationTemplateUrl } from '../types/ConfigurationData';
+import type { Statistics } from '../types/Statistics';
 import Configuration from '../utils/Configuration';
 import logger from '../utils/Logger';
 import Utils from '../utils/Utils';
-import WorkerAbstract from '../worker/WorkerAbstract';
+import type WorkerAbstract from '../worker/WorkerAbstract';
 import WorkerFactory from '../worker/WorkerFactory';
 import { ChargingStationUtils } from './ChargingStationUtils';
-import { AbstractUIServer } from './ui-server/AbstractUIServer';
-import { UIServiceUtils } from './ui-server/ui-services/UIServiceUtils';
+import type { AbstractUIServer } from './ui-server/AbstractUIServer';
 import UIServerFactory from './ui-server/UIServerFactory';
 
 const moduleName = 'Bootstrap';
 
-const missingChargingStationsConfigurationExitCode = 1;
-const noChargingStationTemplatesExitCode = 2;
+enum exitCodes {
+  missingChargingStationsConfiguration = 1,
+  noChargingStationTemplates = 2,
+}
 
-export default class Bootstrap {
+export class Bootstrap {
   private static instance: Bootstrap | null = null;
-  private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null = null;
+  private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null;
   private readonly uiServer!: AbstractUIServer;
   private readonly storage!: Storage;
   private numberOfChargingStationTemplates!: number;
@@ -49,18 +49,16 @@ export default class Bootstrap {
 
   private constructor() {
     this.started = false;
+    this.workerImplementation = null;
     this.workerScript = path.join(
       path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'),
       'charging-station',
       'ChargingStationWorker' + path.extname(fileURLToPath(import.meta.url))
     );
     this.initialize();
-    Configuration.getUIServer().enabled &&
-      (this.uiServer = UIServerFactory.getUIServerImplementation(ApplicationProtocol.WS, {
-        ...Configuration.getUIServer().options,
-        handleProtocols: UIServiceUtils.handleProtocols,
-      }));
-    Configuration.getPerformanceStorage().enabled &&
+    Configuration.getUIServer().enabled === true &&
+      (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
+    Configuration.getPerformanceStorage().enabled === true &&
       (this.storage = StorageFactory.getStorage(
         Configuration.getPerformanceStorage().type,
         Configuration.getPerformanceStorage().uri,
@@ -77,8 +75,11 @@ export default class Bootstrap {
   }
 
   public async start(): Promise<void> {
-    if (isMainThread && !this.started) {
+    if (isMainThread && this.started === false) {
       try {
+        // Enable unconditionally for now
+        this.logUnhandledRejection();
+        this.logUncaughtException();
         this.initialize();
         await this.storage?.open();
         await this.workerImplementation.start();
@@ -108,13 +109,13 @@ export default class Bootstrap {
           console.warn(
             chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting")
           );
-          process.exit(missingChargingStationsConfigurationExitCode);
+          process.exit(exitCodes.missingChargingStationsConfiguration);
         }
         if (this.numberOfChargingStations === 0) {
           console.warn(
             chalk.yellow('No charging station template enabled in configuration, exiting')
           );
-          process.exit(noChargingStationTemplatesExitCode);
+          process.exit(exitCodes.noChargingStationTemplates);
         } else {
           console.info(
             chalk.green(
@@ -138,7 +139,7 @@ export default class Bootstrap {
         }
         this.started = true;
       } catch (error) {
-        console.error(chalk.red('Bootstrap start error '), error);
+        console.error(chalk.red('Bootstrap start error: '), error);
       }
     } else {
       console.error(chalk.red('Cannot start an already started charging stations simulator'));
@@ -146,15 +147,15 @@ export default class Bootstrap {
   }
 
   public async stop(): Promise<void> {
-    if (isMainThread && this.started) {
+    if (isMainThread && this.started === true) {
       await this.workerImplementation.stop();
       this.workerImplementation = null;
       this.uiServer?.stop();
       await this.storage?.close();
+      this.started = false;
     } else {
-      console.error(chalk.red('Trying to stop the charging stations simulator while not started'));
+      console.error(chalk.red('Cannot stop a not started charging stations simulator'));
     }
-    this.started = false;
   }
 
   public async restart(): Promise<void> {
@@ -164,7 +165,7 @@ export default class Bootstrap {
   }
 
   private initializeWorkerImplementation(): void {
-    !this.workerImplementation &&
+    this.workerImplementation === null &&
       (this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
         this.workerScript,
         Configuration.getWorker().processType,
@@ -178,6 +179,7 @@ export default class Bootstrap {
             workerChoiceStrategy: Configuration.getWorker().poolStrategy,
           },
           messageHandler: this.messageHandler.bind(this) as (
+            this: Worker,
             msg: ChargingStationWorkerMessage<ChargingStationWorkerMessageData>
           ) => void,
         }
@@ -223,19 +225,33 @@ export default class Bootstrap {
     }
   }
 
-  private workerEventStarted(data: ChargingStationData) {
-    this.uiServer?.chargingStations.set(data.hashId, data);
+  private workerEventStarted = (data: ChargingStationData) => {
+    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
     ++this.numberOfStartedChargingStations;
-  }
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station '${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId})' started (${
+        this.numberOfStartedChargingStations
+      } started from ${this.numberOfChargingStations})`
+    );
+  };
 
-  private workerEventStopped(data: ChargingStationData) {
-    this.uiServer?.chargingStations.set(data.hashId, data);
+  private workerEventStopped = (data: ChargingStationData) => {
+    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
     --this.numberOfStartedChargingStations;
-  }
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station '${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId})' stopped (${
+        this.numberOfStartedChargingStations
+      } started from ${this.numberOfChargingStations})`
+    );
+  };
 
-  private workerEventUpdated(data: ChargingStationData) {
-    this.uiServer?.chargingStations.set(data.hashId, data);
-  }
+  private workerEventUpdated = (data: ChargingStationData) => {
+    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
+  };
 
   private workerEventPerformanceStatistics = (data: Statistics) => {
     this.storage.storePerformanceStatistics(data) as void;
@@ -248,6 +264,18 @@ export default class Bootstrap {
     this.initializeWorkerImplementation();
   }
 
+  private logUncaughtException(): void {
+    process.on('uncaughtException', (error: Error) => {
+      console.error(chalk.red('Uncaught exception: '), error);
+    });
+  }
+
+  private logUnhandledRejection(): void {
+    process.on('unhandledRejection', (reason: unknown) => {
+      console.error(chalk.red('Unhandled rejection: '), reason);
+    });
+  }
+
   private async startChargingStation(
     index: number,
     stationTemplateUrl: StationTemplateUrl