Enum RateLimitKey 

pub enum RateLimitKey {
    ApiKey(Uuid),
    User(Uuid),
    Ip(IpAddr),
    Account {
        route: String,
        email: String,
    },
    KeyCheck {
        ip: Option<IpAddr>,
        api_key: Uuid,
    },
}

Rate limit key: identity-based when authenticated, IP-based otherwise.

Examples

use std::net::{IpAddr, Ipv4Addr};
use uuid::Uuid;
use ironflow_api::rate_limit::RateLimitKey;

let ip_key = RateLimitKey::Ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
let user_key = RateLimitKey::User(Uuid::nil());
let api_key = RateLimitKey::ApiKey(Uuid::nil());
let account_key = RateLimitKey::Account {
    route: "/sign-in".to_string(),
    email: "alice@ironflow.dev".to_string(),
};
let key_check = RateLimitKey::KeyCheck {
    ip: Some(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))),
    api_key: Uuid::nil(),
};

Variants

ApiKey(Uuid)

Authenticated via API key.

User(Uuid)

Authenticated via JWT.

Ip(IpAddr)

Unauthenticated, identified by client IP.

Account

The account a credential request targets on one route.

Fields

route: String

Path of the credential route, so sign-up and sign-in are counted apart.

email: String

Normalized email of the account.

KeyCheck

Argon2 verifications of an API key secret not yet in the cache, by client IP, or by key alone when the server has no peer address.

Keyed on both so an attacker cannot exhaust the budget of a victim key from another address, and one NAT address using many keys is not throttled.

Fields

ip: Option<IpAddr>

Client IP, None when the server has no peer address.

api_key: Uuid

ID of the API key whose secret is checked.

Trait Implementations

impl Clone for RateLimitKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RateLimitKey

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

Formats the value using the given formatter.

impl Eq for RateLimitKey

impl Hash for RateLimitKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RateLimitKey

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RateLimitKey