chore: consolidate cache items to one location

karenc-bq · karenc-bq · commit 34e7930a3a7b · 2026-02-25T18:06:53.000-08:00
diff --git a/.github/workflows/integration_tests.yml b/.github/workflows/integration_tests.yml
@@ -5,7 +5,6 @@ on:
   push:
     branches:
       - main
-      - dev/v3
     paths-ignore:
       - "**/*.md"
       - "**/*.jpg"
diff --git a/common/lib/utils/cache_map.ts b/common/lib/utils/cache_map.ts
@@ -14,17 +14,40 @@
   limitations under the License.
 */
 
-class CacheItem<V> {
-  readonly item: V;
-  private readonly expirationTimeNanos: bigint;
+import { getTimeInNanos } from "./utils";
 
-  constructor(item: V, expirationTimeNanos: bigint) {
+export class CacheItem<V> {
+  private readonly item: V;
+  private _expirationTimeNs: bigint;
+
+  constructor(item: V, expirationTime: bigint) {
     this.item = item;
-    this.expirationTimeNanos = expirationTimeNanos;
+    this._expirationTimeNs = expirationTime;
   }
 
   isExpired(): boolean {
-    return process.hrtime.bigint() > this.expirationTimeNanos;
+    if (this._expirationTimeNs <= 0) {
+      // No expiration time.
+      return false;
+    }
+    return getTimeInNanos() > this._expirationTimeNs;
+  }
+
+  get(returnExpired: boolean = false): V | null {
+    return this.isExpired() && !returnExpired ? null : this.item;
+  }
+
+  updateExpiration(expirationIntervalNanos: bigint): CacheItem<V> {
+    this._expirationTimeNs = getTimeInNanos() + expirationIntervalNanos;
+    return this;
+  }
+
+  get expirationTimeNs(): bigint {
+    return this._expirationTimeNs;
+  }
+
+  toString(): string {
+    return `CacheItem [item=${this.item}, expirationTime=${this._expirationTimeNs}]`;
   }
 }
 
@@ -38,7 +61,7 @@ export class CacheMap<K, V> {
   get(key: K, defaultItemValue?: any, itemExpirationNano?: any): V | null {
     const cacheItem: CacheItem<V> | undefined = this.cache.get(key);
     if (cacheItem && !cacheItem.isExpired()) {
-      return cacheItem.item;
+      return cacheItem.get();
     }
 
     if (!defaultItemValue || !itemExpirationNano) {
@@ -74,14 +97,6 @@ export class CacheMap<K, V> {
     this.cache.clear();
   }
 
-  getEntries(): Map<K, V> {
-    const entries: Map<K, V> = new Map();
-    this.cache.forEach((v, k) => {
-      entries.set(k, v.item);
-    });
-    return entries;
-  }
-
   protected cleanUp() {
     if (this.cleanupTimeNanos < process.hrtime.bigint()) {
       this.cleanupTimeNanos = process.hrtime.bigint() + this.cleanupIntervalNanos;
diff --git a/common/lib/utils/core_services_container.ts b/common/lib/utils/core_services_container.ts
@@ -45,4 +45,8 @@ export class CoreServicesContainer {
   // getMonitorService(): MonitorService {
   //   return this.monitorService;
   // }
+
+  static releaseResources(): void {
+    CoreServicesContainer.INSTANCE.storageService.releaseResources();
+  }
 }
diff --git a/common/lib/utils/sliding_expiration_cache.ts b/common/lib/utils/sliding_expiration_cache.ts
@@ -16,25 +16,7 @@
 
 import { getTimeInNanos } from "./utils";
 import { MapUtils } from "./map_utils";
-
-class CacheItem<V> {
-  readonly item: V;
-  private _expirationTimeNanos: bigint;
-
-  constructor(item: V, expirationTimeNanos: bigint) {
-    this.item = item;
-    this._expirationTimeNanos = expirationTimeNanos;
-  }
-
-  get expirationTimeNs(): bigint {
-    return this._expirationTimeNanos;
-  }
-
-  updateExpiration(expirationIntervalNanos: bigint): CacheItem<V> {
-    this._expirationTimeNanos = getTimeInNanos() + expirationIntervalNanos;
-    return this;
-  }
-}
+import { CacheItem } from "./cache_map";
 
 export class SlidingExpirationCache<K, V> {
   protected _cleanupIntervalNanos: bigint = BigInt(10 * 60_000_000_000); // 10 minutes
@@ -69,29 +51,29 @@ export class SlidingExpirationCache<K, V> {
   computeIfAbsent(key: K, mappingFunc: (key: K) => V, itemExpirationNanos: bigint): V | null {
     this.cleanUp();
     const cacheItem = MapUtils.computeIfAbsent(this.map, key, (k) => new CacheItem(mappingFunc(k), getTimeInNanos() + itemExpirationNanos));
-    return cacheItem?.updateExpiration(itemExpirationNanos).item ?? null;
+    return cacheItem?.updateExpiration(itemExpirationNanos).get() ?? null;
   }
 
   putIfAbsent(key: K, value: V, itemExpirationNanos: bigint): V | null {
     const cacheItem = MapUtils.putIfAbsent(this.map, key, new CacheItem(value, getTimeInNanos() + itemExpirationNanos));
-    return cacheItem?.item ?? null;
+    return cacheItem?.get(true) ?? null;
   }
 
   get(key: K, itemExpirationNanos?: bigint): V | undefined {
     this.cleanUp();
     const cacheItem = this.map.get(key);
-    if (cacheItem?.item && itemExpirationNanos) {
+    if (cacheItem?.get(true) && itemExpirationNanos) {
       cacheItem.updateExpiration(itemExpirationNanos);
-      return cacheItem.item;
+      return cacheItem.get();
     }
-    return cacheItem?.item;
+    return cacheItem?.get(true);
   }
 
   put(key: K, value: V, itemExpirationNanos: bigint): V | null {
     this.cleanUp();
     const cacheItem = new CacheItem(value, getTimeInNanos() + itemExpirationNanos);
     this.map.set(key, cacheItem);
-    return cacheItem.item;
+    return cacheItem.get(true);
   }
 
   remove(key: K): void {
@@ -102,15 +84,15 @@ export class SlidingExpirationCache<K, V> {
   removeAndDispose(key: K): void {
     const cacheItem = MapUtils.remove(this.map, key);
     if (cacheItem != null && this._itemDisposalFunc != null) {
-      this._itemDisposalFunc(cacheItem.item);
+      this._itemDisposalFunc(cacheItem.get(true));
     }
   }
 
   removeIfExpired(key: K): void {
     let item;
     MapUtils.computeIfPresent(this.map, key, (key, cacheItem) => {
       if (this.shouldCleanupItem(cacheItem)) {
-        item = cacheItem.item;
+        item = cacheItem.get(true);
         return null;
       }
       return cacheItem;
@@ -123,15 +105,15 @@ export class SlidingExpirationCache<K, V> {
 
   shouldCleanupItem(cacheItem: CacheItem<V>): boolean {
     if (this._shouldDisposeFunc != null) {
-      return getTimeInNanos() > cacheItem.expirationTimeNs && this._shouldDisposeFunc(cacheItem.item);
+      return cacheItem.isExpired() && this._shouldDisposeFunc(cacheItem.get(true));
     }
-    return getTimeInNanos() > cacheItem.expirationTimeNs;
+    return cacheItem.isExpired();
   }
 
   clear(): void {
     for (const [key, val] of this.map.entries()) {
       if (val !== undefined && this._itemDisposalFunc !== undefined) {
-        this._itemDisposalFunc(val.item);
+        this._itemDisposalFunc(val.get());
       }
     }
     this.map.clear();
diff --git a/common/lib/utils/storage/storage_service.ts b/common/lib/utils/storage/storage_service.ts
@@ -102,6 +102,12 @@ export interface StorageService {
    * @returns The number of items stored for the given item class
    */
   size(itemClass: Constructor): number;
+
+  /**
+   * Cleanup method to stop the cleanup interval timer.
+   * Should be called when the service is no longer needed.
+   */
+  releaseResources(): void;
 }
 
 type CacheSupplier = () => ExpirationCache<unknown, unknown>;
@@ -129,7 +135,6 @@ export class StorageServiceImpl implements StorageService {
   }
 
   protected removeExpiredItems(): void {
-    logger.debug("StorageServiceImpl: Removing expired items");
     for (const cache of this.caches.values()) {
       cache.removeExpiredEntries();
     }
@@ -246,11 +251,7 @@ export class StorageServiceImpl implements StorageService {
     StorageServiceImpl.defaultCacheSuppliers.set(itemClass, supplier);
   }
 
-  /**
-   * Cleanup method to stop the cleanup interval timer.
-   * Should be called when the service is no longer needed.
-   */
-  destroy(): void {
+  releaseResources(): void {
     if (this.cleanupIntervalHandle) {
       clearInterval(this.cleanupIntervalHandle);
       this.cleanupIntervalHandle = undefined;
diff --git a/common/lib/wrapper_property.ts b/common/lib/wrapper_property.ts
@@ -232,9 +232,7 @@ export class WrapperProperties {
 
   static readonly CLUSTER_ID = new WrapperProperty<string>(
     "clusterId",
-    "A unique identifier for the cluster. " +
-      "Connections with the same cluster id share a cluster topology cache. " +
-      "If unspecified, a cluster id is '1'.",
+    "A unique identifier for the cluster. Connections with the same cluster id share a cluster topology cache. If unspecified, cluster id will be '1'.",
     "1"
   );
 
diff --git a/tests/unit/sliding_expiration_cache.test.ts b/tests/unit/sliding_expiration_cache.test.ts
@@ -15,7 +15,7 @@
 */
 
 import { SlidingExpirationCache } from "../../common/lib/utils/sliding_expiration_cache";
-import { convertNanosToMs, sleep } from "../../common/lib/utils/utils";
+import { convertMsToNanos, convertNanosToMs, sleep } from "../../common/lib/utils/utils";
 import { SlidingExpirationCacheWithCleanupTask } from "../../common/lib/utils/sliding_expiration_cache_with_cleanup_task";
 
 class DisposableItem {
@@ -48,9 +48,9 @@ class AsyncDisposableItem {
 describe("test_sliding_expiration_cache", () => {
   it("test compute if absent", async () => {
     const target = new SlidingExpirationCache(BigInt(50_000_000));
-    const result1 = target.computeIfAbsent(1, () => "a", BigInt(1));
+    const result1 = target.computeIfAbsent(1, () => "a", convertMsToNanos(100));
     const originalItemExpiration = target.map.get(1)!.expirationTimeNs;
-    const result2 = target.computeIfAbsent(1, () => "b", BigInt(5));
+    const result2 = target.computeIfAbsent(1, () => "b", convertMsToNanos(500));
     const updatedItemExpiration = target.map.get(1)?.expirationTimeNs;
 
     expect(updatedItemExpiration).toBeGreaterThan(originalItemExpiration);
@@ -59,7 +59,7 @@ describe("test_sliding_expiration_cache", () => {
     expect(target.get(1)).toEqual("a");
 
     await sleep(700);
-    const result3 = target.computeIfAbsent(1, () => "b", BigInt(5));
+    const result3 = target.computeIfAbsent(1, () => "b", convertMsToNanos(500));
     expect(result3).toEqual("b");
     expect(target.get(1)).toEqual("b");
   });
@@ -71,19 +71,19 @@ describe("test_sliding_expiration_cache", () => {
       (item) => item.dispose()
     );
     const itemToRemove = new DisposableItem(true);
-    let result = target.computeIfAbsent("itemToRemove", () => itemToRemove, BigInt(15_000_000_000));
+    let result = target.computeIfAbsent("itemToRemove", () => itemToRemove, convertMsToNanos(15_000));
     expect(itemToRemove).toEqual(result);
 
     const itemToCleanup = new DisposableItem(true);
-    result = target.computeIfAbsent("itemToCleanup", () => itemToCleanup, BigInt(1));
+    result = target.computeIfAbsent("itemToCleanup", () => itemToCleanup, convertMsToNanos(100));
     expect(itemToCleanup).toEqual(result);
 
     const nonDisposableItem = new DisposableItem(false);
-    result = target.computeIfAbsent("nonDisposableItem", () => nonDisposableItem, BigInt(1));
+    result = target.computeIfAbsent("nonDisposableItem", () => nonDisposableItem, convertMsToNanos(100));
     expect(nonDisposableItem).toEqual(result);
 
     const nonExpiredItem = new DisposableItem(true);
-    result = target.computeIfAbsent("nonExpiredItem", () => nonExpiredItem, BigInt(15_000_000_000));
+    result = target.computeIfAbsent("nonExpiredItem", () => nonExpiredItem, convertMsToNanos(15_000));
     expect(nonExpiredItem).toEqual(result);
 
     await sleep(700);

Original file line number	Diff line number	Diff line change
`@@ -45,4 +45,8 @@ export class CoreServicesContainer {`
`45`	`45`	`// getMonitorService(): MonitorService {`
`46`	`46`	`// return this.monitorService;`
`47`	`47`	`// }`
	`48`	`+`
	`49`	`+ static releaseResources(): void {`
	`50`	`+ CoreServicesContainer.INSTANCE.storageService.releaseResources();`
	`51`	`+ }`
`48`	`52`	`}`