qpid_proton 0.4 → 0.5

data/lib/qpid_proton/described.rb

@@ -0,0 +1,66 @@
+#
+# 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 # :nodoc:
+
+  module Proton # :nodoc:
+
+    class Described
+
+      attr_reader :descriptor
+      attr_reader :value
+
+      def initialize(descriptor, value)
+        @descriptor = descriptor
+        @value = value
+      end
+
+      # Puts the description into the Data object.
+      #
+      # ==== Arguments
+      #
+      # * data - the Qpid::Proton::Data instance
+      #
+      # ==== Examples
+      #
+      #   described = Qpid::Proton::Described.new("my-descriptor", "the value")
+      #   data = Qpid::Proton::Data.new
+      #   ...
+      #   described.put(data)
+      #
+      def put(data)
+        data.symbol = @descriptor
+        data.string = @value
+      end
+
+      def ==(that) # :nodoc:
+        (that.is_a?(Qpid::Proton::Described) &&
+         (self.descriptor == that.descriptor) &&
+         (self.value == that.value))
+      end
+
+      def to_s # :nodoc:
+        "descriptor=#{descriptor} value=#{value}"
+      end
+
+    end
+
+  end
+
+end

data/lib/qpid_proton/exception_handling.rb

@@ -54,6 +54,9 @@ module Qpid
         when Qpid::Proton::Error::TIMEOUT
           raise Qpid::Proton::TimeoutError.new(self.error)
 
+        when Qpid::Proton::Error::INPROGRESS
+          return
+
         else
 
           raise ::ArgumentError.new("Unknown error code: #{code}")

data/lib/qpid_proton/exceptions.rb

@@ -31,6 +31,7 @@ module Qpid
       STATE = Cproton::PN_STATE_ERR
       ARGUMENT = Cproton::PN_ARG_ERR
       TIMEOUT = Cproton::PN_TIMEOUT
+      INPROGRESS = Cproton::PN_INPROGRESS
 
     end
 

data/lib/qpid_proton/hash.rb

@@ -0,0 +1,86 @@
+#
+# 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.
+#
+
+#--
+# Patch the Hash class to provide methods for adding its contents
+# to a Qpid::Proton::Data instance.
+#++
+
+class Hash
+
+  # Places the contents of the hash into the specified data object.
+  #
+  # ==== Arguments
+  #
+  # * data - the Qpid::Proton::Data instance
+  #
+  # ==== Examples
+  #
+  #   data = Qpid::Proton::Data.new
+  #   values = {:foo => :bar}
+  #   values.proton_data_put(data)
+  #
+  def proton_data_put(data)
+    raise TypeError, "data object cannot be nil" if data.nil?
+
+    data.put_map
+    data.enter
+
+    each_pair do |key, value|
+      type = Qpid::Proton::Mapping.for_class(key.class)
+      type.put(data, key)
+      type = Qpid::Proton::Mapping.for_class(value.class)
+      type.put(data, value)
+    end
+
+    data.exit
+  end
+
+  class << self
+
+    def proton_data_get(data)
+      raise TypeError, "data object cannot be nil" if data.nil?
+
+      type = data.type
+
+      raise TypeError, "element is not a map" unless type == Qpid::Proton::MAP
+
+      count = data.map
+      result = {}
+
+      data.enter
+
+      (0...(count/2)).each do
+        data.next
+        type = data.type
+        key = type.get(data)
+        data.next
+        type = data.type
+        value = type.get(data)
+        result[key] = value
+      end
+
+      data.exit
+
+      return result
+    end
+
+  end
+
+end

data/lib/qpid_proton/mapping.rb

@@ -0,0 +1,142 @@
+#
+# 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 # :nodoc:
+
+  module Proton # :nodoc:
+
+    # Maps between Proton types and their Ruby native language counterparts.
+    #
+    class Mapping
+
+      attr_reader :code
+      attr_reader :put_method
+      attr_reader :get_method
+
+      # Creates a new mapping.
+      #
+      # ==== Arguments
+      #
+      # * code    - the AMQP code for this type
+      # * name    - the AMQP name for this type
+      # * klasses - the Ruby classes for this 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?
+          end
+        end
+
+        @put_method = (name + "=").intern
+
+        if getter.nil?
+          @get_method = name.intern
+        else
+          @get_method = getter.intern
+        end
+      end
+
+      def to_s; @name; end
+
+      def put(data, value)
+        data.send(@put_method, value)
+      end
+
+      def get(data)
+        data.send(@get_method)
+      end
+
+      def self.for_class(klass) # :nodoc:
+        @@by_class[klass]
+      end
+
+      def self.for_code(code)
+        @@by_code["#{code}"]
+      end
+
+    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", [Fixnum, Bignum])
+    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])
+
+    class << STRING
+      def put(data, value)
+        data.string = value.to_s
+      end
+    end
+
+    SYMBOL     = Mapping.new(Cproton::PN_SYMBOL, "symbol")
+    DESCRIBED  = Mapping.new(Cproton::PN_DESCRIBED, "described", [Qpid::Proton::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")
+
+    class << MAP
+      def put(data, map)
+        data.put_map
+        data.enter
+        map.each_pair do |key, value|
+          Mapping.for_class(key.class).put(data, key)
+
+          if value.nil?
+            data.null
+          else
+            Mapping.for_class(value.class).put(data, value)
+          end
+        end
+        data.exit
+      end
+    end
+
+  end
+
+end

data/lib/qpid_proton/message.rb

@@ -27,10 +27,99 @@ module Qpid
     #
     class Message
 
+      # Decodes a message from supplied AMQP data and returns the number
+      # of bytes consumed.
+      #
+      # ==== Options
+      #
+      # * encoded - the encoded data
+      #
+      def decode(encoded)
+        check(Cproton.pn_message_decode(@impl, encoded, encoded.length))
+
+        post_decode
+      end
+
+      def post_decode # :nodoc:
+        # decode elements from the message
+        @properties = {}
+        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
+        if props.next
+          @properties = props.type.get(props)
+        end
+        @instructions = nil
+        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
+        if insts.next
+          @instructions = insts.type.get(insts)
+        end
+        @annotations = nil
+        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
+        if annts.next
+          @annotations = annts.type.get(annts)
+        end
+        @body = nil
+        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
+        if body.next
+          @body = body.type.get(body)
+        end
+      end
+
+      # Encodes the message.
+      def encode
+        pre_encode
+        size = 16
+        loop do
+          error, data = Cproton::pn_message_encode(@impl, size)
+          if error == Qpid::Proton::Error::OVERFLOW
+            size *= 2
+          else
+            check(error)
+            return data
+          end
+        end
+      end
+
+      def pre_encode # :nodoc:
+        # encode elements from the message
+        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
+        props.clear
+        Qpid::Proton::Mapping.for_class(@properties.class).put(props, @properties) unless @properties.empty?
+        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
+        insts.clear
+        if !@instructions.nil?
+          mapping = Qpid::Proton::Mapping.for_class(@instructions.class)
+          mapping.put(insts, @instructions)
+        end
+        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
+        annts.clear
+        if !@annotations.nil?
+          mapping = Qpid::Proton::Mapping.for_class(@annotations.class)
+          mapping.put(annts, @annotations)
+        end
+        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
+        body.clear
+        if !@body.nil?
+          mapping = Qpid::Proton::Mapping.for_class(@body.class)
+          mapping.put(body, @body)
+        end
+      end
+
       # Creates a new +Message+ instance.
       def initialize
         @impl = Cproton.pn_message
         ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
+        @properties = {}
+        @instructions = {}
+        @annotations = {}
+        @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
       end
 
       # Invoked by garbage collection to clean up resources used
@@ -51,6 +140,10 @@ module Qpid
       #
       def clear
         Cproton.pn_message_clear(@impl)
+        @properties.clear unless @properties.nil?
+        @instructions.clear unless @instructions.nil?
+        @annotations.clear unless @annotations.nil?
+        @body = nil
       end
 
       # Returns the most recent error number.
@@ -62,7 +155,7 @@ module Qpid
       # Returns the most recent error message.
       #
       def error
-        Cproton.pn_message_error(@impl)
+        Cproton.pn_error_text(Cproton.pn_message_error(@impl))
       end
 
       # Returns whether there is currently an error reported.
@@ -427,6 +520,92 @@ module Qpid
         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
+
+      # Assigns the value given to the named property.
+      #
+      # ==== Arguments
+      #
+      # * name - the property name
+      # * value - the property 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
+
+      # Deletes the named property.
+      #
+      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
+
+      # Assigns annotations to this message.
+      #
+      def annotations=(annotations)
+        @annotations = annotations
+      end
+
+      # 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
+
+      private
+
+      def check(err) # :nodoc:
+        if err < 0
+          raise DataError, "[#{err}]: #{Cproton.pn_message_error(@data)}"
+        else
+          return err
+        end
+      end
     end
 
   end