Make the build app self contained.
[e-mobility-charging-stations-simulator.git] / src / charging-station / ChargingStation.ts
1 import { BootNotificationResponse, RegistrationStatus } from '../types/ocpp/Responses';
2 import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
3 import ChargingStationTemplate, { PowerOutType, VoltageOut } from '../types/ChargingStationTemplate';
4 import Connectors, { Connector } from '../types/Connectors';
5 import { PerformanceObserver, performance } from 'perf_hooks';
6 import Requests, { AvailabilityType, BootNotificationRequest, IncomingRequest, IncomingRequestCommand } from '../types/ocpp/Requests';
7 import WebSocket, { MessageEvent } from 'ws';
8
9 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
10 import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
11 import { ChargingProfile } from '../types/ocpp/ChargingProfile';
12 import ChargingStationInfo from '../types/ChargingStationInfo';
13 import Configuration from '../utils/Configuration';
14 import Constants from '../utils/Constants';
15 import { MessageType } from '../types/ocpp/MessageType';
16 import { MeterValueMeasurand } from '../types/ocpp/MeterValues';
17 import OCPP16IncomingRequestService from './ocpp/1.6/OCCP16IncomingRequestService';
18 import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
19 import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
20 import OCPPError from './OcppError';
21 import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
22 import OCPPRequestService from './ocpp/OCPPRequestService';
23 import { OCPPVersion } from '../types/ocpp/OCPPVersion';
24 import { StandardParametersKey } from '../types/ocpp/Configuration';
25 import Statistics from '../utils/Statistics';
26 import { StopTransactionReason } from '../types/ocpp/Transaction';
27 import Utils from '../utils/Utils';
28 import { WebSocketCloseEventStatusCode } from '../types/WebSocket';
29 import crypto from 'crypto';
30 import fs from 'fs';
31 import logger from '../utils/Logger';
32 import path from 'path';
33
34 export default class ChargingStation {
35 public stationTemplateFile: string;
36 public authorizedTags: string[];
37 public stationInfo: ChargingStationInfo;
38 public connectors: Connectors;
39 public configuration: ChargingStationConfiguration;
40 public hasStopped: boolean;
41 public wsConnection: WebSocket;
42 public requests: Requests;
43 public messageQueue: string[];
44 public statistics: Statistics;
45 public heartbeatSetInterval: NodeJS.Timeout;
46 public ocppIncomingRequestService: OCPPIncomingRequestService;
47 public ocppRequestService: OCPPRequestService;
48 private index: number;
49 private bootNotificationRequest: BootNotificationRequest;
50 private bootNotificationResponse: BootNotificationResponse;
51 private connectorsConfigurationHash: string;
52 private supervisionUrl: string;
53 private wsConnectionUrl: string;
54 private hasSocketRestarted: boolean;
55 private autoReconnectRetryCount: number;
56 private automaticTransactionGeneration: AutomaticTransactionGenerator;
57 private performanceObserver: PerformanceObserver;
58 private webSocketPingSetInterval: NodeJS.Timeout;
59
60 constructor(index: number, stationTemplateFile: string) {
61 this.index = index;
62 this.stationTemplateFile = stationTemplateFile;
63 this.connectors = {} as Connectors;
64 this.initialize();
65
66 this.hasStopped = false;
67 this.hasSocketRestarted = false;
68 this.autoReconnectRetryCount = 0;
69
70 this.requests = {} as Requests;
71 this.messageQueue = [] as string[];
72
73 this.authorizedTags = this.getAuthorizedTags();
74 }
75
76 public logPrefix(): string {
77 return Utils.logPrefix(` ${this.stationInfo.chargingStationId}:`);
78 }
79
80 public getRandomTagId(): string {
81 const index = Math.floor(Math.random() * this.authorizedTags.length);
82 return this.authorizedTags[index];
83 }
84
85 public hasAuthorizedTags(): boolean {
86 return !Utils.isEmptyArray(this.authorizedTags);
87 }
88
89 public getEnableStatistics(): boolean {
90 return !Utils.isUndefined(this.stationInfo.enableStatistics) ? this.stationInfo.enableStatistics : true;
91 }
92
93 public getNumberOfPhases(): number {
94 switch (this.getPowerOutType()) {
95 case PowerOutType.AC:
96 return !Utils.isUndefined(this.stationInfo.numberOfPhases) ? this.stationInfo.numberOfPhases : 3;
97 case PowerOutType.DC:
98 return 0;
99 }
100 }
101
102 public isWebSocketOpen(): boolean {
103 return this.wsConnection?.readyState === WebSocket.OPEN;
104 }
105
106 public isRegistered(): boolean {
107 return this.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
108 }
109
110 public isChargingStationAvailable(): boolean {
111 return this.getConnector(0).availability === AvailabilityType.OPERATIVE;
112 }
113
114 public isConnectorAvailable(id: number): boolean {
115 return this.getConnector(id).availability === AvailabilityType.OPERATIVE;
116 }
117
118 public getConnector(id: number): Connector {
119 return this.connectors[id];
120 }
121
122 public getPowerOutType(): PowerOutType {
123 return !Utils.isUndefined(this.stationInfo.powerOutType) ? this.stationInfo.powerOutType : PowerOutType.AC;
124 }
125
126 public getVoltageOut(): number {
127 const errMsg = `${this.logPrefix()} Unknown ${this.getPowerOutType()} powerOutType in template file ${this.stationTemplateFile}, cannot define default voltage out`;
128 let defaultVoltageOut: number;
129 switch (this.getPowerOutType()) {
130 case PowerOutType.AC:
131 defaultVoltageOut = VoltageOut.VOLTAGE_230;
132 break;
133 case PowerOutType.DC:
134 defaultVoltageOut = VoltageOut.VOLTAGE_400;
135 break;
136 default:
137 logger.error(errMsg);
138 throw Error(errMsg);
139 }
140 return !Utils.isUndefined(this.stationInfo.voltageOut) ? this.stationInfo.voltageOut : defaultVoltageOut;
141 }
142
143 public getTransactionIdTag(transactionId: number): string {
144 for (const connector in this.connectors) {
145 if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
146 return this.getConnector(Utils.convertToInt(connector)).idTag;
147 }
148 }
149 }
150
151 public getTransactionMeterStop(transactionId: number): number {
152 for (const connector in this.connectors) {
153 if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
154 return this.getConnector(Utils.convertToInt(connector)).lastEnergyActiveImportRegisterValue;
155 }
156 }
157 }
158
159 public getAuthorizeRemoteTxRequests(): boolean {
160 const authorizeRemoteTxRequests = this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests);
161 return authorizeRemoteTxRequests ? Utils.convertToBoolean(authorizeRemoteTxRequests.value) : false;
162 }
163
164 public getLocalAuthListEnabled(): boolean {
165 const localAuthListEnabled = this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled);
166 return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
167 }
168
169 public restartWebSocketPing(): void {
170 // Stop WebSocket ping
171 this.stopWebSocketPing();
172 // Start WebSocket ping
173 this.startWebSocketPing();
174 }
175
176 public startHeartbeat(): void {
177 if (this.getHeartbeatInterval() && this.getHeartbeatInterval() > 0 && !this.heartbeatSetInterval) {
178 // eslint-disable-next-line @typescript-eslint/no-misused-promises
179 this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
180 await this.ocppRequestService.sendHeartbeat();
181 }, this.getHeartbeatInterval());
182 logger.info(this.logPrefix() + ' Heartbeat started every ' + Utils.milliSecondsToHHMMSS(this.getHeartbeatInterval()));
183 } else if (this.heartbeatSetInterval) {
184 logger.info(this.logPrefix() + ' Heartbeat every ' + Utils.milliSecondsToHHMMSS(this.getHeartbeatInterval()) + ' already started');
185 } else {
186 logger.error(`${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval() ? Utils.milliSecondsToHHMMSS(this.getHeartbeatInterval()) : this.getHeartbeatInterval()}, not starting the heartbeat`);
187 }
188 }
189
190 public restartHeartbeat(): void {
191 // Stop heartbeat
192 this.stopHeartbeat();
193 // Start heartbeat
194 this.startHeartbeat();
195 }
196
197 public startMeterValues(connectorId: number, interval: number): void {
198 if (connectorId === 0) {
199 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
200 return;
201 }
202 if (!this.getConnector(connectorId)) {
203 logger.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
204 return;
205 }
206 if (!this.getConnector(connectorId)?.transactionStarted) {
207 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
208 return;
209 } else if (this.getConnector(connectorId)?.transactionStarted && !this.getConnector(connectorId)?.transactionId) {
210 logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
211 return;
212 }
213 if (interval > 0) {
214 // eslint-disable-next-line @typescript-eslint/no-misused-promises
215 this.getConnector(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
216 if (this.getEnableStatistics()) {
217 const sendMeterValues = performance.timerify(this.ocppRequestService.sendMeterValues);
218 this.performanceObserver.observe({
219 entryTypes: ['function'],
220 });
221 await sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval, this.ocppRequestService);
222 } else {
223 await this.ocppRequestService.sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval, this.ocppRequestService);
224 }
225 }, interval);
226 } else {
227 logger.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.milliSecondsToHHMMSS(interval) : interval}, not sending MeterValues`);
228 }
229 }
230
231 public start(): void {
232 this.openWSConnection();
233 // Monitor authorization file
234 this.startAuthorizationFileMonitoring();
235 // Monitor station template file
236 this.startStationTemplateFileMonitoring();
237 // Handle Socket incoming messages
238 this.wsConnection.on('message', this.onMessage.bind(this));
239 // Handle Socket error
240 this.wsConnection.on('error', this.onError.bind(this));
241 // Handle Socket close
242 this.wsConnection.on('close', this.onClose.bind(this));
243 // Handle Socket opening connection
244 this.wsConnection.on('open', this.onOpen.bind(this));
245 // Handle Socket ping
246 this.wsConnection.on('ping', this.onPing.bind(this));
247 // Handle Socket pong
248 this.wsConnection.on('pong', this.onPong.bind(this));
249 }
250
251 public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
252 // Stop message sequence
253 await this.stopMessageSequence(reason);
254 for (const connector in this.connectors) {
255 if (Utils.convertToInt(connector) > 0) {
256 await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.UNAVAILABLE);
257 this.getConnector(Utils.convertToInt(connector)).status = ChargePointStatus.UNAVAILABLE;
258 }
259 }
260 if (this.isWebSocketOpen()) {
261 this.wsConnection.close();
262 }
263 this.bootNotificationResponse = null;
264 this.hasStopped = true;
265 }
266
267 public getConfigurationKey(key: string | StandardParametersKey, caseInsensitive = false): ConfigurationKey {
268 const configurationKey: ConfigurationKey = this.configuration.configurationKey.find((configElement) => {
269 if (caseInsensitive) {
270 return configElement.key.toLowerCase() === key.toLowerCase();
271 }
272 return configElement.key === key;
273 });
274 return configurationKey;
275 }
276
277 public addConfigurationKey(key: string | StandardParametersKey, value: string, readonly = false, visible = true, reboot = false): void {
278 const keyFound = this.getConfigurationKey(key);
279 if (!keyFound) {
280 this.configuration.configurationKey.push({
281 key,
282 readonly,
283 value,
284 visible,
285 reboot,
286 });
287 } else {
288 logger.error(`${this.logPrefix()} Trying to add an already existing configuration key: %j`, keyFound);
289 }
290 }
291
292 public setConfigurationKeyValue(key: string | StandardParametersKey, value: string): void {
293 const keyFound = this.getConfigurationKey(key);
294 if (keyFound) {
295 const keyIndex = this.configuration.configurationKey.indexOf(keyFound);
296 this.configuration.configurationKey[keyIndex].value = value;
297 } else {
298 logger.error(`${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key, value });
299 }
300 }
301
302 public setChargingProfile(connectorId: number, cp: ChargingProfile): boolean {
303 if (!Utils.isEmptyArray(this.getConnector(connectorId).chargingProfiles)) {
304 this.getConnector(connectorId).chargingProfiles.forEach((chargingProfile: ChargingProfile, index: number) => {
305 if (chargingProfile.chargingProfileId === cp.chargingProfileId
306 || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
307 this.getConnector(connectorId).chargingProfiles[index] = cp;
308 return true;
309 }
310 });
311 }
312 this.getConnector(connectorId).chargingProfiles.push(cp);
313 return true;
314 }
315
316 public resetTransactionOnConnector(connectorId: number): void {
317 this.initTransactionOnConnector(connectorId);
318 if (this.getConnector(connectorId)?.transactionSetInterval) {
319 clearInterval(this.getConnector(connectorId).transactionSetInterval);
320 }
321 }
322
323 public addToMessageQueue(message: string): void {
324 let dups = false;
325 // Handle dups in buffer
326 for (const bufferedMessage of this.messageQueue) {
327 // Same message
328 if (message === bufferedMessage) {
329 dups = true;
330 break;
331 }
332 }
333 if (!dups) {
334 // Buffer message
335 this.messageQueue.push(message);
336 }
337 }
338
339 private flushMessageQueue() {
340 if (!Utils.isEmptyArray(this.messageQueue)) {
341 this.messageQueue.forEach((message, index) => {
342 this.messageQueue.splice(index, 1);
343 this.wsConnection.send(message);
344 });
345 }
346 }
347
348 private getChargingStationId(stationTemplate: ChargingStationTemplate): string {
349 // In case of multiple instances: add instance index to charging station id
350 let instanceIndex = process.env.CF_INSTANCE_INDEX ? process.env.CF_INSTANCE_INDEX : 0;
351 instanceIndex = instanceIndex > 0 ? instanceIndex : '';
352 const idSuffix = stationTemplate.nameSuffix ? stationTemplate.nameSuffix : '';
353 return stationTemplate.fixedName ? stationTemplate.baseName : stationTemplate.baseName + '-' + instanceIndex.toString() + ('000000000' + this.index.toString()).substr(('000000000' + this.index.toString()).length - 4) + idSuffix;
354 }
355
356 private buildStationInfo(): ChargingStationInfo {
357 let stationTemplateFromFile: ChargingStationTemplate;
358 try {
359 // Load template file
360 const fileDescriptor = fs.openSync(this.stationTemplateFile, 'r');
361 stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as ChargingStationTemplate;
362 fs.closeSync(fileDescriptor);
363 } catch (error) {
364 logger.error('Template file ' + this.stationTemplateFile + ' loading error: %j', error);
365 throw error;
366 }
367 const stationInfo: ChargingStationInfo = stationTemplateFromFile || {} as ChargingStationInfo;
368 if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
369 stationTemplateFromFile.power = stationTemplateFromFile.power as number[];
370 stationInfo.maxPower = stationTemplateFromFile.power[Math.floor(Math.random() * stationTemplateFromFile.power.length)];
371 } else {
372 stationInfo.maxPower = stationTemplateFromFile.power as number;
373 }
374 stationInfo.chargingStationId = this.getChargingStationId(stationTemplateFromFile);
375 stationInfo.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
376 return stationInfo;
377 }
378
379 private getOCPPVersion(): OCPPVersion {
380 return this.stationInfo.ocppVersion ? this.stationInfo.ocppVersion : OCPPVersion.VERSION_16;
381 }
382
383 private handleUnsupportedVersion(version: OCPPVersion) {
384 const errMsg = `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${this.stationTemplateFile}`;
385 logger.error(errMsg);
386 throw new Error(errMsg);
387 }
388
389 private initialize(): void {
390 this.stationInfo = this.buildStationInfo();
391 this.bootNotificationRequest = {
392 chargePointModel: this.stationInfo.chargePointModel,
393 chargePointVendor: this.stationInfo.chargePointVendor,
394 ...!Utils.isUndefined(this.stationInfo.chargeBoxSerialNumberPrefix) && { chargeBoxSerialNumber: this.stationInfo.chargeBoxSerialNumberPrefix },
395 ...!Utils.isUndefined(this.stationInfo.firmwareVersion) && { firmwareVersion: this.stationInfo.firmwareVersion },
396 };
397 this.configuration = this.getTemplateChargingStationConfiguration();
398 this.supervisionUrl = this.getSupervisionURL();
399 this.wsConnectionUrl = this.supervisionUrl + '/' + this.stationInfo.chargingStationId;
400 // Build connectors if needed
401 const maxConnectors = this.getMaxNumberOfConnectors();
402 if (maxConnectors <= 0) {
403 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with ${maxConnectors} connectors`);
404 }
405 const templateMaxConnectors = this.getTemplateMaxNumberOfConnectors();
406 if (templateMaxConnectors <= 0) {
407 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector configuration`);
408 }
409 if (!this.stationInfo.Connectors[0]) {
410 logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector Id 0 configuration`);
411 }
412 // Sanity check
413 if (maxConnectors > (this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) && !this.stationInfo.randomConnectors) {
414 logger.warn(`${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this.stationTemplateFile}, forcing random connector configurations affectation`);
415 this.stationInfo.randomConnectors = true;
416 }
417 const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
418 // FIXME: Handle shrinking the number of connectors
419 if (!this.connectors || (this.connectors && this.connectorsConfigurationHash !== connectorsConfigHash)) {
420 this.connectorsConfigurationHash = connectorsConfigHash;
421 // Add connector Id 0
422 let lastConnector = '0';
423 for (lastConnector in this.stationInfo.Connectors) {
424 if (Utils.convertToInt(lastConnector) === 0 && this.getUseConnectorId0() && this.stationInfo.Connectors[lastConnector]) {
425 this.connectors[lastConnector] = Utils.cloneObject<Connector>(this.stationInfo.Connectors[lastConnector]);
426 this.connectors[lastConnector].availability = AvailabilityType.OPERATIVE;
427 if (Utils.isUndefined(this.connectors[lastConnector]?.chargingProfiles)) {
428 this.connectors[lastConnector].chargingProfiles = [];
429 }
430 }
431 }
432 // Generate all connectors
433 if ((this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
434 for (let index = 1; index <= maxConnectors; index++) {
435 const randConnectorID = this.stationInfo.randomConnectors ? Utils.getRandomInt(Utils.convertToInt(lastConnector), 1) : index;
436 this.connectors[index] = Utils.cloneObject<Connector>(this.stationInfo.Connectors[randConnectorID]);
437 this.connectors[index].availability = AvailabilityType.OPERATIVE;
438 if (Utils.isUndefined(this.connectors[lastConnector]?.chargingProfiles)) {
439 this.connectors[index].chargingProfiles = [];
440 }
441 }
442 }
443 }
444 // Avoid duplication of connectors related information
445 delete this.stationInfo.Connectors;
446 // Initialize transaction attributes on connectors
447 for (const connector in this.connectors) {
448 if (Utils.convertToInt(connector) > 0 && !this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
449 this.initTransactionOnConnector(Utils.convertToInt(connector));
450 }
451 }
452 switch (this.getOCPPVersion()) {
453 case OCPPVersion.VERSION_16:
454 this.ocppIncomingRequestService = new OCPP16IncomingRequestService(this);
455 this.ocppRequestService = new OCPP16RequestService(this, new OCPP16ResponseService(this));
456 break;
457 default:
458 this.handleUnsupportedVersion(this.getOCPPVersion());
459 break;
460 }
461 // OCPP parameters
462 this.addConfigurationKey(StandardParametersKey.NumberOfConnectors, this.getNumberOfConnectors().toString(), true);
463 if (!this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)) {
464 this.addConfigurationKey(StandardParametersKey.MeterValuesSampledData, MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER);
465 }
466 this.stationInfo.powerDivider = this.getPowerDivider();
467 if (this.getEnableStatistics()) {
468 this.statistics = new Statistics(this.stationInfo.chargingStationId);
469 this.performanceObserver = new PerformanceObserver((list) => {
470 const entry = list.getEntries()[0];
471 this.statistics.logPerformance(entry, Constants.ENTITY_CHARGING_STATION);
472 this.performanceObserver.disconnect();
473 });
474 }
475 }
476
477 private async onOpen(): Promise<void> {
478 logger.info(`${this.logPrefix()} Is connected to server through ${this.wsConnectionUrl}`);
479 if (!this.isRegistered()) {
480 // Send BootNotification
481 let registrationRetryCount = 0;
482 do {
483 this.bootNotificationResponse = await this.ocppRequestService.sendBootNotification(this.bootNotificationRequest.chargePointModel, this.bootNotificationRequest.chargePointVendor, this.bootNotificationRequest.chargeBoxSerialNumber, this.bootNotificationRequest.firmwareVersion);
484 if (!this.isRegistered()) {
485 registrationRetryCount++;
486 await Utils.sleep(this.bootNotificationResponse?.interval ? this.bootNotificationResponse.interval * 1000 : Constants.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL);
487 }
488 } while (!this.isRegistered() && (registrationRetryCount <= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
489 }
490 if (this.isRegistered()) {
491 await this.startMessageSequence();
492 this.hasStopped && (this.hasStopped = false);
493 if (this.hasSocketRestarted && this.isWebSocketOpen()) {
494 this.flushMessageQueue();
495 }
496 } else {
497 logger.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
498 }
499 this.autoReconnectRetryCount = 0;
500 this.hasSocketRestarted = false;
501 }
502
503 private async onClose(closeEvent): Promise<void> {
504 switch (closeEvent) {
505 case WebSocketCloseEventStatusCode.CLOSE_NORMAL: // Normal close
506 case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
507 logger.info(`${this.logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
508 this.autoReconnectRetryCount = 0;
509 break;
510 default: // Abnormal close
511 logger.error(`${this.logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
512 await this.reconnect(closeEvent);
513 break;
514 }
515 }
516
517 private async onMessage(messageEvent: MessageEvent): Promise<void> {
518 let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, {}, {}];
519 let responseCallback: (payload?: Record<string, unknown> | string, requestPayload?: Record<string, unknown>) => void;
520 let rejectCallback: (error: OCPPError) => void;
521 let requestPayload: Record<string, unknown>;
522 let errMsg: string;
523 try {
524 // Parse the message
525 [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString()) as IncomingRequest;
526
527 // Check the Type of message
528 switch (messageType) {
529 // Incoming Message
530 case MessageType.CALL_MESSAGE:
531 if (this.getEnableStatistics()) {
532 this.statistics.addMessage(commandName, messageType);
533 }
534 // Process the call
535 await this.ocppIncomingRequestService.handleRequest(messageId, commandName, commandPayload);
536 break;
537 // Outcome Message
538 case MessageType.CALL_RESULT_MESSAGE:
539 // Respond
540 if (Utils.isIterable(this.requests[messageId])) {
541 [responseCallback, , requestPayload] = this.requests[messageId];
542 } else {
543 throw new Error(`Response request for message id ${messageId} is not iterable`);
544 }
545 if (!responseCallback) {
546 // Error
547 throw new Error(`Response request for unknown message id ${messageId}`);
548 }
549 delete this.requests[messageId];
550 responseCallback(commandName, requestPayload);
551 break;
552 // Error Message
553 case MessageType.CALL_ERROR_MESSAGE:
554 if (!this.requests[messageId]) {
555 // Error
556 throw new Error(`Error request for unknown message id ${messageId}`);
557 }
558 if (Utils.isIterable(this.requests[messageId])) {
559 [, rejectCallback] = this.requests[messageId];
560 } else {
561 throw new Error(`Error request for message id ${messageId} is not iterable`);
562 }
563 delete this.requests[messageId];
564 rejectCallback(new OCPPError(commandName, commandPayload.toString(), errorDetails));
565 break;
566 // Error
567 default:
568 errMsg = `${this.logPrefix()} Wrong message type ${messageType}`;
569 logger.error(errMsg);
570 throw new Error(errMsg);
571 }
572 } catch (error) {
573 // Log
574 logger.error('%s Incoming message %j processing error %j on request content type %j', this.logPrefix(), messageEvent, error, this.requests[messageId]);
575 // Send error
576 messageType !== MessageType.CALL_ERROR_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
577 }
578 }
579
580 private onPing(): void {
581 logger.debug(this.logPrefix() + ' Has received a WS ping (rfc6455) from the server');
582 }
583
584 private onPong(): void {
585 logger.debug(this.logPrefix() + ' Has received a WS pong (rfc6455) from the server');
586 }
587
588 private async onError(errorEvent): Promise<void> {
589 logger.error(this.logPrefix() + ' Socket error: %j', errorEvent);
590 // pragma switch (errorEvent.code) {
591 // case 'ECONNREFUSED':
592 // await this._reconnect(errorEvent);
593 // break;
594 // }
595 }
596
597 private getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
598 return this.stationInfo.Configuration ? this.stationInfo.Configuration : {} as ChargingStationConfiguration;
599 }
600
601 private getAuthorizationFile(): string {
602 return this.stationInfo.authorizationFile && path.join(path.resolve(__dirname, '../'), 'assets', path.basename(this.stationInfo.authorizationFile));
603 }
604
605 private getAuthorizedTags(): string[] {
606 let authorizedTags: string[] = [];
607 const authorizationFile = this.getAuthorizationFile();
608 if (authorizationFile) {
609 try {
610 // Load authorization file
611 const fileDescriptor = fs.openSync(authorizationFile, 'r');
612 authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as string[];
613 fs.closeSync(fileDescriptor);
614 } catch (error) {
615 logger.error(this.logPrefix() + ' Authorization file ' + authorizationFile + ' loading error: %j', error);
616 throw error;
617 }
618 } else {
619 logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile);
620 }
621 return authorizedTags;
622 }
623
624 private getUseConnectorId0(): boolean {
625 return !Utils.isUndefined(this.stationInfo.useConnectorId0) ? this.stationInfo.useConnectorId0 : true;
626 }
627
628 private getNumberOfRunningTransactions(): number {
629 let trxCount = 0;
630 for (const connector in this.connectors) {
631 if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
632 trxCount++;
633 }
634 }
635 return trxCount;
636 }
637
638 // 0 for disabling
639 private getConnectionTimeout(): number {
640 if (!Utils.isUndefined(this.stationInfo.connectionTimeout)) {
641 return this.stationInfo.connectionTimeout;
642 }
643 if (!Utils.isUndefined(Configuration.getConnectionTimeout())) {
644 return Configuration.getConnectionTimeout();
645 }
646 return 30;
647 }
648
649 // -1 for unlimited, 0 for disabling
650 private getAutoReconnectMaxRetries(): number {
651 if (!Utils.isUndefined(this.stationInfo.autoReconnectMaxRetries)) {
652 return this.stationInfo.autoReconnectMaxRetries;
653 }
654 if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
655 return Configuration.getAutoReconnectMaxRetries();
656 }
657 return -1;
658 }
659
660 // 0 for disabling
661 private getRegistrationMaxRetries(): number {
662 if (!Utils.isUndefined(this.stationInfo.registrationMaxRetries)) {
663 return this.stationInfo.registrationMaxRetries;
664 }
665 return -1;
666 }
667
668 private getPowerDivider(): number {
669 let powerDivider = this.getNumberOfConnectors();
670 if (this.stationInfo.powerSharedByConnectors) {
671 powerDivider = this.getNumberOfRunningTransactions();
672 }
673 return powerDivider;
674 }
675
676 private getTemplateMaxNumberOfConnectors(): number {
677 return Object.keys(this.stationInfo.Connectors).length;
678 }
679
680 private getMaxNumberOfConnectors(): number {
681 let maxConnectors = 0;
682 if (!Utils.isEmptyArray(this.stationInfo.numberOfConnectors)) {
683 const numberOfConnectors = this.stationInfo.numberOfConnectors as number[];
684 // Distribute evenly the number of connectors
685 maxConnectors = numberOfConnectors[(this.index - 1) % numberOfConnectors.length];
686 } else if (!Utils.isUndefined(this.stationInfo.numberOfConnectors)) {
687 maxConnectors = this.stationInfo.numberOfConnectors as number;
688 } else {
689 maxConnectors = this.stationInfo.Connectors[0] ? this.getTemplateMaxNumberOfConnectors() - 1 : this.getTemplateMaxNumberOfConnectors();
690 }
691 return maxConnectors;
692 }
693
694 private getNumberOfConnectors(): number {
695 return this.connectors[0] ? Object.keys(this.connectors).length - 1 : Object.keys(this.connectors).length;
696 }
697
698 private async startMessageSequence(): Promise<void> {
699 // Start WebSocket ping
700 this.startWebSocketPing();
701 // Start heartbeat
702 this.startHeartbeat();
703 // Initialize connectors status
704 for (const connector in this.connectors) {
705 if (Utils.convertToInt(connector) === 0) {
706 continue;
707 } else if (!this.hasStopped && !this.getConnector(Utils.convertToInt(connector))?.status && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
708 // Send status in template at startup
709 await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
710 this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
711 } else if (this.hasStopped && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
712 // Send status in template after reset
713 await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
714 this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
715 } else if (!this.hasStopped && this.getConnector(Utils.convertToInt(connector))?.status) {
716 // Send previous status at template reload
717 await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).status);
718 } else {
719 // Send default status
720 await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.AVAILABLE);
721 this.getConnector(Utils.convertToInt(connector)).status = ChargePointStatus.AVAILABLE;
722 }
723 }
724 // Start the ATG
725 if (this.stationInfo.AutomaticTransactionGenerator.enable) {
726 if (!this.automaticTransactionGeneration) {
727 this.automaticTransactionGeneration = new AutomaticTransactionGenerator(this);
728 }
729 if (this.automaticTransactionGeneration.timeToStop) {
730 await this.automaticTransactionGeneration.start();
731 }
732 }
733 if (this.getEnableStatistics()) {
734 this.statistics.start();
735 }
736 }
737
738 private async stopMessageSequence(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
739 // Stop WebSocket ping
740 this.stopWebSocketPing();
741 // Stop heartbeat
742 this.stopHeartbeat();
743 // Stop the ATG
744 if (this.stationInfo.AutomaticTransactionGenerator.enable &&
745 this.automaticTransactionGeneration &&
746 !this.automaticTransactionGeneration.timeToStop) {
747 await this.automaticTransactionGeneration.stop(reason);
748 } else {
749 for (const connector in this.connectors) {
750 if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
751 const transactionId = this.getConnector(Utils.convertToInt(connector)).transactionId;
752 await this.ocppRequestService.sendStopTransaction(transactionId, this.getTransactionMeterStop(transactionId), this.getTransactionIdTag(transactionId), reason);
753 }
754 }
755 }
756 }
757
758 private startWebSocketPing(): void {
759 const webSocketPingInterval: number = this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval) ? Utils.convertToInt(this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval).value) : 0;
760 if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
761 this.webSocketPingSetInterval = setInterval(() => {
762 if (this.isWebSocketOpen()) {
763 this.wsConnection.ping((): void => { });
764 }
765 }, webSocketPingInterval * 1000);
766 logger.info(this.logPrefix() + ' WebSocket ping started every ' + Utils.secondsToHHMMSS(webSocketPingInterval));
767 } else if (this.webSocketPingSetInterval) {
768 logger.info(this.logPrefix() + ' WebSocket ping every ' + Utils.secondsToHHMMSS(webSocketPingInterval) + ' already started');
769 } else {
770 logger.error(`${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.secondsToHHMMSS(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
771 }
772 }
773
774 private stopWebSocketPing(): void {
775 if (this.webSocketPingSetInterval) {
776 clearInterval(this.webSocketPingSetInterval);
777 this.webSocketPingSetInterval = null;
778 }
779 }
780
781 private getSupervisionURL(): string {
782 const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionURL ? this.stationInfo.supervisionURL : Configuration.getSupervisionURLs());
783 let indexUrl = 0;
784 if (!Utils.isEmptyArray(supervisionUrls)) {
785 if (Configuration.getDistributeStationsToTenantsEqually()) {
786 indexUrl = this.index % supervisionUrls.length;
787 } else {
788 // Get a random url
789 indexUrl = Math.floor(Math.random() * supervisionUrls.length);
790 }
791 return supervisionUrls[indexUrl];
792 }
793 return supervisionUrls as string;
794 }
795
796 private getHeartbeatInterval(): number {
797 const HeartbeatInterval = this.getConfigurationKey(StandardParametersKey.HeartbeatInterval);
798 if (HeartbeatInterval) {
799 return Utils.convertToInt(HeartbeatInterval.value) * 1000;
800 }
801 const HeartBeatInterval = this.getConfigurationKey(StandardParametersKey.HeartBeatInterval);
802 if (HeartBeatInterval) {
803 return Utils.convertToInt(HeartBeatInterval.value) * 1000;
804 }
805 }
806
807 private stopHeartbeat(): void {
808 if (this.heartbeatSetInterval) {
809 clearInterval(this.heartbeatSetInterval);
810 this.heartbeatSetInterval = null;
811 }
812 }
813
814 private openWSConnection(options?: WebSocket.ClientOptions, forceCloseOpened = false): void {
815 if (Utils.isUndefined(options)) {
816 options = {} as WebSocket.ClientOptions;
817 }
818 if (Utils.isUndefined(options.handshakeTimeout)) {
819 options.handshakeTimeout = this.getConnectionTimeout() * 1000;
820 }
821 if (this.isWebSocketOpen() && forceCloseOpened) {
822 this.wsConnection.close();
823 }
824 let protocol;
825 switch (this.getOCPPVersion()) {
826 case OCPPVersion.VERSION_16:
827 protocol = 'ocpp' + OCPPVersion.VERSION_16;
828 break;
829 default:
830 this.handleUnsupportedVersion(this.getOCPPVersion());
831 break;
832 }
833 this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
834 logger.info(this.logPrefix() + ' Will communicate through URL ' + this.supervisionUrl);
835 }
836
837 private startAuthorizationFileMonitoring(): void {
838 fs.watch(this.getAuthorizationFile()).on('change', (e) => {
839 try {
840 logger.debug(this.logPrefix() + ' Authorization file ' + this.getAuthorizationFile() + ' have changed, reload');
841 // Initialize authorizedTags
842 this.authorizedTags = this.getAuthorizedTags();
843 } catch (error) {
844 logger.error(this.logPrefix() + ' Authorization file monitoring error: %j', error);
845 }
846 });
847 }
848
849 private startStationTemplateFileMonitoring(): void {
850 // eslint-disable-next-line @typescript-eslint/no-misused-promises
851 fs.watch(this.stationTemplateFile).on('change', async (e): Promise<void> => {
852 try {
853 logger.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile + ' have changed, reload');
854 // Initialize
855 this.initialize();
856 // Stop the ATG
857 if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
858 this.automaticTransactionGeneration) {
859 await this.automaticTransactionGeneration.stop();
860 }
861 // Start the ATG
862 if (this.stationInfo.AutomaticTransactionGenerator.enable) {
863 if (!this.automaticTransactionGeneration) {
864 this.automaticTransactionGeneration = new AutomaticTransactionGenerator(this);
865 }
866 if (this.automaticTransactionGeneration.timeToStop) {
867 await this.automaticTransactionGeneration.start();
868 }
869 }
870 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
871 } catch (error) {
872 logger.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error);
873 }
874 });
875 }
876
877 private getReconnectExponentialDelay(): boolean {
878 return !Utils.isUndefined(this.stationInfo.reconnectExponentialDelay) ? this.stationInfo.reconnectExponentialDelay : false;
879 }
880
881 private async reconnect(error): Promise<void> {
882 // Stop heartbeat
883 this.stopHeartbeat();
884 // Stop the ATG if needed
885 if (this.stationInfo.AutomaticTransactionGenerator.enable &&
886 this.stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
887 this.automaticTransactionGeneration &&
888 !this.automaticTransactionGeneration.timeToStop) {
889 this.automaticTransactionGeneration.stop().catch(() => { });
890 }
891 if (this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
892 this.autoReconnectRetryCount++;
893 const reconnectDelay = (this.getReconnectExponentialDelay() ? Utils.exponentialDelay(this.autoReconnectRetryCount) : this.getConnectionTimeout() * 1000);
894 logger.error(`${this.logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
895 await Utils.sleep(reconnectDelay);
896 logger.error(this.logPrefix() + ' Socket: reconnecting try #' + this.autoReconnectRetryCount.toString());
897 this.openWSConnection({ handshakeTimeout: reconnectDelay - 100 });
898 this.hasSocketRestarted = true;
899 } else if (this.getAutoReconnectMaxRetries() !== -1) {
900 logger.error(`${this.logPrefix()} Socket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
901 }
902 }
903
904 private initTransactionOnConnector(connectorId: number): void {
905 this.getConnector(connectorId).transactionStarted = false;
906 this.getConnector(connectorId).transactionId = null;
907 this.getConnector(connectorId).idTag = null;
908 this.getConnector(connectorId).lastEnergyActiveImportRegisterValue = -1;
909 }
910 }
911