qpid_proton 0.9.0 → 0.10

data/lib/core/receiver.rb

@@ -0,0 +1,95 @@
+#--
+# 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 receiving endpoint.
+  #
+  # @see Sender
+  #
+  class Receiver < Link
+
+    # @private
+    include Util::SwigHelper
+
+    # @private
+    PROTON_METHOD_PREFIX = "pn_link"
+
+    # @!attribute drain
+    #
+    # The drain mode.
+    #
+    # If a receiver is in drain mode, then the sending endpoint of a link must
+    # immediately use up all available credit on the link. If this is not
+    # possible, the excess credit must be returned by invoking #drained.
+    #
+    # Only the receiving endpoint can set the drain mode.
+    #
+    # @return [Boolean] True if drain mode is set.
+    #
+    proton_accessor :drain
+
+    # @!attribute [r] draining?
+    #
+    # Returns if a link is currently draining.
+    #
+    # A link is defined to be draining when drain mode is set to true and
+    # the sender still has excess credit.
+    #
+    # @return [Boolean] True if the receiver is currently draining.
+    #
+    proton_caller :draining?
+
+    # Grants credit for incoming deliveries.
+    #
+    # @param n [Fixnum] The amount to increment the link credit.
+    #
+    def flow(n)
+      Cproton.pn_link_flow(@impl, n)
+    end
+
+    # Allows receiving up to the specified limit of data from the remote
+    # endpoint.
+    #
+    # Note that large messages can be streamed across the network, so just
+    # because there is no data to read does not imply the message is complete.
+    #
+    # To ensure the entirety of the message data has been read, either call
+    # #receive until nil is returned, or verify that #partial? is false and
+    # Delivery#pending is 0.
+    #
+    # @param limit [Fixnum] The maximum bytes to receive.
+    #
+    # @return [Fixnum, nil] The number of bytes received, or nil if the end of
+    # the stream was reached.t
+    #
+    # @see Deliver#pending To see how much buffer space is needed.
+    #
+    # @raise [LinkError] If an error occurs.
+    #
+    def receive(limit)
+      (n, bytes) = Cproton.pn_link_recv(@impl, limit)
+      return nil if n == Qpid::Proton::Error::EOS
+      raise LinkError.new("[#{n}]: #{Cproton.pn_link_error(@impl)}") if n < 0
+      return bytes
+    end
+
+  end
+
+end

data/lib/core/sasl.rb

@@ -0,0 +1,94 @@
+#--
+# 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 SASL layer is responsible for establishing an authenticated and/or
+  # encrypted tunnel over which AMQP frames are passed between peers.
+  #
+  # The peer acting as the SASL client must provide authentication
+  # credentials.
+  #
+  # The peer acting as the SASL server must provide authentication against the
+  # received credentials.
+  #
+  # @example
+  #   # SCENARIO: the remote endpoint has not initialized their connection
+  #   #           then the local endpoint, acting as a SASL server, decides
+  #   #           to allow an anonymous connection.
+  #   #
+  #   #           The SASL layer locally assumes the role of server and then
+  #   #           enables anonymous authentication for the remote endpoint.
+  #   #
+  #   sasl = @transport.sasl
+  #   sasl.server
+  #   sasl.mechanisms("ANONYMOUS")
+  #   sasl.done(Qpid::Proton::SASL::OK)
+  #
+  class SASL
+
+    # Negotation has not completed.
+    NONE = Cproton::PN_SASL_NONE
+    # Authentication succeeded.
+    OK = Cproton::PN_SASL_OK
+    # Authentication failed due to bad credentials.
+    AUTH = Cproton::PN_SASL_AUTH
+
+    # Constructs a new instance for the given transport.
+    #
+    # @param transport [Transport] The transport.
+    #
+    # @private A SASL should be fetched only from its Transport
+    #
+    def initialize(transport)
+      @impl = Cproton.pn_sasl(transport.impl)
+    end
+
+    # Sets the acceptable SASL mechanisms.
+    #
+    # @param mechanisms [String] The space-delimited set of mechanisms.
+    #
+    # @example Use anonymous SASL authentication.
+    #  @sasl.mechanisms("GSSAPI CRAM-MD5 PLAIN")
+    #
+    def mechanisms(mechanisms)
+      Cproton.pn_sasl_mechanisms(@impl, mechanisms)
+    end
+
+    # Returns the outcome of the SASL negotiation.
+    #
+    # @return [Fixnum] The outcome.
+    #
+    def outcome
+      outcome = Cprotn.pn_sasl_outcome(@impl)
+      return nil if outcome == NONE
+      outcome
+    end
+
+    # Set the condition of the SASL negotiation.
+    #
+    # @param outcome [Fixnum] The outcome.
+    #
+    def done(outcome)
+      Cproton.pn_sasl_done(@impl, outcome)
+    end
+
+  end
+
+end

data/lib/core/selectable.rb

@@ -0,0 +1,130 @@
+#--
+# 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
+
+  # Selectable enables accessing the underlying file descriptors
+  # for Messenger.
+  #
+  # @private
+  class Selectable
+
+    # @private
+    include Util::SwigHelper
+
+    # @private
+    PROTON_METHOD_PREFIX = "pn_selectable"
+
+    # Returns the underlying file descriptor.
+    #
+    # This can be used in conjunction with the IO class.
+    #
+    def fileno
+      Cproton.pn_selectable_get_fd(@impl)
+    end
+
+    proton_reader :reading, :is_or_get => :is
+
+    proton_reader :writing, :is_or_get => :is
+
+    proton_caller :readable
+
+    proton_caller :writable
+
+    proton_caller :expired
+
+    proton_accessor :registered, :is_or_get => :is
+
+    proton_accessor :terminal, :is_or_get => :is
+
+    proton_caller :terminate
+
+    proton_caller :release
+
+    # @private
+    def self.wrap(impl)
+      return nil if impl.nil?
+
+      self.fetch_instance(impl, :pn_selectable_attachments) || Selectable.new(impl)
+    end
+
+    # @private
+    include Util::Wrapper
+
+    # @private
+    def initialize(impl)
+      @impl = impl
+      self.class.store_instance(self, :pn_selectable_attachments)
+    end
+
+    private
+
+    DEFAULT = Object.new
+
+    public
+
+    def fileno(fd = DEFAULT)
+      if fd == DEFAULT
+        Cproton.pn_selectable_get_fd(@impl)
+      elsif fd.nil?
+        Cproton.pn_selectable_set_fd(@impl, Cproton::PN_INVALID_SOCKET)
+      else
+        Cproton.pn_selectable_set_fd(@impl, fd)
+      end
+    end
+
+    def reading=(reading)
+      if reading.nil?
+        reading = false
+      elsif reading == "0"
+        reading = false
+      else
+        reading = true
+      end
+      Cproton.pn_selectable_set_reading(@impl, reading ? true : false)
+    end
+
+    def writing=(writing)
+      if writing.nil?
+        writing = false
+      elsif writing == "0"
+        writing = false
+      else
+        writing = true
+      end
+      Cproton.pn_selectable_set_writing(@impl, writing ? true : false)
+    end
+
+    def deadline
+      tstamp = Cproton.pn_selectable_get_deadline(@impl)
+      return nil if tstamp.nil?
+      mills_to_sec(tstamp)
+    end
+
+    def deadline=(deadline)
+      Cproton.pn_selectable_set_deadline(sec_to_millis(deadline))
+    end
+
+    def to_io
+      @io ||= IO.new(fileno)
+    end
+
+  end
+
+end

data/lib/core/sender.rb

@@ -0,0 +1,76 @@
+#--
+# 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 sending endpoint.
+  #
+  # @see Receiver
+  #
+  class Sender < Link
+
+    # @private
+    include Util::ErrorHandler
+
+    # @private
+    can_raise_error :stream, :error_class => Qpid::Proton::LinkError
+
+    # Signals the availability of deliveries.
+    #
+    # @param n [Fixnum] The number of deliveries potentially available.
+    #
+    def offered(n)
+      Cproton.pn_link_offered(@impl, n)
+    end
+
+    # Sends the specified data to the remote endpoint.
+    #
+    # @param object [Object] The content to send.
+    # @param tag [Object] The tag
+    #
+    # @return [Fixnum] The number of bytes sent.
+    #
+    def send(object, tag = nil)
+      if object.respond_to? :proton_send
+        object.proton_send(self, tag)
+      else
+        stream(object)
+      end
+    end
+
+    # Send the specified bytes as part of the current delivery.
+    #
+    # @param bytes [Array] The bytes to send.
+    #
+    # @return n [Fixnum] The number of bytes sent.
+    #
+    def stream(bytes)
+      Cproton.pn_link_send(@impl, bytes)
+    end
+
+    def delivery_tag
+      @tag_count ||= 0
+      result = @tag_count.succ
+      @tag_count = result
+      return "#{result}"
+    end
+
+  end
+
+end

data/lib/core/session.rb

@@ -0,0 +1,163 @@
+#--
+# 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 session is the parent for senders and receivers.
+  #
+  # A Session has a single parent Qpid::Proton::Connection instance.
+  #
+  class Session < Endpoint
+
+    # @private
+    include Util::Wrapper
+
+    # @private
+    include Util::SwigHelper
+
+    # @private
+    PROTON_METHOD_PREFIX = "pn_session"
+
+    # @!attribute incoming_capacity
+    #
+    # The incoming capacity of a session determines how much incoming message
+    # data the session will buffer. Note that if this value is less than the
+    # negotatied frame size of the transport, it will be rounded up to one full
+    # frame.
+    #
+    # @return [Fixnum] The incoing capacity of the session, measured in bytes.
+    #
+    proton_accessor :incoming_capacity
+
+    # @private
+    proton_reader :attachments
+
+    # @!attribute [r] outgoing_bytes
+    #
+    # @return [Fixnum] The number of outgoing bytes currently being buffered.
+    #
+    proton_caller :outgoing_bytes
+
+    # @!attribute [r] incoming_bytes
+    #
+    # @return [Fixnum] The number of incomign bytes currently being buffered.
+    #
+    proton_caller :incoming_bytes
+
+    # @!method open
+    # Opens the session.
+    #
+    # Once this operaton has completed, the state flag is updated.
+    #
+    # @see LOCAL_ACTIVE
+    #
+    proton_caller :open
+
+    # @!attribute [r] state
+    #
+    # @return [Fixnum] The endpoint state.
+    #
+    proton_caller :state
+
+    # @private
+    def self.wrap(impl)
+      return nil if impl.nil?
+      self.fetch_instance(impl, :pn_session_attachments) || Session.new(impl)
+    end
+
+    # @private
+    def initialize(impl)
+      @impl = impl
+      self.class.store_instance(self, :pn_session_attachments)
+    end
+
+    # Closed the session.
+    #
+    # Once this operation has completed, the state flag will be set. This may be
+    # called without calling #open, in which case it is the equivalence of
+    # calling #open and then close immediately.
+    #
+    def close
+      self._update_condition
+      Cproton.pn_session_close(@impl)
+    end
+
+    # Retrieves the next session from a given connection that matches the
+    # specified state mask.
+    #
+    # When uses with Connection#session_head an application can access all of
+    # the session son the connection that match the given state.
+    #
+    # @param state_mask [Fixnum] The state mask to match.
+    #
+    # @return [Session, nil] The next session if one matches, or nil.
+    #
+    def next(state_mask)
+      Session.wrap(Cproton.pn_session_next(@impl, state_mask))
+    end
+
+    # Returns the parent connection.
+    #
+    # @return [Connection] The connection.
+    #
+    def connection
+      Connection.wrap(Cproton.pn_session_connection(@impl))
+    end
+
+    # Constructs a new sender.
+    #
+    # Each sender between two AMQP containers must be uniquely named. Note that
+    # this uniqueness cannot be enforced at the library level, so some
+    # consideration should be taken in choosing link names.
+    #
+    # @param name [String] The link name.
+    #
+    # @return [Sender, nil] The sender, or nil if an error occurred.
+    #
+    def sender(name)
+      Sender.new(Cproton.pn_sender(@impl, name))
+    end
+
+    # Constructs a new receiver.
+    #
+    # Each receiver between two AMQP containers must be uniquely named. Note
+    # that this uniqueness cannot be enforced at the library level, so some
+    # consideration should be taken in choosing link names.
+    #
+    # @param name [String] The link name.
+    #
+    # @return [Receiver, nil] The receiver, or nil if an error occurred.
+    #
+    def receiver(name)
+      Receiver.new(Cproton.pn_receiver(@impl, name))
+    end
+
+    # @private
+    def _local_condition
+      Cproton.pn_session_condition(@impl)
+    end
+
+    # @private
+    def _remote_condition # :nodoc:
+      Cproton.pn_session_remote_condition(@impl)
+    end
+
+  end
+
+end