use std::{fmt, time::Duration};
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::result::{ClassifyError, ErrorKind};
pub const DEFAULT_MAX_RATE_LIMIT_BUCKETS: usize = 10_000;
pub const MAX_RATE_LIMIT_HEADER_VALUE_BYTES: usize = 1024;
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RateLimitRequestPolicy {
Enabled,
#[default]
Disabled,
}
impl RateLimitRequestPolicy {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Enabled => "enabled",
Self::Disabled => "disabled",
}
}
#[must_use]
pub const fn enabled(self) -> bool {
matches!(self, Self::Enabled)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct RateLimitConfig {
capacity: u32,
refill_tokens: u32,
refill_interval: Duration,
}
impl RateLimitConfig {
pub fn new(
capacity: u32,
refill_tokens: u32,
refill_interval: Duration,
) -> Result<Self, RateLimitError> {
if capacity == 0 {
return Err(RateLimitError::InvalidCapacity);
}
if refill_tokens == 0 {
return Err(RateLimitError::InvalidRefillTokens);
}
if refill_interval.is_zero() {
return Err(RateLimitError::InvalidRefillInterval);
}
Ok(Self {
capacity,
refill_tokens,
refill_interval,
})
}
#[must_use]
pub const fn capacity(&self) -> u32 {
self.capacity
}
#[must_use]
pub const fn refill_tokens(&self) -> u32 {
self.refill_tokens
}
#[must_use]
pub const fn refill_interval(&self) -> Duration {
self.refill_interval
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct RateLimitDecision {
pub(super) kind: RateLimitDecisionKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum RateLimitDecisionKind {
Allowed { remaining: u32 },
Denied { retry_after: Duration },
}
impl RateLimitDecision {
#[must_use]
pub const fn allowed(remaining: u32) -> Self {
Self {
kind: RateLimitDecisionKind::Allowed { remaining },
}
}
#[must_use]
pub const fn denied(retry_after: Duration) -> Self {
Self {
kind: RateLimitDecisionKind::Denied { retry_after },
}
}
#[must_use]
pub const fn is_allowed(&self) -> bool {
matches!(self.kind, RateLimitDecisionKind::Allowed { .. })
}
#[must_use]
pub const fn remaining(&self) -> u32 {
match self.kind {
RateLimitDecisionKind::Allowed { remaining } => remaining,
RateLimitDecisionKind::Denied { .. } => 0,
}
}
#[must_use]
pub const fn retry_after(&self) -> Option<Duration> {
match self.kind {
RateLimitDecisionKind::Allowed { .. } => None,
RateLimitDecisionKind::Denied { retry_after } => Some(retry_after),
}
}
}
#[derive(Error)]
#[non_exhaustive]
pub enum RateLimitError {
#[error("rate limit capacity must be greater than zero")]
InvalidCapacity,
#[error("rate limit refill_tokens must be greater than zero")]
InvalidRefillTokens,
#[error("rate limit refill_interval must be greater than zero")]
InvalidRefillInterval,
#[error("rate limit max buckets must be greater than zero")]
InvalidMaxBuckets,
#[error("rate limit configuration differs from the store policy")]
ConfigMismatch,
#[error("rate limiter bucket capacity is exhausted")]
CapacityExceeded,
#[error("rate limiter state lock is poisoned")]
LockPoisoned,
#[error("rate limit store is unavailable")]
Store(#[source] crate::result::BoxError),
}
impl fmt::Debug for RateLimitError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("RateLimitError")
.field("code", &self.error_code())
.finish_non_exhaustive()
}
}
impl ClassifyError for RateLimitError {
fn error_kind(&self) -> ErrorKind {
match self {
Self::InvalidCapacity
| Self::InvalidRefillTokens
| Self::InvalidRefillInterval
| Self::InvalidMaxBuckets
| Self::ConfigMismatch => ErrorKind::Validation,
Self::CapacityExceeded | Self::LockPoisoned | Self::Store(_) => ErrorKind::Unavailable,
}
}
fn error_code(&self) -> crate::result::ErrorCode {
crate::result::ErrorCode::internal(match self {
Self::InvalidCapacity => "rate_limit_invalid_capacity",
Self::InvalidRefillTokens => "rate_limit_invalid_refill_tokens",
Self::InvalidRefillInterval => "rate_limit_invalid_refill_interval",
Self::InvalidMaxBuckets => "rate_limit_invalid_max_buckets",
Self::ConfigMismatch => "rate_limit_config_mismatch",
Self::CapacityExceeded => "rate_limit_capacity_exceeded",
Self::LockPoisoned => "rate_limit_lock_poisoned",
Self::Store(_) => "rate_limit_store_unavailable",
})
}
}