store increments in redis

limitador/src/storage/redis/redis_async.rs

@@ -58,7 +58,6 @@ impl AsyncCounterStorage for AsyncRedisStorage {
             redis::Script::new(SCRIPT_UPDATE_COUNTER)
                 .key(key_for_counter(counter))
                 .key(key_for_counters_of_limit(counter.limit()))
-                .arg(counter.max_value())
                 .arg(counter.seconds())
                 .arg(delta)
                 .invoke_async::<_, _>(&mut con)
@@ -138,7 +137,6 @@ impl AsyncCounterStorage for AsyncRedisStorage {
                 let result = redis::Script::new(SCRIPT_UPDATE_COUNTER)
                     .key(key)
                     .key(key_for_counters_of_limit(counter.limit()))
-                    .arg(counter.max_value())
                     .arg(counter.seconds())
                     .arg(delta)
                     .invoke_async::<_, _>(&mut con)
@@ -187,7 +185,7 @@ impl AsyncCounterStorage for AsyncRedisStorage {
                         .await?
                 };
                 if let Some(val) = option {
-                    counter.set_remaining(val);
+                    counter.set_remaining(limit.max_value() - val);
                     let ttl = {
                         let span = trace_span!("datastore");
                         async { con.ttl(&counter_key).await }

limitador/src/storage/redis/redis_sync.rs

@@ -45,7 +45,6 @@ impl CounterStorage for RedisStorage {
         redis::Script::new(SCRIPT_UPDATE_COUNTER)
             .key(key_for_counter(counter))
             .key(key_for_counters_of_limit(counter.limit()))
-            .arg(counter.max_value())
             .arg(counter.seconds())
             .arg(delta)
             .invoke(&mut *con)?;
@@ -95,7 +94,6 @@ impl CounterStorage for RedisStorage {
             redis::Script::new(SCRIPT_UPDATE_COUNTER)
                 .key(key)
                 .key(key_for_counters_of_limit(counter.limit()))
-                .arg(counter.max_value())
                 .arg(counter.seconds())
                 .arg(delta)
                 .invoke(&mut *con)?;
@@ -125,7 +123,7 @@ impl CounterStorage for RedisStorage {
                 // This does not cause any bugs, but consumes memory
                 // unnecessarily.
                 if let Some(val) = con.get::<String, Option<i64>>(counter_key.clone())? {
-                    counter.set_remaining(val);
+                    counter.set_remaining(limit.max_value() - val);
                     let ttl = con.ttl(&counter_key)?;
                     counter.set_expires_in(Duration::from_secs(ttl));
 

limitador/src/storage/redis/scripts.rs

@@ -9,15 +9,15 @@
 
 // KEYS[1]: counter key
 // KEYS[2]: key that contains the counters that belong to the limit
-// ARGV[1]: counter max val
-// ARGV[2]: counter TTL
-// ARGV[3]: delta
+// ARGV[1]: counter TTL
+// ARGV[2]: delta
 pub const SCRIPT_UPDATE_COUNTER: &str = "
-    local set_res = redis.call('set', KEYS[1], ARGV[1], 'EX', ARGV[2], 'NX')
-    redis.call('incrby', KEYS[1], - ARGV[3])
-    if set_res then
-        redis.call('sadd', KEYS[2], KEYS[1])
-    end";
+    local c = redis.call('incrby', KEYS[1], ARGV[2])
+    if c == tonumber(ARGV[2]) then
+      redis.call('expire', KEYS[1], ARGV[1], 'NX')
+      redis.call('sadd', KEYS[2], KEYS[1])
+    end
+    return c";
 
 // KEYS: the function returns the value and TTL (in ms) for these keys
 // The first position of the list returned contains the value of KEYS[1], the

limitador/tests/integration_tests.rs

@@ -685,6 +685,7 @@ mod test {
                 if let Some(ttl) = counter.expires_in() {
                     assert!(ttl.as_secs() <= 60);
                 }
+                println!("check_rate_limited_and_update_load_counters: hit {}, remaining {}", hit, counter.remaining().unwrap())
                 assert_eq!(counter.remaining().unwrap(), 3 - (hit + 1));
             }
         }