import { isMainThread } from 'node:worker_threads';
import chalk from 'chalk';
+import { availableParallelism } from 'poolifier';
-import { waitChargingStationEvents } from './ChargingStationUtils';
+import { waitChargingStationEvents } from './Helpers';
import type { AbstractUIServer } from './ui-server/AbstractUIServer';
import { UIServerFactory } from './ui-server/UIServerFactory';
import { version } from '../../package.json' assert { type: 'json' };
type ChargingStationWorkerMessage,
type ChargingStationWorkerMessageData,
ChargingStationWorkerMessageEvents,
+ ConfigurationSection,
ProcedureName,
type StationTemplateUrl,
type Statistics,
+ type StorageConfiguration,
+ type UIServerConfiguration,
+ type WorkerConfiguration,
} from '../types';
import {
Configuration,
const moduleName = 'Bootstrap';
enum exitCodes {
+ succeeded = 0,
missingChargingStationsConfiguration = 1,
noChargingStationTemplates = 2,
+ gracefulShutdownError = 3,
}
export class Bootstrap extends EventEmitter {
dirname(fileURLToPath(import.meta.url)),
`ChargingStationWorker${extname(fileURLToPath(import.meta.url))}`,
);
- Configuration.getUIServer().enabled === true &&
- (this.uiServer = UIServerFactory.getUIServerImplementation(Configuration.getUIServer()));
- Configuration.getPerformanceStorage().enabled === true &&
+ const uiServerConfiguration = Configuration.getConfigurationSection<UIServerConfiguration>(
+ ConfigurationSection.uiServer,
+ );
+ uiServerConfiguration.enabled === true &&
+ (this.uiServer = UIServerFactory.getUIServerImplementation(uiServerConfiguration));
+ const performanceStorageConfiguration =
+ Configuration.getConfigurationSection<StorageConfiguration>(
+ ConfigurationSection.performanceStorage,
+ );
+ performanceStorageConfiguration.enabled === true &&
(this.storage = StorageFactory.getStorage(
- Configuration.getPerformanceStorage().type,
- Configuration.getPerformanceStorage().uri,
+ performanceStorageConfiguration.type!,
+ performanceStorageConfiguration.uri!,
this.logPrefix(),
));
- Configuration.setConfigurationChangeCallback(async () => Bootstrap.getInstance().restart());
+ Configuration.configurationChangeCallback = async () => Bootstrap.getInstance().restart();
}
public static getInstance(): Bootstrap {
public async start(): Promise<void> {
if (!isMainThread) {
- throw new Error('Cannot start charging stations simulator from worker thread');
+ throw new BaseError('Cannot start charging stations simulator from worker thread');
}
if (this.started === false) {
if (this.starting === false) {
this.starting = true;
this.initializeCounters();
- this.initializeWorkerImplementation();
+ const workerConfiguration = Configuration.getConfigurationSection<WorkerConfiguration>(
+ ConfigurationSection.worker,
+ );
+ this.initializeWorkerImplementation(workerConfiguration);
await this.workerImplementation?.start();
await this.storage?.open();
this.uiServer?.start();
// Start ChargingStation object instance in worker thread
- for (const stationTemplateUrl of Configuration.getStationTemplateUrls()) {
+ for (const stationTemplateUrl of Configuration.getStationTemplateUrls()!) {
try {
const nbStations = stationTemplateUrl.numberOfStations ?? 0;
for (let index = 1; index <= nbStations; index++) {
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()}/`
+ ? `${workerConfiguration.poolMinSize?.toString()}/`
: ''
}${this.workerImplementation?.size}${
Configuration.workerPoolInUse()
- ? `/${Configuration.getWorker().poolMaxSize?.toString()}`
+ ? `/${workerConfiguration.poolMaxSize?.toString()}`
: ''
- } worker(s) concurrently running in '${Configuration.getWorker().processType}' mode${
+ } worker(s) concurrently running in '${workerConfiguration.processType}' mode${
!isNullOrUndefined(this.workerImplementation?.maxElementsPerWorker)
? ` (${this.workerImplementation?.maxElementsPerWorker} charging station(s) per worker)`
: ''
public async stop(): Promise<void> {
if (!isMainThread) {
- throw new Error('Cannot stop charging stations simulator from worker thread');
+ throw new BaseError('Cannot stop charging stations simulator from worker thread');
}
if (this.started === true) {
if (this.stopping === false) {
this.uiServer.buildProtocolRequest(
generateUUID(),
ProcedureName.STOP_CHARGING_STATION,
- Constants.EMPTY_FREEZED_OBJECT,
+ Constants.EMPTY_FROZEN_OBJECT,
),
);
await Promise.race([
await this.start();
}
- private initializeWorkerImplementation(): void {
+ private initializeWorkerImplementation(workerConfiguration: WorkerConfiguration): void {
+ let elementsPerWorker: number | undefined;
+ if (workerConfiguration?.elementsPerWorker === 'auto') {
+ elementsPerWorker =
+ this.numberOfChargingStations > availableParallelism()
+ ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5))
+ : 1;
+ }
this.workerImplementation === null &&
(this.workerImplementation = WorkerFactory.getWorkerImplementation<ChargingStationWorkerData>(
this.workerScript,
- Configuration.getWorker().processType,
+ workerConfiguration.processType!,
{
- workerStartDelay: Configuration.getWorker().startDelay,
- elementStartDelay: Configuration.getWorker().elementStartDelay,
- poolMaxSize: Configuration.getWorker().poolMaxSize,
- poolMinSize: Configuration.getWorker().poolMinSize,
- elementsPerWorker: Configuration.getWorker().elementsPerWorker,
+ workerStartDelay: workerConfiguration.startDelay,
+ elementStartDelay: workerConfiguration.elementStartDelay,
+ poolMaxSize: workerConfiguration.poolMaxSize!,
+ poolMinSize: workerConfiguration.poolMinSize!,
+ elementsPerWorker: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number),
poolOptions: {
- workerChoiceStrategy: Configuration.getWorker().poolStrategy,
messageHandler: this.messageHandler.bind(this) as (message: unknown) => void,
},
},
// `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify(
// msg,
// null,
- // 2
- // )}`
+ // 2,
+ // )}`,
// );
try {
- switch (msg.id) {
+ switch (msg.event) {
case ChargingStationWorkerMessageEvents.started:
this.workerEventStarted(msg.data as ChargingStationData);
this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData);
msg.data as Statistics,
);
break;
+ case ChargingStationWorkerMessageEvents.startWorkerElementError:
+ logger.error(
+ `${this.logPrefix()} ${moduleName}.messageHandler: Error occured while starting worker element:`,
+ msg.data,
+ );
+ this.emit(ChargingStationWorkerMessageEvents.startWorkerElementError, msg.data);
+ break;
+ case ChargingStationWorkerMessageEvents.startedWorkerElement:
+ 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, null, 2)}`,
);
}
} catch (error) {
logger.error(
`${this.logPrefix()} ${moduleName}.messageHandler: Error occurred while handling '${
- msg.id
+ msg.event
}' event:`,
error,
);
private initializeCounters() {
if (this.initializedCounters === false) {
this.resetCounters();
- const stationTemplateUrls = Configuration.getStationTemplateUrls();
+ const stationTemplateUrls = Configuration.getStationTemplateUrls()!;
if (isNotEmptyArray(stationTemplateUrls)) {
this.numberOfChargingStationTemplates = stationTemplateUrls.length;
for (const stationTemplateUrl of stationTemplateUrls) {
console.info(`${chalk.green('Graceful shutdown')}`);
this.stop()
.then(() => {
- process.exit(0);
+ process.exit(exitCodes.succeeded);
})
.catch((error) => {
console.error(chalk.red('Error while shutdowning charging stations simulator: '), error);
- process.exit(1);
+ process.exit(exitCodes.gracefulShutdownError);
});
};
repositories / e-mobility-charging-stations-simulator.git / blobdiff