qpid_proton 0.18.1 → 0.19.0

data/lib/handler/reactor_messaging_adapter.rb

@@ -0,0 +1,158 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+# @private
+module Qpid::Proton
+  module Handler
+
+    # Adapter to convert raw proton events for the old {Handler::MessagingHandler}
+    # used by the Reactor.
+    class ReactorMessagingAdapter  < Adapter
+      def initialize handler
+        super
+        @opts = (handler.options if handler.respond_to?(:options)) || {}
+        @opts[:prefetch] ||= 10
+        @opts[:peer_close_is_error] = false unless @opts.include? :peer_close_is_error
+        [:auto_accept, :auto_settle, :auto_open, :auto_close].each do |k|
+          @opts[k] = true unless @opts.include? k
+        end
+      end
+
+      alias dispatch forward
+
+      def delegate(method, event)
+        event.method = method     # Update the event with the new method
+        event.dispatch(@handler) or dispatch(:on_unhandled, event)
+      end
+
+      def delegate_error(method, event)
+        event.method = method
+        unless event.dispatch(@handler) || dispatch(:on_error, event)
+          dispatch(:on_unhandled, event)
+          event.connection.close(event.context.condition) if @opts[:auto_close]
+        end
+      end
+
+      def on_container_start(container) delegate(:on_start, Event.new(nil, nil, container)); end
+      def on_container_stop(container) delegate(:on_stop, Event.new(nil, nil, container)); end
+
+      # Define repetative on_xxx_open/close methods for each endpoint type
+      def self.open_close(endpoint)
+        on_opening = :"on_#{endpoint}_opening"
+        on_opened = :"on_#{endpoint}_opened"
+        on_closing = :"on_#{endpoint}_closing"
+        on_closed = :"on_#{endpoint}_closed"
+        on_error = :"on_#{endpoint}_error"
+
+        Module.new do
+          define_method(:"on_#{endpoint}_local_open") do |event|
+            delegate(on_opened, event) if event.context.remote_open?
+          end
+
+          define_method(:"on_#{endpoint}_remote_open") do |event|
+            if event.context.local_open?
+              delegate(on_opened, event)
+            elsif event.context.local_uninit?
+              delegate(on_opening, event)
+              event.context.open if @opts[:auto_open]
+            end
+          end
+
+          define_method(:"on_#{endpoint}_local_close") do |event|
+            delegate(on_closed, event) if event.context.remote_closed?
+          end
+
+          define_method(:"on_#{endpoint}_remote_close") do |event|
+            if event.context.remote_condition
+              delegate_error(on_error, event)
+            elsif event.context.local_closed?
+              delegate(on_closed, event)
+            elsif @opts[:peer_close_is_error]
+              Condition.assign(event.context.__send__(:_remote_condition), "unexpected peer close")
+              delegate_error(on_error, event)
+            else
+              delegate(on_closing, event)
+            end
+            event.context.close if @opts[:auto_close]
+          end
+        end
+      end
+      # Generate and include open_close modules for each endpoint type
+      [:connection, :session, :link].each { |endpoint| include open_close(endpoint) }
+
+      def on_transport_error(event) delegate_error(:on_transport_error, event); end
+      def on_transport_closed(event) delegate(:on_transport_closed, event); end
+
+      # Add flow control for link opening events
+      def on_link_local_open(event) super; add_credit(event); end
+      def on_link_remote_open(event) super; add_credit(event); end
+
+
+      def on_delivery(event)
+        if event.link.receiver?       # Incoming message
+          d = event.delivery
+          if d.aborted?
+            delegate(:on_aborted, event)
+            d.settle
+          elsif d.complete?
+            if d.link.local_closed? && @opts[:auto_accept]
+              d.release
+            else
+              begin
+                delegate(:on_message, event)
+                d.accept if @opts[:auto_accept] && !d.settled?
+              rescue Qpid::Proton::Reject
+                d.reject
+              rescue Qpid::Proton::Release
+                d.release(true)
+              end
+            end
+          end
+          delegate(:on_settled, event) if d.settled?
+          add_credit(event)
+        else                      # Outgoing message
+          t = event.tracker
+          if t.updated?
+            case t.state
+            when Qpid::Proton::Delivery::ACCEPTED then delegate(:on_accepted, event)
+            when Qpid::Proton::Delivery::REJECTED then delegate(:on_rejected, event)
+            when Qpid::Proton::Delivery::RELEASED then delegate(:on_released, event)
+            when Qpid::Proton::Delivery::MODIFIED then delegate(:on_modified, event)
+            end
+            delegate(:on_settled, event) if t.settled?
+            t.settle if @opts[:auto_settle]
+          end
+        end
+      end
+
+      def on_link_flow(event)
+        add_credit(event)
+        l = event.link
+        delegate(:on_sendable, event) if l.sender? && l.open? && l.credit > 0
+      end
+
+      def add_credit(event)
+        r = event.receiver
+        prefetch = @opts[:prefetch]
+        if r && r.open? && (r.drained == 0) && prefetch && (prefetch > r.credit)
+          r.flow(prefetch - r.credit)
+        end
+      end
+    end
+  end
+end

data/lib/messenger/messenger.rb

@@ -1,4 +1,3 @@
-#
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,9 +14,10 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
+
 
 module Qpid::Proton::Messenger
+  # @deprecated use {Qpid::Proton::Container}
   #
   # The +Messenger+ class defines a high level interface for
   # sending and receiving Messages. Every Messenger contains
@@ -56,11 +56,7 @@ module Qpid::Proton::Messenger
   class Messenger
 
     include Qpid::Proton::Util::ErrorHandler
-
-    can_raise_error [:send, :receive, :password=, :start, :stop,
-                     :perform_put, :perform_get, :interrupt,
-                     :route, :rewrite, :accept, :reject,
-                     :incoming_window=, :outgoing_window=]
+    include Qpid::Proton::Util::Deprecation
 
     # Creates a new +Messenger+.
     #
@@ -72,6 +68,7 @@ module Qpid::Proton::Messenger
     # * name - the name (def. nil)
     #
     def initialize(name = nil)
+      deprecated Qpid::Proton::Messenger, Qpid::Proton::Container
       @impl = Cproton.pn_messenger(name)
       @selectables = {}
       ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
@@ -697,6 +694,10 @@ module Qpid::Proton::Messenger
       !window.nil? && window.is_a?(Numeric)
     end
 
-  end
+    can_raise_error [:send, :receive, :password=, :start, :stop,
+                     :perform_put, :perform_get, :interrupt,
+                     :route, :rewrite, :accept, :reject,
+                     :incoming_window=, :outgoing_window=]
 
+  end
 end

data/lib/messenger/subscription.rb

@@ -1,4 +1,3 @@
-#--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton::Messenger
 

data/lib/messenger/tracker.rb

@@ -1,4 +1,3 @@
-#--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton::Messenger
 

data/lib/messenger/tracker_status.rb

@@ -1,4 +1,3 @@
-#--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton::Messenger
 

data/lib/qpid_proton.rb

@@ -1,4 +1,3 @@
-#--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,36 +14,40 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 require "cproton"
 require "date"
 require "weakref"
 
-if RUBY_VERSION < "1.9"
-require "kconv"
-else
+begin
   require "securerandom"
+rescue LoadError
+  require "kconv"               # Ruby < 1.9
+end
+
+# Qpid is the top level module for the Qpid project http://qpid.apache.org
+# Definitions for this library are in module {Qpid::Proton}
+module Qpid
+  # Proton is a ruby API for sending and receiving AMQP messages in clients or servers.
+  # See the {overview}[../file.README.html] for more.
+  module Proton
+    # Only opened here for module doc comment
+  end
 end
 
 # Exception classes
 require "core/exceptions"
 
 # Utility classes
+require "util/deprecation"
 require "util/version"
 require "util/error_handler"
-require "util/constants"
-require "util/swig_helper"
-require "util/condition"
 require "util/wrapper"
-require "util/class_wrapper"
-require "util/engine"
-require "util/uuid"
 require "util/timeout"
-require "util/handler"
-require "util/reactor"
 
 # Types
+require "types/type"
 require "types/strings"
 require "types/hash"
 require "types/array"
@@ -54,20 +57,18 @@ require "types/described"
 require "codec/mapping"
 require "codec/data"
 
-# Event API classes
-require "event/event_type"
-require "event/event_base"
-require "event/event"
-require "event/collector"
-
 # Main Proton classes
-require "core/selectable"
+require "core/condition"
+require "core/event"
+require "core/uri"
 require "core/message"
 require "core/endpoint"
 require "core/session"
 require "core/terminus"
 require "core/disposition"
+require "core/transfer"
 require "core/delivery"
+require "core/tracker"
 require "core/link"
 require "core/sender"
 require "core/receiver"
@@ -77,56 +78,25 @@ require "core/ssl_domain"
 require "core/ssl_details"
 require "core/ssl"
 require "core/transport"
-require "core/base_handler"
 require "core/url"
+require "core/connection_driver"
 
-# Messenger API classes
-require "messenger/subscription"
-require "messenger/tracker_status"
-require "messenger/tracker"
-require "messenger/messenger"
+# Handlers and adapters
+require "handler/adapter"
+require "handler/messaging_adapter"
+require "core/messaging_handler"
 
-# Handler classes
-require "handler/c_adaptor"
-require "handler/wrapped_handler"
-require "handler/acking"
-require "handler/endpoint_state_handler"
-require "handler/incoming_message_handler"
-require "handler/outgoing_message_handler"
-require "handler/c_flow_controller"
-require "handler/messaging_handler"
+# Main container class
+require "core/container"
 
-# Reactor classes
-require "reactor/task"
-require "reactor/acceptor"
-require "reactor/reactor"
-require "reactor/ssl_config"
-require "reactor/global_overrides"
-require "reactor/urls"
-require "reactor/connector"
-require "reactor/backoff"
-require "reactor/session_per_connection"
+# DEPRECATED Backwards compatibility shims for Reactor API
+require "handler/reactor_messaging_adapter"
+require "handler/messaging_handler" # Keep original name for compatibility
 require "reactor/container"
-require "reactor/link_option"
-
-module Qpid::Proton
-  # @private
-  def self.registry
-    @registry ||= {}
-  end
-
-  # @private
-  def self.add_to_registry(key, value)
-    self.registry[key] = value
-  end
 
-  # @private
-  def self.get_from_registry(key)
-    self.registry[key]
-  end
+# DEPRECATED Messenger API classes
+require "messenger/subscription"
+require "messenger/tracker_status"
+require "messenger/tracker"
+require "messenger/messenger"
 
-  # @private
-  def self.delete_from_registry(key)
-    self.registry.delete(key)
-  end
-end

data/lib/reactor/container.rb

@@ -1,4 +1,3 @@
-#--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,256 +14,63 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
 
-module Qpid::Proton::Reactor
 
-  private
-  class InternalTransactionHandler < Qpid::Proton::Handler::OutgoingMessageHandler
+module Qpid::Proton
+  module Reactor
 
-    def initialize
-      super
-    end
-
-    def on_settled(event)
-      if event.delivery.respond_to? :transaction
-        event.transaction = event.delivery.transaction
-        event.delivery.transaction.handle_outcome(event)
-      end
-    end
-
-  end
-
-  public
-  # A representation of the AMQP concept of a container which, loosely
-  # speaking, is something that establishes links to or from another
-  # container on which messages are transferred.
-  #
-  # This is an extension to the Reactor classthat adds convenience methods
-  # for creating instances of Qpid::Proton::Connection, Qpid::Proton::Sender
-  # and Qpid::Proton::Receiver.
-  class Container < Reactor
-
-    include Qpid::Proton::Util::Reactor
-
-    include Qpid::Proton::Util::UUID
-
-    attr_accessor :container_id
-    attr_accessor :global_handler
-
-    def initialize(handlers, options = {})
-      super(handlers, options)
+    # @deprecated use {Qpid::Proton::Container}
+    class Container < Qpid::Proton::Container
+      include Util::Deprecation
 
-      # only do the following if we're creating a new instance
-      if !options.has_key?(:impl)
-        @ssl = SSLConfig.new
-        if options[:global_handler]
-          self.global_handler = GlobalOverrides.new(options[:global_handler])
-        else
-          # very ugly, but using self.global_handler doesn't work in the constructor
-          ghandler = Reactor.instance_method(:global_handler).bind(self).call
-          ghandler = GlobalOverrides.new(ghandler)
-          Reactor.instance_method(:global_handler=).bind(self).call(ghandler)
-        end
-        @trigger = nil
-        @container_id = generate_uuid
-      end
-    end
+      private
+      alias super_connect connect # Access to superclass method
 
-    # Initiate an AMQP connection.
-    #
-    # @param url [String] Connect to URL host:port, using user:password@ if present
-    # @param opts [Hash] Named options
-    #   For backwards compatibility, can be called with a single parameter opts.
-    #
-    # @option opts [String] :url Connect to URL host:port using user:password@ if present.
-    # @option opts [String] :user user name for authentication if not given by URL
-    # @option opts [String] :password password for authentication if not given by URL
-    # @option opts [Numeric] :idle_timeout seconds before closing an idle connection,
-    #   can be a fractional value.
-    # @option opts [Boolean] :sasl_enabled Enable or disable SASL.
-    # @option opts [Boolean] :sasl_allow_insecure_mechs Allow mechanisms that disclose clear text
-    #   passwords, even over an insecure connection. By default, such mechanisms are only allowed
-    #   when SSL is enabled.
-    # @option opts [String] :sasl_allowed_mechs the allowed SASL mechanisms for use on the connection.
-    #
-    # @option opts [String] :address *deprecated* use the :url option
-    # @option opts [Numeric] :heartbeat milliseconds before closing an idle connection.
-    #   *deprecated* use :idle_timeout => heartbeat/1000 
-    #
-    # @return [Connection] the new connection
-    #
-    def connect(url, opts = {})
-      # Backwards compatible with old connect(options)
-      if url.is_a? Hash and opts.empty?
-        opts = url
-        url = nil
-      end
-      conn = self.connection(opts[:handler])
-      conn.container = self.container_id || generate_uuid
-      connector = Connector.new(conn, url, opts)
-      return conn
-    end
+      public
 
-    private
-    def _session(context)
-      if context.is_a?(Qpid::Proton::URL)
-        return _session(self.connect(:url => context))
-      elsif context.is_a?(Qpid::Proton::Session)
-        return context
-      elsif context.is_a?(Qpid::Proton::Connection)
-        if context.session_policy?
-          return context.session_policy.session(context)
-        else
-          return self.create_session(context)
-        end
-      else
-        return context.session
+      # @deprecated use {Qpid::Proton::Container}
+      def initialize(handlers, opts=nil)
+        deprecated Qpid::Proton::Reactor::Container, Qpid::Proton::Container
+        h = handlers || (opts && opts[:global_handler]) || Handler::ReactorMessagingAdapter.new(nil)
+        id = opts && opts[:container_id]
+        super(h, id)
       end
-    end
 
-    public
-    # Initiates the establishment of a link over which messages can be sent.
-    #
-    # @param context [String, URL] The context.
-    # @param opts [Hash] Additional options.
-    # @option opts [String, Qpid::Proton::URL] The target address.
-    # @option opts [String] :source The source address.
-    # @option opts [Boolean] :dynamic
-    # @option opts [Object] :handler
-    # @option opts [Object] :tag_generator The tag generator.
-    # @option opts [Hash] :options Addtional link options
-    #
-    # @return [Sender] The sender.
-    #
-    def create_sender(context, opts = {})
-      if context.is_a?(::String)
-        context = Qpid::Proton::URL.new(context)
-      end
+      alias container_id id
+      alias global_handler handler
 
-      target = opts[:target]
-      if context.is_a?(Qpid::Proton::URL) && target.nil?
-        target = context.path
+      def connect(opts=nil)
+        url = opts && (opts[:url] || opts[:address])
+        raise ::ArgumentError.new, "no :url or :address option provided" unless url
+        super(url, opts)
       end
 
-      session = _session(context)
-
-      sender = session.sender(opts[:name] ||
-                              id(session.connection.container,
-                                target, opts[:source]))
-        sender.source.address = opts[:source] if !opts[:source].nil?
-        sender.target.address = target if target
-        sender.handler = opts[:handler] if !opts[:handler].nil?
-        sender.tag_generator = opts[:tag_generator] if !opts[:tag_gnenerator].nil?
-        _apply_link_options(opts[:options], sender)
-        sender.open
-        return sender
-    end
-
-    # Initiates the establishment of a link over which messages can be received.
-    #
-    # There are two accepted arguments for the context
-    #  1. If a Connection is supplied then the link is established using that
-    # object. The source, and optionally the target, address can be supplied
-    #  2. If it is a String or a URL then a new Connection is created on which
-    # the link will be attached. If a path is specified, but not the source
-    # address, then the path of the URL is used as the target address.
-    #
-    # The name will be generated for the link if one is not specified.
-    #
-    # @param context [Connection, URL, String] The connection or the address.
-    # @param opts [Hash] Additional otpions.
-    # @option opts [String, Qpid::Proton::URL] The source address.
-    # @option opts [String] :target The target address
-    # @option opts [String] :name The link name.
-    # @option opts [Boolean] :dynamic
-    # @option opts [Object] :handler
-    # @option opts [Hash] :options Additional link options.
-    #
-    # @return [Receiver
-    #
-    def create_receiver(context, opts = {})
-      if context.is_a?(::String)
-        context = Qpid::Proton::URL.new(context)
-      end
-
-      source = opts[:source]
-      if context.is_a?(Qpid::Proton::URL) && source.nil?
-        source = context.path
-      end
-
-      session = _session(context)
-
-      receiver = session.receiver(opts[:name] ||
-                                  id(session.connection.container,
-                                      source, opts[:target]))
-      receiver.source.address = source if source
-      receiver.source.dynamic = true if opts.has_key?(:dynamic) && opts[:dynamic]
-      receiver.target.address = opts[:target] if !opts[:target].nil?
-      receiver.handler = opts[:handler] if !opts[:handler].nil?
-      _apply_link_options(opts[:options], receiver)
-      receiver.open
-      return receiver
-    end
-
-    def declare_transaction(context, handler = nil, settle_before_discharge = false)
-      if context.respond_to? :txn_ctl && !context.__send__(:txn_ctl).nil?
-        class << context
-          attr_accessor :txn_ctl
+      def create_sender(context, opts=nil)
+        c = context if context.is_a? Qpid::Proton::Connection
+        unless c
+          url = Qpid::Proton::uri context
+          c = super_connect(url, opts)
+          opts ||= {}
+          opts[:target] ||= url.amqp_address
         end
-        context.txn_ctl = self.create_sender(context, nil, "txn-ctl",
-        InternalTransactionHandler.new())
+        c.open_sender opts
       end
-      return Transaction.new(context.txn_ctl, handler, settle_before_discharge)
-    end
 
-    # Initiates a server socket, accepting incoming AMQP connections on the
-    # interface and port specified.
-    #
-    # @param url []
-    # @param ssl_domain []
-    #
-    def listen(url, ssl_domain = nil)
-      url = Qpid::Proton::URL.new(url)
-      acceptor = self.acceptor(url.host, url.port)
-      ssl_config = ssl_domain
-      if ssl_config.nil? && (url.scheme == 'amqps') && @ssl
-        ssl_config = @ssl.server
-      end
-      if !ssl_config.nil?
-        acceptor.ssl_domain(ssl_config)
-      end
-      return acceptor
-    end
-
-    private
-
-    def id(container, remote, local)
-      if !local.nil? && !remote.nil?
-        "#{container}-#{remote}-#{local}"
-      elsif !local.nil?
-        "#{container}-#{local}"
-      elsif !remote.nil?
-        "#{container}-#{remote}"
-      else
-        "#{container}-#{generate_uuid}"
-      end
-    end
-
-    def _apply_link_options(options, link)
-      if !options.nil? && !options.empty?
-        if !options.is_a?(::List)
-          options = [Options].flatten
+      def create_receiver(context, opts=nil)
+        c = context if context.is_a? Qpid::Proton::Connection
+        unless c
+          url = Qpid::Proton::uri context
+          c = super_connect(url, opts)
+          opts ||= {}
+          opts[:source] ||= url.amqp_address
         end
-
-        options.each {|option| o.apply(link) if o.test(link)}
+        c.open_receiver opts
       end
-    end
 
-    def to_s
-      "#{self.class}<@impl=#{Cproton.pni_address_of(@impl)}>"
+      def listen(url, ssl_domain = nil)
+        # TODO aconway 2017-11-29: ssl_domain
+        super(url)
+      end
     end
-
   end
-
 end