X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=df0bb8e98cda7c85b30104ba9ed9fac37fceb610;hb=507a34c154d4877cc261df07b942bcef01b87b4b;hp=5f20e74b6ca320224e374bc4cbfe63e55dd70dec;hpb=01f4001e733ebc61423d3023d87b1399b6afa215;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index 5f20e74b..df0bb8e9 100644
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -1,13 +1,15 @@
 // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
 
+import { EventEmitter } from 'node:events';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { type Worker, isMainThread } from 'node:worker_threads';
 
 import chalk from 'chalk';
 
-import { type AbstractUIServer, ChargingStationUtils, UIServerFactory } from './internal';
-import { version } from '../../package.json';
+import type { AbstractUIServer } from './ui-server/AbstractUIServer';
+import { UIServerFactory } from './ui-server/UIServerFactory';
+import packageJson from '../../package.json' assert { type: 'json' };
 import { BaseError } from '../exception';
 import { type Storage, StorageFactory } from '../performance';
 import {
@@ -16,10 +18,18 @@ import {
   type ChargingStationWorkerMessage,
   type ChargingStationWorkerMessageData,
   ChargingStationWorkerMessageEvents,
+  ProcedureName,
   type StationTemplateUrl,
   type Statistics,
 } from '../types';
-import { Configuration, Utils, logger } from '../utils';
+import {
+  Configuration,
+  Constants,
+  Utils,
+  handleUncaughtException,
+  handleUnhandledRejection,
+  logger,
+} from '../utils';
 import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker';
 
 const moduleName = 'Bootstrap';
@@ -29,7 +39,7 @@ enum exitCodes {
   noChargingStationTemplates = 2,
 }
 
-export class Bootstrap {
+export class Bootstrap extends EventEmitter {
   private static instance: Bootstrap | null = null;
   public numberOfChargingStations!: number;
   public numberOfChargingStationTemplates!: number;
@@ -37,22 +47,29 @@ export class Bootstrap {
   private readonly uiServer!: AbstractUIServer | null;
   private readonly storage!: Storage;
   private numberOfStartedChargingStations!: number;
-  private readonly version: string = version;
+  private readonly version: string = packageJson.version;
   private initializedCounters: boolean;
   private started: boolean;
+  private starting: boolean;
+  private stopping: boolean;
   private readonly workerScript: string;
 
   private constructor() {
+    super();
+    for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) {
+      process.on(signal, this.gracefulShutdown);
+    }
     // Enable unconditionally for now
-    this.logUnhandledRejection();
-    this.logUncaughtException();
-    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(
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'),
-      'charging-station',
+      path.dirname(fileURLToPath(import.meta.url)),
       `ChargingStationWorker${path.extname(fileURLToPath(import.meta.url))}`
     );
     Configuration.getUIServer().enabled === true &&
@@ -74,63 +91,90 @@ export class Bootstrap {
   }
 
   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 ${
-            ChargingStationUtils.workerDynamicPoolInUse()
-              ? `${Configuration.getWorker().poolMinSize?.toString()}/`
-              : ''
-          }${this.workerImplementation?.size}${
-            ChargingStationUtils.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.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'));
     }
   }
 
@@ -170,17 +214,24 @@ export class Bootstrap {
     // );
     try {
       switch (msg.id) {
-        case ChargingStationWorkerMessageEvents.STARTED:
+        case ChargingStationWorkerMessageEvents.started:
           this.workerEventStarted(msg.data as ChargingStationData);
+          this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData);
           break;
-        case ChargingStationWorkerMessageEvents.STOPPED:
+        case ChargingStationWorkerMessageEvents.stopped:
           this.workerEventStopped(msg.data as ChargingStationData);
+          this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData);
           break;
-        case ChargingStationWorkerMessageEvents.UPDATED:
+        case ChargingStationWorkerMessageEvents.updated:
           this.workerEventUpdated(msg.data as ChargingStationData);
+          this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData);
           break;
-        case ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS:
+        case ChargingStationWorkerMessageEvents.performanceStatistics:
           this.workerEventPerformanceStatistics(msg.data as Statistics);
+          this.emit(
+            ChargingStationWorkerMessageEvents.performanceStatistics,
+            msg.data as Statistics
+          );
           break;
         default:
           throw new BaseError(
@@ -231,14 +282,13 @@ export class Bootstrap {
 
   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;
-        stationTemplateUrls.forEach((stationTemplateUrl) => {
+        for (const stationTemplateUrl of stationTemplateUrls) {
           this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0;
-        });
+        }
       } else {
         console.warn(
           chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting")
@@ -251,21 +301,14 @@ export class Bootstrap {
         );
         process.exit(exitCodes.noChargingStationTemplates);
       }
-      this.numberOfStartedChargingStations = 0;
       this.initializedCounters = true;
     }
   }
 
-  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 resetCounters(): void {
+    this.numberOfChargingStationTemplates = 0;
+    this.numberOfChargingStations = 0;
+    this.numberOfStartedChargingStations = 0;
   }
 
   private async startChargingStation(
@@ -275,7 +318,7 @@ export class Bootstrap {
     await this.workerImplementation?.addElement({
       index,
       templateFile: path.join(
-        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'),
+        path.dirname(fileURLToPath(import.meta.url)),
         'assets',
         'station-templates',
         stationTemplateUrl.file
@@ -283,6 +326,35 @@ export class Bootstrap {
     });
   }
 
+  private gracefulShutdown = (): void => {
+    console.info(`${chalk.green('Graceful shutdown')}`);
+    this.stop()
+      .then(() => {
+        process.exit(0);
+      })
+      .catch((error) => {
+        console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
+        process.exit(1);
+      });
+  };
+
+  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 |');
   };