throttler 0.2.1 → 0.2.2

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
  
-Copyright (c) 2009 Paper Cavalier
+Copyright (c) 2010 Paper Cavalier
  
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,47 +1,27 @@
 Throttler
 =========
 
-Put a throttle on concurrency.
+Throttler is a tired, cranky module that throttles parallel-running Ruby scripts on a single machine.
 
-![Mapplethorpe](http://github.com/papercavalier/throttler/raw/master/mapplethorpe_chains.jpg)
+![Mapplethorpe](https://github.com/papercavalier/throttler/raw/master/mapplethorpe_chains.jpg)
 
 Example
---------
+-------
 
-Let's assume we have multiple workers hitting the Amazon API on three IP addresses.
+Our very own peculiar use case: We have multiple Resque workers hitting the Amazon IP on multiple addresses and want to make sure they don't fire more than once per locale per IP.
 
     class Worker
       include Throttler
-      
-      attr_accessor :interface
-      
-      def request
-        
-        # 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
-    end
-    
-    worker, count = Worker.new, 0
-    
-    (0..3).each do |port|
-      10.times do
-        Thread.new do
-          count += 1
-          worker.interface = "eth#{port}"
-          loop{ worker.request }
+
+      attr_accessor :locale,
+                    :interface
+
+      def perform
+        scope = "#{locale}-#{interface}"
+        freq  = 1.0
+
+        throttle(scope, interval) do
+          # perform a request
         end
       end
     end
-    
-    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,27 +1,27 @@
-module Throttler
+module Throttler #:nodoc:
   class Timer
     def initialize(scope)
       path = "/tmp/.#{scope}"
-      @file = File.open(path, File::RDWR|File::CREAT)
+      @timer = File.open(path, File::RDWR|File::CREAT)
     end
 
     def lock
-      @file.flock(File::LOCK_EX)
+      @timer.flock(File::LOCK_EX)
     end
 
     def timestamp
-      @timestamp ||= @file.gets.to_f
+      @timestamp ||= @timer.gets.to_f
     end
 
     def timestamp=(time)
-      @file.rewind
-      @file.write(time)
+      @timer.rewind
+      @timer.write(time)
       @timestamp = time
     end
 
     def unlock
-      @file.flock(File::LOCK_UN)
-      @file.close
+      @timer.flock(File::LOCK_UN)
+      @timer.close
     end
   end
 end

data/lib/throttler/version.rb

@@ -0,0 +1,4 @@
+module Throttler #:nodoc:
+  VERSION = "0.2.2"
+end
+

data/lib/throttler.rb

@@ -1,18 +1,14 @@
-require File.dirname(__FILE__) + "/throttler/timer"
+require "throttler/timer"
 
-# The Throttler module.
+# = Throttler
 #
-# Include this in the class where you wish to use the throttler.
+# An old, rusty throttler that gets the job done
 module Throttler
 
-  # Throttles the frequency in which a block is run.
+  # Throttles the frequency in which a block is run
   #
-  # Pass throttler scope and the interval between each execution.
-  # Latter defaults to one second.
-  #
-  #    throttle("foo") { some_code }
-  #
-  def throttle(scope, interval=1.0)
+  # Optionally pass a scope and interval.
+  def throttle(scope="throttler", interval=1.0)
     timer = Timer.new(scope)
     timer.lock
     sleep [timer.timestamp + interval - Time.now.to_f, 0.0].max

data/spec/fixtures/foo.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + "/../../lib/throttler"
+$:.push File.expand_path("../../../lib", __FILE__)
+require "throttler"
 
 class Foo
   include Throttler

data/spec/integration/fibers_spec.rb

@@ -9,11 +9,11 @@ describe "Throttler" do
       include Throttler
 
       def bar
-        throttle("foo"){ }
+        throttle { }
       end
     end
 
-    FileUtils.rm "/tmp/.foo", :force => true
+    FileUtils.rm "/tmp/.throttler", :force => true
   end
 
   it "throttles fibers" do
@@ -24,6 +24,6 @@ describe "Throttler" do
       3.times { fib.resume }
     end
 
-    time.should be_close 2, 0.01
+    time.should be_within(0.1).of(2)
   end
 end

data/spec/integration/loop_spec.rb

@@ -8,11 +8,11 @@ describe "Throttler" do
       include Throttler
 
       def bar
-        throttle("foo"){ }
+        throttle { }
       end
     end
 
-    FileUtils.rm "/tmp/.foo", :force => true
+    FileUtils.rm "/tmp/.throttler", :force => true
   end
 
   it "throttles a loop" do
@@ -22,6 +22,6 @@ describe "Throttler" do
       end
     end
 
-    time.should be_close 2, 0.1
+    time.should be_within(0.1).of(2)
   end
 end

data/spec/integration/processes_spec.rb

@@ -17,6 +17,6 @@ describe "Throttler" do
       4.times{ `ruby #{File.dirname(__FILE__) + "/../fixtures/foo.rb"}` }
     end
 
-    (time - startup_time).should be_close(6.0, 0.5)
+    (time - startup_time).should be_within(0.5).of(6.0)
   end
 end

data/spec/integration/threads_spec.rb

@@ -7,7 +7,7 @@ describe "Throttler" do
       include Throttler
 
       def bar
-        throttle("foo"){ }
+        throttle { }
       end
 
       def baz
@@ -15,7 +15,7 @@ describe "Throttler" do
       end
     end
 
-    %w{foo foo-prime}.each do |file|
+    %w{throttler foo-prime}.each do |file|
       FileUtils.rm "/tmp/.#{file}", :force => true
     end
   end

data/spec/spec_helper.rb

@@ -1,4 +1,2 @@
 require "rspec"
 require File.expand_path("../../lib/throttler", __FILE__)
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each{ |f| require f }

data/spec/unit/throttler/timer_spec.rb

@@ -6,7 +6,10 @@ module Throttler
   describe Timer do
     before do
       FileUtils.rm "/tmp/.foo", :force => true
-      @timer = Timer.new("foo")
+    end
+
+    let!(:timer) do
+      Timer.new("foo")
     end
 
     it "creates a file" do
@@ -15,8 +18,10 @@ module Throttler
 
     context "#lock" do
       it "locks the file" do
-        @timer.lock
-        File.open("/tmp/.foo") { |f| f.flock(File::LOCK_EX | File::LOCK_NB).should be_false }
+        timer.lock
+        File.open("/tmp/.foo") do |f|
+          f.flock(File::LOCK_EX | File::LOCK_NB).should be_false
+        end
       end
     end
 
@@ -24,32 +29,36 @@ module Throttler
       it "gets the timestamp" do
         now = Time.now.to_f
         File.open("/tmp/.foo", "w") { |f| f.write(now) }
-        @timer.timestamp.should be_close(now, 0.1)
+        timer.timestamp.should be_within(0.1).of(now)
       end
 
       it "returns 0.0 when file is first created" do
-        @timer.timestamp.should eql(0.0)
+        timer.timestamp.should eql(0.0)
       end
     end
-  
+
     context "#timestamp=" do
       it "sets the timestamp" do
         now = Time.now.to_f
-        @timer.timestamp= now
+        timer.timestamp= now
 
         # We need to close the file first
-        @timer.instance_variable_get(:@file).close
+        timer.instance_variable_get(:@timer).close
 
-        File.open("/tmp/.foo") { |f| f.gets.to_f.should be_close(now, 0.1) }
+        File.open("/tmp/.foo") do |f|
+          f.gets.to_f.should be_within(0.1).of(now)
+        end
       end
     end
 
     context "#unlock" do
       it "unlocks the file" do
-        @timer.lock
-        @timer.unlock
+        timer.lock
+        timer.unlock
 
-        File.open("/tmp/.foo") { |f| f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false }
+        File.open("/tmp/.foo") do |f|
+          f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false
+        end
       end
     end
   end

data/spec/unit/throttler_spec.rb

@@ -6,30 +6,39 @@ describe Throttler do
   before do
     class Foo
       include Throttler
-
-      def bar
-        throttle("foo"){ raise }
-      end
     end
 
-    FileUtils.rm "/tmp/.foo", :force => true
+    FileUtils.rm "/tmp/.throttler", :force => true
+  end
 
-    @foo = Foo.new
+  let!(:foo) do
+    Foo.new
   end
 
-  context "#throttle" do
-    it "removes lock even if block raises an exception" do
-      lambda{ @foo.throttle("foo"){ raise } }.should raise_error
+  describe "#throttle" do
+    it "removes a lock when an exception is raised" do
+      expect do
+        foo.throttle { raise }
+      end.to raise_error
 
-      File.open("/tmp/.foo"){ |f| f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false }
+      File.open("/tmp/.throttler") do |f|
+        f.flock(File::LOCK_EX | File::LOCK_NB).should_not be_false
+      end
     end
 
-    it "throttles for one second by default" do
-      time = Benchmark.realtime do
-        2.times{ @foo.throttle("foo"){ } }
+    context "by default" do
+      it "namespaces as `throttler`" do
+        foo.throttle
+        FileTest.exists?("/tmp/.throttler").should be_true
       end
 
-      time.should be_close 1, 0.1
+      it "throttles for one second" do
+        time = Benchmark.realtime do
+          2.times{ foo.throttle }
+        end
+
+        time.should be_within(0.1).of(1)
+      end
     end
-  end  
+  end
 end

metadata

@@ -5,33 +5,48 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Hakan Ensari
-- Piotr Laszewski
+- "Piotr \xC5\x81aszewski"
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-07-27 00:00:00 +01:00
+date: 2010-11-29 00:00:00 +00:00
 default_executable: 
-dependencies: []
-
-description: Throttles the frequency in which asynchronously-executed Ruby blocks are run on a single server or network interface.
-email: code@papercavalier.com
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id001
+description: A tired, cranky module that throttles parallel-running Ruby scripts on a single machine.
+email: 
+- code@papercavalier.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
-- LICENSE
-- lib/throttler.rb
 - lib/throttler/timer.rb
+- lib/throttler/version.rb
+- lib/throttler.rb
+- LICENSE
 - README.md
 - spec/fixtures/foo.rb
 - spec/integration/blocks_with_long_execution_time_spec.rb
@@ -47,8 +62,8 @@ homepage: http://github.com/papercavalier/throttler
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -56,7 +71,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3148749189245223368
       segments: 
       - 0
       version: "0"
@@ -70,11 +84,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: throttler
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Throttles the frequency in which asynchronously-executed Ruby blocks are run on a single server or network interface.
+summary: A tired, cranky throttler
 test_files: 
 - spec/fixtures/foo.rb
 - spec/integration/blocks_with_long_execution_time_spec.rb