X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=3ac768c2052c9468fae03c2a30a4cb8fea0e99b8;hb=a9671b9e315a2807c2659fdda962203229d35c0a;hp=0d95ffa5493f8f4b06677c43f7cf47231ff9ee30;hpb=1b821a640d1f793e969eed6d76e9c20e7cebb626;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts index 0d95ffa5..3ac768c2 100644 --- a/src/charging-station/ocpp/OCPPRequestService.ts +++ b/src/charging-station/ocpp/OCPPRequestService.ts @@ -1,56 +1,71 @@ -import Ajv, { type JSONSchemaType } from 'ajv'; -import ajvFormats from 'ajv-formats'; +import _Ajv, { type ValidateFunction } 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 type { ChargingStation } from '../../charging-station/index.js' +import { OCPPError } from '../../exception/index.js' +import { PerformanceStatistics } from '../../performance/index.js' import { + ChargingStationEvents, type ErrorCallback, + type ErrorResponse, + ErrorType, type IncomingRequestCommand, + 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'; + type ResponseType +} from '../../types/index.js' +import { + clone, + formatDurationMilliSeconds, + handleSendMessageError, + logger +} from '../../utils/index.js' +import { OCPPConstants } from './OCPPConstants.js' +import type { OCPPResponseService } from './OCPPResponseService.js' +import { OCPPServiceUtils } from './OCPPServiceUtils.js' +type Ajv = _Ajv.default +// eslint-disable-next-line @typescript-eslint/no-redeclare +const Ajv = _Ajv.default +const ajvFormats = _ajvFormats.default + +const moduleName = 'OCPPRequestService' -const moduleName = 'OCPPRequestService'; +const defaultRequestParams: RequestParams = { + skipBufferingOnError: false, + triggerMessage: false, + throwError: false +} -export default 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>; +export abstract class OCPPRequestService { + private static instance: OCPPRequestService | null = null + private readonly version: OCPPVersion + private readonly ocppResponseService: OCPPResponseService + protected readonly ajv: Ajv + protected abstract payloadValidateFunctions: Map> - protected constructor(version: OCPPVersion, ocppResponseService: OCPPResponseService) { - this.version = version; + 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.internalSendMessage.bind(this); - this.buildMessageToSend.bind(this); - this.validateRequestPayload.bind(this); - this.validateIncomingRequestResponsePayload.bind(this); + multipleOfPrecision: 2 + }) + ajvFormats(this.ajv) + this.ocppResponseService = ocppResponseService + this.requestHandler = this.requestHandler.bind(this) + this.sendMessage = this.sendMessage.bind(this) + this.sendResponse = this.sendResponse.bind(this) + this.sendError = this.sendError.bind(this) + this.internalSendMessage = this.internalSendMessage.bind(this) + this.buildMessageToSend = this.buildMessageToSend.bind(this) + this.validateRequestPayload = this.validateRequestPayload.bind(this) + this.validateIncomingRequestResponsePayload = + this.validateIncomingRequestResponsePayload.bind(this) } public static getInstance( @@ -58,12 +73,12 @@ export default abstract class OCPPRequestService { ocppResponseService: OCPPResponseService ): T { if (OCPPRequestService.instance === null) { - OCPPRequestService.instance = new this(ocppResponseService); + OCPPRequestService.instance = new this(ocppResponseService) } - return OCPPRequestService.instance as T; + return OCPPRequestService.instance as T } - public async sendResponse( + public async sendResponse ( chargingStation: ChargingStation, messageId: string, messagePayload: JsonType, @@ -77,15 +92,16 @@ export default abstract class OCPPRequestService { messagePayload, MessageType.CALL_RESULT_MESSAGE, commandName - ); + ) } catch (error) { - this.handleSendMessageError(chargingStation, commandName, error as Error, { - throwError: true, - }); + handleSendMessageError(chargingStation, commandName, error as Error, { + throwError: true + }) + return null } } - public async sendError( + public async sendError ( chargingStation: ChargingStation, messageId: string, ocppError: OCPPError, @@ -99,22 +115,24 @@ export default abstract class OCPPRequestService { ocppError, MessageType.CALL_ERROR_MESSAGE, commandName - ); + ) } catch (error) { - this.handleSendMessageError(chargingStation, commandName, error as Error); + handleSendMessageError(chargingStation, commandName, error as Error) + return null } } - protected async sendMessage( + protected async sendMessage ( chargingStation: ChargingStation, messageId: string, messagePayload: JsonType, commandName: RequestCommand, - params: RequestParams = { - skipBufferingOnError: false, - triggerMessage: false, - } + params?: RequestParams ): Promise { + params = { + ...defaultRequestParams, + ...params + } try { return await this.internalSendMessage( chargingStation, @@ -123,329 +141,347 @@ export default abstract class OCPPRequestService { MessageType.CALL_MESSAGE, commandName, params - ); + ) } catch (error) { - this.handleSendMessageError(chargingStation, commandName, error as Error); + handleSendMessageError(chargingStation, commandName, error as Error, { + throwError: params.throwError + }) + return null } } - private validateRequestPayload( + private validateRequestPayload( chargingStation: ChargingStation, commandName: RequestCommand | IncomingRequestCommand, payload: T ): boolean { - if (chargingStation.getPayloadSchemaValidation() === false) { - return true; + if (chargingStation.stationInfo?.ocppStrictCompliance === false) { + return true } - if (this.jsonSchemas.has(commandName as RequestCommand) === false) { + if (!this.payloadValidateFunctions.has(commandName as RequestCommand)) { logger.warn( `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: No JSON schema found for command '${commandName}' PDU validation` - ); - return true; + ) + 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; + const validate = this.payloadValidateFunctions.get(commandName as RequestCommand) + payload = clone(payload) + OCPPServiceUtils.convertDateToISOString(payload) + if (validate?.(payload) === true) { + return true } logger.error( `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: Command '${commandName}' request PDU is invalid: %j`, - validate.errors - ); + 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), + OCPPServiceUtils.ajvErrorsToErrorType(validate?.errors), 'Request PDU is invalid', commandName, - JSON.stringify(validate.errors, null, 2) - ); + JSON.stringify(validate?.errors, undefined, 2) + ) } - private validateIncomingRequestResponsePayload( + private validateIncomingRequestResponsePayload( chargingStation: ChargingStation, commandName: RequestCommand | IncomingRequestCommand, payload: T ): boolean { - if (chargingStation.getPayloadSchemaValidation() === false) { - return true; + if (chargingStation.stationInfo?.ocppStrictCompliance === false) { + return true } if ( - this.ocppResponseService.jsonIncomingRequestResponseSchemas.has( + !this.ocppResponseService.incomingRequestResponsePayloadValidateFunctions.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 + `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: No JSON schema validation function found for command '${commandName}' PDU validation` ) - ); - payload = Utils.cloneObject(payload); - OCPPServiceUtils.convertDateToISOString(payload); - if (validate(payload)) { - return true; + return true + } + const validate = this.ocppResponseService.incomingRequestResponsePayloadValidateFunctions.get( + commandName as IncomingRequestCommand + ) + payload = clone(payload) + OCPPServiceUtils.convertDateToISOString(payload) + if (validate?.(payload) === true) { + return true } logger.error( - `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: Command '${commandName}' reponse PDU is invalid: %j`, - validate.errors - ); + `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: Command '${commandName}' response 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), + OCPPServiceUtils.ajvErrorsToErrorType(validate?.errors), 'Response PDU is invalid', commandName, - JSON.stringify(validate.errors, null, 2) - ); + JSON.stringify(validate?.errors, undefined, 2) + ) } - private async internalSendMessage( + private async internalSendMessage ( chargingStation: ChargingStation, messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, - commandName?: RequestCommand | IncomingRequestCommand, - params: RequestParams = { - skipBufferingOnError: false, - triggerMessage: false, - } + commandName: RequestCommand | IncomingRequestCommand, + params?: RequestParams ): Promise { + params = { + ...defaultRequestParams, + ...params + } if ( - (chargingStation.isInUnknownState() === true && - commandName === RequestCommand.BOOT_NOTIFICATION) || - (chargingStation.getOcppStrictCompliance() === false && - chargingStation.isInUnknownState() === true) || - chargingStation.isInAcceptedState() === true || - (chargingStation.isInPendingState() === true && + (chargingStation.inUnknownState() && commandName === RequestCommand.BOOT_NOTIFICATION) || + (chargingStation.stationInfo?.ocppStrictCompliance === false && + chargingStation.inUnknownState()) || + chargingStation.inAcceptedState() || + (chargingStation.inPendingState() && (params.triggerMessage === true || messageType === MessageType.CALL_RESULT_MESSAGE)) ) { // eslint-disable-next-line @typescript-eslint/no-this-alias - const self = this; + const self = this // 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); + return await new Promise((resolve, reject: (reason?: unknown) => void) => { + /** + * Function that will receive the request's response + * + * @param payload - + * @param requestPayload - + */ + const responseCallback = (payload: JsonType, requestPayload: JsonType): void => { + if (chargingStation.stationInfo?.enableStatistics === true) { + chargingStation.performanceStatistics?.addRequestStatistic( + commandName, + MessageType.CALL_RESULT_MESSAGE + ) } - let sendError = false; - // Check if wsConnection opened - if (chargingStation.isWebSocketConnectionOpened() === true) { - const beginId = PerformanceStatistics.beginMeasure(commandName as string); - try { - chargingStation.wsConnection.send(messageToSend); - } catch (error) { - sendError = true; - } - PerformanceStatistics.endMeasure(commandName as string, beginId); - logger.debug( - `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${this.getMessageTypeString( - messageType - )} payload: ${messageToSend}` - ); + // Handle the request's response + self.ocppResponseService + .responseHandler( + chargingStation, + commandName as RequestCommand, + payload, + requestPayload + ) + .then(() => { + resolve(payload) + }) + .catch(reject) + .finally(() => { + chargingStation.requests.delete(messageId) + chargingStation.emit(ChargingStationEvents.updated) + }) + } + + /** + * Function that will receive the request's error response + * + * @param ocppError - + * @param requestStatistic - + */ + const errorCallback = (ocppError: OCPPError, requestStatistic = true): void => { + if (requestStatistic && chargingStation.stationInfo?.enableStatistics === true) { + chargingStation.performanceStatistics?.addRequestStatistic( + commandName, + MessageType.CALL_ERROR_MESSAGE + ) } - const wsClosedOrErrored = - chargingStation.isWebSocketConnectionOpened() === false || sendError === true; - if (wsClosedOrErrored && params.skipBufferingOnError === false) { + logger.error( + `${chargingStation.logPrefix()} Error occurred at ${OCPPServiceUtils.getMessageTypeString( + messageType + )} command ${commandName} with PDU %j:`, + messagePayload, + ocppError + ) + chargingStation.requests.delete(messageId) + chargingStation.emit(ChargingStationEvents.updated) + reject(ocppError) + } + + const handleSendError = (ocppError: OCPPError): void => { + if (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}'`, + chargingStation.bufferMessage(messageToSend) + if (messageType === MessageType.CALL_MESSAGE) { + this.setCachedRequest( + chargingStation, + messageId, + messagePayload as JsonType, commandName, - (messagePayload as JsonObject)?.details ?? {} + responseCallback, + errorCallback ) - ); - } 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 ?? {} - ); - // 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); + } else if ( + params.skipBufferingOnError === true && + messageType === MessageType.CALL_MESSAGE + ) { + // Remove request from the cache + chargingStation.requests.delete(messageId) } + reject(ocppError) + } - /** - * Function that will receive the request's response - * - * @param payload - - * @param requestPayload - - */ - function responseCallback(payload: JsonType, requestPayload: JsonType): void { - if (chargingStation.getEnableStatistics() === true) { - chargingStation.performanceStatistics.addRequestStatistic( + if (chargingStation.stationInfo?.enableStatistics === true) { + chargingStation.performanceStatistics?.addRequestStatistic(commandName, messageType) + } + const messageToSend = this.buildMessageToSend( + chargingStation, + messageId, + messagePayload, + messageType, + commandName + ) + // Check if wsConnection opened + if (chargingStation.isWebSocketConnectionOpened()) { + const beginId = PerformanceStatistics.beginMeasure(commandName) + const sendTimeout = setTimeout(() => { + handleSendError( + new OCPPError( + ErrorType.GENERIC_ERROR, + `Timeout ${formatDurationMilliSeconds( + OCPPConstants.OCPP_WEBSOCKET_TIMEOUT + )} reached for ${ + params.skipBufferingOnError === false ? '' : 'non ' + }buffered message id '${messageId}' with content '${messageToSend}'`, commandName, - MessageType.CALL_RESULT_MESSAGE - ); - } - // Handle the request's response - self.ocppResponseService - .responseHandler( - chargingStation, - commandName as RequestCommand, - payload, - requestPayload + (messagePayload as OCPPError).details + ) + ) + }, OCPPConstants.OCPP_WEBSOCKET_TIMEOUT) + chargingStation.wsConnection?.send(messageToSend, (error?: Error) => { + PerformanceStatistics.endMeasure(commandName, beginId) + clearTimeout(sendTimeout) + if (error == null) { + logger.debug( + `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${OCPPServiceUtils.getMessageTypeString( + messageType + )} payload: ${messageToSend}` + ) + if (messageType === MessageType.CALL_MESSAGE) { + this.setCachedRequest( + chargingStation, + messageId, + messagePayload as JsonType, + commandName, + responseCallback, + errorCallback + ) + } else { + // Resolve response + resolve(messagePayload) + } + } else { + handleSendError( + new OCPPError( + ErrorType.GENERIC_ERROR, + `WebSocket errored for ${ + params.skipBufferingOnError === false ? '' : 'non ' + }buffered message id '${messageId}' with content '${messageToSend}'`, + commandName, + { name: error.name, message: error.message, stack: error.stack } + ) ) - .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 - - */ - function errorCallback(error: OCPPError, requestStatistic = true): void { - if (requestStatistic === true && chargingStation.getEnableStatistics() === true) { - chargingStation.performanceStatistics.addRequestStatistic( - commandName, - MessageType.CALL_ERROR_MESSAGE - ); } - logger.error( - `${chargingStation.logPrefix()} Error occurred at ${self.getMessageTypeString( - messageType - )} command ${commandName} with PDU %j:`, - messagePayload, - error - ); - chargingStation.requests.delete(messageId); - reject(error); - } - }), - Constants.OCPP_WEBSOCKET_TIMEOUT, - new OCPPError( - ErrorType.GENERIC_ERROR, - `Timeout for message id '${messageId}'`, - commandName, - (messagePayload as JsonObject)?.details ?? {} - ), - () => { - messageType === MessageType.CALL_MESSAGE && chargingStation.requests.delete(messageId); + }) + } else { + handleSendError( + new OCPPError( + ErrorType.GENERIC_ERROR, + `WebSocket closed for ${ + params.skipBufferingOnError === false ? '' : 'non ' + }buffered message id '${messageId}' with content '${messageToSend}'`, + commandName, + (messagePayload as OCPPError).details + ) + ) } - ); + }) } throw new OCPPError( ErrorType.SECURITY_ERROR, - `Cannot send command ${commandName} PDU when the charging station is in ${chargingStation.getRegistrationStatus()} state on the central server`, + `Cannot send command ${commandName} PDU when the charging station is in ${chargingStation.bootNotificationResponse?.status} state on the central server`, commandName - ); + ) } - private buildMessageToSend( + private buildMessageToSend ( chargingStation: ChargingStation, messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, - commandName?: RequestCommand | IncomingRequestCommand, - responseCallback?: ResponseCallback, - errorCallback?: ErrorCallback + commandName: RequestCommand | IncomingRequestCommand ): string { - let messageToSend: string; + let messageToSend: string // Type of message switch (messageType) { // Request case MessageType.CALL_MESSAGE: // Build request - chargingStation.requests.set(messageId, [ - responseCallback, - errorCallback, - commandName, - messagePayload as JsonType, - ]); - this.validateRequestPayload(chargingStation, commandName, messagePayload as JsonObject); + this.validateRequestPayload(chargingStation, commandName, messagePayload as JsonType) messageToSend = JSON.stringify([ messageType, messageId, - commandName, - messagePayload, - ] as OutgoingRequest); - break; + commandName as RequestCommand, + messagePayload as JsonType + ] satisfies OutgoingRequest) + break // Response case MessageType.CALL_RESULT_MESSAGE: // Build response this.validateIncomingRequestResponsePayload( chargingStation, commandName, - messagePayload as JsonObject - ); - messageToSend = JSON.stringify([messageType, messageId, messagePayload] as Response); - break; + messagePayload as JsonType + ) + messageToSend = JSON.stringify([ + messageType, + messageId, + messagePayload as JsonType + ] satisfies Response) + break // Error Message case MessageType.CALL_ERROR_MESSAGE: // Build Error Message messageToSend = JSON.stringify([ messageType, messageId, - (messagePayload as OCPPError)?.code ?? ErrorType.GENERIC_ERROR, - (messagePayload as OCPPError)?.message ?? '', - (messagePayload as OCPPError)?.details ?? { commandName }, - ] as ErrorResponse); - break; - } - 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'; + (messagePayload as OCPPError).code, + (messagePayload as OCPPError).message, + (messagePayload as OCPPError).details ?? { + command: (messagePayload as OCPPError).command + } + ] satisfies ErrorResponse) + break } + return messageToSend } - private handleSendMessageError( + private setCachedRequest ( chargingStation: ChargingStation, + messageId: string, + messagePayload: JsonType, commandName: RequestCommand | IncomingRequestCommand, - error: Error, - params: HandleErrorParams = { throwError: false } + responseCallback: ResponseCallback, + errorCallback: ErrorCallback ): void { - logger.error(`${chargingStation.logPrefix()} Request command '${commandName}' error:`, error); - if (params?.throwError === true) { - throw error; - } + chargingStation.requests.set(messageId, [ + responseCallback, + errorCallback, + commandName, + messagePayload + ]) } // eslint-disable-next-line @typescript-eslint/no-unused-vars public abstract requestHandler( chargingStation: ChargingStation, commandName: RequestCommand, - commandParams?: JsonType, + commandParams?: ReqType, params?: RequestParams - ): Promise; + ): Promise }