qpid_proton 0.18.1 → 0.19.0

data/lib/core/link.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
 
@@ -26,6 +25,11 @@ module Qpid::Proton
   #
   class Link < Endpoint
 
+    # @private
+    PROTON_METHOD_PREFIX = "pn_link"
+    # @private
+    include Util::Wrapper
+
     # The sender will send all deliveries initially unsettled.
     SND_UNSETTLED = Cproton::PN_SND_UNSETTLED
     # The sender will send all deliveries settled to the receiver.
@@ -38,36 +42,21 @@ module Qpid::Proton
     # The receiver will only settle deliveries after the sender settles.
     RCV_SECOND = Cproton::PN_RCV_SECOND
 
-    # @private
-    include Util::SwigHelper
-
-    # @private
-    PROTON_METHOD_PREFIX = "pn_link"
-
     # @!attribute [r] state
     #
     # Returns the endpoint state flags.
     #
     proton_caller :state
 
-    # @!method open
-    #
-    # Opens the link. Once this operation has completed, the state flag will be
-    # set.
-    #
-    # @see Endpoint::LOCAL_ACTIVE
+    # @deprecated  Use {Sender#open} or {Receiver#open}
     proton_caller :open
 
-    # @!method close
-    #
-    # Closes the link.
-    #
-    # Once this operation has completed, the state flag will be set.
-    # This may be called without first calling #open, which is the equivalent to
-    # calling #open and then #close.
-    #
-    # @see Endpoint::LOCAL_CLOSED
-    proton_caller :close
+    # Close the local end of the link. 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_link_close(@impl)
+    end
 
     # @!method detach
     #
@@ -176,7 +165,7 @@ module Qpid::Proton
     #
     # @return [Boolean] True if the link is a sender.
     #
-    proton_reader  :sender, :is_or_get => :is
+    proton_is  :sender
 
     # @!attribute [r] receiver?
     #
@@ -184,10 +173,10 @@ module Qpid::Proton
     #
     # @return [Boolean] True if the link is a receiver.
     #
-    proton_reader  :receiver, :is_or_get => :is
+    proton_is  :receiver
 
     # @private
-    proton_reader :attachments
+    proton_get :attachments
 
     # Drains excess credit.
     #
@@ -207,20 +196,11 @@ module Qpid::Proton
     #
     proton_caller :drained
 
-    # @private
-    include Util::Wrapper
-
     # @private
     def self.wrap(impl)
-      return nil if impl.nil?
-
-      result = self.fetch_instance(impl, :pn_link_attachments)
-      return result unless result.nil?
-      if Cproton.pn_link_is_sender(impl)
-        return Sender.new(impl)
-      elsif Cproton.pn_link_is_receiver(impl)
-        return Receiver.new(impl)
-      end
+      return unless impl
+      return fetch_instance(impl, :pn_link_attachments) ||
+        (Cproton.pn_link_is_sender(impl) ? Sender : Receiver).new(impl)
     end
 
     # @private
@@ -241,13 +221,9 @@ module Qpid::Proton
       Cproton.pn_link_error(@impl)
     end
 
-    # Returns the next link that matches the given state mask.
-    #
-    # @param state_mask [Integer] The state mask.
-    #
-    # @return [Sender, Receiver] The next link.
-    #
+    # @deprecated use {Session#each_link, Connection#each_link}
     def next(state_mask)
+      deprecated __method__, "Session#each_link, Connection#each_link"
       return Link.wrap(Cproton.pn_link_next(@impl, state_mask))
     end
 
@@ -298,11 +274,10 @@ module Qpid::Proton
       self.session.connection
     end
 
-    # Returns the parent delivery.
-    #
-    # @return [Delivery] The delivery.
-    #
+
+    # @deprecated use {Sender#send}
     def delivery(tag)
+      deprecated __method__, "Sender#send"
       Delivery.new(Cproton.pn_delivery(@impl, tag))
     end
 

data/lib/core/listener.rb

@@ -0,0 +1,82 @@
+# 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
+  # A listener for incoming connections.
+  #
+  # Create with {Container#listen} or  {Container#listen_io}.
+  # To control the handler and connection options applied to incoming connections,
+  # pass a {ListenerHandler} on creation.
+  #
+  class Listener
+
+    # Class that handles listener events and provides options for accepted
+    # connections. This class simply returns a fixed set of options for every
+    # connection accepted, but you can subclass and override all of the on_
+    # methods to provide more interesting behaviour.
+    class Handler
+      # @param opts [Hash] Options to return from on_accept.
+      def initialize(opts=nil) @opts = opts || {}; end
+
+      # Called when the listener is ready to accept connections.
+      # @param listener [Listener] The listener
+      def on_open(listener) end
+
+      # Called if an error occurs.
+      # If there is an error while opening the listener, this method is
+      # called and {#on_open} is not
+      # @param listener [Listener]
+      # @param what [Condition] Information about the error.
+      def on_error(listener, what) end
+
+      # Called when a listener accepts a new connection.
+      # @param listener [Listener] The listener
+      # @return [Hash] Options to apply to the incoming connection, see {#connect}
+      def on_accept(listener) @opts; end
+
+      # Called when the listener closes.
+      # @param listener [Listener] The listener accepting the connection.
+      def on_close(listener) end
+    end
+
+    # @return [Container] The listener's container
+    attr_reader :container
+
+    # @return [Condition] The error condition if there is one
+    attr_reader :condition
+
+    # Close the listener
+    # @param error [Condition] Optional error condition.
+    def close(error=nil)
+      @closing = true
+      @condition ||= Condition.convert error
+      @io.close_read rescue nil # Cause listener to wake out of IO.select
+      nil
+    end
+
+    # Get the {IO} server socket used by the listener
+    def to_io() @io; end
+
+    private                     # Called by {Container}
+
+    def initialize(io, handler, container)
+      @io, @handler = io, handler
+      @container = container
+    end
+  end
+end

data/lib/core/message.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,77 +14,45 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton
 
-  # A Message represents an addressable quantity of data.
-  #
-  # ==== Message Body
-  #
-  # The message body can be set using the #body= method. The message will
-  # then attempt to determine how exactly to encode the content.
-  #
-  # ==== Examples
+  # Messsage data and headers that can sent or received on a {Link}
   #
-  # To create a message for sending:
+  # {#body} is the main message content.
+  # {#properties} is a {Hash} of extra properties that can be attached to the message.
   #
-  #   # send a simple text message
-  #   msg = Qpid::Proton::Message.new
-  #   msg.body = "STATE: update"
+  # @example Create a message containing a Unicode string
+  #   msg = Qpid::Proton::Message.new "this is a string"
   #
-  #   # send a binary chunk of data
-  #   data = File.binread("/home/qpid/binfile.tar.gz")
+  # @example Create a message containing binary data
   #   msg = Qpid::Proton::Message.new
-  #   msg.body = Qpid::Proton::BinaryString.new(data)
+  #   msg.body = Qpid::Proton::BinaryString.new(File.binread("/home/qpid/binfile.tar.gz"))
   #
   class Message
+    include Util::Deprecation
 
     # @private
-    def proton_send(sender, tag = nil)
-      dlv = sender.delivery(tag || sender.delivery_tag)
-      encoded = self.encode
-      sender.stream(encoded)
-      sender.advance
-      dlv.settle if sender.snd_settle_mode == Link::SND_SETTLED
-      return dlv
-    end
+    PROTON_METHOD_PREFIX = "pn_message"
+    # @private
+    include Util::Wrapper
 
-    # Decodes a message from supplied AMQP data and returns the number
-    # of bytes consumed.
-    #
-    # ==== Options
-    #
-    # * encoded - the encoded data
-    #
+    # Decodes a message from AMQP binary data.
+    # @param encoded [String] the encoded bytes
+    # @return[Integer] the number of bytes consumed
     def decode(encoded)
       check(Cproton.pn_message_decode(@impl, encoded, encoded.length))
-
       post_decode
     end
 
-    def post_decode # :nodoc:
+    # @private
+    def post_decode
       # decode elements from the message
-      @properties = {}
-      props = Codec::Data.new(Cproton::pn_message_properties(@impl))
-      if props.next
-        @properties = props.type.get(props)
-      end
-      @instructions = nil
-      insts = Codec::Data.new(Cproton::pn_message_instructions(@impl))
-      if insts.next
-        @instructions = insts.type.get(insts)
-      end
-      @annotations = nil
-      annts = Codec::Data.new(Cproton::pn_message_annotations(@impl))
-      if annts.next
-        @annotations = annts.type.get(annts)
-      end
-      @body = nil
-      body = Codec::Data.new(Cproton::pn_message_body(@impl))
-      if body.next
-        @body = body.type.get(body)
-      end
+      @properties = Codec::Data.to_object(Cproton::pn_message_properties(@impl)) || {}
+      @instructions = Codec:: Data.to_object(Cproton::pn_message_instructions(@impl)) || {}
+      @annotations = Codec::Data.to_object(Cproton::pn_message_annotations(@impl)) || {}
+      @body = Codec::Data.to_object(Cproton::pn_message_body(@impl))
     end
 
     # Encodes the message.
@@ -103,47 +70,38 @@ module Qpid::Proton
       end
     end
 
-    def pre_encode # :nodoc:
+    # @private
+    def pre_encode
       # encode elements from the message
-      props = Codec::Data.new(Cproton::pn_message_properties(@impl))
-      props.clear
-      Codec::Mapping.for_class(@properties.class).put(props, @properties) unless @properties.empty?
-      insts = Codec::Data.new(Cproton::pn_message_instructions(@impl))
-      insts.clear
-      if !@instructions.nil?
-        mapping = Codec::Mapping.for_class(@instructions.class)
-        mapping.put(insts, @instructions)
-      end
-      annts = Codec::Data.new(Cproton::pn_message_annotations(@impl))
-      annts.clear
-      if !@annotations.nil?
-        mapping = Codec::Mapping.for_class(@annotations.class)
-        mapping.put(annts, @annotations, :keys => :SYMBOL)
-      end
-      body = Codec::Data.new(Cproton::pn_message_body(@impl))
-      body.clear
-      if !@body.nil?
-        mapping = Codec::Mapping.for_class(@body.class)
-        mapping.put(body, @body)
+      Codec::Data.from_object(Cproton::pn_message_properties(@impl),
+                              !@properties.empty? && Types.symbol_keys!(@properties))
+      Codec::Data.from_object(Cproton::pn_message_instructions(@impl),
+                              !@instructions.empty? && Types.symbol_keys!(@instructions))
+      if @annotations           # Make sure keys are symbols
+        @annotations.keys.each do |k|
+          @annotations[k.to_sym] = @annotations.delete(k) unless k.is_a? Symbol
+        end
       end
+      Codec::Data.from_object(Cproton::pn_message_annotations(@impl), !@annotations.empty? && @annotations)
+      Codec::Data.from_object(Cproton::pn_message_body(@impl), @body)
     end
 
     # Creates a new +Message+ instance.
-    def initialize(body = nil)
+    # @param body the body of the message, equivalent to calling m.body=(body)
+    # @param opts [Hash] additional options, equivalent to +Message#key=value+ for each +key=>value+
+    def initialize(body = nil, opts={})
       @impl = Cproton.pn_message
       ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
       @properties = {}
       @instructions = {}
       @annotations = {}
       self.body = body unless body.nil?
-    end
-
-    def to_s
-      tmp = Cproton.pn_string("")
-      Cproton.pn_inspect(@impl, tmp)
-      result = Cproton.pn_string_get(tmp)
-      Cproton.pn_free(tmp)
-      return result
+      if !opts.nil? then
+        opts.each do |k, v|
+          setter = (k.to_s+"=").to_sym()
+          self.send setter, v
+        end
+      end
     end
 
     # Invoked by garbage collection to clean up resources used
@@ -409,11 +367,13 @@ module Qpid::Proton
 
     # @deprecated use {#body=}
     def content=(content)
+      deprecated __method__, "body="
       Cproton.pn_message_load(@impl, content)
     end
 
     # @deprecated use {#body}
     def content
+      deprecated __method__, "body"
       size = 16
       loop do
         result = Cproton.pn_message_save(@impl, size)
@@ -529,88 +489,32 @@ module Qpid::Proton
       Cproton.pn_message_get_reply_to_group_id(@impl)
     end
 
-    # Returns the list of property names for associated with this message.
-    #
-    # ==== Examples
-    #
-    #   msg.properties.each do |name|
-    #   end
-    #
-    def properties
-      @properties
-    end
-
-    # Replaces the entire set of properties with the specified hash.
-    #
-    def properties=(properties)
-      @properties = properties
-    end
+    # @return [Hash] Application properties for the message
+    attr_accessor :properties
 
-    # Assigns the value given to the named property.
-    #
-    # ==== Arguments
-    #
-    # * name - the property name
-    # * value - the property value
-    #
-    def []=(name, value)
-      @properties[name] = value
-    end
+    # Equivalent to +{#properties}[name] = value+
+    def []=(name, value) @properties[name] = value; end
 
-    # Retrieves the value for the specified property name. If not found, then
-    # it returns nil.
-    #
-    def [](name)
-      @properties[name]
-    end
+    # Equivalent to +{#properties}[name]+
+    def [](name) @properties[name]; end
 
-    # Deletes the named property.
-    #
-    def delete_property(name)
-      @properties.delete(name)
-    end
+    # Equivalent to +{#properties}.delete(name)+
+    def delete_property(name) @properties.delete(name); end
 
-    # Returns the instructions for this message.
-    #
-    def instructions
-      @instructions
-    end
-
-    # Assigns instructions to this message.
-    #
-    def instructions=(instr)
-      @instructions = instr
-    end
-
-    # Returns the annotations for this message.
-    #
-    def annotations
-      @annotations
-    end
+    # @return [Hash] Delivery instructions for this message.
+    attr_accessor :instructions
 
-    # Assigns annotations to this message.
-    #
-    def annotations=(annotations)
-      @annotations = annotations
-    end
+    # @return [Hash] Delivery annotations for this message.
+    attr_accessor :annotations
 
-    # Returns the body property of the message.
-    #
-    def body
-      @body
-    end
-
-    # Assigns a new value to the body of the message.
-    #
-    def body=(body)
-      @body = body
-    end
+    # @return [Object] body of the message.
+    attr_accessor :body
 
     private
 
     def check(err) # :nodoc:
       if err < 0
-        raise DataError, "[#{err}]: #{Cproton.pn_message_error(@data)}"
+        raise TypeError, "[#{err}]: #{Cproton.pn_message_error(@data)}"
       else
         return err
       end