Crate gcra

Library which implements the core GCRA functionality in rust.

Features

• rate-limiter a LRU + expiring rate limiter. Implements Send + Sync so can be used asynchronously.

Usage

use gcra::{GcraState, RateLimit};

fn check_rate_limit() {
  const LIMIT: u32 = 1;
  // Create a rate limit that allows `1/1s`
  let rate_limit = RateLimit::per_sec(LIMIT);

  let mut user_state = GcraState::default();
  assert!(user_state.check_and_modify(&rate_limit, 1).is_ok());
  assert!(
      user_state.check_and_modify(&rate_limit, 1).is_err(),
      "We should be over the limit now"
  );
}

With rate-limiter

use std::sync::Arc;
use gcra::{GcraError, RateLimit, RateLimiter};

#[tokio::main]
async fn main() -> Result<(), GcraError> {
    let rate_limit = RateLimit::per_sec(2);
    let rate_limiter = Arc::new(RateLimiter::new(4));

    rate_limiter.check("key", &rate_limit, 1).await?;
    rate_limiter.check("key", &rate_limit, 1).await?;

    match rate_limiter.check("key", &rate_limit, 1).await {
        Err(GcraError::DeniedUntil { next_allowed_at }) => {
            print!("Denied: Request next at {:?}", next_allowed_at);
            Ok(())
        }
        unexpected => panic!("Opps something went wrong! {:?}", unexpected),
    }
}

Modules

• clock

Structs

• GcraState
  Holds the minmum amount of state necessary to implement a GRCA leaky buckets. Refer to: understanding GCRA
• RateLimit
  Defines the configuration for a GCRA rate limit.
• RateLimitEntry
• RateLimitGuard
  A simple wrapper to help make using RateLimits with GcraStates easier for basic cases.
• RateLimitRequest
• RateLimiter
  A sharded rate limiter implementation using an internal [GcraState] per entry. It is Send + Sync + Clone and manages an internal LRU with expiration.

Enums

• GcraError