Struct RateLimited 

pub struct RateLimited {
    pub kind: RateLimitKind,
    pub retry_after: Option<Duration>,
    pub remaining: Option<u64>,
    pub reset_unix_secs: Option<u64>,
}

An exhausted rate limit, as a state something can display.

The Definition of Done asks for “a distinct, displayable state rather than an opaque error”, and the distinction is the point: a rate limit is the one failure in this gateway that is neither the operator’s fault nor a reason to change anything. It resolves by waiting, and the operator’s only legitimate question is “how long”, which is what every field here answers.

Fields

kind: RateLimitKind

retry_after: Option<Duration>

retry-after, when GitHub sent one in the integer-seconds form.

remaining: Option<u64>

x-ratelimit-remaining.

reset_unix_secs: Option<u64>

x-ratelimit-reset, a Unix timestamp in seconds.

Implementations

impl RateLimited

pub fn detect(error: &GithubError) -> Option<Self>

Whether this failure is GitHub declining to serve any more requests for now — and if so, which limit.

Why this is narrower than “remaining is zero”

GitHub attaches x-ratelimit-* to every response, successful ones included. A 404 that happens to arrive on the request that exhausted the hourly quota therefore carries x-ratelimit-remaining: 0 while having nothing to do with rate limiting — and reporting it as a rate limit would tell the operator to wait for a repository name that will never resolve.

So the status has to be one GitHub actually rate-limits with — 403 or 429 — before the headers are read at all. And a 403 is not enough on its own, because 403 is also how GitHub refuses a missing permission. The two questions are therefore answered in order:

Is this a rate limit at all? Only a 429, or a 403 whose message says “rate limit”, qualifies. The message is the same evidence crate::AuthenticatedClient already uses to keep a rate limit from being misreported as an authentication lockout, and reading it the same way here is what keeps the two layers agreeing. Everything else is a permissions answer, whatever the headers say — see a_permissions_403_that_lands_on_an_exhausted_quota_is_still_forbidden.

Which limit is it? Now the headers matter. x-ratelimit-remaining: 0 is the primary limit and takes precedence, because a 429 sent while the hourly quota is exhausted resets on the hourly schedule rather than on a short back-off. Anything else is the secondary limit.

pub fn delay_from(&self, now: Timestamp) -> Duration

How long to wait before asking again, given the current instant.

retry-after first, because it is GitHub’s explicit instruction; x-ratelimit-reset second, because a primary limit says when rather than how long; DEFAULT_RATE_LIMIT_BACKOFF when neither is usable, because “GitHub said stop and named no time” must still stop.

Clamped to MAX_RATE_LIMIT_BACKOFF. A remote header is not allowed to decide how long this product stays dark.

Trait Implementations

impl Clone for RateLimited

fn clone(&self) -> RateLimited

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RateLimited

impl Debug for RateLimited

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

Formats the value using the given formatter.

impl Display for RateLimited

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

Formats the value using the given formatter.

impl Eq for RateLimited

impl PartialEq for RateLimited

fn eq(&self, other: &RateLimited) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RateLimited