X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=a50500dc24047f7a7eb3276a03d725cedf69fb44;hb=a14022a2a2426ab1f42c3ee25ffbfab8969447ea;hp=c089c86a1af4092dd57e1deb281dab48c9d7769a;hpb=b0342994636646699094b2d16a767d6d902d2bde;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts index c089c86a..a50500dc 100644 --- a/src/charging-station/ocpp/OCPPRequestService.ts +++ b/src/charging-station/ocpp/OCPPRequestService.ts @@ -1,52 +1,104 @@ import Ajv, { type JSONSchemaType } from 'ajv'; import ajvFormats from 'ajv-formats'; -import OCPPError from '../../exception/OCPPError'; -import PerformanceStatistics from '../../performance/PerformanceStatistics'; -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 { OCPPConstants, type OCPPResponseService, OCPPServiceUtils } from './internal'; +import type { ChargingStation } from '../../charging-station'; +import { OCPPError } from '../../exception'; +import { PerformanceStatistics } from '../../performance'; import { + type EmptyObject, type ErrorCallback, + type ErrorResponse, + ErrorType, + type HandleErrorParams, type IncomingRequestCommand, + type JsonObject, + type JsonType, + MessageType, + type OCPPVersion, type OutgoingRequest, RequestCommand, type RequestParams, + type Response, type ResponseCallback, type ResponseType, -} from '../../types/ocpp/Requests'; -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'; -import { OCPPServiceUtils } from './OCPPServiceUtils'; +} from '../../types'; +import { Constants, Utils, logger } from '../../utils'; const moduleName = 'OCPPRequestService'; -export default abstract class OCPPRequestService { +export abstract class OCPPRequestService { private static instance: OCPPRequestService | null = null; private readonly version: OCPPVersion; private readonly ajv: Ajv; - private readonly ocppResponseService: OCPPResponseService; + protected abstract jsonSchemas: Map>; protected constructor(version: OCPPVersion, ocppResponseService: OCPPResponseService) { this.version = version; - this.ajv = new Ajv(); + 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.internalSendMessage.bind(this); - this.buildMessageToSend.bind(this); - this.validateRequestPayload.bind(this); + this.requestHandler = this.requestHandler.bind(this) as < + ReqType extends JsonType, + ResType extends JsonType + >( + chargingStation: ChargingStation, + commandName: RequestCommand, + commandParams?: JsonType, + params?: RequestParams + ) => Promise; + this.sendMessage = this.sendMessage.bind(this) as ( + chargingStation: ChargingStation, + messageId: string, + messagePayload: JsonType, + commandName: RequestCommand, + params?: RequestParams + ) => Promise; + this.sendResponse = this.sendResponse.bind(this) as ( + chargingStation: ChargingStation, + messageId: string, + messagePayload: JsonType, + commandName: IncomingRequestCommand + ) => Promise; + this.sendError = this.sendError.bind(this) as ( + chargingStation: ChargingStation, + messageId: string, + ocppError: OCPPError, + commandName: RequestCommand | IncomingRequestCommand + ) => Promise; + this.internalSendMessage = this.internalSendMessage.bind(this) as ( + chargingStation: ChargingStation, + messageId: string, + messagePayload: JsonType | OCPPError, + messageType: MessageType, + commandName: RequestCommand | IncomingRequestCommand, + params?: RequestParams + ) => Promise; + this.buildMessageToSend = this.buildMessageToSend.bind(this) as ( + chargingStation: ChargingStation, + messageId: string, + messagePayload: JsonType | OCPPError, + messageType: MessageType, + commandName: RequestCommand | IncomingRequestCommand, + responseCallback: ResponseCallback, + errorCallback: ErrorCallback + ) => string; + this.validateRequestPayload = this.validateRequestPayload.bind(this) as ( + chargingStation: ChargingStation, + commandName: RequestCommand | IncomingRequestCommand, + payload: T + ) => boolean; + this.validateIncomingRequestResponsePayload = this.validateIncomingRequestResponsePayload.bind( + this + ) as ( + chargingStation: ChargingStation, + commandName: RequestCommand | IncomingRequestCommand, + payload: T + ) => boolean; } public static getInstance( @@ -109,6 +161,7 @@ export default abstract class OCPPRequestService { params: RequestParams = { skipBufferingOnError: false, triggerMessage: false, + throwError: false, } ): Promise { try { @@ -121,25 +174,34 @@ export default abstract class OCPPRequestService { params ); } catch (error) { - this.handleSendMessageError(chargingStation, commandName, error as Error); + 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() === 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(). @@ -151,12 +213,53 @@ export default abstract class OCPPRequestService { ); } + 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, messagePayload: JsonType | OCPPError, messageType: MessageType, - commandName?: RequestCommand | IncomingRequestCommand, + commandName: RequestCommand | IncomingRequestCommand, params: RequestParams = { skipBufferingOnError: false, triggerMessage: false, @@ -176,71 +279,15 @@ export default abstract class OCPPRequestService { // Send a message through wsConnection return Utils.promiseWithTimeout( new Promise((resolve, reject) => { - const messageToSend = this.buildMessageToSend( - chargingStation, - messageId, - messagePayload, - messageType, - commandName, - responseCallback, - errorCallback - ); - if (chargingStation.getEnableStatistics() === true) { - chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType); - } - // Check if wsConnection opened - if (chargingStation.isWebSocketConnectionOpened() === true) { - // Yes: Send Message - const beginId = PerformanceStatistics.beginMeasure(commandName as string); - // FIXME: Handle sending error - chargingStation.wsConnection.send(messageToSend); - PerformanceStatistics.endMeasure(commandName as string, beginId); - logger.debug( - `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${this.getMessageTypeString( - messageType - )} payload: ${messageToSend}` - ); - } else if (params.skipBufferingOnError === false) { - // Buffer it - chargingStation.bufferMessage(messageToSend); - const ocppError = new OCPPError( - ErrorType.GENERIC_ERROR, - `WebSocket closed for 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 - return reject(ocppError); - } - 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? - if (messageType !== MessageType.CALL_MESSAGE) { - // Yes: send Ok - return resolve(messagePayload); - } - /** * Function that will receive the request's response * * @param payload - * @param requestPayload - */ - function responseCallback(payload: JsonType, requestPayload: JsonType): void { + const responseCallback = (payload: JsonType, requestPayload: JsonType): void => { if (chargingStation.getEnableStatistics() === true) { - chargingStation.performanceStatistics.addRequestStatistic( + chargingStation.performanceStatistics?.addRequestStatistic( commandName, MessageType.CALL_RESULT_MESSAGE ); @@ -262,7 +309,7 @@ export default abstract class OCPPRequestService { .finally(() => { chargingStation.requests.delete(messageId); }); - } + }; /** * Function that will receive the request's error response @@ -270,29 +317,97 @@ export default abstract class OCPPRequestService { * @param error - * @param requestStatistic - */ - function errorCallback(error: OCPPError, requestStatistic = true): void { + const errorCallback = (error: OCPPError, requestStatistic = true): void => { if (requestStatistic === true && chargingStation.getEnableStatistics() === true) { - chargingStation.performanceStatistics.addRequestStatistic( + chargingStation.performanceStatistics?.addRequestStatistic( commandName, MessageType.CALL_ERROR_MESSAGE ); } logger.error( - `${chargingStation.logPrefix()} Error occurred when calling command ${commandName} with message data ${JSON.stringify( - messagePayload - )}:`, + `${chargingStation.logPrefix()} Error occurred at ${OCPPServiceUtils.getMessageTypeString( + messageType + )} command ${commandName} with PDU %j:`, + messagePayload, error ); chargingStation.requests.delete(messageId); reject(error); + }; + + if (chargingStation.getEnableStatistics() === true) { + chargingStation.performanceStatistics?.addRequestStatistic(commandName, messageType); + } + const messageToSend = this.buildMessageToSend( + chargingStation, + messageId, + messagePayload, + messageType, + commandName, + responseCallback, + errorCallback + ); + let sendError = false; + // Check if wsConnection opened + const wsOpened = chargingStation.isWebSocketConnectionOpened() === true; + if (wsOpened) { + const beginId = PerformanceStatistics.beginMeasure(commandName); + 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, beginId); + } + const wsClosedOrErrored = !wsOpened || 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 ?? Constants.EMPTY_FREEZED_OBJECT + ) + ); + } else if (wsClosedOrErrored) { + const ocppError = new OCPPError( + ErrorType.GENERIC_ERROR, + `WebSocket closed or errored for non buffered message id '${messageId}' with content '${messageToSend}'`, + commandName, + (messagePayload as JsonObject)?.details ?? Constants.EMPTY_FREEZED_OBJECT + ); + // Reject response + if (messageType !== MessageType.CALL_MESSAGE) { + return reject(ocppError); + } + // Reject and remove request from the cache + return errorCallback(ocppError, false); + } + // Resolve response + if (messageType !== MessageType.CALL_MESSAGE) { + return resolve(messagePayload); } }), - Constants.OCPP_WEBSOCKET_TIMEOUT, + OCPPConstants.OCPP_WEBSOCKET_TIMEOUT, new OCPPError( ErrorType.GENERIC_ERROR, `Timeout for message id '${messageId}'`, commandName, - (messagePayload as JsonObject)?.details ?? {} + (messagePayload as JsonObject)?.details ?? Constants.EMPTY_FREEZED_OBJECT ), () => { messageType === MessageType.CALL_MESSAGE && chargingStation.requests.delete(messageId); @@ -311,9 +426,9 @@ export default abstract class OCPPRequestService { messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, - commandName?: RequestCommand | IncomingRequestCommand, - responseCallback?: ResponseCallback, - errorCallback?: ErrorCallback + commandName: RequestCommand | IncomingRequestCommand, + responseCallback: ResponseCallback, + errorCallback: ErrorCallback ): string { let messageToSend: string; // Type of message @@ -321,6 +436,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, @@ -337,6 +453,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 @@ -354,17 +475,6 @@ 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 handleSendMessageError( chargingStation: ChargingStation, commandName: RequestCommand | IncomingRequestCommand,