fix: ensure event listeners are always removed at simulator stop

[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 05bd7053033250988e3b9dc66dab275a16ac5f34..6620764559974d12e6ca8a89cf7ccae497937e22 100644 (file)
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -55,16 +55,15 @@ export class Bootstrap extends EventEmitter {
   private static instance: Bootstrap | null = null;
   public numberOfChargingStations!: number;
   public numberOfChargingStationTemplates!: number;
-  private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null;
-  private readonly uiServer: AbstractUIServer | null;
-  private readonly storage!: Storage;
+  private workerImplementation?: WorkerAbstract<ChargingStationWorkerData>;
+  private readonly uiServer?: AbstractUIServer;
+  private storage?: Storage;
   private numberOfStartedChargingStations!: number;
   private readonly version: string = version;
   private initializedCounters: boolean;
   private started: boolean;
   private starting: boolean;
   private stopping: boolean;
-  private readonly workerScript: string;
 
   private constructor() {
     super();
@@ -79,24 +78,9 @@ export class Bootstrap extends EventEmitter {
     this.stopping = false;
     this.initializedCounters = false;
     this.initializeCounters();
-    this.workerImplementation = null;
-    this.workerScript = join(
-      dirname(fileURLToPath(import.meta.url)),
-      `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`,
-    );
     this.uiServer = UIServerFactory.getUIServerImplementation(
       Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer),
     );
-    const performanceStorageConfiguration =
-      Configuration.getConfigurationSection<StorageConfiguration>(
-        ConfigurationSection.performanceStorage,
-      );
-    performanceStorageConfiguration.enabled === true &&
-      (this.storage = StorageFactory.getStorage(
-        performanceStorageConfiguration.type!,
-        performanceStorageConfiguration.uri!,
-        this.logPrefix(),
-      ));
     Configuration.configurationChangeCallback = async () => Bootstrap.getInstance().restart(false);
   }
 
@@ -111,13 +95,31 @@ export class Bootstrap extends EventEmitter {
     if (this.started === false) {
       if (this.starting === false) {
         this.starting = true;
+        this.on(ChargingStationWorkerMessageEvents.started, this.workerEventStarted);
+        this.on(ChargingStationWorkerMessageEvents.stopped, this.workerEventStopped);
+        this.on(ChargingStationWorkerMessageEvents.updated, this.workerEventUpdated);
+        this.on(
+          ChargingStationWorkerMessageEvents.performanceStatistics,
+          this.workerEventPerformanceStatistics,
+        );
         this.initializeCounters();
         const workerConfiguration = Configuration.getConfigurationSection<WorkerConfiguration>(
           ConfigurationSection.worker,
         );
         this.initializeWorkerImplementation(workerConfiguration);
         await this.workerImplementation?.start();
-        await this.storage?.open();
+        const performanceStorageConfiguration =
+          Configuration.getConfigurationSection<StorageConfiguration>(
+            ConfigurationSection.performanceStorage,
+          );
+        if (performanceStorageConfiguration.enabled === true) {
+          this.storage = StorageFactory.getStorage(
+            performanceStorageConfiguration.type!,
+            performanceStorageConfiguration.uri!,
+            this.logPrefix(),
+          );
+          await this.storage?.open();
+        }
         Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
           .enabled === true && this.uiServer?.start();
         // Start ChargingStation object instance in worker thread
@@ -191,9 +193,11 @@ export class Bootstrap extends EventEmitter {
           }
         }
         await this.workerImplementation?.stop();
-        this.workerImplementation = null;
+        delete this.workerImplementation;
+        this.removeAllListeners();
         this.uiServer?.stop();
         await this.storage?.close();
+        delete this.storage;
         this.resetCounters();
         this.initializedCounters = false;
         this.started = false;
@@ -228,9 +232,7 @@ export class Bootstrap extends EventEmitter {
         .then(() => {
           resolve('Charging stations stopped');
         })
-        .catch((error) => {
-          reject(error);
-        })
+        .catch(reject)
         .finally(() => {
           clearTimeout(waitTimeout);
         });
@@ -239,27 +241,35 @@ export class Bootstrap extends EventEmitter {
 
   private initializeWorkerImplementation(workerConfiguration: WorkerConfiguration): void {
     let elementsPerWorker: number | undefined;
-    if (workerConfiguration?.elementsPerWorker === 'auto') {
-      elementsPerWorker =
-        this.numberOfChargingStations > availableParallelism()
-          ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5))
-          : 1;
+    switch (workerConfiguration?.elementsPerWorker) {
+      case 'auto':
+        elementsPerWorker =
+          this.numberOfChargingStations > availableParallelism()
+            ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5))
+            : 1;
+        break;
+      case 'all':
+        elementsPerWorker = this.numberOfChargingStations;
+        break;
     }
-    this.workerImplementation === null &&
-      (this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
-        this.workerScript,
-        workerConfiguration.processType!,
-        {
-          workerStartDelay: workerConfiguration.startDelay,
-          elementStartDelay: workerConfiguration.elementStartDelay,
-          poolMaxSize: workerConfiguration.poolMaxSize!,
-          poolMinSize: workerConfiguration.poolMinSize!,
-          elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number),
-          poolOptions: {
-            messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
-          },
+    this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
+      join(
+        dirname(fileURLToPath(import.meta.url)),
+        `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`,
+      ),
+      workerConfiguration.processType!,
+      {
+        workerStartDelay: workerConfiguration.startDelay,
+        elementStartDelay: workerConfiguration.elementStartDelay,
+        poolMaxSize: workerConfiguration.poolMaxSize!,
+        poolMinSize: workerConfiguration.poolMinSize!,
+        elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number),
+        poolOptions: {
+          messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
+          workerOptions: { resourceLimits: workerConfiguration.resourceLimits },
         },
-      ));
+      },
+    );
   }
 
   private messageHandler(
@@ -275,19 +285,15 @@ export class Bootstrap extends EventEmitter {
     try {
       switch (msg.event) {
         case ChargingStationWorkerMessageEvents.started:
-          this.workerEventStarted(msg.data as ChargingStationData);
           this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData);
           break;
         case ChargingStationWorkerMessageEvents.stopped:
-          this.workerEventStopped(msg.data as ChargingStationData);
           this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData);
           break;
         case ChargingStationWorkerMessageEvents.updated:
-          this.workerEventUpdated(msg.data as ChargingStationData);
           this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData);
           break;
         case ChargingStationWorkerMessageEvents.performanceStatistics:
-          this.workerEventPerformanceStatistics(msg.data as Statistics);
           this.emit(
             ChargingStationWorkerMessageEvents.performanceStatistics,
             msg.data as Statistics,
@@ -348,7 +354,7 @@ export class Bootstrap extends EventEmitter {
   };
 
   private workerEventPerformanceStatistics = (data: Statistics) => {
-    this.storage.storePerformanceStatistics(data) as void;
+    this.storage?.storePerformanceStatistics(data) as void;
   };
 
   private initializeCounters() {