Struct SingleFlight 

pub struct SingleFlight { /* private fields */ }

Guard for a single-flight fill, returned by CacheKit::single_flight.

Holds the per-key in-process lock for its whole lifetime, and the distributed fill lock (if one was acquired) until Self::release. Dropping without release is safe: the in-process lock frees immediately and a distributed lock expires server-side after its timeout.

Implementations

impl SingleFlight

pub async fn wait_for_fill(&mut self) -> bool

true while another worker may still be filling this key — re-check the cache after every true before computing yourself:

• Leader: immediately false (compute, don’t re-read your own miss).
• Queued behind a local holder: true once, for the re-check, then false. If the holder found the distributed lock contested and let go without a fill, a missed re-check first contests that lock and then behaves as a leader or a contested flight.
• Contested cross-process: sleeps one poll interval per call, true until the lock timeout (5 s), measured from this flight’s lock attempt, has passed. A hung re-check is not cut short here; #[cachekit] bounds its own.

pub async fn release(self)

Release the flight. Best-effort: frees the distributed fill lock (if held) so other processes stop waiting early. A failed release is traced (feature tracing) and otherwise ignored: the lock expires server-side regardless. Leaves the stand-down note as it is (see the FlightMap docs), since a caller may release after an error, with no fill.