rate_limited_scheduler 0.0.1

data/lib/rate_limited_scheduler.rb

@@ -0,0 +1,89 @@
+require 'redis'
+require 'redis-namespace'
+
+class RateLimitedScheduler
+  class Configuration
+    attr_accessor :default_threshold, :default_interval
+  end
+  
+  def self.configure(&block)
+    block.call(@@configuration)
+  end
+
+  @@configuration = Configuration.new
+  
+  self.configure do |config|
+    config.default_threshold = 5
+    config.default_interval = 1
+  end  
+  
+  def initialize(bucket, constraint)
+    # default: 5 executions per second
+    constraint[:threshold] ||= @@configuration.default_threshold
+    constraint[:interval] ||= @@configuration.default_interval
+    
+    @bucket = bucket
+    @constraint = constraint
+    @redis = Redis::Namespace.new(:ratelimiter, { :redis => Redis.new })
+    
+    @redis.multi do
+      @redis.del(@bucket)
+      @redis.lpush(@bucket, Array.new(constraint[:threshold], Time.now.to_f))
+    end
+  end
+  
+  def within_constraints(&block)      
+    start_execution
+    yield
+    stop_execution
+  end
+  
+  def count_active_executions
+    @constraint[:threshold] - count_free_execution_handles
+  end
+  
+  def count_free_execution_handles
+    @redis.llen(@bucket)
+  end
+  
+  private
+  
+  def get_execution_handle(subscriber)
+    execution_handle = @redis.lpop(@bucket)
+    unless execution_handle.nil?
+      subscriber.unsubscribe(:new_execution_handle_available)
+      return execution_handle
+    end
+  end
+  
+  def wait_for_execution_handle
+    subscriber = Redis::Namespace.new(:ratelimiter, { :redis => Redis.new })
+    
+    subscriber.subscribe(:new_execution_handle_available) do |on|
+      execution_handle = get_execution_handle(subscriber)
+      return execution_handle unless execution_handle.nil?
+      
+      on.message do
+        execution_handle = get_execution_handle(subscriber)
+        return execution_handle unless execution_handle.nil?
+      end
+    end
+  end
+  
+  def start_execution
+    execution_handle = wait_for_execution_handle
+    current_time = Time.now.to_f
+            
+    # got next execution handle, wait till it gets valid
+    if execution_handle.to_f > current_time
+      sleep(execution_handle.to_f - current_time)
+    end
+  end
+  
+  def stop_execution
+    @redis.multi do
+      @redis.rpush(@bucket, Time.now.to_f + @constraint[:interval])
+      @redis.publish(:new_execution_handle_available, nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: rate_limited_scheduler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Robert Strobl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-15 00:00:00.000000000 Z
+dependencies: []
+description: This rate-limited scheduler is made for requests to APIs with sensitive,
+  time-critical access restrictions which means that even limits with short time intervals
+  such as 5 requests per second can be hold in a multi-threading environment. It implements
+  Redis-based execution handles.
+email: mail@rstrobl.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rate_limited_scheduler.rb
+homepage: http://github.com/rstrobl/rate_limited_scheduler
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Redis-based rate-limited scheduler for requests to APIs with sensitive
+  and time-critical access restrictions
+test_files: []