src/charging-station/ui-server/AbstractUIServer.ts

   1 import { type IncomingMessage, Server, type ServerResponse } from 'node:http'
   2 import { type Http2Server, createServer } from 'node:http2'
   3
   4 import type { WebSocket } from 'ws'
   5
   6 import type { AbstractUIService } from './ui-services/AbstractUIService.js'
   7 import { UIServiceFactory } from './ui-services/UIServiceFactory.js'
   8 import { BaseError } from '../../exception/index.js'
   9 import {
  10   ApplicationProtocolVersion,
  11   AuthenticationType,
  12   type ChargingStationData,
  13   type ProcedureName,
  14   type ProtocolRequest,
  15   type ProtocolResponse,
  16   ProtocolVersion,
  17   type RequestPayload,
  18   type ResponsePayload,
  19   type UIServerConfiguration
  20 } from '../../types/index.js'
  21
  22 export abstract class AbstractUIServer {
  23   public readonly chargingStations: Map<string, ChargingStationData>
  24   public readonly chargingStationTemplates: Set<string>
  25   protected readonly httpServer: Server | Http2Server
  26   protected readonly responseHandlers: Map<string, ServerResponse | WebSocket>
  27   protected readonly uiServices: Map<ProtocolVersion, AbstractUIService>
  28
  29   public constructor (protected readonly uiServerConfiguration: UIServerConfiguration) {
  30     this.chargingStations = new Map<string, ChargingStationData>()
  31     this.chargingStationTemplates = new Set<string>()
  32     switch (this.uiServerConfiguration.version) {
  33       case ApplicationProtocolVersion.VERSION_11:
  34         this.httpServer = new Server()
  35         break
  36       case ApplicationProtocolVersion.VERSION_20:
  37         this.httpServer = createServer()
  38         break
  39       default:
  40         throw new BaseError(
  41           `Unsupported application protocol version ${this.uiServerConfiguration.version}`
  42         )
  43     }
  44     this.responseHandlers = new Map<string, ServerResponse | WebSocket>()
  45     this.uiServices = new Map<ProtocolVersion, AbstractUIService>()
  46   }
  47
  48   public buildProtocolRequest (
  49     id: string,
  50     procedureName: ProcedureName,
  51     requestPayload: RequestPayload
  52   ): ProtocolRequest {
  53     return [id, procedureName, requestPayload]
  54   }
  55
  56   public buildProtocolResponse (id: string, responsePayload: ResponsePayload): ProtocolResponse {
  57     return [id, responsePayload]
  58   }
  59
  60   public stop (): void {
  61     this.stopHttpServer()
  62     for (const uiService of this.uiServices.values()) {
  63       uiService.stop()
  64     }
  65     this.chargingStations.clear()
  66     this.chargingStationTemplates.clear()
  67   }
  68
  69   public async sendInternalRequest (request: ProtocolRequest): Promise<ProtocolResponse> {
  70     const protocolVersion = ProtocolVersion['0.0.1']
  71     this.registerProtocolVersionUIService(protocolVersion)
  72     return await (this.uiServices
  73       .get(protocolVersion)
  74       ?.requestHandler(request) as Promise<ProtocolResponse>)
  75   }
  76
  77   public hasResponseHandler (id: string): boolean {
  78     return this.responseHandlers.has(id)
  79   }
  80
  81   protected startHttpServer (): void {
  82     if (!this.httpServer.listening) {
  83       this.httpServer.listen(this.uiServerConfiguration.options)
  84     }
  85   }
  86
  87   protected registerProtocolVersionUIService (version: ProtocolVersion): void {
  88     if (!this.uiServices.has(version)) {
  89       this.uiServices.set(version, UIServiceFactory.getUIServiceImplementation(version, this))
  90     }
  91   }
  92
  93   protected authenticate (req: IncomingMessage, next: (err?: Error) => void): void {
  94     const authorizationError = new BaseError('Unauthorized')
  95     if (this.isBasicAuthEnabled()) {
  96       if (!this.isValidBasicAuth(req, next)) {
  97         next(authorizationError)
  98       }
  99       next()
 100     } else if (this.isProtocolBasicAuthEnabled()) {
 101       if (!this.isValidProtocolBasicAuth(req, next)) {
 102         next(authorizationError)
 103       }
 104       next()
 105     } else if (this.uiServerConfiguration.authentication?.enabled === true) {
 106       next(authorizationError)
 107     }
 108     next()
 109   }
 110
 111   private stopHttpServer (): void {
 112     if (this.httpServer.listening) {
 113       this.httpServer.close()
 114     }
 115   }
 116
 117   private isBasicAuthEnabled (): boolean {
 118     return (
 119       this.uiServerConfiguration.authentication?.enabled === true &&
 120       this.uiServerConfiguration.authentication.type === AuthenticationType.BASIC_AUTH
 121     )
 122   }
 123
 124   private isProtocolBasicAuthEnabled (): boolean {
 125     return (
 126       this.uiServerConfiguration.authentication?.enabled === true &&
 127       this.uiServerConfiguration.authentication.type === AuthenticationType.PROTOCOL_BASIC_AUTH
 128     )
 129   }
 130
 131   private isValidBasicAuth (req: IncomingMessage, next: (err?: Error) => void): boolean {
 132     const [username, password] = this.getUsernameAndPasswordFromAuthorizationToken(
 133       req.headers.authorization?.split(/\s+/).pop() ?? '',
 134       next
 135     )
 136     return this.isValidUsernameAndPassword(username, password)
 137   }
 138
 139   private isValidProtocolBasicAuth (req: IncomingMessage, next: (err?: Error) => void): boolean {
 140     const authorizationProtocol = req.headers['sec-websocket-protocol']?.split(/,\s+/).pop()
 141     const [username, password] = this.getUsernameAndPasswordFromAuthorizationToken(
 142       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 143       `${authorizationProtocol}${Array(((4 - (authorizationProtocol!.length % 4)) % 4) + 1).join('=')}`
 144         .split('.')
 145         .pop() ?? '',
 146       next
 147     )
 148     return this.isValidUsernameAndPassword(username, password)
 149   }
 150
 151   private getUsernameAndPasswordFromAuthorizationToken (
 152     authorizationToken: string,
 153     next: (err?: Error) => void
 154   ): [string, string] {
 155     if (
 156       !/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/.test(authorizationToken)
 157     ) {
 158       next(new BaseError('Invalid basic authentication token format'))
 159     }
 160     const authentication = Buffer.from(authorizationToken, 'base64').toString()
 161     const authenticationParts = authentication.split(/:/)
 162     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 163     return [authenticationParts.shift()!, authenticationParts.join(':')]
 164   }
 165
 166   private isValidUsernameAndPassword (username: string, password: string): boolean {
 167     return (
 168       this.uiServerConfiguration.authentication?.username === username &&
 169       this.uiServerConfiguration.authentication.password === password
 170     )
 171   }
 172
 173   public abstract start (): void
 174   public abstract sendRequest (request: ProtocolRequest): void
 175   public abstract sendResponse (response: ProtocolResponse): void
 176   public abstract logPrefix (moduleName?: string, methodName?: string, prefixSuffix?: string): string
 177 }