X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=9fa50b4f2f53a7dc7f2b6f982208f4441451d87f;hb=875e9541d6c760511b03a401d2cf18997d2855ce;hp=fc465b8c3e8ac784d025f44e7fa1cd146bc2995d;hpb=100680888f3b49453ddb4081988a480ee3030d07;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts index fc465b8c..9fa50b4f 100644 --- a/src/charging-station/ocpp/OCPPRequestService.ts +++ b/src/charging-station/ocpp/OCPPRequestService.ts @@ -1,112 +1,115 @@ +import type { JSONSchemaType } from 'ajv'; +import Ajv from 'ajv-draft-04'; +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 { - AuthorizeResponse, - StartTransactionResponse, - StopTransactionReason, - StopTransactionResponse, -} from '../../types/ocpp/Transaction'; -import { - DiagnosticsStatus, IncomingRequestCommand, + OutgoingRequest, RequestCommand, + RequestParams, ResponseType, - SendParams, } from '../../types/ocpp/Requests'; - -import { BootNotificationResponse } from '../../types/ocpp/Responses'; -import { ChargePointErrorCode } from '../../types/ocpp/ChargePointErrorCode'; -import { ChargePointStatus } from '../../types/ocpp/ChargePointStatus'; -import type ChargingStation from '../ChargingStation'; +import type { ErrorResponse, Response } from '../../types/ocpp/Responses'; import Constants from '../../utils/Constants'; -import { EmptyObject } from '../../types/EmptyObject'; -import { ErrorType } from '../../types/ocpp/ErrorType'; -import { HandleErrorParams } from '../../types/Error'; -import { JsonType } from '../../types/JsonType'; -import { MessageType } from '../../types/ocpp/MessageType'; -import { MeterValue } from '../../types/ocpp/MeterValues'; -import OCPPError from '../../exception/OCPPError'; -import type OCPPResponseService from './OCPPResponseService'; -import PerformanceStatistics from '../../performance/PerformanceStatistics'; -import Utils from '../../utils/Utils'; import logger from '../../utils/Logger'; +import Utils from '../../utils/Utils'; +import type ChargingStation from '../ChargingStation'; +import type OCPPResponseService from './OCPPResponseService'; +import { OCPPServiceUtils } from './OCPPServiceUtils'; + +const moduleName = 'OCPPRequestService'; export default abstract class OCPPRequestService { - private static readonly instances: Map = new Map< - string, - OCPPRequestService - >(); + private static instance: OCPPRequestService | null = null; + private readonly ajv: Ajv; - protected readonly chargingStation: ChargingStation; private readonly ocppResponseService: OCPPResponseService; - protected constructor( - chargingStation: ChargingStation, - ocppResponseService: OCPPResponseService - ) { - this.chargingStation = chargingStation; + protected constructor(ocppResponseService: OCPPResponseService) { this.ocppResponseService = ocppResponseService; + this.ajv = new Ajv(); + ajvFormats(this.ajv); + 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); } public static getInstance( - this: new (chargingStation: ChargingStation, ocppResponseService: OCPPResponseService) => T, - chargingStation: ChargingStation, + this: new (ocppResponseService: OCPPResponseService) => T, ocppResponseService: OCPPResponseService ): T { - if (!OCPPRequestService.instances.has(chargingStation.id)) { - OCPPRequestService.instances.set( - chargingStation.id, - new this(chargingStation, ocppResponseService) - ); + if (OCPPRequestService.instance === null) { + OCPPRequestService.instance = new this(ocppResponseService); } - return OCPPRequestService.instances.get(chargingStation.id) as T; + return OCPPRequestService.instance as T; } - public async sendResult( + public async sendResponse( + chargingStation: ChargingStation, messageId: string, messagePayload: JsonType, commandName: IncomingRequestCommand ): Promise { try { - // Send result message + // Send response message return await this.internalSendMessage( + chargingStation, messageId, messagePayload, MessageType.CALL_RESULT_MESSAGE, commandName ); } catch (error) { - this.handleRequestError(commandName, error as Error); + this.handleSendMessageError(chargingStation, commandName, error as Error, { + throwError: true, + }); } } public async sendError( + chargingStation: ChargingStation, messageId: string, ocppError: OCPPError, - commandName: IncomingRequestCommand + commandName: RequestCommand | IncomingRequestCommand ): Promise { try { // Send error message return await this.internalSendMessage( + chargingStation, messageId, ocppError, MessageType.CALL_ERROR_MESSAGE, commandName ); } catch (error) { - this.handleRequestError(commandName, error as Error); + this.handleSendMessageError(chargingStation, commandName, error as Error); } } protected async sendMessage( + chargingStation: ChargingStation, messageId: string, messagePayload: JsonType, commandName: RequestCommand, - params: SendParams = { + params: RequestParams = { skipBufferingOnError: false, triggerMessage: false, } ): Promise { try { return await this.internalSendMessage( + chargingStation, messageId, messagePayload, MessageType.CALL_MESSAGE, @@ -114,27 +117,53 @@ export default abstract class OCPPRequestService { params ); } catch (error) { - this.handleRequestError(commandName, error as Error, { throwError: false }); + this.handleSendMessageError(chargingStation, commandName, error as Error); } } + protected validateRequestPayload( + chargingStation: ChargingStation, + commandName: RequestCommand, + schema: JSONSchemaType, + payload: T + ): boolean { + if (chargingStation.getPayloadSchemaValidation() === false) { + return true; + } + const validate = this.ajv.compile(schema); + if (validate(payload)) { + return true; + } + logger.error( + `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: 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( + OCPPServiceUtils.ajvErrorsToErrorType(validate.errors), + 'Request 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, - params: SendParams = { + params: RequestParams = { skipBufferingOnError: false, triggerMessage: false, } ): Promise { if ( - (this.chargingStation.isInUnknownState() && - commandName === RequestCommand.BOOT_NOTIFICATION) || - (!this.chargingStation.getOcppStrictCompliance() && - this.chargingStation.isInUnknownState()) || - this.chargingStation.isInAcceptedState() || - (this.chargingStation.isInPendingState() && params.triggerMessage) + (chargingStation.isInUnknownState() && commandName === RequestCommand.BOOT_NOTIFICATION) || + (!chargingStation.getOcppStrictCompliance() && chargingStation.isInUnknownState()) || + chargingStation.isInAcceptedState() || + (chargingStation.isInPendingState() && + (params.triggerMessage || messageType === MessageType.CALL_RESULT_MESSAGE)) ) { // eslint-disable-next-line @typescript-eslint/no-this-alias const self = this; @@ -142,48 +171,51 @@ export default abstract class OCPPRequestService { return Utils.promiseWithTimeout( new Promise((resolve, reject) => { const messageToSend = this.buildMessageToSend( + chargingStation, messageId, messagePayload, messageType, commandName, responseCallback, - rejectCallback + errorCallback ); - if (this.chargingStation.getEnableStatistics()) { - this.chargingStation.performanceStatistics.addRequestStatistic( - commandName, - messageType - ); + if (chargingStation.getEnableStatistics() === true) { + chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType); } // Check if wsConnection opened - if (this.chargingStation.isWebSocketConnectionOpened()) { + if (chargingStation.isWebSocketConnectionOpened() === true) { // Yes: Send Message const beginId = PerformanceStatistics.beginMeasure(commandName); // FIXME: Handle sending error - this.chargingStation.wsConnection.send(messageToSend); + chargingStation.wsConnection.send(messageToSend); PerformanceStatistics.endMeasure(commandName, beginId); - } else if (!params.skipBufferingOnError) { + logger.debug( + `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${this.getMessageTypeString( + messageType + )} payload: ${messageToSend}` + ); + } else if (params.skipBufferingOnError === false) { // Buffer it - this.chargingStation.bufferMessage(messageToSend); + chargingStation.bufferMessage(messageToSend); const ocppError = new OCPPError( ErrorType.GENERIC_ERROR, `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`, commandName, - (messagePayload?.details as JsonType) ?? {} + (messagePayload as JsonObject)?.details ?? {} ); if (messageType === MessageType.CALL_MESSAGE) { // Reject it but keep the request in the cache return reject(ocppError); } - return rejectCallback(ocppError, false); + return errorCallback(ocppError, false); } else { // Reject it - return rejectCallback( + return errorCallback( new OCPPError( ErrorType.GENERIC_ERROR, `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`, commandName, - (messagePayload?.details as JsonType) ?? {} + (messagePayload as JsonObject)?.details ?? {} ), false ); @@ -201,18 +233,19 @@ export default abstract class OCPPRequestService { * @param requestPayload */ async function responseCallback( - payload: JsonType | string, + payload: JsonType, requestPayload: JsonType ): Promise { - if (self.chargingStation.getEnableStatistics()) { - self.chargingStation.performanceStatistics.addRequestStatistic( + if (chargingStation.getEnableStatistics() === true) { + chargingStation.performanceStatistics.addRequestStatistic( commandName, MessageType.CALL_RESULT_MESSAGE ); } // Handle the request's response try { - await self.ocppResponseService.handleResponse( + await self.ocppResponseService.responseHandler( + chargingStation, commandName as RequestCommand, payload, requestPayload @@ -220,9 +253,8 @@ export default abstract class OCPPRequestService { resolve(payload); } catch (error) { reject(error); - throw error; } finally { - self.chargingStation.requests.delete(messageId); + chargingStation.requests.delete(messageId); } } @@ -232,20 +264,20 @@ export default abstract class OCPPRequestService { * @param error * @param requestStatistic */ - function rejectCallback(error: OCPPError, requestStatistic = true): void { - if (requestStatistic && self.chargingStation.getEnableStatistics()) { - self.chargingStation.performanceStatistics.addRequestStatistic( + function errorCallback(error: OCPPError, requestStatistic = true): void { + if (requestStatistic === true && chargingStation.getEnableStatistics() === true) { + chargingStation.performanceStatistics.addRequestStatistic( commandName, MessageType.CALL_ERROR_MESSAGE ); } logger.error( - `${self.chargingStation.logPrefix()} Error %j occurred when calling command %s with message data %j`, - error, - commandName, - messagePayload + `${chargingStation.logPrefix()} Error occurred when calling command ${commandName} with message data ${JSON.stringify( + messagePayload + )}:`, + error ); - self.chargingStation.requests.delete(messageId); + chargingStation.requests.delete(messageId); reject(error); } }), @@ -254,28 +286,28 @@ export default abstract class OCPPRequestService { ErrorType.GENERIC_ERROR, `Timeout for message id '${messageId}'`, commandName, - (messagePayload?.details as JsonType) ?? {} + (messagePayload as JsonObject)?.details ?? {} ), () => { - messageType === MessageType.CALL_MESSAGE && - this.chargingStation.requests.delete(messageId); + messageType === MessageType.CALL_MESSAGE && chargingStation.requests.delete(messageId); } ); } throw new OCPPError( ErrorType.SECURITY_ERROR, - `Cannot send command ${commandName} payload when the charging station is in ${this.chargingStation.getRegistrationStatus()} state on the central server`, + `Cannot send command ${commandName} PDU when the charging station is in ${chargingStation.getRegistrationStatus()} state on the central server`, commandName ); } private buildMessageToSend( + chargingStation: ChargingStation, messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, commandName?: RequestCommand | IncomingRequestCommand, - responseCallback?: (payload: JsonType | string, requestPayload: JsonType) => Promise, - rejectCallback?: (error: OCPPError, requestStatistic?: boolean) => void + responseCallback?: (payload: JsonType, requestPayload: JsonType) => Promise, + errorCallback?: (error: OCPPError, requestStatistic?: boolean) => void ): string { let messageToSend: string; // Type of message @@ -283,18 +315,23 @@ export default abstract class OCPPRequestService { // Request case MessageType.CALL_MESSAGE: // Build request - this.chargingStation.requests.set(messageId, [ + chargingStation.requests.set(messageId, [ responseCallback, - rejectCallback, + errorCallback, commandName, - messagePayload, + messagePayload as JsonType, ]); - messageToSend = JSON.stringify([messageType, messageId, commandName, messagePayload]); + messageToSend = JSON.stringify([ + messageType, + messageId, + commandName, + messagePayload, + ] as OutgoingRequest); break; // Response case MessageType.CALL_RESULT_MESSAGE: // Build response - messageToSend = JSON.stringify([messageType, messageId, messagePayload]); + messageToSend = JSON.stringify([messageType, messageId, messagePayload] as Response); break; // Error Message case MessageType.CALL_ERROR_MESSAGE: @@ -302,82 +339,43 @@ export default abstract class OCPPRequestService { messageToSend = JSON.stringify([ messageType, messageId, - messagePayload?.code ?? ErrorType.GENERIC_ERROR, - messagePayload?.message ?? '', - messagePayload?.details ?? { commandName }, - ]); + (messagePayload as OCPPError)?.code ?? ErrorType.GENERIC_ERROR, + (messagePayload as OCPPError)?.message ?? '', + (messagePayload as OCPPError)?.details ?? { commandName }, + ] as ErrorResponse); break; } return messageToSend; } - private handleRequestError( + 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, error: Error, - params: HandleErrorParams = { throwError: true } + params: HandleErrorParams = { throwError: false } ): void { - logger.error( - this.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; } } - public abstract sendHeartbeat(params?: SendParams): Promise; - public abstract sendBootNotification( - chargePointModel: string, - chargePointVendor: string, - chargeBoxSerialNumber?: string, - firmwareVersion?: string, - chargePointSerialNumber?: string, - iccid?: string, - imsi?: string, - meterSerialNumber?: string, - meterType?: string, - params?: SendParams - ): Promise; - - public abstract sendStatusNotification( - connectorId: number, - status: ChargePointStatus, - errorCode?: ChargePointErrorCode - ): Promise; - - public abstract sendAuthorize(connectorId: number, idTag?: string): Promise; - public abstract sendStartTransaction( - connectorId: number, - idTag?: string - ): Promise; - - public abstract sendStopTransaction( - transactionId: number, - meterStop: number, - idTag?: string, - reason?: StopTransactionReason - ): Promise; - - public abstract sendMeterValues( - connectorId: number, - transactionId: number, - interval: number - ): Promise; - - public abstract sendTransactionBeginMeterValues( - connectorId: number, - transactionId: number, - beginMeterValue: MeterValue - ): Promise; - - public abstract sendTransactionEndMeterValues( - connectorId: number, - transactionId: number, - endMeterValue: MeterValue - ): Promise; - - public abstract sendDiagnosticsStatusNotification( - diagnosticsStatus: DiagnosticsStatus - ): Promise; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + public abstract requestHandler( + chargingStation: ChargingStation, + commandName: RequestCommand, + commandParams?: JsonType, + params?: RequestParams + ): Promise; }