import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles } from '../types/ocpp/Configuration';
import Connectors, { Connector, SampledValueTemplate } from '../types/Connectors';
import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
-import { PerformanceObserver, performance } from 'perf_hooks';
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 OCPPError from './OCPPError';
import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
import OCPPRequestService from './ocpp/OCPPRequestService';
import { OCPPVersion } from '../types/ocpp/OCPPVersion';
import PerformanceStatistics from '../utils/PerformanceStatistics';
import { StopTransactionReason } from '../types/ocpp/Transaction';
+import { URL } from 'url';
import Utils from '../utils/Utils';
import { WebSocketCloseEventStatusCode } from '../types/WebSocket';
import crypto from 'crypto';
private bootNotificationRequest!: BootNotificationRequest;
private bootNotificationResponse!: BootNotificationResponse | null;
private connectorsConfigurationHash!: string;
- private supervisionUrl!: string;
- private wsConnectionUrl!: string;
+ private wsConnectionUrl!: URL;
private hasSocketRestarted: boolean;
private autoReconnectRetryCount: number;
private automaticTransactionGeneration!: AutomaticTransactionGenerator;
- private performanceObserver!: PerformanceObserver;
private webSocketPingSetInterval!: NodeJS.Timeout;
constructor(index: number, stationTemplateFile: string) {
break;
default:
logger.error(errMsg);
- throw Error(errMsg);
+ throw new Error(errMsg);
}
return !Utils.isUndefined(this.stationInfo.voltageOut) ? this.stationInfo.voltageOut : defaultVoltageOut;
}
}
const sampledValueTemplates: SampledValueTemplate[] = this.getConnector(connectorId).MeterValues;
for (let index = 0; !Utils.isEmptyArray(sampledValueTemplates) && index < sampledValueTemplates.length; index++) {
- if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand)) {
+ if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER)) {
logger.warn(`${this.logPrefix()} Unsupported MeterValues measurand ${measurand} ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
continue;
} else if (phase && sampledValueTemplates[index]?.phase === phase && sampledValueTemplates[index]?.measurand === measurand
if (interval > 0) {
// eslint-disable-next-line @typescript-eslint/no-misused-promises
this.getConnector(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
- if (this.getEnableStatistics()) {
- const sendMeterValues = performance.timerify(this.ocppRequestService.sendMeterValues);
- this.performanceObserver.observe({
- entryTypes: ['function'],
- });
- await sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval, this.ocppRequestService);
- } else {
- 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();
if (this.isWebSocketOpen()) {
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);
});
}
...!Utils.isUndefined(this.stationInfo.firmwareVersion) && { firmwareVersion: this.stationInfo.firmwareVersion },
};
this.configuration = this.getTemplateChargingStationConfiguration();
- this.supervisionUrl = this.getSupervisionURL();
- this.wsConnectionUrl = this.supervisionUrl + '/' + this.stationInfo.chargingStationId;
+ this.wsConnectionUrl = new URL(this.getSupervisionURL().href + '/' + this.stationInfo.chargingStationId);
// Build connectors if needed
const maxConnectors = this.getMaxNumberOfConnectors();
if (maxConnectors <= 0) {
this.stationInfo.powerDivider = this.getPowerDivider();
if (this.getEnableStatistics()) {
this.performanceStatistics = new PerformanceStatistics(this.stationInfo.chargingStationId);
- this.performanceObserver = new PerformanceObserver((list) => {
- const entry = list.getEntries()[0];
- this.performanceStatistics.logPerformance(entry, Constants.ENTITY_CHARGING_STATION);
- this.performanceObserver.disconnect();
- });
}
}
}
private async onOpen(): Promise<void> {
- logger.info(`${this.logPrefix()} Is connected to server through ${this.wsConnectionUrl}`);
+ logger.info(`${this.logPrefix()} Connected to OCPP server through ${this.wsConnectionUrl.toString()}`);
if (!this.isRegistered()) {
// Send BootNotification
let registrationRetryCount = 0;
// 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 onPing(): void {
- logger.debug(this.logPrefix() + ' Has received a WS ping (rfc6455) from the server');
+ logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
}
private onPong(): void {
- logger.debug(this.logPrefix() + ' Has received a WS pong (rfc6455) from the server');
+ logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
}
private async onError(errorEvent: any): Promise<void> {
}
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() {
}
}
- private getSupervisionURL(): string {
+ private getSupervisionURL(): URL {
const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionURL ? this.stationInfo.supervisionURL : Configuration.getSupervisionURLs());
let indexUrl = 0;
if (!Utils.isEmptyArray(supervisionUrls)) {
// Get a random url
indexUrl = Math.floor(Math.random() * supervisionUrls.length);
}
- return supervisionUrls[indexUrl];
+ return new URL(supervisionUrls[indexUrl]);
}
- return supervisionUrls as string;
+ return new URL(supervisionUrls as string);
}
private getHeartbeatInterval(): number | undefined {
}
}
- private openWSConnection(options?: WebSocket.ClientOptions, forceCloseOpened = false): void {
- options ?? {} as WebSocket.ClientOptions;
- options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
+ 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.isWebSocketOpen() && forceCloseOpened) {
this.wsConnection.close();
}
break;
}
this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
- logger.info(this.logPrefix() + ' Will communicate through URL ' + this.supervisionUrl);
+ 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