// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
import { EventEmitter } from 'node:events';
-import path from 'node:path';
+import { dirname, extname, join } 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 { waitChargingStationEvents } from './ChargingStationUtils';
import type { AbstractUIServer } from './ui-server/AbstractUIServer';
import { UIServerFactory } from './ui-server/UIServerFactory';
-import packageJson from '../../package.json' assert { type: 'json' };
+import { version } from '../../package.json' assert { type: 'json' };
import { BaseError } from '../exception';
import { type Storage, StorageFactory } from '../performance';
import {
import {
Configuration,
Constants,
- Utils,
+ formatDurationMilliSeconds,
+ generateUUID,
handleUncaughtException,
handleUnhandledRejection,
+ isNotEmptyArray,
+ isNullOrUndefined,
+ logPrefix,
logger,
} from '../utils';
-import { type MessageHandler, type WorkerAbstract, WorkerFactory } from '../worker';
+import { type WorkerAbstract, WorkerFactory } from '../worker';
const moduleName = 'Bootstrap';
private readonly uiServer!: AbstractUIServer | null;
private readonly storage!: Storage;
private numberOfStartedChargingStations!: number;
- private readonly version: string = packageJson.version;
+ private readonly version: string = version;
private initializedCounters: boolean;
private started: boolean;
private starting: boolean;
this.initializedCounters = false;
this.initializeCounters();
this.workerImplementation = null;
- this.workerScript = path.join(
- path.dirname(fileURLToPath(import.meta.url)),
- `ChargingStationWorker${path.extname(fileURLToPath(import.meta.url))}`
+ this.workerScript = join(
+ dirname(fileURLToPath(import.meta.url)),
+ `ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`
);
Configuration.getUIServer().enabled === true &&
(this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
}
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();
? `/${Configuration.getWorker().poolMaxSize?.toString()}`
: ''
} worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${
- !Utils.isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
+ !isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
? ` (${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 static pool or worker set mode instead'
+ )
+ );
+ console.info(chalk.green('Worker set/pool information:'), this.workerImplementation?.info);
this.started = true;
this.starting = false;
} else {
}
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(
this.uiServer.buildProtocolRequest(
- Utils.generateUUID(),
+ generateUUID(),
ProcedureName.STOP_CHARGING_STATION,
Constants.EMPTY_FREEZED_OBJECT
)
);
- await this.waitForChargingStationsStopped();
+ 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);
+ }),
+ ]);
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>,
}
));
}
if (this.initializedCounters === false) {
this.resetCounters();
const stationTemplateUrls = Configuration.getStationTemplateUrls();
- if (Utils.isNotEmptyArray(stationTemplateUrls)) {
+ if (isNotEmptyArray(stationTemplateUrls)) {
this.numberOfChargingStationTemplates = stationTemplateUrls.length;
for (const stationTemplateUrl of stationTemplateUrls) {
this.numberOfChargingStations += stationTemplateUrl.numberOfStations ?? 0;
): Promise<void> {
await this.workerImplementation?.addElement({
index,
- templateFile: path.join(
- path.dirname(fileURLToPath(import.meta.url)),
+ templateFile: join(
+ dirname(fileURLToPath(import.meta.url)),
'assets',
'station-templates',
stationTemplateUrl.file
});
};
- 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 |');
+ return logPrefix(' Bootstrap |');
};
}