import { EventEmitter } from 'node:events';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
-import { type Worker, isMainThread } from 'node:worker_threads';
+import { isMainThread } from 'node:worker_threads';
import chalk from 'chalk';
+import { ChargingStationUtils } from './ChargingStationUtils';
import type { AbstractUIServer } from './ui-server/AbstractUIServer';
import { UIServerFactory } from './ui-server/UIServerFactory';
import packageJson from '../../package.json' assert { type: 'json' };
handleUnhandledRejection,
logger,
} from '../utils';
-import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker';
+import { type WorkerAbstract, WorkerFactory } from '../worker';
const moduleName = 'Bootstrap';
}
public async start(): Promise<void> {
- if (isMainThread && this.started === false) {
+ 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();
}
public async stop(): Promise<void> {
- if (isMainThread && this.started === true) {
+ 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(
Constants.EMPTY_FREEZED_OBJECT
)
);
- await this.waitForChargingStationsStopped();
+ await Promise.race([
+ ChargingStationUtils.waitForChargingStationEvents(
+ this,
+ ChargingStationWorkerMessageEvents.stopped,
+ this.numberOfChargingStations
+ ),
+ new Promise<string>((resolve) => {
+ setTimeout(() => {
+ const message = `Timeout reached ${Utils.formatDurationMilliSeconds(
+ Constants.STOP_SIMULATOR_TIMEOUT
+ )} at stopping charging stations simulator`;
+ console.warn(chalk.yellow(message));
+ resolve(message);
+ }, Constants.STOP_SIMULATOR_TIMEOUT);
+ }),
+ ]);
await this.workerImplementation?.stop();
this.workerImplementation = null;
this.uiServer?.stop();
elementsPerWorker: Configuration.getWorker().elementsPerWorker,
poolOptions: {
workerChoiceStrategy: Configuration.getWorker().poolStrategy,
+ messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
},
- messageHandler: this.messageHandler.bind(this) as MessageHandler<Worker>,
}
));
}
});
};
- 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 |');
};