qpid_proton 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6495371bf4622d74d87cfd02d4e58323652572eb
-  data.tar.gz: 79af23eb910b3f38a1252530b318c45cafe6af54
+  metadata.gz: 606167f90e6d8e39827fd3166b073468735f6cb9
+  data.tar.gz: 8a98a50b98eebc56846228ed843780d9c139fc06
 SHA512:
-  metadata.gz: 52e822deb2d458caa735b88d0d6dc5d5e6377d16e836d744d80cdf847c1fcff89b1f22e2e178aa653411e2ffecefb7e314dfa3315f10034c77795cecf4146414
-  data.tar.gz: 4cea7fcfbdfadaf4c7fc1319303186c0282292134397c4d536eb46b9e8abccb719164b1b964b09a712aba95fab2193c00a502d1c39fbdace8b6ff636a594fc40
+  metadata.gz: d5850008fb8352a0773900878d0bc1afba63e8b8d6caacb9602fa4ff501086ed5b7fcf07edc978fd446866bce66e432698dee49c639fafb3eaf47097b4701b9c
+  data.tar.gz: dcd40be0c4ef4cf579e906606030120cd36e6bba9d59e9850e9443454ec6ff4c5da6a9678b1e11c726fd2cc6b65b5033bcbef953a057255b9bef851df756f024

data/examples/README.md

@@ -58,19 +58,35 @@ In this set of examples we see the following event occurring, in addition to wha
 
 ## Now About That Broker example
 
-The **broker.rb** example application is a nice demonstration of doing something more interesting in Ruby with Proton.
+The **broker.rb** example application is a nice demonstration of doing something more interesting in Ruby with Proton, and shows how to use multiple threads.
 
-The way the broker works is to listen to incoming connections, examine the components of the address for that connection, attach that connection to an exchange managing that address and then it sends any messages destined for that address to them.
+The broker listens for incoming connections and sender/receiver links. It uses the source and target address of senders and receivers to identify a queue. Messages from receivers go on the queue, and are sent via senders.
 
 The components of the broker example include:
- * **Broker** - A class that extends the MessagingHandler class. It accepts incoming connections, manages subscribing them to exchanges, and transfers messages between them.
- * **MessageQueue** - Distributes messages to subscriptions.
-
-The Broker manages a map connecting a queue address to the instance of Exchange that holds references to the endpoints of interest.
+ * **Broker** is a Listener::Handler that accepts connections, and manages the set of named queues.
+ * **BrokerHandler** extends MessagingHandler to accept incoming connections, senders and receivers and transfers messages between them and the Broker's queues.
+ * **MessageQueue** - A queue of messages that keeps track of waiting senders.
 
 The broker application demonstrates a new set of events:
 
- * **on_link_open** - Fired when a remote link is opened. From this event the broker grabs the address and subscribes the link to an exchange for that address.
- * **on_link_close** - Fired when a remote link is closed. From this event the broker grabs the address and unsubscribes the link from that exchange.
- * **on_connection_close** - Fired when a remote connection is closed but the local end is still open.
- * **on_transport_close** - Fired when the protocol transport has closed. The broker removes all links for the disconnected connection, avoiding workign with endpoints that are now gone.
+ * **on_sender_open** - Fired when a sender link is opened, the broker gets the address and starts sending messages from the corresponding queue.
+ * **on_sender_close** - Fired when a sender link is closed, remove the sender from the queue so no more messages are sent.
+ * **on_connection_close** - Fired when the remote connection is closes, close all senders.
+ * **on_transport_close** - Fired when the transport (socket) has closed, close all senders.
+
+It also demonstrates aspects of multi-threaded proton:
+
+ * **Thread safe MessageQueue** Uses a Mutex to make actions atomic when called concurrently.
+
+ * **Using WorkQueue** Proton objects like Sender are not thread safe.  They are
+   normally only used in MessagingHandler#on_ callbacks.  To request work from a
+   different thread you can add a code block to a WorkQueue, as shown in
+   MessageQueue#push.
+
+ * **Listener::Handler** The broker creates a new BrokerHandler instance for
+   each accepted connection. The container ensures that calls on each handler instance
+   are serialized even if there are multiple threads in the container.
+
+ * **Calling Container#run in multiple threads** The Container uses threads that call
+   #run as a thread pool to dispatch calls to MessagingHandler instances. Even
+   if there are multiple threads, calls to handler instance are serialized.

data/examples/broker.rb

@@ -21,139 +21,142 @@ require 'qpid_proton'
 require 'optparse'
 require 'pathname'
 
+# Thread safe message queue that notifies waiting senders when messages arrive.
 class MessageQueue
 
-  def initialize(dynamic = false)
-    @dynamic = dynamic
-    @queue = Queue.new
-    @consumers = []
-  end
-
-  def subscribe(consumer)
-    @consumers << (consumer)
-  end
-
-  def unsubscribe(consumer)
-    if @consumers.include?(consumer)
-      @consumers.delete(consumer)
+  def initialize
+    @lock = Mutex.new           # Make ations on the queue atomic
+    @messages = []              # Messages on the queue
+    @waiting = []               # Senders that are waiting for messages
+  end
+
+  # Push a message onto the queue and notify any waiting senders
+  def push(message)
+    @lock.synchronize do
+      @messages << message
+      unless @waiting.empty?    # Notify waiting senders
+        # NOTE: the call to self.send_to is added to the sender's work_queue,
+        # and will be executed in the sender's thread
+        @waiting.each { |s| s.work_queue.add { self.send_to(s); } }
+        @waiting.clear
+      end
     end
-    @consumers.empty? && (@dynamic || @queue.empty?)
-  end
-
-  def publish(message)
-    @queue << message
-    self.dispatch
   end
 
-  def dispatch(consumer = nil)
-    if consumer
-      c = [consumer]
-    else
-      c = @consumers
-    end
-
-    while self.deliver_to(c) do
+  # Pop a message off the queue.
+  # If no messages available, record sender as waiting and return nil.
+  def pop(sender)
+    @lock.synchronize do
+      if @messages.empty?
+        @waiting << sender
+        nil
+      else
+        @messages.shift
+      end
     end
   end
 
-  def deliver_to(consumers)
-    result = false
-    consumers.each do |consumer|
-      if consumer.credit > 0 && !@queue.empty?
-        consumer.send(@queue.pop(true))
-        result = true
-      end
+  # NOTE: Called in sender's thread.
+  # Pull messages from the queue as long as sender has credit.
+  # If queue runs out of messages, record sender as waiting.
+  def send_to(sender)
+    while sender.credit > 0 && (message = pop(sender))
+      sender.send(message)
     end
-    return result
   end
 
+  def forget(sender)
+    @lock.synchronize { @waiting.delete(sender) }
+  end
 end
 
-class Broker < Qpid::Proton::MessagingHandler
-
-  def initialize(url)
-    super()
-    @url = url
-    @queues = {}
-    begin          # Optional SSL setup, ignore if we don't find cert files etc.
-      @ssl_domain = Qpid::Proton::SSLDomain.new(Qpid::Proton::SSLDomain::MODE_SERVER)
-      cert_passsword = "tserverpw"
-      if Gem.win_platform?       # Use P12 certs for windows schannel
-        @ssl_domain.credentials("ssl_certs/tserver-certificate.p12", "", cert_passsword)
-      else
-        @ssl_domain.credentials("ssl_certs/tserver-certificate.pem", "ssl_certs/tserver-private-key.pem", cert_passsword)
-      end
-      @ssl_domain.allow_unsecured_client # SSL is optional, this is not secure.
-    rescue
-      @ssl_domain = nil # Don't worry if we can't set up SSL.
-    end
-  end
 
-  def on_container_start(container)
-    # Options for incoming connections, provide SSL configuration if we have it.
-    opts = {:ssl_domain => @ssl_domain} if @ssl_domain
-    @listener = container.listen(@url, Qpid::Proton::Listener::Handler.new(opts))
-    STDOUT.puts "Listening on #{@url.inspect}"; STDOUT.flush
-  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
 
-  def queue(address)
-    unless @queues.has_key?(address)
-      @queues[address] = MessageQueue.new
-    end
-    @queues[address]
+  def initialize(broker)
+    @broker = broker
   end
 
   def on_sender_open(sender)
     if sender.remote_source.dynamic?
-      address = SecureRandom.uuid
-      sender.source.address = address
-      q = MessageQueue.new(true)
-      @queues[address] = q
-      q.subscribe(sender)
+      sender.source.address = SecureRandom.uuid
     elsif sender.remote_source.address
       sender.source.address = sender.remote_source.address
-      self.queue(sender.source.address).subscribe(sender)
+    else
+      sender.connection.close("no source address")
+      return
     end
+    q = @broker.queue(sender.source.address)
+    q.send_to(sender)
   end
 
   def on_receiver_open(receiver)
     if receiver.remote_target.address
       receiver.target.address = receiver.remote_target.address
-    end
-  end
-
-  def unsubscribe(link)
-    if @queues.has_key?(link.source.address)
-      if @queues[link.source.address].unsubscribe(link)
-        @queues.delete(link.source.address)
-      end
+    else
+      receiver.connection.close("no target address")
     end
   end
 
   def on_sender_close(sender)
-    self.unsubscribe(sender)
+    q = @broker.queue(sender.source.address)
+    q.forget(sender) if q
   end
 
   def on_connection_close(connection)
-    self.remove_stale_consumers(connection)
+    connection.each_sender { |s| on_sender_close(s) }
   end
 
   def on_transport_close(transport)
-    self.remove_stale_consumers(transport.connection)
-  end
-
-  def remove_stale_consumers(connection)
-    connection.each_sender { |s| unsubscribe(s) }
+    transport.connection.each_sender { |s| on_sender_close(s) }
   end
 
   def on_sendable(sender)
-    q = self.queue(sender.source.address)
-    q.dispatch(sender)
+    @broker.queue(sender.source.address).send_to(sender)
   end
 
   def on_message(delivery, message)
-    q = self.queue(delivery.link.target.address)
-    q.publish(message)
+    @broker.queue(delivery.receiver.target.address).push(message)
+  end
+end
+
+# Broker manages the queues and accepts incoming connections.
+class Broker < Qpid::Proton::Listener::Handler
+
+  def initialize
+    @queues = {}
+    @connection_options = {}
+    ssl_setup
+  end
+
+  def ssl_setup
+    # Optional SSL setup
+    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)
+    else
+      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
+  rescue
+    # Don't worry if we can't set up SSL.
+  end
+
+  def on_open(l)
+    STDOUT.puts "Listening on #{l}\n"; STDOUT.flush
+  end
+
+  # Create a new BrokerHandler instance for each connection we accept
+  def on_accept(l)
+    { :handler => BrokerHandler.new(self) }.update(@connection_options)
+  end
+
+  def queue(address)
+    @queues[address] ||= MessageQueue.new
   end
 
 end
@@ -164,4 +167,9 @@ Start an example broker listening on URL"
   return 1
 end
 url, = ARGV
-Qpid::Proton::Container.new(Broker.new(url)).run
+container = Qpid::Proton::Container.new
+container.listen(url, Broker.new)
+
+# Run the container in multiple threads.
+threads = 4.times.map { Thread.new {  container.run }}
+threads.each { |t| t.join }

data/examples/example_test.rb

@@ -46,7 +46,7 @@ class ExampleTest < MiniTest::Test
   end
 
   def test_helloworld
-    assert_output("Hello world!", "helloworld.rb", $url, __method__)
+    assert_output("Hello world!", "helloworld.rb", $url, "examples")
   end
 
   def test_client_server
@@ -60,40 +60,40 @@ class ExampleTest < MiniTest::Test
 -> And the mome raths outgrabe.
 <- AND THE MOME RATHS OUTGRABE.
 EOS
-    server = run_script("server.rb", $url, __method__)
-    assert_output(want.strip, "client.rb", $url, __method__)
+    server = run_script("server.rb", $url, "examples")
+    assert_output(want.strip, "client.rb", $url, "examples")
   ensure
     Process.kill :TERM, server.pid if server
   end
 
   def test_send_recv
-    assert_output("All 10 messages confirmed!", "simple_send.rb", $url, __method__)
+    assert_output("All 10 messages confirmed!", "simple_send.rb", $url, "examples")
     want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
-    assert_output(want.strip, "simple_recv.rb", $url, __method__)
+    assert_output(want.strip, "simple_recv.rb", $url, "examples")
   end
 
   def test_ssl_send_recv
-    out = run_script("ssl_send.rb", $url, __method__).read.strip
+    out = run_script("ssl_send.rb", $url, "examples").read.strip
     assert_match(/Connection secured with "...*\"\nAll 10 messages confirmed!/, out)
     want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
-    assert_output(want.strip, "simple_recv.rb", $url, __method__)
+    assert_output(want.strip, "simple_recv.rb", $url, "examples")
   end
 
   def test_direct_recv
     url = test_url
-      p = run_script("direct_recv.rb", url, __method__)
+      p = run_script("direct_recv.rb", url, "examples")
       p.readline                # Wait till ready
-      assert_output("All 10 messages confirmed!", "simple_send.rb", url, __method__)
+      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, __method__)
+    p = run_script("direct_send.rb", url, "examples")
     p.readline                # Wait till ready
     want = (0..9).reduce("") { |x,y| x << "Received: sequence #{y}\n" }
-    assert_output(want.strip, "simple_recv.rb", url, __method__)
+    assert_output(want.strip, "simple_recv.rb", url, "examples")
     assert_equal("All 10 messages confirmed!", p.read.strip)
   end
 end

data/ext/cproton/cproton.c

@@ -19329,7 +19329,7 @@ _wrap_pn_data_put_decimal32(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (pn_data_t *)(argp1);
   {
-    arg2 = FIX2UINT(argv[1]);
+    arg2 = NUM2UINT(argv[1]);
   }
   result = (int)pn_data_put_decimal32(arg1,arg2);
   vresult = SWIG_From_int((int)(result));
@@ -20044,7 +20044,7 @@ _wrap_pn_data_get_decimal32(int argc, VALUE *argv, VALUE self) {
   arg1 = (pn_data_t *)(argp1);
   result = (pn_decimal32_t)pn_data_get_decimal32(arg1);
   {
-    vresult = ULL2NUM(result);
+    vresult = UINT2NUM(result);
   }
   return vresult;
 fail:
@@ -23711,7 +23711,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)(21)));
+  rb_define_const(mCproton, "PN_VERSION_MINOR", SWIG_From_int((int)(22)));
   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))));

data/lib/core/connection.rb

@@ -124,9 +124,8 @@ module Qpid::Proton
 
     # @private
     def apply opts
-      # NOTE: Only connection options are set here. Transport options are set
-      # with {Transport#apply} from the connection_driver (or in
-      # on_connection_bound if not using a connection_driver)
+      # NOTE: Only connection options are set here.
+      # Transport options must be applied with {Transport#apply}
       @container = opts[:container]
       cid = opts[:container_id] || (@container && @container.id) || SecureRandom.uuid
       cid = cid.to_s if cid.is_a? Symbol # Allow symbols as container name
@@ -135,12 +134,9 @@ module Qpid::Proton
       Cproton.pn_connection_set_password(@impl, opts[:password]) if opts[:password]
       Cproton.pn_connection_set_hostname(@impl, opts[:virtual_host]) if opts[:virtual_host]
       @link_prefix = opts[:link_prefix] || cid
-      Codec::Data.from_object(Cproton.pn_connection_offered_capabilities(@impl),
-                              Types.symbol_array(opts[:offered_capabilities]))
-      Codec::Data.from_object(Cproton.pn_connection_desired_capabilities(@impl),
-                              Types.symbol_array(opts[:desired_capabilities]))
-      Codec::Data.from_object(Cproton.pn_connection_properties(@impl),
-                              Types.symbol_keys(opts[:properties]))
+      Codec::Data.from_object(Cproton.pn_connection_offered_capabilities(@impl), opts[:offered_capabilities])
+      Codec::Data.from_object(Cproton.pn_connection_desired_capabilities(@impl), opts[:desired_capabilities])
+      Codec::Data.from_object(Cproton.pn_connection_properties(@impl), opts[:properties])
     end
 
     # Idle-timeout advertised by the remote peer, in seconds.
@@ -253,17 +249,24 @@ module Qpid::Proton
       return enum_for(:each_link) unless block_given?
       l = Cproton.pn_link_head(@impl, 0);
       while l
-        yield Link.wrap(l)
+        l2 = l                  #  get next before yield, in case yield closes l and unlinks it
         l = Cproton.pn_link_next(l, 0)
+        yield Link.wrap(l2)
       end
       self
     end
 
     # Get the {Sender} links - see {#each_link}
-    def each_sender() each_link.select { |l| l.sender? }; end
+    def each_sender()
+      return enum_for(:each_sender) unless block_given?
+      each_link.select { |l| yield l if l.sender? }
+    end
 
     # Get the {Receiver} links - see {#each_link}
-    def each_receiver() each_link.select { |l| l.receiver? }; end
+      def each_receiver()
+        return enum_for(:each_receiver) unless block_given?
+        each_link.select { |l| yield l if l.receiver? }
+      end
 
     # @deprecated use {#MessagingHandler} to handle work
     def work_head
@@ -282,6 +285,9 @@ module Qpid::Proton
       @link_prefix + "/" +  (@link_count += 1).to_s(32)
     end
 
+    # @return [WorkQueue] work queue to execute code serialized correctly for this connection
+    attr_reader :work_queue
+
     protected
 
     def _local_condition

data/lib/core/connection_driver.rb

@@ -118,9 +118,17 @@ module Qpid::Proton
     def tick(now=Time.now)
       transport = Cproton.pni_connection_driver_transport(@impl)
       ms = Cproton.pn_transport_tick(transport, (now.to_r * 1000).to_i)
-      return ms.zero? ? nil : Time.at(ms.to_r / 1000);
+      @next_tick = ms.zero? ? nil : Time.at(ms.to_r / 1000);
+      unless @next_tick
+        idle = Cproton.pn_transport_get_idle_timeout(transport);
+        @next_tick = now + (idle.to_r / 1000) unless idle.zero?
+      end
+      @next_tick
     end
 
+    # Time returned by the last call to {#tick}
+    attr_accessor :next_tick
+
     # Disconnect the write side of the transport, *without* sending an AMQP
     # close frame. To close politely, you should use {Connection#close}, the
     # transport will close itself once the protocol close is complete.
@@ -181,6 +189,7 @@ module Qpid::Proton
         case e.method           # Events that affect the driver
         when :on_transport_tail_closed then close_read
         when :on_transport_head_closed then close_write
+        when :on_transport_closed then @io.close rescue nil # Allow double-close
         end
         e.dispatch @adapter
       end
@@ -192,10 +201,11 @@ module Qpid::Proton
     #   or nil if there are no scheduled events
     def process(now=Time.now)
       read
+      dispatch
       next_tick = tick(now)
-      dispatch                # Generate data for write
+      dispatch
       write
-      dispatch                # Consume events generated by write
+      dispatch
       return next_tick
     end
   end