import { createHash } from 'node:crypto'
import { EventEmitter } from 'node:events'
import { type FSWatcher, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { dirname, join, parse } from 'node:path'
import { URL } from 'node:url'
import { parentPort } from 'node:worker_threads'
private ocppIncomingRequestService!: OCPPIncomingRequestService
private readonly messageBuffer: Set<string>
private configuredSupervisionUrl!: URL
- private autoReconnectRetryCount: number
+ private wsConnectionRetried: boolean
+ private wsConnectionRetryCount: number
private templateFileWatcher!: FSWatcher | undefined
private templateFileHash!: string
private readonly sharedLRUCache: SharedLRUCache
- private webSocketPingSetInterval?: NodeJS.Timeout
+ private wsPingSetInterval?: NodeJS.Timeout
private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel
private flushMessageBufferSetInterval?: NodeJS.Timeout
this.starting = false
this.stopping = false
this.wsConnection = null
- this.autoReconnectRetryCount = 0
+ this.wsConnectionRetried = false
+ this.wsConnectionRetryCount = 0
this.index = index
this.templateFile = templateFile
this.connectors = new Map<number, ConnectorStatus>()
})
this.on(ChargingStationEvents.accepted, () => {
this.startMessageSequence(
- this.autoReconnectRetryCount > 0
+ this.wsConnectionRetried
? true
: this.getAutomaticTransactionGeneratorConfiguration()?.stopAbsoluteDuration
).catch(error => {
logger.error(`${this.logPrefix()} Error while starting the message sequence:`, error)
})
+ this.wsConnectionRetried = false
+ })
+ this.on(ChargingStationEvents.rejected, () => {
+ this.wsConnectionRetried = false
})
this.on(ChargingStationEvents.disconnected, () => {
try {
}
}
- public async stop (reason?: StopTransactionReason, stopTransactions?: boolean): Promise<void> {
+ public async stop (
+ reason?: StopTransactionReason,
+ stopTransactions = this.stationInfo?.stopTransactionsOnStopped
+ ): Promise<void> {
if (this.started) {
if (!this.stopping) {
this.stopping = true
}
const stationInfo = stationTemplateToStationInfo(stationTemplate)
stationInfo.hashId = getHashId(this.index, stationTemplate)
+ stationInfo.templateName = parse(this.templateFile).name
stationInfo.chargingStationId = getChargingStationId(this.index, stationTemplate)
stationInfo.ocppVersion = stationTemplate.ocppVersion ?? OCPPVersion.VERSION_16
createSerialNumber(stationTemplate, stationInfo)
stationInfo.resetTime =
stationTemplate.resetTime != null
? secondsToMilliseconds(stationTemplate.resetTime)
- : Constants.CHARGING_STATION_DEFAULT_RESET_TIME
+ : Constants.DEFAULT_CHARGING_STATION_RESET_TIME
return stationInfo
}
stationInfo = this.getConfigurationFromFile()?.stationInfo
if (stationInfo != null) {
delete stationInfo.infoHash
+ // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+ if (stationInfo.templateName == null) {
+ stationInfo.templateName = parse(this.templateFile).name
+ }
}
}
return stationInfo
})`
)
}
- this.autoReconnectRetryCount = 0
+ this.wsConnectionRetryCount = 0
this.emit(ChargingStationEvents.updated)
} else {
logger.warn(
code
)}' and reason '${reason.toString()}'`
)
- this.autoReconnectRetryCount = 0
+ this.wsConnectionRetryCount = 0
break
// Abnormal close
default:
this.emit(ChargingStationEvents.updated)
}
- private getCachedRequest (messageType: MessageType, messageId: string): CachedRequest | undefined {
+ private getCachedRequest (
+ messageType: MessageType | undefined,
+ messageId: string
+ ): CachedRequest | undefined {
const cachedRequest = this.requests.get(messageId)
if (Array.isArray(cachedRequest)) {
return cachedRequest
commandName ?? requestCommandName ?? Constants.UNKNOWN_COMMAND
// eslint-disable-next-line @typescript-eslint/no-base-to-string
}' message '${data.toString()}'${
- messageType !== MessageType.CALL_MESSAGE
- ? ` matching cached request '${JSON.stringify(this.requests.get(messageId))}'`
+ this.requests.has(messageId)
+ ? ` matching cached request '${JSON.stringify(this.getCachedRequest(messageType, messageId))}'`
: ''
} processing error:`,
error
private async stopMessageSequence (
reason?: StopTransactionReason,
- stopTransactions = this.stationInfo?.stopTransactionsOnStopped
+ stopTransactions?: boolean
): Promise<void> {
this.internalStopMessageSequence()
// Stop ongoing transactions
getConfigurationKey(this, StandardParametersKey.WebSocketPingInterval)?.value
)
: 0
- if (webSocketPingInterval > 0 && this.webSocketPingSetInterval == null) {
- this.webSocketPingSetInterval = setInterval(() => {
+ if (webSocketPingInterval > 0 && this.wsPingSetInterval == null) {
+ this.wsPingSetInterval = setInterval(() => {
if (this.isWebSocketConnectionOpened()) {
this.wsConnection?.ping()
}
webSocketPingInterval
)}`
)
- } else if (this.webSocketPingSetInterval != null) {
+ } else if (this.wsPingSetInterval != null) {
logger.info(
`${this.logPrefix()} WebSocket ping already started every ${formatDurationSeconds(
webSocketPingInterval
}
private stopWebSocketPing (): void {
- if (this.webSocketPingSetInterval != null) {
- clearInterval(this.webSocketPingSetInterval)
- delete this.webSocketPingSetInterval
+ if (this.wsPingSetInterval != null) {
+ clearInterval(this.wsPingSetInterval)
+ delete this.wsPingSetInterval
}
}
private async reconnect (): Promise<void> {
if (
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- this.autoReconnectRetryCount < this.stationInfo!.autoReconnectMaxRetries! ||
+ this.wsConnectionRetryCount < this.stationInfo!.autoReconnectMaxRetries! ||
this.stationInfo?.autoReconnectMaxRetries === -1
) {
- ++this.autoReconnectRetryCount
+ this.wsConnectionRetried = true
+ ++this.wsConnectionRetryCount
const reconnectDelay =
this.stationInfo?.reconnectExponentialDelay === true
- ? exponentialDelay(this.autoReconnectRetryCount)
+ ? exponentialDelay(this.wsConnectionRetryCount)
: secondsToMilliseconds(this.getConnectionTimeout())
const reconnectDelayWithdraw = 1000
const reconnectTimeout =
)
await sleep(reconnectDelay)
logger.error(
- `${this.logPrefix()} WebSocket connection retry #${this.autoReconnectRetryCount.toString()}`
+ `${this.logPrefix()} WebSocket connection retry #${this.wsConnectionRetryCount.toString()}`
)
this.openWSConnection(
{
} else if (this.stationInfo?.autoReconnectMaxRetries !== -1) {
logger.error(
`${this.logPrefix()} WebSocket connection retries failure: maximum retries reached (${
- this.autoReconnectRetryCount
+ this.wsConnectionRetryCount
}) or retries disabled (${this.stationInfo?.autoReconnectMaxRetries})`
)
}