gcra 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2aa36cd71aea4bfc16ba99bc633fd8c6ab2fffc6
+  data.tar.gz: 2a14cda68fe7237ee3b73fb9e804c845bbe50a67
+SHA512:
+  metadata.gz: 56f422072041b5029ab157d0de4cf663b924d22dccdbf957acb241419cd35bfecde7c179f4b8d64cfd60893974daa5ea02d8c3032229ac0b6f6955f08f93cf8b
+  data.tar.gz: 18932fe87d83d41b2abedb7c06eca4f6e29ee75e186a744d1e5e61c1e0cb46d2fc41ea6d3161fbd095fae311f7bf26a3fd0ccdea924500baca2754bed416ad5f

data/lib/gcra/rate_limiter.rb

@@ -0,0 +1,100 @@
+module GCRA
+  RateLimitInfo = Struct.new(
+    :limit,
+    :remaining,
+    :reset_after,
+    :retry_after
+  )
+
+  class StoreUpdateFailed < RuntimeError; end
+
+  class RateLimiter
+    MAX_ATTEMPTS = 10
+    NANO_SECOND = 1_000_000_000
+
+    # rate_period in seconds
+    def initialize(store, rate_period, max_burst)
+      @store = store
+      # Convert from seconds to nanoseconds. Ruby's time types return floats from calculations,
+      # which is not what we want. Also, there's no proper type for durations.
+      @emission_interval = (rate_period * NANO_SECOND).to_i
+      @delay_variation_tolerance = @emission_interval * (max_burst + 1)
+      @limit = max_burst + 1
+    end
+
+    def limit(key, quantity)
+      i = 0
+
+      while i < MAX_ATTEMPTS
+        # tat refers to the theoretical arrival time that would be expected
+        # from equally spaced requests at exactly the rate limit.
+        tat_from_store, now = @store.get_with_time(key)
+
+        tat = if tat_from_store.nil?
+                now
+              else
+                tat_from_store
+              end
+
+        increment = quantity * @emission_interval
+
+        # new_tat describes the new theoretical arrival if the request would succeed.
+        # If we get a `tat` in the past (empty bucket), use the current time instead. Having
+        # a delay_variation_tolerance >= 1 makes sure that at least one request with quantity 1 is
+        # possible when the bucket is empty.
+        new_tat = [now, tat].max + increment
+
+        allow_at_and_after = new_tat - @delay_variation_tolerance
+        if now < allow_at_and_after
+
+          info = RateLimitInfo.new
+          info.limit = @limit
+
+          # Bucket size in duration minus time left until TAT, divided by the emission interval
+          # to get a count
+          # This is non-zero when a request with quantity > 1 is limited, but lower quantities
+          # are still allowed.
+          info.remaining = ((@delay_variation_tolerance - (tat - now)) / @emission_interval).to_i
+
+          # Use `tat` instead of `newTat` - we don't further increment tat for a blocked request
+          info.reset_after = (tat - now).to_f / NANO_SECOND
+
+          # There's no point in setting retry_after if a request larger than the maximum quantity
+          # is attempted.
+          if increment <= @delay_variation_tolerance
+            info.retry_after = (allow_at_and_after - now).to_f / NANO_SECOND
+          end
+
+          return true, info
+        end
+
+        # Time until bucket is empty again
+        ttl = new_tat - now
+
+        new_value = new_tat.to_i
+
+        updated = if tat_from_store.nil?
+                    @store.set_if_not_exists_with_ttl(key, new_value, ttl)
+                  else
+                    @store.compare_and_set_with_ttl(key, tat_from_store, new_value, ttl)
+                  end
+
+        if updated
+          info = RateLimitInfo.new
+          info.limit = @limit
+          info.remaining = ((@delay_variation_tolerance - ttl) / @emission_interval).to_i
+          info.reset_after = ttl.to_f / NANO_SECOND
+          info.retry_after = nil
+
+          return false, info
+        end
+
+        i += 1
+      end
+
+      raise StoreUpdateFailed.new(
+        "Failed to store updated rate limit data for key '#{key}' after #{MAX_ATTEMPTS} attempts"
+      )
+    end
+  end
+end

data/lib/gcra/redis_store.rb

@@ -0,0 +1,73 @@
+module GCRA
+  # Redis store, expects all timestamps and durations to be integers with nanoseconds since epoch.
+  class RedisStore
+    CAS_SCRIPT = <<-EOF.freeze
+  local v = redis.call('get', KEYS[1])
+  if v == false then
+    return redis.error_reply("key does not exist")
+  end
+  if v ~= ARGV[1] then
+    return 0
+  end
+  if ARGV[3] ~= "0" then
+    redis.call('psetex', KEYS[1], ARGV[3], ARGV[2])
+  else
+    redis.call('set', KEYS[1], ARGV[2])
+  end
+  return 1
+  EOF
+    CAS_SCRIPT_MISSING_KEY_RESPONSE = 'key does not exist'.freeze
+
+    def initialize(redis, key_prefix)
+      @redis = redis
+      @key_prefix = key_prefix
+    end
+
+    # Returns the value of the key or nil, if it isn't in the store.
+    # Also returns the time from the Redis server, with microsecond precision.
+    def get_with_time(key)
+      time_response = @redis.time # returns tuple (seconds since epoch, microseconds)
+      # Convert tuple to nanoseconds
+      time = (time_response[0] * 1_000_000 + time_response[1]) * 1_000
+      value = @redis.get(@key_prefix + key)
+      if value != nil
+        value = value.to_i
+      end
+
+      return value, time
+    end
+
+    # Set the value of key only if it is not already set. Return whether the value was set.
+    # Also set the key's expiration (ttl, in seconds). The operations are not performed atomically.
+    def set_if_not_exists_with_ttl(key, value, ttl_nano)
+      full_key = @key_prefix + key
+      did_set = @redis.setnx(full_key, value)
+
+      if did_set && ttl_nano > 0
+        ttl_milli = ttl_nano / 1_000_000
+        puts "TTL: #{ttl_milli}"
+        @redis.pexpire(full_key, ttl_milli)
+      end
+
+      return did_set
+    end
+
+    # Atomically compare the value at key to the old value. If it matches, set it to the new value
+    # and return true. Otherwise, return false. If the key does not exist in the store,
+    # return false with no error. If the swap succeeds, update the ttl for the key atomically.
+    def compare_and_set_with_ttl(key, old_value, new_value, ttl_nano)
+      full_key = @key_prefix + key
+      begin
+        ttl_milli = ttl_nano / 1_000_000
+        swapped = @redis.eval(CAS_SCRIPT, keys: [full_key], argv: [old_value, new_value, ttl_milli])
+      rescue Redis::CommandError => e
+        if e.message == CAS_SCRIPT_MISSING_KEY_RESPONSE
+          return false
+        end
+        raise
+      end
+
+      return swapped == 1
+    end
+  end
+end

data/lib/gcra/version.rb

@@ -0,0 +1,3 @@
+module GCRA
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: gcra
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Frister
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: GCRA implementation for rate limiting
+email:
+- michael.frister@barzahlen.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gcra/rate_limiter.rb
+- lib/gcra/redis_store.rb
+- lib/gcra/version.rb
+homepage: https://github.com/Barzahlen/gcra
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of a generic cell rate algorithm (GCRA), ported from
+  the Go implementation throttled.
+test_files: []