Immutable Limit.id API

limitador-server/src/http_api/request_types.rs

@@ -30,7 +30,7 @@ pub struct Limit {
 impl From<&LimitadorLimit> for Limit {
  fn from(ll: &LimitadorLimit) -> Self {
  Self {
- id: ll.id().clone(),
+ id: ll.id().map(|id| id.to_string()),
  namespace: ll.namespace().as_ref().to_string(),
  max_value: ll.max_value(),
  seconds: ll.seconds(),
@@ -43,17 +43,24 @@ impl From<&LimitadorLimit> for Limit {
 
 impl From<Limit> for LimitadorLimit {
  fn from(limit: Limit) -> Self {
- let mut limitador_limit = Self::new(
- limit.namespace,
- limit.max_value,
- limit.seconds,
- limit.conditions,
- limit.variables,
- );
-
- if let Some(id) = limit.id {
- limitador_limit.set_id(id);
- }
+ let mut limitador_limit = if let Some(id) = limit.id {
+ Self::with_id(
+ id,
+ limit.namespace,
+ limit.max_value,
+ limit.seconds,
+ limit.conditions,
+ limit.variables,
+ )
+ } else {
+ Self::new(
+ limit.namespace,
+ limit.max_value,
+ limit.seconds,
+ limit.conditions,
+ limit.variables,
+ )
+ };
 
  if let Some(name) = limit.name {
  limitador_limit.set_name(name)

limitador/src/counter.rs

@@ -72,7 +72,7 @@ impl Counter {
  Duration::from_secs(self.limit.seconds())
  }
 
- pub fn id(&self) -> &Option<String> {
+ pub fn id(&self) -> Option<&str> {
  self.limit.id()
  }
 

limitador/src/limit.rs

@@ -334,16 +334,38 @@ impl Limit {
  }
  }
 
- pub fn namespace(&self) -> &Namespace {
- &self.namespace
+ pub fn with_id<S: Into<String>, N: Into<Namespace>, T: TryInto<Condition>>(
+ id: S,
+ namespace: N,
+ max_value: u64,
+ seconds: u64,
+ conditions: impl IntoIterator<Item = T>,
+ variables: impl IntoIterator<Item = impl Into<String>>,
+ ) -> Self
+ where
+ <N as TryInto<Namespace>>::Error: core::fmt::Debug,
+ <T as TryInto<Condition>>::Error: core::fmt::Debug,
+ {
+ Self {
+ id: Some(id.into()),
+ namespace: namespace.into(),
+ max_value,
+ seconds,
+ name: None,
+ conditions: conditions
+ .into_iter()
+ .map(|cond| cond.try_into().expect("Invalid condition"))
+ .collect(),
+ variables: variables.into_iter().map(|var| var.into()).collect(),
+ }
  }
 
- pub fn set_id(&mut self, value: String) {
- self.id = Some(value);
+ pub fn namespace(&self) -> &Namespace {
+ &self.namespace
  }
 
- pub fn id(&self) -> &Option<String> {
- &self.id
+ pub fn id(&self) -> Option<&str> {
+ self.id.as_deref()
  }
 
  pub fn max_value(&self) -> u64 {
@@ -1012,15 +1034,15 @@ mod tests {
 
  #[test]
  fn limit_id() {
- let mut limit = Limit::new(
+ let limit = Limit::with_id(
+ "test_id",
  "test_namespace",
  10,
  60,
  vec!["req.method == 'GET'"],
  vec!["app_id"],
  );
- limit.set_id("test_id".to_string());
 
- assert_eq!(limit.id().clone(), Some("test_id".to_string()))
+ assert_eq!(limit.id(), Some("test_id"))
  }
 }

limitador/src/storage/keys.rs

@@ -40,26 +40,25 @@ pub fn key_for_counter(counter: &Counter) -> Vec<u8> {
 }
 
 pub fn key_for_counters_of_limit(limit: &Limit) -> Vec<u8> {
- if limit.id().is_none() {
- let namespace = limit.namespace().as_ref();
- format!(
- "namespace:{{{namespace}}},counters_of_limit:{}",
- serde_json::to_string(limit).unwrap()
- )
- .into_bytes()
- } else {
+ if let Some(id) = limit.id() {
  #[derive(PartialEq, Debug, Serialize, Deserialize)]
  struct IdLimitKey<'a> {
  id: &'a str,
  }
 
- let id = limit.id().as_ref().unwrap();
- let key = IdLimitKey { id: id.as_ref() };
+ let key = IdLimitKey { id };
 
  let mut encoded_key = Vec::new();
  encoded_key = postcard::to_extend(&2u8, encoded_key).unwrap();
  encoded_key = postcard::to_extend(&key, encoded_key).unwrap();
  encoded_key
+ } else {
+ let namespace = limit.namespace().as_ref();
+ format!(
+ "namespace:{{{namespace}}},counters_of_limit:{}",
+ serde_json::to_string(limit).unwrap()
+ )
+ .into_bytes()
  }
 }
 
@@ -130,14 +129,14 @@ mod tests {
 
  #[test]
  fn key_for_limit_with_id_format() {
- let mut limit = Limit::new(
+ let limit = Limit::with_id(
+ "test_id",
  "example.com",
  10,
  60,
  vec!["req.method == 'GET'"],
  vec!["app_id"],
  );
- limit.set_id("test_id".to_string());
  assert_eq!(
  "\u{2}\u{7}test_id".as_bytes(),
  key_for_counters_of_limit(&limit)
@@ -182,7 +181,7 @@ pub mod bin {
  impl<'a> From<&'a Counter> for IdCounterKey<'a> {
  fn from(counter: &'a Counter) -> Self {
  IdCounterKey {
- id: counter.id().as_ref().unwrap().as_ref(),
+ id: counter.id().unwrap(),
  variables: counter.variables_for_key(),
  }
  }
@@ -280,8 +279,14 @@ pub mod bin {
  .collect();
 
  // we are not able to rebuild the full limit since we only have the id and variables.
- let mut limit = Limit::new::<&str, &str>("", u64::default(), 0, vec![], map.keys());
- limit.set_id(id.to_string());
+ let limit = Limit::with_id::<&str, &str, &str>(
+ id,
+ "",
+ u64::default(),
+ 0,
+ vec![],
+ map.keys(),
+ );
  Counter::new(limit, map)
  }
  _ => panic!("Unknown version: {}", version),
@@ -316,14 +321,13 @@ pub mod bin {
 
  #[cfg(test)]
  mod tests {
- use crate::counter::Counter;
- use crate::Limit;
- use std::collections::HashMap;
-
  use super::{
  key_for_counter, key_for_counter_v2, partial_counter_from_counter_key,
  prefix_for_namespace, CounterKey,
  };
+ use crate::counter::Counter;
+ use crate::Limit;
+ use std::collections::HashMap;
 
  #[test]
  fn counter_key_serializes_and_back() {
@@ -375,9 +379,14 @@ pub mod bin {
  let namespace = "ns_counter:";
  let limit_without_id =
  Limit::new(namespace, 1, 1, vec!["req.method == 'GET'"], vec!["app_id"]);
- let mut limit_with_id =
- Limit::new(namespace, 1, 1, vec!["req.method == 'GET'"], vec!["app_id"]);
- limit_with_id.set_id("id200".to_string());
+ let limit_with_id = Limit::with_id(
+ "id200",
+ namespace,
+ 1,
+ 1,
+ vec!["req.method == 'GET'"],
+ vec!["app_id"],
+ );
 
  let counter_with_id = Counter::new(limit_with_id, HashMap::default());
  let serialized_with_id_counter = key_for_counter(&counter_with_id);

limitador/tests/integration_tests.rs

@@ -523,14 +523,14 @@ mod test {
  async fn rate_limited_id_counter(rate_limiter: &mut TestsLimiter) {
  let namespace = "test_namespace";
  let max_hits = 3;
- let mut limit = Limit::new(
+ let limit = Limit::with_id(
+ "test-rate_limited_id_counter",
  namespace,
  max_hits,
  60,
  vec!["req.method == 'GET'"],
  vec!["app_id"],
  );
- limit.set_id("test-rate_limited_id_counter".to_string());
 
  rate_limiter.add_limit(&limit).await;