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 {
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);
}
// 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;
} else if (
!this.getConnectorStatus(connectorId)?.status &&
(this.isChargingStationAvailable() === false ||
- (this.isChargingStationAvailable() === true &&
- this.isConnectorAvailable(connectorId) === false))
+ this.isConnectorAvailable(connectorId) === false)
) {
chargePointStatus = ChargePointStatus.UNAVAILABLE;
} else if (
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(
}
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:
repositories / e-mobility-charging-stations-simulator.git / blobdiff