frugal_timeout 0.0.8 → 0.0.9

data/lib/frugal_timeout.rb

@@ -2,7 +2,6 @@
 
 require 'hitimes'
 require 'monitor'
-require 'null_object'
 require 'thread'
 require 'timeout'
 
@@ -55,11 +54,11 @@ module FrugalTimeout
     include Comparable
     @@mutex = Mutex.new
 
-    attr_reader :at, :exception, :klass, :thread
+    attr_reader :at, :klass, :thread
 
     def initialize thread, at, klass
       @thread, @at, @klass = thread, at, klass
-      @defused, @exception = false, Class.new(Timeout::ExitException)
+      @defused = false
     end
 
     def <=>(other)
@@ -75,12 +74,9 @@ module FrugalTimeout
       @@mutex.synchronize { @defused }
     end
 
-    def enforceTimeout filter=NullObject.new {}
+    def enforceTimeout
       @@mutex.synchronize {
-	return if @defused || filter.has_key?(@thread)
-
-	filter[@thread] = true
-	@thread.raise @exception, 'execution expired'
+	@thread.raise @klass, 'execution expired' unless @defused
       }
     end
   end
@@ -95,6 +91,11 @@ module FrugalTimeout
       @onNewNearestRequest, @requests = proc {}, SortedQueue.new
     end
 
+    def defuse_thread! thread
+      @requests.each { |r| r.defuse! if r.thread == thread }
+    end
+    private :defuse_thread!
+
     def onNewNearestRequest &b
       @onNewNearestRequest = b
     end
@@ -102,13 +103,19 @@ module FrugalTimeout
     # Purge and enforce expired timeouts. Only enforce once for each thread,
     # even if multiple timeouts for that thread expire at once.
     def purgeExpired
-      filter, now = {}, MonotonicTime.now
-      @requests.reject_and_get! { |r| r.at <= now }.each { |r|
-	r.enforceTimeout filter
-      }
-
+      expiredRequests, filter, now = nil, {}, MonotonicTime.now
       @requests.synchronize {
-	@onNewNearestRequest.call(@requests.first) unless @requests.empty?
+	@requests.reject_and_get! { |r| r.at <= now }.each { |r|
+	  next if filter[r.thread]
+
+	  r.enforceTimeout
+	  defuse_thread! r.thread
+	  filter[r.thread] = true
+	}
+
+	# It's necessary to call onNewNearestRequest inside synchronize as other
+	# threads may #queue requests.
+	@onNewNearestRequest.call @requests.first unless @requests.empty?
       }
     end
 
@@ -123,56 +130,73 @@ module FrugalTimeout
   end
 
   # {{{1 SleeperNotifier
+  # Executes callback when a request expires.
+  # 1. Set callback to execute with #onExpiry=.
+  # 2. Set expiry time with #expireAt.
+  # 3. After the expiry time comes, execute the callback.
+  #
+  # 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:
     include MonitorMixin
 
+    DO_NOTHING = proc {}
+
     def initialize
       super()
-      @condVar, @onExpiry, @request = new_cond, proc {}, nil
+      @condVar, @expireAt, @onExpiry = new_cond, nil, DO_NOTHING
 
       @thread = Thread.new {
 	loop {
-	  @onExpiry.call if synchronize {
-	    sleepFor = latestDelay
-	    sleptFor = MonotonicTime.measure { @condVar.wait sleepFor }
-
-	    if sleepFor && sleptFor >= sleepFor
-	      @request = nil
-	      true
+	  synchronize { @onExpiry }.call if synchronize {
+	    # Sleep forever until a request comes in.
+	    unless @expireAt
+	      wait
+	      next
 	    end
+
+	    timeLeft = calcTimeLeft
+	    disposeOfRequest
+	    elapsedTime = MonotonicTime.measure { wait timeLeft }
+
+	    elapsedTime >= timeLeft
 	  }
 	}
       }
       ObjectSpace.define_finalizer self, proc { @thread.kill }
     end
 
-    def latestDelay
+    def onExpiry &b
+      synchronize { @onExpiry = b || DO_NOTHING }
+    end
+
+    def expireAt time
       synchronize {
-	return unless @request
+	@expireAt = time
+	signalThread
+      }
+    end
+
+    private
 
-	delay = @request.at - MonotonicTime.now
+    def calcTimeLeft
+      synchronize {
+	delay = @expireAt - MonotonicTime.now
 	delay < 0 ? 0 : delay
       }
     end
-    private :latestDelay
 
-    def notify
-      @condVar.signal
+    def disposeOfRequest
+      @expireAt = nil
     end
-    private :notify
 
-    def onExpiry &b
-      @onExpiry = b
+    def signalThread
+      @condVar.signal
     end
 
-    # 1. Send any request.
-    # 2. Send only nearer (than the first request) expiration times.
-    # 3. The latest passed request expires and @onExpiry is called. Goto 1.
-    def sleepUntilExpires request
-      synchronize {
-	@request = request
-	notify
-      }
+    def wait sec=nil
+      @condVar.wait sec
     end
   end
 
@@ -185,6 +209,10 @@ module FrugalTimeout
       @array, @unsorted = storage, false
     end
 
+    def each &b
+      synchronize { @array.each &b }
+    end
+
     def empty?
       synchronize { @array.empty? }
     end
@@ -249,7 +277,7 @@ module FrugalTimeout
   @requestQueue = RequestQueue.new
   sleeper = SleeperNotifier.new
   @requestQueue.onNewNearestRequest { |request|
-    sleeper.sleepUntilExpires request
+    sleeper.expireAt request.at
   }
   sleeper.onExpiry { @requestQueue.purgeExpired }
 
@@ -263,18 +291,22 @@ module FrugalTimeout
        end'
   end
 
+  def self.on_ensure &b # :nodoc:
+    @onEnsure = b
+  end
+
   # Same as Timeout.timeout()
   def self.timeout sec, klass=Error
     return yield sec if sec.nil? || sec <= 0
 
-    request = @requestQueue.queue(sec, klass)
+    innerException = Class.new Timeout::ExitException
+    request = @requestQueue.queue(sec, innerException)
     begin
       yield sec
-    rescue request.exception => e
-      raise unless e.is_a? Timeout::ExitException
-
-      raise request.klass, e.message, e.backtrace
+    rescue innerException => e
+      raise klass, e.message, e.backtrace
     ensure
+      @onEnsure.call if @onEnsure
       request.defuse!
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frugal_timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-20 00:00:00.000000000 Z
+date: 2014-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -43,22 +43,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: null_object
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.0'
 description: Timeout.timeout replacement that uses only 1 thread
 email: ledestin@gmail.com
 executables: []