src/charging-station/UIWebSocketServer.ts

   1 import { Protocol, ProtocolCommand, ProtocolRequest, ProtocolVersion } from '../types/UIProtocol';
   2 import WebSocket, { OPEN, Server, ServerOptions } from 'ws';
   3
   4 import AbstractUIService from './ui-websocket-services/AbstractUIService';
   5 import BaseError from '../exception/BaseError';
   6 import Configuration from '../utils/Configuration';
   7 import { IncomingMessage } from 'http';
   8 import UIServiceFactory from './ui-websocket-services/UIServiceFactory';
   9 import Utils from '../utils/Utils';
  10 import logger from '../utils/Logger';
  11
  12 export default class UIWebSocketServer extends Server {
  13   public readonly chargingStations: Set<string>;
  14   public readonly uiServices: Map<ProtocolVersion, AbstractUIService>;
  15
  16   public constructor(options?: ServerOptions, callback?: () => void) {
  17     // Create the WebSocket Server
  18     super(options ?? Configuration.getUIWebSocketServer().options, callback);
  19     this.chargingStations = new Set<string>();
  20     this.uiServices = new Map<ProtocolVersion, AbstractUIService>();
  21     for (const version of Object.values(ProtocolVersion)) {
  22       this.uiServices.set(version, UIServiceFactory.getUIServiceImplementation(version, this));
  23     }
  24   }
  25
  26   public broadcastToClients(message: string): void {
  27     for (const client of this.clients) {
  28       if (client?.readyState === OPEN) {
  29         client.send(message);
  30       }
  31     }
  32   }
  33
  34   public start(): void {
  35     this.on('connection', (socket: WebSocket, request: IncomingMessage): void => {
  36       const protocolIndex = socket.protocol.indexOf(Protocol.UI);
  37       const version = socket.protocol.substring(
  38         protocolIndex + Protocol.UI.length
  39       ) as ProtocolVersion;
  40       if (!this.uiServices.has(version)) {
  41         throw new BaseError(
  42           `Could not find a UI service implementation for UI protocol version ${version}`
  43         );
  44       }
  45       // FIXME: check connection validity
  46       socket.on('message', (messageData) => {
  47         let [command, payload]: ProtocolRequest = [ProtocolCommand.UNKNOWN, {}];
  48         const protocolRequest = JSON.parse(messageData.toString()) as ProtocolRequest;
  49         if (Utils.isIterable(protocolRequest)) {
  50           [command, payload] = protocolRequest;
  51         } else {
  52           throw new BaseError('UI protocol request is not iterable');
  53         }
  54         this.uiServices
  55           .get(version)
  56           .handleMessage(command, payload)
  57           .catch(() => {
  58             logger.error(
  59               `${this.logPrefix()} Error while handling command %s message: %j`,
  60               command,
  61               payload
  62             );
  63           });
  64       });
  65       socket.on('error', (error) => {
  66         logger.error(`${this.logPrefix()} Error on WebSocket: %j`, error);
  67       });
  68     });
  69   }
  70
  71   public stop(): void {
  72     this.close();
  73   }
  74
  75   public logPrefix(): string {
  76     return Utils.logPrefix(' UI WebSocket Server:');
  77   }
  78 }