src/charging-station/IdTagsCache.ts

   1 import fs from 'node:fs';
   2
   3 import type { ChargingStation } from './ChargingStation';
   4 import { ChargingStationUtils } from './ChargingStationUtils';
   5 import { FileType, IdTagDistribution } from '../types';
   6 import { Utils, handleFileException, logger, watchJsonFile } from '../utils';
   7
   8 type IdTagsCacheValueType = {
   9   idTags: string[];
  10   idTagsFileWatcher: fs.FSWatcher | undefined;
  11 };
  12
  13 export class IdTagsCache {
  14   private static instance: IdTagsCache | null = null;
  15   private readonly idTagsCaches: Map<string, IdTagsCacheValueType>;
  16   private readonly idTagsCachesAddressableIndexes: Map<string, number>;
  17
  18   private constructor() {
  19     this.idTagsCaches = new Map<string, IdTagsCacheValueType>();
  20     this.idTagsCachesAddressableIndexes = new Map<string, number>();
  21   }
  22
  23   public static getInstance(): IdTagsCache {
  24     if (IdTagsCache.instance === null) {
  25       IdTagsCache.instance = new IdTagsCache();
  26     }
  27     return IdTagsCache.instance;
  28   }
  29
  30   /**
  31    * Gets one idtag from the cache given the distribution
  32    * Must be called after checking the cache is not an empty array
  33    *
  34    * @param distribution -
  35    * @param chargingStation -
  36    * @param connectorId -
  37    * @returns
  38    */
  39   public getIdTag(
  40     distribution: IdTagDistribution,
  41     chargingStation: ChargingStation,
  42     connectorId: number
  43   ): string {
  44     const hashId = chargingStation.stationInfo.hashId;
  45     const idTagsFile = ChargingStationUtils.getIdTagsFile(chargingStation.stationInfo);
  46     switch (distribution) {
  47       case IdTagDistribution.RANDOM:
  48         return this.getRandomIdTag(hashId, idTagsFile);
  49       case IdTagDistribution.ROUND_ROBIN:
  50         return this.getRoundRobinIdTag(hashId, idTagsFile);
  51       case IdTagDistribution.CONNECTOR_AFFINITY:
  52         return this.getConnectorAffinityIdTag(chargingStation, connectorId);
  53       default:
  54         return this.getRoundRobinIdTag(hashId, idTagsFile);
  55     }
  56   }
  57
  58   /**
  59    * Gets all idtags from the cache
  60    * Must be called after checking the cache is not an empty array
  61    *
  62    * @param file -
  63    * @returns
  64    */
  65   public getIdTags(file: string): string[] | undefined {
  66     if (this.hasIdTagsCache(file) === false) {
  67       this.setIdTagsCache(file, this.getIdTagsFromFile(file));
  68     }
  69     return this.getIdTagsCache(file);
  70   }
  71
  72   public deleteIdTags(file: string): boolean {
  73     return this.deleteIdTagsCache(file) && this.deleteIdTagsCacheIndexes(file);
  74   }
  75
  76   private getRandomIdTag(hashId: string, file: string): string {
  77     const idTags = this.getIdTags(file);
  78     const addressableKey = this.getIdTagsCacheIndexesAddressableKey(file, hashId);
  79     this.idTagsCachesAddressableIndexes.set(
  80       addressableKey,
  81       Math.floor(Utils.secureRandom() * idTags.length)
  82     );
  83     return idTags[this.idTagsCachesAddressableIndexes.get(addressableKey)];
  84   }
  85
  86   private getRoundRobinIdTag(hashId: string, file: string): string {
  87     const idTags = this.getIdTags(file);
  88     const addressableKey = this.getIdTagsCacheIndexesAddressableKey(file, hashId);
  89     const idTagIndex = this.idTagsCachesAddressableIndexes.get(addressableKey) ?? 0;
  90     const idTag = idTags[idTagIndex];
  91     this.idTagsCachesAddressableIndexes.set(
  92       addressableKey,
  93       idTagIndex === idTags.length - 1 ? 0 : idTagIndex + 1
  94     );
  95     return idTag;
  96   }
  97
  98   private getConnectorAffinityIdTag(chargingStation: ChargingStation, connectorId: number): string {
  99     const file = ChargingStationUtils.getIdTagsFile(chargingStation.stationInfo);
 100     const idTags = this.getIdTags(file);
 101     const addressableKey = this.getIdTagsCacheIndexesAddressableKey(
 102       file,
 103       chargingStation.stationInfo.hashId
 104     );
 105     this.idTagsCachesAddressableIndexes.set(
 106       addressableKey,
 107       (chargingStation.index - 1 + (connectorId - 1)) % idTags.length
 108     );
 109     return idTags[this.idTagsCachesAddressableIndexes.get(addressableKey)];
 110   }
 111
 112   private hasIdTagsCache(file: string): boolean {
 113     return this.idTagsCaches.has(file);
 114   }
 115
 116   private setIdTagsCache(file: string, idTags: string[]) {
 117     return this.idTagsCaches.set(file, {
 118       idTags,
 119       idTagsFileWatcher: watchJsonFile(
 120         file,
 121         FileType.Authorization,
 122         this.logPrefix(file),
 123         undefined,
 124         (event, filename) => {
 125           if (Utils.isNotEmptyString(filename) && event === 'change') {
 126             try {
 127               logger.debug(
 128                 `${this.logPrefix(file)} ${FileType.Authorization} file have changed, reload`
 129               );
 130               this.deleteIdTagsCache(file);
 131               this.deleteIdTagsCacheIndexes(file);
 132             } catch (error) {
 133               handleFileException(
 134                 file,
 135                 FileType.Authorization,
 136                 error as NodeJS.ErrnoException,
 137                 this.logPrefix(file),
 138                 {
 139                   throwError: false,
 140                 }
 141               );
 142             }
 143           }
 144         }
 145       ),
 146     });
 147   }
 148
 149   private getIdTagsCache(file: string): string[] | undefined {
 150     return this.idTagsCaches.get(file)?.idTags;
 151   }
 152
 153   private deleteIdTagsCache(file: string): boolean {
 154     this.idTagsCaches.get(file)?.idTagsFileWatcher?.close();
 155     return this.idTagsCaches.delete(file);
 156   }
 157
 158   private deleteIdTagsCacheIndexes(file: string): boolean {
 159     let deleted: boolean[];
 160     for (const [key] of this.idTagsCachesAddressableIndexes) {
 161       if (key.startsWith(file)) {
 162         deleted.push(this.idTagsCachesAddressableIndexes.delete(key));
 163       }
 164     }
 165     return !deleted.some((value) => value === false);
 166   }
 167
 168   private getIdTagsCacheIndexesAddressableKey(prefix: string, uid: string): string {
 169     return `${prefix}${uid}`;
 170   }
 171
 172   private getIdTagsFromFile(file: string): string[] {
 173     if (Utils.isNotEmptyString(file)) {
 174       try {
 175         return JSON.parse(fs.readFileSync(file, 'utf8')) as string[];
 176       } catch (error) {
 177         handleFileException(
 178           file,
 179           FileType.Authorization,
 180           error as NodeJS.ErrnoException,
 181           this.logPrefix(file)
 182         );
 183       }
 184     }
 185     return [];
 186   }
 187
 188   private logPrefix = (file: string): string => {
 189     return Utils.logPrefix(` Id tags cache for id tags file '${file}' |`);
 190   };
 191 }