throttled_object 1.0.0 → 1.1.0

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@throttled_object --create

data/README.md

@@ -1,7 +1,8 @@
 # throttled_object
 
 `throttled_object` is a Ruby 1.9 library built on top of ruby to provide throttled access
-to a given object. It provides an interface to interact with an object, sleeping if it's unavailable.
+to a given object. It provides an interface to interact with an object, either sleeping or raising
+an exception when it's not available.
 
 The ideal use for this is for access to APIs with a blocking interface (e.g. Run the code in a thread,
 sleep until it's available).

data/lib/throttled_object.rb

@@ -5,8 +5,10 @@ module ThrottledObject
   require 'throttled_object/proxy'
 
   def self.make(object, options = {}, *args)
-    lock = Lock.new(options)
-    Proxy.new object, lock, *args
+    object_options = args.last.is_a?(Hash) ? args.pop : {}
+    object_options[:lock] = Lock.new(options)
+    args << object_options
+    Proxy.new object, *args
   end
 
 end

data/lib/throttled_object/lock.rb

@@ -3,7 +3,20 @@ require 'redis'
 module ThrottledObject
   class Lock
 
-    class Unavailable < StandardError; end
+    class Error < StandardError; end
+    class Unavailable < Error; end
+    class WaitForLock < Error
+
+      attr_reader :available_at, :wait_for
+
+      def initialize(time, *args)
+        super *args
+        @available_at = Time.now + time
+        @wait_for     = time
+      end
+
+    end
+
 
     KEY_PREFIX = "throttled_object:key:"
 
@@ -26,12 +39,13 @@ module ThrottledObject
     # 2. Occassionally, we need to abort after a short period.
     #
     # So, the lock method operates in two methods. The first, and default, we will basically
-    # loop and attempt to aggressively obtain the lock. We loop until we've obtained a lock - 
+    # loop and attempt to aggressively obtain the lock. We loop until we've obtained a lock -
     # To obtain the lock, we increment the current periods counter and check if it's <= the max count.
     # If it is, we have a lock. If not, we sleep until the lock should be 'fresh' again.
     #
     # If we're the first one to obtain a lock, we update some book keeping data.
     def lock(max_time = nil)
+      raise 'lock must be called with a block' unless block_given?
       started_at = current_period
       has_lock   = false
       until has_lock
@@ -58,13 +72,28 @@ module ThrottledObject
           obtained_at = [redis.get("#{current_key}:obtained_at").to_i, lockable_time].max
           next_period = (lockable_time + period)
           wait_for    = (next_period - current_period).to_f / 1000
-          sleep wait_for
+          yield wait_for
         end
       end
     end
 
+    def wait_for_lock(*args)
+      lock(*args) { |time| sleep time }
+    end
+
+    def lock!(*args)
+      lock(*args) do |time|
+        raise WaitForLock.new(time, "Lock unavailable, please wait #{time} seconds and attempt again.")
+      end
+    end
+
     def synchronize(*args, &blk)
-      lock *args
+      wait_for_lock *args
+      yield if block_given?
+    end
+
+    def synchronize!(*args, &blk)
+      lock! *args
       yield if block_given?
     end
 

data/lib/throttled_object/proxy.rb

@@ -5,17 +5,24 @@ module ThrottledObject
 
     attr_accessor :lock, :throttled_methods
 
-    def initialize(object, lock, throttled_methods = nil)
+    def initialize(object, options = {})
       super object
-      @lock              = lock
+      @lock              = options.fetch(:lock)
+      @blocking          = options.fetch :blocking, true
+      @lock_method       = @blocking ? :synchronize : :synchronize!
+      throttled_methods  = options.fetch :methods, nil
       @throttled_methods = throttled_methods && throttled_methods.map(&:to_sym)
     end
 
     private
 
+    def lock_method?(m)
+      throttled_methods.nil? || throttled_methods.include?(m.to_sym)
+    end
+
     def method_missing(m, *args, &block)
-      if throttled_methods.nil? || throttled_methods.include?(m.to_sym)
-        @lock.synchronize { super }
+      if lock_method?(m)
+        @lock.send(@lock_method) { super }
       else
         super
       end

data/lib/throttled_object/version.rb

@@ -1,3 +1,3 @@
 module ThrottledObject
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/lock_spec.rb

@@ -10,15 +10,44 @@ describe ThrottledObject::Lock do
   end
 
   it 'should throttle access under the limit' do
-    expect_to_take(0.0..0.99) { 4.times { lock.lock } }
+    expect_to_take(0.0..0.99) { 4.times { lock.wait_for_lock } }
   end
 
   it 'should throttle access equal to the limit' do
-    expect_to_take(0.0..0.99) { 5.times { lock.lock } }
+    expect_to_take(0.0..0.99) { 5.times { lock.wait_for_lock } }
   end
 
   it 'correctly throttle access over the limit' do
-    expect_to_take(1.0..1.99) { 6.times { lock.lock } }
+    expect_to_take(1.0..1.99) { 6.times { lock.wait_for_lock } }
+  end
+
+  it 'should allow you to have an exceptional version' do
+    started_at = Time.now.to_f
+    ended_at   = nil
+    5.times { lock.lock! }
+    begin
+      lock.lock!
+      raise 'Should not reach this point'
+    rescue => e
+      ended_at = Time.now.to_f
+      e.should be_a ThrottledObject::Lock::WaitForLock
+      time_range = (started_at + 1.0)..(started_at + 2.0)
+      time_range.should include e.available_at.to_f
+    end
+    ended_at.should_not be_nil
+    (0.0..0.99).should include (ended_at - started_at)
+  end
+
+  it 'should use lock! for synchronize!' do
+    dont_allow(lock).wait_for_lock
+    mock.proxy(lock).lock! { |v| v }
+    lock.synchronize! { true }
+  end
+
+  it 'should use wait_for_lock for synchronize' do
+    dont_allow(lock).lock!
+    mock.proxy(lock).wait_for_lock { |v| v }
+    lock.synchronize { true }
   end
 
   def expect_to_take(range, &block)

data/spec/proxy_spec.rb

@@ -17,7 +17,7 @@ describe ThrottledObject::Proxy do
   end
 
   it 'should let you control which methods invoke it' do
-    proxy = ThrottledObject::Proxy.new target, lock, [:hello]
+    proxy = ThrottledObject::Proxy.new target, lock: lock, methods: [:hello]
     proxy.one.should == 1
     lock.value.should == 0
     proxy.other.should == nil
@@ -29,7 +29,7 @@ describe ThrottledObject::Proxy do
   end
 
   it 'should default to requiring all are throttled' do
-    proxy = ThrottledObject::Proxy.new target, lock
+    proxy = ThrottledObject::Proxy.new target, lock: lock
     expect do
       proxy.one.should == 1
     end.to change(lock, :value).by(1)
@@ -41,4 +41,13 @@ describe ThrottledObject::Proxy do
     end.to change(lock, :value).by(1)
   end
 
+  it 'should let you make a blocking one' do
+    def lock.synchronize!; yield if block_given?; end
+    def lock.synchronize; raise 'Lock using synchronize, not synchronize!.'; end
+    proxy = ThrottledObject::Proxy.new target, lock: lock, blocking: false
+    proxy.one.should == 1
+    proxy = ThrottledObject::Proxy.new target, lock: lock, blocking: true
+    expect { proxy.one }.to raise_error
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 ENV['REDIS_URL'] ||= "redis://127.0.0.1:6379/#{ENV['REDIS_TEST_DATABASE'] || 9}"
 
 require 'throttled_object'
+require 'rr'
 
-RSpec.configure do |config| 
+RSpec.configure do |config|
+  config.mock_with :rr
 end

data/throttled_object.gemspec

@@ -16,8 +16,8 @@ Gem::Specification.new do |gem|
   gem.version       = ThrottledObject::VERSION
 
   gem.add_dependency 'redis', '~> 3.0'
-  gem.add_development_dependency 'timecop'
   gem.add_development_dependency 'rspec', '~> 2.0'
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rr'
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: throttled_object
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-18 00:00:00.000000000 Z
+date: 2012-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -28,39 +28,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rr
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -84,6 +84,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .rvmrc
 - Gemfile
 - LICENSE
 - README.md
@@ -109,12 +110,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4367176850969236044
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4367176850969236044
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24