1 use crate::{IpAddr, LemmyError};
2 use std::{collections::HashMap, time::SystemTime};
3 use strum::IntoEnumIterator;
6 #[derive(Debug, Clone)]
7 struct RateLimitBucket {
8 last_checked: SystemTime,
12 #[derive(Eq, PartialEq, Hash, Debug, EnumIter, Copy, Clone, AsRefStr)]
13 pub(crate) enum RateLimitType {
21 /// Rate limiting based on rate type and IP addr
22 #[derive(Debug, Clone, Default)]
23 pub struct RateLimiter {
24 buckets: HashMap<RateLimitType, HashMap<IpAddr, RateLimitBucket>>,
28 fn insert_ip(&mut self, ip: &IpAddr) {
29 for rate_limit_type in RateLimitType::iter() {
30 if self.buckets.get(&rate_limit_type).is_none() {
31 self.buckets.insert(rate_limit_type, HashMap::new());
34 if let Some(bucket) = self.buckets.get_mut(&rate_limit_type) {
35 if bucket.get(ip).is_none() {
39 last_checked: SystemTime::now(),
48 /// Rate limiting Algorithm described here: https://stackoverflow.com/a/668327/1655478
49 #[allow(clippy::float_cmp)]
50 pub(super) fn check_rate_limit_full(
56 ) -> Result<(), LemmyError> {
58 if let Some(bucket) = self.buckets.get_mut(&type_) {
59 if let Some(rate_limit) = bucket.get_mut(ip) {
60 let current = SystemTime::now();
61 let time_passed = current.duration_since(rate_limit.last_checked)?.as_secs() as f64;
64 if rate_limit.allowance == -2f64 {
65 rate_limit.allowance = rate as f64;
68 rate_limit.last_checked = current;
69 rate_limit.allowance += time_passed * (rate as f64 / per as f64);
70 if rate_limit.allowance > rate as f64 {
71 rate_limit.allowance = rate as f64;
74 if rate_limit.allowance < 1.0 {
76 "Rate limited type: {}, IP: {}, time_passed: {}, allowance: {}",
82 Err(LemmyError::from_error_message(
84 "Too many requests. type: {}, IP: {}, {} per {} seconds",
93 rate_limit.allowance -= 1.0;