Struct SharedReads 

struct SharedReads {
    in_flight: Arc<Mutex<HashMap<String, Arc<PendingRead>>>>,
}

Keychain reads, at most one in flight per account.

A read runs on a detached thread, and its caller gives up after a timeout; the platform call underneath can’t be cancelled and stays queued behind an unanswered consent dialog. Without this, every retry queued another one: on 2026-10-08 an hour of once-a-minute retries behind one open dialog meant each Deny showed the next queued read’s dialog, six in two seconds. Now a read of an account that already has one in flight waits on that one, under its own timeout, so an open dialog stays one dialog. Nothing is cached: a read that starts after the answer arrived reads again.

Fields

in_flight: Arc<Mutex<HashMap<String, Arc<PendingRead>>>>

Implementations

impl SharedReads

fn new() -> Self

fn read( &self, account_id: &str, timeout: Duration, read: impl FnOnce() -> Result<Option<Zeroizing<String>>, String> + Send + 'static, ) -> Result<Result<Option<Zeroizing<String>>, String>, RunOutcome>

Wait up to timeout for account_id’s read, starting it with read unless one is already in flight. The RunOutcome is separate from any error the read itself returns; callers fold it into their own message (run_outcome_message).

fn read_with( &self, account_id: &str, timeout: Duration, read: impl FnOnce() -> Result<Option<Zeroizing<String>>, String> + Send + 'static, spawn: impl FnOnce(Box<dyn FnOnce() + Send>) -> Result<()>, ) -> Result<Result<Option<Zeroizing<String>>, String>, RunOutcome>

read with the thread start passed in, so a test can make it fail.

fn forget(&self, account_id: &str)

Stop sharing account_id’s in-flight read: the next read starts its own. Called after a write, so no read that starts after it can get the value from before it.

fn after_write<T>( &self, account_id: &str, written: Result<T, String>, ) -> Result<T, String>

Pass a write’s result through, forgetting the account’s in-flight read only if the write succeeded. A failed write changed nothing, and forgetting then would let the next retry start a second read beside the one still blocked on a dialog.