import Connectors, { Connector, SampledValueTemplate } from '../types/Connectors';
import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
import Requests, { AvailabilityType, BootNotificationRequest, IncomingRequest, IncomingRequestCommand } from '../types/ocpp/Requests';
-import WebSocket, { MessageEvent } from 'ws';
+import WebSocket, { ClientOptions, MessageEvent } from 'ws';
import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
import { ChargingProfile } from '../types/ocpp/ChargingProfile';
import ChargingStationInfo from '../types/ChargingStationInfo';
+import { ClientRequestArgs } from 'http';
import Configuration from '../utils/Configuration';
import Constants from '../utils/Constants';
import FileUtils from '../utils/FileUtils';
import { MessageType } from '../types/ocpp/MessageType';
-import OCPP16IncomingRequestService from './ocpp/1.6/OCCP16IncomingRequestService';
+import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
import OCPPError from './OCPPError';
import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
import OCPPRequestService from './ocpp/OCPPRequestService';
import { OCPPVersion } from '../types/ocpp/OCPPVersion';
-import { PerformanceObserver } from 'perf_hooks';
import PerformanceStatistics from '../utils/PerformanceStatistics';
import { StopTransactionReason } from '../types/ocpp/Transaction';
import { URL } from 'url';
private hasSocketRestarted: boolean;
private autoReconnectRetryCount: number;
private automaticTransactionGeneration!: AutomaticTransactionGenerator;
- private performanceObserver!: PerformanceObserver;
private webSocketPingSetInterval!: NodeJS.Timeout;
constructor(index: number, stationTemplateFile: string) {
}
}
- public isWebSocketOpen(): boolean {
+ public isWebSocketConnectionOpened(): boolean {
return this.wsConnection?.readyState === WebSocket.OPEN;
}
if (interval > 0) {
// eslint-disable-next-line @typescript-eslint/no-misused-promises
this.getConnector(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
- await this.ocppRequestService.sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval, this.ocppRequestService);
+ await this.ocppRequestService.sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval);
}, interval);
} else {
logger.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.milliSecondsToHHMMSS(interval) : interval}, not sending MeterValues`);
}
public start(): void {
+ if (this.getEnableStatistics()) {
+ this.performanceStatistics.start();
+ }
this.openWSConnection();
// Monitor authorization file
this.startAuthorizationFileMonitoring();
this.getConnector(Utils.convertToInt(connector)).status = ChargePointStatus.UNAVAILABLE;
}
}
- if (this.isWebSocketOpen()) {
+ if (this.isWebSocketConnectionOpened()) {
this.wsConnection.close();
}
+ if (this.getEnableStatistics()) {
+ this.performanceStatistics.stop();
+ }
this.bootNotificationResponse = null;
this.hasStopped = true;
}
public getConfigurationKey(key: string | StandardParametersKey, caseInsensitive = false): ConfigurationKey | undefined {
- const configurationKey: ConfigurationKey | undefined = this.configuration.configurationKey.find((configElement) => {
+ return this.configuration.configurationKey.find((configElement) => {
if (caseInsensitive) {
return configElement.key.toLowerCase() === key.toLowerCase();
}
return configElement.key === key;
});
- return configurationKey;
}
public addConfigurationKey(key: string | StandardParametersKey, value: string, readonly = false, visible = true, reboot = false): void {
if (!Utils.isEmptyArray(this.messageQueue)) {
this.messageQueue.forEach((message, index) => {
this.messageQueue.splice(index, 1);
+ // TODO: evaluate the need to track performance
this.wsConnection.send(message);
});
}
this.stationInfo.powerDivider = this.getPowerDivider();
if (this.getEnableStatistics()) {
this.performanceStatistics = new PerformanceStatistics(this.stationInfo.chargingStationId);
- this.performanceObserver = PerformanceStatistics.initPerformanceObserver(Constants.ENTITY_CHARGING_STATION, this.performanceStatistics, this.performanceObserver);
}
}
}
private async onOpen(): Promise<void> {
- logger.info(`${this.logPrefix()} Connected to server through ${this.wsConnectionUrl.toString()}`);
+ logger.info(`${this.logPrefix()} Connected to OCPP server through ${this.wsConnectionUrl.toString()}`);
if (!this.isRegistered()) {
// Send BootNotification
let registrationRetryCount = 0;
if (this.isRegistered()) {
await this.startMessageSequence();
this.hasStopped && (this.hasStopped = false);
- if (this.hasSocketRestarted && this.isWebSocketOpen()) {
+ if (this.hasSocketRestarted && this.isWebSocketConnectionOpened()) {
this.flushMessageQueue();
}
} else {
// Incoming Message
case MessageType.CALL_MESSAGE:
if (this.getEnableStatistics()) {
- this.performanceStatistics.addMessage(commandName, messageType);
+ this.performanceStatistics.addRequestStatistic(commandName, messageType);
}
// Process the call
await this.ocppIncomingRequestService.handleRequest(messageId, commandName, commandPayload);
}
private getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
- return this.stationInfo.Configuration ? this.stationInfo.Configuration : {} as ChargingStationConfiguration;
+ return this.stationInfo.Configuration ?? {} as ChargingStationConfiguration;
}
private getAuthorizationFile(): string | undefined {
}
// Start the ATG
this.startAutomaticTransactionGenerator();
- if (this.getEnableStatistics()) {
- this.performanceStatistics.start();
- }
}
private startAutomaticTransactionGenerator() {
: 0;
if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
this.webSocketPingSetInterval = setInterval(() => {
- if (this.isWebSocketOpen()) {
+ if (this.isWebSocketConnectionOpened()) {
this.wsConnection.ping((): void => { });
}
}, webSocketPingInterval * 1000);
}
}
- private openWSConnection(options?: WebSocket.ClientOptions, forceCloseOpened = false): void {
- options ?? {} as WebSocket.ClientOptions;
- options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
- if (this.isWebSocketOpen() && forceCloseOpened) {
+ private openWSConnection(options?: ClientOptions & ClientRequestArgs, forceCloseOpened = false): void {
+ options = options ?? {};
+ options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
+ if (!Utils.isNullOrUndefined(this.stationInfo.supervisionUser) && !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)) {
+ options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
+ }
+ if (this.isWebSocketConnectionOpened() && forceCloseOpened) {
this.wsConnection.close();
}
let protocol;
break;
}
this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
- logger.info(this.logPrefix() + ' Open connection to URL ' + this.wsConnectionUrl.toString());
+ logger.info(this.logPrefix() + ' Open OCPP connection to URL ' + this.wsConnectionUrl.toString());
}
private stopMeterValues(connectorId: number) {
logger.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile + ' have changed, reload');
// Initialize
this.initialize();
- // Stop the ATG
+ // Restart the ATG
if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
this.automaticTransactionGeneration) {
await this.automaticTransactionGeneration.stop();
}
- // Start the ATG
this.startAutomaticTransactionGenerator();
+ if (this.getEnableStatistics()) {
+ this.performanceStatistics.restart();
+ } else {
+ this.performanceStatistics.stop();
+ }
// FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
} catch (error) {
logger.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error);
}
private async reconnect(error: any): Promise<void> {
+ // Stop WebSocket ping
+ this.stopWebSocketPing();
// Stop heartbeat
this.stopHeartbeat();
// Stop the ATG if needed
repositories / e-mobility-charging-stations-simulator.git / blobdiff