X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=023d5f95174bc07df34f3f5dbc49e214f1191d1a;hb=8ca6874c767f7068b101291232cf69b05bbd28c1;hp=74ea7a8d547f8eada5b202b6d178b53f4835544a;hpb=b52c969dc8bfbd4bc2a2b6f1fc74e3868c4a091d;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts index 74ea7a8d..023d5f95 100644 --- a/src/charging-station/ocpp/OCPPRequestService.ts +++ b/src/charging-station/ocpp/OCPPRequestService.ts @@ -1,50 +1,63 @@ -import { JSONSchemaType } from 'ajv'; -import Ajv from 'ajv-draft-04'; +import Ajv, { type JSONSchemaType } from 'ajv'; import ajvFormats from 'ajv-formats'; +import type OCPPResponseService from './OCPPResponseService'; +import { OCPPServiceUtils } from './OCPPServiceUtils'; import OCPPError from '../../exception/OCPPError'; import PerformanceStatistics from '../../performance/PerformanceStatistics'; -import { EmptyObject } from '../../types/EmptyObject'; -import { HandleErrorParams } from '../../types/Error'; -import { JsonObject, JsonType } from '../../types/JsonType'; +import type { EmptyObject } from '../../types/EmptyObject'; +import type { HandleErrorParams } from '../../types/Error'; +import type { JsonObject, JsonType } from '../../types/JsonType'; import { ErrorType } from '../../types/ocpp/ErrorType'; import { MessageType } from '../../types/ocpp/MessageType'; +import type { OCPPVersion } from '../../types/ocpp/OCPPVersion'; import { - IncomingRequestCommand, - OutgoingRequest, + type ErrorCallback, + type IncomingRequestCommand, + type OutgoingRequest, RequestCommand, - RequestParams, - ResponseType, + type RequestParams, + type ResponseCallback, + type ResponseType, } from '../../types/ocpp/Requests'; -import { ErrorResponse, Response } from '../../types/ocpp/Responses'; +import type { ErrorResponse, Response } from '../../types/ocpp/Responses'; import Constants from '../../utils/Constants'; import logger from '../../utils/Logger'; import Utils from '../../utils/Utils'; import type ChargingStation from '../ChargingStation'; -import type OCPPResponseService from './OCPPResponseService'; const moduleName = 'OCPPRequestService'; export default abstract class OCPPRequestService { private static instance: OCPPRequestService | null = null; - private ajv: Ajv; - + private readonly version: OCPPVersion; + private readonly ajv: Ajv; private readonly ocppResponseService: OCPPResponseService; + protected abstract jsonSchemas: Map>; - protected constructor(ocppResponseService: OCPPResponseService) { + protected constructor(version: OCPPVersion, ocppResponseService: OCPPResponseService) { + this.version = version; + this.ajv = new Ajv({ + keywords: ['javaType'], + multipleOfPrecision: 2, + }); + ajvFormats(this.ajv); this.ocppResponseService = ocppResponseService; this.requestHandler.bind(this); + this.sendMessage.bind(this); this.sendResponse.bind(this); this.sendError.bind(this); - this.ajv = new Ajv(); - ajvFormats(this.ajv); + this.internalSendMessage.bind(this); + this.buildMessageToSend.bind(this); + this.validateRequestPayload.bind(this); + this.validateIncomingRequestResponsePayload.bind(this); } public static getInstance( this: new (ocppResponseService: OCPPResponseService) => T, ocppResponseService: OCPPResponseService ): T { - if (!OCPPRequestService.instance) { + if (OCPPRequestService.instance === null) { OCPPRequestService.instance = new this(ocppResponseService); } return OCPPRequestService.instance as T; @@ -66,7 +79,9 @@ export default abstract class OCPPRequestService { commandName ); } catch (error) { - this.handleRequestError(chargingStation, commandName, error as Error); + this.handleSendMessageError(chargingStation, commandName, error as Error, { + throwError: true, + }); } } @@ -86,7 +101,7 @@ export default abstract class OCPPRequestService { commandName ); } catch (error) { - this.handleRequestError(chargingStation, commandName, error as Error); + this.handleSendMessageError(chargingStation, commandName, error as Error); } } @@ -98,6 +113,7 @@ export default abstract class OCPPRequestService { params: RequestParams = { skipBufferingOnError: false, triggerMessage: false, + throwError: false, } ): Promise { try { @@ -110,35 +126,86 @@ export default abstract class OCPPRequestService { params ); } catch (error) { - this.handleRequestError(chargingStation, commandName, error as Error, { throwError: false }); + this.handleSendMessageError(chargingStation, commandName, error as Error, { + throwError: params.throwError, + }); } } - protected validateRequestPayload( + private validateRequestPayload( chargingStation: ChargingStation, - commandName: RequestCommand, - schema: JSONSchemaType, + commandName: RequestCommand | IncomingRequestCommand, payload: T ): boolean { - if (!chargingStation.getPayloadSchemaValidation()) { + if (chargingStation.getPayloadSchemaValidation() === false) { return true; } - const validate = this.ajv.compile(schema); + if (this.jsonSchemas.has(commandName as RequestCommand) === false) { + logger.warn( + `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: No JSON schema found for command '${commandName}' PDU validation` + ); + return true; + } + const validate = this.ajv.compile(this.jsonSchemas.get(commandName as RequestCommand)); + payload = Utils.cloneObject(payload); + OCPPServiceUtils.convertDateToISOString(payload); if (validate(payload)) { return true; } logger.error( - `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: Request PDU is invalid: %j`, + `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: Command '${commandName}' request PDU is invalid: %j`, validate.errors ); + // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError(). throw new OCPPError( - ErrorType.FORMATION_VIOLATION, + OCPPServiceUtils.ajvErrorsToErrorType(validate.errors), 'Request PDU is invalid', commandName, JSON.stringify(validate.errors, null, 2) ); } + private validateIncomingRequestResponsePayload( + chargingStation: ChargingStation, + commandName: RequestCommand | IncomingRequestCommand, + payload: T + ): boolean { + if (chargingStation.getPayloadSchemaValidation() === false) { + return true; + } + if ( + this.ocppResponseService.jsonIncomingRequestResponseSchemas.has( + commandName as IncomingRequestCommand + ) === false + ) { + logger.warn( + `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: No JSON schema found for command '${commandName}' PDU validation` + ); + return true; + } + const validate = this.ajv.compile( + this.ocppResponseService.jsonIncomingRequestResponseSchemas.get( + commandName as IncomingRequestCommand + ) + ); + payload = Utils.cloneObject(payload); + OCPPServiceUtils.convertDateToISOString(payload); + if (validate(payload)) { + return true; + } + logger.error( + `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: Command '${commandName}' reponse PDU is invalid: %j`, + validate.errors + ); + // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError(). + throw new OCPPError( + OCPPServiceUtils.ajvErrorsToErrorType(validate.errors), + 'Response PDU is invalid', + commandName, + JSON.stringify(validate.errors, null, 2) + ); + } + private async internalSendMessage( chargingStation: ChargingStation, messageId: string, @@ -151,11 +218,13 @@ export default abstract class OCPPRequestService { } ): Promise { if ( - (chargingStation.isInUnknownState() && commandName === RequestCommand.BOOT_NOTIFICATION) || - (!chargingStation.getOcppStrictCompliance() && chargingStation.isInUnknownState()) || - chargingStation.isInAcceptedState() || - (chargingStation.isInPendingState() && - (params.triggerMessage || messageType === MessageType.CALL_RESULT_MESSAGE)) + (chargingStation.isInUnknownState() === true && + commandName === RequestCommand.BOOT_NOTIFICATION) || + (chargingStation.getOcppStrictCompliance() === false && + chargingStation.isInUnknownState() === true) || + chargingStation.isInAcceptedState() === true || + (chargingStation.isInPendingState() === true && + (params.triggerMessage === true || messageType === MessageType.CALL_RESULT_MESSAGE)) ) { // eslint-disable-next-line @typescript-eslint/no-this-alias const self = this; @@ -171,103 +240,115 @@ export default abstract class OCPPRequestService { responseCallback, errorCallback ); - if (chargingStation.getEnableStatistics()) { + if (chargingStation.getEnableStatistics() === true) { chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType); } + let sendError = false; // Check if wsConnection opened - if (chargingStation.isWebSocketConnectionOpened()) { - // Yes: Send Message - const beginId = PerformanceStatistics.beginMeasure(commandName); - // FIXME: Handle sending error - chargingStation.wsConnection.send(messageToSend); - PerformanceStatistics.endMeasure(commandName, beginId); - logger.debug( - `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${this.getMessageTypeString( - messageType - )} payload: ${messageToSend}` - ); - } else if (!params.skipBufferingOnError) { - // Buffer it + if (chargingStation.isWebSocketConnectionOpened() === true) { + const beginId = PerformanceStatistics.beginMeasure(commandName as string); + try { + chargingStation.wsConnection.send(messageToSend); + logger.debug( + `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${OCPPServiceUtils.getMessageTypeString( + messageType + )} payload: ${messageToSend}` + ); + } catch (error) { + logger.error( + `${chargingStation.logPrefix()} >> Command '${commandName}' failed to send ${OCPPServiceUtils.getMessageTypeString( + messageType + )} payload: ${messageToSend}:`, + error + ); + sendError = true; + } + PerformanceStatistics.endMeasure(commandName as string, beginId); + } + const wsClosedOrErrored = + chargingStation.isWebSocketConnectionOpened() === false || sendError === true; + if (wsClosedOrErrored && params.skipBufferingOnError === false) { + // Buffer chargingStation.bufferMessage(messageToSend); + // Reject and keep request in the cache + return reject( + new OCPPError( + ErrorType.GENERIC_ERROR, + `WebSocket closed or errored for buffered message id '${messageId}' with content '${messageToSend}'`, + commandName, + (messagePayload as JsonObject)?.details ?? {} + ) + ); + } else if (wsClosedOrErrored) { const ocppError = new OCPPError( ErrorType.GENERIC_ERROR, - `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`, + `WebSocket closed or errored for non buffered message id '${messageId}' with content '${messageToSend}'`, commandName, (messagePayload as JsonObject)?.details ?? {} ); - if (messageType === MessageType.CALL_MESSAGE) { - // Reject it but keep the request in the cache + // Reject response + if (messageType !== MessageType.CALL_MESSAGE) { return reject(ocppError); } + // Reject and remove request from the cache return errorCallback(ocppError, false); - } else { - // Reject it - return errorCallback( - new OCPPError( - ErrorType.GENERIC_ERROR, - `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`, - commandName, - (messagePayload as JsonObject)?.details ?? {} - ), - false - ); } - // Response? + // Resolve response if (messageType !== MessageType.CALL_MESSAGE) { - // Yes: send Ok return resolve(messagePayload); } /** * Function that will receive the request's response * - * @param payload - * @param requestPayload + * @param payload - + * @param requestPayload - */ - async function responseCallback( - payload: JsonType, - requestPayload: JsonType - ): Promise { - if (chargingStation.getEnableStatistics()) { + function responseCallback(payload: JsonType, requestPayload: JsonType): void { + if (chargingStation.getEnableStatistics() === true) { chargingStation.performanceStatistics.addRequestStatistic( commandName, MessageType.CALL_RESULT_MESSAGE ); } // Handle the request's response - try { - await self.ocppResponseService.responseHandler( + self.ocppResponseService + .responseHandler( chargingStation, commandName as RequestCommand, payload, requestPayload - ); - resolve(payload); - } catch (error) { - reject(error); - } finally { - chargingStation.requests.delete(messageId); - } + ) + .then(() => { + resolve(payload); + }) + .catch((error) => { + reject(error); + }) + .finally(() => { + chargingStation.requests.delete(messageId); + }); } /** * Function that will receive the request's error response * - * @param error - * @param requestStatistic + * @param error - + * @param requestStatistic - */ function errorCallback(error: OCPPError, requestStatistic = true): void { - if (requestStatistic && chargingStation.getEnableStatistics()) { + if (requestStatistic === true && chargingStation.getEnableStatistics() === true) { chargingStation.performanceStatistics.addRequestStatistic( commandName, MessageType.CALL_ERROR_MESSAGE ); } logger.error( - `${chargingStation.logPrefix()} Error %j occurred when calling command %s with message data %j`, - error, - commandName, - messagePayload + `${chargingStation.logPrefix()} Error occurred at ${OCPPServiceUtils.getMessageTypeString( + messageType + )} command ${commandName} with PDU %j:`, + messagePayload, + error ); chargingStation.requests.delete(messageId); reject(error); @@ -298,8 +379,8 @@ export default abstract class OCPPRequestService { messagePayload: JsonType | OCPPError, messageType: MessageType, commandName?: RequestCommand | IncomingRequestCommand, - responseCallback?: (payload: JsonType, requestPayload: JsonType) => Promise, - errorCallback?: (error: OCPPError, requestStatistic?: boolean) => void + responseCallback?: ResponseCallback, + errorCallback?: ErrorCallback ): string { let messageToSend: string; // Type of message @@ -307,6 +388,7 @@ export default abstract class OCPPRequestService { // Request case MessageType.CALL_MESSAGE: // Build request + this.validateRequestPayload(chargingStation, commandName, messagePayload as JsonObject); chargingStation.requests.set(messageId, [ responseCallback, errorCallback, @@ -323,6 +405,11 @@ export default abstract class OCPPRequestService { // Response case MessageType.CALL_RESULT_MESSAGE: // Build response + this.validateIncomingRequestResponsePayload( + chargingStation, + commandName, + messagePayload as JsonObject + ); messageToSend = JSON.stringify([messageType, messageId, messagePayload] as Response); break; // Error Message @@ -340,34 +427,23 @@ export default abstract class OCPPRequestService { return messageToSend; } - private getMessageTypeString(messageType: MessageType): string { - switch (messageType) { - case MessageType.CALL_MESSAGE: - return 'request'; - case MessageType.CALL_RESULT_MESSAGE: - return 'response'; - case MessageType.CALL_ERROR_MESSAGE: - return 'error'; - } - } - - private handleRequestError( + private handleSendMessageError( chargingStation: ChargingStation, commandName: RequestCommand | IncomingRequestCommand, error: Error, - params: HandleErrorParams = { throwError: true } + params: HandleErrorParams = { throwError: false } ): void { - logger.error(chargingStation.logPrefix() + ' Request command %s error: %j', commandName, error); - if (params?.throwError) { + logger.error(`${chargingStation.logPrefix()} Request command '${commandName}' error:`, error); + if (params?.throwError === true) { throw error; } } // eslint-disable-next-line @typescript-eslint/no-unused-vars - public abstract requestHandler( + public abstract requestHandler( chargingStation: ChargingStation, commandName: RequestCommand, commandParams?: JsonType, params?: RequestParams - ): Promise; + ): Promise; }