Merge pull request #1033 from SAP/dependabot/npm_and_yarn/typescript-5.4.5
[e-mobility-charging-stations-simulator.git] / src / charging-station / ChargingStation.ts
1 // Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved.
2
3 import { createHash, randomInt } from 'node:crypto'
4 import { EventEmitter } from 'node:events'
5 import { existsSync, type FSWatcher, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
6 import { dirname, join } from 'node:path'
7 import { URL } from 'node:url'
8 import { parentPort } from 'node:worker_threads'
9
10 import { millisecondsToSeconds, secondsToMilliseconds } from 'date-fns'
11 import { mergeDeepRight, once } from 'rambda'
12 import { type RawData, WebSocket } from 'ws'
13
14 import { BaseError, OCPPError } from '../exception/index.js'
15 import { PerformanceStatistics } from '../performance/index.js'
16 import {
17 type AutomaticTransactionGeneratorConfiguration,
18 AvailabilityType,
19 type BootNotificationRequest,
20 type BootNotificationResponse,
21 type CachedRequest,
22 type ChargingStationConfiguration,
23 ChargingStationEvents,
24 type ChargingStationInfo,
25 type ChargingStationOcppConfiguration,
26 type ChargingStationOptions,
27 type ChargingStationTemplate,
28 type ConnectorStatus,
29 ConnectorStatusEnum,
30 CurrentType,
31 type ErrorCallback,
32 type ErrorResponse,
33 ErrorType,
34 type EvseStatus,
35 type EvseStatusConfiguration,
36 FileType,
37 FirmwareStatus,
38 type FirmwareStatusNotificationRequest,
39 type FirmwareStatusNotificationResponse,
40 type HeartbeatRequest,
41 type HeartbeatResponse,
42 type IncomingRequest,
43 type IncomingRequestCommand,
44 MessageType,
45 MeterValueMeasurand,
46 type MeterValuesRequest,
47 type MeterValuesResponse,
48 OCPPVersion,
49 type OutgoingRequest,
50 PowerUnits,
51 RegistrationStatusEnumType,
52 RequestCommand,
53 type Reservation,
54 type ReservationKey,
55 ReservationTerminationReason,
56 type Response,
57 StandardParametersKey,
58 type Status,
59 type StopTransactionReason,
60 type StopTransactionRequest,
61 type StopTransactionResponse,
62 SupervisionUrlDistribution,
63 SupportedFeatureProfiles,
64 type Voltage,
65 WebSocketCloseEventStatusCode,
66 type WSError,
67 type WsOptions
68 } from '../types/index.js'
69 import {
70 ACElectricUtils,
71 AsyncLock,
72 AsyncLockType,
73 buildAddedMessage,
74 buildChargingStationAutomaticTransactionGeneratorConfiguration,
75 buildConnectorsStatus,
76 buildDeletedMessage,
77 buildEvsesStatus,
78 buildStartedMessage,
79 buildStoppedMessage,
80 buildUpdatedMessage,
81 clone,
82 Configuration,
83 Constants,
84 convertToBoolean,
85 convertToDate,
86 convertToInt,
87 DCElectricUtils,
88 exponentialDelay,
89 formatDurationMilliSeconds,
90 formatDurationSeconds,
91 getWebSocketCloseEventStatusString,
92 handleFileException,
93 isNotEmptyArray,
94 isNotEmptyString,
95 logger,
96 logPrefix,
97 min,
98 roundTo,
99 secureRandom,
100 sleep,
101 watchJsonFile
102 } from '../utils/index.js'
103 import { AutomaticTransactionGenerator } from './AutomaticTransactionGenerator.js'
104 import { ChargingStationWorkerBroadcastChannel } from './broadcast-channel/ChargingStationWorkerBroadcastChannel.js'
105 import {
106 addConfigurationKey,
107 deleteConfigurationKey,
108 getConfigurationKey,
109 setConfigurationKeyValue
110 } from './ConfigurationKeyUtils.js'
111 import {
112 buildConnectorsMap,
113 buildTemplateName,
114 checkChargingStation,
115 checkConfiguration,
116 checkConnectorsConfiguration,
117 checkStationInfoConnectorStatus,
118 checkTemplate,
119 createBootNotificationRequest,
120 createSerialNumber,
121 getAmperageLimitationUnitDivider,
122 getBootConnectorStatus,
123 getChargingStationConnectorChargingProfilesPowerLimit,
124 getChargingStationId,
125 getDefaultVoltageOut,
126 getHashId,
127 getIdTagsFile,
128 getMaxNumberOfEvses,
129 getNumberOfReservableConnectors,
130 getPhaseRotationValue,
131 hasFeatureProfile,
132 hasReservationExpired,
133 initializeConnectorsMapStatus,
134 propagateSerialNumber,
135 setChargingStationOptions,
136 stationTemplateToStationInfo,
137 warnTemplateKeysDeprecation
138 } from './Helpers.js'
139 import { IdTagsCache } from './IdTagsCache.js'
140 import {
141 buildMeterValue,
142 buildTransactionEndMeterValue,
143 getMessageTypeString,
144 OCPP16IncomingRequestService,
145 OCPP16RequestService,
146 OCPP16ResponseService,
147 OCPP20IncomingRequestService,
148 OCPP20RequestService,
149 OCPP20ResponseService,
150 type OCPPIncomingRequestService,
151 type OCPPRequestService,
152 sendAndSetConnectorStatus
153 } from './ocpp/index.js'
154 import { SharedLRUCache } from './SharedLRUCache.js'
155
156 export class ChargingStation extends EventEmitter {
157 public readonly index: number
158 public readonly templateFile: string
159 public stationInfo?: ChargingStationInfo
160 public started: boolean
161 public starting: boolean
162 public idTagsCache: IdTagsCache
163 public automaticTransactionGenerator?: AutomaticTransactionGenerator
164 public ocppConfiguration?: ChargingStationOcppConfiguration
165 public wsConnection: WebSocket | null
166 public readonly connectors: Map<number, ConnectorStatus>
167 public readonly evses: Map<number, EvseStatus>
168 public readonly requests: Map<string, CachedRequest>
169 public performanceStatistics?: PerformanceStatistics
170 public heartbeatSetInterval?: NodeJS.Timeout
171 public ocppRequestService!: OCPPRequestService
172 public bootNotificationRequest?: BootNotificationRequest
173 public bootNotificationResponse?: BootNotificationResponse
174 public powerDivider?: number
175 private stopping: boolean
176 private configurationFile!: string
177 private configurationFileHash!: string
178 private connectorsConfigurationHash!: string
179 private evsesConfigurationHash!: string
180 private automaticTransactionGeneratorConfiguration?: AutomaticTransactionGeneratorConfiguration
181 private ocppIncomingRequestService!: OCPPIncomingRequestService
182 private readonly messageBuffer: Set<string>
183 private configuredSupervisionUrl!: URL
184 private wsConnectionRetried: boolean
185 private wsConnectionRetryCount: number
186 private templateFileWatcher?: FSWatcher
187 private templateFileHash!: string
188 private readonly sharedLRUCache: SharedLRUCache
189 private wsPingSetInterval?: NodeJS.Timeout
190 private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel
191 private flushMessageBufferSetInterval?: NodeJS.Timeout
192
193 constructor (index: number, templateFile: string, options?: ChargingStationOptions) {
194 super()
195 this.started = false
196 this.starting = false
197 this.stopping = false
198 this.wsConnection = null
199 this.wsConnectionRetried = false
200 this.wsConnectionRetryCount = 0
201 this.index = index
202 this.templateFile = templateFile
203 this.connectors = new Map<number, ConnectorStatus>()
204 this.evses = new Map<number, EvseStatus>()
205 this.requests = new Map<string, CachedRequest>()
206 this.messageBuffer = new Set<string>()
207 this.sharedLRUCache = SharedLRUCache.getInstance()
208 this.idTagsCache = IdTagsCache.getInstance()
209 this.chargingStationWorkerBroadcastChannel = new ChargingStationWorkerBroadcastChannel(this)
210
211 this.on(ChargingStationEvents.added, () => {
212 parentPort?.postMessage(buildAddedMessage(this))
213 })
214 this.on(ChargingStationEvents.deleted, () => {
215 parentPort?.postMessage(buildDeletedMessage(this))
216 })
217 this.on(ChargingStationEvents.started, () => {
218 parentPort?.postMessage(buildStartedMessage(this))
219 })
220 this.on(ChargingStationEvents.stopped, () => {
221 parentPort?.postMessage(buildStoppedMessage(this))
222 })
223 this.on(ChargingStationEvents.updated, () => {
224 parentPort?.postMessage(buildUpdatedMessage(this))
225 })
226 this.on(ChargingStationEvents.accepted, () => {
227 this.startMessageSequence(
228 this.wsConnectionRetried
229 ? true
230 : this.getAutomaticTransactionGeneratorConfiguration()?.stopAbsoluteDuration
231 ).catch((error: unknown) => {
232 logger.error(`${this.logPrefix()} Error while starting the message sequence:`, error)
233 })
234 this.wsConnectionRetried = false
235 })
236 this.on(ChargingStationEvents.rejected, () => {
237 this.wsConnectionRetried = false
238 })
239 this.on(ChargingStationEvents.disconnected, () => {
240 try {
241 this.internalStopMessageSequence()
242 } catch (error) {
243 logger.error(
244 `${this.logPrefix()} Error while stopping the internal message sequence:`,
245 error
246 )
247 }
248 })
249
250 this.initialize(options)
251
252 this.add()
253
254 if (this.stationInfo?.autoStart === true) {
255 this.start()
256 }
257 }
258
259 public get hasEvses (): boolean {
260 return this.connectors.size === 0 && this.evses.size > 0
261 }
262
263 public get wsConnectionUrl (): URL {
264 return new URL(
265 `${
266 this.stationInfo?.supervisionUrlOcppConfiguration === true &&
267 isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
268 isNotEmptyString(getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey)?.value)
269 ? getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey)?.value
270 : this.configuredSupervisionUrl.href
271 }/${this.stationInfo?.chargingStationId}`
272 )
273 }
274
275 public logPrefix = (): string => {
276 if (
277 this instanceof ChargingStation &&
278 this.stationInfo != null &&
279 isNotEmptyString(this.stationInfo.chargingStationId)
280 ) {
281 return logPrefix(` ${this.stationInfo.chargingStationId} |`)
282 }
283 let stationTemplate: ChargingStationTemplate | undefined
284 try {
285 stationTemplate = JSON.parse(
286 readFileSync(this.templateFile, 'utf8')
287 ) as ChargingStationTemplate
288 } catch {
289 // Ignore
290 }
291 return logPrefix(` ${getChargingStationId(this.index, stationTemplate)} |`)
292 }
293
294 public hasIdTags (): boolean {
295 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
296 return isNotEmptyArray(this.idTagsCache.getIdTags(getIdTagsFile(this.stationInfo!)!))
297 }
298
299 public getNumberOfPhases (stationInfo?: ChargingStationInfo): number {
300 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
301 const localStationInfo = stationInfo ?? this.stationInfo!
302 switch (this.getCurrentOutType(stationInfo)) {
303 case CurrentType.AC:
304 return localStationInfo.numberOfPhases ?? 3
305 case CurrentType.DC:
306 return 0
307 }
308 }
309
310 public isWebSocketConnectionOpened (): boolean {
311 return this.wsConnection?.readyState === WebSocket.OPEN
312 }
313
314 public inUnknownState (): boolean {
315 return this.bootNotificationResponse?.status == null
316 }
317
318 public inPendingState (): boolean {
319 return this.bootNotificationResponse?.status === RegistrationStatusEnumType.PENDING
320 }
321
322 public inAcceptedState (): boolean {
323 return this.bootNotificationResponse?.status === RegistrationStatusEnumType.ACCEPTED
324 }
325
326 public inRejectedState (): boolean {
327 return this.bootNotificationResponse?.status === RegistrationStatusEnumType.REJECTED
328 }
329
330 public isRegistered (): boolean {
331 return !this.inUnknownState() && (this.inAcceptedState() || this.inPendingState())
332 }
333
334 public isChargingStationAvailable (): boolean {
335 return this.getConnectorStatus(0)?.availability === AvailabilityType.Operative
336 }
337
338 public hasConnector (connectorId: number): boolean {
339 if (this.hasEvses) {
340 for (const evseStatus of this.evses.values()) {
341 if (evseStatus.connectors.has(connectorId)) {
342 return true
343 }
344 }
345 return false
346 }
347 return this.connectors.has(connectorId)
348 }
349
350 public isConnectorAvailable (connectorId: number): boolean {
351 return (
352 connectorId > 0 &&
353 this.getConnectorStatus(connectorId)?.availability === AvailabilityType.Operative
354 )
355 }
356
357 public getNumberOfConnectors (): number {
358 if (this.hasEvses) {
359 let numberOfConnectors = 0
360 for (const [evseId, evseStatus] of this.evses) {
361 if (evseId > 0) {
362 numberOfConnectors += evseStatus.connectors.size
363 }
364 }
365 return numberOfConnectors
366 }
367 return this.connectors.has(0) ? this.connectors.size - 1 : this.connectors.size
368 }
369
370 public getNumberOfEvses (): number {
371 return this.evses.has(0) ? this.evses.size - 1 : this.evses.size
372 }
373
374 public getConnectorStatus (connectorId: number): ConnectorStatus | undefined {
375 if (this.hasEvses) {
376 for (const evseStatus of this.evses.values()) {
377 if (evseStatus.connectors.has(connectorId)) {
378 return evseStatus.connectors.get(connectorId)
379 }
380 }
381 return undefined
382 }
383 return this.connectors.get(connectorId)
384 }
385
386 public getConnectorMaximumAvailablePower (connectorId: number): number {
387 let connectorAmperageLimitationPowerLimit: number | undefined
388 const amperageLimitation = this.getAmperageLimitation()
389 if (
390 amperageLimitation != null &&
391 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
392 amperageLimitation < this.stationInfo!.maximumAmperage!
393 ) {
394 connectorAmperageLimitationPowerLimit =
395 (this.stationInfo?.currentOutType === CurrentType.AC
396 ? ACElectricUtils.powerTotal(
397 this.getNumberOfPhases(),
398 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
399 this.stationInfo.voltageOut!,
400 amperageLimitation *
401 (this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors())
402 )
403 : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
404 DCElectricUtils.power(this.stationInfo!.voltageOut!, amperageLimitation)) /
405 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
406 this.powerDivider!
407 }
408 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
409 const connectorMaximumPower = this.stationInfo!.maximumPower! / this.powerDivider!
410 const connectorChargingProfilesPowerLimit =
411 getChargingStationConnectorChargingProfilesPowerLimit(this, connectorId)
412 return min(
413 isNaN(connectorMaximumPower) ? Infinity : connectorMaximumPower,
414 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
415 isNaN(connectorAmperageLimitationPowerLimit!)
416 ? Infinity
417 : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
418 connectorAmperageLimitationPowerLimit!,
419 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
420 isNaN(connectorChargingProfilesPowerLimit!) ? Infinity : connectorChargingProfilesPowerLimit!
421 )
422 }
423
424 public getTransactionIdTag (transactionId: number): string | undefined {
425 if (this.hasEvses) {
426 for (const evseStatus of this.evses.values()) {
427 for (const connectorStatus of evseStatus.connectors.values()) {
428 if (connectorStatus.transactionId === transactionId) {
429 return connectorStatus.transactionIdTag
430 }
431 }
432 }
433 } else {
434 for (const connectorId of this.connectors.keys()) {
435 if (this.getConnectorStatus(connectorId)?.transactionId === transactionId) {
436 return this.getConnectorStatus(connectorId)?.transactionIdTag
437 }
438 }
439 }
440 }
441
442 public getNumberOfRunningTransactions (): number {
443 let numberOfRunningTransactions = 0
444 if (this.hasEvses) {
445 for (const [evseId, evseStatus] of this.evses) {
446 if (evseId === 0) {
447 continue
448 }
449 for (const connectorStatus of evseStatus.connectors.values()) {
450 if (connectorStatus.transactionStarted === true) {
451 ++numberOfRunningTransactions
452 }
453 }
454 }
455 } else {
456 for (const connectorId of this.connectors.keys()) {
457 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted === true) {
458 ++numberOfRunningTransactions
459 }
460 }
461 }
462 return numberOfRunningTransactions
463 }
464
465 public getConnectorIdByTransactionId (transactionId: number | undefined): number | undefined {
466 if (transactionId == null) {
467 return undefined
468 } else if (this.hasEvses) {
469 for (const evseStatus of this.evses.values()) {
470 for (const [connectorId, connectorStatus] of evseStatus.connectors) {
471 if (connectorStatus.transactionId === transactionId) {
472 return connectorId
473 }
474 }
475 }
476 } else {
477 for (const connectorId of this.connectors.keys()) {
478 if (this.getConnectorStatus(connectorId)?.transactionId === transactionId) {
479 return connectorId
480 }
481 }
482 }
483 }
484
485 public getEnergyActiveImportRegisterByTransactionId (
486 transactionId: number | undefined,
487 rounded = false
488 ): number {
489 return this.getEnergyActiveImportRegister(
490 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
491 this.getConnectorStatus(this.getConnectorIdByTransactionId(transactionId)!),
492 rounded
493 )
494 }
495
496 public getEnergyActiveImportRegisterByConnectorId (connectorId: number, rounded = false): number {
497 return this.getEnergyActiveImportRegister(this.getConnectorStatus(connectorId), rounded)
498 }
499
500 public getAuthorizeRemoteTxRequests (): boolean {
501 const authorizeRemoteTxRequests = getConfigurationKey(
502 this,
503 StandardParametersKey.AuthorizeRemoteTxRequests
504 )
505 return authorizeRemoteTxRequests != null
506 ? convertToBoolean(authorizeRemoteTxRequests.value)
507 : false
508 }
509
510 public getLocalAuthListEnabled (): boolean {
511 const localAuthListEnabled = getConfigurationKey(
512 this,
513 StandardParametersKey.LocalAuthListEnabled
514 )
515 return localAuthListEnabled != null ? convertToBoolean(localAuthListEnabled.value) : false
516 }
517
518 public getHeartbeatInterval (): number {
519 const HeartbeatInterval = getConfigurationKey(this, StandardParametersKey.HeartbeatInterval)
520 if (HeartbeatInterval != null) {
521 return secondsToMilliseconds(convertToInt(HeartbeatInterval.value))
522 }
523 const HeartBeatInterval = getConfigurationKey(this, StandardParametersKey.HeartBeatInterval)
524 if (HeartBeatInterval != null) {
525 return secondsToMilliseconds(convertToInt(HeartBeatInterval.value))
526 }
527 this.stationInfo?.autoRegister === false &&
528 logger.warn(
529 `${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
530 Constants.DEFAULT_HEARTBEAT_INTERVAL
531 }`
532 )
533 return Constants.DEFAULT_HEARTBEAT_INTERVAL
534 }
535
536 public setSupervisionUrl (url: string): void {
537 if (
538 this.stationInfo?.supervisionUrlOcppConfiguration === true &&
539 isNotEmptyString(this.stationInfo.supervisionUrlOcppKey)
540 ) {
541 setConfigurationKeyValue(this, this.stationInfo.supervisionUrlOcppKey, url)
542 } else {
543 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
544 this.stationInfo!.supervisionUrls = url
545 this.configuredSupervisionUrl = this.getConfiguredSupervisionUrl()
546 this.saveStationInfo()
547 }
548 }
549
550 public startHeartbeat (): void {
551 if (this.getHeartbeatInterval() > 0 && this.heartbeatSetInterval == null) {
552 this.heartbeatSetInterval = setInterval(() => {
553 this.ocppRequestService
554 .requestHandler<HeartbeatRequest, HeartbeatResponse>(this, RequestCommand.HEARTBEAT)
555 .catch((error: unknown) => {
556 logger.error(
557 `${this.logPrefix()} Error while sending '${RequestCommand.HEARTBEAT}':`,
558 error
559 )
560 })
561 }, this.getHeartbeatInterval())
562 logger.info(
563 `${this.logPrefix()} Heartbeat started every ${formatDurationMilliSeconds(
564 this.getHeartbeatInterval()
565 )}`
566 )
567 } else if (this.heartbeatSetInterval != null) {
568 logger.info(
569 `${this.logPrefix()} Heartbeat already started every ${formatDurationMilliSeconds(
570 this.getHeartbeatInterval()
571 )}`
572 )
573 } else {
574 logger.error(
575 `${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval()}, not starting the heartbeat`
576 )
577 }
578 }
579
580 public restartHeartbeat (): void {
581 // Stop heartbeat
582 this.stopHeartbeat()
583 // Start heartbeat
584 this.startHeartbeat()
585 }
586
587 public restartWebSocketPing (): void {
588 // Stop WebSocket ping
589 this.stopWebSocketPing()
590 // Start WebSocket ping
591 this.startWebSocketPing()
592 }
593
594 public startMeterValues (connectorId: number, interval: number): void {
595 if (connectorId === 0) {
596 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId}`)
597 return
598 }
599 const connectorStatus = this.getConnectorStatus(connectorId)
600 if (connectorStatus == null) {
601 logger.error(
602 `${this.logPrefix()} Trying to start MeterValues on non existing connector id
603 ${connectorId}`
604 )
605 return
606 }
607 if (connectorStatus.transactionStarted === false) {
608 logger.error(
609 `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction started`
610 )
611 return
612 } else if (
613 connectorStatus.transactionStarted === true &&
614 connectorStatus.transactionId == null
615 ) {
616 logger.error(
617 `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction id`
618 )
619 return
620 }
621 if (interval > 0) {
622 connectorStatus.transactionSetInterval = setInterval(() => {
623 const meterValue = buildMeterValue(
624 this,
625 connectorId,
626 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
627 connectorStatus.transactionId!,
628 interval
629 )
630 this.ocppRequestService
631 .requestHandler<MeterValuesRequest, MeterValuesResponse>(
632 this,
633 RequestCommand.METER_VALUES,
634 {
635 connectorId,
636 transactionId: connectorStatus.transactionId,
637 meterValue: [meterValue]
638 }
639 )
640 .catch((error: unknown) => {
641 logger.error(
642 `${this.logPrefix()} Error while sending '${RequestCommand.METER_VALUES}':`,
643 error
644 )
645 })
646 }, interval)
647 } else {
648 logger.error(
649 `${this.logPrefix()} Charging station ${
650 StandardParametersKey.MeterValueSampleInterval
651 } configuration set to ${interval}, not sending MeterValues`
652 )
653 }
654 }
655
656 public stopMeterValues (connectorId: number): void {
657 const connectorStatus = this.getConnectorStatus(connectorId)
658 if (connectorStatus?.transactionSetInterval != null) {
659 clearInterval(connectorStatus.transactionSetInterval)
660 }
661 }
662
663 private add (): void {
664 this.emit(ChargingStationEvents.added)
665 }
666
667 public async delete (deleteConfiguration = true): Promise<void> {
668 if (this.started) {
669 await this.stop()
670 }
671 AutomaticTransactionGenerator.deleteInstance(this)
672 PerformanceStatistics.deleteInstance(this.stationInfo?.hashId)
673 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
674 this.idTagsCache.deleteIdTags(getIdTagsFile(this.stationInfo!)!)
675 this.requests.clear()
676 this.connectors.clear()
677 this.evses.clear()
678 this.templateFileWatcher?.unref()
679 deleteConfiguration && rmSync(this.configurationFile, { force: true })
680 this.chargingStationWorkerBroadcastChannel.unref()
681 this.emit(ChargingStationEvents.deleted)
682 this.removeAllListeners()
683 }
684
685 public start (): void {
686 if (!this.started) {
687 if (!this.starting) {
688 this.starting = true
689 if (this.stationInfo?.enableStatistics === true) {
690 this.performanceStatistics?.start()
691 }
692 this.openWSConnection()
693 // Monitor charging station template file
694 this.templateFileWatcher = watchJsonFile(
695 this.templateFile,
696 FileType.ChargingStationTemplate,
697 this.logPrefix(),
698 undefined,
699 (event, filename): void => {
700 if (isNotEmptyString(filename) && event === 'change') {
701 try {
702 logger.debug(
703 `${this.logPrefix()} ${FileType.ChargingStationTemplate} ${
704 this.templateFile
705 } file have changed, reload`
706 )
707 this.sharedLRUCache.deleteChargingStationTemplate(this.templateFileHash)
708 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
709 this.idTagsCache.deleteIdTags(getIdTagsFile(this.stationInfo!)!)
710 // Initialize
711 this.initialize()
712 // Restart the ATG
713 const ATGStarted = this.automaticTransactionGenerator?.started
714 if (ATGStarted === true) {
715 this.stopAutomaticTransactionGenerator()
716 }
717 delete this.automaticTransactionGeneratorConfiguration
718 if (
719 this.getAutomaticTransactionGeneratorConfiguration()?.enable === true &&
720 ATGStarted === true
721 ) {
722 this.startAutomaticTransactionGenerator(undefined, true)
723 }
724 if (this.stationInfo?.enableStatistics === true) {
725 this.performanceStatistics?.restart()
726 } else {
727 this.performanceStatistics?.stop()
728 }
729 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
730 } catch (error) {
731 logger.error(
732 `${this.logPrefix()} ${FileType.ChargingStationTemplate} file monitoring error:`,
733 error
734 )
735 }
736 }
737 }
738 )
739 this.started = true
740 this.emit(ChargingStationEvents.started)
741 this.starting = false
742 } else {
743 logger.warn(`${this.logPrefix()} Charging station is already starting...`)
744 }
745 } else {
746 logger.warn(`${this.logPrefix()} Charging station is already started...`)
747 }
748 }
749
750 public async stop (
751 reason?: StopTransactionReason,
752 stopTransactions = this.stationInfo?.stopTransactionsOnStopped
753 ): Promise<void> {
754 if (this.started) {
755 if (!this.stopping) {
756 this.stopping = true
757 await this.stopMessageSequence(reason, stopTransactions)
758 this.closeWSConnection()
759 if (this.stationInfo?.enableStatistics === true) {
760 this.performanceStatistics?.stop()
761 }
762 this.templateFileWatcher?.close()
763 delete this.bootNotificationResponse
764 this.started = false
765 this.saveConfiguration()
766 this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash)
767 this.emit(ChargingStationEvents.stopped)
768 this.stopping = false
769 } else {
770 logger.warn(`${this.logPrefix()} Charging station is already stopping...`)
771 }
772 } else {
773 logger.warn(`${this.logPrefix()} Charging station is already stopped...`)
774 }
775 }
776
777 public async reset (reason?: StopTransactionReason): Promise<void> {
778 await this.stop(reason)
779 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
780 await sleep(this.stationInfo!.resetTime!)
781 this.initialize()
782 this.start()
783 }
784
785 public saveOcppConfiguration (): void {
786 if (this.stationInfo?.ocppPersistentConfiguration === true) {
787 this.saveConfiguration()
788 }
789 }
790
791 public bufferMessage (message: string): void {
792 this.messageBuffer.add(message)
793 this.setIntervalFlushMessageBuffer()
794 }
795
796 public openWSConnection (
797 options?: WsOptions,
798 params?: { closeOpened?: boolean, terminateOpened?: boolean }
799 ): void {
800 options = {
801 handshakeTimeout: secondsToMilliseconds(this.getConnectionTimeout()),
802 ...this.stationInfo?.wsOptions,
803 ...options
804 }
805 params = { ...{ closeOpened: false, terminateOpened: false }, ...params }
806 if (!checkChargingStation(this, this.logPrefix())) {
807 return
808 }
809 if (this.stationInfo?.supervisionUser != null && this.stationInfo.supervisionPassword != null) {
810 options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`
811 }
812 if (params.closeOpened === true) {
813 this.closeWSConnection()
814 }
815 if (params.terminateOpened === true) {
816 this.terminateWSConnection()
817 }
818
819 if (this.isWebSocketConnectionOpened()) {
820 logger.warn(
821 `${this.logPrefix()} OCPP connection to URL ${this.wsConnectionUrl.href} is already opened`
822 )
823 return
824 }
825
826 logger.info(`${this.logPrefix()} Open OCPP connection to URL ${this.wsConnectionUrl.href}`)
827
828 this.wsConnection = new WebSocket(
829 this.wsConnectionUrl,
830 `ocpp${this.stationInfo?.ocppVersion}`,
831 options
832 )
833
834 // Handle WebSocket message
835 this.wsConnection.on('message', data => {
836 this.onMessage(data).catch(Constants.EMPTY_FUNCTION)
837 })
838 // Handle WebSocket error
839 this.wsConnection.on('error', this.onError.bind(this))
840 // Handle WebSocket close
841 this.wsConnection.on('close', this.onClose.bind(this))
842 // Handle WebSocket open
843 this.wsConnection.on('open', () => {
844 this.onOpen().catch((error: unknown) =>
845 logger.error(`${this.logPrefix()} Error while opening WebSocket connection:`, error)
846 )
847 })
848 // Handle WebSocket ping
849 this.wsConnection.on('ping', this.onPing.bind(this))
850 // Handle WebSocket pong
851 this.wsConnection.on('pong', this.onPong.bind(this))
852 }
853
854 public closeWSConnection (): void {
855 if (this.isWebSocketConnectionOpened()) {
856 this.wsConnection?.close()
857 this.wsConnection = null
858 }
859 }
860
861 public getAutomaticTransactionGeneratorConfiguration ():
862 | AutomaticTransactionGeneratorConfiguration
863 | undefined {
864 if (this.automaticTransactionGeneratorConfiguration == null) {
865 let automaticTransactionGeneratorConfiguration:
866 | AutomaticTransactionGeneratorConfiguration
867 | undefined
868 const stationTemplate = this.getTemplateFromFile()
869 const stationConfiguration = this.getConfigurationFromFile()
870 if (
871 this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration === true &&
872 stationConfiguration?.stationInfo?.templateHash === stationTemplate?.templateHash &&
873 stationConfiguration?.automaticTransactionGenerator != null
874 ) {
875 automaticTransactionGeneratorConfiguration =
876 stationConfiguration.automaticTransactionGenerator
877 } else {
878 automaticTransactionGeneratorConfiguration = stationTemplate?.AutomaticTransactionGenerator
879 }
880 this.automaticTransactionGeneratorConfiguration = {
881 ...Constants.DEFAULT_ATG_CONFIGURATION,
882 ...automaticTransactionGeneratorConfiguration
883 }
884 }
885 return this.automaticTransactionGeneratorConfiguration
886 }
887
888 public getAutomaticTransactionGeneratorStatuses (): Status[] | undefined {
889 return this.getConfigurationFromFile()?.automaticTransactionGeneratorStatuses
890 }
891
892 public startAutomaticTransactionGenerator (
893 connectorIds?: number[],
894 stopAbsoluteDuration?: boolean
895 ): void {
896 this.automaticTransactionGenerator = AutomaticTransactionGenerator.getInstance(this)
897 if (isNotEmptyArray(connectorIds)) {
898 for (const connectorId of connectorIds) {
899 this.automaticTransactionGenerator?.startConnector(connectorId, stopAbsoluteDuration)
900 }
901 } else {
902 this.automaticTransactionGenerator?.start(stopAbsoluteDuration)
903 }
904 this.saveAutomaticTransactionGeneratorConfiguration()
905 this.emit(ChargingStationEvents.updated)
906 }
907
908 public stopAutomaticTransactionGenerator (connectorIds?: number[]): void {
909 if (isNotEmptyArray(connectorIds)) {
910 for (const connectorId of connectorIds) {
911 this.automaticTransactionGenerator?.stopConnector(connectorId)
912 }
913 } else {
914 this.automaticTransactionGenerator?.stop()
915 }
916 this.saveAutomaticTransactionGeneratorConfiguration()
917 this.emit(ChargingStationEvents.updated)
918 }
919
920 public async stopTransactionOnConnector (
921 connectorId: number,
922 reason?: StopTransactionReason
923 ): Promise<StopTransactionResponse> {
924 const transactionId = this.getConnectorStatus(connectorId)?.transactionId
925 if (
926 this.stationInfo?.beginEndMeterValues === true &&
927 this.stationInfo.ocppStrictCompliance === true &&
928 this.stationInfo.outOfOrderEndMeterValues === false
929 ) {
930 const transactionEndMeterValue = buildTransactionEndMeterValue(
931 this,
932 connectorId,
933 this.getEnergyActiveImportRegisterByTransactionId(transactionId)
934 )
935 await this.ocppRequestService.requestHandler<MeterValuesRequest, MeterValuesResponse>(
936 this,
937 RequestCommand.METER_VALUES,
938 {
939 connectorId,
940 transactionId,
941 meterValue: [transactionEndMeterValue]
942 }
943 )
944 }
945 return await this.ocppRequestService.requestHandler<
946 StopTransactionRequest,
947 StopTransactionResponse
948 >(this, RequestCommand.STOP_TRANSACTION, {
949 transactionId,
950 meterStop: this.getEnergyActiveImportRegisterByTransactionId(transactionId, true),
951 ...(reason != null && { reason })
952 })
953 }
954
955 public getReserveConnectorZeroSupported (): boolean {
956 return convertToBoolean(
957 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
958 getConfigurationKey(this, StandardParametersKey.ReserveConnectorZeroSupported)!.value
959 )
960 }
961
962 public async addReservation (reservation: Reservation): Promise<void> {
963 const reservationFound = this.getReservationBy('reservationId', reservation.reservationId)
964 if (reservationFound != null) {
965 await this.removeReservation(reservationFound, ReservationTerminationReason.REPLACE_EXISTING)
966 }
967 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
968 this.getConnectorStatus(reservation.connectorId)!.reservation = reservation
969 await sendAndSetConnectorStatus(
970 this,
971 reservation.connectorId,
972 ConnectorStatusEnum.Reserved,
973 undefined,
974 { send: reservation.connectorId !== 0 }
975 )
976 }
977
978 public async removeReservation (
979 reservation: Reservation,
980 reason: ReservationTerminationReason
981 ): Promise<void> {
982 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
983 const connector = this.getConnectorStatus(reservation.connectorId)!
984 switch (reason) {
985 case ReservationTerminationReason.CONNECTOR_STATE_CHANGED:
986 case ReservationTerminationReason.TRANSACTION_STARTED:
987 delete connector.reservation
988 break
989 case ReservationTerminationReason.RESERVATION_CANCELED:
990 case ReservationTerminationReason.REPLACE_EXISTING:
991 case ReservationTerminationReason.EXPIRED:
992 await sendAndSetConnectorStatus(
993 this,
994 reservation.connectorId,
995 ConnectorStatusEnum.Available,
996 undefined,
997 { send: reservation.connectorId !== 0 }
998 )
999 delete connector.reservation
1000 break
1001 default:
1002 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
1003 throw new BaseError(`Unknown reservation termination reason '${reason}'`)
1004 }
1005 }
1006
1007 public getReservationBy (
1008 filterKey: ReservationKey,
1009 value: number | string
1010 ): Reservation | undefined {
1011 if (this.hasEvses) {
1012 for (const evseStatus of this.evses.values()) {
1013 for (const connectorStatus of evseStatus.connectors.values()) {
1014 if (connectorStatus.reservation?.[filterKey] === value) {
1015 return connectorStatus.reservation
1016 }
1017 }
1018 }
1019 } else {
1020 for (const connectorStatus of this.connectors.values()) {
1021 if (connectorStatus.reservation?.[filterKey] === value) {
1022 return connectorStatus.reservation
1023 }
1024 }
1025 }
1026 }
1027
1028 public isConnectorReservable (
1029 reservationId: number,
1030 idTag?: string,
1031 connectorId?: number
1032 ): boolean {
1033 const reservation = this.getReservationBy('reservationId', reservationId)
1034 const reservationExists = reservation != null && !hasReservationExpired(reservation)
1035 if (arguments.length === 1) {
1036 return !reservationExists
1037 } else if (arguments.length > 1) {
1038 const userReservation = idTag != null ? this.getReservationBy('idTag', idTag) : undefined
1039 const userReservationExists =
1040 userReservation != null && !hasReservationExpired(userReservation)
1041 const notConnectorZero = connectorId == null ? true : connectorId > 0
1042 const freeConnectorsAvailable = this.getNumberOfReservableConnectors() > 0
1043 return (
1044 !reservationExists && !userReservationExists && notConnectorZero && freeConnectorsAvailable
1045 )
1046 }
1047 return false
1048 }
1049
1050 private setIntervalFlushMessageBuffer (): void {
1051 if (this.flushMessageBufferSetInterval == null) {
1052 this.flushMessageBufferSetInterval = setInterval(() => {
1053 if (this.isWebSocketConnectionOpened() && this.inAcceptedState()) {
1054 this.flushMessageBuffer()
1055 }
1056 if (this.messageBuffer.size === 0) {
1057 this.clearIntervalFlushMessageBuffer()
1058 }
1059 }, Constants.DEFAULT_MESSAGE_BUFFER_FLUSH_INTERVAL)
1060 }
1061 }
1062
1063 private clearIntervalFlushMessageBuffer (): void {
1064 if (this.flushMessageBufferSetInterval != null) {
1065 clearInterval(this.flushMessageBufferSetInterval)
1066 delete this.flushMessageBufferSetInterval
1067 }
1068 }
1069
1070 private getNumberOfReservableConnectors (): number {
1071 let numberOfReservableConnectors = 0
1072 if (this.hasEvses) {
1073 for (const evseStatus of this.evses.values()) {
1074 numberOfReservableConnectors += getNumberOfReservableConnectors(evseStatus.connectors)
1075 }
1076 } else {
1077 numberOfReservableConnectors = getNumberOfReservableConnectors(this.connectors)
1078 }
1079 return numberOfReservableConnectors - this.getNumberOfReservationsOnConnectorZero()
1080 }
1081
1082 private getNumberOfReservationsOnConnectorZero (): number {
1083 if (
1084 (this.hasEvses && this.evses.get(0)?.connectors.get(0)?.reservation != null) ||
1085 (!this.hasEvses && this.connectors.get(0)?.reservation != null)
1086 ) {
1087 return 1
1088 }
1089 return 0
1090 }
1091
1092 private flushMessageBuffer (): void {
1093 if (this.messageBuffer.size > 0) {
1094 for (const message of this.messageBuffer.values()) {
1095 let beginId: string | undefined
1096 let commandName: RequestCommand | undefined
1097 const [messageType] = JSON.parse(message) as OutgoingRequest | Response | ErrorResponse
1098 const isRequest = messageType === MessageType.CALL_MESSAGE
1099 if (isRequest) {
1100 [, , commandName] = JSON.parse(message) as OutgoingRequest
1101 beginId = PerformanceStatistics.beginMeasure(commandName)
1102 }
1103 this.wsConnection?.send(message, (error?: Error) => {
1104 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1105 isRequest && PerformanceStatistics.endMeasure(commandName!, beginId!)
1106 if (error == null) {
1107 logger.debug(
1108 `${this.logPrefix()} >> Buffered ${getMessageTypeString(
1109 messageType
1110 )} OCPP message sent '${JSON.stringify(message)}'`
1111 )
1112 this.messageBuffer.delete(message)
1113 } else {
1114 logger.debug(
1115 `${this.logPrefix()} >> Buffered ${getMessageTypeString(
1116 messageType
1117 )} OCPP message '${JSON.stringify(message)}' send failed:`,
1118 error
1119 )
1120 }
1121 })
1122 }
1123 }
1124 }
1125
1126 private getTemplateFromFile (): ChargingStationTemplate | undefined {
1127 let template: ChargingStationTemplate | undefined
1128 try {
1129 if (this.sharedLRUCache.hasChargingStationTemplate(this.templateFileHash)) {
1130 template = this.sharedLRUCache.getChargingStationTemplate(this.templateFileHash)
1131 } else {
1132 const measureId = `${FileType.ChargingStationTemplate} read`
1133 const beginId = PerformanceStatistics.beginMeasure(measureId)
1134 template = JSON.parse(readFileSync(this.templateFile, 'utf8')) as ChargingStationTemplate
1135 PerformanceStatistics.endMeasure(measureId, beginId)
1136 template.templateHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1137 .update(JSON.stringify(template))
1138 .digest('hex')
1139 this.sharedLRUCache.setChargingStationTemplate(template)
1140 this.templateFileHash = template.templateHash
1141 }
1142 } catch (error) {
1143 handleFileException(
1144 this.templateFile,
1145 FileType.ChargingStationTemplate,
1146 error as NodeJS.ErrnoException,
1147 this.logPrefix()
1148 )
1149 }
1150 return template
1151 }
1152
1153 private getStationInfoFromTemplate (): ChargingStationInfo {
1154 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1155 const stationTemplate = this.getTemplateFromFile()!
1156 checkTemplate(stationTemplate, this.logPrefix(), this.templateFile)
1157 const warnTemplateKeysDeprecationOnce = once(warnTemplateKeysDeprecation)
1158 warnTemplateKeysDeprecationOnce(stationTemplate, this.logPrefix(), this.templateFile)
1159 if (stationTemplate.Connectors != null) {
1160 checkConnectorsConfiguration(stationTemplate, this.logPrefix(), this.templateFile)
1161 }
1162 const stationInfo = stationTemplateToStationInfo(stationTemplate)
1163 stationInfo.hashId = getHashId(this.index, stationTemplate)
1164 stationInfo.templateIndex = this.index
1165 stationInfo.templateName = buildTemplateName(this.templateFile)
1166 stationInfo.chargingStationId = getChargingStationId(this.index, stationTemplate)
1167 createSerialNumber(stationTemplate, stationInfo)
1168 stationInfo.voltageOut = this.getVoltageOut(stationInfo)
1169 if (isNotEmptyArray(stationTemplate.power)) {
1170 const powerArrayRandomIndex = Math.floor(secureRandom() * stationTemplate.power.length)
1171 stationInfo.maximumPower =
1172 stationTemplate.powerUnit === PowerUnits.KILO_WATT
1173 ? stationTemplate.power[powerArrayRandomIndex] * 1000
1174 : stationTemplate.power[powerArrayRandomIndex]
1175 } else {
1176 stationInfo.maximumPower =
1177 stationTemplate.powerUnit === PowerUnits.KILO_WATT
1178 ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1179 stationTemplate.power! * 1000
1180 : stationTemplate.power
1181 }
1182 stationInfo.maximumAmperage = this.getMaximumAmperage(stationInfo)
1183 if (
1184 isNotEmptyString(stationInfo.firmwareVersionPattern) &&
1185 isNotEmptyString(stationInfo.firmwareVersion) &&
1186 !new RegExp(stationInfo.firmwareVersionPattern).test(stationInfo.firmwareVersion)
1187 ) {
1188 logger.warn(
1189 `${this.logPrefix()} Firmware version '${stationInfo.firmwareVersion}' in template file ${
1190 this.templateFile
1191 } does not match firmware version pattern '${stationInfo.firmwareVersionPattern}'`
1192 )
1193 }
1194 if (stationTemplate.resetTime != null) {
1195 stationInfo.resetTime = secondsToMilliseconds(stationTemplate.resetTime)
1196 }
1197 return stationInfo
1198 }
1199
1200 private getStationInfoFromFile (
1201 stationInfoPersistentConfiguration: boolean | undefined = Constants.DEFAULT_STATION_INFO
1202 .stationInfoPersistentConfiguration
1203 ): ChargingStationInfo | undefined {
1204 let stationInfo: ChargingStationInfo | undefined
1205 if (stationInfoPersistentConfiguration === true) {
1206 stationInfo = this.getConfigurationFromFile()?.stationInfo
1207 if (stationInfo != null) {
1208 delete stationInfo.infoHash
1209 delete (stationInfo as ChargingStationTemplate).numberOfConnectors
1210 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1211 if (stationInfo.templateIndex == null) {
1212 stationInfo.templateIndex = this.index
1213 }
1214 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1215 if (stationInfo.templateName == null) {
1216 stationInfo.templateName = buildTemplateName(this.templateFile)
1217 }
1218 }
1219 }
1220 return stationInfo
1221 }
1222
1223 private getStationInfo (options?: ChargingStationOptions): ChargingStationInfo {
1224 const stationInfoFromTemplate = this.getStationInfoFromTemplate()
1225 options?.persistentConfiguration != null &&
1226 (stationInfoFromTemplate.stationInfoPersistentConfiguration = options.persistentConfiguration)
1227 const stationInfoFromFile = this.getStationInfoFromFile(
1228 stationInfoFromTemplate.stationInfoPersistentConfiguration
1229 )
1230 let stationInfo: ChargingStationInfo
1231 // Priority:
1232 // 1. charging station info from template
1233 // 2. charging station info from configuration file
1234 if (
1235 stationInfoFromFile != null &&
1236 stationInfoFromFile.templateHash === stationInfoFromTemplate.templateHash
1237 ) {
1238 stationInfo = stationInfoFromFile
1239 } else {
1240 stationInfo = stationInfoFromTemplate
1241 stationInfoFromFile != null &&
1242 propagateSerialNumber(this.getTemplateFromFile(), stationInfoFromFile, stationInfo)
1243 }
1244 return setChargingStationOptions(
1245 mergeDeepRight(Constants.DEFAULT_STATION_INFO, stationInfo),
1246 options
1247 )
1248 }
1249
1250 private saveStationInfo (): void {
1251 if (this.stationInfo?.stationInfoPersistentConfiguration === true) {
1252 this.saveConfiguration()
1253 }
1254 }
1255
1256 private handleUnsupportedVersion (version: OCPPVersion | undefined): void {
1257 const errorMsg = `Unsupported protocol version '${version}' configured in template file ${this.templateFile}`
1258 logger.error(`${this.logPrefix()} ${errorMsg}`)
1259 throw new BaseError(errorMsg)
1260 }
1261
1262 private initialize (options?: ChargingStationOptions): void {
1263 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1264 const stationTemplate = this.getTemplateFromFile()!
1265 checkTemplate(stationTemplate, this.logPrefix(), this.templateFile)
1266 this.configurationFile = join(
1267 dirname(this.templateFile.replace('station-templates', 'configurations')),
1268 `${getHashId(this.index, stationTemplate)}.json`
1269 )
1270 const stationConfiguration = this.getConfigurationFromFile()
1271 if (
1272 stationConfiguration?.stationInfo?.templateHash === stationTemplate.templateHash &&
1273 (stationConfiguration?.connectorsStatus != null || stationConfiguration?.evsesStatus != null)
1274 ) {
1275 checkConfiguration(stationConfiguration, this.logPrefix(), this.configurationFile)
1276 this.initializeConnectorsOrEvsesFromFile(stationConfiguration)
1277 } else {
1278 this.initializeConnectorsOrEvsesFromTemplate(stationTemplate)
1279 }
1280 this.stationInfo = this.getStationInfo(options)
1281 if (
1282 this.stationInfo.firmwareStatus === FirmwareStatus.Installing &&
1283 isNotEmptyString(this.stationInfo.firmwareVersionPattern) &&
1284 isNotEmptyString(this.stationInfo.firmwareVersion)
1285 ) {
1286 const patternGroup =
1287 this.stationInfo.firmwareUpgrade?.versionUpgrade?.patternGroup ??
1288 this.stationInfo.firmwareVersion.split('.').length
1289 const match = new RegExp(this.stationInfo.firmwareVersionPattern)
1290 .exec(this.stationInfo.firmwareVersion)
1291 ?.slice(1, patternGroup + 1)
1292 if (match != null) {
1293 const patchLevelIndex = match.length - 1
1294 match[patchLevelIndex] = (
1295 convertToInt(match[patchLevelIndex]) +
1296 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1297 this.stationInfo.firmwareUpgrade!.versionUpgrade!.step!
1298 ).toString()
1299 this.stationInfo.firmwareVersion = match.join('.')
1300 }
1301 }
1302 this.saveStationInfo()
1303 this.configuredSupervisionUrl = this.getConfiguredSupervisionUrl()
1304 if (this.stationInfo.enableStatistics === true) {
1305 this.performanceStatistics = PerformanceStatistics.getInstance(
1306 this.stationInfo.hashId,
1307 this.stationInfo.chargingStationId,
1308 this.configuredSupervisionUrl
1309 )
1310 }
1311 const bootNotificationRequest = createBootNotificationRequest(this.stationInfo)
1312 if (bootNotificationRequest == null) {
1313 const errorMsg = 'Error while creating boot notification request'
1314 logger.error(`${this.logPrefix()} ${errorMsg}`)
1315 throw new BaseError(errorMsg)
1316 }
1317 this.bootNotificationRequest = bootNotificationRequest
1318 this.powerDivider = this.getPowerDivider()
1319 // OCPP configuration
1320 this.ocppConfiguration = this.getOcppConfiguration(options?.persistentConfiguration)
1321 this.initializeOcppConfiguration()
1322 this.initializeOcppServices()
1323 if (this.stationInfo.autoRegister === true) {
1324 this.bootNotificationResponse = {
1325 currentTime: new Date(),
1326 interval: millisecondsToSeconds(this.getHeartbeatInterval()),
1327 status: RegistrationStatusEnumType.ACCEPTED
1328 }
1329 }
1330 }
1331
1332 private initializeOcppServices (): void {
1333 const ocppVersion = this.stationInfo?.ocppVersion
1334 switch (ocppVersion) {
1335 case OCPPVersion.VERSION_16:
1336 this.ocppIncomingRequestService =
1337 OCPP16IncomingRequestService.getInstance<OCPP16IncomingRequestService>()
1338 this.ocppRequestService = OCPP16RequestService.getInstance<OCPP16RequestService>(
1339 OCPP16ResponseService.getInstance<OCPP16ResponseService>()
1340 )
1341 break
1342 case OCPPVersion.VERSION_20:
1343 case OCPPVersion.VERSION_201:
1344 this.ocppIncomingRequestService =
1345 OCPP20IncomingRequestService.getInstance<OCPP20IncomingRequestService>()
1346 this.ocppRequestService = OCPP20RequestService.getInstance<OCPP20RequestService>(
1347 OCPP20ResponseService.getInstance<OCPP20ResponseService>()
1348 )
1349 break
1350 default:
1351 this.handleUnsupportedVersion(ocppVersion)
1352 break
1353 }
1354 }
1355
1356 private initializeOcppConfiguration (): void {
1357 if (getConfigurationKey(this, StandardParametersKey.HeartbeatInterval) == null) {
1358 addConfigurationKey(this, StandardParametersKey.HeartbeatInterval, '0')
1359 }
1360 if (getConfigurationKey(this, StandardParametersKey.HeartBeatInterval) == null) {
1361 addConfigurationKey(this, StandardParametersKey.HeartBeatInterval, '0', { visible: false })
1362 }
1363 if (
1364 this.stationInfo?.supervisionUrlOcppConfiguration === true &&
1365 isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
1366 getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey) == null
1367 ) {
1368 addConfigurationKey(
1369 this,
1370 this.stationInfo.supervisionUrlOcppKey,
1371 this.configuredSupervisionUrl.href,
1372 { reboot: true }
1373 )
1374 } else if (
1375 this.stationInfo?.supervisionUrlOcppConfiguration === false &&
1376 isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
1377 getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey) != null
1378 ) {
1379 deleteConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey, { save: false })
1380 }
1381 if (
1382 isNotEmptyString(this.stationInfo?.amperageLimitationOcppKey) &&
1383 getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey) == null
1384 ) {
1385 addConfigurationKey(
1386 this,
1387 this.stationInfo.amperageLimitationOcppKey,
1388 // prettier-ignore
1389 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1390 (this.stationInfo.maximumAmperage! * getAmperageLimitationUnitDivider(this.stationInfo)).toString()
1391 )
1392 }
1393 if (getConfigurationKey(this, StandardParametersKey.SupportedFeatureProfiles) == null) {
1394 addConfigurationKey(
1395 this,
1396 StandardParametersKey.SupportedFeatureProfiles,
1397 `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.FirmwareManagement},${SupportedFeatureProfiles.LocalAuthListManagement},${SupportedFeatureProfiles.SmartCharging},${SupportedFeatureProfiles.RemoteTrigger}`
1398 )
1399 }
1400 addConfigurationKey(
1401 this,
1402 StandardParametersKey.NumberOfConnectors,
1403 this.getNumberOfConnectors().toString(),
1404 { readonly: true },
1405 { overwrite: true }
1406 )
1407 if (getConfigurationKey(this, StandardParametersKey.MeterValuesSampledData) == null) {
1408 addConfigurationKey(
1409 this,
1410 StandardParametersKey.MeterValuesSampledData,
1411 MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
1412 )
1413 }
1414 if (getConfigurationKey(this, StandardParametersKey.ConnectorPhaseRotation) == null) {
1415 const connectorsPhaseRotation: string[] = []
1416 if (this.hasEvses) {
1417 for (const evseStatus of this.evses.values()) {
1418 for (const connectorId of evseStatus.connectors.keys()) {
1419 connectorsPhaseRotation.push(
1420 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1421 getPhaseRotationValue(connectorId, this.getNumberOfPhases())!
1422 )
1423 }
1424 }
1425 } else {
1426 for (const connectorId of this.connectors.keys()) {
1427 connectorsPhaseRotation.push(
1428 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1429 getPhaseRotationValue(connectorId, this.getNumberOfPhases())!
1430 )
1431 }
1432 }
1433 addConfigurationKey(
1434 this,
1435 StandardParametersKey.ConnectorPhaseRotation,
1436 connectorsPhaseRotation.toString()
1437 )
1438 }
1439 if (getConfigurationKey(this, StandardParametersKey.AuthorizeRemoteTxRequests) == null) {
1440 addConfigurationKey(this, StandardParametersKey.AuthorizeRemoteTxRequests, 'true')
1441 }
1442 if (
1443 getConfigurationKey(this, StandardParametersKey.LocalAuthListEnabled) == null &&
1444 hasFeatureProfile(this, SupportedFeatureProfiles.LocalAuthListManagement) === true
1445 ) {
1446 addConfigurationKey(this, StandardParametersKey.LocalAuthListEnabled, 'false')
1447 }
1448 if (getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut) == null) {
1449 addConfigurationKey(
1450 this,
1451 StandardParametersKey.ConnectionTimeOut,
1452 Constants.DEFAULT_CONNECTION_TIMEOUT.toString()
1453 )
1454 }
1455 this.saveOcppConfiguration()
1456 }
1457
1458 private initializeConnectorsOrEvsesFromFile (configuration: ChargingStationConfiguration): void {
1459 if (configuration.connectorsStatus != null && configuration.evsesStatus == null) {
1460 for (const [connectorId, connectorStatus] of configuration.connectorsStatus.entries()) {
1461 this.connectors.set(connectorId, clone<ConnectorStatus>(connectorStatus))
1462 }
1463 } else if (configuration.evsesStatus != null && configuration.connectorsStatus == null) {
1464 for (const [evseId, evseStatusConfiguration] of configuration.evsesStatus.entries()) {
1465 const evseStatus = clone<EvseStatusConfiguration>(evseStatusConfiguration)
1466 delete evseStatus.connectorsStatus
1467 this.evses.set(evseId, {
1468 ...(evseStatus as EvseStatus),
1469 connectors: new Map<number, ConnectorStatus>(
1470 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1471 evseStatusConfiguration.connectorsStatus!.map((connectorStatus, connectorId) => [
1472 connectorId,
1473 connectorStatus
1474 ])
1475 )
1476 })
1477 }
1478 } else if (configuration.evsesStatus != null && configuration.connectorsStatus != null) {
1479 const errorMsg = `Connectors and evses defined at the same time in configuration file ${this.configurationFile}`
1480 logger.error(`${this.logPrefix()} ${errorMsg}`)
1481 throw new BaseError(errorMsg)
1482 } else {
1483 const errorMsg = `No connectors or evses defined in configuration file ${this.configurationFile}`
1484 logger.error(`${this.logPrefix()} ${errorMsg}`)
1485 throw new BaseError(errorMsg)
1486 }
1487 }
1488
1489 private initializeConnectorsOrEvsesFromTemplate (stationTemplate: ChargingStationTemplate): void {
1490 if (stationTemplate.Connectors != null && stationTemplate.Evses == null) {
1491 this.initializeConnectorsFromTemplate(stationTemplate)
1492 } else if (stationTemplate.Evses != null && stationTemplate.Connectors == null) {
1493 this.initializeEvsesFromTemplate(stationTemplate)
1494 } else if (stationTemplate.Evses != null && stationTemplate.Connectors != null) {
1495 const errorMsg = `Connectors and evses defined at the same time in template file ${this.templateFile}`
1496 logger.error(`${this.logPrefix()} ${errorMsg}`)
1497 throw new BaseError(errorMsg)
1498 } else {
1499 const errorMsg = `No connectors or evses defined in template file ${this.templateFile}`
1500 logger.error(`${this.logPrefix()} ${errorMsg}`)
1501 throw new BaseError(errorMsg)
1502 }
1503 }
1504
1505 private initializeConnectorsFromTemplate (stationTemplate: ChargingStationTemplate): void {
1506 if (stationTemplate.Connectors == null && this.connectors.size === 0) {
1507 const errorMsg = `No already defined connectors and charging station information from template ${this.templateFile} with no connectors configuration defined`
1508 logger.error(`${this.logPrefix()} ${errorMsg}`)
1509 throw new BaseError(errorMsg)
1510 }
1511 if (stationTemplate.Connectors?.[0] == null) {
1512 logger.warn(
1513 `${this.logPrefix()} Charging station information from template ${
1514 this.templateFile
1515 } with no connector id 0 configuration`
1516 )
1517 }
1518 if (stationTemplate.Connectors != null) {
1519 const { configuredMaxConnectors, templateMaxConnectors, templateMaxAvailableConnectors } =
1520 checkConnectorsConfiguration(stationTemplate, this.logPrefix(), this.templateFile)
1521 const connectorsConfigHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1522 .update(
1523 `${JSON.stringify(stationTemplate.Connectors)}${configuredMaxConnectors.toString()}`
1524 )
1525 .digest('hex')
1526 const connectorsConfigChanged =
1527 this.connectors.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash
1528 if (this.connectors.size === 0 || connectorsConfigChanged) {
1529 connectorsConfigChanged && this.connectors.clear()
1530 this.connectorsConfigurationHash = connectorsConfigHash
1531 if (templateMaxConnectors > 0) {
1532 for (let connectorId = 0; connectorId <= configuredMaxConnectors; connectorId++) {
1533 if (
1534 connectorId === 0 &&
1535 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1536 (stationTemplate.Connectors[connectorId] == null ||
1537 !this.getUseConnectorId0(stationTemplate))
1538 ) {
1539 continue
1540 }
1541 const templateConnectorId =
1542 connectorId > 0 && stationTemplate.randomConnectors === true
1543 ? randomInt(1, templateMaxAvailableConnectors)
1544 : connectorId
1545 const connectorStatus = stationTemplate.Connectors[templateConnectorId]
1546 checkStationInfoConnectorStatus(
1547 templateConnectorId,
1548 connectorStatus,
1549 this.logPrefix(),
1550 this.templateFile
1551 )
1552 this.connectors.set(connectorId, clone<ConnectorStatus>(connectorStatus))
1553 }
1554 initializeConnectorsMapStatus(this.connectors, this.logPrefix())
1555 this.saveConnectorsStatus()
1556 } else {
1557 logger.warn(
1558 `${this.logPrefix()} Charging station information from template ${
1559 this.templateFile
1560 } with no connectors configuration defined, cannot create connectors`
1561 )
1562 }
1563 }
1564 } else {
1565 logger.warn(
1566 `${this.logPrefix()} Charging station information from template ${
1567 this.templateFile
1568 } with no connectors configuration defined, using already defined connectors`
1569 )
1570 }
1571 }
1572
1573 private initializeEvsesFromTemplate (stationTemplate: ChargingStationTemplate): void {
1574 if (stationTemplate.Evses == null && this.evses.size === 0) {
1575 const errorMsg = `No already defined evses and charging station information from template ${this.templateFile} with no evses configuration defined`
1576 logger.error(`${this.logPrefix()} ${errorMsg}`)
1577 throw new BaseError(errorMsg)
1578 }
1579 if (stationTemplate.Evses?.[0] == null) {
1580 logger.warn(
1581 `${this.logPrefix()} Charging station information from template ${
1582 this.templateFile
1583 } with no evse id 0 configuration`
1584 )
1585 }
1586 if (stationTemplate.Evses?.[0]?.Connectors[0] == null) {
1587 logger.warn(
1588 `${this.logPrefix()} Charging station information from template ${
1589 this.templateFile
1590 } with evse id 0 with no connector id 0 configuration`
1591 )
1592 }
1593 if (Object.keys(stationTemplate.Evses?.[0]?.Connectors as object).length > 1) {
1594 logger.warn(
1595 `${this.logPrefix()} Charging station information from template ${
1596 this.templateFile
1597 } with evse id 0 with more than one connector configuration, only connector id 0 configuration will be used`
1598 )
1599 }
1600 if (stationTemplate.Evses != null) {
1601 const evsesConfigHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1602 .update(JSON.stringify(stationTemplate.Evses))
1603 .digest('hex')
1604 const evsesConfigChanged =
1605 this.evses.size !== 0 && this.evsesConfigurationHash !== evsesConfigHash
1606 if (this.evses.size === 0 || evsesConfigChanged) {
1607 evsesConfigChanged && this.evses.clear()
1608 this.evsesConfigurationHash = evsesConfigHash
1609 const templateMaxEvses = getMaxNumberOfEvses(stationTemplate.Evses)
1610 if (templateMaxEvses > 0) {
1611 for (const evseKey in stationTemplate.Evses) {
1612 const evseId = convertToInt(evseKey)
1613 this.evses.set(evseId, {
1614 connectors: buildConnectorsMap(
1615 stationTemplate.Evses[evseKey].Connectors,
1616 this.logPrefix(),
1617 this.templateFile
1618 ),
1619 availability: AvailabilityType.Operative
1620 })
1621 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1622 initializeConnectorsMapStatus(this.evses.get(evseId)!.connectors, this.logPrefix())
1623 }
1624 this.saveEvsesStatus()
1625 } else {
1626 logger.warn(
1627 `${this.logPrefix()} Charging station information from template ${
1628 this.templateFile
1629 } with no evses configuration defined, cannot create evses`
1630 )
1631 }
1632 }
1633 } else {
1634 logger.warn(
1635 `${this.logPrefix()} Charging station information from template ${
1636 this.templateFile
1637 } with no evses configuration defined, using already defined evses`
1638 )
1639 }
1640 }
1641
1642 private getConfigurationFromFile (): ChargingStationConfiguration | undefined {
1643 let configuration: ChargingStationConfiguration | undefined
1644 if (isNotEmptyString(this.configurationFile) && existsSync(this.configurationFile)) {
1645 try {
1646 if (this.sharedLRUCache.hasChargingStationConfiguration(this.configurationFileHash)) {
1647 configuration = this.sharedLRUCache.getChargingStationConfiguration(
1648 this.configurationFileHash
1649 )
1650 } else {
1651 const measureId = `${FileType.ChargingStationConfiguration} read`
1652 const beginId = PerformanceStatistics.beginMeasure(measureId)
1653 configuration = JSON.parse(
1654 readFileSync(this.configurationFile, 'utf8')
1655 ) as ChargingStationConfiguration
1656 PerformanceStatistics.endMeasure(measureId, beginId)
1657 this.sharedLRUCache.setChargingStationConfiguration(configuration)
1658 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1659 this.configurationFileHash = configuration.configurationHash!
1660 }
1661 } catch (error) {
1662 handleFileException(
1663 this.configurationFile,
1664 FileType.ChargingStationConfiguration,
1665 error as NodeJS.ErrnoException,
1666 this.logPrefix()
1667 )
1668 }
1669 }
1670 return configuration
1671 }
1672
1673 private saveAutomaticTransactionGeneratorConfiguration (): void {
1674 if (this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration === true) {
1675 this.saveConfiguration()
1676 }
1677 }
1678
1679 private saveConnectorsStatus (): void {
1680 this.saveConfiguration()
1681 }
1682
1683 private saveEvsesStatus (): void {
1684 this.saveConfiguration()
1685 }
1686
1687 private saveConfiguration (): void {
1688 if (isNotEmptyString(this.configurationFile)) {
1689 try {
1690 if (!existsSync(dirname(this.configurationFile))) {
1691 mkdirSync(dirname(this.configurationFile), { recursive: true })
1692 }
1693 const configurationFromFile = this.getConfigurationFromFile()
1694 let configurationData: ChargingStationConfiguration =
1695 configurationFromFile != null
1696 ? clone<ChargingStationConfiguration>(configurationFromFile)
1697 : {}
1698 if (this.stationInfo?.stationInfoPersistentConfiguration === true) {
1699 configurationData.stationInfo = this.stationInfo
1700 } else {
1701 delete configurationData.stationInfo
1702 }
1703 if (
1704 this.stationInfo?.ocppPersistentConfiguration === true &&
1705 Array.isArray(this.ocppConfiguration?.configurationKey)
1706 ) {
1707 configurationData.configurationKey = this.ocppConfiguration.configurationKey
1708 } else {
1709 delete configurationData.configurationKey
1710 }
1711 configurationData = mergeDeepRight(
1712 configurationData,
1713 buildChargingStationAutomaticTransactionGeneratorConfiguration(this)
1714 )
1715 if (this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration !== true) {
1716 delete configurationData.automaticTransactionGenerator
1717 }
1718 if (this.connectors.size > 0) {
1719 configurationData.connectorsStatus = buildConnectorsStatus(this)
1720 } else {
1721 delete configurationData.connectorsStatus
1722 }
1723 if (this.evses.size > 0) {
1724 configurationData.evsesStatus = buildEvsesStatus(this)
1725 } else {
1726 delete configurationData.evsesStatus
1727 }
1728 delete configurationData.configurationHash
1729 const configurationHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1730 .update(
1731 JSON.stringify({
1732 stationInfo: configurationData.stationInfo,
1733 configurationKey: configurationData.configurationKey,
1734 automaticTransactionGenerator: configurationData.automaticTransactionGenerator,
1735 ...(this.connectors.size > 0 && {
1736 connectorsStatus: configurationData.connectorsStatus
1737 }),
1738 ...(this.evses.size > 0 && { evsesStatus: configurationData.evsesStatus })
1739 } satisfies ChargingStationConfiguration)
1740 )
1741 .digest('hex')
1742 if (this.configurationFileHash !== configurationHash) {
1743 AsyncLock.runExclusive(AsyncLockType.configuration, () => {
1744 configurationData.configurationHash = configurationHash
1745 const measureId = `${FileType.ChargingStationConfiguration} write`
1746 const beginId = PerformanceStatistics.beginMeasure(measureId)
1747 writeFileSync(
1748 this.configurationFile,
1749 JSON.stringify(configurationData, undefined, 2),
1750 'utf8'
1751 )
1752 PerformanceStatistics.endMeasure(measureId, beginId)
1753 this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash)
1754 this.sharedLRUCache.setChargingStationConfiguration(configurationData)
1755 this.configurationFileHash = configurationHash
1756 }).catch((error: unknown) => {
1757 handleFileException(
1758 this.configurationFile,
1759 FileType.ChargingStationConfiguration,
1760 error as NodeJS.ErrnoException,
1761 this.logPrefix()
1762 )
1763 })
1764 } else {
1765 logger.debug(
1766 `${this.logPrefix()} Not saving unchanged charging station configuration file ${
1767 this.configurationFile
1768 }`
1769 )
1770 }
1771 } catch (error) {
1772 handleFileException(
1773 this.configurationFile,
1774 FileType.ChargingStationConfiguration,
1775 error as NodeJS.ErrnoException,
1776 this.logPrefix()
1777 )
1778 }
1779 } else {
1780 logger.error(
1781 `${this.logPrefix()} Trying to save charging station configuration to undefined configuration file`
1782 )
1783 }
1784 }
1785
1786 private getOcppConfigurationFromTemplate (): ChargingStationOcppConfiguration | undefined {
1787 return this.getTemplateFromFile()?.Configuration
1788 }
1789
1790 private getOcppConfigurationFromFile (
1791 ocppPersistentConfiguration?: boolean
1792 ): ChargingStationOcppConfiguration | undefined {
1793 const configurationKey = this.getConfigurationFromFile()?.configurationKey
1794 if (ocppPersistentConfiguration === true && Array.isArray(configurationKey)) {
1795 return { configurationKey }
1796 }
1797 return undefined
1798 }
1799
1800 private getOcppConfiguration (
1801 ocppPersistentConfiguration: boolean | undefined = this.stationInfo?.ocppPersistentConfiguration
1802 ): ChargingStationOcppConfiguration | undefined {
1803 let ocppConfiguration: ChargingStationOcppConfiguration | undefined =
1804 this.getOcppConfigurationFromFile(ocppPersistentConfiguration)
1805 if (ocppConfiguration == null) {
1806 ocppConfiguration = this.getOcppConfigurationFromTemplate()
1807 }
1808 return ocppConfiguration
1809 }
1810
1811 private async onOpen (): Promise<void> {
1812 if (this.isWebSocketConnectionOpened()) {
1813 this.emit(ChargingStationEvents.updated)
1814 logger.info(
1815 `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.href} succeeded`
1816 )
1817 let registrationRetryCount = 0
1818 if (!this.isRegistered()) {
1819 // Send BootNotification
1820 do {
1821 this.bootNotificationResponse = await this.ocppRequestService.requestHandler<
1822 BootNotificationRequest,
1823 BootNotificationResponse
1824 >(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
1825 skipBufferingOnError: true
1826 })
1827 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1828 if (this.bootNotificationResponse?.currentTime != null) {
1829 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1830 this.bootNotificationResponse.currentTime = convertToDate(
1831 this.bootNotificationResponse.currentTime
1832 )!
1833 }
1834 if (!this.isRegistered()) {
1835 this.stationInfo?.registrationMaxRetries !== -1 && ++registrationRetryCount
1836 await sleep(
1837 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1838 this.bootNotificationResponse?.interval != null
1839 ? secondsToMilliseconds(this.bootNotificationResponse.interval)
1840 : Constants.DEFAULT_BOOT_NOTIFICATION_INTERVAL
1841 )
1842 }
1843 } while (
1844 !this.isRegistered() &&
1845 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1846 (registrationRetryCount <= this.stationInfo!.registrationMaxRetries! ||
1847 this.stationInfo?.registrationMaxRetries === -1)
1848 )
1849 }
1850 if (this.isRegistered()) {
1851 this.emit(ChargingStationEvents.registered)
1852 if (this.inAcceptedState()) {
1853 this.emit(ChargingStationEvents.accepted)
1854 }
1855 } else {
1856 if (this.inRejectedState()) {
1857 this.emit(ChargingStationEvents.rejected)
1858 }
1859 logger.error(
1860 `${this.logPrefix()} Registration failure: maximum retries reached (${registrationRetryCount}) or retry disabled (${
1861 this.stationInfo?.registrationMaxRetries
1862 })`
1863 )
1864 }
1865 this.wsConnectionRetryCount = 0
1866 this.emit(ChargingStationEvents.updated)
1867 } else {
1868 logger.warn(
1869 `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.href} failed`
1870 )
1871 }
1872 }
1873
1874 private onClose (code: WebSocketCloseEventStatusCode, reason: Buffer): void {
1875 this.emit(ChargingStationEvents.disconnected)
1876 this.emit(ChargingStationEvents.updated)
1877 switch (code) {
1878 // Normal close
1879 case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
1880 case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
1881 logger.info(
1882 `${this.logPrefix()} WebSocket normally closed with status '${getWebSocketCloseEventStatusString(
1883 code
1884 )}' and reason '${reason.toString()}'`
1885 )
1886 this.wsConnectionRetryCount = 0
1887 break
1888 // Abnormal close
1889 default:
1890 logger.error(
1891 `${this.logPrefix()} WebSocket abnormally closed with status '${getWebSocketCloseEventStatusString(
1892 code
1893 )}' and reason '${reason.toString()}'`
1894 )
1895 this.started &&
1896 this.reconnect()
1897 .then(() => {
1898 this.emit(ChargingStationEvents.updated)
1899 })
1900 .catch((error: unknown) =>
1901 logger.error(`${this.logPrefix()} Error while reconnecting:`, error)
1902 )
1903 break
1904 }
1905 }
1906
1907 private getCachedRequest (
1908 messageType: MessageType | undefined,
1909 messageId: string
1910 ): CachedRequest | undefined {
1911 const cachedRequest = this.requests.get(messageId)
1912 if (Array.isArray(cachedRequest)) {
1913 return cachedRequest
1914 }
1915 throw new OCPPError(
1916 ErrorType.PROTOCOL_ERROR,
1917 `Cached request for message id ${messageId} ${getMessageTypeString(
1918 messageType
1919 )} is not an array`,
1920 undefined,
1921 cachedRequest
1922 )
1923 }
1924
1925 private async handleIncomingMessage (request: IncomingRequest): Promise<void> {
1926 const [messageType, messageId, commandName, commandPayload] = request
1927 if (this.stationInfo?.enableStatistics === true) {
1928 this.performanceStatistics?.addRequestStatistic(commandName, messageType)
1929 }
1930 logger.debug(
1931 `${this.logPrefix()} << Command '${commandName}' received request payload: ${JSON.stringify(
1932 request
1933 )}`
1934 )
1935 // Process the message
1936 await this.ocppIncomingRequestService.incomingRequestHandler(
1937 this,
1938 messageId,
1939 commandName,
1940 commandPayload
1941 )
1942 this.emit(ChargingStationEvents.updated)
1943 }
1944
1945 private handleResponseMessage (response: Response): void {
1946 const [messageType, messageId, commandPayload] = response
1947 if (!this.requests.has(messageId)) {
1948 // Error
1949 throw new OCPPError(
1950 ErrorType.INTERNAL_ERROR,
1951 `Response for unknown message id ${messageId}`,
1952 undefined,
1953 commandPayload
1954 )
1955 }
1956 // Respond
1957 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1958 const [responseCallback, , requestCommandName, requestPayload] = this.getCachedRequest(
1959 messageType,
1960 messageId
1961 )!
1962 logger.debug(
1963 `${this.logPrefix()} << Command '${requestCommandName}' received response payload: ${JSON.stringify(
1964 response
1965 )}`
1966 )
1967 responseCallback(commandPayload, requestPayload)
1968 }
1969
1970 private handleErrorMessage (errorResponse: ErrorResponse): void {
1971 const [messageType, messageId, errorType, errorMessage, errorDetails] = errorResponse
1972 if (!this.requests.has(messageId)) {
1973 // Error
1974 throw new OCPPError(
1975 ErrorType.INTERNAL_ERROR,
1976 `Error response for unknown message id ${messageId}`,
1977 undefined,
1978 { errorType, errorMessage, errorDetails }
1979 )
1980 }
1981 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1982 const [, errorCallback, requestCommandName] = this.getCachedRequest(messageType, messageId)!
1983 logger.debug(
1984 `${this.logPrefix()} << Command '${requestCommandName}' received error response payload: ${JSON.stringify(
1985 errorResponse
1986 )}`
1987 )
1988 errorCallback(new OCPPError(errorType, errorMessage, requestCommandName, errorDetails))
1989 }
1990
1991 private async onMessage (data: RawData): Promise<void> {
1992 let request: IncomingRequest | Response | ErrorResponse | undefined
1993 let messageType: MessageType | undefined
1994 let errorMsg: string
1995 try {
1996 // eslint-disable-next-line @typescript-eslint/no-base-to-string
1997 request = JSON.parse(data.toString()) as IncomingRequest | Response | ErrorResponse
1998 if (Array.isArray(request)) {
1999 [messageType] = request
2000 // Check the type of message
2001 switch (messageType) {
2002 // Incoming Message
2003 case MessageType.CALL_MESSAGE:
2004 await this.handleIncomingMessage(request as IncomingRequest)
2005 break
2006 // Response Message
2007 case MessageType.CALL_RESULT_MESSAGE:
2008 this.handleResponseMessage(request as Response)
2009 break
2010 // Error Message
2011 case MessageType.CALL_ERROR_MESSAGE:
2012 this.handleErrorMessage(request as ErrorResponse)
2013 break
2014 // Unknown Message
2015 default:
2016 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
2017 errorMsg = `Wrong message type ${messageType}`
2018 logger.error(`${this.logPrefix()} ${errorMsg}`)
2019 throw new OCPPError(ErrorType.PROTOCOL_ERROR, errorMsg)
2020 }
2021 } else {
2022 throw new OCPPError(
2023 ErrorType.PROTOCOL_ERROR,
2024 'Incoming message is not an array',
2025 undefined,
2026 {
2027 request
2028 }
2029 )
2030 }
2031 } catch (error) {
2032 if (!Array.isArray(request)) {
2033 logger.error(`${this.logPrefix()} Incoming message '${request}' parsing error:`, error)
2034 return
2035 }
2036 let commandName: IncomingRequestCommand | undefined
2037 let requestCommandName: RequestCommand | IncomingRequestCommand | undefined
2038 let errorCallback: ErrorCallback
2039 const [, messageId] = request
2040 switch (messageType) {
2041 case MessageType.CALL_MESSAGE:
2042 [, , commandName] = request as IncomingRequest
2043 // Send error
2044 await this.ocppRequestService.sendError(this, messageId, error as OCPPError, commandName)
2045 break
2046 case MessageType.CALL_RESULT_MESSAGE:
2047 case MessageType.CALL_ERROR_MESSAGE:
2048 if (this.requests.has(messageId)) {
2049 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2050 [, errorCallback, requestCommandName] = this.getCachedRequest(messageType, messageId)!
2051 // Reject the deferred promise in case of error at response handling (rejecting an already fulfilled promise is a no-op)
2052 errorCallback(error as OCPPError, false)
2053 } else {
2054 // Remove the request from the cache in case of error at response handling
2055 this.requests.delete(messageId)
2056 }
2057 break
2058 }
2059 if (!(error instanceof OCPPError)) {
2060 logger.warn(
2061 `${this.logPrefix()} Error thrown at incoming OCPP command '${
2062 commandName ?? requestCommandName ?? Constants.UNKNOWN_OCPP_COMMAND
2063 // eslint-disable-next-line @typescript-eslint/no-base-to-string
2064 }' message '${data.toString()}' handling is not an OCPPError:`,
2065 error
2066 )
2067 }
2068 logger.error(
2069 `${this.logPrefix()} Incoming OCPP command '${
2070 commandName ?? requestCommandName ?? Constants.UNKNOWN_OCPP_COMMAND
2071 // eslint-disable-next-line @typescript-eslint/no-base-to-string
2072 }' message '${data.toString()}'${
2073 this.requests.has(messageId)
2074 ? ` matching cached request '${JSON.stringify(this.getCachedRequest(messageType, messageId))}'`
2075 : ''
2076 } processing error:`,
2077 error
2078 )
2079 }
2080 }
2081
2082 private onPing (): void {
2083 logger.debug(`${this.logPrefix()} Received a WS ping (rfc6455) from the server`)
2084 }
2085
2086 private onPong (): void {
2087 logger.debug(`${this.logPrefix()} Received a WS pong (rfc6455) from the server`)
2088 }
2089
2090 private onError (error: WSError): void {
2091 this.closeWSConnection()
2092 logger.error(`${this.logPrefix()} WebSocket error:`, error)
2093 }
2094
2095 private getEnergyActiveImportRegister (
2096 connectorStatus: ConnectorStatus | undefined,
2097 rounded = false
2098 ): number {
2099 if (this.stationInfo?.meteringPerTransaction === true) {
2100 return (
2101 (rounded
2102 ? connectorStatus?.transactionEnergyActiveImportRegisterValue != null
2103 ? Math.round(connectorStatus.transactionEnergyActiveImportRegisterValue)
2104 : undefined
2105 : connectorStatus?.transactionEnergyActiveImportRegisterValue) ?? 0
2106 )
2107 }
2108 return (
2109 (rounded
2110 ? connectorStatus?.energyActiveImportRegisterValue != null
2111 ? Math.round(connectorStatus.energyActiveImportRegisterValue)
2112 : undefined
2113 : connectorStatus?.energyActiveImportRegisterValue) ?? 0
2114 )
2115 }
2116
2117 private getUseConnectorId0 (stationTemplate?: ChargingStationTemplate): boolean {
2118 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2119 return stationTemplate?.useConnectorId0 ?? Constants.DEFAULT_STATION_INFO.useConnectorId0!
2120 }
2121
2122 private async stopRunningTransactions (reason?: StopTransactionReason): Promise<void> {
2123 if (this.hasEvses) {
2124 for (const [evseId, evseStatus] of this.evses) {
2125 if (evseId === 0) {
2126 continue
2127 }
2128 for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2129 if (connectorStatus.transactionStarted === true) {
2130 await this.stopTransactionOnConnector(connectorId, reason)
2131 }
2132 }
2133 }
2134 } else {
2135 for (const connectorId of this.connectors.keys()) {
2136 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted === true) {
2137 await this.stopTransactionOnConnector(connectorId, reason)
2138 }
2139 }
2140 }
2141 }
2142
2143 // 0 for disabling
2144 private getConnectionTimeout (): number {
2145 if (getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut) != null) {
2146 return convertToInt(
2147 getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut)?.value ??
2148 Constants.DEFAULT_CONNECTION_TIMEOUT
2149 )
2150 }
2151 return Constants.DEFAULT_CONNECTION_TIMEOUT
2152 }
2153
2154 private getPowerDivider (): number {
2155 let powerDivider = this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors()
2156 if (this.stationInfo?.powerSharedByConnectors === true) {
2157 powerDivider = this.getNumberOfRunningTransactions()
2158 }
2159 return powerDivider
2160 }
2161
2162 private getMaximumAmperage (stationInfo?: ChargingStationInfo): number | undefined {
2163 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2164 const maximumPower = (stationInfo ?? this.stationInfo!).maximumPower!
2165 switch (this.getCurrentOutType(stationInfo)) {
2166 case CurrentType.AC:
2167 return ACElectricUtils.amperagePerPhaseFromPower(
2168 this.getNumberOfPhases(stationInfo),
2169 maximumPower / (this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors()),
2170 this.getVoltageOut(stationInfo)
2171 )
2172 case CurrentType.DC:
2173 return DCElectricUtils.amperage(maximumPower, this.getVoltageOut(stationInfo))
2174 }
2175 }
2176
2177 private getCurrentOutType (stationInfo?: ChargingStationInfo): CurrentType {
2178 return (
2179 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2180 (stationInfo ?? this.stationInfo!).currentOutType ??
2181 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2182 Constants.DEFAULT_STATION_INFO.currentOutType!
2183 )
2184 }
2185
2186 private getVoltageOut (stationInfo?: ChargingStationInfo): Voltage {
2187 return (
2188 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2189 (stationInfo ?? this.stationInfo!).voltageOut ??
2190 getDefaultVoltageOut(this.getCurrentOutType(stationInfo), this.logPrefix(), this.templateFile)
2191 )
2192 }
2193
2194 private getAmperageLimitation (): number | undefined {
2195 if (
2196 isNotEmptyString(this.stationInfo?.amperageLimitationOcppKey) &&
2197 getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey) != null
2198 ) {
2199 return (
2200 convertToInt(getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey)?.value) /
2201 getAmperageLimitationUnitDivider(this.stationInfo)
2202 )
2203 }
2204 }
2205
2206 private async startMessageSequence (ATGStopAbsoluteDuration?: boolean): Promise<void> {
2207 if (this.stationInfo?.autoRegister === true) {
2208 await this.ocppRequestService.requestHandler<
2209 BootNotificationRequest,
2210 BootNotificationResponse
2211 >(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
2212 skipBufferingOnError: true
2213 })
2214 }
2215 // Start WebSocket ping
2216 this.startWebSocketPing()
2217 // Start heartbeat
2218 this.startHeartbeat()
2219 // Initialize connectors status
2220 if (this.hasEvses) {
2221 for (const [evseId, evseStatus] of this.evses) {
2222 if (evseId > 0) {
2223 for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2224 await sendAndSetConnectorStatus(
2225 this,
2226 connectorId,
2227 getBootConnectorStatus(this, connectorId, connectorStatus),
2228 evseId
2229 )
2230 }
2231 }
2232 }
2233 } else {
2234 for (const connectorId of this.connectors.keys()) {
2235 if (connectorId > 0) {
2236 await sendAndSetConnectorStatus(
2237 this,
2238 connectorId,
2239 getBootConnectorStatus(
2240 this,
2241 connectorId,
2242 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2243 this.getConnectorStatus(connectorId)!
2244 )
2245 )
2246 }
2247 }
2248 }
2249 if (this.stationInfo?.firmwareStatus === FirmwareStatus.Installing) {
2250 await this.ocppRequestService.requestHandler<
2251 FirmwareStatusNotificationRequest,
2252 FirmwareStatusNotificationResponse
2253 >(this, RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
2254 status: FirmwareStatus.Installed
2255 })
2256 this.stationInfo.firmwareStatus = FirmwareStatus.Installed
2257 }
2258
2259 // Start the ATG
2260 if (this.getAutomaticTransactionGeneratorConfiguration()?.enable === true) {
2261 this.startAutomaticTransactionGenerator(undefined, ATGStopAbsoluteDuration)
2262 }
2263 this.flushMessageBuffer()
2264 }
2265
2266 private internalStopMessageSequence (): void {
2267 // Stop WebSocket ping
2268 this.stopWebSocketPing()
2269 // Stop heartbeat
2270 this.stopHeartbeat()
2271 // Stop the ATG
2272 if (this.automaticTransactionGenerator?.started === true) {
2273 this.stopAutomaticTransactionGenerator()
2274 }
2275 }
2276
2277 private async stopMessageSequence (
2278 reason?: StopTransactionReason,
2279 stopTransactions?: boolean
2280 ): Promise<void> {
2281 this.internalStopMessageSequence()
2282 // Stop ongoing transactions
2283 stopTransactions === true && (await this.stopRunningTransactions(reason))
2284 if (this.hasEvses) {
2285 for (const [evseId, evseStatus] of this.evses) {
2286 if (evseId > 0) {
2287 for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2288 await sendAndSetConnectorStatus(
2289 this,
2290 connectorId,
2291 ConnectorStatusEnum.Unavailable,
2292 evseId
2293 )
2294 delete connectorStatus.status
2295 }
2296 }
2297 }
2298 } else {
2299 for (const connectorId of this.connectors.keys()) {
2300 if (connectorId > 0) {
2301 await sendAndSetConnectorStatus(this, connectorId, ConnectorStatusEnum.Unavailable)
2302 delete this.getConnectorStatus(connectorId)?.status
2303 }
2304 }
2305 }
2306 }
2307
2308 private startWebSocketPing (): void {
2309 const webSocketPingInterval =
2310 getConfigurationKey(this, StandardParametersKey.WebSocketPingInterval) != null
2311 ? convertToInt(
2312 getConfigurationKey(this, StandardParametersKey.WebSocketPingInterval)?.value
2313 )
2314 : 0
2315 if (webSocketPingInterval > 0 && this.wsPingSetInterval == null) {
2316 this.wsPingSetInterval = setInterval(() => {
2317 if (this.isWebSocketConnectionOpened()) {
2318 this.wsConnection?.ping()
2319 }
2320 }, secondsToMilliseconds(webSocketPingInterval))
2321 logger.info(
2322 `${this.logPrefix()} WebSocket ping started every ${formatDurationSeconds(
2323 webSocketPingInterval
2324 )}`
2325 )
2326 } else if (this.wsPingSetInterval != null) {
2327 logger.info(
2328 `${this.logPrefix()} WebSocket ping already started every ${formatDurationSeconds(
2329 webSocketPingInterval
2330 )}`
2331 )
2332 } else {
2333 logger.error(
2334 `${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval}, not starting the WebSocket ping`
2335 )
2336 }
2337 }
2338
2339 private stopWebSocketPing (): void {
2340 if (this.wsPingSetInterval != null) {
2341 clearInterval(this.wsPingSetInterval)
2342 delete this.wsPingSetInterval
2343 }
2344 }
2345
2346 private getConfiguredSupervisionUrl (): URL {
2347 let configuredSupervisionUrl: string
2348 const supervisionUrls = this.stationInfo?.supervisionUrls ?? Configuration.getSupervisionUrls()
2349 if (isNotEmptyArray(supervisionUrls)) {
2350 let configuredSupervisionUrlIndex: number
2351 switch (Configuration.getSupervisionUrlDistribution()) {
2352 case SupervisionUrlDistribution.RANDOM:
2353 configuredSupervisionUrlIndex = Math.floor(secureRandom() * supervisionUrls.length)
2354 break
2355 case SupervisionUrlDistribution.ROUND_ROBIN:
2356 case SupervisionUrlDistribution.CHARGING_STATION_AFFINITY:
2357 default:
2358 !Object.values(SupervisionUrlDistribution).includes(
2359 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2360 Configuration.getSupervisionUrlDistribution()!
2361 ) &&
2362 logger.warn(
2363 // eslint-disable-next-line @typescript-eslint/no-base-to-string
2364 `${this.logPrefix()} Unknown supervision url distribution '${Configuration.getSupervisionUrlDistribution()}' in configuration from values '${SupervisionUrlDistribution.toString()}', defaulting to '${
2365 SupervisionUrlDistribution.CHARGING_STATION_AFFINITY
2366 }'`
2367 )
2368 configuredSupervisionUrlIndex = (this.index - 1) % supervisionUrls.length
2369 break
2370 }
2371 configuredSupervisionUrl = supervisionUrls[configuredSupervisionUrlIndex]
2372 } else {
2373 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2374 configuredSupervisionUrl = supervisionUrls!
2375 }
2376 if (isNotEmptyString(configuredSupervisionUrl)) {
2377 return new URL(configuredSupervisionUrl)
2378 }
2379 const errorMsg = 'No supervision url(s) configured'
2380 logger.error(`${this.logPrefix()} ${errorMsg}`)
2381 throw new BaseError(errorMsg)
2382 }
2383
2384 private stopHeartbeat (): void {
2385 if (this.heartbeatSetInterval != null) {
2386 clearInterval(this.heartbeatSetInterval)
2387 delete this.heartbeatSetInterval
2388 }
2389 }
2390
2391 private terminateWSConnection (): void {
2392 if (this.isWebSocketConnectionOpened()) {
2393 this.wsConnection?.terminate()
2394 this.wsConnection = null
2395 }
2396 }
2397
2398 private async reconnect (): Promise<void> {
2399 if (
2400 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2401 this.wsConnectionRetryCount < this.stationInfo!.autoReconnectMaxRetries! ||
2402 this.stationInfo?.autoReconnectMaxRetries === -1
2403 ) {
2404 this.wsConnectionRetried = true
2405 ++this.wsConnectionRetryCount
2406 const reconnectDelay =
2407 this.stationInfo?.reconnectExponentialDelay === true
2408 ? exponentialDelay(this.wsConnectionRetryCount)
2409 : secondsToMilliseconds(this.getConnectionTimeout())
2410 const reconnectDelayWithdraw = 1000
2411 const reconnectTimeout =
2412 reconnectDelay - reconnectDelayWithdraw > 0 ? reconnectDelay - reconnectDelayWithdraw : 0
2413 logger.error(
2414 `${this.logPrefix()} WebSocket connection retry in ${roundTo(
2415 reconnectDelay,
2416 2
2417 )}ms, timeout ${reconnectTimeout}ms`
2418 )
2419 await sleep(reconnectDelay)
2420 logger.error(
2421 `${this.logPrefix()} WebSocket connection retry #${this.wsConnectionRetryCount.toString()}`
2422 )
2423 this.openWSConnection(
2424 {
2425 handshakeTimeout: reconnectTimeout
2426 },
2427 { closeOpened: true }
2428 )
2429 } else if (this.stationInfo?.autoReconnectMaxRetries !== -1) {
2430 logger.error(
2431 `${this.logPrefix()} WebSocket connection retries failure: maximum retries reached (${
2432 this.wsConnectionRetryCount
2433 }) or retries disabled (${this.stationInfo?.autoReconnectMaxRetries})`
2434 )
2435 }
2436 }
2437 }