src/charging-station/ocpp/OCPPRequestService.ts

   1 import Ajv, { type JSONSchemaType } from 'ajv';
   2 import ajvFormats from 'ajv-formats';
   3
   4 import OCPPError from '../../exception/OCPPError';
   5 import PerformanceStatistics from '../../performance/PerformanceStatistics';
   6 import type { EmptyObject } from '../../types/EmptyObject';
   7 import type { HandleErrorParams } from '../../types/Error';
   8 import type { JsonObject, JsonType } from '../../types/JsonType';
   9 import { ErrorType } from '../../types/ocpp/ErrorType';
  10 import { MessageType } from '../../types/ocpp/MessageType';
  11 import type { OCPPVersion } from '../../types/ocpp/OCPPVersion';
  12 import {
  13   type ErrorCallback,
  14   type IncomingRequestCommand,
  15   type OutgoingRequest,
  16   RequestCommand,
  17   type RequestParams,
  18   type ResponseCallback,
  19   type ResponseType,
  20 } from '../../types/ocpp/Requests';
  21 import type { ErrorResponse, Response } from '../../types/ocpp/Responses';
  22 import Constants from '../../utils/Constants';
  23 import logger from '../../utils/Logger';
  24 import Utils from '../../utils/Utils';
  25 import type ChargingStation from '../ChargingStation';
  26 import type OCPPResponseService from './OCPPResponseService';
  27 import { OCPPServiceUtils } from './OCPPServiceUtils';
  28
  29 const moduleName = 'OCPPRequestService';
  30
  31 export default abstract class OCPPRequestService {
  32   private static instance: OCPPRequestService | null = null;
  33   private readonly version: OCPPVersion;
  34   private readonly ajv: Ajv;
  35   private readonly ocppResponseService: OCPPResponseService;
  36   protected abstract jsonSchemas: Map<RequestCommand, JSONSchemaType<JsonObject>>;
  37
  38   protected constructor(version: OCPPVersion, ocppResponseService: OCPPResponseService) {
  39     this.version = version;
  40     this.ajv = new Ajv({
  41       keywords: ['javaType'],
  42       multipleOfPrecision: 2,
  43     });
  44     ajvFormats(this.ajv);
  45     this.ocppResponseService = ocppResponseService;
  46     this.requestHandler.bind(this);
  47     this.sendMessage.bind(this);
  48     this.sendResponse.bind(this);
  49     this.sendError.bind(this);
  50     this.internalSendMessage.bind(this);
  51     this.buildMessageToSend.bind(this);
  52     this.validateRequestPayload.bind(this);
  53   }
  54
  55   public static getInstance<T extends OCPPRequestService>(
  56     this: new (ocppResponseService: OCPPResponseService) => T,
  57     ocppResponseService: OCPPResponseService
  58   ): T {
  59     if (OCPPRequestService.instance === null) {
  60       OCPPRequestService.instance = new this(ocppResponseService);
  61     }
  62     return OCPPRequestService.instance as T;
  63   }
  64
  65   public async sendResponse(
  66     chargingStation: ChargingStation,
  67     messageId: string,
  68     messagePayload: JsonType,
  69     commandName: IncomingRequestCommand
  70   ): Promise<ResponseType> {
  71     try {
  72       // Send response message
  73       return await this.internalSendMessage(
  74         chargingStation,
  75         messageId,
  76         messagePayload,
  77         MessageType.CALL_RESULT_MESSAGE,
  78         commandName
  79       );
  80     } catch (error) {
  81       this.handleSendMessageError(chargingStation, commandName, error as Error, {
  82         throwError: true,
  83       });
  84     }
  85   }
  86
  87   public async sendError(
  88     chargingStation: ChargingStation,
  89     messageId: string,
  90     ocppError: OCPPError,
  91     commandName: RequestCommand | IncomingRequestCommand
  92   ): Promise<ResponseType> {
  93     try {
  94       // Send error message
  95       return await this.internalSendMessage(
  96         chargingStation,
  97         messageId,
  98         ocppError,
  99         MessageType.CALL_ERROR_MESSAGE,
 100         commandName
 101       );
 102     } catch (error) {
 103       this.handleSendMessageError(chargingStation, commandName, error as Error);
 104     }
 105   }
 106
 107   protected async sendMessage(
 108     chargingStation: ChargingStation,
 109     messageId: string,
 110     messagePayload: JsonType,
 111     commandName: RequestCommand,
 112     params: RequestParams = {
 113       skipBufferingOnError: false,
 114       triggerMessage: false,
 115     }
 116   ): Promise<ResponseType> {
 117     try {
 118       return await this.internalSendMessage(
 119         chargingStation,
 120         messageId,
 121         messagePayload,
 122         MessageType.CALL_MESSAGE,
 123         commandName,
 124         params
 125       );
 126     } catch (error) {
 127       this.handleSendMessageError(chargingStation, commandName, error as Error);
 128     }
 129   }
 130
 131   protected validateRequestPayload<T extends JsonObject>(
 132     chargingStation: ChargingStation,
 133     commandName: RequestCommand | IncomingRequestCommand,
 134     payload: T
 135   ): boolean {
 136     if (chargingStation.getPayloadSchemaValidation() === false) {
 137       return true;
 138     }
 139     if (this.jsonSchemas.has(commandName as RequestCommand) === false) {
 140       logger.warn(
 141         `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: No JSON schema found for command '${commandName}' PDU validation`
 142       );
 143       return true;
 144     }
 145     const validate = this.ajv.compile(this.jsonSchemas.get(commandName as RequestCommand));
 146     payload = Utils.cloneObject<T>(payload);
 147     OCPPServiceUtils.convertDateToISOString<T>(payload);
 148     if (validate(payload)) {
 149       return true;
 150     }
 151     logger.error(
 152       `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: Command '${commandName}' request PDU is invalid: %j`,
 153       validate.errors
 154     );
 155     // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
 156     throw new OCPPError(
 157       OCPPServiceUtils.ajvErrorsToErrorType(validate.errors),
 158       'Request PDU is invalid',
 159       commandName,
 160       JSON.stringify(validate.errors, null, 2)
 161     );
 162   }
 163
 164   protected validateResponsePayload<T extends JsonObject>(
 165     chargingStation: ChargingStation,
 166     commandName: RequestCommand | IncomingRequestCommand,
 167     payload: T
 168   ): boolean {
 169     if (chargingStation.getPayloadSchemaValidation() === false) {
 170       return true;
 171     }
 172     if (
 173       this.ocppResponseService.jsonIncomingRequestResponseSchemas.has(
 174         commandName as IncomingRequestCommand
 175       ) === false
 176     ) {
 177       logger.warn(
 178         `${chargingStation.logPrefix()} ${moduleName}.validateResponsePayload: No JSON schema found for command '${commandName}' PDU validation`
 179       );
 180       return true;
 181     }
 182     const validate = this.ajv.compile(
 183       this.ocppResponseService.jsonIncomingRequestResponseSchemas.get(
 184         commandName as IncomingRequestCommand
 185       )
 186     );
 187     payload = Utils.cloneObject<T>(payload);
 188     OCPPServiceUtils.convertDateToISOString<T>(payload);
 189     if (validate(payload)) {
 190       return true;
 191     }
 192     logger.error(
 193       `${chargingStation.logPrefix()} ${moduleName}.validateResponsePayload: Command '${commandName}' reponse PDU is invalid: %j`,
 194       validate.errors
 195     );
 196     // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
 197     throw new OCPPError(
 198       OCPPServiceUtils.ajvErrorsToErrorType(validate.errors),
 199       'Response PDU is invalid',
 200       commandName,
 201       JSON.stringify(validate.errors, null, 2)
 202     );
 203   }
 204
 205   private async internalSendMessage(
 206     chargingStation: ChargingStation,
 207     messageId: string,
 208     messagePayload: JsonType | OCPPError,
 209     messageType: MessageType,
 210     commandName?: RequestCommand | IncomingRequestCommand,
 211     params: RequestParams = {
 212       skipBufferingOnError: false,
 213       triggerMessage: false,
 214     }
 215   ): Promise<ResponseType> {
 216     if (
 217       (chargingStation.isInUnknownState() === true &&
 218         commandName === RequestCommand.BOOT_NOTIFICATION) ||
 219       (chargingStation.getOcppStrictCompliance() === false &&
 220         chargingStation.isInUnknownState() === true) ||
 221       chargingStation.isInAcceptedState() === true ||
 222       (chargingStation.isInPendingState() === true &&
 223         (params.triggerMessage === true || messageType === MessageType.CALL_RESULT_MESSAGE))
 224     ) {
 225       // eslint-disable-next-line @typescript-eslint/no-this-alias
 226       const self = this;
 227       // Send a message through wsConnection
 228       return Utils.promiseWithTimeout(
 229         new Promise((resolve, reject) => {
 230           const messageToSend = this.buildMessageToSend(
 231             chargingStation,
 232             messageId,
 233             messagePayload,
 234             messageType,
 235             commandName,
 236             responseCallback,
 237             errorCallback
 238           );
 239           if (chargingStation.getEnableStatistics() === true) {
 240             chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType);
 241           }
 242           // Check if wsConnection opened
 243           if (chargingStation.isWebSocketConnectionOpened() === true) {
 244             // Yes: Send Message
 245             const beginId = PerformanceStatistics.beginMeasure(commandName as string);
 246             // FIXME: Handle sending error
 247             chargingStation.wsConnection.send(messageToSend);
 248             PerformanceStatistics.endMeasure(commandName as string, beginId);
 249             logger.debug(
 250               `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${this.getMessageTypeString(
 251                 messageType
 252               )} payload: ${messageToSend}`
 253             );
 254           } else if (params.skipBufferingOnError === false) {
 255             // Buffer it
 256             chargingStation.bufferMessage(messageToSend);
 257             const ocppError = new OCPPError(
 258               ErrorType.GENERIC_ERROR,
 259               `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`,
 260               commandName,
 261               (messagePayload as JsonObject)?.details ?? {}
 262             );
 263             if (messageType === MessageType.CALL_MESSAGE) {
 264               // Reject it but keep the request in the cache
 265               return reject(ocppError);
 266             }
 267             return errorCallback(ocppError, false);
 268           } else {
 269             // Reject it
 270             return errorCallback(
 271               new OCPPError(
 272                 ErrorType.GENERIC_ERROR,
 273                 `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`,
 274                 commandName,
 275                 (messagePayload as JsonObject)?.details ?? {}
 276               ),
 277               false
 278             );
 279           }
 280           // Response?
 281           if (messageType !== MessageType.CALL_MESSAGE) {
 282             // Yes: send Ok
 283             return resolve(messagePayload);
 284           }
 285
 286           /**
 287            * Function that will receive the request's response
 288            *
 289            * @param payload -
 290            * @param requestPayload -
 291            */
 292           function responseCallback(payload: JsonType, requestPayload: JsonType): void {
 293             if (chargingStation.getEnableStatistics() === true) {
 294               chargingStation.performanceStatistics.addRequestStatistic(
 295                 commandName,
 296                 MessageType.CALL_RESULT_MESSAGE
 297               );
 298             }
 299             // Handle the request's response
 300             self.ocppResponseService
 301               .responseHandler(
 302                 chargingStation,
 303                 commandName as RequestCommand,
 304                 payload,
 305                 requestPayload
 306               )
 307               .then(() => {
 308                 resolve(payload);
 309               })
 310               .catch((error) => {
 311                 reject(error);
 312               })
 313               .finally(() => {
 314                 chargingStation.requests.delete(messageId);
 315               });
 316           }
 317
 318           /**
 319            * Function that will receive the request's error response
 320            *
 321            * @param error -
 322            * @param requestStatistic -
 323            */
 324           function errorCallback(error: OCPPError, requestStatistic = true): void {
 325             if (requestStatistic === true && chargingStation.getEnableStatistics() === true) {
 326               chargingStation.performanceStatistics.addRequestStatistic(
 327                 commandName,
 328                 MessageType.CALL_ERROR_MESSAGE
 329               );
 330             }
 331             logger.error(
 332               `${chargingStation.logPrefix()} Error occurred when calling command ${commandName} with message data ${JSON.stringify(
 333                 messagePayload
 334               )}:`,
 335               error
 336             );
 337             chargingStation.requests.delete(messageId);
 338             reject(error);
 339           }
 340         }),
 341         Constants.OCPP_WEBSOCKET_TIMEOUT,
 342         new OCPPError(
 343           ErrorType.GENERIC_ERROR,
 344           `Timeout for message id '${messageId}'`,
 345           commandName,
 346           (messagePayload as JsonObject)?.details ?? {}
 347         ),
 348         () => {
 349           messageType === MessageType.CALL_MESSAGE && chargingStation.requests.delete(messageId);
 350         }
 351       );
 352     }
 353     throw new OCPPError(
 354       ErrorType.SECURITY_ERROR,
 355       `Cannot send command ${commandName} PDU when the charging station is in ${chargingStation.getRegistrationStatus()} state on the central server`,
 356       commandName
 357     );
 358   }
 359
 360   private buildMessageToSend(
 361     chargingStation: ChargingStation,
 362     messageId: string,
 363     messagePayload: JsonType | OCPPError,
 364     messageType: MessageType,
 365     commandName?: RequestCommand | IncomingRequestCommand,
 366     responseCallback?: ResponseCallback,
 367     errorCallback?: ErrorCallback
 368   ): string {
 369     let messageToSend: string;
 370     // Type of message
 371     switch (messageType) {
 372       // Request
 373       case MessageType.CALL_MESSAGE:
 374         // Build request
 375         chargingStation.requests.set(messageId, [
 376           responseCallback,
 377           errorCallback,
 378           commandName,
 379           messagePayload as JsonType,
 380         ]);
 381         this.validateRequestPayload(chargingStation, commandName, messagePayload as JsonObject);
 382         messageToSend = JSON.stringify([
 383           messageType,
 384           messageId,
 385           commandName,
 386           messagePayload,
 387         ] as OutgoingRequest);
 388         break;
 389       // Response
 390       case MessageType.CALL_RESULT_MESSAGE:
 391         // Build response
 392         this.validateResponsePayload(chargingStation, commandName, messagePayload as JsonObject);
 393         messageToSend = JSON.stringify([messageType, messageId, messagePayload] as Response);
 394         break;
 395       // Error Message
 396       case MessageType.CALL_ERROR_MESSAGE:
 397         // Build Error Message
 398         messageToSend = JSON.stringify([
 399           messageType,
 400           messageId,
 401           (messagePayload as OCPPError)?.code ?? ErrorType.GENERIC_ERROR,
 402           (messagePayload as OCPPError)?.message ?? '',
 403           (messagePayload as OCPPError)?.details ?? { commandName },
 404         ] as ErrorResponse);
 405         break;
 406     }
 407     return messageToSend;
 408   }
 409
 410   private getMessageTypeString(messageType: MessageType): string {
 411     switch (messageType) {
 412       case MessageType.CALL_MESSAGE:
 413         return 'request';
 414       case MessageType.CALL_RESULT_MESSAGE:
 415         return 'response';
 416       case MessageType.CALL_ERROR_MESSAGE:
 417         return 'error';
 418     }
 419   }
 420
 421   private handleSendMessageError(
 422     chargingStation: ChargingStation,
 423     commandName: RequestCommand | IncomingRequestCommand,
 424     error: Error,
 425     params: HandleErrorParams<EmptyObject> = { throwError: false }
 426   ): void {
 427     logger.error(`${chargingStation.logPrefix()} Request command '${commandName}' error:`, error);
 428     if (params?.throwError === true) {
 429       throw error;
 430     }
 431   }
 432
 433   // eslint-disable-next-line @typescript-eslint/no-unused-vars
 434   public abstract requestHandler<ReqType extends JsonType, ResType extends JsonType>(
 435     chargingStation: ChargingStation,
 436     commandName: RequestCommand,
 437     commandParams?: JsonType,
 438     params?: RequestParams
 439   ): Promise<ResType>;
 440 }