import { URL } from 'url';
import { parentPort } from 'worker_threads';
-import WebSocket, { Data, RawData } from 'ws';
+import WebSocket, { type RawData } from 'ws';
import BaseError from '../exception/BaseError';
import OCPPError from '../exception/OCPPError';
AvailabilityType,
BootNotificationRequest,
CachedRequest,
+ ErrorCallback,
HeartbeatRequest,
IncomingRequest,
IncomingRequestCommand,
MeterValuesRequest,
RequestCommand,
+ ResponseCallback,
StatusNotificationRequest,
} from '../types/ocpp/Requests';
import {
public readonly templateFile: string;
public stationInfo!: ChargingStationInfo;
public started: boolean;
+ public starting: boolean;
public authorizedTagsCache: AuthorizedTagsCache;
public automaticTransactionGenerator!: AutomaticTransactionGenerator;
public ocppConfiguration!: ChargingStationOcppConfiguration;
public bootNotificationRequest!: BootNotificationRequest;
public bootNotificationResponse!: BootNotificationResponse | null;
public powerDivider!: number;
- private starting: boolean;
private stopping: boolean;
private configurationFile!: string;
private configurationFileHash!: string;
}
public isRegistered(): boolean {
- return !this.isInUnknownState() && (this.isInAcceptedState() || this.isInPendingState());
+ return (
+ this.isInUnknownState() === false &&
+ (this.isInAcceptedState() === true || this.isInPendingState() === true)
+ );
}
public isChargingStationAvailable(): boolean {
if (this.stopping === false) {
this.stopping = true;
await this.stopMessageSequence(reason);
- for (const connectorId of this.connectors.keys()) {
- if (connectorId > 0) {
- await this.ocppRequestService.requestHandler<
- StatusNotificationRequest,
- StatusNotificationResponse
- >(this, RequestCommand.STATUS_NOTIFICATION, {
- connectorId,
- status: ChargePointStatus.UNAVAILABLE,
- errorCode: ChargePointErrorCode.NO_ERROR,
- });
- this.getConnectorStatus(connectorId).status = null;
- }
- }
this.closeWSConnection();
- this.wsConnectionRestarted = false;
if (this.getEnableStatistics()) {
this.performanceStatistics.stop();
}
options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
params.closeOpened = params?.closeOpened ?? false;
params.terminateOpened = params?.terminateOpened ?? false;
+ if (this.started === false && this.starting === false) {
+ logger.warn(
+ `${this.logPrefix()} Cannot open OCPP connection to URL ${this.wsConnectionUrl.toString()} on stopped charging station`
+ );
+ return;
+ }
if (
!Utils.isNullOrUndefined(this.stationInfo.supervisionUser) &&
!Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)
): Promise<StopTransactionResponse> {
const transactionId = this.getConnectorStatus(connectorId).transactionId;
if (
- this.getBeginEndMeterValues() &&
- this.getOcppStrictCompliance() &&
- !this.getOutOfOrderEndMeterValues()
+ this.getBeginEndMeterValues() === true &&
+ this.getOcppStrictCompliance() === true &&
+ this.getOutOfOrderEndMeterValues() === false
) {
// FIXME: Implement OCPP version agnostic helpers
const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
private getStationInfoFromTemplate(): ChargingStationInfo {
const stationTemplate: ChargingStationTemplate = this.getTemplateFromFile();
if (Utils.isNullOrUndefined(stationTemplate)) {
- const errorMsg = 'Failed to read charging station template file';
+ const errorMsg = `Failed to read charging station template file ${this.templateFile}`;
logger.error(`${this.logPrefix()} ${errorMsg}`);
throw new BaseError(errorMsg);
}
'supervisionUrl',
'supervisionUrls'
);
+ const firmwareVersionRegExp = stationTemplate.firmwareVersionPattern
+ ? new RegExp(stationTemplate.firmwareVersionPattern)
+ : Constants.SEMVER_REGEXP;
+ if (
+ stationTemplate.firmwareVersion &&
+ firmwareVersionRegExp.test(stationTemplate.firmwareVersion) === false
+ ) {
+ logger.warn(
+ `${this.logPrefix()} Firmware version '${
+ stationTemplate.firmwareVersion
+ }' in template file ${
+ this.templateFile
+ } does not match regular expression '${firmwareVersionRegExp.toString()}'`
+ );
+ }
const stationInfo: ChargingStationInfo =
ChargingStationUtils.stationTemplateToStationInfo(stationTemplate);
stationInfo.hashId = ChargingStationUtils.getHashId(this.index, stationTemplate);
this.handleUnsupportedVersion(this.getOcppVersion());
break;
}
- if (this.stationInfo?.autoRegister) {
+ if (this.stationInfo?.autoRegister === true) {
this.bootNotificationResponse = {
currentTime: new Date().toISOString(),
interval: this.getHeartbeatInterval() / 1000,
}
// Initialize transaction attributes on connectors
for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionStarted === true) {
+ logger.warn(
+ `${this.logPrefix()} Connector ${connectorId} at initialization has a transaction started: ${
+ this.getConnectorStatus(connectorId).transactionId
+ }`
+ );
+ }
if (
connectorId > 0 &&
(this.getConnectorStatus(connectorId).transactionStarted === undefined ||
- this.getConnectorStatus(connectorId).transactionStarted === false)
+ this.getConnectorStatus(connectorId).transactionStarted === null)
) {
this.initializeConnectorStatus(connectorId);
}
private getOcppConfigurationFromFile(): ChargingStationOcppConfiguration | null {
let configuration: ChargingStationConfiguration = null;
- if (this.getOcppPersistentConfiguration()) {
+ if (this.getOcppPersistentConfiguration() === true) {
const configurationFromFile = this.getConfigurationFromFile();
configuration = configurationFromFile?.configurationKey && configurationFromFile;
}
logger.info(
`${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} succeeded`
);
- if (!this.isRegistered()) {
+ if (this.isRegistered() === false) {
// Send BootNotification
let registrationRetryCount = 0;
do {
>(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
skipBufferingOnError: true,
});
- if (!this.isRegistered()) {
+ if (this.isRegistered() === false) {
this.getRegistrationMaxRetries() !== -1 && registrationRetryCount++;
await Utils.sleep(
this.bootNotificationResponse?.interval
);
}
} while (
- !this.isRegistered() &&
+ this.isRegistered() === false &&
(registrationRetryCount <= this.getRegistrationMaxRetries() ||
this.getRegistrationMaxRetries() === -1)
);
}
- if (this.isRegistered()) {
- if (this.isInAcceptedState()) {
+ if (this.isRegistered() === true) {
+ if (this.isInAcceptedState() === true) {
await this.startMessageSequence();
}
} else {
}
}
- private async onClose(code: number, reason: string): Promise<void> {
+ private async onClose(code: number, reason: Buffer): Promise<void> {
switch (code) {
// Normal close
case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
logger.info(
`${this.logPrefix()} WebSocket normally closed with status '${Utils.getWebSocketCloseEventStatusString(
code
- )}' and reason '${reason}'`
+ )}' and reason '${reason.toString()}'`
);
this.autoReconnectRetryCount = 0;
break;
logger.error(
`${this.logPrefix()} WebSocket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(
code
- )}' and reason '${reason}'`
+ )}' and reason '${reason.toString()}'`
);
this.started === true && (await this.reconnect());
break;
parentPort.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
}
- private async onMessage(data: Data): Promise<void> {
+ private async onMessage(data: RawData): Promise<void> {
let messageType: number;
let messageId: string;
let commandName: IncomingRequestCommand;
let errorType: ErrorType;
let errorMessage: string;
let errorDetails: JsonType;
- let responseCallback: (payload: JsonType, requestPayload: JsonType) => void;
- let errorCallback: (error: OCPPError, requestStatistic?: boolean) => void;
+ let responseCallback: ResponseCallback;
+ let errorCallback: ErrorCallback;
let requestCommandName: RequestCommand | IncomingRequestCommand;
let requestPayload: JsonType;
let cachedRequest: CachedRequest;
}
private async startMessageSequence(): Promise<void> {
- if (this.stationInfo?.autoRegister) {
+ if (this.stationInfo?.autoRegister === true) {
await this.ocppRequestService.requestHandler<
BootNotificationRequest,
BootNotificationResponse
continue;
} else if (
!this.getConnectorStatus(connectorId)?.status &&
- this.getConnectorStatus(connectorId)?.bootStatus
+ (this.isChargingStationAvailable() === false ||
+ this.isConnectorAvailable(connectorId) === false)
) {
- // Set boot status in template at startup
- chargePointStatus = this.getConnectorStatus(connectorId).bootStatus;
+ chargePointStatus = ChargePointStatus.UNAVAILABLE;
} else if (
!this.getConnectorStatus(connectorId)?.status &&
- (this.isChargingStationAvailable() === false ||
- (this.isChargingStationAvailable() === true &&
- this.isConnectorAvailable(connectorId) === false))
+ this.getConnectorStatus(connectorId)?.bootStatus
) {
- chargePointStatus = ChargePointStatus.UNAVAILABLE;
+ // Set boot status in template at startup
+ chargePointStatus = this.getConnectorStatus(connectorId).bootStatus;
} else if (this.getConnectorStatus(connectorId)?.status) {
// Set previous status at startup
chargePointStatus = this.getConnectorStatus(connectorId).status;
} else {
await this.stopRunningTransactions(reason);
}
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0) {
+ await this.ocppRequestService.requestHandler<
+ StatusNotificationRequest,
+ StatusNotificationResponse
+ >(this, RequestCommand.STATUS_NOTIFICATION, {
+ connectorId,
+ status: ChargePointStatus.UNAVAILABLE,
+ errorCode: ChargePointErrorCode.NO_ERROR,
+ });
+ this.getConnectorStatus(connectorId).status = null;
+ }
+ }
}
private startWebSocketPing(): void {
if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
this.webSocketPingSetInterval = setInterval(() => {
if (this.isWebSocketConnectionOpened() === true) {
- this.wsConnection.ping((): void => {
- /* This is intentional */
- });
+ this.wsConnection.ping();
}
}, webSocketPingInterval * 1000);
logger.info(
} else if (this.webSocketPingSetInterval) {
logger.info(
this.logPrefix() +
- ' WebSocket ping every ' +
- Utils.formatDurationSeconds(webSocketPingInterval) +
- ' already started'
+ ' WebSocket ping already started every ' +
+ Utils.formatDurationSeconds(webSocketPingInterval)
);
} else {
logger.error(
}
private getConfiguredSupervisionUrl(): URL {
- const supervisionUrls = Utils.cloneObject<string | string[]>(
- this.stationInfo.supervisionUrls ?? Configuration.getSupervisionUrls()
- );
+ const supervisionUrls = this.stationInfo.supervisionUrls ?? Configuration.getSupervisionUrls();
if (!Utils.isEmptyArray(supervisionUrls)) {
switch (Configuration.getSupervisionUrlDistribution()) {
case SupervisionUrlDistribution.ROUND_ROBIN:
if (HeartBeatInterval) {
return Utils.convertToInt(HeartBeatInterval.value) * 1000;
}
- !this.stationInfo?.autoRegister &&
+ this.stationInfo?.autoRegister === false &&
logger.warn(
`${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
Constants.DEFAULT_HEARTBEAT_INTERVAL
? reconnectDelay - reconnectDelayWithdraw
: 0;
logger.error(
- `${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(
+ `${this.logPrefix()} WebSocket connection retry in ${Utils.roundTo(
reconnectDelay,
2
)}ms, timeout ${reconnectTimeout}ms`
);
await Utils.sleep(reconnectDelay);
logger.error(
- this.logPrefix() +
- ' WebSocket: reconnecting try #' +
- this.autoReconnectRetryCount.toString()
+ this.logPrefix() + ' WebSocket connection retry #' + this.autoReconnectRetryCount.toString()
);
this.openWSConnection(
{ ...(this.stationInfo?.wsOptions ?? {}), handshakeTimeout: reconnectTimeout },
this.wsConnectionRestarted = true;
} else if (this.getAutoReconnectMaxRetries() !== -1) {
logger.error(
- `${this.logPrefix()} WebSocket reconnect failure: maximum retries reached (${
+ `${this.logPrefix()} WebSocket connection retries failure: maximum retries reached (${
this.autoReconnectRetryCount
- }) or retry disabled (${this.getAutoReconnectMaxRetries()})`
+ }) or retries disabled (${this.getAutoReconnectMaxRetries()})`
);
}
}