redis-throttle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6578fcf4ed5b682873d8f6c31a629bf8ab04fa3f747a6e85e67d552fa22ad40
+  data.tar.gz: c3d2ea3307187912af4d4f93ecee4f8a2fc2e386922511b63e3a9ad93e547c49
+SHA512:
+  metadata.gz: 861efde66ca39700db8a6922add9e7539ecd13b9ecea1a79fe14575df1ca75772ac49608a298bbdb92fce7ec7681cb40eeaf3768089e7481395c57eb6ad23418
+  data.tar.gz: a1299fb9d99b21c5cca90823812e77feda7fccc7ed4e69778afcd2bb87a0c74aa94f48746047f3fd8b02ccf2076d4344c4047ca499b69090bfffd823cdc6ae87

data/CHANGES.md

@@ -0,0 +1,7 @@
+# v0.0.1 (2020-08-17)
+
+* Initial release. Effectively this version represents extraction of concurrency
+  and threshold strategies from [sidekiq-throttled][].
+
+
+[sidekiq-throttled]: https://github.com/sensortower/sidekiq-throttled

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Alexey Zapparov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# Redis::Throttle
+
+[Redis](https://redis.io/) based threshold and concurrency throttling.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "redis-throttle"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install redis-throttle
+
+
+## Usage
+
+### Limit concurrency
+
+``` ruby
+# Allow 1 concurrent calls. If call takes more than 10 seconds, consider it
+# gone (as if process died, or by any other reason did not called `#release`):
+concurrency = Redis::Throttle::Concurrency.new(:bucket_name,
+  :limit => 1,
+  :ttl   => 10
+)
+
+concurrency.acquire(Redis.current, :token => "abc") # => true
+concurrency.acquire(Redis.current, :token => "xyz") # => false
+
+concurrency.release(Redis.current, :token => "abc")
+
+concurrency.acquire(Redis.current, :token => "xyz") # => true
+```
+
+### Limit threshold
+
+``` ruby
+# Allow 1 calls per 10 seconds:
+threshold = Redis::Throttle::Threshold.new(:bucket_name,
+  :limit  => 1,
+  :period => 10
+)
+
+threshold.acquire(Redis.current) # => true
+threshold.acquire(Redis.current) # => false
+
+sleep 10
+
+threshold.acquire(Redis.current) # => true
+```
+
+
+## Supported Ruby Versions
+
+This library aims to support and is tested against:
+
+* Ruby
+  * MRI 2.4.x
+  * MRI 2.5.x
+  * MRI 2.6.x
+  * MRI 2.7.x
+  * JRuby 9.2.x
+
+* [redis-rb](https://github.com/redis/redis-rb)
+  * 4.0.x
+  * 4.1.x
+  * 4.2.x
+
+* [redis-namespace](https://github.com/resque/redis-namespace)
+  * 1.6.x
+  * 1.7.x
+
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions,
+however support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version or
+implementation, you may volunteer to be a maintainer. Being a maintainer
+entails making sure all tests run and pass on that implementation. When
+something breaks on your implementation, you will be responsible for providing
+patches in a timely fashion. If critical issues for a particular implementation
+exist at the time of a major release, support for that Ruby version may be
+dropped.
+
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+Then, run `bundle exec rake spec` to run the tests with ruby-rb client.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to [rubygems.org][].
+
+
+## Contributing
+
+* Fork redis-throttle
+* Make your changes
+* Ensure all tests pass (`bundle exec rake`)
+* Send a merge request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access!
+
+
+## Copyright
+
+Copyright (c) 2020 Alexey Zapparov<br>
+See [LICENSE.txt][] for further details.
+
+
+[LICENSE.txt]: https://gitlab.com/ixti/redis-throttle/blob/master/LICENSE.txt

data/lib/redis/throttle.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "throttle/errors"
+require_relative "throttle/version"
+require_relative "throttle/concurrency"
+require_relative "throttle/threshold"
+
+# @see https://github.com/redis/redis-rb
+class Redis
+  # Distributed threshold and concurrency throttling.
+  module Throttle; end
+end

data/lib/redis/throttle/concurrency.lua

@@ -0,0 +1,13 @@
+local bucket, token, limit, ttl, now =
+  KEYS[1], ARGV[1], tonumber(ARGV[2]), tonumber(ARGV[3]), tonumber(ARGV[4])
+
+redis.call("ZREMRANGEBYSCORE", bucket, "-inf", "(" .. now)
+
+if limit <= redis.call("ZCARD", bucket) and not redis.call("ZSCORE", bucket, token) then
+  return 1
+end
+
+redis.call("ZADD", bucket, now + ttl, token)
+redis.call("EXPIRE", bucket, ttl)
+
+return 0

data/lib/redis/throttle/concurrency.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "./script"
+
+class Redis
+  module Throttle
+    class Concurrency
+      SCRIPT = Script.new(File.read("#{__dir__}/concurrency.lua"))
+      private_constant :SCRIPT
+
+      # @param bucket [#to_s]
+      # @param limit [#to_i]
+      # @param ttl [#to_i]
+      def initialize(bucket, limit:, ttl:)
+        @bucket = bucket.to_s
+        @limit  = limit.to_i
+        @ttl    = ttl.to_i
+      end
+
+      # @param redis [Redis, Redis::Namespace]
+      # @param token [#to_s]
+      # @return [Boolean]
+      def acquire(redis, token:)
+        SCRIPT
+          .call(redis, :keys => [@bucket], :argv => [token.to_s, @limit, @ttl, Time.now.to_i])
+          .zero?
+      end
+
+      # @param redis [Redis, Redis::Namespace]
+      # @param token [#to_s]
+      # @return [void]
+      def release(redis, token:)
+        redis.zrem(@bucket, token.to_s)
+      end
+
+      # @param redis [Redis, Redis::Namespace]
+      # @return [void]
+      def reset(redis)
+        redis.del(@bucket)
+      end
+    end
+  end
+end

data/lib/redis/throttle/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Redis
+  module Throttle
+    class Error < StandardError; end
+    class LuaError < Error; end
+  end
+end

data/lib/redis/throttle/script.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "digest"
+require "redis/errors"
+
+require_relative "./errors"
+
+class Redis
+  module Throttle
+    # Simple helper to run script by it's sha1 digest with fallbak to script
+    # load if it was not loaded yet.
+    class Script
+      # Redis error fired when script ID is unkown.
+      NOSCRIPT = "NOSCRIPT"
+      private_constant :NOSCRIPT
+
+      LUA_ERROR_MESSAGE = %r{
+        ERR\s
+        (?<message>Error\s(?:compiling|running)\sscript\s\(.*?\)):\s
+        (?:[^:]+:\d+:\s)+
+        (?<details>.+)
+      }x.freeze
+      private_constant :LUA_ERROR_MESSAGE
+
+      def initialize(source)
+        @source = -source.to_s
+        @digest = Digest::SHA1.hexdigest(@source)
+      end
+
+      def call(redis, keys: [], argv: [])
+        __call__(redis, :keys => keys, :argv => argv)
+      rescue Redis::CommandError => e
+        md = LUA_ERROR_MESSAGE.match(e.message.to_s)
+        raise unless md
+
+        raise LuaError, [md[:message], md[:details]].compact.join(": ")
+      end
+
+      private
+
+      def __call__(redis, keys:, argv:)
+        redis.evalsha(@digest, keys, argv)
+      rescue Redis::CommandError => e
+        raise unless e.message.include?(NOSCRIPT)
+
+        redis.eval(@source, keys, argv)
+      end
+    end
+  end
+end

data/lib/redis/throttle/threshold.lua

@@ -0,0 +1,12 @@
+local bucket, limit, period, now =
+  KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+
+if limit <= redis.call("LLEN", bucket) and now - redis.call("LINDEX", bucket, -1) < period then
+  return 1
+end
+
+redis.call("LPUSH", bucket, now)
+redis.call("LTRIM", bucket, 0, limit - 1)
+redis.call("EXPIRE", bucket, period)
+
+return 0

data/lib/redis/throttle/threshold.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./script"
+
+class Redis
+  module Throttle
+    class Threshold
+      SCRIPT = Script.new(File.read("#{__dir__}/threshold.lua"))
+      private_constant :SCRIPT
+
+      NOOP = ->(_) { nil }
+      private_constant :NOOP
+
+      # @param bucket [#to_s]
+      # @param limit [#to_i]
+      # @param period [#to_i]
+      def initialize(bucket, limit:, period:)
+        @bucket = bucket.to_s
+        @limit  = limit.to_i
+        @period = period.to_i
+      end
+
+      # @param redis [Redis, Redis::Namespace]
+      # @return [Boolean]
+      def acquire(redis)
+        SCRIPT
+          .call(redis, :keys => [@bucket], :argv => [@limit, @period, Time.now.to_i])
+          .zero?
+      end
+
+      # @param redis [Redis, Redis::Namespace]
+      # @return [void]
+      def reset(redis)
+        redis.del(@bucket)
+      end
+    end
+  end
+end

data/lib/redis/throttle/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Redis
+  module Throttle
+    # Gem version.
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: redis-throttle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexey Zapparov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email:
+- alexey@zapparov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGES.md
+- LICENSE.txt
+- README.md
+- lib/redis/throttle.rb
+- lib/redis/throttle/concurrency.lua
+- lib/redis/throttle/concurrency.rb
+- lib/redis/throttle/errors.rb
+- lib/redis/throttle/script.rb
+- lib/redis/throttle/threshold.lua
+- lib/redis/throttle/threshold.rb
+- lib/redis/throttle/version.rb
+homepage: https://gitlab.com/ixti/redis-throttle
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.com/ixti/redis-throttle
+  source_code_uri: https://gitlab.com/ixti/redis-throttle/tree/v0.0.1
+  bug_tracker_uri: https://gitlab.com/ixti/redis-throttle/issues
+  changelog_uri: https://gitlab.com/ixti/redis-throttle/blob/v0.0.1/CHANGES.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Redis based threshold and concurrency throttling.
+test_files: []