throttler 0.1.3 → 0.1.4

data/README.md

@@ -5,22 +5,31 @@ Throttler
 
 Throttle concurrency.
 
-    include Throttler
+    class Foo
+      include Throttler
+
+      def request
+        throttle("foo#{interface}", 1.0) do
+          #noop
+        end
+      end
+
+      def interface; "eth0"; end
+    end
+    
+    foo, count = Foo.new, 0
     
     100.times do
       Thread.new do
-        loop do
-          throttle("foo") do
-            count += 1
-          end
-        end
+        foo.request
+        count += 1
       end
     end
-    sleep 2.2
     
-    count.should eql 3
+    sleep 1.2
+    count.should eql 2 # 98 threads pending
 
 Use case
 --------
 
-Imagine multiple workers hitting the Amazon API on the same IP address. You gotta do something about it.
+Imagine multiple workers hitting the Amazon API on the same IP address.

data/lib/throttler/throttle.rb

@@ -0,0 +1,31 @@
+module Throttler
+
+  # The Throttle file
+  class Throttle
+    def initialize(name)
+      path = "/tmp/.#{name}"
+      @file = File.open(path, File::RDWR|File::CREAT)
+    end
+
+    def delay(interval)
+      last = @file.gets.to_f
+      last = (Time.now.to_f - interval) if last == 0.0
+
+      sleep [last + interval - Time.now.to_f, 0.0].max
+    end
+
+    def lock
+      @file.flock(File::LOCK_EX)
+    end
+
+    def timestamp
+      @file.rewind
+      @file.write(Time.now.to_f)
+    end
+
+    def unlock
+      @file.flock(File::LOCK_UN)
+      @file.close
+    end
+  end
+end

data/lib/throttler.rb

@@ -1,26 +1,26 @@
-# Throttler
+require File.dirname(__FILE__) + "/throttler/throttle"
+
+# The Throttler module.
+#
+# Simply include this in the class where you wish to use the throttler.
 module Throttler
-  require "fileutils"
 
+  # Throttles execution of a block of code.
+  #
+  # Pass name of throttler and optionally, the interval between each
+  # moment of execution. Latte defaults to one second.
+  #
+  #    throttle("foo") { some_code }
+  #
   def throttle(name, interval=1.0)
     begin
-      path = "/tmp/.#{name}"
-
-      FileUtils.touch path unless File.exist? path
-
-      file = File.open(path, "r+")
-      file.flock(File::LOCK_EX)
-    
-      last = file.gets.to_f || Time.now.to_f - interval
-      sleep [last + interval - Time.now.to_f, 0.0].max
-
+      file = Throttle.new(name)
+      file.lock
+      file.delay interval
       yield if block_given?
-
-      file.rewind
-      file.write(Time.now.to_f)
+      file.timestamp
     ensure
-      file.flock(File::LOCK_UN)
-      file.close
+      file.unlock
     end
   end
 end

data/spec/fixtures/foo.rb

@@ -4,10 +4,10 @@ class Foo
   include Throttler
 
   def bar
-    throttle("bar") { noop }
+    throttle("bar", 2.0) do
+      #noop
+    end
   end
-  
-  def noop; end
 end
 
 Foo.new.bar

data/spec/{throttler_spec.rb → integration/scenarios_spec.rb}

@@ -2,7 +2,7 @@ require "benchmark"
 require "fileutils"
 require "spec_helper"
 
-class Foo
+class Bar
   include Throttler
 
   def bar
@@ -20,7 +20,7 @@ class Foo
   def noop; end
 end
 
-describe Throttler do
+describe "Simple integration tests" do
   before do
     FileUtils.rm "/tmp/.bar", :force => true
     FileUtils.rm "/tmp/.baz", :force => true
@@ -29,7 +29,7 @@ describe Throttler do
   it "throttles a loop" do
     time = Benchmark.realtime do
       3.times do
-        Foo.new.bar
+        Bar.new.bar
       end
     end
 
@@ -40,9 +40,9 @@ describe Throttler do
     count = 0
     threads = 10.times.collect do
       Thread.new do
-        foo = Foo.new
+        bar = Bar.new
         loop do
-          foo.bar
+          bar.bar
           count += 1
         end
       end
@@ -53,23 +53,41 @@ describe Throttler do
     count.should eql 3
   end
 
+  it "throttles fibers" do
+    require "fiber"
+
+    time = Benchmark.realtime do
+      fib = Fiber.new do
+        bar = Bar.new
+        loop do
+          bar.bar
+          Fiber.yield
+        end
+      end
+
+      3.times { fib.resume }
+    end
+
+    time.should be_close 2, 0.01
+  end
+
   it "throttles concurrently-running scripts" do
     time = Benchmark.realtime do
       3.times do
-        `ruby #{File.dirname(__FILE__) + "/fixtures/foo.rb"}`
+        `ruby #{File.dirname(__FILE__) + "/../fixtures/foo.rb"}`
       end
     end
 
-    time.should be > 2.0
+    time.should be > 4.0
   end
 
-  it "throttles by name" do
+  it "supports multiple throttles" do
     count = 0
     threads = 10.times.collect do
       Thread.new do
-        foo = Foo.new
+        bar = Bar.new
         loop do
-          count % 2 == 0 ? foo.bar : foo.baz
+          count % 2 == 0 ? bar.bar : bar.baz
           count += 1
         end
       end
@@ -79,9 +97,4 @@ describe Throttler do
 
     count.should eql 6
   end
-
-  it "removes lock if block raises exception" do
-    lambda{ Foo.new.exceptional }.should raise_error
-    File.open("/tmp/.bar") { |f| f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false }
-  end
 end

data/spec/unit/throttler/throttle_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "benchmark"
+require "fileutils"
+
+module Throttler
+  describe Throttle do
+    before do
+      FileUtils.rm "/tmp/.foo", :force => true
+      @foo = Throttle.new("foo")
+    end
+
+    it "creates a file" do
+      File.exists?("/tmp/.foo").should be_true
+    end
+
+    context "#lock" do
+      it "locks the file" do
+        @foo.lock
+        File.open("/tmp/.foo") { |f| f.flock(File::LOCK_EX | File::LOCK_NB).should be_false }
+      end
+    end
+
+    context "#delay" do
+      it "throttles if file contains a timestamp" do
+        file = @foo.instance_variable_get(:@file)
+        file.stub!(:gets).and_return(Time.now.to_f)
+
+        time = Benchmark.realtime do
+          @foo.delay(1.0)
+        end
+
+        time.should be_close 1, 0.1
+      end
+
+      it "does not throttle if file is blank" do
+        file = @foo.instance_variable_get(:@file)
+        file.stub!(:gets).and_return("")
+
+        time = Benchmark.realtime do
+          @foo.delay(1.0)
+        end
+
+        time.should be_close 0, 0.1
+      end
+    end
+
+    context "#timestamp" do
+      it "timestamps file" do
+        @foo.timestamp
+        file = @foo.instance_variable_get(:@file)
+        file.close # We need to close the file first
+
+        File.open("/tmp/.foo") { |f| f.gets.to_f.should be_close Time.now.to_f, 0.1 }
+      end
+    end
+
+    context "#unlock" do
+      it "unlocks the file" do
+        @foo.lock
+        @foo.unlock
+
+        File.open("/tmp/.foo") { |f| f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false }
+      end
+    end
+  end
+end

data/spec/unit/throttler_spec.rb

@@ -0,0 +1,36 @@
+require "benchmark"
+require "fileutils"
+require "spec_helper"
+
+class Foo
+  include Throttler
+
+  def bar
+    throttle("foo"){ raise }
+  end
+end
+
+describe Throttler do
+  before do
+    FileUtils.rm "/tmp/.foo", :force => true
+    
+    class Foo; include Throttler; end
+    @foo = Foo.new
+  end
+
+  context "#throttle" do
+    it "removes lock after block raises an exception" do
+      lambda{ @foo.throttle("foo"){ raise } }.should raise_error
+
+      File.open("/tmp/.foo"){ |f| f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false }
+    end
+
+    it "throttles for one second by default" do
+      time = Benchmark.realtime do
+        2.times{ @foo.throttle("foo"){ } }
+      end
+
+      time.should be_close 1, 0.1
+    end
+  end  
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: throttler
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Hakan Ensari
@@ -16,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-23 00:00:00 +01:00
+date: 2010-07-24 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -32,10 +31,13 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - lib/throttler.rb
+- lib/throttler/throttle.rb
 - README.md
 - spec/fixtures/foo.rb
+- spec/integration/scenarios_spec.rb
 - spec/spec_helper.rb
-- spec/throttler_spec.rb
+- spec/unit/throttler/throttle_spec.rb
+- spec/unit/throttler_spec.rb
 has_rdoc: true
 homepage: http://github.com/papercavalier/throttler
 licenses: []
@@ -50,7 +52,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -2072448878210444692
       segments: 
       - 0
       version: "0"
@@ -59,7 +61,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -72,5 +73,7 @@ specification_version: 3
 summary: Throttles the frequency at which concurrently-running Ruby blocks are executed.
 test_files: 
 - spec/fixtures/foo.rb
+- spec/integration/scenarios_spec.rb
 - spec/spec_helper.rb
-- spec/throttler_spec.rb
+- spec/unit/throttler/throttle_spec.rb
+- spec/unit/throttler_spec.rb