src/charging-station/ocpp/OCPPRequestService.ts

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