Merged out from trunkQPID-2519

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/QPID-2519@1187375 13f79535-47bb-0310-9956-ffa450edef68

11 files changed, 995 insertions, 0 deletions

diff --git a/cpp/bindings/qpid/ruby/lib/qpid.rb b/cpp/bindings/qpid/ruby/lib/qpid.rb
new file mode 100644
index 0000000000..1f00c136c1
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid.rb
@@ -0,0 +1,29 @@
+#
+# 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.
+#
+
+require 'qpid/errors'
+require 'qpid/duration'
+require 'qpid/address'
+require 'qpid/encoding'
+require 'qpid/message'
+require 'qpid/sender'
+require 'qpid/receiver'
+require 'qpid/session'
+require 'qpid/connection'
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/address.rb b/cpp/bindings/qpid/ruby/lib/qpid/address.rb
new file mode 100644
index 0000000000..73b61bb1c7
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/address.rb
@@ -0,0 +1,125 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+module Qpid
+
+  module Messaging
+
+    # Address represents an address to which messages can be sent or from
+    # which they can be received.
+    #
+    # An Address can be described using the following pattern:
+    #
+    # <address> [ / <subject> ] ; [ { <key> : <value> , ... } ]
+    #
+    # where *address* is a simple name and *subject* is a subject or subject
+    # pattern.
+    #
+    # The options, enclosed in curly braces, are key:value pairs delimited by
+    # a comma. The values can be nested maps also enclosed in curly braces.
+    # Or they can be lists of values, where they are contained within square
+    # brackets but still comma delimited, such as:
+    #
+    # [value1,value2,value3]
+    #
+    # The following are the list of supported options:
+    #
+    # create:: Indicates if the address should be created; values are *always*,
+    #          *never*, *sender* or *reciever*.
+    #
+    # assert:: Indicates whether or not to assert any specified node properties;
+    #          values are *always*, *never*, *sender* or *receiver*.
+    #
+    # delete:: Indicates whether or not to delete the addressed node when a
+    #          sender or receiver is cancelled; values are *always*, *never*,
+    #          *sender* or *receiver*.
+    #
+    # node:: A nested map describing properties for the addressed node.
+    #        Properties are *type* (*topic* or *queue*), *durable* (a boolean),
+    #        *x-declare* (a nested map of amqp 0.10-specific options) and
+    #        *x-bindings*. (nested list which specifies a queue, exchange or
+    #        a binding key and arguments.
+    #
+    # link:: A nested map through which properties of the link can be specified;
+    #        properties are *durable*, *reliability*, *x-declare*, *x-subscribe*
+    #        and *x-bindings*.
+    #
+    # mode:: (*For receivers only*) indicates whether the receiver should consume
+    #        or browse messages; values are *consume* (the default) and *browse*.
+    class Address
+
+      def initialize(name, subject, options = {}, _type = "", address_impl = nil)
+        @address_impl = address_impl || Cqpid::Address.new(name, subject, convert_options(options), _type)
+      end
+
+       def address_impl # :nodoc:
+         @address_impl
+       end
+
+       # Returns the name.
+      def name; @address_impl.getName; end
+
+      # Sets the name.
+      def name=(name); @address_impl.setName name; end
+
+      # Returns the subject.
+      def subject; @address_impl.getSubject; end
+
+      # Sets the subject.
+      def subject=(subject); @address_impl.setSubject(subject); end
+
+      # Returns the type.
+      #---
+      # We cannot use "type" since that clashes with the Ruby object.type
+      # identifier.
+      def _type; @address_impl.getType; end
+
+      # Sets the type.
+      #
+      # The type of the address determines how Sender and Receiver objects
+      # are constructed for it. If no type is specified then it will be
+      # determined by querying the broker.
+      def _type=(_type); @address_impl.setType(_type); end
+
+      # Returns the options.
+      def options; @address_impl.getOptions; end
+
+      # Sets the options for the address.
+      # Any symbols are converted to strings.
+      def options=(options); @address_impl.setOptions(convert_options(options)); end
+
+      def to_s; @address_impl.str; end
+
+      private
+
+      def convert_options(options)
+        result = {}
+        options.each_pair {|key, value| result[key.to_s] = value.to_s}
+
+        return result
+      end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/connection.rb b/cpp/bindings/qpid/ruby/lib/qpid/connection.rb
new file mode 100644
index 0000000000..5c56c1f5d0
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/connection.rb
@@ -0,0 +1,134 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+module Qpid
+
+  module Messaging
+
+    # Connection allows for establishing connections to a remote endpoint.
+    class Connection
+
+      # The following general options are supported (as strings or symbols):
+      #
+      # username::
+      # password::
+      # heartbeat::
+      # tcp_nodelay::
+      # sasl_mechanism::
+      # sasl_service::
+      # sasl_min_ssf::
+      # sasl_max_ssf::
+      # transport::
+      #
+      # The following options specifically control reconnection behavior:
+      #
+      # reconnect:: *true* or *false*; indicates whether to attempt reconnections
+      # reconnect_timeout:: the number of seconds to attempt reconnecting
+      # reconnect_limit:: the number of retries before reporting failure
+      # reconnect_interval_min:: initial delay, in seconds, before attempting a reconnecting
+      # reconnect_interval_max:: number of seconds to wait before additional reconnect attempts
+      # reconnect_interval:: shorthand for setting box min and max values
+      # reconnect_urls:: a list of alternate URLs to use for reconnection attempts
+      def initialize(url, options = {}, connection_impl = nil)
+        @url = url
+        @connection_impl = connection_impl
+        @options = options
+      end
+
+      def connection_impl # :nodoc:
+        @connection_impl
+      end
+
+      # Opens the connection.
+      def open
+        @connection_impl = Cqpid::Connection.new(@url, convert_options)
+        @connection_impl.open
+      end
+
+      # Reports whether the connection is open.
+      def open?; false || (@connection_impl.isOpen if @connection_impl); end
+
+      # Closes the connection.
+      def close; @connection_impl.close if open?; end
+
+      # Creates a new session.
+      #
+      # If :transactional => true then a transactional session is created.
+      # Otherwise a standard session is created.
+      def create_session(args = {})
+        name = args[:name] || ""
+        if open?
+          if args[:transactional]
+            session = @connection_impl.createTransactionalSession name
+          else
+            session = @connection_impl.createSession name
+          end
+          return Session.new(session)
+        else
+          raise RuntimeError.new "No connection available."
+        end
+      end
+
+      # Returns a session for the specified session name.
+      def session name
+        session_impl = @connection_impl.getSession name
+        Qpid::Messaging::Session.new session_impl if session_impl
+      end
+
+      # Returns the username used to authenticate with the connection.
+      def authenticated_username; @connection_impl.getAuthenticatedUsername if open?; end
+
+      # inherited from Handle
+
+      # Returns whether the underlying handle is valid; i.e., not null.
+      def valid?
+        @connection_impl.isValid
+      end
+
+      # Returns whether the underlying handle is null.
+      def null?
+        @connection_impl.isNull
+      end
+
+      # Swaps the underlying connection handle.
+      def swap connection
+        @connection_impl.swap connection.connection_impl
+      end
+
+      private
+
+      def convert_options
+        result = {}
+        # map only those options defined in the C++ layer
+        # TODO when new options are added, this needs to be updated.
+        unless @options.nil? || @options.empty?
+          @options.each_pair {|key, value| result[key.to_s] = value.to_s}
+        end
+
+        return result
+      end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/duration.rb b/cpp/bindings/qpid/ruby/lib/qpid/duration.rb
new file mode 100644
index 0000000000..c1f44e9281
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/duration.rb
@@ -0,0 +1,63 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+module Qpid
+
+  module Messaging
+
+    # A Duration represents a period of time in milliseconds
+    #
+    # It defines the following named values as symbols:
+    #
+    # :FOREVER :: the maximum integer value for the platform
+    # :IMMEDIATE :: an alias for 0
+    # :SECOND :: 1,000ms
+    # :MINUTE :: 60,000ms
+    class Duration
+
+      def initialize duration # :nodoc:
+        @duration_impl = Cqpid::Duration.new duration
+      end
+
+      def duration_impl # :nodoc:
+        @duration_impl
+      end
+
+      def self.add_item(key, value) # :nodoc:
+        @hash ||= {}
+        @hash[key] = Duration.new value
+      end
+
+      def self.const_missing(key) # :nodoc:
+        @hash[key]
+      end
+
+      self.add_item :FOREVER,   Cqpid::Duration.FOREVER.getMilliseconds
+      self.add_item :IMMEDIATE, Cqpid::Duration.IMMEDIATE.getMilliseconds
+      self.add_item :SECOND,    Cqpid::Duration.SECOND.getMilliseconds
+      self.add_item :MINUTE,    Cqpid::Duration.MINUTE.getMilliseconds
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/encoding.rb b/cpp/bindings/qpid/ruby/lib/qpid/encoding.rb
new file mode 100644
index 0000000000..c8b843b597
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/encoding.rb
@@ -0,0 +1,56 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+module Qpid
+
+  module Messaging
+
+    # Encodes the supplied content into the given message.
+    def self.encode content, message, encoding = nil
+      prepared = content
+      case content
+      when Hash
+        prepared = {}
+        content.each_pair do |key,value|
+          prepared[key.to_s] = value.to_s
+        end
+        Cqpid::encode prepared, message.message_impl
+      when Array
+        prepared = []
+        content.each {|value| prepared << value.to_s}
+        Cqpid::encode prepared, message.message_impl
+      end
+    end
+
+    # Decodes and returns the message's content.
+    def self.decode(message, content_type = nil)
+      content_type = message.content_type unless content_type
+
+      case content_type
+        when "amqp/map":  Cqpid.decodeMap message.message_impl
+        when "amqp/list": Cqpid.decodeList message.message_impl
+      end
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/errors.rb b/cpp/bindings/qpid/ruby/lib/qpid/errors.rb
new file mode 100644
index 0000000000..7a16d08d84
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/errors.rb
@@ -0,0 +1,30 @@
+#
+# 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
+
+  module Messaging
+
+    class KeyError < RuntimeError
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/message.rb b/cpp/bindings/qpid/ruby/lib/qpid/message.rb
new file mode 100644
index 0000000000..9b1b68c7c3
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/message.rb
@@ -0,0 +1,157 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+module Qpid
+
+  module Messaging
+
+    # Message represents a message.
+    class Message
+
+      def initialize(args = {}, message_impl = nil)
+        @message_impl = message_impl
+        @message_impl = Cqpid::Message.new if @message_impl.nil?
+        @message_impl.setContent args[:content].to_s if args[:content]
+        @content = nil
+      end
+
+      def message_impl # :nodoc:
+        @message_impl
+      end
+
+      # Assigns the reply to address.
+      # The address must be an instance of Address.
+      def reply_to=(address); @message_impl.setReplyTo address.address_impl; end
+
+      # Returns the reply to address for the message as an instance of +Address+.
+      def reply_to
+        address_impl = @message_impl.getReplyTo
+        # only return an address if a reply to was specified
+        Qpid::Messaging::Address.new(nil, nil, nil, nil, address_impl) if address_impl
+      end
+
+      # Sets the subject.
+      def subject=(subject); @message_impl.setSubject subject; end
+
+      # Returns the subject.
+      def subject; @message_impl.getSubject; end
+
+      # Sets the content type.
+      def content_type=(content_type); @message_impl.setContentType content_type; end
+
+      # Returns the content type.
+      def content_type; @message_impl.getContentType; end
+
+      # Sets the message id.
+      def message_id=(message_id); @message_impl.setMessageId message_id.to_s; end
+
+      # Returns the message id.
+      def message_id; @message_impl.getMessageId; end
+
+      # Sets the user id.
+      def user_id=(user_id); @message_impl.setUserId user_id; end
+
+      # Returns the user id.
+      def user_id; @message_impl.getUserId; end
+
+      # Sets the correlation id.
+      def correlation_id=(correlation_id); @message_impl.setCorrelationId correlation_id; end
+
+      # Returns the correlation id.
+      def correlation_id; @message_impl.getCorrelationId; end
+
+      # Sets the priority.
+      def priority=(priority); @message_impl.setPriority priority; end
+
+      # Returns the priority.
+      def priority; @message_impl.getPriority; end
+
+      # Sets the time-to-live in milliseconds.
+      def ttl=(duration); @message_impl.setTtl duration; end
+
+      # Returns the time-to-live in milliseconds.
+      def ttl; @message_impl.getTtl; end
+
+      # Sets the durability.
+      def durable=(durable); @message_impl.setDurable durable; end
+
+      # Returns the durability.
+      def durable; @message_impl.getDurable; end
+
+      # Allows marking the message as redelivered.
+      def redelivered=(redelivered); @message_impl.setRedelivered redelivered; end
+
+      # Returns if the message was redelivered.
+      def redelivered; @message_impl.getRedelivered; end
+
+      # Returns all named properties.
+      # *NOTE:* It is recommended to use the +foo[key]+ method for
+      # retrieving properties.
+      def properties; @message_impl.getProperties; end
+
+      # Returns the value for the named property.
+      def [](key); self.properties[key.to_s]; end
+
+      # Assigns a value to the named property.
+      def []=(key, value); @message_impl.setProperty(key.to_s, value.to_s); end
+
+      # Sets the content.
+      def content=(content)
+        content_type = nil
+        @content = content
+        case @content
+        when Hash
+          content_type = "amqp/map"
+        when Array
+          content_type = "amqp/list"
+        end
+        if content_type.nil?
+          @message_impl.setContent @content
+        else
+          Qpid::Messaging.encode @content, self, content_type
+        end
+      end
+
+      # Returns the content.
+      def content
+        if @content.nil?
+          @content = @message_impl.getContent
+
+          # decode the content is necessary if it
+          # has an encoded content type
+          if ["amqp/list", "amqp/map"].include? @message_impl.getContentType
+            @content = Qpid::Messaging.decode(self,
+                                              @message_impl.getContentType)
+          end
+
+        end
+        @content
+      end
+
+      # Returns the content's size.
+      def content_size; @message_impl.getContentSize; end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/receiver.rb b/cpp/bindings/qpid/ruby/lib/qpid/receiver.rb
new file mode 100644
index 0000000000..d498aa922b
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/receiver.rb
@@ -0,0 +1,102 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+require 'qpid/duration'
+
+module Qpid
+
+  module Messaging
+
+    # Receiver defines a type for receiving messages.
+    class Receiver
+
+      def initialize(receiver_impl) # :nodoc:
+        @receiver_impl = receiver_impl
+      end
+
+      def receiver_impl # :nodoc:
+        @receiver_impl
+      end
+
+      # Retrieves a message from the receiver's local queue, or waits
+      # for up to the duration specified for one to become available.
+      def get(duration = Qpid::Messaging::Duration::FOREVER)
+        message_impl = @receiver_impl.get duration.duration_impl
+        create_message_wrapper message_impl unless message_impl.nil?
+      end
+
+      # Retrieves a message from the receiver's subscription, or waits
+      # for up to the duration specified for one to become available.
+      def fetch(duration = Qpid::Messaging::Duration::FOREVER)
+        message_impl = @receiver_impl.fetch duration.duration_impl
+        create_message_wrapper message_impl unless message_impl.nil?
+      end
+
+      # Sets the capacity.
+      #
+      # The capacity for a receiver determines the number of messages that
+      # can be held in the receiver before being fetched.
+      def capacity=(capacity); @receiver_impl.setCapacity capacity; end
+
+      # Returns the capacity.
+      def capacity; @receiver_impl.getCapacity; end
+
+      # Returns the number of available messages waiting to be fetched.
+      def available; @receiver_impl.getAvailable; end
+
+      # Returns the number of messages that have been received and acknowledged
+      # but whose acknowledgements have not been confirmed by the sender.
+      def unsettled; @receiver_impl.getUnsettled; end
+
+      # Cancels the reciever.
+      def close; @receiver_impl.close; end
+
+      # Returns whether the receiver is closed.
+      def closed?; @receiver_impl.isClosed; end
+
+      # Returns the name of the receiver
+      def name; @receiver_impl.getName; end
+
+      # Returns the Session for this receiver.
+      def session; Qpid::Messaging::Session.new(@receiver_impl.getSession); end
+
+      # Returns whether the underlying handle is valid.
+      def valid?; @receiver_impl.isValid; end
+
+      # Returns whether the underlying handle is null.
+      def null?; @receiver_impl.isNull; end
+
+      def swap receiver
+        @receiver_impl.swap receiver.receiver_impl
+      end
+
+      private
+
+      def create_message_wrapper message_impl
+        Qpid::Messaging::Message.new({}, message_impl)
+      end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/sender.rb b/cpp/bindings/qpid/ruby/lib/qpid/sender.rb
new file mode 100644
index 0000000000..5d59c20d7e
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/sender.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
+
+  module Messaging
+
+    # Sender defines a type for sending messages.
+    class Sender
+
+      def initialize(sender_impl) # :nodoc:
+        @sender_impl = sender_impl
+      end
+
+      def sender_impl # :nodoc:
+        @sender_impl
+      end
+
+      # Sends a message.
+      def send(message, args = {})
+        block = args[:block] || false
+        @sender_impl.send message.message_impl, block
+      end
+
+      # Closes the sender.
+      def close; @sender_impl.close; end
+
+      # Returns the name for the sender.
+      def name; @sender_impl.getName; end
+
+      # Sets the capacity for the sender, which is the number of outgoing
+      # messages that can be held pending confirmation or receipt by
+      # the broker.
+      def capacity=(capacity); @sender_impl.setCapacity capacity; end
+
+      # Returns the capacity.
+      def capacity; @sender_impl.getCapacity; end
+
+      # Returns the number of messages sent that are pending receipt
+      # confirmation by the broker.
+      def unsettled; @sender_impl.getUnsettled; end
+
+      # Returns the available capacity for sending messages.
+      def available
+        @sender_impl.getAvailable
+      end
+
+      # Returns the Session for this sender.
+      def session; Qpid::Messaging::Session.new @sender_impl.getSession; end
+
+      # Returns if the underlying sender is valid.
+      def valid?; @sender_impl.isValid; end
+
+      # Returns if the underlying sender is null.
+      def null?; @sender_impl.isNull; end
+
+      def swap sender
+        @sender_impl.swap sender.sender_impl
+      end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/session.rb b/cpp/bindings/qpid/ruby/lib/qpid/session.rb
new file mode 100644
index 0000000000..543c26cc70
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/session.rb
@@ -0,0 +1,186 @@
+#
+# 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.
+#
+
+require 'cqpid'
+
+require 'qpid/errors'
+
+module Qpid
+
+  module Messaging
+
+    # A Session represents a distinct conversation between end points.
+    class Session
+
+      def initialize(session) # :nodoc:
+        @session_impl = session
+      end
+
+      def session_impl # :nodoc:
+        @session_impl
+      end
+
+      # Returns the +Connection+ for the +Session+.
+      def connection
+        connection_impl = @session_impl.getConnection
+        Qpid::Messaging::Connection.new "", {}, connection_impl
+      end
+
+      # Creates a new endpoint for sending messages.
+      def create_sender(address)
+        _address = address
+
+        if address.class == Qpid::Messaging::Address
+          _address = address.address_impl
+        end
+
+        Qpid::Messaging::Sender.new(@session_impl.createSender(_address))
+      end
+
+      # Retrieves the +Sender+ with the specified name.
+      def sender(name)
+        result = nil
+
+        begin
+          sender_impl = @session_impl.getSender name
+          result = Sender.for_impl sender_impl
+        rescue
+          # treat any error as a key error
+        end
+
+        raise Qpid::Messaging::KeyError, "No such sender: #{name}" if result.nil?
+        result
+      end
+
+      # Retrieves the +Receiver+ with the specified name.
+      def receiver(name)
+        result = nil
+
+        begin
+          receiver_impl = @session_impl.getReceiver name
+          result = Receiver.for_impl receiver_impl
+        rescue
+          # treat any error as a key error
+        end
+
+        raise Qpid::Messaging::KeyError, "No such receiver: #{name}" if result.nil?
+        result
+      end
+
+      # Creates a new endpoint for receiving messages.
+      def create_receiver(address)
+        result = nil
+
+        if address.class == Qpid::Messaging::Address
+          address_impl = address.address_impl
+          result = Qpid::Messaging::Receiver.new(@session_impl.createReceiver(address_impl))
+        else
+          result = Qpid::Messaging::Receiver.new(@session_impl.createReceiver(address))
+        end
+
+        return result
+      end
+
+      # Closes the Session and all associated Senders and Receivers.
+      # All Sessions are closed when the associated Connection is closed.
+      def close; @session_impl.close; end
+
+      # Commits any pending transactions for a transactional session.
+      def commit; @session_impl.commit; end
+
+      # Rolls back any uncommitted transactions on a transactional session.
+      def rollback; @session_impl.rollback; end
+
+      # Acknowledges one or more outstanding messages that have been received
+      # on this session.
+      #
+      # If a message is submitted (:message => something_message) then only
+      # that message is acknowledged. Otherwise all messsages are acknowledged.
+      #
+      # If :sync => true then the call will block until the server completes
+      # processing the acknowledgements.
+      # If :sync => true then the call will block until processed by the server (def. false)
+      def acknowledge(args = {})
+        sync = args[:sync] || false
+        message = args[:message] if args[:message]
+
+        unless message.nil?
+          @session_impl.acknowledge message.message_impl, sync
+        else
+          @session_impl.acknowledge sync
+        end
+      end
+
+      # Rejects the specified message. A rejected message will not be redelivered.
+      #
+      # NOTE: A message cannot be rejected once it has been acknowledged.
+      def reject(message); @session_impl.reject message.message_impl; end
+
+      # Releases the message, which allows the broker to attempt to
+      # redeliver it.
+      #
+      # NOTE: A message connot be released once it has been acknowled.
+      def release(message); @session_impl.release message.message_impl; end
+
+      # Requests synchronization with the server.
+      #
+      # If :block => true then the call will block until the server acknowledges.
+      #
+      # If :block => false (default) then the call will complete and the server
+      # will send notification on completion.
+      def sync(args = {})
+        block = args[:block] || false
+        @session_impl.sync block
+      end
+
+      # Returns the total number of receivable messages, and messages already received,
+      # by Receivers associated with this session.
+      def receivable; @session_impl.getReceivable; end
+
+      # Returns the number of messages that have been acknowledged by this session
+      # whose acknowledgements have not been confirmed as processed by the server.
+      def unsettled_acks; @session_impl.getUnsettledAcks; end
+
+      # Fetches the receiver for the next message.
+      def next_receiver(timeout = Qpid::Messaging::Duration::FOREVER)
+        receiver_impl = @session_impl.nextReceiver(timeout.duration_impl)
+        Qpid::Messaging::Receiver.new receiver_impl
+      end
+
+      # Returns whether there are errors on this session.
+      def error?; @session_impl.hasError; end
+
+      def check_error; @session_impl.checkError; end
+
+      # Returns if the underlying session is valid.
+      def valid?; @session_impl.isValid; end
+
+      # Returns if the underlying session is null.
+      def null?; @session_impl.isNull; end
+
+      def swap session
+        @session_impl.swap session.session_impl
+      end
+
+    end
+
+  end
+
+end
+
diff --git a/cpp/bindings/qpid/ruby/lib/qpid/version.rb b/cpp/bindings/qpid/ruby/lib/qpid/version.rb
new file mode 100644
index 0000000000..f387ba98dc
--- /dev/null
+++ b/cpp/bindings/qpid/ruby/lib/qpid/version.rb
@@ -0,0 +1,31 @@
+#
+# 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
+
+  module Version
+
+    NUMBERS = [MAJOR = 0,
+               MINOR = 13,
+               BUILD = 0]
+  end
+
+  VERSION = Version::NUMBERS.join('.')
+
+end