ChargingStationWorkerMessageEvents,
} from '../types/ChargingStationWorker';
import type { StationTemplateUrl } from '../types/ConfigurationData';
-import type Statistics from '../types/Statistics';
+import type { Statistics } from '../types/Statistics';
import Configuration from '../utils/Configuration';
import logger from '../utils/Logger';
import Utils from '../utils/Utils';
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;
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();
- if (Configuration.getUIServer().enabled === true) {
- this.uiServer = UIServerFactory.getUIServerImplementation(
- Configuration.getUIServer().type,
- Configuration.getUIServer()
- );
- }
+ Configuration.getUIServer().enabled === true &&
+ (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
Configuration.getPerformanceStorage().enabled === true &&
(this.storage = StorageFactory.getStorage(
Configuration.getPerformanceStorage().type,
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.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> {
}
private initializeWorkerImplementation(): void {
- !this.workerImplementation &&
+ this.workerImplementation === null &&
(this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
this.workerScript,
Configuration.getWorker().processType,
}
}
- private workerEventStarted(data: ChargingStationData) {
+ private workerEventStarted = (data: ChargingStationData) => {
this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
++this.numberOfStartedChargingStations;
- }
+ };
- private workerEventStopped(data: ChargingStationData) {
+ private workerEventStopped = (data: ChargingStationData) => {
this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
--this.numberOfStartedChargingStations;
- }
+ };
- private workerEventUpdated(data: ChargingStationData) {
+ private workerEventUpdated = (data: ChargingStationData) => {
this.uiServer?.chargingStations.set(data.stationInfo.hashId, data);
- }
+ };
private workerEventPerformanceStatistics = (data: Statistics) => {
this.storage.storePerformanceStatistics(data) as void;
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