Cleanup
[e-mobility-charging-stations-simulator.git] / src / charging-station / ChargingStation.ts
1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
2
3 import { AvailabilityType, BootNotificationRequest, CachedRequest, IncomingRequest, IncomingRequestCommand, RequestCommand } from '../types/ocpp/Requests';
4 import { BootNotificationResponse, RegistrationStatus } from '../types/ocpp/Responses';
5 import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
6 import ChargingStationTemplate, { CurrentType, PowerUnits, Voltage } from '../types/ChargingStationTemplate';
7 import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles } from '../types/ocpp/Configuration';
8 import { ConnectorStatus, SampledValueTemplate } from '../types/Connectors';
9 import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
10 import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
11 import WebSocket, { ClientOptions, Data, OPEN } from 'ws';
12
13 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
14 import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
15 import { ChargingProfile } from '../types/ocpp/ChargingProfile';
16 import ChargingStationInfo from '../types/ChargingStationInfo';
17 import { ClientRequestArgs } from 'http';
18 import Configuration from '../utils/Configuration';
19 import Constants from '../utils/Constants';
20 import { ErrorType } from '../types/ocpp/ErrorType';
21 import FileUtils from '../utils/FileUtils';
22 import { MessageType } from '../types/ocpp/MessageType';
23 import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
24 import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
25 import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
26 import OCPPError from './ocpp/OCPPError';
27 import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
28 import OCPPRequestService from './ocpp/OCPPRequestService';
29 import { OCPPVersion } from '../types/ocpp/OCPPVersion';
30 import PerformanceStatistics from '../performance/PerformanceStatistics';
31 import { StopTransactionReason } from '../types/ocpp/Transaction';
32 import { URL } from 'url';
33 import Utils from '../utils/Utils';
34 import crypto from 'crypto';
35 import fs from 'fs';
36 import logger from '../utils/Logger';
37 import path from 'path';
38
39 export default class ChargingStation {
40 public stationTemplateFile: string;
41 public authorizedTags: string[];
42 public stationInfo!: ChargingStationInfo;
43 public connectors: Map<number, ConnectorStatus>;
44 public configuration!: ChargingStationConfiguration;
45 public wsConnection!: WebSocket;
46 public requests: Map<string, CachedRequest>;
47 public performanceStatistics!: PerformanceStatistics;
48 public heartbeatSetInterval!: NodeJS.Timeout;
49 public ocppRequestService!: OCPPRequestService;
50 private index: number;
51 private bootNotificationRequest!: BootNotificationRequest;
52 private bootNotificationResponse!: BootNotificationResponse | null;
53 private connectorsConfigurationHash!: string;
54 private ocppIncomingRequestService!: OCPPIncomingRequestService;
55 private messageQueue: string[];
56 private wsConnectionUrl!: URL;
57 private wsConnectionRestarted: boolean;
58 private stopped: boolean;
59 private autoReconnectRetryCount: number;
60 private automaticTransactionGenerator!: AutomaticTransactionGenerator;
61 private webSocketPingSetInterval!: NodeJS.Timeout;
62
63 constructor(index: number, stationTemplateFile: string) {
64 this.index = index;
65 this.stationTemplateFile = stationTemplateFile;
66 this.connectors = new Map<number, ConnectorStatus>();
67 this.initialize();
68
69 this.stopped = false;
70 this.wsConnectionRestarted = false;
71 this.autoReconnectRetryCount = 0;
72
73 this.requests = new Map<string, CachedRequest>();
74 this.messageQueue = new Array<string>();
75
76 this.authorizedTags = this.getAuthorizedTags();
77 }
78
79 public logPrefix(): string {
80 return Utils.logPrefix(` ${this.stationInfo.chargingStationId} |`);
81 }
82
83 public getBootNotificationRequest(): BootNotificationRequest {
84 return this.bootNotificationRequest;
85 }
86
87 public getRandomIdTag(): string {
88 const index = Math.floor(Utils.secureRandom() * this.authorizedTags.length);
89 return this.authorizedTags[index];
90 }
91
92 public hasAuthorizedTags(): boolean {
93 return !Utils.isEmptyArray(this.authorizedTags);
94 }
95
96 public getEnableStatistics(): boolean | undefined {
97 return !Utils.isUndefined(this.stationInfo.enableStatistics) ? this.stationInfo.enableStatistics : true;
98 }
99
100 public getMayAuthorizeAtRemoteStart(): boolean | undefined {
101 return this.stationInfo.mayAuthorizeAtRemoteStart ?? true;
102 }
103
104 public getNumberOfPhases(): number | undefined {
105 switch (this.getCurrentOutType()) {
106 case CurrentType.AC:
107 return !Utils.isUndefined(this.stationInfo.numberOfPhases) ? this.stationInfo.numberOfPhases : 3;
108 case CurrentType.DC:
109 return 0;
110 }
111 }
112
113 public isWebSocketConnectionOpened(): boolean {
114 return this.wsConnection?.readyState === OPEN;
115 }
116
117 public isRegistered(): boolean {
118 return this.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
119 }
120
121 public isChargingStationAvailable(): boolean {
122 return this.getConnectorStatus(0).availability === AvailabilityType.OPERATIVE;
123 }
124
125 public isConnectorAvailable(id: number): boolean {
126 return this.getConnectorStatus(id).availability === AvailabilityType.OPERATIVE;
127 }
128
129 public getConnectorStatus(id: number): ConnectorStatus {
130 return this.connectors.get(id);
131 }
132
133 public getCurrentOutType(): CurrentType | undefined {
134 return this.stationInfo.currentOutType ?? CurrentType.AC;
135 }
136
137 public getVoltageOut(): number | undefined {
138 const errMsg = `${this.logPrefix()} Unknown ${this.getCurrentOutType()} currentOutType in template file ${this.stationTemplateFile}, cannot define default voltage out`;
139 let defaultVoltageOut: number;
140 switch (this.getCurrentOutType()) {
141 case CurrentType.AC:
142 defaultVoltageOut = Voltage.VOLTAGE_230;
143 break;
144 case CurrentType.DC:
145 defaultVoltageOut = Voltage.VOLTAGE_400;
146 break;
147 default:
148 logger.error(errMsg);
149 throw new Error(errMsg);
150 }
151 return !Utils.isUndefined(this.stationInfo.voltageOut) ? this.stationInfo.voltageOut : defaultVoltageOut;
152 }
153
154 public getTransactionIdTag(transactionId: number): string | undefined {
155 for (const connectorId of this.connectors.keys()) {
156 if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
157 return this.getConnectorStatus(connectorId).transactionIdTag;
158 }
159 }
160 }
161
162 public getOutOfOrderEndMeterValues(): boolean {
163 return this.stationInfo.outOfOrderEndMeterValues ?? false;
164 }
165
166 public getBeginEndMeterValues(): boolean {
167 return this.stationInfo.beginEndMeterValues ?? false;
168 }
169
170 public getMeteringPerTransaction(): boolean {
171 return this.stationInfo.meteringPerTransaction ?? true;
172 }
173
174 public getTransactionDataMeterValues(): boolean {
175 return this.stationInfo.transactionDataMeterValues ?? false;
176 }
177
178 public getMainVoltageMeterValues(): boolean {
179 return this.stationInfo.mainVoltageMeterValues ?? true;
180 }
181
182 public getPhaseLineToLineVoltageMeterValues(): boolean {
183 return this.stationInfo.phaseLineToLineVoltageMeterValues ?? false;
184 }
185
186 public getEnergyActiveImportRegisterByTransactionId(transactionId: number): number | undefined {
187 if (this.getMeteringPerTransaction()) {
188 for (const connectorId of this.connectors.keys()) {
189 if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
190 return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
191 }
192 }
193 }
194 for (const connectorId of this.connectors.keys()) {
195 if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
196 return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
197 }
198 }
199 }
200
201 public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number | undefined {
202 if (this.getMeteringPerTransaction()) {
203 return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
204 }
205 return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
206 }
207
208 public getAuthorizeRemoteTxRequests(): boolean {
209 const authorizeRemoteTxRequests = this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests);
210 return authorizeRemoteTxRequests ? Utils.convertToBoolean(authorizeRemoteTxRequests.value) : false;
211 }
212
213 public getLocalAuthListEnabled(): boolean {
214 const localAuthListEnabled = this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled);
215 return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
216 }
217
218 public restartWebSocketPing(): void {
219 // Stop WebSocket ping
220 this.stopWebSocketPing();
221 // Start WebSocket ping
222 this.startWebSocketPing();
223 }
224
225 public getSampledValueTemplate(connectorId: number, measurand: MeterValueMeasurand = MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER,
226 phase?: MeterValuePhase): SampledValueTemplate | undefined {
227 if (!Constants.SUPPORTED_MEASURANDS.includes(measurand)) {
228 logger.warn(`${this.logPrefix()} Trying to get unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
229 return;
230 }
231 if (measurand !== MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER && !this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
232 logger.debug(`${this.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId} not found in '${StandardParametersKey.MeterValuesSampledData}' OCPP parameter`);
233 return;
234 }
235 const sampledValueTemplates: SampledValueTemplate[] = this.getConnectorStatus(connectorId).MeterValues;
236 for (let index = 0; !Utils.isEmptyArray(sampledValueTemplates) && index < sampledValueTemplates.length; index++) {
237 if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER)) {
238 logger.warn(`${this.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
239 } else if (phase && sampledValueTemplates[index]?.phase === phase && sampledValueTemplates[index]?.measurand === measurand
240 && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
241 return sampledValueTemplates[index];
242 } else if (!phase && !sampledValueTemplates[index].phase && sampledValueTemplates[index]?.measurand === measurand
243 && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
244 return sampledValueTemplates[index];
245 } else if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
246 && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
247 return sampledValueTemplates[index];
248 }
249 }
250 if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) {
251 const errorMsg = `${this.logPrefix()} Missing MeterValues for default measurand '${measurand}' in template on connectorId ${connectorId}`;
252 logger.error(errorMsg);
253 throw new Error(errorMsg);
254 }
255 logger.debug(`${this.logPrefix()} No MeterValues for measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
256 }
257
258 public getAutomaticTransactionGeneratorRequireAuthorize(): boolean {
259 return this.stationInfo.AutomaticTransactionGenerator.requireAuthorize ?? true;
260 }
261
262 public startHeartbeat(): void {
263 if (this.getHeartbeatInterval() && this.getHeartbeatInterval() > 0 && !this.heartbeatSetInterval) {
264 // eslint-disable-next-line @typescript-eslint/no-misused-promises
265 this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
266 await this.ocppRequestService.sendHeartbeat();
267 }, this.getHeartbeatInterval());
268 logger.info(this.logPrefix() + ' Heartbeat started every ' + Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()));
269 } else if (this.heartbeatSetInterval) {
270 logger.info(this.logPrefix() + ' Heartbeat already started every ' + Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()));
271 } else {
272 logger.error(`${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval() ? Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()) : this.getHeartbeatInterval()}, not starting the heartbeat`);
273 }
274 }
275
276 public restartHeartbeat(): void {
277 // Stop heartbeat
278 this.stopHeartbeat();
279 // Start heartbeat
280 this.startHeartbeat();
281 }
282
283 public startMeterValues(connectorId: number, interval: number): void {
284 if (connectorId === 0) {
285 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
286 return;
287 }
288 if (!this.getConnectorStatus(connectorId)) {
289 logger.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
290 return;
291 }
292 if (!this.getConnectorStatus(connectorId)?.transactionStarted) {
293 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
294 return;
295 } else if (this.getConnectorStatus(connectorId)?.transactionStarted && !this.getConnectorStatus(connectorId)?.transactionId) {
296 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
297 return;
298 }
299 if (interval > 0) {
300 // eslint-disable-next-line @typescript-eslint/no-misused-promises
301 this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
302 await this.ocppRequestService.sendMeterValues(connectorId, this.getConnectorStatus(connectorId).transactionId, interval);
303 }, interval);
304 } else {
305 logger.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.formatDurationMilliSeconds(interval) : interval}, not sending MeterValues`);
306 }
307 }
308
309 public start(): void {
310 if (this.getEnableStatistics()) {
311 this.performanceStatistics.start();
312 }
313 this.openWSConnection();
314 // Monitor authorization file
315 this.startAuthorizationFileMonitoring();
316 // Monitor station template file
317 this.startStationTemplateFileMonitoring();
318 // Handle WebSocket message
319 this.wsConnection.on('message', this.onMessage.bind(this));
320 // Handle WebSocket error
321 this.wsConnection.on('error', this.onError.bind(this));
322 // Handle WebSocket close
323 this.wsConnection.on('close', this.onClose.bind(this));
324 // Handle WebSocket open
325 this.wsConnection.on('open', this.onOpen.bind(this));
326 // Handle WebSocket ping
327 this.wsConnection.on('ping', this.onPing.bind(this));
328 // Handle WebSocket pong
329 this.wsConnection.on('pong', this.onPong.bind(this));
330 }
331
332 public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
333 // Stop message sequence
334 await this.stopMessageSequence(reason);
335 for (const connectorId of this.connectors.keys()) {
336 if (connectorId > 0) {
337 await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.UNAVAILABLE);
338 this.getConnectorStatus(connectorId).status = ChargePointStatus.UNAVAILABLE;
339 }
340 }
341 if (this.isWebSocketConnectionOpened()) {
342 this.wsConnection.close();
343 }
344 if (this.getEnableStatistics()) {
345 this.performanceStatistics.stop();
346 }
347 this.bootNotificationResponse = null;
348 this.stopped = true;
349 }
350
351 public getConfigurationKey(key: string | StandardParametersKey, caseInsensitive = false): ConfigurationKey | undefined {
352 return this.configuration.configurationKey.find((configElement) => {
353 if (caseInsensitive) {
354 return configElement.key.toLowerCase() === key.toLowerCase();
355 }
356 return configElement.key === key;
357 });
358 }
359
360 public addConfigurationKey(key: string | StandardParametersKey, value: string, readonly = false, visible = true, reboot = false): void {
361 const keyFound = this.getConfigurationKey(key);
362 if (!keyFound) {
363 this.configuration.configurationKey.push({
364 key,
365 readonly,
366 value,
367 visible,
368 reboot,
369 });
370 } else {
371 logger.error(`${this.logPrefix()} Trying to add an already existing configuration key: %j`, keyFound);
372 }
373 }
374
375 public setConfigurationKeyValue(key: string | StandardParametersKey, value: string): void {
376 const keyFound = this.getConfigurationKey(key);
377 if (keyFound) {
378 const keyIndex = this.configuration.configurationKey.indexOf(keyFound);
379 this.configuration.configurationKey[keyIndex].value = value;
380 } else {
381 logger.error(`${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key, value });
382 }
383 }
384
385 public setChargingProfile(connectorId: number, cp: ChargingProfile): void {
386 let cpReplaced = false;
387 if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
388 this.getConnectorStatus(connectorId).chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => {
389 if (chargingProfile.chargingProfileId === cp.chargingProfileId
390 || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
391 this.getConnectorStatus(connectorId).chargingProfiles[index] = cp;
392 cpReplaced = true;
393 }
394 });
395 }
396 !cpReplaced && this.getConnectorStatus(connectorId).chargingProfiles?.push(cp);
397 }
398
399 public resetTransactionOnConnector(connectorId: number): void {
400 this.getConnectorStatus(connectorId).authorized = false;
401 this.getConnectorStatus(connectorId).transactionStarted = false;
402 delete this.getConnectorStatus(connectorId).authorizeIdTag;
403 delete this.getConnectorStatus(connectorId).transactionId;
404 delete this.getConnectorStatus(connectorId).transactionIdTag;
405 this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
406 delete this.getConnectorStatus(connectorId).transactionBeginMeterValue;
407 this.stopMeterValues(connectorId);
408 }
409
410 public addToMessageQueue(message: string): void {
411 let dups = false;
412 // Handle dups in message queue
413 for (const bufferedMessage of this.messageQueue) {
414 // Message already in the queue
415 if (message === bufferedMessage) {
416 dups = true;
417 break;
418 }
419 }
420 if (!dups) {
421 // Queue message
422 this.messageQueue.push(message);
423 }
424 }
425
426 private flushMessageQueue() {
427 if (!Utils.isEmptyArray(this.messageQueue)) {
428 this.messageQueue.forEach((message, index) => {
429 this.messageQueue.splice(index, 1);
430 // TODO: evaluate the need to track performance
431 this.wsConnection.send(message);
432 });
433 }
434 }
435
436 private getChargingStationId(stationTemplate: ChargingStationTemplate): string {
437 // In case of multiple instances: add instance index to charging station id
438 const instanceIndex = process.env.CF_INSTANCE_INDEX ?? 0;
439 const idSuffix = stationTemplate.nameSuffix ?? '';
440 return stationTemplate.fixedName ? stationTemplate.baseName : stationTemplate.baseName + '-' + instanceIndex.toString() + ('000000000' + this.index.toString()).substr(('000000000' + this.index.toString()).length - 4) + idSuffix;
441 }
442
443 private buildStationInfo(): ChargingStationInfo {
444 let stationTemplateFromFile: ChargingStationTemplate;
445 try {
446 // Load template file
447 const fileDescriptor = fs.openSync(this.stationTemplateFile, 'r');
448 stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as ChargingStationTemplate;
449 fs.closeSync(fileDescriptor);
450 } catch (error) {
451 FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
452 }
453 const stationInfo: ChargingStationInfo = stationTemplateFromFile ?? {} as ChargingStationInfo;
454 if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
455 stationTemplateFromFile.power = stationTemplateFromFile.power as number[];
456 const powerArrayRandomIndex = Math.floor(Utils.secureRandom() * stationTemplateFromFile.power.length);
457 stationInfo.maxPower = stationTemplateFromFile.powerUnit === PowerUnits.KILO_WATT
458 ? stationTemplateFromFile.power[powerArrayRandomIndex] * 1000
459 : stationTemplateFromFile.power[powerArrayRandomIndex];
460 } else {
461 stationTemplateFromFile.power = stationTemplateFromFile.power as number;
462 stationInfo.maxPower = stationTemplateFromFile.powerUnit === PowerUnits.KILO_WATT
463 ? stationTemplateFromFile.power * 1000
464 : stationTemplateFromFile.power;
465 }
466 delete stationInfo.power;
467 delete stationInfo.powerUnit;
468 stationInfo.chargingStationId = this.getChargingStationId(stationTemplateFromFile);
469 stationInfo.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
470 return stationInfo;
471 }
472
473 private getOCPPVersion(): OCPPVersion {
474 return this.stationInfo.ocppVersion ? this.stationInfo.ocppVersion : OCPPVersion.VERSION_16;
475 }
476
477 private handleUnsupportedVersion(version: OCPPVersion) {
478 const errMsg = `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${this.stationTemplateFile}`;
479 logger.error(errMsg);
480 throw new Error(errMsg);
481 }
482
483 private initialize(): void {
484 this.stationInfo = this.buildStationInfo();
485 this.bootNotificationRequest = {
486 chargePointModel: this.stationInfo.chargePointModel,
487 chargePointVendor: this.stationInfo.chargePointVendor,
488 ...!Utils.isUndefined(this.stationInfo.chargeBoxSerialNumberPrefix) && { chargeBoxSerialNumber: this.stationInfo.chargeBoxSerialNumberPrefix },
489 ...!Utils.isUndefined(this.stationInfo.firmwareVersion) && { firmwareVersion: this.stationInfo.firmwareVersion },
490 };
491 this.configuration = this.getTemplateChargingStationConfiguration();
492 this.wsConnectionUrl = new URL(this.getSupervisionURL().href + '/' + this.stationInfo.chargingStationId);
493 // Build connectors if needed
494 const maxConnectors = this.getMaxNumberOfConnectors();
495 if (maxConnectors <= 0) {
496 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with ${maxConnectors} connectors`);
497 }
498 const templateMaxConnectors = this.getTemplateMaxNumberOfConnectors();
499 if (templateMaxConnectors <= 0) {
500 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector configuration`);
501 }
502 if (!this.stationInfo.Connectors[0]) {
503 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector Id 0 configuration`);
504 }
505 // Sanity check
506 if (maxConnectors > (this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) && !this.stationInfo.randomConnectors) {
507 logger.warn(`${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this.stationTemplateFile}, forcing random connector configurations affectation`);
508 this.stationInfo.randomConnectors = true;
509 }
510 const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
511 const connectorsConfigChanged = this.connectors.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash;
512 if (!this.connectors || this.connectors.size === 0 || connectorsConfigChanged) {
513 connectorsConfigChanged && (this.connectors.clear());
514 this.connectorsConfigurationHash = connectorsConfigHash;
515 // Add connector Id 0
516 let lastConnector = '0';
517 for (lastConnector in this.stationInfo.Connectors) {
518 const lastConnectorId = Utils.convertToInt(lastConnector);
519 if (lastConnectorId === 0 && this.getUseConnectorId0() && this.stationInfo.Connectors[lastConnector]) {
520 this.connectors.set(lastConnectorId, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[lastConnector]));
521 this.getConnectorStatus(lastConnectorId).availability = AvailabilityType.OPERATIVE;
522 if (Utils.isUndefined(this.getConnectorStatus(lastConnectorId)?.chargingProfiles)) {
523 this.getConnectorStatus(lastConnectorId).chargingProfiles = [];
524 }
525 }
526 }
527 // Generate all connectors
528 if ((this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
529 for (let index = 1; index <= maxConnectors; index++) {
530 const randConnectorId = this.stationInfo.randomConnectors ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1) : index;
531 this.connectors.set(index, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[randConnectorId]));
532 this.getConnectorStatus(index).availability = AvailabilityType.OPERATIVE;
533 if (Utils.isUndefined(this.getConnectorStatus(index)?.chargingProfiles)) {
534 this.getConnectorStatus(index).chargingProfiles = [];
535 }
536 }
537 }
538 }
539 // Avoid duplication of connectors related information
540 delete this.stationInfo.Connectors;
541 // Initialize transaction attributes on connectors
542 for (const connectorId of this.connectors.keys()) {
543 if (connectorId > 0 && !this.getConnectorStatus(connectorId)?.transactionStarted) {
544 this.initTransactionAttributesOnConnector(connectorId);
545 }
546 }
547 switch (this.getOCPPVersion()) {
548 case OCPPVersion.VERSION_16:
549 this.ocppIncomingRequestService = new OCPP16IncomingRequestService(this);
550 this.ocppRequestService = new OCPP16RequestService(this, new OCPP16ResponseService(this));
551 break;
552 default:
553 this.handleUnsupportedVersion(this.getOCPPVersion());
554 break;
555 }
556 // OCPP parameters
557 this.initOCPPParameters();
558 if (this.stationInfo.autoRegister) {
559 this.bootNotificationResponse = {
560 currentTime: new Date().toISOString(),
561 interval: this.getHeartbeatInterval() / 1000,
562 status: RegistrationStatus.ACCEPTED
563 };
564 }
565 this.stationInfo.powerDivider = this.getPowerDivider();
566 if (this.getEnableStatistics()) {
567 this.performanceStatistics = new PerformanceStatistics(this.stationInfo.chargingStationId, this.wsConnectionUrl);
568 }
569 }
570
571 private initOCPPParameters(): void {
572 if (!this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)) {
573 this.addConfigurationKey(StandardParametersKey.SupportedFeatureProfiles, `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.Local_Auth_List_Management},${SupportedFeatureProfiles.Smart_Charging}`);
574 }
575 this.addConfigurationKey(StandardParametersKey.NumberOfConnectors, this.getNumberOfConnectors().toString(), true);
576 if (!this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)) {
577 this.addConfigurationKey(StandardParametersKey.MeterValuesSampledData, MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER);
578 }
579 if (!this.getConfigurationKey(StandardParametersKey.ConnectorPhaseRotation)) {
580 const connectorPhaseRotation = [];
581 for (const connectorId of this.connectors.keys()) {
582 // AC/DC
583 if (connectorId === 0 && this.getNumberOfPhases() === 0) {
584 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
585 } else if (connectorId > 0 && this.getNumberOfPhases() === 0) {
586 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
587 // AC
588 } else if (connectorId > 0 && this.getNumberOfPhases() === 1) {
589 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
590 } else if (connectorId > 0 && this.getNumberOfPhases() === 3) {
591 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
592 }
593 }
594 this.addConfigurationKey(StandardParametersKey.ConnectorPhaseRotation, connectorPhaseRotation.toString());
595 }
596 if (!this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests)) {
597 this.addConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests, 'true');
598 }
599 if (!this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled)
600 && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
601 this.addConfigurationKey(StandardParametersKey.LocalAuthListEnabled, 'false');
602 }
603 if (!this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
604 this.addConfigurationKey(StandardParametersKey.ConnectionTimeOut, Constants.DEFAULT_CONNECTION_TIMEOUT.toString());
605 }
606 }
607
608 private async onOpen(): Promise<void> {
609 logger.info(`${this.logPrefix()} Connected to OCPP server through ${this.wsConnectionUrl.toString()}`);
610 if (!this.isRegistered()) {
611 // Send BootNotification
612 let registrationRetryCount = 0;
613 do {
614 this.bootNotificationResponse = await this.ocppRequestService.sendBootNotification(this.bootNotificationRequest.chargePointModel,
615 this.bootNotificationRequest.chargePointVendor, this.bootNotificationRequest.chargeBoxSerialNumber, this.bootNotificationRequest.firmwareVersion);
616 if (!this.isRegistered()) {
617 registrationRetryCount++;
618 await Utils.sleep(this.bootNotificationResponse?.interval ? this.bootNotificationResponse.interval * 1000 : Constants.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL);
619 }
620 } while (!this.isRegistered() && (registrationRetryCount <= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
621 }
622 if (this.isRegistered()) {
623 await this.startMessageSequence();
624 this.stopped && (this.stopped = false);
625 if (this.wsConnectionRestarted && this.isWebSocketConnectionOpened()) {
626 this.flushMessageQueue();
627 }
628 } else {
629 logger.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
630 }
631 this.autoReconnectRetryCount = 0;
632 this.wsConnectionRestarted = false;
633 }
634
635 private async onClose(code: number, reason: string): Promise<void> {
636 switch (code) {
637 // Normal close
638 case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
639 case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
640 logger.info(`${this.logPrefix()} WebSocket normally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
641 this.autoReconnectRetryCount = 0;
642 break;
643 // Abnormal close
644 default:
645 logger.error(`${this.logPrefix()} WebSocket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
646 await this.reconnect(code);
647 break;
648 }
649 }
650
651 private async onMessage(data: Data): Promise<void> {
652 let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, {}, {}];
653 let responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => void;
654 let rejectCallback: (error: OCPPError) => void;
655 let requestCommandName: RequestCommand | IncomingRequestCommand;
656 let requestPayload: Record<string, unknown>;
657 let cachedRequest: CachedRequest;
658 let errMsg: string;
659 try {
660 const request = JSON.parse(data.toString()) as IncomingRequest;
661 if (Utils.isIterable(request)) {
662 // Parse the message
663 [messageType, messageId, commandName, commandPayload, errorDetails] = request;
664 } else {
665 throw new OCPPError(ErrorType.PROTOCOL_ERROR, 'Incoming request is not iterable', commandName);
666 }
667 // Check the Type of message
668 switch (messageType) {
669 // Incoming Message
670 case MessageType.CALL_MESSAGE:
671 if (this.getEnableStatistics()) {
672 this.performanceStatistics.addRequestStatistic(commandName, messageType);
673 }
674 // Process the call
675 await this.ocppIncomingRequestService.handleRequest(messageId, commandName, commandPayload);
676 break;
677 // Outcome Message
678 case MessageType.CALL_RESULT_MESSAGE:
679 // Respond
680 cachedRequest = this.requests.get(messageId);
681 if (Utils.isIterable(cachedRequest)) {
682 [responseCallback, , , requestPayload] = cachedRequest;
683 } else {
684 throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} response is not iterable`, commandName);
685 }
686 if (!responseCallback) {
687 // Error
688 throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response for unknown message id ${messageId}`, commandName);
689 }
690 responseCallback(commandName, requestPayload);
691 break;
692 // Error Message
693 case MessageType.CALL_ERROR_MESSAGE:
694 cachedRequest = this.requests.get(messageId);
695 if (Utils.isIterable(cachedRequest)) {
696 [, rejectCallback, requestCommandName] = cachedRequest;
697 } else {
698 throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} error response is not iterable`);
699 }
700 if (!rejectCallback) {
701 // Error
702 throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error response for unknown message id ${messageId}`, requestCommandName);
703 }
704 rejectCallback(new OCPPError(commandName, commandPayload.toString(), requestCommandName, errorDetails));
705 break;
706 // Error
707 default:
708 errMsg = `${this.logPrefix()} Wrong message type ${messageType}`;
709 logger.error(errMsg);
710 throw new OCPPError(ErrorType.PROTOCOL_ERROR, errMsg);
711 }
712 } catch (error) {
713 // Log
714 logger.error('%s Incoming OCPP message %j matching cached request %j processing error %j', this.logPrefix(), data, this.requests.get(messageId), error);
715 // Send error
716 messageType === MessageType.CALL_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
717 }
718 }
719
720 private onPing(): void {
721 logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
722 }
723
724 private onPong(): void {
725 logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
726 }
727
728 private async onError(error: WSError): Promise<void> {
729 logger.error(this.logPrefix() + ' WebSocket error: %j', error);
730 // switch (error.code) {
731 // case 'ECONNREFUSED':
732 // await this.reconnect(error);
733 // break;
734 // }
735 }
736
737 private getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
738 return this.stationInfo.Configuration ?? {} as ChargingStationConfiguration;
739 }
740
741 private getAuthorizationFile(): string | undefined {
742 return this.stationInfo.authorizationFile && path.join(path.resolve(__dirname, '../'), 'assets', path.basename(this.stationInfo.authorizationFile));
743 }
744
745 private getAuthorizedTags(): string[] {
746 let authorizedTags: string[] = [];
747 const authorizationFile = this.getAuthorizationFile();
748 if (authorizationFile) {
749 try {
750 // Load authorization file
751 const fileDescriptor = fs.openSync(authorizationFile, 'r');
752 authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as string[];
753 fs.closeSync(fileDescriptor);
754 } catch (error) {
755 FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
756 }
757 } else {
758 logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile);
759 }
760 return authorizedTags;
761 }
762
763 private getUseConnectorId0(): boolean | undefined {
764 return !Utils.isUndefined(this.stationInfo.useConnectorId0) ? this.stationInfo.useConnectorId0 : true;
765 }
766
767 private getNumberOfRunningTransactions(): number {
768 let trxCount = 0;
769 for (const connectorId of this.connectors.keys()) {
770 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
771 trxCount++;
772 }
773 }
774 return trxCount;
775 }
776
777 // 0 for disabling
778 private getConnectionTimeout(): number | undefined {
779 if (this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
780 return parseInt(this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut).value) ?? Constants.DEFAULT_CONNECTION_TIMEOUT;
781 }
782 return Constants.DEFAULT_CONNECTION_TIMEOUT;
783 }
784
785 // -1 for unlimited, 0 for disabling
786 private getAutoReconnectMaxRetries(): number | undefined {
787 if (!Utils.isUndefined(this.stationInfo.autoReconnectMaxRetries)) {
788 return this.stationInfo.autoReconnectMaxRetries;
789 }
790 if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
791 return Configuration.getAutoReconnectMaxRetries();
792 }
793 return -1;
794 }
795
796 // 0 for disabling
797 private getRegistrationMaxRetries(): number | undefined {
798 if (!Utils.isUndefined(this.stationInfo.registrationMaxRetries)) {
799 return this.stationInfo.registrationMaxRetries;
800 }
801 return -1;
802 }
803
804 private getPowerDivider(): number {
805 let powerDivider = this.getNumberOfConnectors();
806 if (this.stationInfo.powerSharedByConnectors) {
807 powerDivider = this.getNumberOfRunningTransactions();
808 }
809 return powerDivider;
810 }
811
812 private getTemplateMaxNumberOfConnectors(): number {
813 return Object.keys(this.stationInfo.Connectors).length;
814 }
815
816 private getMaxNumberOfConnectors(): number {
817 let maxConnectors = 0;
818 if (!Utils.isEmptyArray(this.stationInfo.numberOfConnectors)) {
819 const numberOfConnectors = this.stationInfo.numberOfConnectors as number[];
820 // Distribute evenly the number of connectors
821 maxConnectors = numberOfConnectors[(this.index - 1) % numberOfConnectors.length];
822 } else if (!Utils.isUndefined(this.stationInfo.numberOfConnectors)) {
823 maxConnectors = this.stationInfo.numberOfConnectors as number;
824 } else {
825 maxConnectors = this.stationInfo.Connectors[0] ? this.getTemplateMaxNumberOfConnectors() - 1 : this.getTemplateMaxNumberOfConnectors();
826 }
827 return maxConnectors;
828 }
829
830 private getNumberOfConnectors(): number {
831 return this.connectors.get(0) ? this.connectors.size - 1 : this.connectors.size;
832 }
833
834 private async startMessageSequence(): Promise<void> {
835 // Start WebSocket ping
836 this.startWebSocketPing();
837 // Start heartbeat
838 this.startHeartbeat();
839 // Initialize connectors status
840 for (const connectorId of this.connectors.keys()) {
841 if (connectorId === 0) {
842 continue;
843 } else if (!this.stopped && !this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
844 // Send status in template at startup
845 await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
846 this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
847 } else if (this.stopped && this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
848 // Send status in template after reset
849 await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
850 this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
851 } else if (!this.stopped && this.getConnectorStatus(connectorId)?.status) {
852 // Send previous status at template reload
853 await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).status);
854 } else {
855 // Send default status
856 await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.AVAILABLE);
857 this.getConnectorStatus(connectorId).status = ChargePointStatus.AVAILABLE;
858 }
859 }
860 // Start the ATG
861 this.startAutomaticTransactionGenerator();
862 }
863
864 private startAutomaticTransactionGenerator() {
865 if (this.stationInfo.AutomaticTransactionGenerator.enable) {
866 if (!this.automaticTransactionGenerator) {
867 this.automaticTransactionGenerator = new AutomaticTransactionGenerator(this);
868 }
869 if (!this.automaticTransactionGenerator.started) {
870 this.automaticTransactionGenerator.start();
871 }
872 }
873 }
874
875 private async stopMessageSequence(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
876 // Stop WebSocket ping
877 this.stopWebSocketPing();
878 // Stop heartbeat
879 this.stopHeartbeat();
880 // Stop the ATG
881 if (this.stationInfo.AutomaticTransactionGenerator.enable &&
882 this.automaticTransactionGenerator &&
883 this.automaticTransactionGenerator.started) {
884 this.automaticTransactionGenerator.stop();
885 } else {
886 for (const connectorId of this.connectors.keys()) {
887 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
888 const transactionId = this.getConnectorStatus(connectorId).transactionId;
889 await this.ocppRequestService.sendStopTransaction(transactionId, this.getEnergyActiveImportRegisterByTransactionId(transactionId),
890 this.getTransactionIdTag(transactionId), reason);
891 }
892 }
893 }
894 }
895
896 private startWebSocketPing(): void {
897 const webSocketPingInterval: number = this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval)
898 ? Utils.convertToInt(this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval).value)
899 : 0;
900 if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
901 this.webSocketPingSetInterval = setInterval(() => {
902 if (this.isWebSocketConnectionOpened()) {
903 this.wsConnection.ping((): void => { /* This is intentional */ });
904 }
905 }, webSocketPingInterval * 1000);
906 logger.info(this.logPrefix() + ' WebSocket ping started every ' + Utils.formatDurationSeconds(webSocketPingInterval));
907 } else if (this.webSocketPingSetInterval) {
908 logger.info(this.logPrefix() + ' WebSocket ping every ' + Utils.formatDurationSeconds(webSocketPingInterval) + ' already started');
909 } else {
910 logger.error(`${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.formatDurationSeconds(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
911 }
912 }
913
914 private stopWebSocketPing(): void {
915 if (this.webSocketPingSetInterval) {
916 clearInterval(this.webSocketPingSetInterval);
917 }
918 }
919
920 private getSupervisionURL(): URL {
921 const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionURL ? this.stationInfo.supervisionURL : Configuration.getSupervisionURLs());
922 let indexUrl = 0;
923 if (!Utils.isEmptyArray(supervisionUrls)) {
924 if (Configuration.getDistributeStationsToTenantsEqually()) {
925 indexUrl = this.index % supervisionUrls.length;
926 } else {
927 // Get a random url
928 indexUrl = Math.floor(Utils.secureRandom() * supervisionUrls.length);
929 }
930 return new URL(supervisionUrls[indexUrl]);
931 }
932 return new URL(supervisionUrls as string);
933 }
934
935 private getHeartbeatInterval(): number | undefined {
936 const HeartbeatInterval = this.getConfigurationKey(StandardParametersKey.HeartbeatInterval);
937 if (HeartbeatInterval) {
938 return Utils.convertToInt(HeartbeatInterval.value) * 1000;
939 }
940 const HeartBeatInterval = this.getConfigurationKey(StandardParametersKey.HeartBeatInterval);
941 if (HeartBeatInterval) {
942 return Utils.convertToInt(HeartBeatInterval.value) * 1000;
943 }
944 !this.stationInfo.autoRegister && logger.warn(`${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${Constants.DEFAULT_HEARTBEAT_INTERVAL}`);
945 return Constants.DEFAULT_HEARTBEAT_INTERVAL;
946 }
947
948 private stopHeartbeat(): void {
949 if (this.heartbeatSetInterval) {
950 clearInterval(this.heartbeatSetInterval);
951 }
952 }
953
954 private openWSConnection(options?: ClientOptions & ClientRequestArgs, forceCloseOpened = false): void {
955 options = options ?? {};
956 options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
957 if (!Utils.isNullOrUndefined(this.stationInfo.supervisionUser) && !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)) {
958 options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
959 }
960 if (this.isWebSocketConnectionOpened() && forceCloseOpened) {
961 this.wsConnection.close();
962 }
963 let protocol;
964 switch (this.getOCPPVersion()) {
965 case OCPPVersion.VERSION_16:
966 protocol = 'ocpp' + OCPPVersion.VERSION_16;
967 break;
968 default:
969 this.handleUnsupportedVersion(this.getOCPPVersion());
970 break;
971 }
972 this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
973 logger.info(this.logPrefix() + ' Open OCPP connection to URL ' + this.wsConnectionUrl.toString());
974 }
975
976 private stopMeterValues(connectorId: number) {
977 if (this.getConnectorStatus(connectorId)?.transactionSetInterval) {
978 clearInterval(this.getConnectorStatus(connectorId).transactionSetInterval);
979 }
980 }
981
982 private startAuthorizationFileMonitoring(): void {
983 const authorizationFile = this.getAuthorizationFile();
984 if (authorizationFile) {
985 try {
986 fs.watch(authorizationFile, (event, filename) => {
987 if (filename && event === 'change') {
988 try {
989 logger.debug(this.logPrefix() + ' Authorization file ' + authorizationFile + ' have changed, reload');
990 // Initialize authorizedTags
991 this.authorizedTags = this.getAuthorizedTags();
992 } catch (error) {
993 logger.error(this.logPrefix() + ' Authorization file monitoring error: %j', error);
994 }
995 }
996 });
997 } catch (error) {
998 FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
999 }
1000 } else {
1001 logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile + '. Not monitoring changes');
1002 }
1003 }
1004
1005 private startStationTemplateFileMonitoring(): void {
1006 try {
1007 fs.watch(this.stationTemplateFile, (event, filename): void => {
1008 if (filename && event === 'change') {
1009 try {
1010 logger.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile + ' have changed, reload');
1011 // Initialize
1012 this.initialize();
1013 // Restart the ATG
1014 if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
1015 this.automaticTransactionGenerator) {
1016 this.automaticTransactionGenerator.stop();
1017 }
1018 this.startAutomaticTransactionGenerator();
1019 if (this.getEnableStatistics()) {
1020 this.performanceStatistics.restart();
1021 } else {
1022 this.performanceStatistics.stop();
1023 }
1024 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
1025 } catch (error) {
1026 logger.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error);
1027 }
1028 }
1029 });
1030 } catch (error) {
1031 FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
1032 }
1033 }
1034
1035 private getReconnectExponentialDelay(): boolean | undefined {
1036 return !Utils.isUndefined(this.stationInfo.reconnectExponentialDelay) ? this.stationInfo.reconnectExponentialDelay : false;
1037 }
1038
1039 private async reconnect(code: number): Promise<void> {
1040 // Stop WebSocket ping
1041 this.stopWebSocketPing();
1042 // Stop heartbeat
1043 this.stopHeartbeat();
1044 // Stop the ATG if needed
1045 if (this.stationInfo.AutomaticTransactionGenerator.enable &&
1046 this.stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
1047 this.automaticTransactionGenerator &&
1048 this.automaticTransactionGenerator.started) {
1049 this.automaticTransactionGenerator.stop();
1050 }
1051 if (this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
1052 this.autoReconnectRetryCount++;
1053 const reconnectDelay = (this.getReconnectExponentialDelay() ? Utils.exponentialDelay(this.autoReconnectRetryCount) : this.getConnectionTimeout() * 1000);
1054 const reconnectTimeout = reconnectDelay - 100;
1055 logger.error(`${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectTimeout}ms`);
1056 await Utils.sleep(reconnectDelay);
1057 logger.error(this.logPrefix() + ' WebSocket: reconnecting try #' + this.autoReconnectRetryCount.toString());
1058 this.openWSConnection({ handshakeTimeout: reconnectTimeout }, true);
1059 this.wsConnectionRestarted = true;
1060 } else if (this.getAutoReconnectMaxRetries() !== -1) {
1061 logger.error(`${this.logPrefix()} WebSocket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
1062 }
1063 }
1064
1065 private initTransactionAttributesOnConnector(connectorId: number): void {
1066 this.getConnectorStatus(connectorId).authorized = false;
1067 this.getConnectorStatus(connectorId).transactionStarted = false;
1068 this.getConnectorStatus(connectorId).energyActiveImportRegisterValue = 0;
1069 this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
1070 }
1071 }
1072