X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=003b093a3579c02d094addc7f2210e88d14f789b;hb=1cee0015ac704be480535c7228103525cc3c8cc2;hp=4e8b43a9dffb309dc2558cbb909d47ad359185da;hpb=1d8f226b47637e80c74106799208da5df93b2a04;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index 4e8b43a9..003b093a 100644
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -2,8 +2,8 @@
 
 import { EventEmitter } from 'node:events';
 import { dirname, extname, join } from 'node:path';
+import process, { exit } from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { isMainThread } from 'node:worker_threads';
 
 import chalk from 'chalk';
 import { availableParallelism } from 'poolifier';
@@ -11,7 +11,7 @@ import { availableParallelism } from 'poolifier';
 import { waitChargingStationEvents } from './Helpers';
 import type { AbstractUIServer } from './ui-server/AbstractUIServer';
 import { UIServerFactory } from './ui-server/UIServerFactory';
-import { version } from '../../package.json' assert { type: 'json' };
+import { version } from '../../package.json';
 import { BaseError } from '../exception';
 import { type Storage, StorageFactory } from '../performance';
 import {
@@ -56,7 +56,7 @@ export class Bootstrap extends EventEmitter {
   public numberOfChargingStations!: number;
   public numberOfChargingStationTemplates!: number;
   private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null;
-  private readonly uiServer!: AbstractUIServer | null;
+  private readonly uiServer: AbstractUIServer | null;
   private readonly storage!: Storage;
   private numberOfStartedChargingStations!: number;
   private readonly version: string = version;
@@ -69,7 +69,7 @@ export class Bootstrap extends EventEmitter {
   private constructor() {
     super();
     for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) {
-      process.on(signal, this.gracefulShutdown);
+      process.on(signal, this.gracefulShutdown.bind(this));
     }
     // Enable unconditionally for now
     handleUnhandledRejection();
@@ -84,11 +84,9 @@ export class Bootstrap extends EventEmitter {
       dirname(fileURLToPath(import.meta.url)),
       `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`,
     );
-    const uiServerConfiguration = Configuration.getConfigurationSection<UIServerConfiguration>(
-      ConfigurationSection.uiServer,
+    this.uiServer = UIServerFactory.getUIServerImplementation(
+      Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer),
     );
-    uiServerConfiguration.enabled === true &&
-      (this.uiServer = UIServerFactory.getUIServerImplementation(uiServerConfiguration));
     const performanceStorageConfiguration =
       Configuration.getConfigurationSection<StorageConfiguration>(
         ConfigurationSection.performanceStorage,
@@ -99,7 +97,7 @@ export class Bootstrap extends EventEmitter {
         performanceStorageConfiguration.uri!,
         this.logPrefix(),
       ));
-    Configuration.configurationChangeCallback = async () => Bootstrap.getInstance().restart();
+    Configuration.configurationChangeCallback = async () => Bootstrap.getInstance().restart(false);
   }
 
   public static getInstance(): Bootstrap {
@@ -110,9 +108,6 @@ export class Bootstrap extends EventEmitter {
   }
 
   public async start(): Promise<void> {
-    if (!isMainThread) {
-      throw new BaseError('Cannot start charging stations simulator from worker thread');
-    }
     if (this.started === false) {
       if (this.starting === false) {
         this.starting = true;
@@ -123,7 +118,8 @@ export class Bootstrap extends EventEmitter {
         this.initializeWorkerImplementation(workerConfiguration);
         await this.workerImplementation?.start();
         await this.storage?.open();
-        this.uiServer?.start();
+        Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
+          .enabled === true && this.uiServer?.start();
         // Start ChargingStation object instance in worker thread
         for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) {
           try {
@@ -176,36 +172,24 @@ export class Bootstrap extends EventEmitter {
     }
   }
 
-  public async stop(): Promise<void> {
-    if (!isMainThread) {
-      throw new BaseError('Cannot stop charging stations simulator from worker thread');
-    }
+  public async stop(stopChargingStations = true): Promise<void> {
     if (this.started === true) {
       if (this.stopping === false) {
         this.stopping = true;
-        await this.uiServer?.sendInternalRequest(
-          this.uiServer.buildProtocolRequest(
-            generateUUID(),
-            ProcedureName.STOP_CHARGING_STATION,
-            Constants.EMPTY_FROZEN_OBJECT,
-          ),
-        );
-        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);
-          }),
-        ]);
+        if (stopChargingStations === true) {
+          await this.uiServer?.sendInternalRequest(
+            this.uiServer.buildProtocolRequest(
+              generateUUID(),
+              ProcedureName.STOP_CHARGING_STATION,
+              Constants.EMPTY_FROZEN_OBJECT,
+            ),
+          );
+          try {
+            await this.waitChargingStationsStopped();
+          } catch (error) {
+            console.error(chalk.red('Error while waiting for charging stations to stop: '), error);
+          }
+        }
         await this.workerImplementation?.stop();
         this.workerImplementation = null;
         this.uiServer?.stop();
@@ -222,11 +206,35 @@ export class Bootstrap extends EventEmitter {
     }
   }
 
-  public async restart(): Promise<void> {
-    await this.stop();
+  public async restart(stopChargingStations?: boolean): Promise<void> {
+    await this.stop(stopChargingStations);
     await this.start();
   }
 
+  private async waitChargingStationsStopped(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      const waitTimeout = setTimeout(() => {
+        const message = `Timeout ${formatDurationMilliSeconds(
+          Constants.STOP_CHARGING_STATIONS_TIMEOUT,
+        )} reached at stopping charging stations`;
+        console.warn(chalk.yellow(message));
+        reject(new Error(message));
+      }, Constants.STOP_CHARGING_STATIONS_TIMEOUT);
+      waitChargingStationEvents(
+        this,
+        ChargingStationWorkerMessageEvents.stopped,
+        this.numberOfChargingStations,
+      )
+        .then(() => {
+          resolve('Charging stations stopped');
+        })
+        .catch(reject)
+        .finally(() => {
+          clearTimeout(waitTimeout);
+        });
+    });
+  }
+
   private initializeWorkerImplementation(workerConfiguration: WorkerConfiguration): void {
     let elementsPerWorker: number | undefined;
     if (workerConfiguration?.elementsPerWorker === 'auto') {
@@ -258,7 +266,7 @@ export class Bootstrap extends EventEmitter {
     // logger.debug(
     //   `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify(
     //     msg,
-    //     null,
+    //     undefined,
     //     2,
     //   )}`,
     // );
@@ -296,7 +304,7 @@ export class Bootstrap extends EventEmitter {
           throw new BaseError(
             `Unknown charging station worker event: '${
               msg.event
-            }' received with data: ${JSON.stringify(msg.data, null, 2)}`,
+            }' received with data: ${JSON.stringify(msg.data, undefined, 2)}`,
           );
       }
     } catch (error) {
@@ -354,13 +362,13 @@ export class Bootstrap extends EventEmitter {
         console.warn(
           chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting"),
         );
-        process.exit(exitCodes.missingChargingStationsConfiguration);
+        exit(exitCodes.missingChargingStationsConfiguration);
       }
       if (this.numberOfChargingStations === 0) {
         console.warn(
           chalk.yellow('No charging station template enabled in configuration, exiting'),
         );
-        process.exit(exitCodes.noChargingStationTemplates);
+        exit(exitCodes.noChargingStationTemplates);
       }
       this.initializedCounters = true;
     }
@@ -387,17 +395,24 @@ export class Bootstrap extends EventEmitter {
     });
   }
 
-  private gracefulShutdown = (): void => {
-    console.info(`${chalk.green('Graceful shutdown')}`);
+  private gracefulShutdown(): void {
     this.stop()
       .then(() => {
-        process.exit(exitCodes.succeeded);
+        console.info(`${chalk.green('Graceful shutdown')}`);
+        // stop() asks for charging stations to stop by default
+        this.waitChargingStationsStopped()
+          .then(() => {
+            exit(exitCodes.succeeded);
+          })
+          .catch(() => {
+            exit(exitCodes.gracefulShutdownError);
+          });
       })
       .catch((error) => {
         console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
-        process.exit(exitCodes.gracefulShutdownError);
+        exit(exitCodes.gracefulShutdownError);
       });
-  };
+  }
 
   private logPrefix = (): string => {
     return logPrefix(' Bootstrap |');