+ public async restart (stopChargingStations?: boolean): Promise<void> {
+ await this.stop(stopChargingStations)
+ Configuration.getConfigurationSection<UIServerConfiguration>(ConfigurationSection.uiServer)
+ .enabled === false && this.uiServer?.stop()
+ await this.start()
+ }
+
+ private async waitChargingStationsStopped (): Promise<string> {
+ return await new Promise<string>((resolve, reject) => {
+ 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 (workerConfiguration: WorkerConfiguration): void {
+ let elementsPerWorker: number | undefined
+ switch (workerConfiguration.elementsPerWorker) {
+ case 'auto':
+ elementsPerWorker =
+ this.numberOfChargingStations > availableParallelism()
+ ? Math.round(this.numberOfChargingStations / (availableParallelism() * 1.5))
+ : 1
+ break
+ case 'all':
+ elementsPerWorker = this.numberOfChargingStations
+ 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,
+ elementStartDelay: workerConfiguration.elementStartDelay,
+ // 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: elementsPerWorker ?? (workerConfiguration.elementsPerWorker as number),
+ poolOptions: {
+ messageHandler: this.messageHandler.bind(this) as MessageHandler<Worker>,
+ workerOptions: { resourceLimits: workerConfiguration.resourceLimits }
+ }
+ }
+ )
+ }
+
+ private messageHandler (
+ msg: ChargingStationWorkerMessage<ChargingStationWorkerMessageData>
+ ): void {
+ // logger.debug(
+ // `${this.logPrefix()} ${moduleName}.messageHandler: Worker channel message received: ${JSON.stringify(
+ // msg,
+ // undefined,
+ // 2
+ // )}`
+ // )
+ try {
+ switch (msg.event) {
+ case ChargingStationWorkerMessageEvents.started:
+ this.emit(ChargingStationWorkerMessageEvents.started, msg.data as ChargingStationData)
+ break
+ case ChargingStationWorkerMessageEvents.stopped:
+ this.emit(ChargingStationWorkerMessageEvents.stopped, msg.data as ChargingStationData)
+ break
+ case ChargingStationWorkerMessageEvents.updated:
+ this.emit(ChargingStationWorkerMessageEvents.updated, msg.data as ChargingStationData)
+ break
+ case ChargingStationWorkerMessageEvents.performanceStatistics:
+ this.emit(
+ ChargingStationWorkerMessageEvents.performanceStatistics,
+ 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 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.event
+ }' event:`,
+ error
+ )
+ }
+ }
+
+ private readonly workerEventStarted = (data: ChargingStationData): void => {
+ this.uiServer?.chargingStations.set(data.stationInfo.hashId, data)
+ ++this.numberOfStartedChargingStations
+ logger.info(
+ `${this.logPrefix()} ${moduleName}.workerEventStarted: Charging station ${
+ data.stationInfo.chargingStationId
+ } (hashId: ${data.stationInfo.hashId}) started (${
+ this.numberOfStartedChargingStations
+ } started from ${this.numberOfChargingStations})`
+ )
+ }
+
+ private readonly workerEventStopped = (data: ChargingStationData): void => {
+ this.uiServer?.chargingStations.set(data.stationInfo.hashId, data)
+ --this.numberOfStartedChargingStations
+ logger.info(
+ `${this.logPrefix()} ${moduleName}.workerEventStopped: Charging station ${
+ data.stationInfo.chargingStationId
+ } (hashId: ${data.stationInfo.hashId}) stopped (${
+ this.numberOfStartedChargingStations
+ } started from ${this.numberOfChargingStations})`
+ )
+ }
+
+ private readonly workerEventUpdated = (data: ChargingStationData): void => {
+ this.uiServer?.chargingStations.set(data.stationInfo.hashId, data)
+ }
+
+ 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)