qpid_proton 0.18.1 → 0.19.0

data/lib/codec/mapping.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,155 +14,172 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
 
-module Qpid::Proton::Codec
 
-  # Maps between Proton types and their Ruby native language counterparts.
-  #
-  # @private
-  class Mapping
+module Qpid::Proton
+  module Codec
 
-    attr_reader :code
-    attr_reader :put_method
-    attr_reader :get_method
-
-    # Creates a new mapping.
-    #
-    # ==== Arguments
+    # Maps between Proton types and their Ruby native language counterparts.
     #
-    # * code    - the AMQP code for this type
-    # * name    - the AMQP name for this type
-    # * klasses - native Ruby classes that are mapped to this AMQP type
-    # * getter  - overrides the get method for the type
-    def initialize(code, name, klasses = nil, getter = nil)
-
-      @debug = (name == "bool")
-
-      @code = code
-      @name = name
-
-      @@by_preferred ||= {}
-      @@by_code ||= {}
-      @@by_code["#{code}"] = self
-      @@by_name ||= {}
-      @@by_name[name] = self
-      @@by_class ||= {}
-
-      unless klasses.nil?
-        klasses.each do |klass|
-          raise "entry exists for #{klass}" if @@by_class.keys.include? klass
-          @@by_class[klass] = self unless klass.nil?
+    # @private
+    class Mapping
+
+      attr_reader :code
+      attr_reader :put_method
+      attr_reader :get_method
+
+      @@by_code = {}
+      @@by_class = {}
+
+      # Creates a new mapping.
+      #
+      # ==== Arguments
+      #
+      # * code    - the AMQP code for this type
+      # * name    - the AMQP name for this type
+      # * klasses - native Ruby classes that are mapped to this AMQP type
+      # * getter  - overrides the get method for the type
+      def initialize(code, name, klasses = nil, getter = nil)
+
+        @code = code
+        @name = name
+
+        @@by_code[code] = self
+
+        unless klasses.nil?
+          klasses.each do |klass|
+            raise "entry exists for #{klass}" if @@by_class.keys.include? klass
+            @@by_class[klass] = self unless klass.nil?
+          end
         end
-      end
 
-      @put_method = (name + "=").intern
+        @put_method = (name + "=").intern
 
-      if getter.nil?
-        @get_method = name.intern
-      else
-        @get_method = getter.intern
+        if getter.nil?
+          @get_method = name.intern
+        else
+          @get_method = getter.intern
+        end
       end
-    end
-
-    def to_s; @name; end
 
-    def put(data, value)
-      data.__send__(@put_method, value)
-    end
+      def to_s; @name; end
 
-    def get(data)
-      data.__send__(@get_method)
-    end
+      def put(data, value)
+        data.__send__(@put_method, value)
+      end
 
-    def self.for_class(klass) # :nodoc:
-      klass and (@@by_class[klass] or self.for_class(klass.superclass))
-    end
+      def get(data)
+        data.__send__(@get_method)
+      end
 
-    def self.for_code(code)
-      @@by_code["#{code}"]
-    end
+      def self.for_class(klass)
+        c = klass
+        c = c.superclass while c && (x = @@by_class[c]).nil?
+        raise TypeError, "#{klass} cannot be converted to AMQP" unless x
+        x
+      end
 
-  end
+      def self.for_code(code)
+        @@by_code[code]
+      end
 
-  NULL       = Mapping.new(Cproton::PN_NULL, "null", [NilClass], "nil?")
-  BOOL       = Mapping.new(Cproton::PN_BOOL, "bool", [TrueClass, FalseClass], "bool")
-  UBYTE      = Mapping.new(Cproton::PN_UBYTE, "ubyte")
-  BYTE       = Mapping.new(Cproton::PN_BYTE, "byte")
-  USHORT     = Mapping.new(Cproton::PN_USHORT, "ushort")
-  SHORT      = Mapping.new(Cproton::PN_SHORT, "short")
-  UINT       = Mapping.new(Cproton::PN_UINT, "uint")
-  INT        = Mapping.new(Cproton::PN_INT, "int")
-  CHAR       = Mapping.new(Cproton::PN_CHAR, "char")
-  ULONG      = Mapping.new(Cproton::PN_ULONG, "ulong")
-  LONG       = Mapping.new(Cproton::PN_LONG, "long", [Integer])
-  TIMESTAMP  = Mapping.new(Cproton::PN_TIMESTAMP, "timestamp", [Date, Time])
-  FLOAT      = Mapping.new(Cproton::PN_FLOAT, "float")
-  DOUBLE     = Mapping.new(Cproton::PN_DOUBLE, "double", [Float])
-  DECIMAL32  = Mapping.new(Cproton::PN_DECIMAL32, "decimal32")
-  DECIMAL64  = Mapping.new(Cproton::PN_DECIMAL64, "decimal64")
-  DECIMAL128 = Mapping.new(Cproton::PN_DECIMAL128, "decimal128")
-  UUID       = Mapping.new(Cproton::PN_UUID, "uuid")
-  BINARY     = Mapping.new(Cproton::PN_BINARY, "binary")
-  STRING     = Mapping.new(Cproton::PN_STRING, "string", [String, Symbol,
-                                                          Qpid::Proton::Types::UTFString,
-                                                          Qpid::Proton::Types::BinaryString])
-
-  # @private
-  class << STRING
-    def put(data, value)
-      # if we have a symbol then convert it to a string
-      value = value.to_s if value.is_a?(Symbol)
-
-      isutf = false
-
-      if value.is_a?(Qpid::Proton::Types::UTFString)
-        isutf = true
-      else
-        # For Ruby 1.8 we will just treat all strings as binary.
-        # For Ruby 1.9+ we can check the encoding first to see what it is
-        if RUBY_VERSION >= "1.9"
-          # If the string is ASCII-8BIT then treat is as binary. Otherwise,
-          # try to convert it to UTF-8 and, if successful, send as that.
-          if value.encoding != Encoding::ASCII_8BIT &&
-             value.encode(Encoding::UTF_8).valid_encoding?
-            isutf = true
-          end
+      # Convert x to a Mapping
+      def self.[](x)
+        case x
+        when Mapping then x
+        when Integer then @@by_code[x]
+        when Types::Type then @@by_code[x.code]
         end
       end
 
-      data.string = value if isutf
-      data.binary = value if !isutf
-
     end
-  end
 
-  SYMBOL     = Mapping.new(Cproton::PN_SYMBOL, "symbol")
-  DESCRIBED  = Mapping.new(Cproton::PN_DESCRIBED, "described", [Qpid::Proton::Types::Described], "get_described")
-  ARRAY      = Mapping.new(Cproton::PN_ARRAY, "array", nil, "get_array")
-  LIST       = Mapping.new(Cproton::PN_LIST, "list", [::Array], "get_array")
-  MAP        = Mapping.new(Cproton::PN_MAP, "map", [::Hash], "get_map")
-
-  # @private
-  class << MAP
-    def put(data, map, options = {})
-      data.put_map
-      data.enter
-      map.each_pair do |key, value|
-        if options[:keys] == :SYMBOL
-          SYMBOL.put(data, key)
+    NULL       = Mapping.new(Cproton::PN_NULL, "null", [NilClass])
+    BOOL       = Mapping.new(Cproton::PN_BOOL, "bool", [TrueClass, FalseClass])
+    UBYTE      = Mapping.new(Cproton::PN_UBYTE, "ubyte")
+    BYTE       = Mapping.new(Cproton::PN_BYTE, "byte")
+    USHORT     = Mapping.new(Cproton::PN_USHORT, "ushort")
+    SHORT      = Mapping.new(Cproton::PN_SHORT, "short")
+    UINT       = Mapping.new(Cproton::PN_UINT, "uint")
+    INT        = Mapping.new(Cproton::PN_INT, "int")
+    CHAR       = Mapping.new(Cproton::PN_CHAR, "char")
+    ULONG      = Mapping.new(Cproton::PN_ULONG, "ulong")
+    LONG       = Mapping.new(Cproton::PN_LONG, "long", [Integer])
+    TIMESTAMP  = Mapping.new(Cproton::PN_TIMESTAMP, "timestamp", [Date, Time])
+    FLOAT      = Mapping.new(Cproton::PN_FLOAT, "float")
+    DOUBLE     = Mapping.new(Cproton::PN_DOUBLE, "double", [Float])
+    DECIMAL32  = Mapping.new(Cproton::PN_DECIMAL32, "decimal32")
+    DECIMAL64  = Mapping.new(Cproton::PN_DECIMAL64, "decimal64")
+    DECIMAL128 = Mapping.new(Cproton::PN_DECIMAL128, "decimal128")
+    UUID       = Mapping.new(Cproton::PN_UUID, "uuid")
+    BINARY     = Mapping.new(Cproton::PN_BINARY, "binary")
+    STRING     = Mapping.new(Cproton::PN_STRING, "string", [::String,
+                                                            Types::UTFString,
+                                                            Types::BinaryString])
+    SYMBOL     = Mapping.new(Cproton::PN_SYMBOL, "symbol", [::Symbol])
+    DESCRIBED  = Mapping.new(Cproton::PN_DESCRIBED, "described", [Types::Described])
+    ARRAY      = Mapping.new(Cproton::PN_ARRAY, "array", [Types::UniformArray])
+    LIST       = Mapping.new(Cproton::PN_LIST, "list", [::Array])
+    MAP        = Mapping.new(Cproton::PN_MAP, "map", [::Hash])
+
+    private
+
+    class << STRING
+      def put(data, value)
+        # if we have a symbol then convert it to a string
+        value = value.to_s if value.is_a?(Symbol)
+
+        isutf = false
+
+        if value.is_a?(Types::UTFString)
+          isutf = true
         else
-          Mapping.for_class(key.class).put(data, key)
+          # For Ruby 1.8 we will just treat all strings as binary.
+          # For Ruby 1.9+ we can check the encoding first to see what it is
+          if RUBY_VERSION >= "1.9"
+            # If the string is ASCII-8BIT then treat is as binary. Otherwise,
+            # try to convert it to UTF-8 and, if successful, send as that.
+            if value.encoding != Encoding::ASCII_8BIT &&
+                value.encode(Encoding::UTF_8).valid_encoding?
+              isutf = true
+            end
+          end
         end
 
-        if value.nil?
-          data.null
-        else
-          Mapping.for_class(value.class).put(data, value)
+        data.string = value if isutf
+        data.binary = value if !isutf
+      end
+    end
+
+    class << MAP
+      def put(data, map, options = {})
+        data.put_map
+        data.enter
+        map.each_pair do |key, value|
+          if options[:keys] == :SYMBOL
+            SYMBOL.put(data, key)
+          else
+            data.object = key
+          end
+
+          if value.nil?
+            data.null
+          else
+            data.object = value
+          end
         end
+        data.exit
       end
-      data.exit
     end
-  end
 
+    class << DESCRIBED
+      def put(data, described)
+        data.put_described
+        data.enter
+        data.object = described.descriptor
+        data.object = described.value
+        data.exit
+      end
+    end
+  end
 end

data/lib/core/condition.rb

@@ -0,0 +1,89 @@
+# 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.
+
+
+module Qpid::Proton
+
+  # An AMQP error condition.
+  #
+  # An error sent across an AMQP connection has a name, description and optional extra info.
+  # The {Connectin}, {Session} and {Link} endpoint classes all have a #condition method to
+  # check for errors.
+  #
+  # {Condition} can also be raised as an exception.
+  #
+  class Condition < ProtonError
+
+    attr_reader :name, :description, :info
+
+    def initialize(name, description = nil, info = nil)
+      @name = name
+      @description = description
+      @info = info
+      super(to_s)
+    end
+
+    def to_s() "#{@name}: #{@description}"; end
+
+    def inspect() "#{self.class.name}(#{@name.inspect}, #{@description.inspect}, #{@info.inspect})"; end
+
+    def ==(other)
+      ((other.is_a? Condition) &&
+       (other.name == self.name) &&
+       (other.description == self.description) &&
+       (other.info == self.info))
+    end
+
+    # Convert an object to a condition.
+    # @param obj the object to turn into a condition
+    # @param default_name name to use if obj does not imply a name
+    # @return [Condition] Conversion depends on the type of obj
+    # - Condition: return obj
+    # - Exception: return Condition(obj.class.name, obj.to_s)
+    # - String-like: return String.try_convert(obj)
+    # - nil: return nil
+    # @raise ::ArgumentError if obj is not convertible to {Condition}
+    def self.convert(obj, default_name="error")
+      case obj
+      when nil then nil
+      when Condition then obj
+      when Exception then Condition.new(obj.class.name, obj.to_s)
+      when SWIG::TYPE_p_pn_condition_t
+        if Cproton.pn_condition_is_set(obj)
+          Condition.new(Cproton.pn_condition_get_name(obj),
+                        Cproton.pn_condition_get_description(obj),
+                        Codec::Data.to_object(Cproton.pn_condition_info(obj)))
+        end
+      else
+        raise ::ArgumentError, "can't convert #{obj.class.name} to #{self.class.name}" unless obj.respond_to? :to_str
+        Condition.new(default_name, obj.to_str)
+      end
+    end
+
+    private
+
+    def self.assign(impl, cond)
+      Cproton.pn_condition_clear(impl)
+      if cond
+        cond = self.convert(cond)
+        Cproton.pn_condition_set_name(impl, cond.name) if cond.name
+        Cproton.pn_condition_set_description(impl, cond.description) if cond.description
+        Codec::Data.from_object(Cproton.pn_condition_info(impl), cond.info) if cond.info
+      end
+    end
+  end
+end

data/lib/core/connection.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,214 +14,167 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton
 
-  # A Connection has at most one Qpid::Proton::Transport instance.
-  #
+  # An AMQP connection.
   class Connection < Endpoint
-
-    # @private
-    include Util::SwigHelper
-
-    # @private
     PROTON_METHOD_PREFIX = "pn_connection"
-
-    # @!attribute hostname
-    #
-    # @return [String] The AMQP hostname for the connection.
-    #
-    proton_accessor :hostname
-
-    # @!attribute user
-    #   The user name for authentication.
-    #
-    #   @return [String] the user name
-    proton_accessor :user
-
-    # @private
-    proton_writer :password
-
-    # @private
-    proton_reader :attachments
-
-    attr_accessor :overrides
-    attr_accessor :session_policy
-
-    # @private
     include Util::Wrapper
+    include Util::Deprecation
 
     # @private
     def self.wrap(impl)
       return nil if impl.nil?
-
       self.fetch_instance(impl, :pn_connection_attachments) || Connection.new(impl)
     end
 
-    # Constructs a new instance of Connection.
-    #
-    # You do *not* need to provide the underlying C struct, as this is
-    # automatically generated as needed. The argument is a convenience
-    # for returning existing Connection objects.
-    #
-    # @param impl [pn_connection_t] The pn_connection_t struct.
-    #
+    # @private
     def initialize(impl = Cproton.pn_connection)
       super()
       @impl = impl
-      @offered_capabilities = nil
-      @desired_capabilities = nil
-      @properties = nil
       @overrides = nil
-      @collector = nil
       @session_policy = nil
+      @link_count = 0
+      @link_prefix = ""
       self.class.store_instance(self, :pn_connection_attachments)
     end
 
-    def overrides?
-      !@overrides.nil?
-    end
+    # @return [String] The AMQP hostname for the connection.
+    def virtual_host() Cproton.pn_connection_remote_hostname(@impl); end
+    deprecated_alias :remote_hostname, :virtual_host
 
-    def session_policy?
-      !@session_policy.nil?
-    end
+    # @!attribute hostname
+    # @deprecated use {#virtual_host}
+    proton_set_get :hostname
 
-    # This method is used when working within the context of an event.
-    #
-    # @return [Connection] The connection itself.
-    #
-    def connection
-      self
+    # @return [String] User name used for authentication (outgoing connection)
+    # or the authenticated user name (incoming connection)
+    def user()
+      Cproton.pn_connection_get_user(impl) or (connection.transport && connection.transport.user)
     end
 
-    # The Transport to which this connection is bound.
-    #
-    # @return [Transport] The transport, or nil if the Connection is unbound.
-    #
-    def transport
-      Transport.wrap(Cproton.pn_connection_transport(@impl))
-    end
+    # @deprecated no replacement
+    def overrides?() deprecated __method__; false; end
 
-    # Associates the connection with an event collector.
-    #
-    # By doing this, key changes in the endpoint's state are reported to
-    # the connector via Event objects that can be inspected and processed.
-    #
-    # Note that, by registering a collector, the user is requesting that an
-    # indefinite number of events be queued up on its behalf. This means
-    # that, unless the application eventual processes these events, the
-    # storage requirements for keeping them will grow without bound. So be
-    # careful and do not register a collector with a connection unless the
-    # application will process the events.
-    #
-    # @param collector [Event::Collector] The event collector.
-    #
-    def collect(collector)
-      if collector.nil?
-        Cproton.pn_connection_collect(@impl, nil)
-      else
-        Cproton.pn_connection_collect(@impl, collector.impl)
-      end
-      @collector = collector
-    end
+    # @deprecated no replacement
+    def session_policy?() deprecated __method__; false; end
 
-    # Get the AMQP container name advertised by the remote connection
-    # endpoint.
-    #
-    # This will return nil until the REMOTE_ACTIVE state is reached.
-    #
-    # Any non-nil container returned by this operation will be valid
-    # until the connection is unbound from a transport, or freed,
-    # whichever happens sooner.
-    #
-    # @return [String] The remote connection's AMQP container name.
-    #
-    # @see #container
-    #
-    def remote_container
-      Cproton.pn_connection_remote_container(@impl)
+    # @return [Connection] self
+    def connection() self; end
+
+    # @return [Transport, nil] transport bound to this connection, or nil if unbound.
+    def transport() Transport.wrap(Cproton.pn_connection_transport(@impl)); end
+
+    # @return AMQP container ID advertised by the remote peer.
+    # To get the local container ID use {#container} and {Container#id}
+    def container_id() Cproton.pn_connection_remote_container(@impl); end
+    deprecated_alias :remote_container, :container_id
+
+    # @return [Container] the container managing this connection
+    attr_reader :container
+
+    # @return [Array<Symbol>] offered capabilities provided by the remote peer
+    def offered_capabilities
+      Codec::Data.to_object(Cproton.pn_connection_remote_offered_capabilities(@impl))
     end
+    deprecated_alias :remote_offered_capabilities, :offered_capabilities
 
-    def container=(name)
-      Cproton.pn_connection_set_container(@impl, name)
+    # @return [Array<Symbol>] desired capabilities provided by the remote peer
+    def desired_capabilities
+      Codec::Data.to_object(Cproton.pn_connection_remote_desired_capabilities(@impl))
     end
+    deprecated_alias :remote_desired_capabilities, :desired_capabilities
 
-    def container
-      Cproton.pn_connection_get_container(@impl)
+    # @return [Hash] connection-properties provided by the remote peer
+    def properties
+      Codec::Data.to_object(Cproton.pn_connection_remote_properties(@impl))
     end
+    deprecated_alias :remote_properties, :properties
 
-    # Get the AMQP hostname set by the remote connection endpoint.
+    # Open the local end of the connection.
     #
-    # This will return nil until the #REMOTE_ACTIVE state is
-    # reached.
+    # @option opts [MessagingHandler] :handler handler for events related to this connection.
     #
-    # @return [String] The remote connection's AMQP hostname.
+    # @option opts [String] :user User name for authentication
+    # @option opts [String] :password Authentication secret
+    # @option opts [String] :virtual_host Virtual host name
+    # @option opts [String] :container_id (provided by {Container}) override advertised container-id
     #
-    # @see #hostname
+    # @option opts [Hash<Symbol=>Object>] :properties Application-defined properties
+    # @option opts [Array<Symbol>] :offered_capabilities Extensions the endpoint supports
+    # @option opts [Array<Symbol>] :desired_capabilities Extensions the endpoint can use
     #
-    def remote_hostname
-      Cproton.pn_connection_remote_hostname(@impl)
-    end
-
-    # Get the AMQP offered capabilities suppolied by the remote connection
-    # endpoint.
+    # @option opts [Numeric] :idle_timeout Seconds before closing an idle connection
+    # @option opts [Integer] :max_sessions Limit the number of active sessions
+    # @option opts [Integer] :max_frame_size Limit the size of AMQP frames
     #
-    # This object returned is valid until the connection is freed. The Data
-    # object will be empty until the remote connection is opened, as
-    # indicated by the #REMOTE_ACTIVE flag.
+    # @option opts [Boolean] :sasl_enabled (false) Enable or disable SASL.
+    # @option opts [Boolean] :sasl_allow_insecure_mechs (false) Allow mechanisms send secrets in clear text
+    # @option opts [String] :sasl_allowed_mechs SASL mechanisms allowed by this end of the connection
     #
-    # @return [Data] The offered capabilities.
+    # @option opts [SSLDomain] :ssl_domain SSL configuration domain.
     #
-    def remote_offered_capabilities
-      data_to_object(Cproton.pn_connection_remote_offered_capabilities(@impl))
+    def open(opts=nil)
+      return if local_active?
+      apply opts if opts
+      Cproton.pn_connection_open(@impl)
     end
 
-    # Get the AMQP desired capabilities supplied by the remote connection
-    # endpoint.
-    #
-    # The object returned is valid until the connection is freed. The Data
-    # object will be empty until the remote connection is opened, as
-    # indicated by the #REMOTE_ACTIVE flag.
-    #
-    # @return [Data] The desired capabilities.
-    #
-    def remote_desired_capabilities
-      data_to_object(Cproton.pn_connection_remote_desired_capabilities(@impl))
+    # @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)
+      @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
+      Cproton.pn_connection_set_container(@impl, cid)
+      Cproton.pn_connection_set_user(@impl, opts[:user]) if opts[:user]
+      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]))
     end
 
-    # Get the AMQP connection properties supplie by the remote connection
-    # endpoint.
-    #
-    # The object returned is valid until the connection is freed. The Data
-    # object will be empty until the remote connection is opened, as
-    # indicated by the #REMOTE_ACTIVE flag.
-    #
-    # @return [Data] The remote properties.
-    #
-    def remote_properties
-      data_to_object(Cproton.pn_connection_remote_properites(@impl))
+    # Idle-timeout advertised by the remote peer, in seconds.
+    # @return [Numeric] Idle-timeout advertised by the remote peer, in seconds.
+    # @return [nil] if the peer does not advertise an idle time-out
+    def idle_timeout()
+      if transport && (t = transport.remote_idle_timeout)
+        Rational(t, 1000)       # More precise than Float
+      end
     end
 
-    # Opens the connection.
-    #
-    def open
-      object_to_data(@offered_capabilities,
-                     Cproton.pn_connection_offered_capabilities(@impl))
-      object_to_data(@desired_capabilities,
-                     Cproton.pn_connection_desired_capabilities(@impl))
-      object_to_data(@properties,
-                     Cproton.pn_connection_properties(@impl))
-      Cproton.pn_connection_open(@impl)
+    # Session limit advertised by the remote peer. See {Connection#open :max_sessions}
+    # @return [Integer] maximum number of sessions per connection allowed by remote peer.
+    # @return [nil] no specific limit is set.
+    def max_sessions()
+      raise StateError, "connection not bound to transport" unless transport
+      max = transport.remote_channel_max
+      return max.zero? ? nil : max
     end
 
-    # Closes the connection.
-    #
-    # Once this operation has completed, the #LOCAL_CLOSED state flag will be
-    # set.
-    #
-    def close
-      self._update_condition
+    # Maximum frame size, in bytes, advertised by the remote peer.
+    # See {Connection#open :max_frame_size}
+    # @return [Integer] maximum frame size
+    # @return [nil] no limit
+    def max_frame_size()
+      raise StateError, "connection not bound to transport" unless transport
+      max = transport.remote_max_frame
+      return max.zero? ? nil : max
+    end
+
+    # Closes the local end of the connection. The remote end may or may not be closed.
+    # @param error [Condition] Optional error condition to send with the close.
+    def close(error=nil)
+      Condition.assign(_local_condition, error)
       Cproton.pn_connection_close(@impl)
     end
 
@@ -239,99 +191,107 @@ module Qpid::Proton
       Cproton.pn_connection_state(@impl)
     end
 
-    # Returns the session for this connection.
+    # Returns the default session for this connection.
     #
     # @return [Session] The session.
     #
-    def session
-      @session ||= Session.wrap(Cproton.pn_session(@impl))
+    def default_session
+      @session ||= open_session
     end
 
-    # Returns the first session from the connection that matches the specified
-    # state mask.
-    #
-    # Examines the state of each session owned by the connection, and returns
-    # the first session that matches the given state mask. If the state mask
-    # contains *both* local and remote flags, then an exact match against
-    # those flags is performed. If the state mask contains only local *or*
-    # remote flags, then a match occurs if a*any* of the local or remote flags
-    # are set, respectively.
-    #
-    # @param mask [Integer] The state mask to be matched.
-    #
-    # @return [Session] The first matching session, or nil if none matched.
-    #
-    # @see Endpoint#LOCAL_UNINIT
-    # @see Endpoint#LOCAL_ACTIVE
-    # @see Endpoint#LOCAL_CLOSED
-    # @see Endpoint#REMOTE_UNINIT
-    # @see Endpoint#REMOTE_ACTIVE
-    # @see Endpoint#REMOTE_CLOSED
-    #
-    def session_head(mask)
-      Session.wrap(Cproton.pn_session_header(@impl, mask))
+    # @deprecated use #default_session()
+    deprecated_alias :session, :default_session
+
+    # Open a new session on this connection.
+    def open_session
+      s = Session.wrap(Cproton.pn_session(@impl))
+      s.open
+      return s
     end
 
-    # Returns the first link that matches the given state mask.
-    #
-    # Examines the state of each link owned by the connection and returns the
-    # first that matches the given state mask. If the state mask contains
-    # *both* local and remote flags, then an exact match against those flags
-    # is performed. If the state mask contains *only* local or remote flags,
-    # then a match occurs if *any* of the local ore remote flags are set,
-    # respectively.
-    #
-    # @param mask [Integer] The state mask to be matched.
-    #
-    # @return [Link] The first matching link, or nil if none matched.
-    #
-    # @see Endpoint#LOCAL_UNINIT
-    # @see Endpoint#LOCAL_ACTIVE
-    # @see Endpoint#LOCAL_CLOSED
-    # @see Endpoint#REMOTE_UNINIT
-    # @see Endpoint#REMOTE_ACTIVE
-    # @see Endpoint#REMOTE_CLOSED
-    #
+    # Open a sender on the default_session
+    # @option opts (see Session#open_sender)
+    def open_sender(opts=nil) default_session.open_sender(opts) end
+
+    # Open a  on the default_session
+    # @option opts (see Session#open_receiver)
+    def open_receiver(opts=nil) default_session.open_receiver(opts) end
+
+    # @deprecated use {#each_session}
+    def  session_head(mask)
+      deprecated __method__, "#each_session"
+      Session.wrap(Cproton.pn_session_head(@impl, mask))
+    end
+
+    # Get the sessions on this connection.
+    # @overload each_session
+    #   @yieldparam s [Session] pass each session to block
+    # @overload each_session
+    #   @return [Enumerator] enumerator over sessions
+    def each_session(&block)
+      return enum_for(:each_session) unless block_given?
+      s = Cproton.pn_session_head(@impl, 0);
+      while s
+        yield Session.wrap(s)
+        s = Cproton.pn_session_next(s, 0)
+      end
+      self
+    end
+
+    # @deprecated use {#each_link}
     def link_head(mask)
+      deprecated __method__, "#each_link"
       Link.wrap(Cproton.pn_link_head(@impl, mask))
     end
 
-    # Extracts the first delivery on the connection that has pending
-    # operations.
-    #
-    # A readable delivery indicates message data is waiting to be read. A
-    # A writable delivery indcates that message data may be sent. An updated
-    # delivery indicates that the delivery's disposition has changed.
-    #
-    # A delivery will never be *both* readable and writable, but it may be
-    # both readable or writable and updated.
-    #
-    # @return [Delivery] The delivery, or nil if none are available.
-    #
-    # @see Delivery#next
-    #
+    # Get the links on this connection.
+    # @overload each_link
+    #   @yieldparam l [Link] pass each link to block
+    # @overload each_link
+    #   @return [Enumerator] enumerator over links
+    def each_link
+      return enum_for(:each_link) unless block_given?
+      l = Cproton.pn_link_head(@impl, 0);
+      while l
+        yield Link.wrap(l)
+        l = Cproton.pn_link_next(l, 0)
+      end
+      self
+    end
+
+    # Get the {Sender} links - see {#each_link}
+    def each_sender() each_link.select { |l| l.sender? }; end
+
+    # Get the {Receiver} links - see {#each_link}
+    def each_receiver() each_link.select { |l| l.receiver? }; end
+
+    # @deprecated use {#MessagingHandler} to handle work
     def work_head
+      deprecated __method__
       Delivery.wrap(Cproton.pn_work_head(@impl))
     end
 
-    # Returns the code for a connection error.
-    #
-    # @return [Integer] The error code.
-    #
+    # @deprecated use {#condition}
     def error
+      deprecated __method__, "#condition"
       Cproton.pn_error_code(Cproton.pn_connection_error(@impl))
     end
 
-    # @private
+    # @private Generate a unique link name, internal use only.
+    def link_name()
+      @link_prefix + "/" +  (@link_count += 1).to_s(32)
+    end
+
+    protected
+
     def _local_condition
       Cproton.pn_connection_condition(@impl)
     end
 
-    # @private
     def _remote_condition
       Cproton.pn_connection_remote_condition(@impl)
     end
 
+    proton_get :attachments
   end
-
 end