jduff-api-throttling 0.2.0 → 0.2.1

data/README.md

@@ -2,6 +2,28 @@
 
 <p>I will show you a technique to impose a rate limit (aka API Throttling) on a Ruby Web Service. I will be using Rack middleware so you can use this no matter what Ruby Web Framework you are using, as long as it is Rack-compliant.</p>
 
+<h2>Installation</h2>
+<p>This middleware has recently been gemmified, you can install the latest gem using:</p>
+<pre>sudo gem install jduff-api-throttling</pre>
+<p>If you prefer to have the latest source it can be found at http://github.com/jduff/api-throttling/tree (this is a fork of http://github.com/dambalah/api-throttling/tree with a number of recent changes)</p>
+
+<h2>Usage</h2>
+<p>In your rack application simply use the middleware and pass it some options</p>
+<pre>use ApiThrottling, :requests_per_hour => 3</pre>
+<p>This will setup throttling with a limit of 3 requests per hour and will use a Redis cache to keep track of it. By default Rack::Auth::Basic is used to limit the requests on a per user basis.</p>
+<p>A number of options can be passed to the middleware so it can be configured as needed for your stack.</p>
+<pre>:cache=>:redis # :memcache, :hash are supported. you can also pass in an instance of those caches, or even Rails.cache</pre>
+<pre>:auth=>false # if your middleware is doing authentication somewhere else</pre>
+<pre>:key=>Proc.new{|env,auth| "#{env['PATH_INFO']}_#{Time.now.strftime("%Y-%m-%d-%H")}" } # to customize how the cache key is generated</pre>
+
+<p>An example using all the options might look something like this:</p>
+<pre>
+  CACHE = MemCache.new
+  use ApiThrottling, :requests_per_hour => 100, :cache=>CACHE, :auth=>false, 
+                     :key=>Proc.new{|env,auth| "#{env['PATH_INFO']}_#{Time.now.strftime("%Y-%m-%d-%H")}" } 
+</pre>
+<p>This will limit requests to 100 per hour per url ('/home' will be tracked separately from '/users') keeping track by storing the counts with MemCache.</p>
+
 <h2>Introduction to Rack</h2>
 
 <p>There are plenty of <a href="http://jasonseifer.com/2009/04/08/32-rack-resources-to-get-you-started">great resources</a> to learn the basic of Rack so I will not be explaining how Rack works here but you will need to understand it in order to follow this post. I highly recommend watching the <a href="http://remi.org/2009/02/19/rack-basics.html">three</a> <a href="http://remi.org/2009/02/24/rack-part-2.html">Rack</a> <a href="http://remi.org/2009/02/28/rack-part-3-middleware.html">screencasts</a> from <a href="http://remi.org/">Remi</a> to get started with Rack.</p>

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 0
+:patch: 1

data/lib/handlers/active_support_cache_store_handler.rb

@@ -0,0 +1,21 @@
+module Handlers
+  class ActiveSupportCacheStoreHandler < Handler
+    
+    def initialize(object=nil)
+      raise "Must provide an existing ActiveSupport::Cache::Store" unless object.is_a?(ActiveSupport::Cache::Store)
+      @cache = object
+    end
+    
+    def increment(key)
+      @cache.write(key, (get(key)||0).to_i+1)
+    end
+    
+    def get(key)
+      @cache.read(key)
+    end
+    
+    %w(MemCacheStore FileStore MemoryStore SynchronizedMemoryStore DRbStore CompressedMemCacheStore).each do |store|
+      Handlers.add_handler(self, "ActiveSupport::Cache::#{store}".downcase)
+    end
+  end
+end

data/lib/handlers/handlers.rb

@@ -1,4 +1,14 @@
 module Handlers
+  HANDLERS = {}
+    
+  def self.cache_handler_for(info)
+    HANDLERS[info.to_s.downcase] || HANDLERS[info.class.to_s.downcase]
+  end
+  
+  def self.add_handler(handler, key=nil)
+    HANDLERS[key || handler.cache_class.downcase] = handler
+  end
+  
   # creating a new cache handler is as simple as extending from the handler class,
   # setting the class to use as the cache by calling cache_class("Redis")
   # and then implementing the increment and get methods for that cache type.
@@ -6,11 +16,11 @@ module Handlers
   # If you don't want to extend from Handler you can just create a class that implements
   # increment(key), get(key) and handles?(info)
   # 
-  # Once you have a new handler make sure it is required in here and added to the Handlers list,
   # you can then initialize the middleware and pass :cache=>CACHE_NAME as an option.
   class Handler
     def initialize(object=nil)
-      @cache = object.is_a?(self.class.cache_class) ? object : self.class.cache_class.new
+      cache = Object.const_get(self.class.cache_class)
+      @cache = object.is_a?(cache) ? object : cache.new
     end
     
     def increment(key)
@@ -22,25 +32,15 @@ module Handlers
     end
     
     class << self    
-      def handles?(info)
-        info.to_s.downcase == cache_class.to_s.downcase || info.is_a?(self.cache_class)
-      end
-    
+  
       def cache_class(name = nil)
         @cache_class = name if name
-        Object.const_get(@cache_class) if @cache_class
+        @cache_class
       end
     end
   end
-  
-  %w(redis_handler memcache_handler hash_handler).each do |handler|
+
+  %w(redis_handler memcache_handler hash_handler active_support_cache_store_handler).each do |handler|
     require File.expand_path(File.dirname(__FILE__) + "/#{handler}")
-  end
-  
-  HANDLERS = [RedisHandler, MemCacheHandler, HashHandler]
-  
-  def self.cache_handler_for(info)
-    HANDLERS.detect{|handler| handler.handles?(info)}
-  end
-  
+  end  
 end

data/lib/handlers/hash_handler.rb

@@ -9,5 +9,7 @@ module Handlers
     def get(key)
       @cache[key]
     end
+    
+    Handlers.add_handler self
   end
 end

data/lib/handlers/memcache_handler.rb

@@ -1,4 +1,3 @@
-require 'memcache'
 module Handlers
   class MemCacheHandler < Handler
     cache_class "MemCache"
@@ -10,6 +9,7 @@ module Handlers
     def get(key)
       @cache.get(key)
     end
-
+    
+    Handlers.add_handler self
   end
 end

data/lib/handlers/redis_handler.rb

@@ -1,4 +1,3 @@
-require 'redis'
 module Handlers
   class RedisHandler < Handler
     cache_class "Redis"
@@ -10,5 +9,7 @@ module Handlers
     def get(key)
       @cache[key]
     end
+    
+    Handlers.add_handler self
   end
 end

data/test/test_api_throttling.rb

@@ -1,5 +1,5 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 require 'redis'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 #  To Run this test, you need to have the redis-server running.
 #  And you need to have rack-test gem installed: sudo gem install rack-test
@@ -92,4 +92,48 @@ class ApiThrottlingTest < Test::Unit::TestCase
     end
   end
   
+  context "using active support cache store" do
+    require 'active_support'
+    
+    context "memory store" do
+      include BasicTests
+
+      before do
+        @@cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+      end
+      
+      def app
+        app = Rack::Builder.new {
+          use ApiThrottling, :requests_per_hour => 3, :cache=>@@cache_store
+          run lambda {|env| [200, {'Content-Type' =>  'text/plain', 'Content-Length' => '12'}, ["Hello World!"] ] }
+        }
+      end
+      
+      def test_cache_handler_should_be_memcache
+        assert_equal "Handlers::ActiveSupportCacheStoreHandler", app.to_app.instance_variable_get(:@handler).to_s
+      end
+    end
+    
+    context "memcache store" do
+      include BasicTests
+      
+      
+      before do
+        @@cache_store = ActiveSupport::Cache.lookup_store(:memCache_store)
+        @@cache_store.clear
+      end
+      
+      def app
+        app = Rack::Builder.new {
+          use ApiThrottling, :requests_per_hour => 3, :cache=>@@cache_store
+          run lambda {|env| [200, {'Content-Type' =>  'text/plain', 'Content-Length' => '12'}, ["Hello World!"] ] }
+        }
+      end
+      
+      def test_cache_handler_should_be_memcache
+        assert_equal "Handlers::ActiveSupportCacheStoreHandler", app.to_app.instance_variable_get(:@handler).to_s
+      end
+    end
+  end
+  
 end

data/test/test_api_throttling_memcache.rb

@@ -1,5 +1,5 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 require 'memcache'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestApiThrottlingMemcache < Test::Unit::TestCase
   include Rack::Test::Methods

data/test/test_handlers.rb

@@ -1,39 +1,25 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 require 'redis'
 require 'memcache'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class HandlersTest < Test::Unit::TestCase
-  
-  def setup
-    
-  end
-  
-  def test_redis_should_handle_redis
-    assert Handlers::RedisHandler.handles?(:redis)
-    assert Handlers::RedisHandler.handles?('redis')
-    assert Handlers::RedisHandler.handles?('Redis')
-    assert Handlers::RedisHandler.handles?(Redis.new)
-  end
-  
-  def test_redis_should_not_handle_memcache
-    assert !Handlers::RedisHandler.handles?(:memcache)
-    assert !Handlers::RedisHandler.handles?('memcache')
-    assert !Handlers::RedisHandler.handles?('MemCache')
-    assert !Handlers::RedisHandler.handles?(MemCache.new)
+
+  should "select redis handler" do
+    [:redis, 'redis', 'Redis', Redis.new].each do |key|
+      assert_equal Handlers::RedisHandler, Handlers.cache_handler_for(key)
+    end
   end
-  
-  def test_memcache_should_not_handle_redis
-    assert !Handlers::MemCacheHandler.handles?(:redis)
-    assert !Handlers::MemCacheHandler.handles?('redis')
-    assert !Handlers::MemCacheHandler.handles?('Redis')
-    assert !Handlers::MemCacheHandler.handles?(Redis.new)
+
+  should "select memcache handler" do
+    [:memcache, 'memcache', 'MemCache', MemCache.new].each do |key|
+      assert_equal Handlers::MemCacheHandler, Handlers.cache_handler_for(key)
+    end
   end
   
-  def test_memcache_should_handle_memcache
-    assert Handlers::MemCacheHandler.handles?(:memcache)
-    assert Handlers::MemCacheHandler.handles?('memcache')
-    assert Handlers::MemCacheHandler.handles?('MemCache')
-    assert Handlers::MemCacheHandler.handles?(MemCache.new)
+  should "select hash handler" do
+    [:hash, 'hash', 'Hash', {}].each do |key|
+      assert_equal Handlers::HashHandler, Handlers.cache_handler_for(key)
+    end
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jduff-api-throttling
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Luc Castera
@@ -39,6 +39,7 @@ files:
 - TODO.md
 - VERSION.yml
 - lib/api_throttling.rb
+- lib/handlers/active_support_cache_store_handler.rb
 - lib/handlers/handlers.rb
 - lib/handlers/hash_handler.rb
 - lib/handlers/memcache_handler.rb