Struct RestDemand 

pub struct RestDemand { /* private fields */ }

DemandGateway over api.github.com.

Holds no credential of its own: authentication is entirely AuthenticatedClient’s, and this type only ever hands it an ApiRequest.

Why this is not a method on c3’s RestInventory

It would be the better shape, and it is not available. RestInventory::get — the one place cancellation, request accounting and the rate-limit gate meet — is private to crates/github/src/rest.rs, and a sibling module cannot reach a private item. Making it pub(crate) is an edit to c3’s file, which this task does not own, so the choice was between duplicating c3’s whole rate-limit policy here and consuming what c3 already exports. This consumes.

What “consuming c3’s rate-limit policy” means precisely

RateLimited::detect is c3’s decision procedure for whether a failure is a rate limit and which of GitHub’s two it is, including the part that keeps a permissions 403 landing on an exhausted quota from being misreported as one. It is public, and this module calls it rather than re-deciding.

What this module deliberately does not copy is c3’s in-gateway back-off latch, the window during which RestInventory opens no socket at all. A second latch would be a second, quietly divergent copy of a policy that only works if there is one of it. The scheduling floor is crate::rest::RefreshState::retry_delay, which c3 documents as “the absolute floor on when e1 may try again” — an e1 honouring it stops demand polling for the same window, from the layer that owns the schedule.

The residual gap is stated rather than hidden: a rate limit whose first evidence arrives on a demand request does not silence RestInventory, and vice versa. Both report InventoryError::RateLimited to e1, which is the layer that can act on either.

Implementations

impl RestDemand

pub fn new(client: Arc<AuthenticatedClient>, clock: Arc<dyn Clock>) -> Self

pub fn with_shared_readings(self, window: Duration) -> Self

Hand a repository’s reading to every target that asks within window of it being fetched. See [SharedReadings].

The daemon passes its idle interval: a repository is then read at most once per idle interval, and a target sharing it sees a reading no older than that.

pub fn set_shared_window(&self, window: Duration)

Change the sharing window while running.

pub fn forget_shared_reading(&self, repository: &OwnerRepo)

Drops repository’s shared reading, so the next target to ask for it reads GitHub instead of being handed a reading from before.

For a coordinator’s wake: GitHub just said this repository’s queue changed, so a reading shared from a few seconds ago is known stale. Nothing else is bypassed — the conditional cache still makes an unchanged listing a free 304, and the rate-limit quiet period still withholds every request inside it.

pub fn stats(&self) -> DemandStats

What this gateway has done.

pub const fn client(&self) -> &Arc<AuthenticatedClient>

The client every request goes through, for its traffic counters.

pub fn requests_issued(&self) -> u64

How many HTTP requests this gateway has issued.

demand_requests_per_poll projects a cost and this measures it. A projection nothing measures is a table in a document, which is why c3 exposes the same counter and why the tests below assert one against the other.

Trait Implementations

impl Debug for RestDemand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DemandGateway for RestDemand

fn queued_demand<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 ActivityScope, cancel: &'life2 CancelToken, ) -> Pin<Box<dyn Future<Output = Result<QueuedDemand, InventoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Queued workflow runs across scope.

fn now(&self) -> Timestamp

The instant a reading is stamped with.