Struct ForeignRecords 

pub struct ForeignRecords {
    pub(crate) fetcher: Arc<dyn Fetch>,
    pub(crate) limits: Limits,
    pub(crate) cache: Mutex<LruCache<String, Entry>>,
    pub(crate) hits: AtomicU64,
    pub(crate) misses: AtomicU64,
    pub(crate) unknowns: AtomicU64,
    pub(crate) refusals: AtomicU64,
}

The reader: a bounded cache of foreign records, over one Fetch.

Deployment-wide, not per session: plan/ai-preference.md’s “one resolver, one cache, deployment-wide” is the whole difference between being a good guest on somebody else’s server and being the traffic that gets a deployment defederated.

Fields

fetcher: Arc<dyn Fetch>

limits: Limits

cache: Mutex<LruCache<String, Entry>>

hits: AtomicU64

misses: AtomicU64

unknowns: AtomicU64

refusals: AtomicU64

Implementations

impl ForeignRecords

pub fn new(fetcher: Arc<dyn Fetch>, limits: Limits) -> Self

A reader over fetcher, bounded by limits.

An entries of zero holds one entry: a cache that holds nothing would make every read a fetch, which is the traffic pattern this crate exists to avoid.

pub fn over_network( local: Arc<dyn LocalRepositories>, private: PrivateAddresses, limits: Limits, ) -> Self

A reader over the real network, refusing what local already holds and refusing a private address unless private allows one.

pub fn limits(&self) -> Limits

What this reader is bounded by.

pub fn counts(&self) -> Counts

What this reader has done since the process started.

pub fn read(&self, record: &RecordRef) -> Answer

The answer held for record.

Performs no I/O and never awaits, so an evaluator may call it from inside a decision. A record nothing has fetched, and one whose answer has aged out, are both Unknown::NotFetched.

pub async fn prefetch(&self, wanted: &[RecordRef])

Fetches every record in wanted the cache holds no fresh answer for, and caches what comes back.

Bounded three ways: at most Limits::per_write records are fetched, each fetch by Limits::record_deadline, and the whole call by Limits::prefetch_deadline. A record the budget does not reach is cached as Unknown::Deadline, so the write that asked gets an answer either way and the next write does not queue behind the same dead server.

pub async fn get(&self, record: &RecordRef) -> Answer

prefetch for one record, then read of it — for a caller that has a runtime and wants the answer now rather than at a later decision.

pub(crate) fn fresh(&self, key: &str) -> bool

Whether the cache holds an answer for key that has not expired. Does not count as a read: a prefetch skipping a record it already holds is not an evaluator asking for one.

pub(crate) fn store(&self, record: &RecordRef, fetched: Fetched)

Caches one fetch’s outcome under record’s at-uri, for the TTL its kind of answer gets, and counts it.