src/utils/Configuration.ts

   1 import { type FSWatcher, readFileSync, watch } from 'node:fs'
   2 import { dirname, join } from 'node:path'
   3 import { env } from 'node:process'
   4 import { fileURLToPath } from 'node:url'
   5
   6 import chalk from 'chalk'
   7 import { mergeDeepRight, once } from 'rambda'
   8
   9 import {
  10   ApplicationProtocol,
  11   ApplicationProtocolVersion,
  12   type ConfigurationData,
  13   ConfigurationSection,
  14   FileType,
  15   type LogConfiguration,
  16   type StationTemplateUrl,
  17   type StorageConfiguration,
  18   StorageType,
  19   SupervisionUrlDistribution,
  20   type UIServerConfiguration,
  21   type WorkerConfiguration
  22 } from '../types/index.js'
  23 import {
  24   DEFAULT_ELEMENT_START_DELAY,
  25   DEFAULT_POOL_MAX_SIZE,
  26   DEFAULT_POOL_MIN_SIZE,
  27   DEFAULT_WORKER_START_DELAY,
  28   WorkerProcessType
  29 } from '../worker/index.js'
  30 import {
  31   buildPerformanceUriFilePath,
  32   checkWorkerElementsPerWorker,
  33   checkWorkerProcessType,
  34   getDefaultPerformanceStorageUri,
  35   handleFileException,
  36   logPrefix
  37 } from './ConfigurationUtils.js'
  38 import { Constants } from './Constants.js'
  39 import { hasOwnProp, isCFEnvironment } from './Utils.js'
  40
  41 type ConfigurationSectionType =
  42   | LogConfiguration
  43   | StorageConfiguration
  44   | WorkerConfiguration
  45   | UIServerConfiguration
  46
  47 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
  48 export class Configuration {
  49   public static configurationChangeCallback?: () => Promise<void>
  50
  51   private static readonly configurationFile = join(
  52     dirname(fileURLToPath(import.meta.url)),
  53     'assets',
  54     'config.json'
  55   )
  56
  57   private static configurationFileReloading = false
  58   private static configurationData?: ConfigurationData
  59   private static configurationFileWatcher?: FSWatcher
  60   private static readonly configurationSectionCache = new Map<
  61   ConfigurationSection,
  62   ConfigurationSectionType
  63   >([
  64     [ConfigurationSection.log, Configuration.buildLogSection()],
  65     [ConfigurationSection.performanceStorage, Configuration.buildPerformanceStorageSection()],
  66     [ConfigurationSection.worker, Configuration.buildWorkerSection()],
  67     [ConfigurationSection.uiServer, Configuration.buildUIServerSection()]
  68   ])
  69
  70   private constructor () {
  71     // This is intentional
  72   }
  73
  74   public static getConfigurationSection<T extends ConfigurationSectionType>(
  75     sectionName: ConfigurationSection
  76   ): T {
  77     if (!Configuration.isConfigurationSectionCached(sectionName)) {
  78       Configuration.cacheConfigurationSection(sectionName)
  79     }
  80     return Configuration.configurationSectionCache.get(sectionName) as T
  81   }
  82
  83   public static getStationTemplateUrls (): StationTemplateUrl[] | undefined {
  84     const checkDeprecatedConfigurationKeysOnce = once(
  85       Configuration.checkDeprecatedConfigurationKeys.bind(Configuration)
  86     )
  87     checkDeprecatedConfigurationKeysOnce()
  88     return Configuration.getConfigurationData()?.stationTemplateUrls
  89   }
  90
  91   public static getSupervisionUrls (): string | string[] | undefined {
  92     if (
  93       Configuration.getConfigurationData()?.['supervisionURLs' as keyof ConfigurationData] != null
  94     ) {
  95       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  96       Configuration.getConfigurationData()!.supervisionUrls = Configuration.getConfigurationData()![
  97         'supervisionURLs' as keyof ConfigurationData
  98       ] as string | string[]
  99     }
 100     return Configuration.getConfigurationData()?.supervisionUrls
 101   }
 102
 103   public static getSupervisionUrlDistribution (): SupervisionUrlDistribution | undefined {
 104     return hasOwnProp(Configuration.getConfigurationData(), 'supervisionUrlDistribution')
 105       ? Configuration.getConfigurationData()?.supervisionUrlDistribution
 106       : SupervisionUrlDistribution.ROUND_ROBIN
 107   }
 108
 109   public static workerPoolInUse (): boolean {
 110     return [WorkerProcessType.dynamicPool, WorkerProcessType.fixedPool].includes(
 111       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 112       Configuration.getConfigurationSection<WorkerConfiguration>(ConfigurationSection.worker)
 113         .processType!
 114     )
 115   }
 116
 117   public static workerDynamicPoolInUse (): boolean {
 118     return (
 119       Configuration.getConfigurationSection<WorkerConfiguration>(ConfigurationSection.worker)
 120         .processType === WorkerProcessType.dynamicPool
 121     )
 122   }
 123
 124   private static isConfigurationSectionCached (sectionName: ConfigurationSection): boolean {
 125     return Configuration.configurationSectionCache.has(sectionName)
 126   }
 127
 128   private static cacheConfigurationSection (sectionName: ConfigurationSection): void {
 129     switch (sectionName) {
 130       case ConfigurationSection.log:
 131         Configuration.configurationSectionCache.set(sectionName, Configuration.buildLogSection())
 132         break
 133       case ConfigurationSection.performanceStorage:
 134         Configuration.configurationSectionCache.set(
 135           sectionName,
 136           Configuration.buildPerformanceStorageSection()
 137         )
 138         break
 139       case ConfigurationSection.worker:
 140         Configuration.configurationSectionCache.set(sectionName, Configuration.buildWorkerSection())
 141         break
 142       case ConfigurationSection.uiServer:
 143         Configuration.configurationSectionCache.set(
 144           sectionName,
 145           Configuration.buildUIServerSection()
 146         )
 147         break
 148       default:
 149         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 150         throw new Error(`Unknown configuration section '${sectionName}'`)
 151     }
 152   }
 153
 154   private static buildUIServerSection (): UIServerConfiguration {
 155     let uiServerConfiguration: UIServerConfiguration = {
 156       enabled: false,
 157       type: ApplicationProtocol.WS,
 158       version: ApplicationProtocolVersion.VERSION_11,
 159       options: {
 160         host: Constants.DEFAULT_UI_SERVER_HOST,
 161         port: Constants.DEFAULT_UI_SERVER_PORT
 162       }
 163     }
 164     if (hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.uiServer)) {
 165       uiServerConfiguration = mergeDeepRight(
 166         uiServerConfiguration,
 167         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 168         Configuration.getConfigurationData()!.uiServer!
 169       )
 170     }
 171     if (isCFEnvironment()) {
 172       delete uiServerConfiguration.options?.host
 173       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 174       uiServerConfiguration.options!.port = parseInt(env.PORT!)
 175     }
 176     return uiServerConfiguration
 177   }
 178
 179   private static buildPerformanceStorageSection (): StorageConfiguration {
 180     let storageConfiguration: StorageConfiguration
 181     switch (Configuration.getConfigurationData()?.performanceStorage?.type) {
 182       case StorageType.SQLITE:
 183         storageConfiguration = {
 184           enabled: false,
 185           type: StorageType.SQLITE,
 186           uri: getDefaultPerformanceStorageUri(StorageType.SQLITE)
 187         }
 188         break
 189       case StorageType.JSON_FILE:
 190         storageConfiguration = {
 191           enabled: false,
 192           type: StorageType.JSON_FILE,
 193           uri: getDefaultPerformanceStorageUri(StorageType.JSON_FILE)
 194         }
 195         break
 196       case StorageType.NONE:
 197       default:
 198         storageConfiguration = {
 199           enabled: true,
 200           type: StorageType.NONE
 201         }
 202         break
 203     }
 204     if (hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.performanceStorage)) {
 205       storageConfiguration = {
 206         ...storageConfiguration,
 207         ...Configuration.getConfigurationData()?.performanceStorage,
 208         ...((Configuration.getConfigurationData()?.performanceStorage?.type ===
 209           StorageType.JSON_FILE ||
 210           Configuration.getConfigurationData()?.performanceStorage?.type === StorageType.SQLITE) &&
 211           Configuration.getConfigurationData()?.performanceStorage?.uri != null && {
 212           uri: buildPerformanceUriFilePath(
 213             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 214             new URL(Configuration.getConfigurationData()!.performanceStorage!.uri!).pathname
 215           )
 216         })
 217       }
 218     }
 219     return storageConfiguration
 220   }
 221
 222   private static buildLogSection (): LogConfiguration {
 223     const defaultLogConfiguration: LogConfiguration = {
 224       enabled: true,
 225       file: 'logs/combined.log',
 226       errorFile: 'logs/error.log',
 227       statisticsInterval: Constants.DEFAULT_LOG_STATISTICS_INTERVAL,
 228       level: 'info',
 229       format: 'simple',
 230       rotate: true
 231     }
 232     const deprecatedLogConfiguration: LogConfiguration = {
 233       ...(hasOwnProp(Configuration.getConfigurationData(), 'logEnabled') && {
 234         enabled: Configuration.getConfigurationData()?.logEnabled
 235       }),
 236       ...(hasOwnProp(Configuration.getConfigurationData(), 'logFile') && {
 237         file: Configuration.getConfigurationData()?.logFile
 238       }),
 239       ...(hasOwnProp(Configuration.getConfigurationData(), 'logErrorFile') && {
 240         errorFile: Configuration.getConfigurationData()?.logErrorFile
 241       }),
 242       ...(hasOwnProp(Configuration.getConfigurationData(), 'logStatisticsInterval') && {
 243         statisticsInterval: Configuration.getConfigurationData()?.logStatisticsInterval
 244       }),
 245       ...(hasOwnProp(Configuration.getConfigurationData(), 'logLevel') && {
 246         level: Configuration.getConfigurationData()?.logLevel
 247       }),
 248       ...(hasOwnProp(Configuration.getConfigurationData(), 'logConsole') && {
 249         console: Configuration.getConfigurationData()?.logConsole
 250       }),
 251       ...(hasOwnProp(Configuration.getConfigurationData(), 'logFormat') && {
 252         format: Configuration.getConfigurationData()?.logFormat
 253       }),
 254       ...(hasOwnProp(Configuration.getConfigurationData(), 'logRotate') && {
 255         rotate: Configuration.getConfigurationData()?.logRotate
 256       }),
 257       ...(hasOwnProp(Configuration.getConfigurationData(), 'logMaxFiles') && {
 258         maxFiles: Configuration.getConfigurationData()?.logMaxFiles
 259       }),
 260       ...(hasOwnProp(Configuration.getConfigurationData(), 'logMaxSize') && {
 261         maxSize: Configuration.getConfigurationData()?.logMaxSize
 262       })
 263     }
 264     const logConfiguration: LogConfiguration = {
 265       ...defaultLogConfiguration,
 266       ...deprecatedLogConfiguration,
 267       ...(hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.log) &&
 268         Configuration.getConfigurationData()?.log)
 269     }
 270     return logConfiguration
 271   }
 272
 273   private static buildWorkerSection (): WorkerConfiguration {
 274     const defaultWorkerConfiguration: WorkerConfiguration = {
 275       processType: WorkerProcessType.workerSet,
 276       startDelay: DEFAULT_WORKER_START_DELAY,
 277       elementsPerWorker: 'auto',
 278       elementStartDelay: DEFAULT_ELEMENT_START_DELAY,
 279       poolMinSize: DEFAULT_POOL_MIN_SIZE,
 280       poolMaxSize: DEFAULT_POOL_MAX_SIZE
 281     }
 282     const deprecatedWorkerConfiguration: WorkerConfiguration = {
 283       ...(hasOwnProp(Configuration.getConfigurationData(), 'workerProcess') && {
 284         processType: Configuration.getConfigurationData()?.workerProcess
 285       }),
 286       ...(hasOwnProp(Configuration.getConfigurationData(), 'workerStartDelay') && {
 287         startDelay: Configuration.getConfigurationData()?.workerStartDelay
 288       }),
 289       ...(hasOwnProp(Configuration.getConfigurationData(), 'chargingStationsPerWorker') && {
 290         elementsPerWorker: Configuration.getConfigurationData()?.chargingStationsPerWorker
 291       }),
 292       ...(hasOwnProp(Configuration.getConfigurationData(), 'elementStartDelay') && {
 293         elementStartDelay: Configuration.getConfigurationData()?.elementStartDelay
 294       }),
 295       ...(hasOwnProp(Configuration.getConfigurationData(), 'workerPoolMinSize') && {
 296         poolMinSize: Configuration.getConfigurationData()?.workerPoolMinSize
 297       }),
 298       ...(hasOwnProp(Configuration.getConfigurationData(), 'workerPoolMaxSize') && {
 299         poolMaxSize: Configuration.getConfigurationData()?.workerPoolMaxSize
 300       })
 301     }
 302     hasOwnProp(Configuration.getConfigurationData(), 'workerPoolStrategy') &&
 303       delete Configuration.getConfigurationData()?.workerPoolStrategy
 304     const workerConfiguration: WorkerConfiguration = {
 305       ...defaultWorkerConfiguration,
 306       ...deprecatedWorkerConfiguration,
 307       ...(hasOwnProp(Configuration.getConfigurationData(), ConfigurationSection.worker) &&
 308         Configuration.getConfigurationData()?.worker)
 309     }
 310     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 311     checkWorkerProcessType(workerConfiguration.processType!)
 312     checkWorkerElementsPerWorker(workerConfiguration.elementsPerWorker)
 313     return workerConfiguration
 314   }
 315
 316   private static checkDeprecatedConfigurationKeys (): void {
 317     // connection timeout
 318     Configuration.warnDeprecatedConfigurationKey(
 319       'autoReconnectTimeout',
 320       undefined,
 321       "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead"
 322     )
 323     Configuration.warnDeprecatedConfigurationKey(
 324       'connectionTimeout',
 325       undefined,
 326       "Use 'ConnectionTimeOut' OCPP parameter in charging station template instead"
 327     )
 328     // connection retries
 329     Configuration.warnDeprecatedConfigurationKey(
 330       'autoReconnectMaxRetries',
 331       undefined,
 332       'Use it in charging station template instead'
 333     )
 334     // station template url(s)
 335     Configuration.warnDeprecatedConfigurationKey(
 336       'stationTemplateURLs',
 337       undefined,
 338       "Use 'stationTemplateUrls' instead"
 339     )
 340     Configuration.getConfigurationData()?.['stationTemplateURLs' as keyof ConfigurationData] !=
 341       null &&
 342       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 343       (Configuration.getConfigurationData()!.stationTemplateUrls =
 344         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 345         Configuration.getConfigurationData()![
 346           'stationTemplateURLs' as keyof ConfigurationData
 347         ] as StationTemplateUrl[])
 348     Configuration.getConfigurationData()?.stationTemplateUrls.forEach(
 349       (stationTemplateUrl: StationTemplateUrl) => {
 350         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
 351         if (stationTemplateUrl['numberOfStation' as keyof StationTemplateUrl] != null) {
 352           console.error(
 353             `${chalk.green(logPrefix())} ${chalk.red(
 354               `Deprecated configuration key 'numberOfStation' usage for template file '${stationTemplateUrl.file}' in 'stationTemplateUrls'. Use 'numberOfStations' instead`
 355             )}`
 356           )
 357         }
 358       }
 359     )
 360     // supervision url(s)
 361     Configuration.warnDeprecatedConfigurationKey(
 362       'supervisionURLs',
 363       undefined,
 364       "Use 'supervisionUrls' instead"
 365     )
 366     // supervision urls distribution
 367     Configuration.warnDeprecatedConfigurationKey(
 368       'distributeStationToTenantEqually',
 369       undefined,
 370       "Use 'supervisionUrlDistribution' instead"
 371     )
 372     Configuration.warnDeprecatedConfigurationKey(
 373       'distributeStationsToTenantsEqually',
 374       undefined,
 375       "Use 'supervisionUrlDistribution' instead"
 376     )
 377     // worker section
 378     Configuration.warnDeprecatedConfigurationKey(
 379       'useWorkerPool',
 380       undefined,
 381       `Use '${ConfigurationSection.worker}' section to define the type of worker process model instead`
 382     )
 383     Configuration.warnDeprecatedConfigurationKey(
 384       'workerProcess',
 385       undefined,
 386       `Use '${ConfigurationSection.worker}' section to define the type of worker process model instead`
 387     )
 388     Configuration.warnDeprecatedConfigurationKey(
 389       'workerStartDelay',
 390       undefined,
 391       `Use '${ConfigurationSection.worker}' section to define the worker start delay instead`
 392     )
 393     Configuration.warnDeprecatedConfigurationKey(
 394       'chargingStationsPerWorker',
 395       undefined,
 396       `Use '${ConfigurationSection.worker}' section to define the number of element(s) per worker instead`
 397     )
 398     Configuration.warnDeprecatedConfigurationKey(
 399       'elementStartDelay',
 400       undefined,
 401       `Use '${ConfigurationSection.worker}' section to define the worker's element start delay instead`
 402     )
 403     Configuration.warnDeprecatedConfigurationKey(
 404       'workerPoolMinSize',
 405       undefined,
 406       `Use '${ConfigurationSection.worker}' section to define the worker pool minimum size instead`
 407     )
 408     Configuration.warnDeprecatedConfigurationKey(
 409       'workerPoolSize',
 410       undefined,
 411       `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`
 412     )
 413     Configuration.warnDeprecatedConfigurationKey(
 414       'workerPoolMaxSize',
 415       undefined,
 416       `Use '${ConfigurationSection.worker}' section to define the worker pool maximum size instead`
 417     )
 418     Configuration.warnDeprecatedConfigurationKey(
 419       'workerPoolStrategy',
 420       undefined,
 421       `Use '${ConfigurationSection.worker}' section to define the worker pool strategy instead`
 422     )
 423     Configuration.warnDeprecatedConfigurationKey(
 424       'poolStrategy',
 425       ConfigurationSection.worker,
 426       'Not publicly exposed to end users'
 427     )
 428     if (
 429       Configuration.getConfigurationData()?.worker?.processType ===
 430       ('staticPool' as WorkerProcessType)
 431     ) {
 432       console.error(
 433         `${chalk.green(logPrefix())} ${chalk.red(
 434           `Deprecated configuration 'staticPool' value usage in worker section 'processType' field. Use '${WorkerProcessType.fixedPool}' value instead`
 435         )}`
 436       )
 437     }
 438     // log section
 439     Configuration.warnDeprecatedConfigurationKey(
 440       'logEnabled',
 441       undefined,
 442       `Use '${ConfigurationSection.log}' section to define the logging enablement instead`
 443     )
 444     Configuration.warnDeprecatedConfigurationKey(
 445       'logFile',
 446       undefined,
 447       `Use '${ConfigurationSection.log}' section to define the log file instead`
 448     )
 449     Configuration.warnDeprecatedConfigurationKey(
 450       'logErrorFile',
 451       undefined,
 452       `Use '${ConfigurationSection.log}' section to define the log error file instead`
 453     )
 454     Configuration.warnDeprecatedConfigurationKey(
 455       'logConsole',
 456       undefined,
 457       `Use '${ConfigurationSection.log}' section to define the console logging enablement instead`
 458     )
 459     Configuration.warnDeprecatedConfigurationKey(
 460       'logStatisticsInterval',
 461       undefined,
 462       `Use '${ConfigurationSection.log}' section to define the log statistics interval instead`
 463     )
 464     Configuration.warnDeprecatedConfigurationKey(
 465       'logLevel',
 466       undefined,
 467       `Use '${ConfigurationSection.log}' section to define the log level instead`
 468     )
 469     Configuration.warnDeprecatedConfigurationKey(
 470       'logFormat',
 471       undefined,
 472       `Use '${ConfigurationSection.log}' section to define the log format instead`
 473     )
 474     Configuration.warnDeprecatedConfigurationKey(
 475       'logRotate',
 476       undefined,
 477       `Use '${ConfigurationSection.log}' section to define the log rotation enablement instead`
 478     )
 479     Configuration.warnDeprecatedConfigurationKey(
 480       'logMaxFiles',
 481       undefined,
 482       `Use '${ConfigurationSection.log}' section to define the log maximum files instead`
 483     )
 484     Configuration.warnDeprecatedConfigurationKey(
 485       'logMaxSize',
 486       undefined,
 487       `Use '${ConfigurationSection.log}' section to define the log maximum size instead`
 488     )
 489     // performanceStorage section
 490     Configuration.warnDeprecatedConfigurationKey(
 491       'URI',
 492       ConfigurationSection.performanceStorage,
 493       "Use 'uri' instead"
 494     )
 495     // uiServer section
 496     if (hasOwnProp(Configuration.getConfigurationData(), 'uiWebSocketServer')) {
 497       console.error(
 498         `${chalk.green(logPrefix())} ${chalk.red(
 499           `Deprecated configuration section 'uiWebSocketServer' usage. Use '${ConfigurationSection.uiServer}' instead`
 500         )}`
 501       )
 502     }
 503   }
 504
 505   private static warnDeprecatedConfigurationKey (
 506     key: string,
 507     sectionName?: string,
 508     logMsgToAppend = ''
 509   ): void {
 510     if (
 511       sectionName != null &&
 512       Configuration.getConfigurationData()?.[sectionName as keyof ConfigurationData] != null &&
 513       (
 514         Configuration.getConfigurationData()?.[sectionName as keyof ConfigurationData] as Record<
 515         string,
 516         unknown
 517         >
 518       )[key] != null
 519     ) {
 520       console.error(
 521         `${chalk.green(logPrefix())} ${chalk.red(
 522           `Deprecated configuration key '${key}' usage in section '${sectionName}'${
 523             logMsgToAppend.trim().length > 0 ? `. ${logMsgToAppend}` : ''
 524           }`
 525         )}`
 526       )
 527     } else if (Configuration.getConfigurationData()?.[key as keyof ConfigurationData] != null) {
 528       console.error(
 529         `${chalk.green(logPrefix())} ${chalk.red(
 530           `Deprecated configuration key '${key}' usage${
 531             logMsgToAppend.trim().length > 0 ? `. ${logMsgToAppend}` : ''
 532           }`
 533         )}`
 534       )
 535     }
 536   }
 537
 538   private static getConfigurationData (): ConfigurationData | undefined {
 539     if (Configuration.configurationData == null) {
 540       try {
 541         Configuration.configurationData = JSON.parse(
 542           readFileSync(Configuration.configurationFile, 'utf8')
 543         ) as ConfigurationData
 544         if (Configuration.configurationFileWatcher == null) {
 545           Configuration.configurationFileWatcher = Configuration.getConfigurationFileWatcher()
 546         }
 547       } catch (error) {
 548         handleFileException(
 549           Configuration.configurationFile,
 550           FileType.Configuration,
 551           error as NodeJS.ErrnoException,
 552           logPrefix()
 553         )
 554       }
 555     }
 556     return Configuration.configurationData
 557   }
 558
 559   private static getConfigurationFileWatcher (): FSWatcher | undefined {
 560     try {
 561       return watch(Configuration.configurationFile, (event, filename): void => {
 562         if (
 563           !Configuration.configurationFileReloading &&
 564           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 565           filename!.trim().length > 0 &&
 566           event === 'change'
 567         ) {
 568           Configuration.configurationFileReloading = true
 569           const consoleWarnOnce = once(console.warn)
 570           consoleWarnOnce(
 571             `${chalk.green(logPrefix())} ${chalk.yellow(
 572               `${FileType.Configuration} ${this.configurationFile} file have changed, reload`
 573             )}`
 574           )
 575           delete Configuration.configurationData
 576           Configuration.configurationSectionCache.clear()
 577           if (Configuration.configurationChangeCallback != null) {
 578             Configuration.configurationChangeCallback()
 579               .catch(error => {
 580                 throw typeof error === 'string' ? new Error(error) : error
 581               })
 582               .finally(() => {
 583                 Configuration.configurationFileReloading = false
 584               })
 585           } else {
 586             Configuration.configurationFileReloading = false
 587           }
 588         }
 589       })
 590     } catch (error) {
 591       handleFileException(
 592         Configuration.configurationFile,
 593         FileType.Configuration,
 594         error as NodeJS.ErrnoException,
 595         logPrefix()
 596       )
 597     }
 598   }
 599 }