qpid_proton 0.9.0 → 0.10

data/lib/{qpid_proton → core}/exceptions.rb

@@ -17,9 +17,9 @@
 # under the License.
 #++
 
-module Qpid # :nodoc:
+module Qpid
 
-  module Proton # :nodoc:
+  module Proton
 
     module Error
 
@@ -80,6 +80,47 @@ module Qpid # :nodoc:
     class InProgressError < ProtonError
     end
 
+    # Raised by instances of Transport.
+    #
+    class TransportError < ProtonError
+    end
+
+    # Raised by instances of SASL
+    #
+    class SASLError < TransportError
+    end
+
+    # Raised by Session.
+    #
+    class SessionError < ProtonError
+    end
+
+    # Raised when an attempt is made to change an attribute that is read-only.
+    #
+    class AttributeError < ProtonError
+    end
+
+    # Raised by link components.
+    #
+    class LinkError < ProtonError
+    end
+
+    class SSLError < TransportError
+    end
+
+    class SSLUnavailableError < SSLError
+    end
+
+    # Raised when a message is rejected.
+    #
+    class Reject < ProtonError
+    end
+
+    # Raised when a message is released.
+    #
+    class Release < ProtonError
+    end
+
   end
 
 end

data/lib/core/link.rb

@@ -0,0 +1,387 @@
+#--
+# 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
+
+  # The base for both Sender and Receiver, providing common functionality
+  # between both ends.
+  #
+  # A Link has a single parent Qpid::Proton::Session instance.
+  #
+  class Link < Endpoint
+
+    # The sender will send all deliveries initially unsettled.
+    SND_UNSETTLED = Cproton::PN_SND_UNSETTLED
+    # The sender will send all deliveries settled to the receiver.
+    SND_SETTLED = Cproton::PN_SND_SETTLED
+    # The sender may send a mixture of settled and unsettled deliveries.
+    SND_MIXED = Cproton::PN_SND_MIXED
+
+    # The receiver will settle deliveries regardless of what the sender does.
+    RCV_FIRST = Cproton::PN_RCV_FIRST
+    # 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
+    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
+
+    # @!method detach
+    #
+    # Detaches the link.
+    proton_caller :detach
+
+    # Advance the current delivery to the next on the link.
+    #
+    # For sending links, this operation is used to finish sending message data
+    # for the current outgoing delivery and move on to the next outgoing
+    # delivery (if any).
+    #
+    # For receiving links, this operatoin is used to finish accessing message
+    # data from the current incoming delivery and move on to the next incoming
+    # delivery (if any).
+    #
+    # @return [Boolean] True if the current delivery was changed.
+    #
+    # @see #current
+    #
+    proton_caller :advance
+
+    proton_caller :unsettled
+
+    # @!attribute [r] credit
+    #
+    # Returns the credit balance for a link.
+    #
+    # Links use a credit based flow control scheme. Every receiver maintains a
+    # credit balance that corresponds to the number of deliveries that the
+    # receiver can accept at any given moment.
+    #
+    # As more capacity becomes available at the receiver, it adds credit to this
+    # balance and communicates the new balance to the sender. Whenever a
+    # delivery is sent/received, the credit balance maintained by the link is
+    # decremented by one.
+    #
+    # Once the credit balance at the sender reaches zero, the sender must pause
+    # sending until more credit is obtained from the receiver.
+    #
+    # NOte that a sending link may still be used to send deliveries eve if
+    # credit reaches zero. However those deliveries will end up being buffer by
+    # the link until enough credit is obtained from the receiver to send them
+    # over the wire. In this case the balance reported will go negative.
+    #
+    # @return [Fixnum] The credit balance.
+    #
+    # @see #flow
+    #
+    proton_caller :credit
+
+    # @!attribute [r] remote_credit
+    #
+    # Returns the remote view of the credit.
+    #
+    # The remote view of the credit for a link differs from the local view of
+    # credit for a link by the number of queued deliveries. In other words,
+    # remote credit is defined as credit - queued.
+    #
+    # @see #queued
+    # @see #credit
+    #
+    # @return [Fixnum] The remove view of the credit.
+    #
+    proton_caller :remote_credit
+
+    # @!attribute [r] available
+    #
+    # Returns the available deliveries hint for a link.
+    #
+    # The available count for a link provides a hint as to the number of
+    # deliveries that might be able to be sent if sufficient credit were issued
+    # by the receiving link endpoint.
+    #
+    # @return [Fixnum] The available deliveries hint.
+    #
+    # @see Sender#offered
+    #
+    proton_caller :available
+
+    # @!attribute [r] queued
+    #
+    # Returns the number of queued deliveries for a link.
+    #
+    # Links may queue deliveries for a number of reasons. For example, there may
+    # be insufficient credit to send them to the receiver, or they simply may
+    # not have yet had a chance to be written to the wire.
+    #
+    # @return [Fixnum] The number of queued deliveries.
+    #
+    # @see #credit
+    #
+    proton_caller :queued
+
+    # @!attribute [r] name
+    #
+    # Returns the name of the link.
+    #
+    # @return [String] The name.
+    #
+    proton_caller :name
+
+    # @!attribute [r] sender?
+    #
+    # Returns if the link is a sender.
+    #
+    # @return [Boolean] True if the link is a sender.
+    #
+    proton_reader  :sender, :is_or_get => :is
+
+    # @!attribute [r] receiver?
+    #
+    # Returns if the link is a receiver.
+    #
+    # @return [Boolean] True if the link is a receiver.
+    #
+    proton_reader  :receiver, :is_or_get => :is
+
+    # @private
+    proton_reader :attachments
+
+    # Drains excess credit.
+    #
+    # When a link is in drain mode, the sender must use all excess credit
+    # immediately and release any excess credit back to the receiver if there
+    # are no deliveries available to send.
+    #
+    # When invoked on a Sender that is in drain mode, this operation will
+    # release all excess credit back to the receiver and return the number of
+    # credits released back to the sender. If the link is not in drain mode,
+    # this operation is a noop.
+    #
+    # When invoked on a Receiver, this operation will return and reset the
+    # number of credits the sender has released back to it.
+    #
+    # @return [Fixnum] The number of credits drained.
+    #
+    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
+    end
+
+    # @private
+    def initialize(impl)
+      @impl = impl
+      self.class.store_instance(self, :pn_link_attachments)
+    end
+
+    # Returns additional error information.
+    #
+    # Whenever a link operation fails (i.e., returns an error code) additional
+    # error details can be obtained from this method. Ther error object that is
+    # returned may also be used to clear the error condition.
+    #
+    # @return [Error] The error.
+    #
+    def error
+      Cproton.pn_link_error(@impl)
+    end
+
+    # Returns the next link that matches the given state mask.
+    #
+    # @param state_mask [Fixnum] The state mask.
+    #
+    # @return [Sender, Receiver] The next link.
+    #
+    def next(state_mask)
+      return Link.wrap(Cproton.pn_link_next(@impl, state_mask))
+    end
+
+    # Returns the locally defined source terminus.
+    #
+    # @return [Terminus] The terminus
+    def source
+      Terminus.new(Cproton.pn_link_source(@impl))
+    end
+
+    # Returns the locally defined target terminus.
+    #
+    # @return [Terminus] The terminus.
+    #
+    def target
+      Terminus.new(Cproton.pn_link_target(@impl))
+    end
+
+    # Returns a representation of the remotely defined source terminus.
+    #
+    # @return [Terminus] The terminus.
+    #
+    def remote_source
+      Terminus.new(Cproton.pn_link_remote_source(@impl))
+    end
+
+    # Returns a representation of the remotely defined target terminus.
+    #
+    # @return [Terminus] The terminus.
+    #
+    def remote_target
+      Terminus.new(Cproton.pn_link_remote_target(@impl))
+    end
+
+    # Returns the parent session.
+    #
+    # @return [Session] The session.
+    #
+    def session
+      Session.wrap(Cproton.pn_link_session(@impl))
+    end
+
+    # Returns the parent connection.
+    #
+    # @return [Connection] The connection.
+    #
+    def connection
+      self.session.connection
+    end
+
+    # Returns the parent delivery.
+    #
+    # @return [Delivery] The delivery.
+    #
+    def delivery(tag)
+      Delivery.new(Cproton.pn_delivery(@impl, tag))
+    end
+
+    # Returns the current delivery.
+    #
+    # Each link maintains a sequence of deliveries in the order they were
+    # created, along with a reference to the *current* delivery. All send and
+    # receive operations on a link take place on the *current* delivery. If a
+    # link has no current delivery, the current delivery is automatically
+    # pointed to the *next* delivery created on the link.
+    #
+    # Once initialized, the current delivery remains the same until it is
+    # changed by advancing, or until it is settled.
+    #
+    # @see #next
+    # @see Delivery#settle
+    #
+    # @return [Delivery] The current delivery.
+    #
+    def current
+      Delivery.wrap(Cproton.pn_link_current(@impl))
+    end
+
+    # Sets the local sender settle mode.
+    #
+    # @param mode [Fixnum] The settle mode.
+    #
+    # @see #SND_UNSETTLED
+    # @see #SND_SETTLED
+    # @see #SND_MIXED
+    #
+    def snd_settle_mode=(mode)
+      Cproton.pn_link_set_snd_settle_mode(@impl, mode)
+    end
+
+    # Returns the local sender settle mode.
+    #
+    # @return [Fixnum] The local sender settle mode.
+    #
+    # @see #snd_settle_mode
+    #
+    def snd_settle_mode
+      Cproton.pn_link_snd_settle_mode(@impl)
+    end
+
+    # Sets the local receiver settle mode.
+    #
+    # @param mode [Fixnum] The settle mode.
+    #
+    # @see #RCV_FIRST
+    # @see #RCV_SECOND
+    #
+    def rcv_settle_mode=(mode)
+      Cproton.pn_link_set_rcv_settle_mode(@impl, mode)
+    end
+
+    # Returns the local receiver settle mode.
+    #
+    # @return [Fixnum] The local receiver settle mode.
+    #
+    def rcv_settle_mode
+      Cproton.pn_link_rcv_settle_mode(@impl)
+    end
+
+    # @private
+    def _local_condition
+      Cproton.pn_link_condition(@impl)
+    end
+
+    # @private
+    def _remote_condition
+      Cproton.pn_link_remote_condition(@impl)
+    end
+
+    def ==(other)
+      other.respond_to?(:impl) &&
+      (Cproton.pni_address_of(other.impl) == Cproton.pni_address_of(@impl))
+    end
+
+  end
+
+end

data/lib/core/message.rb

@@ -0,0 +1,633 @@
+#--
+# 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 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
+  #
+  # To create a message for sending:
+  #
+  #   # send a simple text message
+  #   msg = Qpid::Proton::Message.new
+  #   msg.body = "STATE: update"
+  #
+  #   # send a binary chunk of data
+  #   data = File.binread("/home/qpid/binfile.tar.gz")
+  #   msg = Qpid::Proton::Message.new
+  #   msg.body = Qpid::Proton::BinaryString.new(data)
+  #
+  class Message
+
+    # @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
+
+    # 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 = 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
+    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 = 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)
+      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
+    # by the underlying message implementation.
+    def self.finalize!(impl) # :nodoc:
+      proc {
+        Cproton.pn_message_free(impl)
+      }
+    end
+
+    # Returns the underlying message implementation.
+    def impl # :nodoc:
+      @impl
+    end
+
+    # Clears the state of the +Message+. This allows a single instance of
+    # +Message+ to be reused.
+    #
+    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.
+    #
+    def errno
+      Cproton.pn_message_errno(@impl)
+    end
+
+    # Returns the most recent error message.
+    #
+    def error
+      Cproton.pn_error_text(Cproton.pn_message_error(@impl))
+    end
+
+    # Returns whether there is currently an error reported.
+    #
+    def error?
+      !Cproton.pn_message_errno(@impl).zero?
+    end
+
+    # Sets the durable flag.
+    #
+    # See ::durable for more details on message durability.
+    #
+    # ==== Options
+    #
+    # * state - the durable state
+    #
+    def durable=(state)
+      raise TypeError.new("state cannot be nil") if state.nil?
+      Cproton.pn_message_set_durable(@impl, state)
+    end
+
+    # Returns the durable property.
+    #
+    # The durable property indicates that the emessage should be held durably
+    # by any intermediaries taking responsibility for the message.
+    #
+    # ==== Examples
+    #
+    #  msg = Qpid::Proton::Message.new
+    #  msg.durable = true
+    #
+    def durable
+      Cproton.pn_message_is_durable(@impl)
+    end
+
+    # Sets the priority.
+    #
+    # +NOTE:+ Priority values are limited to the range [0,255].
+    #
+    # ==== Options
+    #
+    # * priority - the priority value
+    #
+    def priority=(priority)
+      raise TypeError.new("invalid priority: #{priority}") if priority.nil? || !([Float, Fixnum].include?(priority.class))
+      raise RangeError.new("priority out of range: #{priority}") if ((priority > 255) || (priority < 0))
+      Cproton.pn_message_set_priority(@impl, priority.floor)
+    end
+
+    # Returns the priority.
+    #
+    def priority
+      Cproton.pn_message_get_priority(@impl)
+    end
+
+    # Sets the time-to-live for the message.
+    #
+    # ==== Options
+    #
+    # * time - the time in milliseconds
+    #
+    def ttl=(time)
+      raise TypeError.new("invalid ttl: #{time}") if time.nil? || !([Float, Fixnum].include?(time.class))
+      raise RangeError.new("time out of range: #{time}") if ((time < 0))
+      Cproton.pn_message_set_ttl(@impl, time.floor)
+    end
+
+    # Returns the time-to-live, in milliseconds.
+    #
+    def ttl
+      Cproton.pn_message_get_ttl(@impl)
+    end
+
+    # Sets whether this is the first time the message was acquired.
+    #
+    # See ::first_acquirer? for more details.
+    #
+    # ==== Options
+    #
+    # * state - true if claiming the message
+    #
+    def first_acquirer=(state)
+      raise TypeError.new("invalid state: #{state}") if state.nil? || !([TrueClass, FalseClass].include?(state.class))
+      Cproton.pn_message_set_first_acquirer(@impl, state)
+    end
+
+    # Sets the delivery count for the message.
+    #
+    # See ::delivery_count for more details.
+    #
+    # ==== Options
+    #
+    # * count - the delivery count
+    #
+    def delivery_count=(count)
+      raise ::ArgumentError.new("invalid count: #{count}") if count.nil? || !([Float, Fixnum].include?(count.class))
+      raise RangeError.new("count out of range: #{count}") if count < 0
+
+      Cproton.pn_message_set_delivery_count(@impl, count.floor)
+    end
+
+    # Returns the delivery count for the message.
+    #
+    # This is the number of delivery attempts for the given message.
+    #
+    def delivery_count
+      Cproton.pn_message_get_delivery_count(@impl)
+    end
+
+    # Returns whether this is the first acquirer.
+    #
+    #
+    def first_acquirer?
+      Cproton.pn_message_is_first_acquirer(@impl)
+    end
+
+    # Sets the message id.
+    #
+    # ==== Options
+    #
+    # * id = the id
+    #
+    def id=(id)
+      Cproton.pn_message_set_id(@impl, id)
+    end
+
+    # Returns the message id.
+    #
+    def id
+      Cproton.pn_message_get_id(@impl)
+    end
+
+    # Sets the user id.
+    #
+    # ==== Options
+    #
+    # * id - the user id
+    #
+    def user_id=(id)
+      Cproton.pn_message_set_user_id(@impl, id)
+    end
+
+    # Returns the user id.
+    #
+    def user_id
+      Cproton.pn_message_get_user_id(@impl)
+    end
+
+    # Sets the destination address.
+    #
+    # ==== Options
+    #
+    # * address - the address
+    #
+    def address=(address)
+      Cproton.pn_message_set_address(@impl, address)
+    end
+
+    # Returns the destination address.
+    #
+    def address
+      Cproton.pn_message_get_address(@impl)
+    end
+
+    # Sets the subject.
+    #
+    # ==== Options
+    #
+    # * subject - the subject
+    #
+    def subject=(subject)
+      Cproton.pn_message_set_subject(@impl, subject)
+    end
+
+    # Returns the subject
+    #
+    def subject
+      Cproton.pn_message_get_subject(@impl)
+    end
+
+    # Sets the reply-to address.
+    #
+    # ==== Options
+    #
+    # * address - the reply-to address
+    #
+    def reply_to=(address)
+      Cproton.pn_message_set_reply_to(@impl, address)
+    end
+
+    # Returns the reply-to address
+    #
+    def reply_to
+      Cproton.pn_message_get_reply_to(@impl)
+    end
+
+    # Sets the correlation id.
+    #
+    # ==== Options
+    #
+    # * id - the correlation id
+    #
+    def correlation_id=(id)
+      Cproton.pn_message_set_correlation_id(@impl, id)
+    end
+
+    # Returns the correlation id.
+    #
+    def correlation_id
+      Cproton.pn_message_get_correlation_id(@impl)
+    end
+
+    # Sets the content type.
+    #
+    # ==== Options
+    #
+    # * content_type - the content type
+    #
+    def content_type=(content_type)
+      Cproton.pn_message_set_content_type(@impl, content_type)
+    end
+
+    # Returns the content type
+    #
+    def content_type
+      Cproton.pn_message_get_content_type(@impl)
+    end
+
+    # Sets the message content.
+    #
+    # *WARNING:* This method has been deprecated. Please use #body= instead to
+    # set the content of a message.
+    #
+    # ==== Options
+    #
+    # * content - the content
+    #
+    def content=(content)
+      Cproton.pn_message_load(@impl, content)
+    end
+
+    # Returns the message content.
+    #
+    # *WARNING:* This method has been deprecated. Please use #body instead to
+    # retrieve the content of a message.
+    #
+    def content
+      size = 16
+      loop do
+        result = Cproton.pn_message_save(@impl, size)
+        error = result[0]
+        data = result[1]
+        if error == Qpid::Proton::Error::OVERFLOW
+          size = size * 2
+        else
+          check(error)
+          return data
+        end
+      end
+    end
+
+    # Sets the content encoding type.
+    #
+    # ==== Options
+    #
+    # * encoding - the content encoding
+    #
+    def content_encoding=(encoding)
+      Cproton.pn_message_set_content_encoding(@impl, encoding)
+    end
+
+    # Returns the content encoding type.
+    #
+    def content_encoding
+      Cproton.pn_message_get_content_encoding(@impl)
+    end
+
+    # Sets the expiration time.
+    #
+    # ==== Options
+    #
+    # * time - the expiry time
+    #
+    def expires=(time)
+      raise TypeError.new("invalid expiry time: #{time}") if time.nil?
+      raise ::ArgumentError.new("expiry time cannot be negative: #{time}") if time < 0
+      Cproton.pn_message_set_expiry_time(@impl, time)
+    end
+
+    # Returns the expiration time.
+    #
+    def expires
+      Cproton.pn_message_get_expiry_time(@impl)
+    end
+
+    # Sets the creation time.
+    #
+    # ==== Options
+    #
+    # * time - the creation time
+    #
+    def creation_time=(time)
+      raise TypeError.new("invalid time: #{time}") if time.nil?
+      raise ::ArgumentError.new("time cannot be negative") if time < 0
+      Cproton.pn_message_set_creation_time(@impl, time)
+    end
+
+    # Returns the creation time.
+    #
+    def creation_time
+      Cproton.pn_message_get_creation_time(@impl)
+    end
+
+    # Sets the group id.
+    #
+    # ==== Options
+    #
+    # * id - the group id
+    #
+    def group_id=(id)
+      Cproton.pn_message_set_group_id(@impl, id)
+    end
+
+    # Returns the group id.
+    #
+    def group_id
+      Cproton.pn_message_get_group_id(@impl)
+    end
+
+    # Sets the group sequence number.
+    #
+    # ==== Options
+    #
+    # * seq - the sequence number
+    #
+    def group_sequence=(seq)
+      raise TypeError.new("invalid seq: #{seq}") if seq.nil?
+      Cproton.pn_message_set_group_sequence(@impl, seq)
+    end
+
+    # Returns the group sequence number.
+    #
+    def group_sequence
+      Cproton.pn_message_get_group_sequence(@impl)
+    end
+
+    # Sets the reply-to group id.
+    #
+    # ==== Options
+    #
+    # * id - the id
+    #
+    def reply_to_group_id=(id)
+      Cproton.pn_message_set_reply_to_group_id(@impl, id)
+    end
+
+    # Returns the reply-to group id.
+    #
+    def reply_to_group_id
+      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