Move more cache reading code into IndexAllocationCache.

dlongley · dlongley · commit 6a29e56e6e3a · 2024-02-14T18:00:38.000-05:00
diff --git a/lib/IndexAllocationCache.js b/lib/IndexAllocationCache.js
@@ -5,11 +5,17 @@ import assert from 'assert-plus';
 import {Bitstring} from '@digitalbazaar/bitstring';
 import {v4 as uuid} from 'uuid';
 
-// FIXME: add `_readBlockAssignmentDoc()`
-
 /* See: ListManager for more design notes.
 
-this.selectShard(LMD, activeBADs): Select an IAD to use for assigning indexes:
+this.populate(LMD "active" set items): Reads all active BADs to enable
+  choosing an IAD.
+
+1. Read all BADs associated with the given items.
+  1.1. If any BAD does not exist, CW create it.
+  1.2. If any BAD has an SL sequence number that is behind an LMD item,
+    CW update it. If conflict, read the BAD.
+
+this.selectShard(): Select an IAD to use for assigning indexes:
 
 1. Select an IAD at random from the cached BAD blocks with unassigned indexes:
   1.1. Get total number of unassigned blocks and choose randomly.
@@ -30,14 +36,20 @@ this.selectShard(LMD, activeBADs): Select an IAD to use for assigning indexes:
 */
 
 export class IndexAllocationCache {
-  // FIXME: expose function to read records instead of passing here
-  constructor({edvClient, records} = {}) {
+  constructor({edvClient, statusListConfig} = {}) {
     assert.object(edvClient, 'edvClient');
     this.edvClient = edvClient;
-    this.records = records;//[];
+    this.records = [];
+    this.statusListConfig = statusListConfig;
+  }
+
+  // populate this cache from the given items
+  async populate({items} = {}) {
+    this.records = await Promise.all(items.map(
+      item => this._readBlockAssignmentDoc({item})));
   }
 
-  async outOfSync() {
+  outOfSync() {
     // if any record has a BAD SL sequence number that is greater than the
     // LMD item SL sequence number, then the cache is out of sync
     const {records} = this;
@@ -103,12 +115,11 @@ export class IndexAllocationCache {
     return {...choice, indexAssignmentDoc};
   }
 
-  // FIXME: determine how to expose for use in `ListManager`
   // read BAD contents referenced from LM doc item into a cache record
   async _readBlockAssignmentDoc({item}) {
     const {edvClient, statusListConfig} = this;
 
-    // executes step 1.2.1 of `_readActiveBlockAssignmentDocs()`
+    // executes step 1.1 of `populate()`
     let blockAssignmentDoc;
     while(!blockAssignmentDoc) {
       try {
@@ -144,7 +155,7 @@ export class IndexAllocationCache {
       }
     }
 
-    // executes step 1.2.2 of `_readActiveBlockAssignmentDocs()`
+    // executes step 1.2 of `populate()`
     const cacheRecord = {blockAssignmentDoc, item};
     await this._syncCacheRecord(cacheRecord);
     return cacheRecord;
@@ -191,7 +202,7 @@ export class IndexAllocationCache {
 
   // ensure cache record BAD contents are in sync with LM doc item
   async _syncCacheRecord(cacheRecord) {
-    // 1.2.2. If any BAD has an SL sequence number that is behind an LMD item,
+    // 1.2. If any BAD has an SL sequence number that is behind an LMD item,
     //   CW update it. If conflict, read the BAD.
     if(cacheRecord.blockAssignmentDoc.content.slSequence >=
       cacheRecord.item.slSequence) {
diff --git a/lib/ListManager.js b/lib/ListManager.js
@@ -97,22 +97,19 @@ getShard(): Gets a list shard needed to issue a VC. This will be called by
 this._readActiveBlockAssignmentDocs(LMD): Reads all active BADs to enable
   choosing an IAD.
 
-1. While active BADs cache is not read:
+1. While index allocation active cache is not set:
   1.1. Call _tryAddCapacity(LMD, target=1).
-  1.2. Read all active BADs.
-    1.2.1. If any BAD does not exist, CW create it.
-    1.2.2. If any BAD has an SL sequence number that is behind an LMD item,
-      CW update it. If conflict, read the BAD.
-    1.2.3. If any BAD has an SL sequence number that is ahead of the
-      LMD "active" set item, read the LMD and loop to 1.
-  1.3. If any BADs have fully assigned blocks of indexes:
-    1.3.1. Move BAD IDs to the "inactive" set; if all BADs are fully assigned,
+  1.2. Read all active BADs into an index allocation cache, `cache`.
+  1.3. If any BAD has an SL sequence number that is ahead of the
+    LMD "active" set item, read the LMD and loop to 1.
+  1.4. If any BADs have fully assigned blocks of indexes:
+    1.4.1. Move BAD IDs to the "inactive" set; if all BADs are fully assigned,
       choose one to leave as active and update its SL ID and SL sequence number.
-    1.3.2. CW update LMD.
-    1.3.3. If conflict, read LMD and loop to 1.
-    1.3.4. CW update active BAD, if one was updated.
-    1.3.5. If conflict, read LMD and loop to 1.
-  1.4. Set read BADs as the active cache.
+    1.4.2. CW update LMD.
+    1.4.3. If conflict, read LMD and loop to 1.
+    1.4.4. CW update active BAD, if one was updated.
+    1.4.5. If conflict, read LMD and loop to 1.
+  1.5. Set `cache` as the active cache.
 
 this._selectShard(LMD, activeCache): Select an IAD to use for assigning
   indexes:
@@ -262,37 +259,32 @@ export class ListManager {
     // latest docs are used
     const {documentStore: {edvClient}, statusListConfig} = this;
 
-    // 1. While active BADs cache not read:
+    // 1. While index allocation active cache is not set:
     this.activeCache = null;
     while(!this.activeCache) {
       // FIXME: can `_tryAddCapacity` be moved after reading cache records?
       // 1.1. Call _tryAddCapacity(LMD, target=1).
       await this._tryAddCapacity({target: 1});
-      // 1.2. Read all active BADs.
-      // 1.2.1. If any BAD does not exist, CW create it.
-      // 1.2.2. If any BAD has an SL sequence number that is behind an LMD item,
-      //   CW update it. If conflict, read the BAD.
+      // 1.2. Read all active BADs into an index allocation cache, `cache`.
       const {blockAssignment} = this.lmDoc.content;
-      // FIXME: create `new IndexAllocatorCache()`
-      let cacheRecords = await Promise.all(blockAssignment.active.map(
-        item => this._readBlockAssignmentDoc({item})));
-      // 1.2.3. If any BAD has an SL sequence number that is ahead of the
+      const cache = new IndexAllocationCache({edvClient, statusListConfig});
+      await cache.populate({items: blockAssignment.active});
+      // 1.3. If any BAD has an SL sequence number that is ahead of the
       //   LMD "active" set item, read the LMD and loop to 1.
-      if(cacheRecords.some(({blockAssignmentDoc: {content}, item}) =>
-        content.slSequence > item.slSequence)) {
+      if(cache.outOfSync()) {
         this.lmDoc = await edvClient.get({id: this.lmDoc.id});
         continue;
       }
 
       // FIXME: can this be moved to `tryAddCapacity()` such that it will only
       // execute when another BAD is required?
 
-      // 1.3. If any BADs have fully assigned blocks of indexes:
-      const fullyAssigned = cacheRecords.filter(
+      // 1.4. If any BADs have fully assigned blocks of indexes:
+      const fullyAssigned = cache.records.filter(
         ({blockAssignmentDoc: {content}}) =>
           content.assignedBlockCount === content.blockCount);
       if(fullyAssigned.length > 0) {
-        // 1.3.1. Move BAD IDs to the "inactive" set; if all BADs are fully
+        // 1.4.1. Move BAD IDs to the "inactive" set; if all BADs are fully
         //   assigned, choose one to leave as active and update its SL ID and
         //   SL sequence number.
         const items = fullyAssigned.map(({item}) => item);
@@ -304,7 +296,8 @@ export class ListManager {
         if(blockAssignment.active.length > 0) {
           // "active" items remain, so we can filter cache records by those
           // items with remaining blocks to be assigned and get >= 1 result
-          cacheRecords = cacheRecords.filter(
+          // FIXME: do internally
+          cache.records = cache.records.filter(
             ({blockAssignmentDoc: {content}}) =>
               content.assignedBlockCount < content.blockCount);
         } else {
@@ -322,7 +315,7 @@ export class ListManager {
           blockAssignment.inactive = blockAssignment.inactive.filter(
             item => item !== toUpdate.item);
           blockAssignment.active = [toUpdate.item];
-          cacheRecords = [toUpdate];
+          cache.records = [toUpdate];
           // FIXME: determine how SLC IDs will be stored
           // toUpdate.item.slcIds = slcIds;
           toUpdate.item.statusListCredential = slcIds[0].id;
@@ -335,7 +328,7 @@ export class ListManager {
             content, slSequence: toUpdate.item.slSequence, statusListConfig
           });
         }
-        // 1.3.2. CW update LMD.
+        // 1.4.2. CW update LMD.
         try {
           this.lmDoc = await edvClient.update({doc: this.lmDoc});
         } catch(e) {
@@ -346,7 +339,7 @@ export class ListManager {
           this.lmDoc = await edvClient.get({id: this.lmDoc.id});
           continue;
         }
-        // 1.3.4. CW update active BAD, if one was updated.
+        // 1.4.4. CW update active BAD, if one was updated.
         if(toUpdate) {
           /* Note: If `continue` were just called here instead, it would work
           properly, but be slower because the active items all have to be
@@ -361,17 +354,14 @@ export class ListManager {
             if(e.name !== 'InvalidStateError') {
               throw e;
             }
-            // 1.3.5. If conflict, read LMD and loop to 1.
+            // 1.4.5. If conflict, read LMD and loop to 1.
             this.lmDoc = await edvClient.get({id: this.lmDoc.id});
             continue;
           }
         }
       }
-      // 1.4. Set read BADs as the active cache.
-      // FIXME: just to already instantiated cache above
-      this.activeCache = new IndexAllocationCache({
-        edvClient, records: cacheRecords
-      });
+      // 1.5. Set `cache` as the active cache.
+      this.activeCache = cache;
     }
   }
 
