From dd485b567f2f1b595c8241fa2cf74ba0c27911f0 Mon Sep 17 00:00:00 2001
From: =?utf8?q?J=C3=A9r=C3=B4me=20Benoit?= <jerome.benoit@sap.com>
Date: Tue, 2 May 2023 23:22:51 +0200
Subject: [PATCH] refactor: cleanup async lock API
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

Signed-off-by: Jérôme Benoit <jerome.benoit@sap.com>
---
 src/charging-station/ChargingStation.ts    |  6 ++--
 src/performance/storage/JsonFileStorage.ts |  6 ++--
 src/utils/AsyncLock.ts                     | 34 ++++++++++++----------
 3 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/src/charging-station/ChargingStation.ts b/src/charging-station/ChargingStation.ts
index 9855c8ca..f1895163 100644
--- a/src/charging-station/ChargingStation.ts
+++ b/src/charging-station/ChargingStation.ts
@@ -1594,9 +1594,7 @@ export class ChargingStation {
           .update(JSON.stringify(configurationData))
           .digest('hex');
         if (this.configurationFileHash !== configurationHash) {
-          const asyncLock = AsyncLock.getInstance(AsyncLockType.configuration);
-          asyncLock
-            .acquire()
+          AsyncLock.acquire(AsyncLockType.configuration)
             .then(() => {
               configurationData.configurationHash = configurationHash;
               const measureId = `${FileType.ChargingStationConfiguration} write`;
@@ -1618,7 +1616,7 @@ export class ChargingStation {
               );
             })
             .finally(() => {
-              asyncLock.release().catch(Constants.EMPTY_FUNCTION);
+              AsyncLock.release(AsyncLockType.configuration).catch(Constants.EMPTY_FUNCTION);
             });
         } else {
           logger.debug(
diff --git a/src/performance/storage/JsonFileStorage.ts b/src/performance/storage/JsonFileStorage.ts
index 5effae90..fb706267 100644
--- a/src/performance/storage/JsonFileStorage.ts
+++ b/src/performance/storage/JsonFileStorage.ts
@@ -16,9 +16,7 @@ export class JsonFileStorage extends Storage {
 
   public storePerformanceStatistics(performanceStatistics: Statistics): void {
     this.checkPerformanceRecordsFile();
-    const asyncLock = AsyncLock.getInstance(AsyncLockType.performance);
-    asyncLock
-      .acquire()
+    AsyncLock.acquire(AsyncLockType.performance)
       .then(() => {
         const fileData = fs.readFileSync(this.dbName, 'utf8');
         const performanceRecords: Statistics[] = fileData
@@ -40,7 +38,7 @@ export class JsonFileStorage extends Storage {
         );
       })
       .finally(() => {
-        asyncLock.release().catch(Constants.EMPTY_FUNCTION);
+        AsyncLock.release(AsyncLockType.performance).catch(Constants.EMPTY_FUNCTION);
       });
   }
 
diff --git a/src/utils/AsyncLock.ts b/src/utils/AsyncLock.ts
index 53907ce4..7f44bd25 100644
--- a/src/utils/AsyncLock.ts
+++ b/src/utils/AsyncLock.ts
@@ -6,7 +6,7 @@ export enum AsyncLockType {
 }
 
 export class AsyncLock {
-  private static readonly instances = new Map<AsyncLockType, AsyncLock>();
+  private static readonly asyncLocks = new Map<AsyncLockType, AsyncLock>();
   private acquired: boolean;
   private readonly resolveQueue: ((value: void | PromiseLike<void>) => void)[];
 
@@ -15,32 +15,34 @@ export class AsyncLock {
     this.resolveQueue = [];
   }
 
-  public static getInstance(type: AsyncLockType): AsyncLock {
-    if (!AsyncLock.instances.has(type)) {
-      AsyncLock.instances.set(type, new AsyncLock(type));
-    }
-    return AsyncLock.instances.get(type);
-  }
-
-  public async acquire(): Promise<void> {
-    if (!this.acquired) {
-      this.acquired = true;
+  public static async acquire(type: AsyncLockType): Promise<void> {
+    const asyncLock = AsyncLock.getAsyncLock(type);
+    if (!asyncLock.acquired) {
+      asyncLock.acquired = true;
     } else {
       return new Promise((resolve) => {
-        this.resolveQueue.push(resolve);
+        asyncLock.resolveQueue.push(resolve);
       });
     }
   }
 
-  public async release(): Promise<void> {
-    if (this.resolveQueue.length === 0 && this.acquired) {
-      this.acquired = false;
+  public static async release(type: AsyncLockType): Promise<void> {
+    const asyncLock = AsyncLock.getAsyncLock(type);
+    if (asyncLock.resolveQueue.length === 0 && asyncLock.acquired) {
+      asyncLock.acquired = false;
       return;
     }
-    const queuedResolve = this.resolveQueue.shift();
+    const queuedResolve = asyncLock.resolveQueue.shift();
     return new Promise((resolve) => {
       queuedResolve();
       resolve();
     });
   }
+
+  private static getAsyncLock(type: AsyncLockType): AsyncLock {
+    if (!AsyncLock.asyncLocks.has(type)) {
+      AsyncLock.asyncLocks.set(type, new AsyncLock(type));
+    }
+    return AsyncLock.asyncLocks.get(type);
+  }
 }
-- 
2.34.1