Reset the data need in deserialized Limits

limitador/src/counter.rs

@@ -48,6 +48,17 @@ impl Counter {
         self.limit.max_value()
     }
 
+    pub fn update_to_limit(&mut self, limit: &Limit) -> bool {
+        if limit == &self.limit {
+            self.limit.set_max_value(limit.max_value());
+            if let Some(name) = limit.name() {
+                self.limit.set_name(name.to_string());
+            }
+            return true;
+        }
+        false
+    }
+
     pub fn seconds(&self) -> u64 {
         self.limit.seconds()
     }

limitador/src/lib.rs

@@ -201,6 +201,7 @@ use crate::storage::{AsyncCounterStorage, AsyncStorage, Authorization, CounterSt
 
 #[macro_use]
 extern crate lazy_static;
+extern crate core;
 
 pub mod counter;
 pub mod errors;

limitador/src/limit.rs

@@ -26,10 +26,10 @@ impl From<String> for Namespace {
 #[derive(Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct Limit {
     namespace: Namespace,
-    // #[serde(skip_serializing)]
+    #[serde(skip)]
     max_value: i64,
     seconds: u64,
-    // #[serde(skip_serializing)]
+    #[serde(skip)]
     name: Option<String>,
 
     // Need to sort to generate the same object when using the JSON as a key or
@@ -90,6 +90,10 @@ impl Limit {
         self.name = Some(name)
     }
 
+    pub fn set_max_value(&mut self, value: i64) {
+        self.max_value = value;
+    }
+
     pub fn conditions(&self) -> HashSet<String> {
         self.conditions.iter().map(|cond| cond.into()).collect()
     }

limitador/src/storage/infinispan/infinispan_storage.rs

@@ -102,7 +102,7 @@ impl AsyncCounterStorage for InfinispanStorage {
                 // unnecessarily.
 
                 if let Some(val) = counter_val {
-                    let mut counter: Counter = counter_from_counter_key(&counter_key);
+                    let mut counter: Counter = counter_from_counter_key(&counter_key, &limit);
                     let ttl = 0; // TODO: calculate TTL from response headers.
                     counter.set_remaining(val);
                     counter.set_expires_in(Duration::from_secs(ttl));

limitador/src/storage/keys.rs

@@ -31,11 +31,21 @@ pub fn key_for_counters_of_limit(limit: &Limit) -> String {
     )
 }
 
-pub fn counter_from_counter_key(key: &str) -> Counter {
+pub fn counter_from_counter_key(key: &str, limit: &Limit) -> Counter {
     let counter_prefix = "counter:";
     let start_pos_counter = key.find(counter_prefix).unwrap() + counter_prefix.len();
 
-    serde_json::from_str(&key[start_pos_counter..]).unwrap()
+    let mut counter: Counter = serde_json::from_str(&key[start_pos_counter..]).unwrap();
+    if !counter.update_to_limit(limit) {
+        // this means some kind of data corruption _or_ most probably
+        // an out of sync `impl PartialEq for Limit` vs `pub fn key_for_counter(counter: &Counter) -> String`
+        panic!(
+            "Failed to rebuild Counter's Limit from the provided Limit: {:?} vs {:?}",
+            counter.limit(),
+            limit
+        )
+    }
+    counter
 }
 
 #[cfg(test)]

limitador/src/storage/redis/redis_async.rs

@@ -108,7 +108,7 @@ impl AsyncCounterStorage for AsyncRedisStorage {
                 .await?;
 
             for counter_key in counter_keys {
-                let mut counter: Counter = counter_from_counter_key(&counter_key);
+                let mut counter: Counter = counter_from_counter_key(&counter_key, &limit);
 
                 // If the key does not exist, it means that the counter expired,
                 // so we don't have to return it.

limitador/src/storage/redis/redis_sync.rs

@@ -94,7 +94,7 @@ impl CounterStorage for RedisStorage {
                 con.smembers::<String, HashSet<String>>(key_for_counters_of_limit(limit))?;
 
             for counter_key in counter_keys {
-                let mut counter: Counter = counter_from_counter_key(&counter_key);
+                let mut counter: Counter = counter_from_counter_key(&counter_key, limit);
 
                 // If the key does not exist, it means that the counter expired,
                 // so we don't have to return it.