qpid_messaging 0.20.2 → 0.22.0

data/ChangeLog

@@ -0,0 +1,4 @@
+Verison 0.22:
+	* Qpid::Messaging::Address can use an address string on creation.
+	* Qpid::Messaging::Message can use an address string for reply_to.
+	* Removed errors.rb and the KeyError and SessionNameException errors.

data/LICENSE

@@ -1,7 +1,3 @@
-=========================================================================
-==  Apache License                                                     ==
-=========================================================================
-
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

data/README.rdoc

@@ -1,46 +1,41 @@
 = Qpid - Ruby language bindings for the Qpid messaging framework.
 
-Qpid is an cross-platform enterprise messaging system based on the open-source
+Qpid is a cross-platform enterprise messaging system based on the open-source
 AMQP protocol.
 
-Version :: 0.20.0
-
 = Links
 
 Documents :: http://qpid.apache.org/
 
-= Installation
+= Building The Gemfile
+
+== Prerequisites
 
-You can install Qpid with the following command.
+You need to have the Qpid client libraries installed along with the related
+development files (headers, etc). To install them, please see:
 
-  $ gem install qpid_messaging
+http://cwiki.apache.org/qpid/developer-pages.html
 
-== Building The Native Code
+== Gemfile Creation
 
-The Qpid gem requires that you have available the Qpid libraries and
-development header files. To install them, please see:
+Simply type:
 
-http://cwiki.apache.org/qpid/developer-pages.html
+  $ gem build qpid_messaging.gemspec
 
-If you are building the gem within the Qpid development environment
-itself, you can specify the location of the Qpid headers and
-libraries with:
+This will produce a gemfile name qpid_messaging-${VERSION}.gem.
 
-$ ruby extconfig.rb --with-qpid-lib=[path to libqpidclient.so, etc.]
-$ make
+== Installation
 
-== Examples
+You can install Qpid with the following command:
 
-Take a look at the integration tests for examples on how to leverage
-the messaging capabilities of Qpid in your Ruby applications.
+  $ gem install qpid_messaging-${VERSION}.gem
 
 == License
 
 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor licensing agreements.
 
-Author:: Darryl L. Pierce (mailto:dpierce@redhat.com)
-Copyright:: Copyright (c) 2011, Red Hat, Inc.
+Author:: Apache Qpid Project
 Homepage:: http://qpid.apache.org
 License:: Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0.html
 

data/TODO

@@ -1,7 +1,12 @@
-TODO Items
------------------------------------------------------------------------------
+Qpid Ruby bindigns TODO List
+==============================================================================
 
-Version 0.11.0:
- * Deliver the Ruby bindings as a gem.
- * Rework the blocking tasks to not bring the main thread to a halt.
+Beyond this simple laundry list, you can find the list of bugs and
+enhancements to be fixed by going to the Apache Qpid JIRA instance:
 
+    http://issues.apache.org/jira/browse/QPID
+
+
+Fixes & Improvements
+==============================================================================
+* Fix the threading issues with blocking I/O calls (Receiver get/fetch).

data/ext/cqpid/cqpid.cpp

@@ -1859,6 +1859,12 @@ static VALUE mCqpid;
 
 
 
+struct mystr
+{
+  size_t len;
+  const char *ptr;
+};
+
 #include <qpid/messaging/exceptions.h>
 #include <qpid/messaging/Address.h>
 #include <qpid/messaging/Connection.h>
@@ -1994,6 +2000,9 @@ SWIG_From_std_string  (const std::string& s)
   return SWIG_FromCharPtrAndSize(s.data(), s.size());
 }
 
+SWIGINTERN qpid::messaging::Duration qpid_messaging_Duration___mul__(qpid::messaging::Duration *self,uint64_t multiplier){
+         return qpid::messaging::Duration(self->getMilliseconds() * multiplier);
+    }
 
 SWIGINTERNINLINE VALUE
 SWIG_From_bool  (bool value)
@@ -2126,13 +2135,6 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
 }
 
 
-SWIGINTERNINLINE VALUE 
-SWIG_FromCharPtr(const char *cptr)
-{ 
-  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
-}
-
-
   #define SWIG_From_long   LONG2NUM 
 
 
@@ -2149,6 +2151,12 @@ SWIG_From_size_t  (size_t value)
   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 }
 
+SWIGINTERN mystr qpid_messaging_Message_getContentPtr(qpid::messaging::Message *self){
+    mystr s;
+    s.ptr = self->getContentPtr();
+    s.len = self->getContentSize();
+    return s;
+  }
 
 
 
@@ -3161,6 +3169,45 @@ _wrap_Duration_MINUTE_get(VALUE self) {
 }
 
 
+SWIGINTERN VALUE
+_wrap_Duration___mul__(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::Duration *arg1 = (qpid::messaging::Duration *) 0 ;
+  uint64_t arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< qpid::messaging::Duration > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__Duration, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Duration *","__mul__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::Duration * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_BIGNUM)
+    arg2 = NUM2ULL(argv[0]);
+    else
+    arg2 = (uint64_t) FIX2ULONG(argv[0]);
+  }
+  {
+    try {
+      result = qpid_messaging_Duration___mul__(arg1,arg2);
+    }
+    catch (qpid::messaging::MessagingException& mex) {
+      static VALUE merror = rb_define_class("MessagingError", rb_eStandardError);
+      rb_raise(merror, mex.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj((new qpid::messaging::Duration(static_cast< const qpid::messaging::Duration& >(result))), SWIGTYPE_p_qpid__messaging__Duration, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN void
 free_qpid_messaging_Duration(qpid::messaging::Duration *arg1) {
     delete arg1;
@@ -4586,38 +4633,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_Message_getContentPtr(int argc, VALUE *argv, VALUE self) {
-  qpid::messaging::Message *arg1 = (qpid::messaging::Message *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  char *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__Message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Message const *","getContentPtr", 1, self )); 
-  }
-  arg1 = reinterpret_cast< qpid::messaging::Message * >(argp1);
-  {
-    try {
-      result = (char *)((qpid::messaging::Message const *)arg1)->getContentPtr();
-    }
-    catch (qpid::messaging::MessagingException& mex) {
-      static VALUE merror = rb_define_class("MessagingError", rb_eStandardError);
-      rb_raise(merror, mex.what());
-    }
-  }
-  vresult = SWIG_FromCharPtr((const char *)result);
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_Message_getContentSize(int argc, VALUE *argv, VALUE self) {
   qpid::messaging::Message *arg1 = (qpid::messaging::Message *) 0 ;
@@ -4704,6 +4719,40 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Message_getContentPtr(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::Message *arg1 = (qpid::messaging::Message *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  mystr result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__Message, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Message *","getContentPtr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::Message * >(argp1);
+  {
+    try {
+      result = qpid_messaging_Message_getContentPtr(arg1);
+    }
+    catch (qpid::messaging::MessagingException& mex) {
+      static VALUE merror = rb_define_class("MessagingError", rb_eStandardError);
+      rb_raise(merror, mex.what());
+    }
+  }
+  {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize((&result)->ptr, (&result)->len));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 static swig_class SwigClassEncodingException;
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
@@ -6273,6 +6322,38 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Receiver_getAddress(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::Receiver *arg1 = (qpid::messaging::Receiver *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  qpid::messaging::Address result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__Receiver, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Receiver const *","getAddress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::Receiver * >(argp1);
+  {
+    try {
+      result = ((qpid::messaging::Receiver const *)arg1)->getAddress();
+    }
+    catch (qpid::messaging::MessagingException& mex) {
+      static VALUE merror = rb_define_class("MessagingError", rb_eStandardError);
+      rb_raise(merror, mex.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj((new qpid::messaging::Address(static_cast< const qpid::messaging::Address& >(result))), SWIGTYPE_p_qpid__messaging__Address, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 static swig_class SwigClassSender;
 
 SWIGINTERN VALUE
@@ -6801,6 +6882,38 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Sender_getAddress(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::Sender *arg1 = (qpid::messaging::Sender *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  qpid::messaging::Address result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__Sender, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Sender const *","getAddress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::Sender * >(argp1);
+  {
+    try {
+      result = ((qpid::messaging::Sender const *)arg1)->getAddress();
+    }
+    catch (qpid::messaging::MessagingException& mex) {
+      static VALUE merror = rb_define_class("MessagingError", rb_eStandardError);
+      rb_raise(merror, mex.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj((new qpid::messaging::Address(static_cast< const qpid::messaging::Address& >(result))), SWIGTYPE_p_qpid__messaging__Address, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 static swig_class SwigClassSession;
 
 SWIGINTERN VALUE
@@ -9763,6 +9876,7 @@ SWIGEXPORT void Init_cqpid(void) {
   rb_define_singleton_method(SwigClassDuration.klass, "IMMEDIATE", VALUEFUNC(_wrap_Duration_IMMEDIATE_get), 0);
   rb_define_singleton_method(SwigClassDuration.klass, "SECOND", VALUEFUNC(_wrap_Duration_SECOND_get), 0);
   rb_define_singleton_method(SwigClassDuration.klass, "MINUTE", VALUEFUNC(_wrap_Duration_MINUTE_get), 0);
+  rb_define_method(SwigClassDuration.klass, "*", VALUEFUNC(_wrap_Duration___mul__), -1);
   SwigClassDuration.mark = 0;
   SwigClassDuration.destroy = (void (*)(void *)) free_qpid_messaging_Duration;
   SwigClassDuration.trackObjects = 0;
@@ -9796,9 +9910,9 @@ SWIGEXPORT void Init_cqpid(void) {
   rb_define_method(SwigClassMessage.klass, "getProperties", VALUEFUNC(_wrap_Message_getProperties), -1);
   rb_define_method(SwigClassMessage.klass, "setContent", VALUEFUNC(_wrap_Message_setContent), -1);
   rb_define_method(SwigClassMessage.klass, "getContent", VALUEFUNC(_wrap_Message_getContent), -1);
-  rb_define_method(SwigClassMessage.klass, "getContentPtr", VALUEFUNC(_wrap_Message_getContentPtr), -1);
   rb_define_method(SwigClassMessage.klass, "getContentSize", VALUEFUNC(_wrap_Message_getContentSize), -1);
   rb_define_method(SwigClassMessage.klass, "setProperty", VALUEFUNC(_wrap_Message_setProperty), -1);
+  rb_define_method(SwigClassMessage.klass, "getContentPtr", VALUEFUNC(_wrap_Message_getContentPtr), -1);
   SwigClassMessage.mark = 0;
   SwigClassMessage.destroy = (void (*)(void *)) free_qpid_messaging_Message;
   SwigClassMessage.trackObjects = 0;
@@ -9827,6 +9941,7 @@ SWIGEXPORT void Init_cqpid(void) {
   rb_define_method(SwigClassReceiver.klass, "isClosed", VALUEFUNC(_wrap_Receiver_isClosed), -1);
   rb_define_method(SwigClassReceiver.klass, "getName", VALUEFUNC(_wrap_Receiver_getName), -1);
   rb_define_method(SwigClassReceiver.klass, "getSession", VALUEFUNC(_wrap_Receiver_getSession), -1);
+  rb_define_method(SwigClassReceiver.klass, "getAddress", VALUEFUNC(_wrap_Receiver_getAddress), -1);
   SwigClassReceiver.mark = 0;
   SwigClassReceiver.destroy = (void (*)(void *)) free_qpid_messaging_Receiver;
   SwigClassReceiver.trackObjects = 0;
@@ -9843,6 +9958,7 @@ SWIGEXPORT void Init_cqpid(void) {
   rb_define_method(SwigClassSender.klass, "getAvailable", VALUEFUNC(_wrap_Sender_getAvailable), -1);
   rb_define_method(SwigClassSender.klass, "getName", VALUEFUNC(_wrap_Sender_getName), -1);
   rb_define_method(SwigClassSender.klass, "getSession", VALUEFUNC(_wrap_Sender_getSession), -1);
+  rb_define_method(SwigClassSender.klass, "getAddress", VALUEFUNC(_wrap_Sender_getAddress), -1);
   SwigClassSender.mark = 0;
   SwigClassSender.destroy = (void (*)(void *)) free_qpid_messaging_Sender;
   SwigClassSender.trackObjects = 0;

data/ext/cqpid/extconf.rb

@@ -25,8 +25,16 @@
 
 require 'mkmf'
 
+(rver, rrev, rmin) = RUBY_VERSION.split('.')
+
+old_ruby = (rver == "1" && rrev < "9") # pre-1.9
+
 # Setup the build environment.
-$CFLAGS = "-fPIC -fno-inline -x c++ -lstdc++"
+if old_ruby
+  $CFLAGS = "-fPIC -fno-inline -x c++ -lstdc++"
+else
+  $CFLAGS = "-fPIC -fno-inline"
+end
 
 REQUIRED_LIBRARIES = [
                       'stdc++',
@@ -68,7 +76,7 @@ have_library('stdc++')
 
 REQUIRED_LIBRARIES.each {|library| require_library library}
 
-REQUIRED_HEADERS.each {|header| require_header header}
+REQUIRED_HEADERS.each {|header| require_header header} if old_ruby
 
 create_makefile('cqpid')
 

data/lib/qpid_messaging.rb

@@ -1,4 +1,4 @@
-#
+#--
 # 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,9 +15,9 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
+#++
+
 require 'cqpid'
-require 'qpid_messaging/errors'
 require 'qpid_messaging/duration'
 require 'qpid_messaging/address'
 require 'qpid_messaging/encoding'
@@ -27,3 +27,56 @@ require 'qpid_messaging/receiver'
 require 'qpid_messaging/session'
 require 'qpid_messaging/connection'
 
+module Qpid
+
+  # The Qpid Messaging framework is an enterprise messaging framework
+  # based on the open-source AMQP protocol.
+  #
+  # ==== Example Application
+  #
+  # Here is a simple example application. It creates a link to a broker located
+  # on a system named *broker.myqpiddomain.com*. It then creates a new messaging
+  # queue named "qpid-examples" and publishes a message to it. It then consumes
+  # that same message and closes the connection.
+  #
+  #   require 'rubygems'
+  #   gem 'qpid_messaging'
+  #   require 'qpid_messaging'
+  #
+  #   # create a connection, open it and then create a session named "session1"
+  #   conn = Qpid::Messaging::Connection.new :name => "broker.myqpiddomain.com"
+  #   conn.open
+  #   session = conn.create_session "session1"
+  #
+  #   # create a sender and a receiver
+  #   # the sender marks the queue as one that is deleted when trhe sender disconnects
+  #   send = session.create_sender "qpid-examples;{create:always,delete:always}"
+  #   recv = session.create_receiver "qpid-examples"
+  #
+  #   # create an outgoing message and send it
+  #   outgoing = Qpid::Messaging::Message.new :content => "The time is #{Time.new}"
+  #   sender.send outgoing
+  #
+  #   # set the receiver's capacity to 10 and then check out many messages are pending
+  #   recv.capacity = 10
+  #   puts "There are #{recv.available} messages waiting." # should report 1 message
+  #
+  #   # get the nextwaiting  message, which should be in the local queue now,
+  #   # and output the contents
+  #   incoming = recv.get Qpid::Messaging::Duration::IMMEDIATE
+  #   puts "Received the following message: #{incoming.content}"
+  #   # the output should be the text that was sent earlier
+  #
+  #   # acknowledge the message, letting the sender know the message was received
+  #   puts "The sender currently has #{send.unsettled} message(s) pending."
+  #   # should report 1 unsettled message
+  #   session.acknowledge incoming # acknowledge the received message
+  #   puts "Now sender currently has #{send.unsettled} message(s) pending."
+  #   # should report 0 unsettled messages
+  #
+  #   # close the connection
+  #   conn.close
+  #
+  module Messaging; end
+
+end