qpid_proton 0.18.1 → 0.19.0

data/lib/core/endpoint.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
 
@@ -31,6 +30,7 @@ module Qpid::Proton
   #   puts "Remote connection flags: #{conn.state || Qpid::Proton::Endpoint::REMOTE_MASK}"
   #
   class Endpoint
+    include Util::Deprecation
 
     # The local connection is uninitialized.
     LOCAL_UNINIT = Cproton::PN_LOCAL_UNINIT
@@ -47,32 +47,17 @@ module Qpid::Proton
     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
+    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
+    REMOTE_MASK = Cproton::PN_REMOTE_UNINIT | Cproton::PN_REMOTE_ACTIVE | Cproton::PN_REMOTE_CLOSED
 
     # @private
-    include Util::Engine
-
+    def condition; remote_condition || local_condition; end
     # @private
-    def initialize
-      @condition = nil
-    end
-
+    def remote_condition; Condition.convert(_remote_condition); end
     # @private
-    def _update_condition
-      object_to_condition(@condition, self._local_condition)
-    end
-
-    # @private
-    def remote_condition
-      condition_to_object(self._remote_condition)
-    end
+    def local_condition; Condition.convert(_local_condition); end
 
     # Return the transport associated with this endpoint.
     #
@@ -82,11 +67,21 @@ module Qpid::Proton
       self.connection.transport
     end
 
+    # @private
+    # @return [Bool] true if {#state} has all the bits of `mask` set
+    def check_state(mask) (self.state & mask) == mask; end
+
+    # @return [Bool] true if endpoint has sent and received a CLOSE frame
+    def closed?() check_state(LOCAL_CLOSED | REMOTE_CLOSED); end
+
+    # @return [Bool] true if endpoint has sent and received an OPEN frame
+    def open?() check_state(LOCAL_ACTIVE | REMOTE_ACTIVE); end
+
     def local_uninit?
       check_state(LOCAL_UNINIT)
     end
 
-    def local_active?
+    def local_open?
       check_state(LOCAL_ACTIVE)
     end
 
@@ -98,7 +93,7 @@ module Qpid::Proton
       check_state(REMOTE_UNINIT)
     end
 
-    def remote_active?
+    def remote_open?
       check_state(REMOTE_ACTIVE)
     end
 
@@ -106,35 +101,8 @@ module Qpid::Proton
       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
+    alias local_active? local_open?
+    alias remote_active? remote_open?
 
   end
-
 end

data/lib/core/event.rb

@@ -0,0 +1,156 @@
+# 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
+
+  # @deprecated Only used with the deprecated {Handler::MessagingHandler} API.
+  class Event
+    private
+    include Util::Deprecation
+
+    PROTON_METHOD_PREFIX = "pn_disposition"
+    include Util::Wrapper
+
+    EVENT_TYPE_NAMES = [:PN_EVENT_NONE,
+                        :PN_CONNECTION_INIT,
+                        :PN_CONNECTION_BOUND,
+                        :PN_CONNECTION_UNBOUND,
+                        :PN_CONNECTION_LOCAL_OPEN,
+                        :PN_CONNECTION_REMOTE_OPEN,
+                        :PN_CONNECTION_LOCAL_CLOSE,
+                        :PN_CONNECTION_REMOTE_CLOSE,
+                        :PN_CONNECTION_FINAL,
+                        :PN_SESSION_INIT,
+                        :PN_SESSION_LOCAL_OPEN,
+                        :PN_SESSION_REMOTE_OPEN,
+                        :PN_SESSION_LOCAL_CLOSE,
+                        :PN_SESSION_REMOTE_CLOSE,
+                        :PN_SESSION_FINAL,
+                        :PN_LINK_INIT,
+                        :PN_LINK_LOCAL_OPEN,
+                        :PN_LINK_REMOTE_OPEN,
+                        :PN_LINK_LOCAL_CLOSE,
+                        :PN_LINK_REMOTE_CLOSE,
+                        :PN_LINK_LOCAL_DETACH,
+                        :PN_LINK_REMOTE_DETACH,
+                        :PN_LINK_FLOW,
+                        :PN_LINK_FINAL,
+                        :PN_DELIVERY,
+                        :PN_TRANSPORT,
+                        :PN_TRANSPORT_AUTHENTICATED,
+                        :PN_TRANSPORT_ERROR,
+                        :PN_TRANSPORT_HEAD_CLOSED,
+                        :PN_TRANSPORT_TAIL_CLOSED,
+                        :PN_TRANSPORT_CLOSED]
+
+    TYPE_METHODS = EVENT_TYPE_NAMES.each_with_object({}) do |n, h|
+      type = Cproton.const_get(n)
+      h[type] = "on_#{Cproton.pn_event_type_name(type)[3..-1]}".downcase.to_sym
+    end
+
+    # Use Event.new(impl) to wrap a C event, or Event.new(nil, method, context)
+    # to create a pure-ruby event.
+    def initialize(impl, method=nil, context=nil)
+      @impl, @method, @context = impl, method, context
+      @method ||= TYPE_METHODS[Cproton.pn_event_type(@impl)] if @impl
+    end
+
+    # Get the context if it is_a?(clazz), else call method on the context
+    def get(clazz, method=nil)
+      (ctx = context).is_a?(clazz) ? ctx : ctx.__send__(method) rescue nil
+    end
+
+    def _context
+      x = Cproton.pn_event_context(@impl)
+      case Cproton.pn_class_id(Cproton.pn_event_class(@impl))
+      when Cproton::CID_pn_transport then Transport.wrap(Cproton.pn_cast_pn_transport(x))
+      when Cproton::CID_pn_connection then Connection.wrap(Cproton.pn_cast_pn_connection(x))
+      when Cproton::CID_pn_session then Session.wrap(Cproton.pn_cast_pn_session(x))
+      when Cproton::CID_pn_link then Link.wrap(Cproton.pn_cast_pn_link(x))
+      when Cproton::CID_pn_delivery then Delivery.wrap(Cproton.pn_cast_pn_delivery(x))
+      end
+    end
+
+    public
+
+    # Call handler.{#method}(self) if handler.respond_to? {#method}
+    # @return [Boolean] true if handler responded to the method, nil if not.
+    def dispatch(handler)
+      (handler.__send__(@method, self); true) if handler.respond_to? @method
+    end
+
+    # @return [Symbol] method name that this event will call in {#dispatch}
+    attr_accessor :method
+
+    alias type method
+
+    # @return [Object] the event context object
+    def context; return @context ||= _context; end
+
+    # @return [Container, nil] container for this event
+    def container() @container ||= get(Container, :container); end
+
+    # @return [Transport, nil] transport for this event
+    def transport() @transport ||= get(Transport, :transport); end
+
+    # @return [Connection, nil] the connection for this event
+    def connection() @connection ||= get(Connection, :connection); end
+
+    # @return [Session, nil] session for this event
+    def session() @session ||= get(Session, :session); end
+
+    # @return [Link, nil] link for this event
+    def link() @link ||= get(Link, :link); end
+
+    # @return [Sender, nil] sender associated with this event
+    def sender() link if link && link.sender?; end
+
+    # @return [Receiver, nil] receiver associated with this event
+    def receiver() link if link && link.receiver?; end
+
+    # @return [Delivery, nil] delivery for this event
+    def delivery()
+      @delivery ||= case context
+                    when Delivery then @delivery = @context
+                      # deprecated: for backwards compat allow a Tracker to be treated as a Delivery
+                    when Tracker then @delivery = Delivery.new(context.impl)
+                    end
+    end
+
+    # @return [Tracker, nil] delivery for this event
+    def tracker() @tracker ||= get(Tracker); end
+
+    # @return [Message, nil] message for this event
+    def message() @message ||= delivery.message if delivery; end
+
+    def to_s() "#{self.class}(#{method}, #{context})"; end
+    def inspect() "#{self.class}(#{method.inspect}, #{context.inspect})"; end
+
+    # @return [Condition] Error condition associated with this event or nil if none.
+    def condition
+      (context.remote_condition if context.respond_to? :remote_condition) ||
+        (context.condition if context.respond_to? :condition)
+    end
+
+    # @deprecated use {#container}
+    deprecated_alias :reactor, :container
+
+    # @private
+    Event = self
+  end
+end

data/lib/core/exceptions.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,112 +14,116 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
-
-module Qpid
-
-  module Proton
-
-    module Error
-
-      NONE = 0
-      EOS = Cproton::PN_EOS
-      ERROR = Cproton::PN_ERR
-      OVERFLOW = Cproton::PN_OVERFLOW
-      UNDERFLOW = Cproton::PN_UNDERFLOW
-      STATE = Cproton::PN_STATE_ERR
-      ARGUMENT = Cproton::PN_ARG_ERR
-      TIMEOUT = Cproton::PN_TIMEOUT
-      INTERRUPTED = Cproton::PN_INTR
-      INPROGRESS = Cproton::PN_INPROGRESS
-
-    end
-
-    # Represents a generic error at the messaging level.
-    #
-    class ProtonError < RuntimeError
-    end
-
-    # Represents an end-of-stream error while messaging.
-    #
-    class EOSError < ProtonError
-    end
-
-    # Represents a data overflow exception while messaging.
-    #
-    class OverflowError < ProtonError
-    end
-
-    # Represents a data underflow exception while messaging.
-    #
-    class UnderflowError < ProtonError
-    end
-
-    # Represents an invalid, missing or illegal argument while messaging.
-    #
-    class ArgumentError < ProtonError
-    end
-
-    # Represents that the client has got into an unexpected state during
-    # messaging.
-    #
-    class StateError < ProtonError
-    end
-
-    # Represents a timeout during messaging.
-    #
-    class TimeoutError < ProtonError
-    end
-
-    # Represents an interrupting during a blocking I/O operation.
-    #
-    class InterruptedError < ProtonError
-    end
-
-    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
 
+
+module Qpid::Proton
+
+  # @private
+  module Error
+    NONE = 0
+    EOS = Cproton::PN_EOS
+    ERROR = Cproton::PN_ERR
+    OVERFLOW = Cproton::PN_OVERFLOW
+    UNDERFLOW = Cproton::PN_UNDERFLOW
+    STATE = Cproton::PN_STATE_ERR
+    ARGUMENT = Cproton::PN_ARG_ERR
+    TIMEOUT = Cproton::PN_TIMEOUT
+    INTERRUPTED = Cproton::PN_INTR
+    INPROGRESS = Cproton::PN_INPROGRESS
+  end
+
+  # Represents a generic error at the messaging level.
+  #
+  class ProtonError < RuntimeError
+  end
+
+  # Represents an end-of-stream error while messaging.
+  #
+  class EOSError < ProtonError
+  end
+
+  # Represents a data overflow exception while messaging.
+  #
+  class OverflowError < ProtonError
+  end
+
+  # Represents a data underflow exception while messaging.
+  #
+  class UnderflowError < ProtonError
+  end
+
+  # Represents an invalid, missing or illegal argument while messaging.
+  #
+  class ArgumentError < ProtonError
+  end
+
+  # Represents that the client has got into an unexpected state during
+  # messaging.
+  #
+  class StateError < ProtonError
+  end
+
+  # Represents a timeout during messaging.
+  #
+  class TimeoutError < ProtonError
+  end
+
+  # Represents an interrupting during a blocking I/O operation.
+  #
+  class InterruptedError < ProtonError
+  end
+
+  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
+
+  # Raised when a message is aborted by the sender.
+  #
+  class AbortedError < ProtonError
+  end
+
+  # Raised to stop an automatic response to an endpoint open/close,
+  # so that the application can delay completing the open/close to a later time.
+  class StopAutoResponse < ProtonError
+  end
 end