throttler 0.2.0 → 0.2.1

data/README.md

@@ -1,35 +1,47 @@
 Throttler
 =========
 
+Put a throttle on concurrency.
+
 ![Mapplethorpe](http://github.com/papercavalier/throttler/raw/master/mapplethorpe_chains.jpg)
 
-Throttle concurrency.
+Example
+--------
 
-    class Foo
-      include Throttler
+Let's assume we have multiple workers hitting the Amazon API on three IP addresses.
 
+    class Worker
+      include Throttler
+      
+      attr_accessor :interface
+      
       def request
-        throttle("foo#{interface}", 1.0) do
-          # do something
-        end
+        
+        # Scope the throttle by network interface:
+        name      = "foo#{interface}"
+        
+        # Amazon asks you to limit requests to one per second per IP, so:
+        interval  = 0.9
+        
+        # Say a request downloads in two seconds on average
+        throttle(name, interval) { sleep(2) }
       end
-
-      def interface; "eth0"; end
     end
     
-    foo, count = Foo.new, 0
+    worker, count = Worker.new, 0
     
-    100.times do
-      Thread.new do
-        foo.request
-        count += 1
+    (0..3).each do |port|
+      10.times do
+        Thread.new do
+          count += 1
+          worker.interface = "eth#{port}"
+          loop{ worker.request }
+        end
       end
     end
     
-    sleep 1.2
-    count.should eql(2)
-
-Use case
---------
-
-Imagine multiple workers hitting the Amazon API on the same IP address.
+    sleep 10.25
+    
+    # We expect workers to have sent 11 requests within 10 seconds on
+    # each of the three available network interfaces.
+    count.should eql(33)

data/lib/throttler/timer.rb

@@ -1,7 +1,7 @@
 module Throttler
   class Timer
-    def initialize(name)
-      path = "/tmp/.#{name}"
+    def initialize(scope)
+      path = "/tmp/.#{scope}"
       @file = File.open(path, File::RDWR|File::CREAT)
     end
 

data/lib/throttler.rb

@@ -7,20 +7,17 @@ module Throttler
 
   # Throttles the frequency in which a block is run.
   #
-  # Pass name of throttler and optionally, the interval between each
-  # moment of execution. Latter defaults to one second.
+  # Pass throttler scope and the interval between each execution.
+  # Latter defaults to one second.
   #
   #    throttle("foo") { some_code }
   #
-  def throttle(name, interval=1.0)
-    timer = Timer.new(name)
+  def throttle(scope, interval=1.0)
+    timer = Timer.new(scope)
     timer.lock
-    begin
-      sleep [timer.timestamp + interval - Time.now.to_f, 0.0].max
-      yield if block_given?
-      timer.timestamp = Time.now.to_f
-    ensure
-      timer.unlock
-    end
+    sleep [timer.timestamp + interval - Time.now.to_f, 0.0].max
+    timer.timestamp = Time.now.to_f
+    timer.unlock
+    yield if block_given?
   end
 end

data/spec/fixtures/foo.rb

@@ -4,10 +4,14 @@ class Foo
   include Throttler
 
   def bar
-    throttle("bar", 2.0) do
-      #noop
-    end
+    throttle("foo", 2.0) { }
   end
+
+  def control; end
 end
 
-Foo.new.bar
+if ARGV.size == 0
+  Foo.new.bar
+else
+  Foo.new.control
+end

data/spec/integration/blocks_with_long_execution_time_spec.rb

@@ -0,0 +1,33 @@
+require "fileutils"
+require "spec_helper"
+
+describe "Throttler" do
+  before do
+    class Foo
+      include Throttler
+
+      def bar
+        throttle("foo") do
+          yield # so we can count
+          sleep 10
+        end
+      end
+    end
+
+    FileUtils.rm "/tmp/.foo", :force => true
+  end
+
+  it "throttles threads with long execution times" do
+    count = 0
+
+    threads = 10.times.collect do
+      Thread.new do
+        loop{ Foo.new.bar{ count += 1 } }
+      end
+    end
+    sleep 3.25
+    threads.each { |t| Thread.kill(t) }
+
+    count.should eql 4
+  end
+end

data/spec/integration/fibers_spec.rb

@@ -0,0 +1,29 @@
+require "benchmark"
+require "fiber"
+require "fileutils"
+require "spec_helper"
+
+describe "Throttler" do
+  before do
+    class Foo
+      include Throttler
+
+      def bar
+        throttle("foo"){ }
+      end
+    end
+
+    FileUtils.rm "/tmp/.foo", :force => true
+  end
+
+  it "throttles fibers" do
+    time = Benchmark.realtime do
+      fib = Fiber.new do
+        loop{ Foo.new.bar; Fiber.yield }
+      end
+      3.times { fib.resume }
+    end
+
+    time.should be_close 2, 0.01
+  end
+end

data/spec/integration/loop_spec.rb

@@ -0,0 +1,27 @@
+require "benchmark"
+require "fileutils"
+require "spec_helper"
+
+describe "Throttler" do
+  before do
+    class Foo
+      include Throttler
+
+      def bar
+        throttle("foo"){ }
+      end
+    end
+
+    FileUtils.rm "/tmp/.foo", :force => true
+  end
+
+  it "throttles a loop" do
+    time = Benchmark.realtime do
+      3.times do
+        Foo.new.bar
+      end
+    end
+
+    time.should be_close 2, 0.1
+  end
+end

data/spec/integration/processes_spec.rb

@@ -0,0 +1,22 @@
+require "benchmark"
+require "fileutils"
+require "spec_helper"
+
+
+describe "Throttler" do
+  before do
+    FileUtils.rm "/tmp/.foo", :force => true
+  end
+
+  it "throttles concurrent processes" do
+    startup_time = Benchmark.realtime do
+      `ruby #{File.dirname(__FILE__) + "/../fixtures/foo.rb"} control`
+    end
+
+    time = Benchmark.realtime do
+      4.times{ `ruby #{File.dirname(__FILE__) + "/../fixtures/foo.rb"}` }
+    end
+
+    (time - startup_time).should be_close(6.0, 0.5)
+  end
+end

data/spec/integration/threads_spec.rb

@@ -0,0 +1,51 @@
+require "fileutils"
+require "spec_helper"
+
+describe "Throttler" do
+  before do
+    class Foo
+      include Throttler
+
+      def bar
+        throttle("foo"){ }
+      end
+
+      def baz
+        throttle("foo-prime"){ }
+      end
+    end
+
+    %w{foo foo-prime}.each do |file|
+      FileUtils.rm "/tmp/.#{file}", :force => true
+    end
+  end
+
+  it "throttles threads" do
+    count = 0
+    threads = 10.times.collect do
+      Thread.new do
+        loop { Foo.new.bar; count += 1 }
+      end
+    end
+    sleep 3.25
+    threads.each { |t| Thread.kill(t) }
+
+    count.should eql 4
+  end
+
+  it "throttles by scope" do
+    count = 0
+    threads = 10.times.collect do
+      Thread.new do
+        loop do
+          Foo.new.send(count % 2 == 0 ? :bar : :baz)
+          count += 1
+        end
+      end
+    end
+    sleep 3.25
+    threads.each { |t| Thread.kill(t) }
+
+    count.should eql 8
+  end
+end

data/spec/unit/throttler_spec.rb

@@ -2,24 +2,23 @@ require "benchmark"
 require "fileutils"
 require "spec_helper"
 
-class Foo
-  include Throttler
-
-  def bar
-    throttle("foo"){ raise }
-  end
-end
-
 describe Throttler do
   before do
+    class Foo
+      include Throttler
+
+      def bar
+        throttle("foo"){ raise }
+      end
+    end
+
     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
+    it "removes lock even if 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 }

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Hakan Ensari
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-26 00:00:00 +01:00
+date: 2010-07-27 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -34,7 +34,11 @@ files:
 - lib/throttler/timer.rb
 - README.md
 - spec/fixtures/foo.rb
-- spec/integration/throttler_spec.rb
+- spec/integration/blocks_with_long_execution_time_spec.rb
+- spec/integration/fibers_spec.rb
+- spec/integration/loop_spec.rb
+- spec/integration/processes_spec.rb
+- spec/integration/threads_spec.rb
 - spec/spec_helper.rb
 - spec/unit/throttler/timer_spec.rb
 - spec/unit/throttler_spec.rb
@@ -52,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4404238439013896602
+      hash: -3148749189245223368
       segments: 
       - 0
       version: "0"
@@ -73,7 +77,11 @@ specification_version: 3
 summary: Throttles the frequency in which asynchronously-executed Ruby blocks are run on a single server or network interface.
 test_files: 
 - spec/fixtures/foo.rb
-- spec/integration/throttler_spec.rb
+- spec/integration/blocks_with_long_execution_time_spec.rb
+- spec/integration/fibers_spec.rb
+- spec/integration/loop_spec.rb
+- spec/integration/processes_spec.rb
+- spec/integration/threads_spec.rb
 - spec/spec_helper.rb
 - spec/unit/throttler/timer_spec.rb
 - spec/unit/throttler_spec.rb

data/spec/integration/throttler_spec.rb

@@ -1,100 +0,0 @@
-require "benchmark"
-require "fileutils"
-require "spec_helper"
-
-class Bar
-  include Throttler
-
-  def bar
-    throttle("bar"){ noop }
-  end
-
-  def baz
-    throttle("baz"){ noop }
-  end
-
-  def exceptional
-    throttle("bar"){ raise }
-  end
-
-  def noop; end
-end
-
-describe "Throttler" do
-  before do
-    FileUtils.rm "/tmp/.bar", :force => true
-    FileUtils.rm "/tmp/.baz", :force => true
-  end
-
-  it "throttles a loop" do
-    time = Benchmark.realtime do
-      3.times do
-        Bar.new.bar
-      end
-    end
-
-    time.should be_close 2, 0.1
-  end
-
-  it "throttles threads" do
-    count = 0
-    threads = 10.times.collect do
-      Thread.new do
-        bar = Bar.new
-        loop do
-          bar.bar
-          count += 1
-        end
-      end
-    end
-    sleep 2.2
-    threads.each { |t| Thread.kill(t) }
-
-    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"}`
-      end
-    end
-
-    time.should be > 4.0
-  end
-
-  it "supports multiple throttles" do
-    count = 0
-    threads = 10.times.collect do
-      Thread.new do
-        bar = Bar.new
-        loop do
-          count % 2 == 0 ? bar.bar : bar.baz
-          count += 1
-        end
-      end
-    end
-    sleep 2.2
-    threads.each { |t| Thread.kill(t) }
-
-    count.should eql 6
-  end
-end