X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=b29c0451a968d916dae04f87abe2bf17427cbcff;hb=e58068fde9b27e3de6733be24fc7b3dfac37331b;hp=1e9df7cadd97458218d7117d1b8f51c4bd607b6f;hpb=9292e32a92f3ef63ee5a3cf86dc497b8acae5d2d;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts
index 1e9df7ca..b29c0451 100644
--- a/src/charging-station/ocpp/OCPPRequestService.ts
+++ b/src/charging-station/ocpp/OCPPRequestService.ts
@@ -9,9 +9,10 @@ import Constants from '../../utils/Constants';
 import { ErrorType } from '../../types/ocpp/ErrorType';
 import { MessageType } from '../../types/ocpp/MessageType';
 import { MeterValue } from '../../types/ocpp/MeterValues';
-import OCPPError from './OCPPError';
+import OCPPError from '../../exception/OCPPError';
 import OCPPResponseService from './OCPPResponseService';
 import PerformanceStatistics from '../../performance/PerformanceStatistics';
+import Utils from '../../utils/Utils';
 import logger from '../../utils/Logger';
 
 export default abstract class OCPPRequestService {
@@ -23,32 +24,13 @@ export default abstract class OCPPRequestService {
     this.ocppResponseService = ocppResponseService;
   }
 
-  public async sendMessage(messageId: string, commandParams: any, messageType: MessageType, commandName: RequestCommand | IncomingRequestCommand,
+  public async sendMessage(messageId: string, messageData: any, messageType: MessageType, commandName: RequestCommand | IncomingRequestCommand,
       skipBufferingOnError = false): Promise<unknown> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     // Send a message through wsConnection
-    return new Promise((resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => {
-      let messageToSend: string;
-      // Type of message
-      switch (messageType) {
-        // Request
-        case MessageType.CALL_MESSAGE:
-          // Build request
-          this.chargingStation.requests[messageId] = [responseCallback, rejectCallback, commandParams as Record<string, unknown>];
-          messageToSend = JSON.stringify([messageType, messageId, commandName, commandParams]);
-          break;
-        // Response
-        case MessageType.CALL_RESULT_MESSAGE:
-          // Build response
-          messageToSend = JSON.stringify([messageType, messageId, commandParams]);
-          break;
-        // Error Message
-        case MessageType.CALL_ERROR_MESSAGE:
-          // Build Error Message
-          messageToSend = JSON.stringify([messageType, messageId, commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : '', commandParams.details ? commandParams.details : {}]);
-          break;
-      }
+    return Utils.promiseWithTimeout(new Promise((resolve, reject) => {
+      const messageToSend = this.buildMessageToSend(messageId, messageData, messageType, commandName, responseCallback, rejectCallback);
       if (this.chargingStation.getEnableStatistics()) {
         this.chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType);
       }
@@ -56,21 +38,26 @@ export default abstract class OCPPRequestService {
       if (this.chargingStation.isWebSocketConnectionOpened()) {
         // Yes: Send Message
         const beginId = PerformanceStatistics.beginMeasure(commandName);
+        // FIXME: Handle sending error
         this.chargingStation.wsConnection.send(messageToSend);
         PerformanceStatistics.endMeasure(commandName, beginId);
       } else if (!skipBufferingOnError) {
         // Buffer it
-        this.chargingStation.addToMessageQueue(messageToSend);
+        this.chargingStation.bufferMessage(messageToSend);
+        const ocppError = new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`, messageData?.details ?? {});
+        if (messageType === MessageType.CALL_MESSAGE) {
+          // Reject it but keep the request in the cache
+          return reject(ocppError);
+        }
+        return rejectCallback(ocppError, false);
+      } else {
         // Reject it
-        return rejectCallback(new OCPPError(commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : `WebSocket closed for message id '${messageId}' with content '${messageToSend}', message buffered`, commandParams.details ? commandParams.details : {}));
+        return rejectCallback(new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`, messageData?.details ?? {}), false);
       }
       // Response?
-      if (messageType === MessageType.CALL_RESULT_MESSAGE) {
+      if (messageType !== MessageType.CALL_MESSAGE) {
         // Yes: send Ok
-        resolve();
-      } else if (messageType === MessageType.CALL_ERROR_MESSAGE) {
-        // Send timeout
-        setTimeout(() => rejectCallback(new OCPPError(commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : `Timeout for message id '${messageId}' with content '${messageToSend}'`, commandParams.details ? commandParams.details : {})), Constants.OCPP_ERROR_TIMEOUT);
+        return resolve(messageData);
       }
 
       /**
@@ -83,27 +70,34 @@ export default abstract class OCPPRequestService {
         if (self.chargingStation.getEnableStatistics()) {
           self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_RESULT_MESSAGE);
         }
-        // Send the response
-        await self.ocppResponseService.handleResponse(commandName as RequestCommand, payload, requestPayload);
-        resolve(payload);
+        // Handle the request's response
+        try {
+          await self.ocppResponseService.handleResponse(commandName as RequestCommand, payload, requestPayload);
+          resolve(payload);
+        } catch (error) {
+          reject(error);
+          throw error;
+        } finally {
+          self.chargingStation.requests.delete(messageId);
+        }
       }
 
       /**
-       * Function that will receive the request's rejection
+       * Function that will receive the request's error response
        *
        * @param error
+       * @param requestStatistic
        */
-      function rejectCallback(error: OCPPError): void {
-        if (self.chargingStation.getEnableStatistics()) {
+      function rejectCallback(error: OCPPError, requestStatistic = true): void {
+        if (requestStatistic && self.chargingStation.getEnableStatistics()) {
           self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_ERROR_MESSAGE);
         }
-        logger.debug(`${self.chargingStation.logPrefix()} Error: %j occurred when calling command %s with parameters: %j`, error, commandName, commandParams);
-        // Build Exception
-        // eslint-disable-next-line no-empty-function
-        self.chargingStation.requests[messageId] = [() => { }, () => { }, {}];
-        // Send error
+        logger.error(`${self.chargingStation.logPrefix()} Error %j occurred when calling command %s with message data %j`, error, commandName, messageData);
+        self.chargingStation.requests.delete(messageId);
         reject(error);
       }
+    }), Constants.OCPP_WEBSOCKET_TIMEOUT, new OCPPError(ErrorType.GENERIC_ERROR, `Timeout for message id '${messageId}'`, messageData?.details ?? {}), () => {
+      messageType === MessageType.CALL_MESSAGE && this.chargingStation.requests.delete(messageId);
     });
   }
 
@@ -112,6 +106,32 @@ export default abstract class OCPPRequestService {
     throw error;
   }
 
+  private buildMessageToSend(messageId: string, messageData: Record<string, unknown>, messageType: MessageType, commandName: RequestCommand | IncomingRequestCommand,
+      responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => Promise<void>,
+      rejectCallback: (error: OCPPError, requestStatistic?: boolean) => void): string {
+    let messageToSend: string;
+    // Type of message
+    switch (messageType) {
+      // Request
+      case MessageType.CALL_MESSAGE:
+        // Build request
+        this.chargingStation.requests.set(messageId, [responseCallback, rejectCallback, commandName, messageData]);
+        messageToSend = JSON.stringify([messageType, messageId, commandName, messageData]);
+        break;
+      // Response
+      case MessageType.CALL_RESULT_MESSAGE:
+        // Build response
+        messageToSend = JSON.stringify([messageType, messageId, messageData]);
+        break;
+      // Error Message
+      case MessageType.CALL_ERROR_MESSAGE:
+        // Build Error Message
+        messageToSend = JSON.stringify([messageType, messageId, messageData?.code ?? ErrorType.GENERIC_ERROR, messageData?.message ?? '', messageData?.details ?? {}]);
+        break;
+    }
+    return messageToSend;
+  }
+
   public abstract sendHeartbeat(): Promise<void>;
   public abstract sendBootNotification(chargePointModel: string, chargePointVendor: string, chargeBoxSerialNumber?: string, firmwareVersion?: string, chargePointSerialNumber?: string, iccid?: string, imsi?: string, meterSerialNumber?: string, meterType?: string): Promise<BootNotificationResponse>;
   public abstract sendStatusNotification(connectorId: number, status: ChargePointStatus, errorCode?: ChargePointErrorCode): Promise<void>;
@@ -122,5 +142,6 @@ export default abstract class OCPPRequestService {
   public abstract sendTransactionBeginMeterValues(connectorId: number, transactionId: number, beginMeterValue: MeterValue): Promise<void>;
   public abstract sendTransactionEndMeterValues(connectorId: number, transactionId: number, endMeterValue: MeterValue): Promise<void>;
   public abstract sendDiagnosticsStatusNotification(diagnosticsStatus: DiagnosticsStatus): Promise<void>;
+  public abstract sendResult(messageId: string, resultMessageData: Record<string, unknown>, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown>;
   public abstract sendError(messageId: string, error: OCPPError, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown>;
 }