qpid_proton 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 606167f90e6d8e39827fd3166b073468735f6cb9
-  data.tar.gz: 8a98a50b98eebc56846228ed843780d9c139fc06
+  metadata.gz: e42bf4b912dd9ac683d708d1f495f930524ae050
+  data.tar.gz: 88efa2086f91726b70d22ec26335c4199bd937e6
 SHA512:
-  metadata.gz: d5850008fb8352a0773900878d0bc1afba63e8b8d6caacb9602fa4ff501086ed5b7fcf07edc978fd446866bce66e432698dee49c639fafb3eaf47097b4701b9c
-  data.tar.gz: dcd40be0c4ef4cf579e906606030120cd36e6bba9d59e9850e9443454ec6ff4c5da6a9678b1e11c726fd2cc6b65b5033bcbef953a057255b9bef851df756f024
+  metadata.gz: fb46d347def13c8622f75d4a5db0f5263a3ea0659cdf140a6cbf2e7a1f3dd6a8ec4152313c0c7d61651530ca64beecc451a00926b176901ff018268fc867033a
+  data.tar.gz: 275ada30ae20a91a49cba9ae86352da2aaca5240294899165971d2cfb8540fcfefda5956dc9862fb6743eb26620c12e7a9af15c6afbd4acc589a087db990e34e

data/examples/broker.rb

@@ -70,7 +70,6 @@ class MessageQueue
   end
 end
 
-
 # Handler for broker connections. In a multi-threaded application you should
 # normally create a separate handler instance for each connection.
 class BrokerHandler < Qpid::Proton::MessagingHandler
@@ -136,9 +135,9 @@ class Broker < Qpid::Proton::Listener::Handler
     ssl = Qpid::Proton::SSLDomain.new(Qpid::Proton::SSLDomain::MODE_SERVER)
     cert_passsword = "tserverpw"
     if Gem.win_platform?       # Use P12 certs for windows schannel
-      ssl.credentials("ssl_certs/tserver-certificate.p12", "", cert_passsword)
+      ssl.credentials("ssl-certs/tserver-certificate.p12", "", cert_passsword)
     else
-      ssl.credentials("ssl_certs/tserver-certificate.pem", "ssl_certs/tserver-private-key.pem", cert_passsword)
+      ssl.credentials("ssl-certs/tserver-certificate.pem", "ssl-certs/tserver-private-key.pem", cert_passsword)
     end
     ssl.allow_unsecured_client # SSL is optional, this is not secure.
     @connection_options[:ssl_domain] = ssl if ssl
@@ -147,7 +146,7 @@ class Broker < Qpid::Proton::Listener::Handler
   end
 
   def on_open(l)
-    STDOUT.puts "Listening on #{l}\n"; STDOUT.flush
+    STDOUT.puts "Listening on #{l.port}\n"; STDOUT.flush
   end
 
   # Create a new BrokerHandler instance for each connection we accept

data/examples/direct_recv.rb

@@ -31,7 +31,7 @@ class DirectReceive < Qpid::Proton::MessagingHandler
   end
 
   class ListenOnce < Qpid::Proton::Listener::Handler
-    def on_open(l) STDOUT.puts "Listening\n"; STDOUT.flush; end
+    def on_open(l) STDOUT.puts "Listening on #{l.port}\n"; STDOUT.flush; end
     def on_accept(l) l.close; end
   end
 

data/examples/direct_send.rb

@@ -32,7 +32,7 @@ class DirectSend < Qpid::Proton::MessagingHandler
   end
 
   class ListenOnce < Qpid::Proton::Listener::Handler
-    def on_open(l) STDOUT.puts "Listening\n"; STDOUT.flush; end
+    def on_open(l) STDOUT.puts "Listening on #{l.port}\n"; STDOUT.flush; end
     def on_accept(l) l.close; end
   end
 

data/examples/example_test.rb

@@ -29,11 +29,13 @@ rescue NameError                # For older versions of MiniTest
   MiniTest::Test = MiniTest::Unit::TestCase
 end
 
-# URL with an unused port
-def test_url()
-  "amqp://:#{TCPServer.open(0) { |s| s.addr[1] }}"
+def listening_port(s)
+  /Listening on ([0-9]+)/.match(s)[1]
 end
 
+def listening_url(s)
+  ":#{listening_port s}"
+end
 
 class ExampleTest < MiniTest::Test
 
@@ -80,18 +82,16 @@ EOS
   end
 
   def test_direct_recv
-    url = test_url
-      p = run_script("direct_recv.rb", url, "examples")
-      p.readline                # Wait till ready
-      assert_output("All 10 messages confirmed!", "simple_send.rb", url, "examples")
-      want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
-      assert_equal(want.strip, p.read.strip)
+    p = run_script("direct_recv.rb", ":0", "examples")
+    url = listening_url(p.readline) # Wait till ready
+    assert_output("All 10 messages confirmed!", "simple_send.rb", url, "examples")
+    want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
+    assert_equal(want.strip, p.read.strip)
   end
 
   def test_direct_send
-    url = test_url
-    p = run_script("direct_send.rb", url, "examples")
-    p.readline                # Wait till ready
+    p = run_script("direct_send.rb", ":0", "examples")
+    url = listening_url(p.readline) # Wait till ready
     want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
     assert_output(want.strip, "simple_recv.rb", url, "examples")
     assert_equal("All 10 messages confirmed!", p.read.strip)
@@ -99,9 +99,9 @@ EOS
 end
 
 # Start the broker before all tests.
-$url = test_url
-$broker = IO.popen([RbConfig.ruby, 'broker.rb', $url])
-$broker.readline
+$broker = IO.popen([RbConfig.ruby, 'broker.rb', ":0"])
+l = $broker.readline
+$url = listening_url(l)
 
 # Kill the broker after all tests
 MiniTest.after_run do

data/ext/cproton/cproton.c

@@ -14790,6 +14790,46 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_pn_message_send(int argc, VALUE *argv, VALUE self) {
+  pn_message_t *arg1 = (pn_message_t *) 0 ;
+  pn_link_t *arg2 = (pn_link_t *) 0 ;
+  pn_rwbytes_t *arg3 = (pn_rwbytes_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  ssize_t result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_send", 1, argv[0] )); 
+  }
+  arg1 = (pn_message_t *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_link_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_link_t *","pn_message_send", 2, argv[1] )); 
+  }
+  arg2 = (pn_link_t *)(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_rwbytes_t, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_rwbytes_t *","pn_message_send", 3, argv[2] )); 
+  }
+  arg3 = (pn_rwbytes_t *)(argp3);
+  result = (ssize_t)pn_message_send(arg1,arg2,arg3);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_pn_message_data(int argc, VALUE *argv, VALUE self) {
   pn_message_t *arg1 = (pn_message_t *) 0 ;
@@ -23711,7 +23751,7 @@ SWIGEXPORT void Init_cproton(void) {
   rb_define_module_function(mCproton, "pni_connection_driver", _wrap_pni_connection_driver, -1);
   rb_define_const(mCproton, "PROTON_IMPORT_EXPORT_H", SWIG_From_int((int)(1)));
   rb_define_const(mCproton, "PN_VERSION_MAJOR", SWIG_From_int((int)(0)));
-  rb_define_const(mCproton, "PN_VERSION_MINOR", SWIG_From_int((int)(22)));
+  rb_define_const(mCproton, "PN_VERSION_MINOR", SWIG_From_int((int)(23)));
   rb_define_const(mCproton, "PN_VERSION_POINT", SWIG_From_int((int)(0)));
   rb_define_const(mCproton, "PROTON_TYPES_H", SWIG_From_int((int)(1)));
   rb_define_const(mCproton, "PN_MILLIS_MAX", SWIG_From_unsigned_SS_int((unsigned int)((~0U))));
@@ -24221,6 +24261,7 @@ SWIGEXPORT void Init_cproton(void) {
   rb_define_module_function(mCproton, "pn_message_properties", _wrap_pn_message_properties, -1);
   rb_define_module_function(mCproton, "pn_message_body", _wrap_pn_message_body, -1);
   rb_define_module_function(mCproton, "pn_message_decode", _wrap_pn_message_decode, -1);
+  rb_define_module_function(mCproton, "pn_message_send", _wrap_pn_message_send, -1);
   rb_define_module_function(mCproton, "pn_message_data", _wrap_pn_message_data, -1);
   rb_define_const(mCproton, "PROTON_SASL_H", SWIG_From_int((int)(1)));
   rb_define_const(mCproton, "PN_SASL_NONE", SWIG_From_int((int)(PN_SASL_NONE)));

data/lib/core/container.rb

@@ -35,8 +35,8 @@ module Qpid::Proton
     include TimeCompare
 
     # Error raised if the container is used after {#stop} has been called.
-    class StoppedError < RuntimeError
-      def initialize(*args) super("container has been stopped"); end
+    class StoppedError < Qpid::Proton::StoppedError
+      def initialize() super("container has been stopped"); end
     end
 
     # Create a new Container
@@ -53,7 +53,7 @@ module Qpid::Proton
     #   concurrently.
     #
     def initialize(*args)
-      @handler, @id, @panic = nil
+      @handler, @id = nil
       case args.size
       when 2 then @handler, @id = args
       when 1 then
@@ -66,19 +66,13 @@ module Qpid::Proton
       @adapter = Handler::Adapter.adapt(@handler) || Handler::MessagingAdapter.new(nil)
       @id = (@id || SecureRandom.uuid).freeze
 
-      # Implementation note:
-      #
-      # - #run threads take work items from @work, process them, and rearm them for select
-      # - work items are: ConnectionTask, ListenTask, :start, :select, :schedule
-      # - nil on the @work queue makes a #run thread exit
-
+      # Threading and implementation notes: see comment on #run_one
       @work = Queue.new
       @work << :start
       @work << :select
       @wake = SelectWaker.new   # Wakes #run thread in IO.select
       @auto_stop = true         # Stop when @active drops to 0
-      @schedule = Schedule.new
-      @schedule_working = false # True if :schedule is on the work queue
+      @work_queue = WorkQueue.new(self)  # work scheduled by other threads for :select context
 
       # Following instance variables protected by lock
       @lock = Mutex.new
@@ -87,6 +81,7 @@ module Qpid::Proton
       @running = 0              # Count of #run threads
       @stopped = false          # #stop called
       @stop_err = nil           # Optional error to pass to tasks, from #stop
+      @panic = nil              # Exception caught in a run thread, to be raised by all run threads
     end
 
     # @return [MessagingHandler] The container-wide handler
@@ -95,6 +90,9 @@ module Qpid::Proton
     # @return [String] unique identifier for this container
     attr_reader :id
 
+    def to_s() "#<#{self.class} id=#{id.inspect}>"; end
+    def inspect() to_s; end
+
     # Auto-stop flag.
     #
     # True (the default) means that the container will stop automatically, as if {#stop}
@@ -165,7 +163,7 @@ module Qpid::Proton
       not_stopped
       l = ListenTask.new(io, handler, self)
       add(l)
-      l
+      l.listener
     end
 
     # Run the container: wait for IO activity, dispatch events to handlers.
@@ -198,12 +196,13 @@ module Qpid::Proton
       while task = @work.pop
         run_one(task, Time.now)
       end
-      raise @panic if @panic
+      @lock.synchronize { raise @panic if @panic }
     ensure
       @lock.synchronize do
         if (@running -= 1) > 0
           work_wake nil         # Signal the next thread
         else
+          # This is the last thread, no need to do maybe_panic around this final handler call.
           @adapter.on_container_stop(self) if @adapter.respond_to? :on_container_stop
         end
       end
@@ -217,15 +216,13 @@ module Qpid::Proton
     # is finished.
     #
     # The container can no longer be used, using a stopped container raises
-    # {StoppedError} on attempting.  Create a new container if you want to
-    # resume activity.
+    # {StoppedError}.  Create a new container if you want to resume activity.
     #
     # @param error [Condition] Optional error condition passed to
     #  {MessagingHandler#on_transport_error} for each connection and
     #  {Listener::Handler::on_error} for each listener.
     #
-    # @param panic [Exception] Optional exception raised by all concurrent calls
-    # to run()
+    # @param panic [Exception] Optional exception to raise from all calls to run()
     #
     def stop(error=nil, panic=nil)
       @lock.synchronize do
@@ -239,25 +236,22 @@ module Qpid::Proton
         # - no more select calls after next wakeup
         # - once @active == 0, all threads will be stopped with nil
       end
-      @wake.wake
+      wake
     end
 
-    # Schedule code to be executed after a delay.
-    # @param delay [Numeric] delay in seconds, must be >= 0
-    # @yield [ ] the block is invoked with no parameters in a {#run} thread after +delay+ has elapsed
-    # @return [void]
-    # @raise [ThreadError] if +non_block+ is true and the operation would block
-    def schedule(delay, non_block=false, &block)
-      not_stopped
-      @lock.synchronize { @active += 1 } if @schedule.add(Time.now + delay, non_block, &block)
-      @wake.wake
-    end
+    # Get the {WorkQueue} that can be used to schedule code to be run by the container.
+    #
+    # Note: to run code that affects a {Connection} or it's associated objects,
+    # use {Connection#work_queue}
+    def work_queue() @work_queue; end
+
+    # (see WorkQueue#schedule)
+    def schedule(at, &block) @work_queue.schedule(at, &block) end
 
     private
 
     def wake() @wake.wake; end
 
-    # Container driver applies options and adds container context to events
     class ConnectionTask < Qpid::Proton::HandlerDriver
       include TimeCompare
 
@@ -266,23 +260,23 @@ module Qpid::Proton
         transport.set_server if server
         transport.apply opts
         connection.apply opts
-        @work_queue = WorkQueue.new container
+        @work_queue = WorkQueue.new(container)
         connection.instance_variable_set(:@work_queue, @work_queue)
       end
-      def next_tick() earliest(super, @work_queue.send(:next_tick)); end
-      def process(now) @work_queue.send(:process, now); super(); end
+      def next_tick() earliest(super, @work_queue.next_tick); end
+      def process(now) @work_queue.process(now); super(); end
 
       def dispatch              # Intercept dispatch to close work_queue
         super
-        @work_queue.send(:close) if read_closed? && write_closed? 
+        @work_queue.close if read_closed? && write_closed?
       end
     end
 
     class ListenTask < Listener
 
       def initialize(io, handler, container)
-        super
-        @closing = @closed = nil
+        @io, @handler = io, handler
+        @listener = Listener.new(io, container)
         env = ENV['PN_TRACE_EVT']
         if env && ["true", "1", "yes", "on"].include?(env.downcase)
           @log_prefix = "[0x#{object_id.to_s(16)}](PN_LISTENER_"
@@ -292,28 +286,33 @@ module Qpid::Proton
         dispatch(:on_open);
       end
 
+      attr_reader :listener
+      def closing?() @listener.instance_variable_get(:@closing); end
+      def condition() @listener.instance_variable_get(:@condition); end
+      def closed?() @io.closed?; end
+
       def process
-        return if @closed
-        unless @closing
+        return if closed?
+        unless closing?
           begin
             return @io.accept, dispatch(:on_accept)
           rescue IO::WaitReadable, Errno::EINTR
-          rescue IOError, SystemCallError => e
-            close e
+          rescue StandardError => e
+            @listener.close(e)
           end
         end
       ensure
-        if @closing
+        if closing?
           @io.close rescue nil
-          @closed = true
-          dispatch(:on_error, @condition) if @condition
+          @listener.instance_variable_set(:@closed, true)
+          dispatch(:on_error, condition) if condition
           dispatch(:on_close)
         end
       end
 
       def can_read?() !finished?; end
       def can_write?() false; end
-      def finished?() @closed; end
+      def finished?() closed?; end
 
       def dispatch(method, *args)
         # TODO aconway 2017-11-27: better logging
@@ -322,6 +321,12 @@ module Qpid::Proton
       end
 
       def next_tick() nil; end
+
+      # Close listener and force immediate close of socket
+      def close(e=nil)
+        @listener.close(e)
+        @io.close rescue nil
+      end
     end
 
     # Selectable object that can be used to wake IO.select from another thread
@@ -338,14 +343,14 @@ module Qpid::Proton
         @lock.synchronize do
           return if @set        # Don't write if already has data
           @set = true
-          begin @wr.write_nonblock('x') rescue IO::WaitWritable end
+          @wr.write_nonblock('x') rescue nil
         end
       end
 
       def reset
         @lock.synchronize do
           return unless @set
-          begin @rd.read_nonblock(1) rescue IO::WaitReadable end
+          @rd.read_nonblock(1) rescue nil
           @set = false
         end
       end
@@ -357,49 +362,58 @@ module Qpid::Proton
     end
 
     # Handle a single item from the @work queue, this is the heart of the #run loop.
+    # Take one task from @work, process it, and rearm for select
+    # Tasks are: ConnectionTask, ListenTask, :start, :select
+    # - ConnectionTask/ListenTask have #can_read, #can_write, #next_tick to set up IO.select
+    #   and #process to run handlers and process relevant work_queue
+    # - nil means exit from the  #run thread exit (handled by #run)
+    # - :select does IO.select and processes Container#work_queue
     def run_one(task, now)
       case task
 
       when :start
-        @adapter.on_container_start(self) if @adapter.respond_to? :on_container_start
+        maybe_panic { @adapter.on_container_start(self) } if @adapter.respond_to? :on_container_start
 
       when :select
         # Compute read/write select sets and minimum next_tick for select timeout
         r, w = [@wake], []
-        next_tick = @schedule.next_tick
+        next_tick = @work_queue.next_tick
         @lock.synchronize do
           @selectable.each do |s|
-            r << s if s.send :can_read?
-            w << s if s.send :can_write?
+            r << s if s.can_read?
+            w << s if s.can_write?
             next_tick = earliest(s.next_tick, next_tick)
           end
         end
 
         timeout = ((next_tick > now) ? next_tick - now : 0) if next_tick
         r, w = IO.select(r, w, nil, timeout)
-        now = Time.now unless timeout == 0
         @wake.reset if r && r.delete(@wake)
+        now = Time.now unless timeout == 0 # Update now if we may have blocked
 
         # selected is a Set to eliminate duplicates between r, w and next_tick due.
         selected = Set.new
         selected.merge(r) if r
         selected.merge(w) if w
-        @lock.synchronize do
-          if @stopped # close everything
+        stopped = @lock.synchronize do
+          if @stopped           # close everything
             @selectable.each { |s| s.close @stop_err; @work << s }
             @selectable.clear
+            @work_queue.close
             @wake.close
-            return
-          end
-          if !@schedule_working && before_eq(@schedule.next_tick, now)
-            @schedule_working = true
-            @work << :schedule
+          else
+            @selectable -= selected # Remove already-selected tasks from @selectable
+            # Also select and remove items with next_tick before now
+            @selectable.delete_if { |s| before_eq(s.next_tick, now) and selected << s }
           end
-          selected.merge(@selectable.select { |s| before_eq(s.next_tick, now) })
-          @selectable -= selected # Remove selected tasks from @selectable
+          @stopped
         end
         selected.each { |s| @work << s } # Queue up tasks needing #process
-        @work << :select        # Enable next select
+        maybe_panic { @work_queue.process(now) } # Process current work queue items
+        @work_queue.clear if stopped
+        @lock.synchronize { check_stop_lh } if @work_queue.empty?
+
+        @work << :select  unless stopped # Enable next select
 
       when ConnectionTask then
         maybe_panic { task.process now }
@@ -409,56 +423,7 @@ module Qpid::Proton
         io, opts = maybe_panic { task.process }
         add(connection_driver(io, opts, true)) if io
         rearm task
-
-      when :schedule then
-        if maybe_panic { @schedule.process now }
-          @lock.synchronize { @active -= 1; check_stop_lh }
-        else
-          @lock.synchronize { @schedule_working = false }
-        end
-      end
-    end
-
-    def do_select
-      # Compute the sets to select for read and write, and the minimum next_tick for the timeout
-      r, w = [@wake], []
-      next_tick = nil
-      @lock.synchronize do
-        @selectable.each do |s|
-          r << s if s.can_read?
-          w << s if s.can_write?
-          next_tick = earliest(s.next_tick, next_tick)
-        end
       end
-      next_tick = earliest(@schedule.next_tick, next_tick)
-
-      # Do the select and queue up all resulting work
-      now = Time.now
-      timeout = next_tick - now if next_tick
-      r, w = (timeout.nil? || timeout > 0) && IO.select(r, w, nil, timeout)
-      @wake.reset
-      selected = Set.new
-      @lock.synchronize do
-        if @stopped
-          @selectable.each { |s| s.close @stop_err; @work << s }
-          @wake.close
-          return
-        end
-        # Check if schedule has items due and is not already working
-        if !@schedule_working && before_eq(@schedule.next_tick, now)
-          @work << :schedule
-          @schedule_working = true
-        end
-        # Eliminate duplicates between r, w and next_tick due.
-        selected.merge(r) if r
-        selected.delete(@wake)
-        selected.merge(w) if w
-        @selectable -= selected
-        selected.merge(@selectable.select { |s| before_eq(s.next_tick, now) })
-        @selectable -= selected
-      end
-      selected.each { |s| @work << s } # Queue up tasks needing #process
-      @work << :select
     end
 
     # Rescue any exception raised by the block and stop the container.
@@ -510,7 +475,7 @@ module Qpid::Proton
     end
 
     def check_stop_lh
-      if @active.zero? && (@auto_stop || @stopped)
+      if @active.zero? && (@auto_stop || @stopped) && @work_queue.empty?
         @stopped = true
         work_wake nil          # Signal threads to stop
         true