frugal_timeout 0.0.9 → 0.0.10

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Mac shit
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"

data/Gemfile

@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'coveralls', :require => false
+gem 'hitimes', '~> 1.2'

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (C) 2013, 2014 by Dmitry Maksyoma <ledestin@gmail.com>
+
+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.md

@@ -0,0 +1,58 @@
+frugal_timeout
+==============
+
+[![Build Status](https://travis-ci.org/ledestin/frugal_timeout.png)](https://travis-ci.org/ledestin/frugal_timeout)
+[![Coverage Status] (https://coveralls.io/repos/ledestin/frugal_timeout/badge.png)] (https://coveralls.io/r/ledestin/frugal_timeout)
+[![Code Climate](https://codeclimate.com/github/ledestin/frugal_timeout.png)](https://codeclimate.com/github/ledestin/frugal_timeout)
+
+Ruby Timeout.timeout replacement using only 1 thread
+
+## Why
+
+As you may know, the stock Timeout.timeout uses thread per timeout call. If you
+use it a lot, you will soon be out of threads. This gem is to provide an
+alternative that uses only 1 thread.
+
+Also, there's a race condition in the 1.9-2.0 stock timeout. Consider the
+following code:
+```
+timeout(0.02) {
+  timeout(0.01, IOError) { sleep }
+}
+```
+
+In this case, the stock timeout will most likely rise IOError, but, given the
+race condition, sometimes it can also rise Timeout::Error. Just put `sleep 0.1'
+inside stock timeout ensure to trigger that. As of version 0.0.9, frugal_timeout
+will always rise IOError.
+
+## Example
+
+```
+require 'frugal_timeout'
+
+begin
+  FrugalTimeout.timeout(0.1) { sleep }
+rescue Timeout::Error
+  puts 'it works!'
+end
+
+# Ensure that calling timeout() will use FrugalTimeout.timeout().
+FrugalTimeout.dropin!
+
+# Rescue frugal-specific exception if needed.
+begin
+  timeout(0.1) { sleep }
+rescue FrugalTimeout::Error
+  puts 'yay!'
+end
+```
+
+## Installation
+
+Tested on Ruby 1.9.3 and 2.0.0, but may work on 1.8 as well (tests will not work
+though).
+
+```
+gem install frugal_timeout
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+task :gem do
+  system 'gem build *.gemspec'
+end

data/TODO

@@ -0,0 +1,21 @@
+# * Add docs like in null_object gem.
+
+require 'frugal_timeout'
+
+FrugalTimeout.dropin!
+
+timeout(1.0, Timeout::Error) {
+  begin
+    sleep 0.8;
+    timeout(0.3, Timeout::Error) {
+      begin
+	sleep 0.2;
+      rescue Timeout::Error;
+	puts "0.3 expired"
+      end
+    };
+    sleep 86400;
+  rescue Timeout::Error;
+    puts "1.0 expired"
+  end
+}

data/frugal_timeout.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name        = 'frugal_timeout'
+  s.version     = '0.0.10'
+  s.date        = '2014-01-02'
+  s.summary     = 'Timeout.timeout replacement'
+  s.description = 'Timeout.timeout replacement that uses only 1 thread'
+  s.authors     = ['Dmitry Maksyoma']
+  s.email       = 'ledestin@gmail.com'
+  s.files       = `git ls-files`.split($\)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.homepage    = 'https://github.com/ledestin/frugal_timeout'
+
+  s.add_development_dependency 'rspec', '>= 2.13'
+  s.add_runtime_dependency 'hitimes', '~> 1.2'
+end

data/lib/frugal_timeout.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 by Dmitry Maksyoma <ledestin@gmail.com>
+# Copyright (C) 2013, 2014 by Dmitry Maksyoma <ledestin@gmail.com>
 
 require 'hitimes'
 require 'monitor'
@@ -32,10 +32,11 @@ require 'timeout'
 # }}}1
 module FrugalTimeout
   # {{{1 Error
-  class Error < Timeout::Error; end # :nodoc:
+  class Error < Timeout::Error #:nodoc:
+  end
 
   # {{{1 MonotonicTime
-  class MonotonicTime # :nodoc:
+  class MonotonicTime #:nodoc:
     NANOS_IN_SECOND = 1_000_000_000
 
     def self.measure
@@ -50,7 +51,7 @@ module FrugalTimeout
   end
 
   # {{{1 Request
-  class Request # :nodoc:
+  class Request #:nodoc:
     include Comparable
     @@mutex = Mutex.new
 
@@ -82,7 +83,7 @@ module FrugalTimeout
   end
 
   # {{{1 RequestQueue
-  class RequestQueue # :nodoc:
+  class RequestQueue #:nodoc:
     extend Forwardable
 
     def_delegators :@requests, :empty?, :first, :<<
@@ -138,7 +139,7 @@ module FrugalTimeout
   # It's possible to set a new expiry time before the time set previously
   # expires. In this case, processing of the old request stops and the new
   # request processing starts.
-  class SleeperNotifier # :nodoc:
+  class SleeperNotifier #:nodoc:
     include MonitorMixin
 
     DO_NOTHING = proc {}
@@ -201,7 +202,7 @@ module FrugalTimeout
   end
 
   # {{{1 SortedQueue
-  class SortedQueue # :nodoc:
+  class SortedQueue #:nodoc:
     include MonitorMixin
 
     def initialize storage=[]
@@ -291,7 +292,7 @@ module FrugalTimeout
        end'
   end
 
-  def self.on_ensure &b # :nodoc:
+  def self.on_ensure &b #:nodoc:
     @onEnsure = b
   end
 

data/spec/frugal_timeout_spec.rb

@@ -0,0 +1,349 @@
+#!/usr/bin/env ruby
+
+require 'rspec'
+require 'spec_helper'
+require 'frugal_timeout'
+
+FrugalTimeout.dropin!
+Thread.abort_on_exception = true
+MonotonicTime = FrugalTimeout::MonotonicTime
+
+SMALLEST_TIMEOUT = 0.0000001
+
+# {{{1 Helper methods
+def multiple_timeouts growing, cnt
+  res, resMutex = [], Mutex.new
+  if growing
+    1.upto(cnt) { |sec| new_timeout_request_thread sec, res, resMutex } 
+  else
+    cnt.downto(1) { |sec| new_timeout_request_thread sec, res, resMutex } 
+  end
+  sleep 1 until res.size == cnt
+  res.each_with_index { |t, i| t.round.should == i + 1 }
+end
+
+def new_timeout_request sec, res, resMutex
+  begin
+    start = MonotonicTime.now
+    timeout(sec) { sleep }
+  rescue FrugalTimeout::Error
+    resMutex.synchronize { res << MonotonicTime.now - start }
+  end
+end
+
+def new_timeout_request_thread sec, res, resMutex
+  Thread.new { new_timeout_request sec, res, resMutex }
+end
+
+# {{{1 FrugalTimeout
+describe FrugalTimeout do
+  it 'handles multiple < 1 sec timeouts correctly' do
+    LargeDelay, SmallDelay = 0.44, 0.1
+    ar, arMutex, started = [], Mutex.new, false
+    Thread.new {
+      begin
+	timeout(LargeDelay) { started = true; sleep }
+      rescue FrugalTimeout::Error
+	arMutex.synchronize { ar << LargeDelay }
+      end
+    }
+    sleep 0.01 until started
+    Thread.new {
+      begin
+	timeout(SmallDelay) { sleep }
+      rescue FrugalTimeout::Error
+	arMutex.synchronize { ar << SmallDelay }
+      end
+    }
+    sleep 0.1 until arMutex.synchronize { ar.size == 2 }
+    ar.first.should == SmallDelay
+    ar.last.should == LargeDelay
+  end
+
+  it 'handles lowering timeouts well' do
+    multiple_timeouts false, 5
+  end
+
+  it 'handles growing timeouts well' do
+    multiple_timeouts true, 5
+  end
+
+  it 'handles a lot of timeouts well' do
+    res, resMutex = [], Mutex.new
+    150.times {
+      Thread.new {
+	5.times { new_timeout_request 1, res, resMutex }
+      }
+    }
+    sleep 1 until res.size == 750
+    res.each { |sec| sec.round.should == 1 }
+  end
+
+  it 'handles new timeout well after sleep' do
+    res, resMutex = [], Mutex.new
+    new_timeout_request_thread 2, res, resMutex
+    sleep 0.5
+    new_timeout_request_thread 1, res, resMutex
+    sleep 1 until res.size == 2
+    res.first.round.should == 1
+    res.last.round.should == 2
+  end
+
+  it 'handles multiple consecutive same timeouts' do
+    res, resMutex = [], Mutex.new
+    (cnt = 5).times { new_timeout_request 1, res, resMutex }
+    sleep 1 until res.size == cnt
+    res.each { |sec| sec.round.should == 1 }
+  end
+
+  it 'handles multiple concurrent same timeouts' do
+    res, resMutex = [], Mutex.new
+    (cnt = 5).times { new_timeout_request_thread 1, res, resMutex }
+    sleep 1 until res.size == cnt
+    res.each { |sec| (sec - 1).should < 0.01 }
+  end
+
+  context 'recursive timeouts' do
+    it 'works if recursive timeouts rescue thrown exception' do
+      # A rescue block will only catch exception for the timeout() block it's
+      # written for.
+      expect {
+	timeout(0.5) {
+	  begin
+	    timeout(1) {
+	      begin
+		timeout(2) { sleep }
+	      rescue Timeout::Error
+	      end
+	    }
+	  rescue Timeout::Error
+	  end
+	}
+      }.to raise_error Timeout::Error
+    end
+
+    context "doesn't raise second exception in the same thread" do
+      before :all do
+	FrugalTimeout.on_ensure { sleep 0.02 }
+      end
+
+      it 'when two requests expire close to each other' do
+	expect {
+	  timeout(0.02) {
+	    timeout(0.01, IOError) { sleep }
+	  }
+	}.to raise_error IOError
+      end
+
+      it "when second request doesn't have a chance to start" do
+	expect {
+	  timeout(0.01, IOError) {
+	    sleep
+	    timeout(1) { sleep }
+	  }
+	}.to raise_error IOError
+      end
+
+      FrugalTimeout.on_ensure
+    end
+  end
+
+  it 'finishes after N sec' do
+    start = MonotonicTime.now
+    expect { timeout(1) { sleep 2 } }.to raise_error FrugalTimeout::Error
+    (MonotonicTime.now - start).round.should == 1
+
+    start = MonotonicTime.now
+    expect { timeout(1) { sleep 3 } }.to raise_error FrugalTimeout::Error
+    (MonotonicTime.now - start).round.should == 1
+  end
+
+  it 'returns value from block' do
+    timeout(1) { 10 }.should == 10
+    timeout(1) { 20 }.should == 20
+  end
+
+  it 'passes timeout to block' do
+    timeout(10) { |t| t }.should == 10
+    timeout(20) { |t| t }.should == 20
+  end
+
+  it 'raises specified exception' do
+    expect { timeout(0.1, IOError) { sleep } }.to raise_error IOError
+  end
+
+  it "doesn't raise exception if there's no need" do
+    timeout(1) { }
+    sleep 2
+  end
+
+  it 'handles exception within timeout()' do
+    begin
+      timeout(1) { raise 'lala' }
+    rescue
+    end
+    sleep 2
+  end
+
+  it 'handles already expired timeout well' do
+    expect { timeout(SMALLEST_TIMEOUT) { sleep } }.to \
+      raise_error FrugalTimeout::Error
+  end
+
+  it 'acts as stock timeout (can rescue the same exception)' do
+    expect { timeout(SMALLEST_TIMEOUT) { sleep } }.to \
+      raise_error Timeout::Error
+  end
+end
+
+# {{{1 MonotonicTime
+describe FrugalTimeout::MonotonicTime do
+  it 'ticks properly' do
+    start = MonotonicTime.now
+    sleep 0.1
+    (MonotonicTime.now - start).round(1).should == 0.1
+  end
+
+  it '#measure works' do
+    sleptFor = MonotonicTime.measure { sleep 0.5 }
+    sleptFor.round(1).should == 0.5
+  end
+end
+
+# {{{1 Request
+describe FrugalTimeout::Request do
+  it '#defuse! and #defused? work' do
+    req = FrugalTimeout::Request.new(Thread.current,
+      MonotonicTime.now, FrugalTimeout::Error)
+    req.defused?.should == false
+    req.defuse!
+    req.defused?.should == true
+  end
+end
+
+# {{{1 RequestQueue
+describe FrugalTimeout::RequestQueue do
+  before :each do
+    @ar = []
+    @requests = FrugalTimeout::RequestQueue.new
+    @requests.onNewNearestRequest { |request|
+      @ar << request
+    }
+  end
+
+  context 'always invokes callback after purging' do
+    [[10, "didn't expire yet"], [0, 'expired']].each { |sec, msg|
+      it "when request #{msg}" do
+	req = @requests.queue(sec, FrugalTimeout::Error)
+	@ar.size.should == 1
+      end
+    }
+  end
+end
+
+# {{{1 SleeperNotifier
+describe FrugalTimeout::SleeperNotifier do
+  before :all do
+    @queue = Queue.new
+    @sleeper = FrugalTimeout::SleeperNotifier.new
+    @sleeper.onExpiry { @queue.push '.' }
+  end
+
+  def addRequest sec
+    @sleeper.expireAt MonotonicTime.now + sec
+  end
+
+  it 'sends notification after delay passed' do
+    start = MonotonicTime.now
+    addRequest 0.5
+    @queue.shift
+    (MonotonicTime.now - start - 0.5).round(2).should <= 0.01
+  end
+
+  it 'handles negative delay' do
+    MonotonicTime.measure {
+      addRequest -1
+      @queue.shift
+    }.round(1).should == 0
+  end
+
+  it 'sends notification one time only for multiple requests' do
+    5.times { addRequest 0.5 }
+    start = MonotonicTime.now
+    @queue.shift
+    (MonotonicTime.now - start).round(1).should == 0.5
+    @queue.should be_empty
+  end
+
+  it 'can stop current request by sending nil' do
+    addRequest 0.5
+    @sleeper.expireAt nil
+    sleep 0.5
+    @queue.should be_empty
+  end
+
+  it 'can setup onExpiry again and not break' do
+    @sleeper.onExpiry
+    addRequest 0.01
+    # An exception here would be thrown in a different thread in case of a
+    # problem.
+  end
+end
+
+# {{{1 SortedQueue
+describe FrugalTimeout::SortedQueue do
+  before :each do
+    @queue = FrugalTimeout::SortedQueue.new
+  end
+
+  it 'allows to push items into queue' do
+    item = 'a'
+    @queue.push item
+    @queue.first.should == item
+  end
+
+  it 'supports << method' do
+    @queue << 'a'
+    @queue.first.should == 'a'
+  end
+
+  it 'makes first in order item appear first' do
+    @queue.push 'b', 'a'
+    @queue.first.should == 'a'
+    @queue.last.should == 'b'
+  end
+
+  it 'allows removing items from queue' do
+    @queue.push 'a', 'b', 'c'
+    @queue.reject! { |item|
+      next true if item < 'c'
+      break
+    }
+    @queue.size.should == 1
+    @queue.first.should == 'c'
+  end
+
+  it "doesn't sort underlying array if pushed values are first in order" do
+    ar = double
+    class MockArray < Array
+      def sort!
+	raise 'not supposed to call sort!'
+      end
+    end
+    @queue = FrugalTimeout::SortedQueue.new MockArray.new
+    expect {
+      @queue.push 'c'
+      @queue.push 'b'
+      @queue.push 'a'
+      @queue.first == 'a'
+    }.not_to raise_error
+  end
+
+  it '#reject_and_get!' do
+    @queue.push 'a'
+    @queue.push 'b'
+    res = @queue.reject_and_get! { |el| el < 'b' }
+    res.size.should == 1
+    res.first.should == 'a'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frugal_timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-01 00:00:00.000000000 Z
+date: 2014-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -49,7 +49,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- frugal_timeout.gemspec
 - lib/frugal_timeout.rb
+- spec/frugal_timeout_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/ledestin/frugal_timeout
 licenses: []
 post_install_message: 
@@ -74,5 +86,7 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Timeout.timeout replacement
-test_files: []
+test_files:
+- spec/frugal_timeout_spec.rb
+- spec/spec_helper.rb
 has_rdoc: