ratelimit-bucketbased 0.0.1

data.tar.gz.sig

@@ -0,0 +1,4 @@
+
+�v1���5�wL�4���g�Ko~�8���*J�	� �v�B;-��,�$�5��7��h��i�;��vG\M��vm�J���
��g�����{	���,r�^ɬ�Dȿ��-{��Y�g�����D�?[D]U�4h����ܱaHm
+��ub��j
+L���|����Fk�ك"S"}�V8!������z-c׷4G���Lo3�_��͍!;�@����^E���w��q?�
l�@�){�B:l}����(

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bucket-based-rate-limiter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 chrislee35
+
+MIT License
+
+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,119 @@
+# RateLimit::BucketBased
+
+This is a very simple rate limiting gem useful for regulating the speed at which service is provided and denying service when that rate has been exceeded.  This is very similar to other gems like ratelimit, rack-ratelimiter, rate-limiting, and a ton of gems with the name "throttle" in them.  Mine is different in that it (a) isn't tied to a particular storage, (b) isn't tied to a particular framework, and (c) was written by me.  I guess there might be merits to my approach, but there's a lot of sharp coders out there.
+
+To track the rates of various transactions Memory, MySQL, SQLite3, MemCache, and Redis storage options are supported, but the appropriateness of one over another for various workloads is an exercise left to the reader. I have not added any crafty speed-ups for the SQL databases (e.g., dynamically sized bloom filters), so use those primarily for durability and scalability, not high transaction rates.  Probably the only solution that can scale in the number of items it can track, handle high-transaction loads, and have some durability is Redis.  (it's too bad that MemCache can't save to disk)
+
+Tested in ruby-1.8.7-p371, ruby-1.9.3-p392, and ruby-2.0.0-p0.
+The Memcache gem fails to compile in ruby-2.0.
+
+### The Concept
+
+Imagine a set of buckets, one for each item you want to rate limit such as a user, an apikey, or answers to queries, with a number of balls (credits) in each bucket.  Whenever a service is used, balls (credits) are removed from the user's bucket.  When the user has no more credits left, the service is denied.  Credits are added back to the bucket over time, up to a maximum.  It is also possible for someone to be denied service, but since they keep asking for it anyway, they can go into debt up to a minimum (a negative number), thus they will have to wait some time to let the debt be paid.
+
+Thus, each bucket has the following properties:
+* +name+: the name of the item that you allocated the bucket for
+* +current+: the current credit limit (which may be larger than max, or more negative than min)
+* +max+: the maximum that the bucket will be filled by the regeneration process
+* +min+: the minimum that a bucket can go, must be <= 0.
+* +refill_amount+: the amount that will be added to the bucket every refill_epoch seconds.
+* +refill_epoch+: the number of seconds before the bucket is credited by the regeneration process
+* +last_refill+: the timestamp of the last refill
+* +total_used+: the total, cumulative credits used for service (i.e., refusals don't count)
+
+To set these parameters easily, you can create named configurations to create buckets using those templates.  The configurations have the following fields:
+* +name+: the name of the configuration
+* +start+: the credits that a new bucket starts with
+* +max+: the maximum that the bucket will be filled by the regeneration process
+* +min+: the minimum that a bucket can go, must be <= 0.
+* +refill_amount+: the amount that will be added to the bucket every refill_epoch seconds.
+* +refill_epoch+: the number of seconds before the bucket is credited by the regeneration process
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ratelimiter-bucketbased'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ratelimiter-bucketbased
+
+## Usage
+
+The steps to use the rate limiter are the following:
+1. set up the configurations for accounting, 
+1. create a store, (currently, Memory, MySQL, SQLite3, MemCache, and Redis storage options are supported)
+1. create the rate limiter, 
+1. add non-default items, 
+1. and provide service.
+
+For each of the examples below, use the following template:
+
+	require 'ratelimit-bucketbased'
+
+	# set up the configs
+	start = max = 10
+	min = -10
+	cost = refill_amount = refill_epoch = 2
+	configs = { 
+	  'default' => RateLimit::Config.new('default', start, max, min, cost, refill_amount, refill_epoch),
+	  'power' => RateLimit::Config.new('default', 20, 20, min, cost, refill_amount, 1)
+	}
+
+	# create a store
+	*storage creation code here, see sub-sections below*
+
+	# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+	rl = RateLimit::BucketBased.new(storage, configs, 'default')
+	# add a bucket named "admin", using a non-default configuration
+	rl.create_bucket('admin', 'power')
+
+	def provide_service(username)
+	  if rl.use(username)
+	    // perform service
+	  end
+	end
+
+### Memory-based Store
+
+	# create a Memory-based storage
+	storage = RateLimit::Memory.new
+
+### SQLite3-based Store
+
+	require 'sqlite3'
+
+	# attach to a SQLite3-based storage
+	dbh = SQLite3::Database.new( "test/test.db" )
+	custom_fields = ["username","credits","max_credits","min_credits","cost_per_transaction","refill_credits","refill_seconds","last_refill_time","total_used_credits"]
+	storage = RateLimit::SQLite3.new(dbh,'users_table',custom_fields)
+
+### Memcache-based Store
+
+	require 'memcache'
+
+	# create a MemCache-based storage
+	memcache = Memcache.new(:server => 'localhost:11211')
+	storage = RateLimit::Memcache.new(memcache)
+
+### Redis-based Store
+
+	require 'redis'
+
+	# create a Redis-based storage
+	redis = Redis.new(:server => 'localhost', :port => 6379)
+	storage = RateLimit::Redis.new(redis)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.libs << 'lib'
+	t.test_files = FileList['test/test_*.rb']
+	t.verbose = true
+end
+
+task :default => :test

data/lib/ratelimit/bucketbased.rb

@@ -0,0 +1,264 @@
+require "ratelimit/bucketbased/version"
+
+module RateLimit
+	# Bucket tracks the credits for each item.
+	# Each bucket has the following parameters:
+	# * *Args*    :
+	#   - +name+ -> the name of the item that you allocated the bucket for
+	#   - +current+ -> the current credit limit (which may be larger than max, or more negative than min)
+	#   - +max+ -> the maximum that the bucket will be filled by the regeneration process
+	#   - +min+ -> the minimum that a bucket can go, must be <= 0.
+	#   - +refill_amount+ -> the amount that will be added to the bucket every refill_epoch seconds.
+	#   - +refill_epoch+ -> the number of seconds before the bucket is credited by the regeneration process
+	#   - +last_refill+ -> the timestamp of the last refill
+	#   - +total_used+ -> the total, cumulative credits used for service (so refusals don't count)
+  # * *Returns* :
+  #   - a Bucket
+  
+	class Bucket < Struct.new(:name, :current, :max, :min, :cost, :refill_amount, :refill_epoch, :last_refill, :total_used); end
+	# To set bucket parameters easily, you can create named configurations to create buckets using those templates.  
+	# The configurations have the following parameters:
+	# * <tt>name</tt>:: the name of the configuration
+	# * <tt>start</tt>:: the credits that a new bucket starts with
+	# * <tt>max</tt>:: the maximum that the bucket will be filled by the regeneration process
+	# * <tt>min</tt>:: the minimum that a bucket can go, must be <= 0.
+	# * <tt>refill_amount</tt>:: the amount that will be added to the bucket every refill_epoch seconds.
+	# * <tt>refill_epoch</tt>:: the number of seconds before the bucket is credited by the regeneration process
+	class Config < Struct.new(:name, :start, :max, :min, :cost, :refill_amount, :refill_epoch); end
+	
+	# "Storage" is a jerk class that throws exceptions if you forgot to implement a critical function, welcome to Ruby (no interface)
+	# Bucket tracks the credits for each item.
+	# Each bucket has the following parameters:
+	# * *Args*    :
+	#   - +name+ -> the name of the item that you allocated the bucket for
+	#   - +current+ -> the current credit limit (which may be larger than max, or more negative than min)
+	#   - +max+ -> the maximum that the bucket will be filled by the regeneration process
+	#   - +min+ -> the minimum that a bucket can go, must be <= 0.
+	#   - +refill_amount+ -> the amount that will be added to the bucket every refill_epoch seconds.
+	#   - +refill_epoch+ -> the number of seconds before the bucket is credited by the regeneration process
+	#   - +last_refill+ -> the timestamp of the last refill
+	#   - +total_used+ -> the total, cumulative credits used for service (so refusals don't count)
+  # * *Returns* :
+  #   - a Bucket
+  # * *Raises* :
+  #   - +ArgumentError+ -> if any value is nil or negative
+	class Storage
+		# retrieves a named bucket
+		# * *Args*    :
+		#   - +name+ -> the name of the bucket to be retrieved
+		# * *Returns* :
+		#   - the bucket matching the name if found, nil otherwise
+		# * *Raises* :
+		#   - +NoMethodError+ -> always, because this class is a jerk
+		def get(name)
+			raise NoMethodError
+		end
+		
+		# saves a bucket into the storage
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to set.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - nil
+		# * *Raises* :
+		#   - +NoMethodError+ -> always, because this class is a jerk
+		def set(bucket)
+			raise NoMethodError
+		end
+
+		# updates the key fields that need updating into the storage
+		# this is often cheaper for certain types of storage than using set()
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to update.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - nil
+		# * *Raises* :
+		#   - +NoMethodError+ -> always, because this class is a jerk
+		def update(bucket)
+			raise NoMethodError
+		end
+	end
+	
+	class Memory < Storage
+		def initialize
+			@buckets = {}
+		end
+		
+		# retrieves a named bucket
+		# * *Args*    :
+		#   - +name+ -> the name of the bucket to be retrieved
+		# * *Returns* :
+		#   - the bucket matching the name if found, nil otherwise
+		def get(name)
+			@buckets[name]
+		end
+		
+		# saves a bucket into the storage
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to set.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - the bucket that is provided in the Args
+		def set(bucket)
+			@buckets[bucket.name] = bucket
+		end
+		
+		# updates the key fields that need updating into the storage
+		# this is often cheaper for certain types of storage than using set()
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to update.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - nil
+		def update(bucket)
+			# already updated
+		end
+	end
+	
+	class MySQL < Storage
+		def initialize(dbh, table, fields=["name","current","max","min","cost","refill_amount","refill_epoch","last_refill","total_used"])
+			@queries = {
+				'get' => dbh.prepare("SELECT `#{fields.join('`, `')}` FROM `#{table}` WHERE `#{fields[0]}` = ? LIMIT 1"),
+				'update' => dbh.prepare("UPDATE `#{table}` SET `#{fields[1]}` = ?, `#{fields[7]}` = ?, `#{fields[8]}` = ? WHERE `#{fields[0]}` = ?"),
+				'set' => dbh.prepare("REPLACE INTO `#{table}` (`#{fields.join('`, `')}`) VALUES (?,?,?,?,?,?,?,?,?)")
+			}
+		end
+		
+		# retrieves a named bucket
+		# * *Args*    :
+		#   - +name+ -> the name of the bucket to be retrieved
+		# * *Returns* :
+		#   - the bucket matching the name if found, nil otherwise
+		# * *Raises* :
+		#   - +Mysql::Error+ -> any issue with the connection to the database or the SQL statements
+		def get(name)
+			rs = @queries['get'].execute(name)
+			bucket = nil
+			rs.each do |row|
+				bucket = Bucket.new(row[0],*row[1,8].map{|x| x.to_f})
+			end
+			bucket
+		end
+		
+		# saves a bucket into the storage
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to set.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - an empty result set
+		# * *Raises* :
+		#   - +Mysql::Error+ -> any issue with the connection to the database or the SQL statements
+		def set(bucket)
+			@queries['set'].execute(bucket.name, bucket.current, bucket.max, bucket.min, bucket.cost, bucket.refill_amount, bucket.refill_epoch, bucket.last_refill, bucket.total_used)
+		end
+		
+		# updates the key fields that need updating into the storage
+		# this is often cheaper for certain types of storage than using set()
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to update.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - an empty result set
+		# * *Raises* :
+		#   - +Mysql::Error+ -> any issue with the connection to the database or the SQL statements
+		def update(bucket)
+			@queries['update'].execute(bucket.current, bucket.last_refill, bucket.total_used, bucket.name)
+		end
+	end
+	
+	SQLite3 = MySQL
+	
+	class MemCache
+		def initialize(cache_handle)
+			@cache = cache_handle
+		end
+		
+		# retrieves a named bucket
+		# * *Args*    :
+		#   - +name+ -> the name of the bucket to be retrieved
+		# * *Returns* :
+		#   - the bucket matching the name if found, nil otherwise
+		def get(name)
+			value = @cache.get(name)
+			return nil unless value
+			row = value.split(/\|/)
+			bucket = nil
+			if row
+				bucket = Bucket.new(row[0],*row[1,8].map{|x| x.to_f})
+			end
+			bucket
+		end
+		
+		# saves a bucket into the storage
+		# * *Args*    :
+		#   - +bucket+ -> the Bucket to set.  The <tt>name</tt> field in the Bucket option will be used as a key.
+		# * *Returns* :
+		#   - the bucket that is provided in the Args
+		def set(bucket)
+			@cache.set(bucket.name,bucket.values.join("|"))
+		end
+		
+		alias :update :set
+	end
+	
+	Memcache = MemCache
+	Redis = MemCache
+	
+	# BucketBased is the star of the show.  It takes a storage, a set of configurations, and the name of the default configuration.
+	# <tt>storage</tt>:: a method for saving and retrieving buckets (memory, mysql, sqlite3, memcache)
+	# <tt>bucket_configs</tt>:: a hash of name => Config pairs
+	# <tt>default_bucket_config</tt>:: the name of the default config to choose when automatically creating buckets for items that don't have buckets
+	class BucketBased
+		attr_reader :storage
+		def initialize(storage, bucket_configs, default_bucket_config='default')
+			@storage = storage
+			@bucket_configs = bucket_configs
+			if @bucket_configs.keys.length == 1
+				@default_bucket_config =  @bucket_configs.keys[0]
+			else
+				@default_bucket_config = default_bucket_config
+			end
+			raise "Cannot find default config" unless @bucket_configs[@default_bucket_config]
+		end
+
+		# Used primarily to preallocate buckets that need an alternate configuration from the default so that they aren't automatically created with default configurations
+		# <tt>name</tt>:: the name of the item to track
+		# <tt>config_name</tt>:: the name of the config to use as a template for creating the bucket
+		# The new bucket will be saved into the storage for this instance of RateLimiter
+		def create_bucket(name, config_name=@default_bucket_config)
+			config = @bucket_configs[config_name]
+			raise "Config is nil" unless config
+			bucket = Bucket.new(name, config.start, config.max, config.min, config.cost, config.refill_amount, config.refill_epoch, Time.now.to_f, 0.0)
+			@storage.set(bucket)
+		end
+		
+		# Returns <i>true</i> if the item <tt>name</tt> has enough credits, <i>false</i> otherwise
+		# It will automatically create buckets for items that don't already have buckets and it will do all the bookkeeping to deduct credits, regenerate credits, and track all the credits used.
+		# <tt>name</tt>:: the name of the item to track
+		# <tt>cost</tt>:: the cost of the transaction (defaults to the cost set in the Bucket if nil)
+		def use(name, cost=nil)
+			# create a bucket using the default config if it doesn't already exist
+			bkt = @storage.get(name)
+			unless bkt
+				create_bucket(name)
+				bkt = @storage.get(name)
+			end
+			unless bkt
+				raise Exception, "Could not find bucket"
+			end
+			# first credit the bucket for the time that has elapsed
+			epochs_elapsed = ((Time.now.to_f - bkt.last_refill)/bkt.refill_epoch).to_i
+			bkt.current += epochs_elapsed * bkt.refill_amount
+			bkt.current = bkt.max if bkt.current > bkt.max
+			bkt.last_refill += epochs_elapsed*bkt.refill_epoch
+			# now see if the bkt has enough to provide service
+			cost ||= bkt.cost # if the cost isn't provided, use the default cost
+			raise "Invalid cost: #{cost}" if cost < 0
+			enough = bkt.current >= cost # true if sufficient, false if insufficient
+			# track the total costs, but only if service will be rendered
+			bkt.total_used += cost if enough
+			# now deduct the cost, capping at the minimum
+			bkt.current -= cost
+			bkt.current = bkt.min if bkt.current < bkt.min
+			# now save the changes into the storage (if memory, then no changes are needed, we updated the object in memory)
+			@storage.update(bkt)
+			# return the verdict, did they have enough credits to pay the toll?
+			enough
+		end
+	end
+end

data/lib/ratelimit/bucketbased/version.rb

@@ -0,0 +1,5 @@
+module RateLimit
+	class BucketBased
+		VERSION = "0.0.1"
+	end
+end

data/ratelimit-bucketbased.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ratelimit/bucketbased/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "ratelimit-bucketbased"
+	spec.version       = RateLimit::BucketBased::VERSION
+	spec.authors       = ["chrislee35"]
+	spec.email         = ["rubygems@chrislee.dhs.org"]
+	spec.description   = %q{Simple rate limiting gem useful for regulating the speed at which service is provided, this provides an in-memory data structure for administering rate limits}
+	spec.summary       = %q{Simple rate limiting gem useful for regulating the speed at which service is provided}
+	spec.homepage      = "http://github.com/chrislee35/ratelimit-bucketbased"
+	spec.license       = "MIT"
+
+	spec.files         = `git ls-files`.split($/)
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+	spec.require_paths = ["lib"]
+
+	spec.add_development_dependency "bundler", "~> 1.3"
+	spec.add_development_dependency "rake"
+	spec.add_development_dependency "sqlite3", ">= 1.3.6"
+	spec.add_development_dependency "memcache", ">= 1.2.13"
+	spec.add_development_dependency "redis", "~> 3.0.1"
+
+	spec.signing_key   = "#{File.dirname(__FILE__)}/../gem-private_key.pem"
+	spec.cert_chain    = ["#{File.dirname(__FILE__)}/../gem-public_cert.pem"]
+
+	spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+require 'sqlite3'
+require 'memcache'
+require 'redis'
+require File.expand_path('../../lib/ratelimit/bucketbased.rb', __FILE__)

data/test/test_ratelimit-bucketbased.rb

@@ -0,0 +1,155 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative 'helper'
+
+def get_configs
+	# set up the configs
+	start = max = 5
+	min = -5
+	cost = refill_amount = refill_epoch = 1
+	configs = { 
+		'default' => RateLimit::Config.new('default', start, max, min, cost, refill_amount, refill_epoch),
+		'power' => RateLimit::Config.new('default', 10, 10, min, cost, refill_amount, refill_epoch)
+	}
+end
+
+def standard_tests(rl)
+	# add a bucket named "admin", using a non-default configuration
+	rl.create_bucket('admin', 'power')
+	0.upto(4) do 
+		assert(rl.use("test"))
+	end
+	0.upto(9) do
+		assert(rl.use("admin"))
+	end
+	assert(! rl.use("test"))
+	assert(! rl.use("admin"))
+	# should be at -2, need two epochs to have enough to do another hit
+	sleep 2
+	assert(rl.use("test"))
+	assert(rl.use("admin"))
+	assert_equal(6,rl.storage.get("test").total_used)
+	assert_equal(11,rl.storage.get("admin").total_used)
+end
+
+class TestRateLimitBucketBased < Test::Unit::TestCase
+	
+	
+	def test_setup_a_rate_limiter_and_work_five_times_before_exhaution
+		#should "setup a rate limiter and work five times before exhaution" do
+		# create a Memory-based storage
+		storage = RateLimit::Memory.new
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, get_configs, 'default')
+		# run the standard tests
+		standard_tests(rl)
+	end
+
+	def test_raise_an_exception_with_a_cost_of_less_than_0
+		#should "raise an exception with a cost of less than 0" do
+		# set up the configs
+		start = max = 5
+		min = -5
+		cost = refill_amount = refill_epoch = 1
+		configs = { 
+			'default' => RateLimit::Config.new('default', start, max, min, cost, refill_amount, refill_epoch),
+			'power' => RateLimit::Config.new('default', 10, 10, min, cost, refill_amount, refill_epoch)
+		}
+		# create a Memory-based storage
+		storage = RateLimit::Memory.new
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, configs, 'default')
+		assert_raise(RuntimeError) {
+			rl.use("test",-1)
+		}
+	end
+end
+
+class TestRateLimitBucketBasedSqlite3 < Test::Unit::TestCase
+	def cleanup
+		File.unlink("test/test.db") if File.exist?("test/test.db")
+	end
+	
+	def test_track_the_changes_in_an_SQLite3_database
+		#should "track the changes in an SQLite3 database" do
+		# create a SQLite3-based storage: first create the database, then the table, then the storage
+		File.unlink("test/test.db") if File.exist?("test/test.db")
+		dbh = SQLite3::Database.new( "test/test.db" )
+		assert_not_nil(dbh)
+		res = dbh.execute("CREATE TABLE users (`name`,`current`,`max`,`min`,`cost`,`refill_amount`,`refill_epoch`,`last_refill`,`total_used`,primary key (`name`))")
+		assert(res)
+		storage = RateLimit::SQLite3.new(dbh,'users')
+	
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, get_configs, 'default')
+		# run the standard tests
+		standard_tests(rl)
+	end
+
+	def test_track_the_changes_in_an_SQLite3_database_using_a_custom_field_set
+		#should "track the changes in an SQLite3 database using a custom field-set" do
+		# create a SQLite3-based storage: first create the database, then the table, then the storage
+		File.unlink("test/test.db") if File.exist?("test/test.db")
+		dbh = SQLite3::Database.new( "test/test.db" )
+		assert_not_nil(dbh)
+		fields = ["username","credits","max_credits","min_credits","cost_per_transaction","refill_credits","refill_seconds","last_refill_time","total_used_credits"]
+		res = dbh.execute("CREATE TABLE users (`#{fields.join('`, `')}`,primary key (`username`))")
+		assert(res)
+		storage = RateLimit::SQLite3.new(dbh,'users',fields)
+	
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, get_configs, 'default')
+		# run the standard tests
+		standard_tests(rl)
+	end
+end
+
+class TestRateLimitBucketBasedMemcache < Test::Unit::TestCase
+	def setup
+		# create a MemCache-based storage
+		memcache = Memcache.new(:server => 'localhost:11211')
+		memcache.delete("test")
+		memcache.delete("admin")
+	end
+	
+	def test_track_the_changes_in_memcache
+		#should "track the changes in memcache" do
+		# create a MemCache-based storage
+		memcache = Memcache.new(:server => 'localhost:11211')
+		assert_not_nil(memcache)
+		storage = RateLimit::Memcache.new(memcache)
+	
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, get_configs, 'default')
+		# run the standard tests
+		standard_tests(rl)
+	end
+end
+	
+class TestRateLimitBucketBasedRedis < Test::Unit::TestCase
+	def setup
+		# remove stale entries that could conflict with our test
+		redis = Redis.new(:server => 'localhost', :port => 6379)
+		redis.del("test")
+		redis.del("admin")
+	end
+	
+	def test_track_the_changes_in_redis
+		#should "track the changes in redis" do
+		# create a Redis-based storage
+		redis = Redis.new(:server => 'localhost', :port => 6379)
+		assert_not_nil(redis)
+		storage = RateLimit::Redis.new(redis)
+	
+		# create the rate limiter, setting the storage, the configurations, and the name of the default configuration
+		rl = RateLimit::BucketBased.new(storage, get_configs, 'default')
+		# run the standard tests
+		standard_tests(rl)
+	end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: ratelimit-bucketbased
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- chrislee35
+autorequire: 
+bindir: bin
+cert_chain:
+- !binary |-
+  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURZakNDQWtxZ0F3SUJB
+  Z0lCQURBTkJna3Foa2lHOXcwQkFRVUZBREJYTVJFd0R3WURWUVFEREFoeWRX
+  SjUKWjJWdGN6RVlNQllHQ2dtU0pvbVQ4aXhrQVJrV0NHTm9jbWx6YkdWbE1S
+  TXdFUVlLQ1pJbWlaUHlMR1FCR1JZRApaR2h6TVJNd0VRWUtDWkltaVpQeUxH
+  UUJHUllEYjNKbk1CNFhEVEV6TURVeU1qRXlOVGswTjFvWERURTBNRFV5Ck1q
+  RXlOVGswTjFvd1Z6RVJNQThHQTFVRUF3d0ljblZpZVdkbGJYTXhHREFXQmdv
+  SmtpYUprL0lzWkFFWkZnaGoKYUhKcGMyeGxaVEVUTUJFR0NnbVNKb21UOGl4
+  a0FSa1dBMlJvY3pFVE1CRUdDZ21TSm9tVDhpeGtBUmtXQTI5eQpaekNDQVNJ
+  d0RRWUpLb1pJaHZjTkFRRUJCUUFEZ2dFUEFEQ0NBUW9DZ2dFQkFOY1ByeDhC
+  WmlXSVI5eFdXRzhJCnRxUjUzOHRTMXQrVUo0RlpGbCsxdnJ0VTlUaXVXWDNW
+  ajM3VHdVcGEyZkZremlLMG41S3VwVlRoeUVoY2VtNW0KT0dSanZnclJGYldR
+  SlNTc2NJS09wd3FVUkhWS1JwVjlnVnovSG56azhTK3hvdFVSMUJ1bzNVZ3Ir
+  STFqSGV3RApDZ3IreSt6Z1pidGp0SHNKdHN1dWprT2NQaEVqalVpbmo2OEw5
+  Rno5QmRlSlF0K0lhY2p3QXpVTGl4NmpXQ2h0ClVjK2crMHo4RXNyeWNhMkc2
+  STFHc3JnWDZXSHc4ZHlreVFEVDlkQ3RTMmZsQ093U0MxUjBLNVQveEhXNTRm
+  KzUKd2N3OG1tNTNLTE5lK3RtZ1ZDNlpIeU1FK3FKc0JuUDZ1eEYwYVRFbkdB
+  L2pEQlFEaFFOVEYwWlAvYWJ6eVRzTAp6alVDQXdFQUFhTTVNRGN3Q1FZRFZS
+  MFRCQUl3QURBTEJnTlZIUThFQkFNQ0JMQXdIUVlEVlIwT0JCWUVGTzh3Cith
+  ZVA3VDZrVkpibENnNmV1c09JSTlEZk1BMEdDU3FHU0liM0RRRUJCUVVBQTRJ
+  QkFRQkNReVJKTFhzQm8yRnkKOFc2ZS9XNFJlbVFScmxBdzlESzVPNlU3MUp0
+  ZWRWb2Iyb3ErT2Irem1TK1BpZkUyK0wrM1JpSjJINlZUbE96aQp4K0EwNjFN
+  VVhoR3JhcVZxNEoyRkM4a3Q0RVF5d0FEMFAwVGE1R1UyNENHU0YwOFkzR2tK
+  eTFTYTRYcVRDMllDCm81MXM3SlArdGtDQ3RwVllTZHpKaFRsbGllUkFXQnBH
+  VjFkdGFvZVVLRTZ0WVBNQmtvc3hTUmNWR2N6ay9TYzMKN2VRQ3BleFl5OUps
+  VUJJOXUzQnFJWTlFK2wrTVNuOGloWFNQbXlLMERncmhhQ3Urdm9hU0ZWT1g2
+  WStCNXFibwpqTFhNUXUyWmdJU1l3WE5qTmJHVkhlaHV0ODJVN1U5b2lIb1dj
+  ck9HYXphUlVtR085VFhQK2FKTEgwZ3cyZGNLCkFmTWdsWFBpCi0tLS0tRU5E
+  IENFUlRJRklDQVRFLS0tLS0K
+date: 2013-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: memcache
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.13
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+description: Simple rate limiting gem useful for regulating the speed at which service
+  is provided, this provides an in-memory data structure for administering rate limits
+email:
+- rubygems@chrislee.dhs.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ratelimit/bucketbased.rb
+- lib/ratelimit/bucketbased/version.rb
+- ratelimit-bucketbased.gemspec
+- test/helper.rb
+- test/test.db
+- test/test_ratelimit-bucketbased.rb
+homepage: http://github.com/chrislee35/ratelimit-bucketbased
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 711855890028664277
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 711855890028664277
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple rate limiting gem useful for regulating the speed at which service
+  is provided
+test_files:
+- test/helper.rb
+- test/test.db
+- test/test_ratelimit-bucketbased.rb