nedski-flood 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Neil Kohl
+
+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.rdoc

@@ -0,0 +1,75 @@
+= flood
+
+Flood is a Ruby library to limit events to a count/time ratio.
+
+= Installation
+
+Install the gem using github as the source:
+
+    gem install nedski-flood -s http://gems.github.com
+    
+When requiring, use 'flood' as the gem name:
+
+    require 'flood'
+
+= Introduction
+
+There are many situations when it's desirable to limit events that occur in a
+given time period. This library provides a framework for implementing rate
+limits.
+
+Given a time interval and a maximum number of events that can occur in that
+period, the library determines whether the event should be permitted.
+
+= Storage
+
+If you want flood control to persist across invocations of a script you must
+save the data. The storage method returns the flood data; you have to handle
+storage. To load stored flood data, call the storage= method with the flood
+data as a parameter.
+
+== Examples
+
+A monitoring script should send no more than alert 1 email every 10 minutes.
+
+      email_limit = 1
+      email_interval = 10 * 60 # interval in seconds
+      flood = FloodControl.new(email_limit, email_interval)
+     
+      if (flood.check() == 0)
+        send_email
+      end
+
+A form should only accept 5 submissions from a single IP address every hour.
+
+      submit_limit = 5
+      submit_interval = 60 * 60 # interval in seconds
+      flood = FloodControl.new(submit_limit, submit_interval)
+
+      if (flood.check(ip_address) == 0)
+        send_email
+      else
+        show_sorry_page
+      end
+
+Users have varying limits based on group.
+
+      TODO: Variable limits example
+      
+Save and load flood data for persistence across invocations.
+
+      TODO: Persistence example
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. 
+
+== Copyright
+
+Copyright (c) 2009 Neil Kohl. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flood"
+    gem.summary = %Q{Ruby library to implement flood control}
+    gem.description = %Q{Flood is a Ruby library for flood control. Flood control is limiting events processed to a maximum number in a specified time period.}
+    gem.email = "neil@kohlweb.com"
+    gem.homepage = "http://github.com/nedski/flood"
+    gem.authors = ["Neil Kohl"]
+
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+desc "run test suite"
+Rake::TestTask.new("test") {|t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flood #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/flood.rb

@@ -0,0 +1,105 @@
+
+# Provides a means to limit events to a count/time
+# ratio. This is a more or less straight port of the Perl 
+# Algorithm::FloodControl library by Vladi Belperchinov-Shabanski.
+# 
+# See README for more information and examples of use.
+class FloodControl
+
+  attr_accessor :interval, :flood
+
+  attr_reader :max_events
+
+  def initialize(max_events, interval)
+    @flood = Hash.new
+    @max_events = max_events
+    @interval = interval
+  end
+
+  # Reset the event count for a given event, or if no argument
+  # supplied reset the event count for all events.
+  def reset(event=nil)
+    if event.nil?
+      @flood.clear
+    else
+      @flood.delete(event)
+    end
+  end
+
+  # Get/set the maximum number of events. Setting will truncate
+  # all event queues so they're no longer than max_events.
+  def max_events=(size)
+    old_max_events = @max_events
+    @max_events=size
+    
+    if (old_max_events > @max_events)
+      # New event queue is shorter than old; 
+      # trim long event queues if needed
+      @flood.each do |e, v| 
+        v = v[0..@max_events - 1] if v.length > @max_events
+      end
+    end
+  end
+
+  # Check if an event can proceed. 
+  #
+  # If no event id is given as an argument, the name of the 
+  # caller is used.
+  # 
+  # max_events and interval can be overridden on a per-call basis.
+  #
+  # The return value is 0 if event can proceed, or a positive integer 
+  # if the limit has been exceeded. The  value represents the number 
+  # of seconds to wait so the event will occur within the limit set.
+  def check(event='',max_events=@max_events, interval=@interval)
+
+    #provide event key if not supplied
+    if (event == '')
+      # TEST: is this unique?
+      event = caller[0].gsub(/\s/,'')
+      # print STDERR "EN: $en\n";
+    end
+    
+    # make empty flood array for this event key
+    @flood[event] ||= Array.new;  
+    
+    event_count = @flood[event].length;
+    
+    if( event_count >= max_events )
+      # flood array has enough events to do real flood check
+      ot = @flood[event][0];      # oldest event timestamp in the flood array
+      tp = Time.now.to_i - ot; # time period between current and oldest event
+    
+      # now calculate time in seconds until next allowed event
+      wait = ot + ( event_count * interval / max_events ) - Time.now.to_i
+      if( wait > 0 )
+        # positive number of seconds means flood in progress
+        # event_count should be rejected or postponed
+        # print "WARNING: next event will be allowed in $wait seconds\n";
+        return wait;
+      end
+
+      # negative or 0 seconds means that event should be accepted
+      # oldest event is removed from the flood array
+      @flood[event].shift;
+
+    end
+    # flood array is not full or oldest event is already removed
+    # so current event has to be added
+
+    @flood[event].push(Time.now.to_i);
+    # event is ok
+    return 0
+  end
+
+  # Get flood data
+  def storage
+    @flood
+  end
+
+  # Set flood data
+  def storage=(flood)
+    @flood=flood
+  end
+
+end

data/test/flood_test.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+# run test suite
+require 'test/unit'
+require 'flood'
+
+class TestFlood < Test::Unit::TestCase
+
+  EVENT_LIMIT  = 15
+  EXTRA_EVENTS = 5
+  TIME_LIMIT   = 10
+  EXTRA_TIME   = 5
+
+  def setup
+    @t = FloodControl.new(EVENT_LIMIT, TIME_LIMIT)
+  end
+
+  def test_basic
+
+    EVENT_LIMIT.times do 
+      assert_equal(0, @t.check('test'))
+    end
+    assert(@t.check('test') > 0, "Should return wait > 0")
+    
+    sleep TIME_LIMIT
+    assert_equal(0, @t.check('test'))
+
+    assert_not_nil(@t.storage)
+    
+  end 
+
+  def test_call_with_args
+    @t.reset
+
+    EVENT_LIMIT.times do 
+      assert_equal(0, @t.check('test'))
+    end
+    assert(@t.check('test') > 0, "Should return wait > 0")
+    
+    assert_equal(0, @t.check('test', EVENT_LIMIT + 1, TIME_LIMIT))
+    assert(@t.check('test', EVENT_LIMIT - 1, TIME_LIMIT) > 0, 
+           "Should return wait > 0")
+    
+    sleep TIME_LIMIT
+    assert_equal(0, @t.check('test'))
+    
+    assert_not_nil(@t.storage)
+    
+  end 
+
+  def test_reset_max
+    @t.reset
+
+    # test event
+    EVENT_LIMIT.times do 
+      assert_equal(0, @t.check('test'))
+    end 
+    assert(@t.check('test') != 0, "Should return wait > 0")
+
+    # change limit
+    new_limit = EVENT_LIMIT + EXTRA_EVENTS
+    assert_equal(new_limit, @t.max_events=new_limit)
+    EXTRA_EVENTS.times do 
+      assert_equal(0, @t.check('test'))
+    end
+    assert(@t.check('test') != 0, "Should return wait > 0")   
+    
+  end
+
+  def test_reset_time
+    @t.reset
+    
+    # test event
+    EVENT_LIMIT.times do 
+      assert_equal(0, @t.check('test'))
+    end 
+    sleep TIME_LIMIT + EXTRA_TIME
+    assert_equal(0, @t.check('test'))
+
+    # change time
+    assert_equal(TIME_LIMIT + EXTRA_TIME, @t.interval=TIME_LIMIT + EXTRA_TIME)
+    assert_equal(0, @t.check('test'))
+ 
+  end
+
+  def test_generated_key
+    @t.reset
+
+    # test 
+    EVENT_LIMIT + 1.times do |c|
+      c < EVENT_LIMIT ? assert_equal(0, @t.check()) :  assert(@t.check() != 0, 
+ 		"Should return wait > 0")
+    end
+  end
+  
+  # TODO: Test store/restore flood data
+  
+end
+ 

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: nedski-flood
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Neil Kohl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Flood is a Ruby library for flood control. Flood control is limiting events processed to a maximum number in a specified time period.
+email: neil@kohlweb.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/flood.rb
+- test/flood_test.rb
+has_rdoc: false
+homepage: http://github.com/nedski/flood
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby library to implement flood control
+test_files: 
+- test/flood_test.rb