X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FBootstrap.ts;h=96e7b8ceb2bc30523e2bad399d0a0a0776911d45;hb=56f945900ccdbffb165bc42026fa20158c7032fe;hp=17fe96095a6c197f90d3edf38b2033212424c723;hpb=a307349b9b58052f14cc28b50b97c1113f744782;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/Bootstrap.ts b/src/charging-station/Bootstrap.ts
index 17fe9609..64953a96 100644
--- a/src/charging-station/Bootstrap.ts
+++ b/src/charging-station/Bootstrap.ts
@@ -1,285 +1,595 @@
-// Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
+// Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved.
 
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { type Worker, isMainThread } from 'worker_threads';
+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 chalk from 'chalk'
+import { availableParallelism, type MessageHandler } from 'poolifier'
+import type { Worker } from 'worker_threads'
 
-import { version } from '../../package.json';
-import BaseError from '../exception/BaseError';
-import type { Storage } from '../performance/storage/Storage';
-import { StorageFactory } from '../performance/storage/StorageFactory';
+import { version } from '../../package.json'
+import { BaseError } from '../exception/index.js'
+import { type Storage, StorageFactory } from '../performance/index.js'
 import {
-  ChargingStationData,
-  ChargingStationWorkerData,
-  ChargingStationWorkerMessage,
-  ChargingStationWorkerMessageData,
+  type ChargingStationData,
+  type ChargingStationOptions,
+  type ChargingStationWorkerData,
+  type ChargingStationWorkerEventError,
+  type ChargingStationWorkerMessage,
+  type ChargingStationWorkerMessageData,
   ChargingStationWorkerMessageEvents,
-} from '../types/ChargingStationWorker';
-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 type WorkerAbstract from '../worker/WorkerAbstract';
-import WorkerFactory from '../worker/WorkerFactory';
-import { ChargingStationUtils } from './ChargingStationUtils';
-import type { AbstractUIServer } from './ui-server/AbstractUIServer';
-import UIServerFactory from './ui-server/UIServerFactory';
+  ConfigurationSection,
+  ProcedureName,
+  type SimulatorState,
+  type Statistics,
+  type StorageConfiguration,
+  type TemplateStatistics,
+  type UIServerConfiguration,
+  type WorkerConfiguration
+} from '../types/index.js'
+import {
+  Configuration,
+  Constants,
+  formatDurationMilliSeconds,
+  generateUUID,
+  handleUncaughtException,
+  handleUnhandledRejection,
+  isAsyncFunction,
+  isNotEmptyArray,
+  logger,
+  logPrefix
+} from '../utils/index.js'
+import { type WorkerAbstract, WorkerFactory } from '../worker/index.js'
+import { buildTemplateName, waitChargingStationEvents } from './Helpers.js'
+import type { AbstractUIServer } from './ui-server/AbstractUIServer.js'
+import { UIServerFactory } from './ui-server/UIServerFactory.js'
 
-const moduleName = 'Bootstrap';
+const moduleName = 'Bootstrap'
 
 enum exitCodes {
+  succeeded = 0,
   missingChargingStationsConfiguration = 1,
-  noChargingStationTemplates = 2,
+  duplicateChargingStationTemplateUrls = 2,
+  noChargingStationTemplates = 3,
+  gracefulShutdownError = 4
 }
 
-export class Bootstrap {
-  private static instance: Bootstrap | null = null;
-  private workerImplementation: WorkerAbstract<ChargingStationWorkerData> | null;
-  private readonly uiServer!: AbstractUIServer;
-  private readonly storage!: Storage;
-  private numberOfChargingStationTemplates!: number;
-  private numberOfChargingStations!: number;
-  private numberOfStartedChargingStations!: number;
-  private readonly version: string = version;
-  private started: boolean;
-  private readonly workerScript: string;
+export class Bootstrap extends EventEmitter {
+  private static instance: Bootstrap | null = null
+  private workerImplementation?: WorkerAbstract<ChargingStationWorkerData>
+  private readonly uiServer: AbstractUIServer
+  private storage?: Storage
+  private readonly templateStatistics: Map<string, TemplateStatistics>
+  private readonly version: string = version
+  private initializedCounters: boolean
+  private started: boolean
+  private starting: boolean
+  private stopping: boolean
+  private uiServerStarted: boolean
 
-  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 === true &&
-      (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
-    Configuration.getPerformanceStorage().enabled === true &&
-      (this.storage = StorageFactory.getStorage(
-        Configuration.getPerformanceStorage().type,
-        Configuration.getPerformanceStorage().uri,
-        this.logPrefix()
-      ));
-    Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart());
+  private constructor () {
+    super()
+    for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) {
+      process.on(signal, this.gracefulShutdown.bind(this))
+    }
+    // Enable unconditionally for now
+    handleUnhandledRejection()
+    handleUncaughtException()
+    this.started = false
+    this.starting = false
+    this.stopping = false
+    this.initializedCounters = false
+    this.uiServerStarted = false
+    this.templateStatistics = new Map<string, TemplateStatistics>()
+    this.initializeWorkerImplementation(
+      Configuration.getConfigurationSection<WorkerConfiguration>(ConfigurationSection.worker)
+    )
+    this.uiServer = UIServerFactory.getUIServerImplementation(
+      Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
+    )
+    this.initializeCounters()
+    Configuration.configurationChangeCallback = async () => {
+      if (isMainThread) {
+        await Bootstrap.getInstance().restart()
+      }
+    }
   }
 
-  public static getInstance(): Bootstrap {
+  public static getInstance (): Bootstrap {
     if (Bootstrap.instance === null) {
-      Bootstrap.instance = new Bootstrap();
+      Bootstrap.instance = new Bootstrap()
     }
-    return Bootstrap.instance;
+    return Bootstrap.instance
   }
 
-  public async start(): Promise<void> {
-    if (isMainThread && this.started === false) {
-      try {
-        // Enable unconditionally for now
-        this.logUnhandledRejection();
-        this.logUncaughtException();
-        this.initialize();
-        await this.storage?.open();
-        await this.workerImplementation.start();
-        this.uiServer?.start();
-        const stationTemplateUrls = Configuration.getStationTemplateUrls();
-        this.numberOfChargingStationTemplates = stationTemplateUrls.length;
-        // Start ChargingStation object in worker thread
-        if (!Utils.isEmptyArray(stationTemplateUrls)) {
-          for (const stationTemplateUrl of stationTemplateUrls) {
-            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
-              );
-            }
+  public get numberOfChargingStationTemplates (): number {
+    return this.templateStatistics.size
+  }
+
+  public get numberOfConfiguredChargingStations (): number {
+    return [...this.templateStatistics.values()].reduce(
+      (accumulator, value) => accumulator + value.configured,
+      0
+    )
+  }
+
+  public getState (): SimulatorState {
+    return {
+      version: this.version,
+      started: this.started,
+      templateStatistics: this.templateStatistics
+    }
+  }
+
+  public getLastIndex (templateName: string): number {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const indexes = [...this.templateStatistics.get(templateName)!.indexes]
+      .concat(0)
+      .sort((a, b) => a - b)
+    for (let i = 0; i < indexes.length - 1; i++) {
+      if (indexes[i + 1] - indexes[i] !== 1) {
+        return indexes[i]
+      }
+    }
+    return indexes[indexes.length - 1]
+  }
+
+  public getPerformanceStatistics (): IterableIterator<Statistics> | undefined {
+    return this.storage?.getPerformanceStatistics()
+  }
+
+  private get numberOfAddedChargingStations (): number {
+    return [...this.templateStatistics.values()].reduce(
+      (accumulator, value) => accumulator + value.added,
+      0
+    )
+  }
+
+  private get numberOfStartedChargingStations (): number {
+    return [...this.templateStatistics.values()].reduce(
+      (accumulator, value) => accumulator + value.started,
+      0
+    )
+  }
+
+  public async start (): Promise<void> {
+    if (!this.started) {
+      if (!this.starting) {
+        this.starting = true
+        this.on(ChargingStationWorkerMessageEvents.added, this.workerEventAdded)
+        this.on(ChargingStationWorkerMessageEvents.deleted, this.workerEventDeleted)
+        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.on(
+          ChargingStationWorkerMessageEvents.workerElementError,
+          (eventError: ChargingStationWorkerEventError) => {
+            logger.error(
+              `${this.logPrefix()} ${moduleName}.start: Error occurred while handling '${eventError.event}' event on worker:`,
+              eventError
+            )
           }
+        )
+        this.initializeCounters()
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        if (isAsyncFunction(this.workerImplementation?.start)) {
+          await this.workerImplementation.start()
         } else {
-          console.warn(
-            chalk.yellow("'stationTemplateUrls' not defined or empty in configuration, exiting")
-          );
-          process.exit(exitCodes.missingChargingStationsConfiguration);
+          (this.workerImplementation?.start as () => void)()
         }
-        if (this.numberOfChargingStations === 0) {
-          console.warn(
-            chalk.yellow('No charging station template enabled in configuration, exiting')
-          );
-          process.exit(exitCodes.noChargingStationTemplates);
-        } else {
-          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${
-                this.workerImplementation.maxElementsPerWorker
-                  ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)`
-                  : ''
-              }`
+        const performanceStorageConfiguration =
+          Configuration.getConfigurationSection<StorageConfiguration>(
+            ConfigurationSection.performanceStorage
+          )
+        if (performanceStorageConfiguration.enabled === true) {
+          this.storage = StorageFactory.getStorage(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            performanceStorageConfiguration.type!,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            performanceStorageConfiguration.uri!,
+            this.logPrefix()
+          )
+          await this.storage?.open()
+        }
+        if (
+          !this.uiServerStarted &&
+          Configuration.getConfigurationSection<UIServerConfiguration>(
+            ConfigurationSection.uiServer
+          ).enabled === true
+        ) {
+          this.uiServer.start()
+          this.uiServerStarted = true
+        }
+        // Start ChargingStation object instance in worker thread
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) {
+          try {
+            const nbStations = stationTemplateUrl.numberOfStations
+            for (let index = 1; index <= nbStations; index++) {
+              await this.addChargingStation(index, stationTemplateUrl.file)
+            }
+          } catch (error) {
+            console.error(
+              chalk.red(
+                `Error at starting charging station with template file ${stationTemplateUrl.file}: `
+              ),
+              error
             )
-          );
+          }
         }
-        this.started = true;
-      } catch (error) {
-        console.error(chalk.red('Bootstrap start error: '), error);
+        const workerConfiguration = Configuration.getConfigurationSection<WorkerConfiguration>(
+          ConfigurationSection.worker
+        )
+        console.info(
+          chalk.green(
+            `Charging stations simulator ${
+              this.version
+            } started with ${this.numberOfConfiguredChargingStations} configured charging station(s) from ${this.numberOfChargingStationTemplates} charging station template(s) and ${
+              Configuration.workerDynamicPoolInUse() ? `${workerConfiguration.poolMinSize}/` : ''
+            }${this.workerImplementation?.size}${
+              Configuration.workerPoolInUse() ? `/${workerConfiguration.poolMaxSize}` : ''
+            } worker(s) concurrently running in '${workerConfiguration.processType}' mode${
+              this.workerImplementation?.maxElementsPerWorker != null
+                ? ` (${this.workerImplementation.maxElementsPerWorker} charging station(s) per worker)`
+                : ''
+            }`
+          )
+        )
+        Configuration.workerDynamicPoolInUse() &&
+          console.warn(
+            chalk.yellow(
+              'Charging stations simulator is using dynamic pool mode. This is an experimental feature with known issues.\nPlease consider using fixed pool or worker set mode instead'
+            )
+          )
+        console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info)
+        this.started = true
+        this.starting = false
+      } else {
+        console.error(chalk.red('Cannot start an already starting charging stations simulator'))
       }
     } else {
-      console.error(chalk.red('Cannot start an already started charging stations simulator'));
+      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.started = false;
+  public async stop (): Promise<void> {
+    if (this.started) {
+      if (!this.stopping) {
+        this.stopping = 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.removeAllListeners()
+        this.uiServer.clearCaches()
+        this.initializedCounters = false
+        await this.storage?.close()
+        delete this.storage
+        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'))
+    }
+  }
+
+  private async restart (): Promise<void> {
+    await this.stop()
+    // FIXME: initialize worker implementation only if the worker section has changed
+    this.initializeWorkerImplementation(
+      Configuration.getConfigurationSection<WorkerConfiguration>(ConfigurationSection.worker)
+    )
+    if (
+      this.uiServerStarted &&
+      Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
+        .enabled !== true
+    ) {
+      this.uiServer.stop()
+      this.uiServerStarted = false
     }
+    await this.start()
   }
 
-  public async restart(): Promise<void> {
-    await this.stop();
-    this.initialize();
-    await this.start();
+  private async waitChargingStationsStopped (): Promise<string> {
+    return await new Promise<string>((resolve, reject: (reason?: unknown) => void) => {
+      const waitTimeout = setTimeout(() => {
+        const timeoutMessage = `Timeout ${formatDurationMilliSeconds(
+          Constants.STOP_CHARGING_STATIONS_TIMEOUT
+        )} reached at stopping charging stations`
+        console.warn(chalk.yellow(timeoutMessage))
+        reject(new Error(timeoutMessage))
+      }, Constants.STOP_CHARGING_STATIONS_TIMEOUT)
+      waitChargingStationEvents(
+        this,
+        ChargingStationWorkerMessageEvents.stopped,
+        this.numberOfStartedChargingStations
+      )
+        .then(() => {
+          resolve('Charging stations stopped')
+        })
+        .catch(reject)
+        .finally(() => {
+          clearTimeout(waitTimeout)
+        })
+    })
   }
 
-  private initializeWorkerImplementation(): void {
-    this.workerImplementation === null &&
-      (this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
-        this.workerScript,
-        Configuration.getWorker().processType,
-        {
-          workerStartDelay: Configuration.getWorker().startDelay,
-          elementStartDelay: Configuration.getWorker().elementStartDelay,
-          poolMaxSize: Configuration.getWorker().poolMaxSize,
-          poolMinSize: Configuration.getWorker().poolMinSize,
-          elementsPerWorker: Configuration.getWorker().elementsPerWorker,
-          poolOptions: {
-            workerChoiceStrategy: Configuration.getWorker().poolStrategy,
-          },
-          messageHandler: this.messageHandler.bind(this) as (
-            this: Worker,
-            msg: ChargingStationWorkerMessage<ChargingStationWorkerMessageData>
-          ) => void,
+  private initializeWorkerImplementation (workerConfiguration: WorkerConfiguration): void {
+    if (!isMainThread) {
+      return
+    }
+    let elementsPerWorker: number
+    switch (workerConfiguration.elementsPerWorker) {
+      case 'all':
+        elementsPerWorker = this.numberOfConfiguredChargingStations
+        break
+      case 'auto':
+      default:
+        elementsPerWorker =
+          this.numberOfConfiguredChargingStations > availableParallelism()
+            ? Math.round(this.numberOfConfiguredChargingStations / (availableParallelism() * 1.5))
+            : 1
+        break
+    }
+    this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
+      join(
+        dirname(fileURLToPath(import.meta.url)),
+        `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`
+      ),
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      workerConfiguration.processType!,
+      {
+        workerStartDelay: workerConfiguration.startDelay,
+        elementAddDelay: workerConfiguration.elementAddDelay,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        poolMaxSize: workerConfiguration.poolMaxSize!,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        poolMinSize: workerConfiguration.poolMinSize!,
+        elementsPerWorker,
+        poolOptions: {
+          messageHandler: this.messageHandler.bind(this) as MessageHandler<Worker>,
+          ...(workerConfiguration.resourceLimits != null && {
+            workerOptions: { resourceLimits: workerConfiguration.resourceLimits }
+          })
         }
-      ));
+      }
+    )
   }
 
-  private messageHandler(
+  private messageHandler (
     msg: ChargingStationWorkerMessage<ChargingStationWorkerMessageData>
   ): void {
     // logger.debug(
     //   `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify(
     //     msg,
-    //     null,
+    //     undefined,
     //     2
     //   )}`
-    // );
+    // )
     try {
-      switch (msg.id) {
-        case ChargingStationWorkerMessageEvents.STARTED:
-          this.workerEventStarted(msg.data as ChargingStationData);
-          break;
-        case ChargingStationWorkerMessageEvents.STOPPED:
-          this.workerEventStopped(msg.data as ChargingStationData);
-          break;
-        case ChargingStationWorkerMessageEvents.UPDATED:
-          this.workerEventUpdated(msg.data as ChargingStationData);
-          break;
-        case ChargingStationWorkerMessageEvents.PERFORMANCE_STATISTICS:
-          this.workerEventPerformanceStatistics(msg.data as Statistics);
-          break;
+      switch (msg.event) {
+        case ChargingStationWorkerMessageEvents.added:
+          this.emit(ChargingStationWorkerMessageEvents.added, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.deleted:
+          this.emit(ChargingStationWorkerMessageEvents.deleted, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.started:
+          this.emit(ChargingStationWorkerMessageEvents.started, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.stopped:
+          this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.updated:
+          this.emit(ChargingStationWorkerMessageEvents.updated, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.performanceStatistics:
+          this.emit(ChargingStationWorkerMessageEvents.performanceStatistics, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.addedWorkerElement:
+          this.emit(ChargingStationWorkerMessageEvents.addWorkerElement, msg.data)
+          break
+        case ChargingStationWorkerMessageEvents.workerElementError:
+          this.emit(ChargingStationWorkerMessageEvents.workerElementError, msg.data)
+          break
         default:
           throw new BaseError(
-            `Unknown event type: '${msg.id}' for data: ${JSON.stringify(msg.data, null, 2)}`
-          );
+            `Unknown charging station worker event: '${
+              msg.event
+            }' received with data: ${JSON.stringify(msg.data, undefined, 2)}`
+          )
       }
     } catch (error) {
       logger.error(
         `${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${
-          msg.id
+          msg.event
         }' event:`,
         error
-      );
+      )
     }
   }
 
-  private workerEventStarted = (data: ChargingStationData) => {
-    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
-    ++this.numberOfStartedChargingStations;
-  };
+  private readonly workerEventAdded = (data: ChargingStationData): void => {
+    this.uiServer.chargingStations.set(data.stationInfo.hashId, data)
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventAdded: Charging station ${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId}) added (${
+        this.numberOfAddedChargingStations
+      } added from ${this.numberOfConfiguredChargingStations} configured charging station(s))`
+    )
+  }
 
-  private workerEventStopped = (data: ChargingStationData) => {
-    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
-    --this.numberOfStartedChargingStations;
-  };
+  private readonly workerEventDeleted = (data: ChargingStationData): void => {
+    this.uiServer.chargingStations.delete(data.stationInfo.hashId)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const templateStatistics = this.templateStatistics.get(data.stationInfo.templateName)!
+    --templateStatistics.added
+    templateStatistics.indexes.delete(data.stationInfo.templateIndex)
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventDeleted: Charging station ${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId}) deleted (${
+        this.numberOfAddedChargingStations
+      } added from ${this.numberOfConfiguredChargingStations} configured charging station(s))`
+    )
+  }
 
-  private workerEventUpdated = (data: ChargingStationData) => {
-    this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
-  };
+  private readonly workerEventStarted = (data: ChargingStationData): void => {
+    this.uiServer.chargingStations.set(data.stationInfo.hashId, data)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ++this.templateStatistics.get(data.stationInfo.templateName)!.started
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId}) started (${
+        this.numberOfStartedChargingStations
+      } started from ${this.numberOfAddedChargingStations} added charging station(s))`
+    )
+  }
 
-  private workerEventPerformanceStatistics = (data: Statistics) => {
-    this.storage.storePerformanceStatistics(data) as void;
-  };
+  private readonly workerEventStopped = (data: ChargingStationData): void => {
+    this.uiServer.chargingStations.set(data.stationInfo.hashId, data)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    --this.templateStatistics.get(data.stationInfo.templateName)!.started
+    logger.info(
+      `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${
+        data.stationInfo.chargingStationId
+      } (hashId: ${data.stationInfo.hashId}) stopped (${
+        this.numberOfStartedChargingStations
+      } started from ${this.numberOfAddedChargingStations} added charging station(s))`
+    )
+  }
 
-  private initialize() {
-    this.numberOfChargingStationTemplates = 0;
-    this.numberOfChargingStations = 0;
-    this.numberOfStartedChargingStations = 0;
-    this.initializeWorkerImplementation();
+  private readonly workerEventUpdated = (data: ChargingStationData): void => {
+    this.uiServer.chargingStations.set(data.stationInfo.hashId, data)
   }
 
-  private logUncaughtException(): void {
-    process.on('uncaughtException', (error: Error) => {
-      console.error(chalk.red('Uncaught exception: '), error);
-    });
+  private readonly workerEventPerformanceStatistics = (data: Statistics): void => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    if (isAsyncFunction(this.storage?.storePerformanceStatistics)) {
+      (
+        this.storage.storePerformanceStatistics as (
+          performanceStatistics: Statistics
+        ) => Promise<void>
+      )(data).catch(Constants.EMPTY_FUNCTION)
+    } else {
+      (this.storage?.storePerformanceStatistics as (performanceStatistics: Statistics) => void)(
+        data
+      )
+    }
   }
 
-  private logUnhandledRejection(): void {
-    process.on('unhandledRejection', (reason: unknown) => {
-      console.error(chalk.red('Unhandled rejection: '), reason);
-    });
+  private initializeCounters (): void {
+    if (!this.initializedCounters) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const stationTemplateUrls = Configuration.getStationTemplateUrls()!
+      if (isNotEmptyArray(stationTemplateUrls)) {
+        for (const stationTemplateUrl of stationTemplateUrls) {
+          const templateName = buildTemplateName(stationTemplateUrl.file)
+          this.templateStatistics.set(templateName, {
+            configured: stationTemplateUrl.numberOfStations,
+            added: 0,
+            started: 0,
+            indexes: new Set<number>()
+          })
+          this.uiServer.chargingStationTemplates.add(templateName)
+        }
+        if (this.templateStatistics.size !== stationTemplateUrls.length) {
+          console.error(
+            chalk.red(
+              "'stationTemplateUrls' contains duplicate entries, please check your configuration"
+            )
+          )
+          exit(exitCodes.duplicateChargingStationTemplateUrls)
+        }
+      } else {
+        console.error(
+          chalk.red("'stationTemplateUrls' not defined or empty, please check your configuration")
+        )
+        exit(exitCodes.missingChargingStationsConfiguration)
+      }
+      if (
+        this.numberOfConfiguredChargingStations === 0 &&
+        Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
+          .enabled !== true
+      ) {
+        console.error(
+          chalk.red(
+            "'stationTemplateUrls' has no charging station enabled and UI server is disabled, please check your configuration"
+          )
+        )
+        exit(exitCodes.noChargingStationTemplates)
+      }
+      this.initializedCounters = true
+    }
   }
 
-  private async startChargingStation(
+  public async addChargingStation (
     index: number,
-    stationTemplateUrl: StationTemplateUrl
+    templateFile: string,
+    options?: ChargingStationOptions
   ): Promise<void> {
-    const workerData: ChargingStationWorkerData = {
+    if (!this.started && !this.starting) {
+      throw new BaseError(
+        'Cannot add charging station while the charging stations simulator is not started'
+      )
+    }
+    await this.workerImplementation?.addElement({
       index,
-      templateFile: path.join(
-        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'),
+      templateFile: join(
+        dirname(fileURLToPath(import.meta.url)),
         'assets',
         'station-templates',
-        stationTemplateUrl.file
+        templateFile
       ),
-    };
-    await this.workerImplementation.addElement(workerData);
-    ++this.numberOfChargingStations;
+      options
+    })
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const templateStatistics = this.templateStatistics.get(buildTemplateName(templateFile))!
+    ++templateStatistics.added
+    templateStatistics.indexes.add(index)
+  }
+
+  private gracefulShutdown (): void {
+    this.stop()
+      .then(() => {
+        console.info(chalk.green('Graceful shutdown'))
+        this.uiServer.stop()
+        this.uiServerStarted = false
+        this.waitChargingStationsStopped()
+          .then(() => {
+            exit(exitCodes.succeeded)
+          })
+          .catch(() => {
+            exit(exitCodes.gracefulShutdownError)
+          })
+      })
+      .catch((error: unknown) => {
+        console.error(chalk.red('Error while shutdowning charging stations simulator: '), error)
+        exit(exitCodes.gracefulShutdownError)
+      })
   }
 
-  private logPrefix(): string {
-    return Utils.logPrefix(' Bootstrap |');
+  private readonly logPrefix = (): string => {
+    return logPrefix(' Bootstrap |')
   }
 }