X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FChargingStationWorkerBroadcastChannel.ts;h=8d6cb1c62ac7ff647f1cbbf8a6cf6a240c1520ea;hb=59395dc149654128f2996f4999bccb66270f54e4;hp=7212f09d0cf7b6832f494ddf0fb0925a47bac440;hpb=4e3ff94d15f16cbeb7f65d14525bca7af3c551fd;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ChargingStationWorkerBroadcastChannel.ts b/src/charging-station/ChargingStationWorkerBroadcastChannel.ts index 7212f09d..8d6cb1c6 100644 --- a/src/charging-station/ChargingStationWorkerBroadcastChannel.ts +++ b/src/charging-station/ChargingStationWorkerBroadcastChannel.ts @@ -1,68 +1,409 @@ -import { RequestCommand } from '../types/ocpp/Requests'; +import type ChargingStation from './ChargingStation'; +import { ChargingStationConfigurationUtils } from './ChargingStationConfigurationUtils'; +import { OCPP16ServiceUtils } from './ocpp/1.6/OCPP16ServiceUtils'; +import WorkerBroadcastChannel from './WorkerBroadcastChannel'; +import BaseError from '../exception/BaseError'; +import type OCPPError from '../exception/OCPPError'; +import { StandardParametersKey } from '../types/ocpp/Configuration'; +import { + type BootNotificationRequest, + type DataTransferRequest, + type DiagnosticsStatusNotificationRequest, + type FirmwareStatusNotificationRequest, + type HeartbeatRequest, + type MeterValuesRequest, + RequestCommand, + type RequestParams, + type StatusNotificationRequest, +} from '../types/ocpp/Requests'; import { - StartTransactionRequest, - StartTransactionResponse, - StopTransactionReason, - StopTransactionRequest, - StopTransactionResponse, + type BootNotificationResponse, + type DataTransferResponse, + DataTransferStatus, + type DiagnosticsStatusNotificationResponse, + type FirmwareStatusNotificationResponse, + type HeartbeatResponse, + type MeterValuesResponse, + RegistrationStatusEnumType, + type StatusNotificationResponse, +} from '../types/ocpp/Responses'; +import { + AuthorizationStatus, + type AuthorizeRequest, + type AuthorizeResponse, + type StartTransactionRequest, + type StartTransactionResponse, + type StopTransactionRequest, + type StopTransactionResponse, } from '../types/ocpp/Transaction'; +import { ResponseStatus } from '../types/UIProtocol'; import { BroadcastChannelProcedureName, - BroadcastChannelRequest, + type BroadcastChannelRequest, + type BroadcastChannelRequestPayload, + type BroadcastChannelResponsePayload, + type MessageEvent, } from '../types/WorkerBroadcastChannel'; -import ChargingStation from './ChargingStation'; -import WorkerBroadcastChannel from './WorkerBroadcastChannel'; +import Constants from '../utils/Constants'; +import logger from '../utils/Logger'; +import Utils from '../utils/Utils'; const moduleName = 'ChargingStationWorkerBroadcastChannel'; -type MessageEvent = { data: unknown }; +type CommandResponse = + | StartTransactionResponse + | StopTransactionResponse + | AuthorizeResponse + | BootNotificationResponse + | StatusNotificationResponse + | HeartbeatResponse + | MeterValuesResponse + | DataTransferResponse + | DiagnosticsStatusNotificationResponse + | FirmwareStatusNotificationResponse; + +type CommandHandler = ( + requestPayload?: BroadcastChannelRequestPayload +) => Promise | void; export default class ChargingStationWorkerBroadcastChannel extends WorkerBroadcastChannel { + private readonly commandHandlers: Map; private readonly chargingStation: ChargingStation; constructor(chargingStation: ChargingStation) { super(); + const requestParams: RequestParams = { + throwError: true, + }; + this.commandHandlers = new Map([ + [BroadcastChannelProcedureName.START_CHARGING_STATION, () => this.chargingStation.start()], + [ + BroadcastChannelProcedureName.STOP_CHARGING_STATION, + async () => this.chargingStation.stop(), + ], + [ + BroadcastChannelProcedureName.OPEN_CONNECTION, + () => this.chargingStation.openWSConnection(), + ], + [ + BroadcastChannelProcedureName.CLOSE_CONNECTION, + () => this.chargingStation.closeWSConnection(), + ], + [ + BroadcastChannelProcedureName.START_AUTOMATIC_TRANSACTION_GENERATOR, + (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.startAutomaticTransactionGenerator(requestPayload.connectorIds), + ], + [ + BroadcastChannelProcedureName.STOP_AUTOMATIC_TRANSACTION_GENERATOR, + (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.stopAutomaticTransactionGenerator(requestPayload.connectorIds), + ], + [ + BroadcastChannelProcedureName.START_TRANSACTION, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + StartTransactionRequest, + StartTransactionResponse + >(this.chargingStation, RequestCommand.START_TRANSACTION, requestPayload, requestParams), + ], + [ + BroadcastChannelProcedureName.STOP_TRANSACTION, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + StopTransactionRequest, + StartTransactionResponse + >( + this.chargingStation, + RequestCommand.STOP_TRANSACTION, + { + meterStop: this.chargingStation.getEnergyActiveImportRegisterByTransactionId( + requestPayload.transactionId, + true + ), + ...requestPayload, + }, + requestParams + ), + ], + [ + BroadcastChannelProcedureName.AUTHORIZE, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + AuthorizeRequest, + AuthorizeResponse + >(this.chargingStation, RequestCommand.AUTHORIZE, requestPayload, requestParams), + ], + [ + BroadcastChannelProcedureName.BOOT_NOTIFICATION, + async (requestPayload?: BroadcastChannelRequestPayload) => { + this.chargingStation.bootNotificationResponse = + await this.chargingStation.ocppRequestService.requestHandler< + BootNotificationRequest, + BootNotificationResponse + >( + this.chargingStation, + RequestCommand.BOOT_NOTIFICATION, + { + ...this.chargingStation.bootNotificationRequest, + ...requestPayload, + }, + { + skipBufferingOnError: true, + throwError: true, + } + ); + return this.chargingStation.bootNotificationResponse; + }, + ], + [ + BroadcastChannelProcedureName.STATUS_NOTIFICATION, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + StatusNotificationRequest, + StatusNotificationResponse + >( + this.chargingStation, + RequestCommand.STATUS_NOTIFICATION, + requestPayload, + requestParams + ), + ], + [ + BroadcastChannelProcedureName.HEARTBEAT, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + HeartbeatRequest, + HeartbeatResponse + >(this.chargingStation, RequestCommand.HEARTBEAT, requestPayload, requestParams), + ], + [ + BroadcastChannelProcedureName.METER_VALUES, + async (requestPayload?: BroadcastChannelRequestPayload) => { + const configuredMeterValueSampleInterval = + ChargingStationConfigurationUtils.getConfigurationKey( + chargingStation, + StandardParametersKey.MeterValueSampleInterval + ); + return this.chargingStation.ocppRequestService.requestHandler< + MeterValuesRequest, + MeterValuesResponse + >( + this.chargingStation, + RequestCommand.METER_VALUES, + { + meterValue: [ + // FIXME: Implement OCPP version agnostic helpers + OCPP16ServiceUtils.buildMeterValue( + this.chargingStation, + requestPayload.connectorId, + this.chargingStation.getConnectorStatus(requestPayload.connectorId) + ?.transactionId, + configuredMeterValueSampleInterval + ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000 + : Constants.DEFAULT_METER_VALUES_INTERVAL + ), + ], + ...requestPayload, + }, + requestParams + ); + }, + ], + [ + BroadcastChannelProcedureName.DATA_TRANSFER, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + DataTransferRequest, + DataTransferResponse + >(this.chargingStation, RequestCommand.DATA_TRANSFER, requestPayload, requestParams), + ], + [ + BroadcastChannelProcedureName.DIAGNOSTICS_STATUS_NOTIFICATION, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + DiagnosticsStatusNotificationRequest, + DiagnosticsStatusNotificationResponse + >( + this.chargingStation, + RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, + requestPayload, + requestParams + ), + ], + [ + BroadcastChannelProcedureName.FIRMWARE_STATUS_NOTIFICATION, + async (requestPayload?: BroadcastChannelRequestPayload) => + this.chargingStation.ocppRequestService.requestHandler< + FirmwareStatusNotificationRequest, + FirmwareStatusNotificationResponse + >( + this.chargingStation, + RequestCommand.FIRMWARE_STATUS_NOTIFICATION, + requestPayload, + requestParams + ), + ], + ]); this.chargingStation = chargingStation; - this.onmessage = this.handleRequest.bind(this) as (message: MessageEvent) => void; + this.onmessage = this.requestHandler.bind(this) as (message: MessageEvent) => void; + this.onmessageerror = this.messageErrorHandler.bind(this) as (message: MessageEvent) => void; } - private async handleRequest(messageEvent: MessageEvent): Promise { - const [, command, payload] = messageEvent.data as BroadcastChannelRequest; - - if (payload.hashId !== this.chargingStation.hashId) { + private async requestHandler(messageEvent: MessageEvent): Promise { + const validatedMessageEvent = this.validateMessageEvent(messageEvent); + if (validatedMessageEvent === false) { + return; + } + if (this.isResponse(validatedMessageEvent.data) === true) { return; } + const [uuid, command, requestPayload] = validatedMessageEvent.data as BroadcastChannelRequest; + if ( + requestPayload?.hashIds !== undefined && + requestPayload?.hashIds?.includes(this.chargingStation.stationInfo.hashId) === false + ) { + return; + } + if (requestPayload?.hashId !== undefined) { + logger.error( + `${this.chargingStation.logPrefix()} ${moduleName}.requestHandler: 'hashId' field usage in PDU is deprecated, use 'hashIds' array instead` + ); + return; + } + let responsePayload: BroadcastChannelResponsePayload; + let commandResponse: CommandResponse | void; + try { + commandResponse = await this.commandHandler(command, requestPayload); + if ( + commandResponse === undefined || + commandResponse === null || + Utils.isEmptyObject(commandResponse as CommandResponse) + ) { + responsePayload = { + hashId: this.chargingStation.stationInfo.hashId, + status: ResponseStatus.SUCCESS, + }; + } else { + responsePayload = this.commandResponseToResponsePayload( + command, + requestPayload, + commandResponse as CommandResponse + ); + } + } catch (error) { + logger.error( + `${this.chargingStation.logPrefix()} ${moduleName}.requestHandler: Handle request error:`, + error + ); + responsePayload = { + hashId: this.chargingStation.stationInfo.hashId, + status: ResponseStatus.FAILURE, + command, + requestPayload, + commandResponse: commandResponse as CommandResponse, + errorMessage: (error as Error).message, + errorStack: (error as Error).stack, + errorDetails: (error as OCPPError).details, + }; + } finally { + this.sendResponse([uuid, responsePayload]); + } + } + + private messageErrorHandler(messageEvent: MessageEvent): void { + logger.error( + `${this.chargingStation.logPrefix()} ${moduleName}.messageErrorHandler: Error at handling message:`, + messageEvent + ); + } + + private async commandHandler( + command: BroadcastChannelProcedureName, + requestPayload: BroadcastChannelRequestPayload + ): Promise { + if (this.commandHandlers.has(command) === true) { + this.cleanRequestPayload(command, requestPayload); + return this.commandHandlers.get(command)(requestPayload); + } + throw new BaseError(`Unknown worker broadcast channel command: ${command}`); + } + + private cleanRequestPayload( + command: BroadcastChannelProcedureName, + requestPayload: BroadcastChannelRequestPayload + ): void { + delete requestPayload.hashId; + delete requestPayload.hashIds; + [ + BroadcastChannelProcedureName.START_AUTOMATIC_TRANSACTION_GENERATOR, + BroadcastChannelProcedureName.STOP_AUTOMATIC_TRANSACTION_GENERATOR, + ].includes(command) === false && delete requestPayload.connectorIds; + } - // TODO: return a response stating the command success or failure + private commandResponseToResponsePayload( + command: BroadcastChannelProcedureName, + requestPayload: BroadcastChannelRequestPayload, + commandResponse: CommandResponse + ): BroadcastChannelResponsePayload { + const responseStatus = this.commandResponseToResponseStatus(command, commandResponse); + if (responseStatus === ResponseStatus.SUCCESS) { + return { + hashId: this.chargingStation.stationInfo.hashId, + status: responseStatus, + }; + } + return { + hashId: this.chargingStation.stationInfo.hashId, + status: responseStatus, + command, + requestPayload, + commandResponse, + }; + } + + private commandResponseToResponseStatus( + command: BroadcastChannelProcedureName, + commandResponse: CommandResponse + ): ResponseStatus { switch (command) { case BroadcastChannelProcedureName.START_TRANSACTION: - await this.chargingStation.ocppRequestService.requestHandler< - StartTransactionRequest, - StartTransactionResponse - >(this.chargingStation, RequestCommand.START_TRANSACTION, { - connectorId: payload.connectorId, - idTag: payload.idTag, - }); - break; case BroadcastChannelProcedureName.STOP_TRANSACTION: - await this.chargingStation.ocppRequestService.requestHandler< - StopTransactionRequest, - StopTransactionResponse - >(this.chargingStation, RequestCommand.STOP_TRANSACTION, { - transactionId: payload.transactionId, - meterStop: this.chargingStation.getEnergyActiveImportRegisterByTransactionId( - payload.transactionId - ), - idTag: this.chargingStation.getTransactionIdTag(payload.transactionId), - reason: StopTransactionReason.NONE, - }); - break; - case BroadcastChannelProcedureName.START_CHARGING_STATION: - this.chargingStation.start(); - break; - case BroadcastChannelProcedureName.STOP_CHARGING_STATION: - await this.chargingStation.stop(); - break; + case BroadcastChannelProcedureName.AUTHORIZE: + if ( + ( + commandResponse as + | StartTransactionResponse + | StopTransactionResponse + | AuthorizeResponse + )?.idTagInfo?.status === AuthorizationStatus.ACCEPTED + ) { + return ResponseStatus.SUCCESS; + } + return ResponseStatus.FAILURE; + case BroadcastChannelProcedureName.BOOT_NOTIFICATION: + if (commandResponse?.status === RegistrationStatusEnumType.ACCEPTED) { + return ResponseStatus.SUCCESS; + } + return ResponseStatus.FAILURE; + case BroadcastChannelProcedureName.DATA_TRANSFER: + if (commandResponse?.status === DataTransferStatus.ACCEPTED) { + return ResponseStatus.SUCCESS; + } + return ResponseStatus.FAILURE; + case BroadcastChannelProcedureName.STATUS_NOTIFICATION: + case BroadcastChannelProcedureName.METER_VALUES: + if (Utils.isEmptyObject(commandResponse) === true) { + return ResponseStatus.SUCCESS; + } + return ResponseStatus.FAILURE; + case BroadcastChannelProcedureName.HEARTBEAT: + if ('currentTime' in commandResponse) { + return ResponseStatus.SUCCESS; + } + return ResponseStatus.FAILURE; + default: + return ResponseStatus.FAILURE; } } }