qpid_proton 0.22.0 → 0.23.0

data/lib/core/disposition.rb

@@ -18,7 +18,6 @@
 
 module Qpid::Proton
 
-  # @deprecated use {Delivery}
   class Disposition
     include Util::Deprecation
 
@@ -27,12 +26,31 @@ module Qpid::Proton
     # @private
     extend Util::SWIGClassHelper
 
+    # States of a message transfer
+    module State
+      # Message was successfully processed by the receiver
+      ACCEPTED = Cproton::PN_ACCEPTED
 
-    ACCEPTED = Cproton::PN_ACCEPTED
-    REJECTED = Cproton::PN_REJECTED
-    RELEASED = Cproton::PN_RELEASED
-    MODIFIED = Cproton::PN_MODIFIED
-    RECEIVED =  Cproton::PN_RECEIVED
+      # Message rejected as invalid and unprocessable by the receiver.
+      REJECTED = Cproton::PN_REJECTED
+
+      # Message was not (and will not be) processed by the receiver, but may be
+      # acceptable if re-delivered to another receiver
+      RELEASED = Cproton::PN_RELEASED
+      # Like {RELEASED}, but there are modifications (see {Tracker#modifications})
+      # that must be applied to the message by the {Sender} before re-delivering it.
+      MODIFIED = Cproton::PN_MODIFIED
+
+      # Partial message data received. Only used during link recovery.
+      RECEIVED = Cproton::PN_RECEIVED
+
+      module ClassMethods
+        def name_of(state) Cproton::pn_disposition_type_name(state); end
+      end
+      extend ClassMethods
+      def self.included(klass) klass.extend ClassMethods; end
+    end
+    include State
 
     attr_reader :impl
 

data/lib/core/exceptions.rb

@@ -126,4 +126,8 @@ module Qpid::Proton
   # so that the application can delay completing the open/close to a later time.
   class StopAutoResponse < ProtonError
   end
+
+  # Raised when a method is called on an object that has been stopped.
+  class StoppedError < StateError
+  end
 end

data/lib/core/listener.rb

@@ -63,12 +63,14 @@ module Qpid::Proton
     # @return [Condition] The error condition if there is one
     attr_reader :condition
 
-    # Close the listener
+    # Initiate closing the the listener.
+    # It will not be fully {#closed?} until its {Handler#on_close} is called by the {Container}
     # @param error [Condition] Optional error condition.
     def close(error=nil)
+      return if closed? || @closing
       @closing = true
       @condition ||= Condition.convert error
-      @io.close_read rescue nil # Cause listener to wake out of IO.select
+      @io.close_read rescue nil # Force Container IO.select to wake with listener readable.
       nil
     end
 
@@ -78,11 +80,15 @@ module Qpid::Proton
     # Get the IP port used by the listener
     def port() to_io.addr[1]; end
 
+    # True if the listening socket is fully closed
+    def closed?() @io.closed?; end
+
     private                     # Called by {Container}
 
-    def initialize(io, handler, container)
-      @io, @handler = io, handler
+    def initialize(io, container)
+      @io = io
       @container = container
+      @closing = nil
     end
   end
 end

data/lib/core/transfer.rb

@@ -42,26 +42,7 @@ module Qpid::Proton
 
     public
 
-    # AMQP Delivery States describing the outcome of a message transfer
-    module State
-      # Message was successfully processed by the receiver
-      ACCEPTED = Cproton::PN_ACCEPTED
-
-      # Message rejected as invalid and unprocessable by the receiver.
-      REJECTED = Cproton::PN_REJECTED
-
-      # Message was not (and will not be) processed by the receiver, but may be
-      # acceptable if re-delivered to another receiver
-      RELEASED = Cproton::PN_RELEASED
-
-      # Like {RELEASED}, but there are modifications (see {Tracker#modifications})
-      # that must be applied to the message by the {Sender} before re-delivering it.
-      MODIFIED = Cproton::PN_MODIFIED
-
-      # Partial message data received. Only used during link recovery.
-      RECEIVED =  Cproton::PN_RECEIVED
-    end
-
+    State = Disposition::State
     include State
 
     # @return [String] Unique ID for the transfer in the context of the {#link}

data/lib/core/work_queue.rb

@@ -19,58 +19,79 @@ module Qpid::Proton
 
   # A thread-safe queue of work for multi-threaded programs.
   #
-  # Instances of {Connection} and objects associated with it ({Session}, {Sender},
-  # {Receiver}, {Delivery}, {Tracker}) are not thread-safe and must be
-  # used correctly when multiple threads call {Container#run}
+  # A {Container} can have multiple threads calling {Container#run}
+  # The container ensures that work associated with a single {Connection} or
+  # {Listener} is _serialized_ - two threads will never concurrently call
+  # handlers associated with the same object.
   #
-  # Calls to {MessagingHandler} methods by the {Container} are automatically
-  # serialized for each connection instance. Other threads may have code
-  # similarly serialized by adding it to the {Connection#work_queue} for the
-  # connection.  Each object related to a {Connection} also provides a
-  # +work_queue+ method.
+  # To have your own code serialized in the same, add a block to the connection's
+  # {WorkQueue}. The block will be invoked as soon as it is safe to do so.
+  #
+  # A {Connection} and the objects associated with it ({Session}, {Sender},
+  # {Receiver}, {Delivery}, {Tracker}) are not thread safe, so if you have
+  # multiple threads calling {Container#run} or if you want to affect objects
+  # managed by the container from non-container threads you need to use the
+  # {WorkQueue}
   #
   class WorkQueue
 
-    # Add code to be executed in series with other {Container} operations on the
-    # work queue's owner. The code will be executed as soon as possible.
+    # Error raised if work is added after the queue has been stopped.
+    class StoppedError < Qpid::Proton::StoppedError
+      def initialize() super("WorkQueue has been stopped"); end
+    end
+
+    # Add a block of code to be invoked in sequence.
     #
+    # @yield [ ] the block will be invoked with no parameters in the appropriate thread context
     # @note Thread Safe: may be called in any thread.
-    # @param non_block [Boolean] if true raise {ThreadError} if the operation would block.
-    # @yield [ ] the block will be invoked with no parameters in the {WorkQueue} context,
-    #  which may be a different thread.
     # @return [void]
-    # @raise [ThreadError] if +non_block+ is true and the operation would block
-    # @raise [EOFError] if the queue is closed and cannot accept more work
-    def add(non_block=false, &block)
-      @schedule.add(Time.at(0), non_block, &block)
-      @container.send :wake
+    # @raise [StoppedError] if the queue is closed and cannot accept more work
+    def add(&block)
+      schedule(0, &block)
     end
 
-    # Schedule code to be executed after +delay+ seconds in series with other
-    # {Container} operations on the work queue's owner.
-    #
-    # Work scheduled for after the {WorkQueue} has closed will be silently dropped.
+    # Schedule a block to be invoked at a certain time.
     #
+    # @param at [Time] Invoke block as soon as possible after Time +at+
+    # @param at [Numeric] Invoke block after a delay of +at+ seconds from now
+    # @yield [ ] (see #add)
     # @note (see #add)
-    # @param delay delay in seconds until the block is added to the queue.
-    # @param (see #add)
-    # @yield (see #add)
-    # @return [void]
+    # @return (see #add)
     # @raise (see #add)
-    def schedule(delay, non_block=false, &block)
-      @schedule.add(Time.now + delay, non_block, &block)
+    def schedule(at, &block)
+      raise ArgumentError, "no block" unless block_given?
+      @lock.synchronize do
+        raise @closed if @closed
+        @schedule.insert(at, block)
+      end
       @container.send :wake
     end
 
-    private
-
+    # @private
     def initialize(container)
+      @lock = Mutex.new
       @schedule = Schedule.new
       @container = container
+      @closed = nil
+    end
+
+    # @private
+    def close() @lock.synchronize { @closed = StoppedError.new } end
+
+    # @private
+    def process(now)
+      while p = @lock.synchronize { @schedule.pop(now) }
+        p.call
+      end
     end
 
-    def close() @schedule.close; end
-    def process(now) @schedule.process(now); end
-    def next_tick() @schedule.next_tick; end
+    # @private
+    def next_tick() @lock.synchronize { @schedule.next_tick } end
+
+    # @private
+    def empty?() @lock.synchronize { @schedule.empty? } end
+
+    # @private
+    def clear() @lock.synchronize { @schedule.clear } end
   end
 end

data/lib/util/schedule.rb

@@ -27,53 +27,37 @@ module Qpid::Proton
   end
 
   # @private
-  # A sorted, thread-safe list of scheduled Proc.
-  # Note: calls to #process are always serialized, but calls to #add may be concurrent.
+  # A time-sorted list of objects. Thread unsafe.
   class Schedule
     include TimeCompare
-    Item = Struct.new(:time, :proc)
+    Entry = Struct.new(:time, :item)
 
-    def initialize()
-      @lock = Mutex.new
-      @items = []
-      @closed = false
-    end
+    def initialize() @entries = []; end
+
+    def empty?() @entries.empty?; end
 
     def next_tick()
-      @lock.synchronize { @items.first.time unless @items.empty? }
+      @entries.first.time unless @entries.empty?
     end
 
-    # @return true if the Schedule was previously empty
-    # @raise EOFError if schedule is closed
-    # @raise ThreadError if +non_block+ and operation would block
-    def add(time, non_block=false, &proc)
-      # non_block ignored for now, but we may implement a bounded schedule in future.
-      @lock.synchronize do
-        raise EOFError if @closed
-        if at = (0...@items.size).bsearch { |i| @items[i].time > time }
-          @items.insert(at, Item.new(time, proc))
-        else
-          @items << Item.new(time, proc)
-        end
-        return @items.size == 1
-      end
+    # @param at [Time] Insert item at time +at+
+    # @param at [Numeric] Insert item at +Time.now \+ at+
+    # @param at [0] Insert item at Time.at(0)
+    def insert(at, item)
+      time = case at
+             when 0 then Time.at(0) # Avoid call to Time.now for immediate tasks
+             when Numeric then Time.now + at
+             else at
+             end
+      index = time && ((0...@entries.size).bsearch { |i| @entries[i].time > time })
+      @entries.insert(index || -1, Entry.new(time, item))
     end
 
-    # @return true if the Schedule became empty as a result of this call
-    def process(now)
-      due = []
-      empty = @lock.synchronize do
-        due << @items.shift while (!@items.empty? && before_eq(@items.first.time, now))
-        @items.empty?
-      end
-      due.each { |i| i.proc.call() }
-      return empty && !due.empty?
+    # Return next item due at or before time, else nil
+    def pop(time)
+      @entries.shift.item if !@entries.empty? && before_eq(@entries.first.time, time)
     end
 
-    # #add raises EOFError after #close.
-    # #process can still be called to drain the schedule.
-    def close()
-      @lock.synchronize { @closed = true }
-    end
+    def clear() @entries.clear; end
   end
 end

data/tests/test_container.rb

@@ -330,34 +330,10 @@ class ContainerTest < MiniTest::Test
     assert_raises(Container::StoppedError) { cont.listen "" }
   end
 
-  # Make sure Container::Scheduler puts tasks in proper order.
-  def test_scheduler
-    a = []
-    s = Schedule.new
-
-    assert_equal true,  s.add(Time.at 3) { a << 3 }
-    assert_equal false, s.process(Time.at 2)      # Should not run
-    assert_equal [], a
-    assert_equal true, s.process(Time.at 3)      # Should run
-    assert_equal [3], a
-
-    a = []
-    assert_equal true, s.add(Time.at 3) { a << 3 }
-    assert_equal false, s.add(Time.at 5) { a << 5 }
-    assert_equal false, s.add(Time.at 1) { a << 1 }
-    assert_equal false, s.add(Time.at 4) { a << 4 }
-    assert_equal false, s.add(Time.at 4) { a << 4.1 }
-    assert_equal false, s.add(Time.at 4) { a << 4.2 }
-    assert_equal false, s.process(Time.at 4)
-    assert_equal [1, 3, 4, 4.1, 4.2], a
-    a = []
-    assert_equal true, s.process(Time.at 5)
-    assert_equal [5], a
-  end
-
-  def test_container_schedule
+  # Test container doesn't stops only when schedule work is done
+  def test_container_work_queue
     c = Container.new __method__
-    delays = [0.1, 0.03, 0.02, 0.04]
+    delays = [0.1, 0.03, 0.02]
     a = []
     delays.each { |d| c.schedule(d) { a << [d, Time.now] } }
     start = Time.now
@@ -369,7 +345,91 @@ class ContainerTest < MiniTest::Test
     end
   end
 
-  def test_work_queue
+  # Test container work queue finishes due tasks on external stop, drops future tasks
+  def test_container_work_queue_stop
+    q = Queue.new
+    c = Container.new __method__
+    thread = Thread.new { c.run }
+    time = Time.now + 0.01
+    # Mix good scheduled tasks at time and bad tasks scheduled after 10 secs
+    10.times do
+      c.schedule(time) { q << true }
+      c.schedule(10) { q << false }
+    end
+    assert_same true, q.pop # First task processed, all others at same time are due
+    # Mix in some immediate tasks
+    5.times do
+      c.work_queue.add { q << true } # Immediate
+      c.schedule(time) { q << true }
+      c.schedule(10) { q << false }
+    end
+    c.stop
+    thread.join
+    19.times { assert_same true, q.pop }
+    assert_equal 0, q.size      # Tasks with 10 sec delay should be dropped
+  end
+
+  # Chain schedule calls from other schedule calls
+  def test_container_schedule_chain
+    c = Container.new(__method__)
+    delays = [0.05, 0.02, 0.04]
+    i = delays.each
+    a = []
+    p = Proc.new { c.schedule(i.next) { a << Time.now; p.call } rescue nil }
+    p.call                 # Schedule the first, which schedules the second etc.
+    start = Time.now
+    c.run
+    assert_equal 3, a.size
+    delays.inject(0) do |d,sum|
+      x = a.shift
+      assert_in_delta  start + d + sum, x, 0.01
+      sum + d
+    end
+  end
+
+  # Schedule calls from handlers
+  def test_container_schedule_handler
+    h = Class.new() do
+      def initialize() @got = []; end
+      attr_reader :got
+      def record(m) @got << m; end
+      def on_container_start(c) c.schedule(0) {record __method__}; end
+      def on_connection_open(c) c.close; c.container.schedule(0) {record __method__}; end
+      def on_connection_close(c) c.container.schedule(0) {record __method__}; end
+    end.new
+    t = ServerContainerThread.new(__method__, nil, 1, h)
+    t.connect(t.url)
+    t.join
+    assert_equal [:on_container_start, :on_connection_open, :on_connection_open, :on_connection_close, :on_connection_close], h.got
+  end
+
+  # Raising from container handler should stop container
+  def test_container_handler_raise
+    h = Class.new() do
+      def on_container_start(c) raise "BROKEN"; end
+    end.new
+    c = Container.new(h, __method__)
+    assert_equal("BROKEN", (assert_raises(RuntimeError) { c.run }).to_s)
+  end
+
+  # Raising from connection handler should stop container
+  def test_connection_handler_raise
+    h = Class.new() do
+      def on_connection_open(c) raise "BROKEN"; end
+    end.new
+    c = ServerContainer.new(__method__, nil, 1, h)
+    c.connect(c.url)
+    assert_equal("BROKEN", (assert_raises(RuntimeError) { c.run }).to_s)
+  end
+
+  # Raising from container schedule should stop container
+  def test_container_schedule_raise
+    c = Container.new(__method__)
+    c.schedule(0) { raise "BROKEN" }
+    assert_equal("BROKEN", (assert_raises(RuntimeError) { c.run }).to_s)
+  end
+
+  def test_connection_work_queue
     cont = ServerContainer.new(__method__, {}, 1)
     c = cont.connect(cont.url)
     t = Thread.new { cont.run }
@@ -391,6 +451,14 @@ class ContainerTest < MiniTest::Test
 
     c.work_queue.add { c.close }
     t.join
-    assert_raises(EOFError) { c.work_queue.add {  } }
+    assert_raises(WorkQueue::StoppedError) { c.work_queue.add {  } }
+  end
+
+  # Raising from connection schedule should stop container
+  def test_connection_work_queue_raise
+    c = ServerContainer.new(__method__)
+    c.connect(c.url)
+    c.work_queue.add { raise "BROKEN" }
+    assert_equal("BROKEN", (assert_raises(RuntimeError) { c.run }).to_s)
   end
 end