SystemTimer 1.1.3 → 1.2

data/ChangeLog

@@ -1,4 +1,18 @@
-=== 1.1.3/ 2009-29-11
+=== 1.2 / 2010-02-25
+
+ * Changed from using Mutex to Monitor. Mutex causes thread join
+   errors when Ruby is compiled with -disable-pthreads
+	 (Contributed by Dmytro Shteflyuk <http://kpumuk.info/>)
+
+ * Timeouts can now be specified as a float and be a fraction of a second.
+   e.g. `SystemTimer.timeout(0.5)`
+	 (Based on a contribution by Dmytro Shteflyuk <http://kpumuk.info/>)
+ 
+ * Added support for custom timeout exception. Useful to avoid interference
+   with other libraries using `Timeout::Error` (e.g. `Net::HTTP`)
+   (Contributed by runix <http://github.com/runix>)
+
+=== 1.1.3/ 2009-11-29
 
  * Preparing GemCutter migration
 

data/README

@@ -1,47 +1,110 @@
-== Synopsis
+Synopsis
+========
 
-System Timer, a timer based on underlying SIGALRM system timers, is a
+System Timer, a timer based on underlying `SIGALRM` system timers, is a
 solution to Ruby processes which hang beyond the time limit when accessing
-external resources. This is useful when timeout.rb, which relies on green
-threads, does not work consistently.
+external resources. This is useful when `timeout.rb`, which, on M.R.I 1.8,
+relies on green threads, does not work consistently.
 
 More background on:
 
-* http://ph7spot.com/articles/system_timer 
-* http://davidvollbracht.com/2008/6/2/30-days-of-teach-day-1-systemtimer
+* [http://ph7spot.com/musings/system-timer](http://ph7spot.com/musings/system-timer)
+* [http://davidvollbracht.com/2008/6/2/30-days-of-teach-day-1-systemtimer](http://davidvollbracht.com/2008/6/2/30-days-of-teach-day-1-systemtimer)
 
-== Usage
+Usage 
+=====
 
-  require 'systemtimer'
+    require 'systemtimer'
+  
+    SystemTimer.timeout_after(5) do
+  
+      # Something that should be interrupted if it takes too much time...
+      # ... even if blocked on a system call!
+  
+    end
 
-  SystemTimer.timeout_after(5) do
+ Timeouts as Floats
+ ------------------
 
-    # Something that should be interrupted if it takes too much time...
-    # ... even if blocked on a system call!
+  You can use a floating point number when specifying the timeout in
+  seconds but SystemTimer will not allow you to go below 200ms, e.g.
 
-  end
+    SystemTimer.timeout_after(0.5) do 
+      # timeout after 500ms
+    end
 
-== Requirements
+    SystemTimer.timeout_after(0.01) do 
+      # timeout after (uncompressable) 200ms even if 10ms is requested
+    end
+
+  Note that SystemTimer is going through too many layers to be 
+  able to reliably guarantee a sub-second timeout on all platforms, 
+  so your mileage may vary when specifying timeouts under one second.
+
+ Custom Timeout Exceptions
+ -------------------------
+
+  You can also use a custom timeout exception to be raised on timeouts (to
+  avoid interference with other libraries using `Timeout::Error` -- e.g. `Net::HTTP`)
+
+    require 'systemtimer'
+ 
+    begin
+
+      SystemTimer.timeout_after(5, MyCustomTimeoutException) do
+    
+        # Something that should be interrupted if it takes too much time...
+        # ... even if blocked on a system call!
+    
+      end
+
+    rescue MyCustomTimeoutException => e
+      # Recovering strategy
+    end
+
+
+Requirements
+============
 
 SystemTimer only works on UNIX platforms (Mac OS X, Linux, Solaris, BSD, ...).
 You can install the gem on Microsoft Windows, but you will only get 
 a convenience shell wrapping a simple call to timeout.rb under the cover.
 
-== Install
+Install
+=======
 
     sudo gem install systemtimer
 
 
-== Authors
+Authors
+=======
 
 * David Vollbracht  <http://davidvollbracht.com>
-* Philippe Hanrigou <http:/ph7spot.com>
-   
-== Copyright
+* Philippe Hanrigou <http://ph7spot.com>
+
+Contributor
+===========
+
+* Dmytro Shteflyuk <http://kpumuk.info/> :
+   - Changed from using Mutex to Monitor. Evidently Mutex causes thread
+     join errors when Ruby is compiled with -disable-pthreads
+     <http://github.com/kpumuk/system-micro-timer/commit/fe28f4dcf7d4126e53b7c642c5ec35fe8bc1e081>
+   - First tentative to support float timeouts
+     <http://github.com/kpumuk/system-micro-timer/commit/57fff73849aad7c94f8b9234352b7288d1314d21>
+
+* runix <http://github.com/runix> :
+   - Added support for custom timeout exception. Useful to avoid interference
+     with other libraries using `Timeout::Error` (e.g. `Net::HTTP`)
+     <http://github.com/runix/system-timer/commit/d33acb3acc53d5105c68b25c3a2126fa682f12c0>
+     <http://github.com/runix/system-timer/commit/d8ca3452e462ea909d8e11a6091e7c30dfa3a1a8>
+
+Copyright
+=========
 
-Copyright:: (C) 2008  David Vollbracht & Philippe Hanrigou
+Copyright:: (C) 2008-2010  David Vollbracht & Philippe Hanrigou
 
-== Description
+Description
+===========
 
 While deploying Rails application in production our team discovered
 that some web service call would not timeout way beyond their defined
@@ -66,11 +129,12 @@ timeout.rb, just a way to wrap sensitive call to system resources.
 You can find more details on SystemTimer and how to use it 
 at http://ph7spot.com/articles/system_timer 
 
-== License
+License
+=======
 
 (The Ruby License)
 
-Copyright:: (C) 2008  David Vollbracht & Philippe Hanrigou
+Copyright:: (C) 2008-2010  David Vollbracht & Philippe Hanrigou
 
 SystemTimer is copyrighted free software by David Vollbracht and Philippe Hanrigou.
 You can redistribute it and/or modify it under either the terms of the GPL
@@ -83,33 +147,33 @@ You can redistribute it and/or modify it under either the terms of the GPL
   2. You may modify your copy of the software in any way, provided that
      you do at least ONE of the following:
 
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-          modifications to Usenet or an equivalent medium, or by allowing
-	      the author to include your modifications in the software.
+    a) place your modifications in the Public Domain or otherwise
+       make them Freely Available, such as by posting said
+       modifications to Usenet or an equivalent medium, or by allowing
+       the author to include your modifications in the software.
 
-       b) use the modified software only within your corporation or
-          organization.
+    b) use the modified software only within your corporation or
+       organization.
 
-       c) rename any non-standard executables so the names do not conflict
-	      with standard executables, which must also be provided.
+    c) rename any non-standard executables so the names do not conflict
+       with standard executables, which must also be provided.
 
-       d) make other distribution arrangements with the author.
+    d) make other distribution arrangements with the author.
 
   3. You may distribute the software in object code or executable
      form, provided that you do at least ONE of the following:
 
-       a) distribute the executables and library files of the software,
-          together with instructions (in the manual page or equivalent)
-          on where to get the original distribution.
+    a) distribute the executables and library files of the software,
+       together with instructions (in the manual page or equivalent)
+       on where to get the original distribution.
 
-       b) accompany the distribution with the machine-readable source of
-          the software.
+    b) accompany the distribution with the machine-readable source of
+       the software.
 
-       c) give non-standard executables non-standard names, with
-          instructions on where to get the original software distribution.
+    c) give non-standard executables non-standard names, with
+       instructions on where to get the original software distribution.
 
-       d) make other distribution arrangements with the author.
+    d) make other distribution arrangements with the author.
 
   4. You may modify and include the part of the software into any other
      software (possibly commercial).  But some files in the distribution

data/ext/system_timer/system_timer_native.c

@@ -12,6 +12,8 @@
 
 #define DISPLAY_ERRNO 	 		 1
 #define DO_NOT_DISPLAY_ERRNO 0
+#define MICRO_SECONDS 1000000.0
+#define MINIMUM_TIMER_INTERVAL_IN_SECONDS 0.2
 
 VALUE rb_cSystemTimer;
 sigset_t original_mask;
@@ -26,7 +28,7 @@ static void restore_original_ruby_sigalrm_handler(VALUE);
 static void restore_original_sigalrm_mask_when_blocked();
 static void restore_original_timer_interval();
 static void set_itimerval_with_minimum_1s_interval(struct itimerval *, VALUE);
-static void set_itimerval(struct itimerval *, int);
+static void set_itimerval(struct itimerval *, double);
 static void restore_sigalrm_mask(sigset_t *previous_mask);
 static void log_debug(char*, ...);
 static void log_error(char*, int);
@@ -37,7 +39,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
     struct itimerval timer_interval;
 
     if (debug_enabled) {
-        log_debug("[install_first_timer] %d s\n", NUM2INT(seconds));
+        log_debug("[install_first_timer] %.2lfs\n", NUM2DBL(seconds));
     }
 
     /*
@@ -70,7 +72,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
     /*
      * Save original real time interval timer and aet new real time interval timer.     
      */	
-    set_itimerval(&original_timer_interval, 0);
+    set_itimerval(&original_timer_interval, 0.0);
     set_itimerval_with_minimum_1s_interval(&timer_interval, seconds);
     if (0 != setitimer(ITIMER_REAL, &timer_interval, &original_timer_interval)) {
         log_error("[install_first_timer] Could not install our own timer, timeout will not work", DISPLAY_ERRNO);
@@ -78,7 +80,10 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
         restore_original_sigalrm_mask_when_blocked();
         return Qnil;
     }
-    log_debug("[install_first_timer] Successfully installed timer (%ds)\n", timer_interval.it_value.tv_sec);
+    if (debug_enabled) {
+      log_debug("[install_first_timer] Successfully installed timer (%ds)\n", 
+                timer_interval.it_value.tv_sec);
+    }
 
     /*
      * Unblock SIG_ALRM
@@ -100,7 +105,7 @@ static VALUE install_next_timer(VALUE self, VALUE seconds)
     sigset_t previous_sigalarm_mask;
 
     if (debug_enabled) {
-        log_debug("[install_next_timer] %ds\n", NUM2INT(seconds));
+        log_debug("[install_next_timer] %.2lfs\n", NUM2DBL(seconds));
     }
 
     /*
@@ -122,7 +127,10 @@ static VALUE install_next_timer(VALUE self, VALUE seconds)
         restore_sigalrm_mask(&previous_sigalarm_mask);
         return Qnil;
     }
-    log_debug("[install_next_timer] Successfully installed timer (%ds)\n", timer_interval.it_value.tv_sec);
+    if (debug_enabled) {
+      log_debug("[install_next_timer] Successfully installed timer (%ds + %dus)\n", 
+                timer_interval.it_value.tv_sec, timer_interval.it_value.tv_usec);
+    }
 
     /*
      * Unblock SIG_ALRM
@@ -264,20 +272,28 @@ static void init_sigalarm_mask()
 static void set_itimerval_with_minimum_1s_interval(struct itimerval *value, 
                                                    VALUE seconds) {
 
-    int sanitized_second_interval;
+    double sanitized_second_interval;
                                                      
-    sanitized_second_interval = NUM2INT(seconds);
-    if (sanitized_second_interval <= 0 ) {
-        sanitized_second_interval = 1;
+    sanitized_second_interval = NUM2DBL(seconds) + MINIMUM_TIMER_INTERVAL_IN_SECONDS;
+    if (sanitized_second_interval < MINIMUM_TIMER_INTERVAL_IN_SECONDS ) {
+        sanitized_second_interval = MINIMUM_TIMER_INTERVAL_IN_SECONDS;
     }
     set_itimerval(value, sanitized_second_interval);
 }
 
-static void set_itimerval(struct itimerval *value, int seconds) {
+static void set_itimerval(struct itimerval *value, double seconds) {
+    if (debug_enabled) {
+      log_debug("[set_itimerval] %.3lfs\n", seconds);
+    }
     value->it_interval.tv_usec = 0;
     value->it_interval.tv_sec = 0;
-    value->it_value.tv_usec = 0;
-    value->it_value.tv_sec = seconds; // (long int) 
+    value->it_value.tv_sec = (long int) (seconds);
+    value->it_value.tv_usec = (long int) ((seconds - value->it_value.tv_sec) \
+                                          * MICRO_SECONDS);
+    if (debug_enabled) {
+      log_debug("[set_itimerval] Set to %ds + %dus\n", value->it_value.tv_sec, 
+                                                       value->it_value.tv_usec);
+    }
     return;
 }
 

data/lib/system_timer.rb

@@ -3,6 +3,7 @@
 require 'rubygems'
 require 'timeout'
 require 'forwardable'
+require 'monitor'
 require File.dirname(__FILE__) + '/system_timer/thread_timer'
 require File.dirname(__FILE__) + '/system_timer/concurrent_timer_pool'
 
@@ -29,9 +30,9 @@ require File.dirname(__FILE__) + '/system_timer/concurrent_timer_pool'
 #
 module SystemTimer
 
-  Thread.exclusive do    # Avoid race conditions for mutex and pool creation
+  Thread.exclusive do    # Avoid race conditions for monitor and pool creation
     @timer_pool = ConcurrentTimerPool.new
-    @mutex = Mutex.new
+    @monitor = Monitor.new
   end
   
   class << self
@@ -40,12 +41,12 @@ module SystemTimer
     # Executes the method's block. If the block execution terminates before 
     # +seconds+ seconds has passed, it returns true. If not, it terminates 
     # the execution and raises a +Timeout::Error+.
-    def timeout_after(seconds)
+    def timeout_after(seconds, exception_class = nil)
       new_timer = nil                                      # just for scope
-      @mutex.synchronize do
-        new_timer = timer_pool.add_timer seconds
+      @monitor.synchronize do
+        new_timer = timer_pool.add_timer seconds, exception_class
         timer_interval = timer_pool.next_trigger_interval_in_seconds
-        debug "==== Install Timer ==== at #{Time.now.to_i}, next interval: #{timer_interval}"
+        debug "==== Install Timer ==== at #{Time.now.to_f}, next interval: #{timer_interval}"
         if timer_pool.first_timer?
           install_first_timer_and_save_original_configuration timer_interval
         else
@@ -54,8 +55,8 @@ module SystemTimer
      end
       return yield
     ensure
-      @mutex.synchronize do
-        debug "==== Cleanup Timer ==== at #{Time.now.to_i}, #{new_timer} "
+      @monitor.synchronize do
+        debug "==== Cleanup Timer ==== at #{Time.now.to_f}, #{new_timer} "
         timer_pool.cancel new_timer
         timer_pool.log_registered_timers if debug_enabled?
         next_interval = timer_pool.next_trigger_interval_in_seconds
@@ -75,7 +76,7 @@ module SystemTimer
    
    def install_ruby_sigalrm_handler            #:nodoc:
      @original_ruby_sigalrm_handler = trap('SIGALRM') do
-       @mutex.synchronize do
+       @monitor.synchronize do
           # Triggers timers one at a time to ensure more deterministic results
           timer_pool.trigger_next_expired_timer
        end
@@ -104,4 +105,4 @@ module SystemTimer
 
 end
 
-require 'system_timer_native'
+require 'system_timer_native'

data/lib/system_timer/concurrent_timer_pool.rb

@@ -8,14 +8,14 @@ module SystemTimer
       @timers ||= []
     end
         
-    def register_timer(trigger_time, thread)
-      new_timer = ThreadTimer.new(trigger_time, thread)
+    def register_timer(trigger_time, thread, exception_class=nil)
+      new_timer = ThreadTimer.new(trigger_time, thread, exception_class)
       registered_timers << new_timer
       new_timer
     end
 
-    def add_timer(interval_in_seconds)
-      new_timer = register_timer(Time.now.to_i + interval_in_seconds, Thread.current)
+    def add_timer(interval_in_seconds, exception_class=nil)
+      new_timer = register_timer(Time.now.to_f + interval_in_seconds, Thread.current, exception_class)
       log_registered_timers if SystemTimer.debug_enabled?
       new_timer
     end
@@ -39,11 +39,15 @@ module SystemTimer
 
     def next_trigger_interval_in_seconds
       timer = next_timer
-      [0, (timer.trigger_time - Time.now.to_i)].max unless timer.nil?
+      [0, (timer.trigger_time - Time.now.to_f)].max unless timer.nil?
     end
     
     def next_expired_timer(now_in_seconds_since_epoch)
       candidate_timer = next_timer
+      if SystemTimer.debug_enabled?
+        puts "Candidate timer at #{now_in_seconds_since_epoch} : " +
+             candidate_timer.inspect
+      end
       return nil if candidate_timer.nil? || 
                     candidate_timer.trigger_time > now_in_seconds_since_epoch
       candidate_timer
@@ -51,15 +55,17 @@ module SystemTimer
 
     def trigger_next_expired_timer_at(now_in_seconds_since_epoch)
       timer = next_expired_timer(now_in_seconds_since_epoch)
+      puts "Next expired timer : #{timer.inspect}" if SystemTimer.debug_enabled?
       return if timer.nil?
 
       cancel timer
       log_timeout_received(timer) if SystemTimer.debug_enabled?
-      timer.thread.raise Timeout::Error.new("time's up!")
+      timer.thread.raise timer.exception_class.new("time's up!")
     end
 
     def trigger_next_expired_timer
-      trigger_next_expired_timer_at Time.now.to_i
+      puts "Trigger next expired timer" if SystemTimer.debug_enabled?
+      trigger_next_expired_timer_at Time.now.to_f
     end
     
     def log_timeout_received(thread_timer)          #:nodoc:
@@ -74,10 +80,10 @@ module SystemTimer
 
     def log_registered_timers          #:nodoc:
       puts <<-EOS
-            Registered Timers: #{registered_timers.collect do |t| t.to_s end} 
+            Registered Timers: #{registered_timers.map {|t| t.to_s}.join("\n                               ")}
       EOS
     end
     
   end
   
-end
+end

data/lib/system_timer/thread_timer.rb

@@ -6,15 +6,16 @@ module SystemTimer
   # from a Ruby signal handler and Ruby signals are always delivered to 
   # main thread.
   class ThreadTimer
-    attr_reader :trigger_time, :thread
+    attr_reader :trigger_time, :thread, :exception_class
     
-    def initialize(trigger_time, thread)
+    def initialize(trigger_time, thread, exception_class = nil)
       @trigger_time = trigger_time
       @thread = thread
+	  @exception_class = exception_class || Timeout::Error
     end
     
     def to_s
-      "<ThreadTimer :time => #{trigger_time}, :thread => #{thread}>"
+      "<ThreadTimer :time => #{trigger_time}, :thread => #{thread}, :exception_class => #{exception_class}>"
     end
     
   end

data/test/system_timer/concurrent_timer_pool_unit_test.rb

@@ -25,7 +25,7 @@ unit_tests do
     now = Time.now
     Time.stubs(:now).returns(now)
     
-    pool.expects(:register_timer).with(now.to_i + 15, :the_current_thread)
+    pool.expects(:register_timer).with(now.to_f + 15, :the_current_thread, nil)
     pool.add_timer 15
   end
 
@@ -123,7 +123,7 @@ unit_tests do
     pool = SystemTimer::ConcurrentTimerPool.new
     now = Time.now
     Time.stubs(:now).returns(now)
-    next_timer = SystemTimer::ThreadTimer.new((now.to_i + 7), stub_everything)
+    next_timer = SystemTimer::ThreadTimer.new((now.to_f + 7), stub_everything)
     pool.expects(:next_timer).returns(next_timer)
     assert_equal 7, pool.next_trigger_interval_in_seconds
   end
@@ -132,7 +132,7 @@ unit_tests do
     pool = SystemTimer::ConcurrentTimerPool.new
     now = Time.now
     Time.stubs(:now).returns(now)
-    next_timer = SystemTimer::ThreadTimer.new now.to_i, stub_everything
+    next_timer = SystemTimer::ThreadTimer.new now.to_f, stub_everything
     pool.expects(:next_timer).returns(next_timer)
     assert_equal 0, pool.next_trigger_interval_in_seconds
   end
@@ -141,7 +141,7 @@ unit_tests do
     pool = SystemTimer::ConcurrentTimerPool.new
     now = Time.now
     Time.stubs(:now).returns(now)
-    next_timer = SystemTimer::ThreadTimer.new((now.to_i - 3), stub_everything)
+    next_timer = SystemTimer::ThreadTimer.new((now.to_f - 3), stub_everything)
     pool.expects(:next_timer).returns(next_timer)
     assert_equal 0, pool.next_trigger_interval_in_seconds
   end
@@ -217,12 +217,21 @@ unit_tests do
 
   test "trigger_next_expired_timer_at logs timeout a registered timer has expired" +
        "and SystemTimer debug mode is enabled " do
-    pool = SystemTimer::ConcurrentTimerPool.new
-    the_timer = pool.register_timer 24, stub_everything
-    SystemTimer.stubs(:debug_enabled?).returns(true)
 
-    pool.expects(:log_timeout_received).with(the_timer)
-    pool.trigger_next_expired_timer_at 24
+    original_stdout = $stdout
+    begin
+      stdout = StringIO.new
+      $stdout = stdout
+
+      pool = SystemTimer::ConcurrentTimerPool.new
+      the_timer = pool.register_timer 24, stub_everything
+      SystemTimer.stubs(:debug_enabled?).returns(true)
+  
+      pool.expects(:log_timeout_received).with(the_timer)
+      pool.trigger_next_expired_timer_at 24
+    ensure
+      $stdout = original_stdout
+    end
   end
 
   test "trigger_next_expired_timer_at does not logs timeoout when SystemTimer " +
@@ -238,13 +247,21 @@ unit_tests do
 
   test "trigger_next_expired_timer_at does not logs timeout no registered timer " +
        "has expired and SystemTimer debug mode is enabled " do
+
+    original_stdout = $stdout
+    begin
+      stdout = StringIO.new
+      $stdout = stdout
          
-    pool = SystemTimer::ConcurrentTimerPool.new
-    the_timer = pool.register_timer 24, stub_everything
-    SystemTimer.stubs(:debug_enabled?).returns(true)
+      pool = SystemTimer::ConcurrentTimerPool.new
+      the_timer = pool.register_timer 24, stub_everything
+      SystemTimer.stubs(:debug_enabled?).returns(true)
 
-    pool.expects(:log_timeout_received).never
-    pool.trigger_next_expired_timer_at 23
+      pool.expects(:log_timeout_received).never
+      pool.trigger_next_expired_timer_at 23
+    ensure
+      $stdout = original_stdout
+    end
   end
   
   test "trigger_next_expired_timer is a shorcut method calling " +
@@ -254,7 +271,7 @@ unit_tests do
     pool = SystemTimer::ConcurrentTimerPool.new
     Time.stubs(:now).returns(now)
     
-    pool.expects(:trigger_next_expired_timer_at).with(now.to_i)
+    pool.expects(:trigger_next_expired_timer_at).with(now.to_f)
     pool.trigger_next_expired_timer
   end
   

data/test/system_timer/thread_timer_test.rb

@@ -13,7 +13,7 @@ unit_tests do
   end
 
   test "to_s retruns a human friendly description of the timer" do
-    assert_match /<ThreadTimer :time => 24, :thread => #<Thread(.*)>>/, 
+    assert_match /<ThreadTimer :time => 24, :thread => #<Thread(.*)>, :exception_class => Timeout::Error>/, 
                  SystemTimer::ThreadTimer.new(24, Thread.current).to_s                 
   end
     

data/test/system_timer_functional_test.rb

@@ -50,7 +50,21 @@ functional_tests do
       SystemTimer.timeout_after(1) {sleep 5}
     end
   end
-  
+
+  test "timeout_after timeout can be a fraction of a second" do
+    assert_raises(Timeout::Error) do
+      SystemTimer.timeout_after(0.2) {sleep 3}
+    end
+  end
+
+
+  test "timeout_after raises a custom timeout when block takes too long and a custom exception class is provided" do
+    ACustomException = Class.new(Exception)
+    assert_raises(ACustomException) do
+      SystemTimer.timeout_after(1, ACustomException) {sleep 5}
+    end
+  end
+ 
   test "timeout_after does not raises Timeout Error if block completes in time" do
     SystemTimer.timeout_after(5) {sleep 1}
   end
@@ -154,18 +168,28 @@ functional_tests do
   end
   
   test "can set multiple serial timers" do
-    10.times do
-      assert_timeout_within(3) do
-        SystemTimer.timeout(3) do
+    10.times do |i|
+      print(i) & STDOUT.flush
+      assert_timeout_within(1) do
+        SystemTimer.timeout(1) do
+           sleep 60
+        end
+      end
+    end
+  end
+
+  test "can set multiple serial timers with fractional timeout" do
+    10.times do |i|
+      print(i) & STDOUT.flush
+      assert_timeout_within(0.5) do
+        SystemTimer.timeout(0.5) do
            sleep 60
         end
       end
     end
   end
   
-  test "timeout work when setting concurrent timers, the first one " +
-       "expiring before the second one" do
-         
+  test "timeout work when setting concurrent timers, the first one expiring before the second one" do
     first_thread = Thread.new do
       assert_timeout_within(3) do
         SystemTimer.timeout(3) do
@@ -184,9 +208,8 @@ functional_tests do
     second_thread.join
   end
   
-  test "timeout work when setting concurrent timers, the second one " +
-       "expiring before the first one" do
-         
+  test "timeout work when setting concurrent timers, the second one expiring before the first one" do
+
     first_thread = Thread.new do
       assert_timeout_within(10) do
         SystemTimer.timeout(10) do
@@ -205,8 +228,7 @@ functional_tests do
     second_thread.join
   end
   
-  test "timeout work when setting concurrent timers with the exact" +
-       "same timeout" do
+  test "timeout work when setting concurrent timers with the exact same timeout" do
          
     first_thread = Thread.new do
       assert_timeout_within(2) do
@@ -230,7 +252,7 @@ functional_tests do
     all_threads = []
     
     10.times do
-      a_timeout = [1, (rand(10)).to_i].max
+      a_timeout = [1, (rand(10)).to_f].max
       all_threads << Thread.new do
         assert_timeout_within(a_timeout, 10) do
           SystemTimer.timeout(a_timeout) do
@@ -257,4 +279,4 @@ functional_tests do
            "Timed out after #{elapsed} seconds, expected #{expected_timeout_in_seconds}"
   end
   
-end
+end

data/test/system_timer_unit_test.rb

@@ -9,18 +9,30 @@ unit_tests do
     SystemTimer.stubs(:install_next_timer)
     SystemTimer.stubs(:restore_original_configuration)
 
-    pool.expects(:add_timer).with(5).returns(stub_everything)
+    pool.expects(:add_timer).with(5, nil).returns(stub_everything)
     SystemTimer.timeout_after(5) {}    
   end
 
+  test "timeout_after registers a new timer with a custom timeout exception in the timer pool" do
+    MyCustomException = Class.new(Exception)
+    pool = stub_everything
+    Thread.stubs(:current).returns(:the_current_thread)
+    SystemTimer.stubs(:timer_pool).returns(pool)
+    SystemTimer.stubs(:install_next_timer)
+    SystemTimer.stubs(:restore_original_configuration)
+
+    pool.expects(:add_timer).with(5, MyCustomException).returns(stub_everything)
+    SystemTimer.timeout_after(5, MyCustomException) {}    
+  end
+
   test "timeout_after installs a system timer saving the previous " +
        "configuration when there is only one timer" do
          
     now = Time.now
     Time.stubs(:now).returns(now)
     SystemTimer.stubs(:restore_original_configuration)
-
-    SystemTimer.expects(:install_first_timer_and_save_original_configuration).with(24)
+    SystemTimer.expects(:install_first_timer_and_save_original_configuration) \
+               .with {|value| value.between?(23.99, 24.01) }
     SystemTimer.timeout_after(24) {}    
   end
 
@@ -29,11 +41,12 @@ unit_tests do
          
     now = Time.now
     Time.stubs(:now).returns(now)
-    SystemTimer.timer_pool.register_timer now.to_i + 100, :a_thread
+    SystemTimer.timer_pool.register_timer now.to_f + 100, :a_thread
     SystemTimer.stubs(:restore_original_configuration)
     SystemTimer.stubs(:install_next_timer)
 
-    SystemTimer.expects(:install_next_timer).with(24)
+    SystemTimer.expects(:install_next_timer) \
+               .with {|value| value.between?(23.99, 24.01) }
     SystemTimer.timeout_after(24) {}    
   end
 
@@ -42,11 +55,12 @@ unit_tests do
          
     now = Time.now
     Time.stubs(:now).returns(now)
-    SystemTimer.timer_pool.register_timer now.to_i + 24, :a_thread
+    SystemTimer.timer_pool.register_timer now.to_f + 24, :a_thread
     SystemTimer.stubs(:restore_original_configuration)
     SystemTimer.stubs(:install_next_timer)
 
-    SystemTimer.expects(:install_next_timer).with(24)
+    SystemTimer.expects(:install_next_timer) \
+               .with {|value| value.between?(23.99, 24.01) }
     SystemTimer.timeout_after(100) {}    
   end
   
@@ -93,4 +107,4 @@ unit_tests do
    end   
  end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: SystemTimer
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
+  version: "1.2"
 platform: ruby
 authors: 
 - Philippe Hanrigou
@@ -10,7 +10,7 @@ autorequire: system_timer
 bindir: bin
 cert_chain: []
 
-date: 2009-10-29 00:00:00 -07:00
+date: 2010-02-25 00:00:00 -08:00
 default_executable: 
 dependencies: []