qpid_proton 0.9.0 → 0.10

data/lib/util/condition.rb

@@ -0,0 +1,45 @@
+#--
+# 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::Util
+
+  class Condition
+
+    def initialize(name, description = nil, info = nil)
+      @name = name
+      @description = description
+      @info = info
+    end
+
+    # @private
+    def to_s
+      "Condition(#{@name}, #{@description}, #{@info})"
+    end
+
+    # @private
+    def ==(other)
+      ((other.class = self.class) &&
+       (other.name == self.name) && 
+       (other.description == self.description) &&
+       (other.info == self.info))
+    end
+
+  end
+
+end

data/lib/util/constants.rb

@@ -0,0 +1,85 @@
+#--
+# 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::Util
+
+  # Provides a means for defining constant values within the namespace
+  # of a class.
+  #
+  # If the class has defined the class method, :post_add_constant, then that
+  # method will be invoked after each new item is added. It must be defined
+  # *before* any constants are defined.
+  #
+  # ==== Example
+  #
+  #   class GrammarComponent
+  #
+  #     include Qpid::Proton::Constants
+  #
+  #     def self.post_add_constant(key, value)
+  #       @terminal << value if value.terminal?
+  #       @nonterminal << value if !value.terminal? && !value.rule
+  #       @rule << value if value.rule
+  #     end
+  #
+  #     self.add_constant :LEFT_PARENTHESIS, new GrammarComponent("(", :terminal)
+  #     self.add_constant :RIGHT_PARENTHESIS, new GrammarComponent(")", :terminal)
+  #     self.add_constant :ELEMENT, new GrammarComponent("E", :rule)
+  #
+  #     def initialize(component, type)
+  #       @component = component
+  #       @type = type
+  #     end
+  #
+  #     def terminal?; @type == :terminal; end
+  #
+  #     def rule?; @type == :rule; end
+  #
+  #   end
+  #
+  # @private
+  #
+  module Constants
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def add_constant(key, value)
+        self.const_set(key, value)
+
+        @pn_by_value ||= {}
+        @pn_by_value[value] = key
+
+        if self.respond_to? :post_add_constant
+          self.post_add_constant(key, value)
+        end
+      end
+
+      def by_value(value)
+        (@pn_by_value || {})[value]
+      end
+
+    end
+
+  end
+
+end

data/lib/util/engine.rb

@@ -0,0 +1,82 @@
+#--
+# 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::Util
+
+  # @private
+  module Engine
+
+    # Convenience method to receive messages from a delivery.
+    #
+    # @param delivery [Qpid::Proton::Delivery] The delivery.
+    # @param message [Qpid::Proton::Message] The message to use.
+    #
+    # @return [Qpid::Proton::Message] the message
+    #
+    def self.receive_message(delivery, msg = nil)
+      msg = Qpid::Proton::Message.new if msg.nil?
+      msg.decode(delivery.link.receive(delivery.pending))
+      delivery.link.advance
+      return msg
+    end
+
+    def data_to_object(data_impl) # :nodoc:
+      object = nil
+      unless data_impl.nil?
+        data = Qpid::Proton::Codec::Data.new(data_impl)
+        data.rewind
+        data.next
+        object = data.object
+        data.rewind
+      end
+      return object
+    end
+
+    def object_to_data(object, data_impl) # :nodoc:
+      unless object.nil?
+        data = Data.new(data_impl)
+        data.object = object
+      end
+    end
+
+    def condition_to_object(condition) # :nodoc:
+      result = nil
+      if Cproton.pn_condition_is_set(condition)
+        result = Condition.new(Cproton.pn_condition_get_name(condition),
+                               Cproton.pn_condition_get_description(condition),
+                               data_to_object(Cproton.pn_condition_info(condition)))
+      end
+      return result
+    end
+
+    def object_to_condition(object, condition) # :nodoc:
+      Cproton.pn_condition_clear(condition)
+      unless object.nil?
+        Cproton.pn_condition_set_name(condition, object.name)
+        Cproton.pn_condition_set_description(condition, object.description)
+        info = Data.new(Cproton.pn_condition_info(condition))
+        if object.info?
+          info.object = object.info
+        end
+      end
+    end
+
+  end
+
+end

data/lib/util/error_handler.rb

@@ -0,0 +1,127 @@
+#--
+# 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::Util
+
+  # Provides mixin functionality for dealing with exception conditions.
+  #
+  # @private
+  module ErrorHandler
+
+    def self.included(base)
+      base.extend(self)
+
+      unless defined? base.to_be_wrapped
+        class << base
+          @@to_be_wrapped = []
+        end
+      end
+
+      define_method :method_added do |name|
+        if (!@@to_be_wrapped.nil?) && (@@to_be_wrapped.include? name)
+          @@to_be_wrapped.delete name
+          create_exception_handler_wrapper(name)
+        end
+      end
+    end
+
+    def can_raise_error(method_names, options = {})
+      error_class = options[:error_class]
+      below = options[:below] || 0
+      # coerce the names to be an array
+      Array(method_names).each do |method_name|
+        # if the method doesn't already exist then queue this aliasing
+        unless self.method_defined? method_name
+          @@to_be_wrapped ||= []
+          @@to_be_wrapped << method_name
+        else
+          create_exception_handler_wrapper(method_name, error_class, below)
+        end
+      end
+    end
+
+    def create_exception_handler_wrapper(method_name, error_class = nil, below = 0)
+      original_method_name = method_name.to_s
+      wrapped_method_name = "_excwrap_#{original_method_name}"
+      alias_method wrapped_method_name, original_method_name
+      define_method original_method_name do |*args, &block|
+        # need to get a reference to the method object itself since
+        # calls to Class.send interfere with Messenger.send
+        method = self.method(wrapped_method_name.to_sym)
+        rc = method.call(*args, &block)
+        check_for_error(rc, error_class) if rc < below
+        return rc
+      end
+    end
+
+    # Raises an Proton-specific error if a return code is non-zero.
+    #
+    # Expects the class to provide an +error+ method.
+    def check_for_error(code, error_class = nil)
+
+      raise ::ArgumentError.new("Invalid error code: #{code}") if code.nil?
+
+      return code if code > 0
+
+      case(code)
+
+      when Qpid::Proton::Error::NONE
+        return
+
+      when Qpid::Proton::Error::EOS
+        raise Qpid::Proton::EOSError.new(self.error)
+
+      when Qpid::Proton::Error::ERROR
+        raise Qpid::Proton::ProtonError.new(self.error)
+
+      when Qpid::Proton::Error::OVERFLOW
+        raise Qpid::Proton::OverflowError.new(self.error)
+
+      when Qpid::Proton::Error::UNDERFLOW
+        raise Qpid::Proton::UnderflowError.new(self.error)
+
+      when Qpid::Proton::Error::ARGUMENT
+        raise Qpid::Proton::ArgumentError.new(self.error)
+
+      when Qpid::Proton::Error::STATE
+        raise Qpid::Proton::StateError.new(self.error)
+
+      when Qpid::Proton::Error::TIMEOUT
+        raise Qpid::Proton::TimeoutError.new(self.error)
+
+      when Qpid::Proton::Error::INPROGRESS
+        return
+
+      when Qpid::Proton::Error::INTERRUPTED
+        raise Qpid::Proton::InterruptedError.new(self.error)
+
+      when Qpid::Proton::Error::INPROGRESS
+        raise Qpid::Proton::InProgressError.new(self.error)
+
+      else
+
+        raise ::ArgumentError.new("Unknown error code: #{code}")
+
+      end
+
+    end
+
+  end
+
+end

data/lib/util/handler.rb

@@ -0,0 +1,41 @@
+#--
+# 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::Util
+
+  # @private
+  module Handler
+
+    def chandler(handler, on_error)
+      return nil if handler.nil?
+
+      if handler.instance_of?(Qpid::Proton::Handler::WrappedHandler)
+        impl = handler.impl
+        Cproton.pn_incref(impl)
+        return impl
+      else
+        cadaptor = Qpid::Proton::Handler::CAdaptor.new(handler, on_error)
+        rbhandler = Cproton.pn_rbhandler(cadaptor)
+        return rbhandler
+      end
+    end
+
+  end
+
+end

data/lib/util/reactor.rb

@@ -0,0 +1,32 @@
+#--
+# 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::Util
+
+  module Reactor
+
+    def create_session(connection, handler = nil)
+      session = connection.session
+      session.open
+      return session
+    end
+
+  end
+
+end

data/lib/util/swig_helper.rb

@@ -0,0 +1,114 @@
+#--
+# 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::Util
+
+  # Provides helper functions for writing wrapper functions for the
+  # underlying C APIs.
+  #
+  # Before defining any mutators the class must define the name of the
+  # prefix for methods with the constant PROTON_METOD_PREFIX.
+  #
+  # == Mutators, Setters And Getters
+  #
+  # There are three types of wrappers that are supported:
+  #
+  # [proton_writer] Defines a set-only method for the named attribute.
+  # [proton_reader] Defines a get-only method for the named attribute.
+  # [proton_accessor] Defines both a set- and a get-method for the named
+  #                  attribute.
+  # [proton_caller] A simple wrapper for calling an underlying method,
+  #                  avoids repetitive boiler plate coding.
+  #
+  # == Arguments
+  #
+  # [:is_or_get => {:is, :get}] For both the getter and the mutator types
+  # you can also declare that the method uses "is" instead of "get" in the
+  # underlying API. Such methods are then defined with "?"
+  #
+  # @example
+  #   class Terminus
+  #
+  #     include WrapperHelper
+  #
+  #     PROTON_METHOD_PREFIX = "pn_terminus"
+  #
+  #     # add methods "type" and "type=" that call "pn_terminus_{get,set}_type"
+  #     proton_accessor :type
+  #
+  #     # adds the method "dynamic?" that calls "pn_terminus_is_dynamic"
+  #     proton_accessor :dynamic, :is_or_get => :is
+  #
+  #     # adds a method named "foo" that calls "pn_terminus_foo"
+  #     proton_caller :foo
+  #
+  #   end
+  #
+  # @private
+  module SwigHelper
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods # :nodoc:
+
+      def create_wrapper_method(name, proton_method, with_arg = false)
+        if with_arg
+          define_method "#{name}" do |arg|
+            Cproton.__send__(proton_method.to_sym, @impl, arg)
+          end
+        else
+          define_method "#{name}" do
+            Cproton.__send__(proton_method.to_sym, @impl)
+          end
+        end
+      end
+
+      # Defines a method that calls an underlying C library function.
+      def proton_caller(name, options = {})
+        proton_method = "#{self::PROTON_METHOD_PREFIX}_#{name}"
+        # drop the trailing '?' if this is a property method
+        proton_method = proton_method[0..-2] if proton_method.end_with? "?"
+        create_wrapper_method(name, proton_method)
+      end
+
+      def proton_writer(name, options = {})
+        proton_method = "#{self::PROTON_METHOD_PREFIX}_set_#{name}"
+        create_wrapper_method("#{name}=", proton_method, true)
+      end
+
+      def proton_reader(name, options = {})
+        an_is_method = options[:is_or_get] == :is
+        prefix = (an_is_method) ? "is" : "get"
+        proton_method = "#{self::PROTON_METHOD_PREFIX}_#{prefix}_#{name}"
+        name = "#{name}?" if an_is_method
+        create_wrapper_method(name, proton_method)
+      end
+
+      def proton_accessor(name, options = {})
+        proton_writer(name, options)
+        proton_reader(name, options)
+      end
+
+    end
+
+  end
+
+end