Method load_cache

nodedb/src/control/array_sync/ack_registry.rs:133–178

(db: &Database)

    }

    fn load_cache(db: &Database) -> crate::Result<HashMap<String, AckVector>> {
        let txn = db.begin_read().map_err(|e| crate::Error::Storage {
            engine: "array_sync".into(),
            detail: format!("ack_registry load begin_read: {e}"),
        })?;
        let table = txn
            .open_table(ACK_TABLE)
            .map_err(|e| crate::Error::Storage {
                engine: "array_sync".into(),
                detail: format!("ack_registry load open_table: {e}"),
            })?;

        let mut cache: HashMap<String, AckVector> = HashMap::new();
        let iter = table.iter().map_err(|e| crate::Error::Storage {
            engine: "array_sync".into(),
            detail: format!("ack_registry load iter: {e}"),
        })?;

        for entry in iter {
            let (k, v) = entry.map_err(|e| crate::Error::Storage {
                engine: "array_sync".into(),
                detail: format!("ack_registry load entry: {e}"),
            })?;
            let key = k.value();
            let val = v.value();

            let Some(array) = array_from_key(key) else {
                warn!("ack_registry: malformed key, skipping");
                continue;
            };
            let Some(replica_raw) = replica_id_from_key(key) else {
                warn!(array = %array, "ack_registry: cannot parse replica_id, skipping");
                continue;
            };
            if val.len() != 18 {
                warn!(array = %array, "ack_registry: ack hlc wrong length, skipping");
                continue;
            }
            let hlc_bytes: [u8; 18] = val.try_into().unwrap_or([0u8; 18]);
            let hlc = Hlc::from_bytes(&hlc_bytes);
            let replica_id = ReplicaId::new(replica_raw);
            cache.entry(array).or_default().record(replica_id, hlc);
        }

        Ok(cache)
    }

    /// Record an ack from `replica_id` for `array` at `ack_hlc`.
    ///