qpid_proton 0.9.0 → 0.10

data/lib/core/delivery.rb

@@ -0,0 +1,271 @@
+#--
+# 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 Delivery maintains detail on the delivery of data to an endpoint.
+  #
+  # A Delivery has a single parent Qpid::Proton::Link
+  #
+  # @example
+  #
+  #   # SCENARIO: An event comes in notifying that data has been delivered to
+  #   #           the local endpoint. A Delivery object can be used to check
+  #   #           the details of the delivery.
+  #
+  #   delivery = @event.delivery
+  #   if delivery.readable? && !delivery.partial?
+  #     # decode the incoming message
+  #     msg = Qpid::Proton::Message.new
+  #     msg.decode(link.receive(delivery.pending))
+  #   end
+  #
+  class Delivery
+
+    # @private
+    include Util::Wrapper
+
+    # @private
+    def self.wrap(impl) # :nodoc:
+      return nil if impl.nil?
+      self.fetch_instance(impl, :pn_delivery_attachments) || Delivery.new(impl)
+    end
+
+    # @private
+    def initialize(impl)
+      @impl = impl
+      @local = Disposition.new(Cproton.pn_delivery_local(impl), true)
+      @remote = Disposition.new(Cproton.pn_delivery_remote(impl), false)
+      self.class.store_instance(self, :pn_delivery_attachments)
+    end
+
+    # @private
+    include Util::SwigHelper
+
+    # @private
+    PROTON_METHOD_PREFIX = "pn_delivery"
+
+    # @!attribute [r] tag
+    #
+    # @return [String] The tag for the delivery.
+    #
+    proton_caller :tag
+
+    # @!attribute [r] writable?
+    #
+    # A delivery is considered writable if it is the current delivery on an
+    # outgoing link, and the link has positive credit.
+    #
+    # @return [Boolean] Returns if a delivery is writable.
+    #
+    proton_caller :writable?
+
+    # @!attribute [r] readable?
+    #
+    # A delivery is considered readable if it is the current delivery on an
+    # incoming link.
+    #
+    # @return [Boolean] Returns if a delivery is readable.
+    #
+    proton_caller :readable?
+    # @!attribute [r] updated?
+    #
+    # A delivery is considered updated whenever the peer communicates a new
+    # disposition for the dlievery. Once a delivery becomes updated, it will
+    # remain so until cleared.
+    #
+    # @return [Boolean] Returns if a delivery is updated.
+    #
+    # @see #clear
+    #
+    proton_caller :updated?
+
+    # @!method clear
+    #
+    # Clear the updated flag for a delivery.
+    #
+    proton_caller :clear
+
+    # @!attribute [r] pending
+    #
+    # @return [Fixnum] Return the amount of pending message data for the
+    # delivery.
+    #
+    proton_caller :pending
+
+    # @!attribute [r] partial?
+    #
+    # @return [Boolean] Returns if the delivery has only partial message data.
+    #
+    proton_caller :partial?
+
+    # @!attribute [r] settled?
+    #
+    # @return [Boolean] Returns if the delivery is remotely settled.
+    #
+    proton_caller :settled?
+
+
+    # @!method settle
+    #
+    # Settles a delivery.
+    #
+    #  A settled delivery can never be used again.
+    #
+    proton_caller :settle
+
+    # @!method dump
+    #
+    #  Utility function for printing details of a delivery.
+    #
+    proton_caller :dump
+
+    # @!attribute [r] buffered?
+    #
+    # A delivery that is buffered has not yet been written to the wire.
+    #
+    # Note that returning false does not imply that a delivery was definitely
+    # written to the wire. If false is returned, it is not known whether the
+    # delivery was actually written to the wire or not.
+    #
+    # @return [Boolean] Returns if the delivery is buffered.
+    #
+    proton_caller :buffered?
+
+    include Util::Engine
+
+    def update(state)
+      impl = @local.impl
+      object_to_data(@local.data, Cproton.pn_disposition_data(impl))
+      object_to_data(@local.annotations, Cproton.pn_disposition_annotations(impl))
+      object_to_data(@local.condition, Cproton.pn_disposition_condition(impl))
+      Cproton.pn_delivery_update(@impl, state)
+    end
+
+    # Returns the local disposition state for the delivery.
+    #
+    # @return [Disposition] The local disposition state.
+    #
+    def local_state
+      Cproton.pn_delivery_local_state(@impl)
+    end
+
+    # Returns the remote disposition state for the delivery.
+    #
+    # @return [Disposition] The remote disposition state.
+    #
+    def remote_state
+      Cproton.pn_delivery_remote_state(@impl)
+    end
+
+    # Returns the next delivery on the connection that has pending operations.
+    #
+    # @return [Delivery, nil] The next delivery, or nil if there are none.
+    #
+    # @see Connection#work_head
+    #
+    def work_next
+      Delivery.wrap(Cproton.pn_work_next(@impl))
+    end
+
+    # Returns the parent link.
+    #
+    # @return [Link] The parent link.
+    #
+    def link
+      Link.wrap(Cproton.pn_delivery_link(@impl))
+    end
+
+    # Returns the parent session.
+    #
+    # @return [Session] The session.
+    #
+    def session
+      self.link.session
+    end
+
+    # Returns the parent connection.
+    #
+    # @return [Connection] The connection.
+    #
+    def connection
+      self.session.connection
+    end
+
+    # Returns the parent transport.
+    #
+    # @return [Transport] The transport.
+    #
+    def transport
+      self.connection.transport
+    end
+
+    # @private
+    def local_received?
+      self.local_state == Disposition::RECEIVED
+    end
+
+    # @private
+    def remote_received?
+      self.remote_state == Disposition::RECEIVED
+    end
+
+    # @private
+    def local_accepted?
+      self.local_state == Disposition::ACCEPTED
+    end
+
+    # @private
+    def remote_accepted?
+      self.remote_state == Disposition::ACCEPTED
+    end
+
+    # @private
+    def local_rejected?
+      self.local_state == Disposition::REJECTED
+    end
+
+    # @private
+    def remote_rejected?
+      self.remote_state == Disposition::REJECTED
+    end
+
+    # @private
+    def local_released?
+      self.local_state == Disposition::RELEASED
+    end
+
+    # @private
+    def remote_released?
+      self.remote_state == Disposition::RELEASED
+    end
+
+    # @private
+    def local_modified?
+      self.local_state == Disposition::MODIFIED
+    end
+
+    # @private
+    def remote_modified?
+      self.remote_state == Disposition::MODIFIED
+    end
+
+  end
+
+end

data/lib/core/disposition.rb

@@ -0,0 +1,158 @@
+#--
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#++
+
+module Qpid::Proton
+
+  # Disposition records the current state and/or final outcome of a transfer.
+  #
+  # Every delivery contains both a local and a remote disposition. The local
+  # disposition holds the local state of the delivery, and the remote
+  # disposition holds the *last known* remote state of the delivery.
+  #
+  class Disposition
+
+    include Util::Constants
+
+    # Indicates the delivery was received.
+    self.add_constant(:RECEIVED, Cproton::PN_RECEIVED)
+    # Indicates the delivery was accepted.
+    self.add_constant(:ACCEPTED, Cproton::PN_ACCEPTED)
+    # Indicates the delivery was rejected.
+    self.add_constant(:REJECTED, Cproton::PN_REJECTED)
+    # Indicates the delivery was released.
+    self.add_constant(:RELEASED, Cproton::PN_RELEASED)
+    # Indicates the delivery was modified.
+    self.add_constant(:MODIFIED, Cproton::PN_MODIFIED)
+
+    # @private
+    include Util::Engine
+
+    attr_reader :impl
+
+    # @private
+    def initialize(impl, local)
+      @impl = impl
+      @local = local
+      @data = nil
+      @condition = nil
+      @annotations = nil
+    end
+
+    # @private
+    include Util::SwigHelper
+
+    # @private
+    PROTON_METHOD_PREFIX = "pn_disposition"
+
+    # @!attribute section_number
+    #
+    # @return [Fixnum] The section number of the disposition.
+    #
+    proton_accessor :section_number
+
+    # @!attribute section_offset
+    #
+    #  @return [Fixnum] The section offset of the disposition.
+    #
+    proton_accessor :section_offset
+
+    # @!attribute failed?
+    #
+    # @return [Boolean] The failed flag.
+    #
+    proton_accessor :failed, :is_or_get => :is
+
+    # @!attribute undeliverable?
+    #
+    # @return [Boolean] The undeliverable flag.
+    #
+    proton_accessor :undeliverable, :is_or_get => :is
+
+    # Sets the data for the disposition.
+    #
+    # @param data [Codec::Data] The data.
+    #
+    # @raise [AttributeError] If the disposition is remote.
+    #
+    def data=(data)
+      raise AttributeError.new("data attribute is read-only") unless @local
+      @data = data
+    end
+
+    # Returns the data for the disposition.
+    #
+    # @return [Codec::Data] The data.
+    #
+    def data
+      if @local
+        @data
+      else
+        data_to_object(Cproton.pn_disposition_data(@impl))
+      end
+    end
+
+    # Sets the annotations for the disposition.
+    #
+    # @param annotations [Codec::Data] The annotations.
+    #
+    # @raise [AttributeError] If the disposition is remote.
+    #
+    def annotations=(annotations)
+      raise AttributeError.new("annotations attribute is read-only") unless @local
+      @annotations = annotations
+    end
+
+    # Returns the annotations for the disposition.
+    #
+    # @return [Codec::Data] The annotations.
+    #
+    def annotations
+      if @local
+        @annotations
+      else
+        data_to_object(Cproton.pn_disposition_annotations(@impl))
+      end
+    end
+
+    # Sets the condition for the disposition.
+    #
+    # @param condition [Codec::Data] The condition.
+    #
+    # @raise [AttributeError] If the disposition is remote.
+    #
+    def condition=(condition)
+      raise AttributeError.new("condition attribute is read-only") unless @local
+      @condition = condition
+    end
+
+    # Returns the condition of the disposition.
+    #
+    # @return [Codec::Data] The condition of the disposition.
+    #
+    def condition
+      if @local
+        @condition
+      else
+        condition_to_object(Cproton.pn_disposition_condition(@impl))
+      end
+    end
+
+  end
+
+end

data/lib/core/endpoint.rb

@@ -0,0 +1,140 @@
+#--
+# 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
+
+  # Endpoint is the parent classes for Link and Session.
+  #
+  # It provides a namespace for constant values that relate to the current
+  # state of both links and sessions.
+  #
+  # @example
+  #
+  #   conn = Qpid::Proton::Connection.new
+  #   puts "Local connection flags : #{conn.state || Qpid::Proton::Endpoint::LOCAL_MASK}"
+  #   puts "Remote connection flags: #{conn.state || Qpid::Proton::Endpoint::REMOTE_MASK}"
+  #
+  class Endpoint
+
+    # The local connection is uninitialized.
+    LOCAL_UNINIT = Cproton::PN_LOCAL_UNINIT
+    # The local connection is active.
+    LOCAL_ACTIVE = Cproton::PN_LOCAL_ACTIVE
+    # The local connection is closed.
+    LOCAL_CLOSED = Cproton::PN_LOCAL_CLOSED
+
+    # The remote connection is unitialized.
+    REMOTE_UNINIT = Cproton::PN_REMOTE_UNINIT
+    # The remote connection is active.
+    REMOTE_ACTIVE = Cproton::PN_REMOTE_ACTIVE
+    # The remote connection is closed.
+    REMOTE_CLOSED = Cproton::PN_REMOTE_CLOSED
+
+    # Bitmask for the local-only flags.
+    LOCAL_MASK = Cproton::PN_LOCAL_UNINIT |
+                 Cproton::PN_LOCAL_ACTIVE |
+                 Cproton::PN_LOCAL_CLOSED
+
+    # Bitmask for the remote-only flags.
+    REMOTE_MASK = Cproton::PN_REMOTE_UNINIT |
+                  Cproton::PN_REMOTE_ACTIVE |
+                  Cproton::PN_REMOTE_CLOSED
+
+    # @private
+    include Util::Engine
+
+    # @private
+    def initialize
+      @condition = nil
+    end
+
+    # @private
+    def _update_condition
+      object_to_condition(@condition, self._local_condition)
+    end
+
+    # @private
+    def remote_condition
+      condition_to_object(self._remote_condition)
+    end
+
+    # Return the transport associated with this endpoint.
+    #
+    # @return [Transport] The transport.
+    #
+    def transport
+      self.connection.transport
+    end
+
+    def local_uninit?
+      check_state(LOCAL_UNINIT)
+    end
+
+    def local_active?
+      check_state(LOCAL_ACTIVE)
+    end
+
+    def local_closed?
+      check_state(LOCAL_CLOSED)
+    end
+
+    def remote_uninit?
+      check_state(REMOTE_UNINIT)
+    end
+
+    def remote_active?
+      check_state(REMOTE_ACTIVE)
+    end
+
+    def remote_closed?
+      check_state(REMOTE_CLOSED)
+    end
+
+    def check_state(state_mask)
+      !(self.state & state_mask).zero?
+    end
+
+    def handler
+      reactor = Qpid::Proton::Reactor::Reactor.wrap(Cproton.pn_object_reactor(@impl))
+      if reactor.nil?
+        on_error = nil
+      else
+        on_error = reactor.method(:on_error)
+      end
+      record = self.attachments
+      puts "record=#{record}"
+      WrappedHandler.wrap(Cproton.pn_record_get_handler(record), on_error)
+    end
+
+    def handler=(handler)
+      reactor = Qpid::Proton::Reactor::Reactor.wrap(Cproton.pn_object_reactor(@impl))
+      if reactor.nil?
+        on_error = nil
+      else
+        on_error = reactor.method(:on_error)
+      end
+      impl = chandler(handler, on_error)
+      record = self.attachments
+      Cproton.pn_record_set_handler(record, impl)
+      Cproton.pn_decref(impl)
+    end
+
+  end
+
+end