ons 1.0.0

data/ext/ons/consumer.cpp

@@ -0,0 +1,68 @@
+#include <rice/Constructor.hpp>
+#include <rice/Data_Type.hpp>
+#include <rice/Hash.hpp>
+#include <rice/Module.hpp>
+#include <rice/String.hpp>
+#include <rice/Symbol.hpp>
+#include <ons/ONSFactory.h>
+#include "listener.hpp"
+#include "consumer.hpp"
+
+Consumer::Consumer(Rice::String accessKey, Rice::String secretKey, Rice::String consumerId, Rice::Hash options)
+{
+  ons::ONSFactoryProperty factoryInfo;
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::AccessKey,   accessKey.str());
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::SecretKey,   secretKey.str());
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::ConsumerId, consumerId.str());
+
+  Rice::Object namesrvAddr = options.call("[]", Rice::String("namesrv_addr"));
+  if (!namesrvAddr) { namesrvAddr = options.call("[]", Rice::Symbol("namesrv_addr")); }
+  if (namesrvAddr) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::NAMESRV_ADDR, ((Rice::String)namesrvAddr).str()); }
+
+  Rice::Object onsAddr = options.call("[]", Rice::String("ons_addr"));
+  if (!onsAddr) { onsAddr = options.call("[]", Rice::Symbol("ons_addr")); }
+  if (onsAddr) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::ONSAddr, ((Rice::String)onsAddr).str()); }
+
+  Rice::Object threadNum = options.call("[]", Rice::String("thread_num"));
+  if (!threadNum) { threadNum = options.call("[]", Rice::Symbol("thread_num")); }
+  if (threadNum.rb_type() == T_FIXNUM || threadNum.rb_type() == T_BIGNUM) { threadNum = threadNum.to_s(); }
+  if (threadNum) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::ConsumeThreadNums, ((Rice::String)threadNum).str()); }
+
+  this->onsPushConsumer = ons::ONSFactory::getInstance()->createPushConsumer(factoryInfo);
+}
+
+Consumer::~Consumer()
+{
+  for (std::vector<Listener*>::iterator iter = this->listeners.begin(); iter != this->listeners.end(); ++iter) {
+    delete *iter;
+  }
+}
+
+void Consumer::subscribe(Rice::String topic, Rice::String subscribeExpression, Rice::Object handler)
+{
+  Listener *listener = new Listener;
+  listener->setHandler(handler);
+
+  this->listeners.push_back(listener);
+  this->onsPushConsumer->subscribe(topic.str(), subscribeExpression.str(), listener);
+}
+
+void Consumer::start()
+{
+  this->onsPushConsumer->start();
+}
+
+void Consumer::shutdown()
+{
+  this->onsPushConsumer->shutdown();
+}
+
+void define_class_consumer_under_module(Rice::Module module)
+{
+  Rice::Data_Type<Consumer> rb_cConsumer = Rice::define_class_under<Consumer>(module, "Consumer");
+
+  rb_cConsumer.define_constructor(Rice::Constructor<Consumer, Rice::String, Rice::String, Rice::String, Rice::Hash>());
+  rb_cConsumer.define_method("subscribe", &Consumer::subscribe);
+  rb_cConsumer.define_method("start", &Consumer::start);
+  rb_cConsumer.define_method("shutdown", &Consumer::shutdown);
+}

data/ext/ons/consumer.hpp

@@ -0,0 +1,33 @@
+#ifndef __RBEXT_CONSUMER_HPP__
+#define __RBEXT_CONSUMER_HPP__
+
+#include <vector>
+
+namespace Rice { class Hash; class Module; class Object; class String; }
+namespace ons { class PushConsumer; }
+class Listener;
+
+class Consumer {
+
+public:
+  Consumer(Rice::String accessKey, Rice::String secretKey, Rice::String consumerId, Rice::Hash options);
+  virtual ~Consumer();
+
+  virtual void subscribe(Rice::String topic, Rice::String subscribeExpression, Rice::Object handler);
+
+  // call this method once after subscribe topic.
+  virtual void start();
+
+  // call this method before program exit,
+  // otherwise it would cause a memory leak and some other issues.
+  virtual void shutdown();
+
+private:
+  ons::PushConsumer* onsPushConsumer;
+  std::vector<Listener*> listeners;
+
+};
+
+void define_class_consumer_under_module(Rice::Module module);
+
+#endif  // __RBEXT_CONSUMER_HPP__

data/ext/ons/extconf.rb

@@ -0,0 +1,44 @@
+# rubocop:disable Style/GlobalVars
+
+# use mkmf-rice instead mkmf
+require 'mkmf-rice'
+
+# aliyun mq sdk dir
+ALIYUN_MQ_CPP_SDK_DIR = File.expand_path('../aliyun-mq-cpp-sdk', __FILE__)
+
+# header dirs to search
+HEADER_DIRS = [
+  '/opt/local/include',           # search /opt/local for macports
+  '/usr/local/include',           # search /usr/local for people that installed from source
+  RbConfig::CONFIG['includedir'], # check the ruby install locations
+  File.join(ALIYUN_MQ_CPP_SDK_DIR, 'include'),
+  '/usr/include',                 # finally fall back to /usr
+].freeze
+
+# library dirs to search
+LIB_DIRS = [
+  '/opt/local/lib',               # search /opt/local for macports
+  '/usr/local/lib',               # search /usr/local for people that installed from source
+  RbConfig::CONFIG['libdir'],     # check the ruby install locations
+  File.join(ALIYUN_MQ_CPP_SDK_DIR, 'lib'),
+  '/usr/lib',                     # finally fall back to /usr
+].freeze
+
+# configure cxxflags
+$warnflags.gsub!(/-Wdeclaration-after-statement/, '')   # this flag is valid for C/ObjC but not for C++
+$warnflags.gsub!(/-Wimplicit-function-declaration/, '') # this flag is valid for C/ObjC but not for C++
+$warnflags << ' -Wno-ignored-qualifiers'
+
+# configure various "with" options
+dir_config('boost', HEADER_DIRS, LIB_DIRS)
+dir_config('onsclient4cpp', HEADER_DIRS, LIB_DIRS)
+
+# configure link libraries
+abort 'libboost_chrono is missing, please install libboost_chrono' unless have_library('boost_chrono')
+abort 'libboost_system is missing, please install libboost_system' unless have_library('boost_system')
+abort 'libboost_thread is missing, please install libboost_thread' unless have_library('boost_thread')
+abort unless have_library('onsclient4cpp')
+abort unless have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+
+# create Makefile
+create_makefile('ons/ons')

data/ext/ons/listener.cpp

@@ -0,0 +1,19 @@
+#include <rice/Hash.hpp>
+#include "listener.hpp"
+#include "lmfao.hpp"
+
+void Listener::setHandler(Rice::Object handler)
+{
+  this->handler = handler.value();
+  this->riceHandler = handler;
+}
+
+Action Listener::consume(ons::Message& message, ons::ConsumeContext& context)
+{
+  // Listener::consume will called in a separate thread which is not created by Ruby,
+  // so you cannot call any Ruby functions here. Use the LMFAO library workaround.
+  bool result = mLMFAO_call(this->handler, &message);
+
+  if (result) { return CommitMessage; }
+  return ReconsumeLater;
+}

data/ext/ons/listener.hpp

@@ -0,0 +1,25 @@
+#ifndef __RBEXT_LISTENER_HPP__
+#define __RBEXT_LISTENER_HPP__
+
+#include <rice/Object.hpp>
+#include <ons/MessageListener.h>
+
+class Listener: public ons::MessageListener {
+
+public:
+  Listener() {}
+  virtual ~Listener() {}
+
+  virtual void setHandler(Rice::Object handler);
+
+  // implement the interface of consuming message.
+  virtual Action consume(ons::Message& message, ons::ConsumeContext& context);
+
+private:
+  // a object which should be repsond to :call method.
+  VALUE handler;
+  Rice::Object riceHandler;
+
+};
+
+#endif  // __RBEXT_LISTENER_HPP__

data/ext/ons/lmfao.cpp

@@ -0,0 +1,251 @@
+#include "lmfao.hpp"
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Functions related to the global callback queue
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+   Three globals to allow for Ruby/C-thread communication:
+
+   - mutex & condition to synchronize access to callback_queue
+   - callback_queue to store actual callback data in
+
+   Be careful with the functions that manipulate the callback
+   queue; they must do so in the protection of a mutex.
+*/
+pthread_mutex_t g_callback_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t g_callback_cond   = PTHREAD_COND_INITIALIZER;
+callback_t *g_callback_queue     = NULL;
+
+/*
+   Use this function to add a callback node onto the global
+   callback queue.
+
+   Do note that we are adding items to the front of the linked
+   list, and as such events will always be handled by most recent
+   first. To remedy this, add to the end of the queue instead.
+*/
+void g_callback_queue_push(callback_t *callback)
+{
+  callback->next   = g_callback_queue;
+  g_callback_queue = callback;
+}
+
+/*
+   Use this function to pop off a callback node from the
+   global callback queue. Returns NULL if queue is empty.
+*/
+callback_t *g_callback_queue_pop()
+{
+  callback_t *callback = g_callback_queue;
+  if (callback)
+  {
+    g_callback_queue = callback->next;
+  }
+  return callback;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Functions related to LMFAO Ruby API
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+   Call LMFAO with the given argument.
+*/
+bool mLMFAO_call(VALUE handler, ons::Message* message)
+{
+  listener_consume_args_t args = {
+    .handler = handler,
+    .message = message
+  };
+  return lmfao_callback((void *) &args);
+}
+
+/*
+  This is our user-defined C callback, it gets called by the C library.
+
+  We need to:
+
+  1. Create a callback structure, put our parameters in it
+  2. Push the callback node onto the global callback queue
+  3. Wait for the callback to be handled
+  4. Return the return value
+*/
+void *lmfao_callback(void *data)
+{
+  callback_t callback;
+  pthread_mutex_init(&callback.mutex, NULL);
+  pthread_cond_init(&callback.cond, NULL);
+  callback.data = data;
+  callback.handled = false;
+
+  // Put callback data in global callback queue
+  pthread_mutex_lock(&g_callback_mutex);
+  g_callback_queue_push(&callback);
+  pthread_mutex_unlock(&g_callback_mutex);
+
+  // Notify waiting Ruby thread that we have callback data
+  pthread_cond_signal(&g_callback_cond);
+
+  // Wait for callback to be handled
+  pthread_mutex_lock(&callback.mutex);
+  while (callback.handled == false)
+  {
+    pthread_cond_wait(&callback.cond, &callback.mutex);
+  }
+  pthread_mutex_unlock(&callback.mutex);
+
+  // Clean up
+  pthread_mutex_destroy(&callback.mutex);
+  pthread_cond_destroy(&callback.cond);
+
+  return callback.data;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Our special Ruby event-listening thread functions
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+   Executed for each callback notification; what we receive
+   are the callback parameters. The job of this method is to:
+
+   1. Convert callback parameters into Ruby values
+   2. Call the appropriate callback with said parameters
+   3. Convert the Ruby return value into a C value
+   4. Hand over the C value to the C callback
+*/
+VALUE LMFAO_handle_callback(void *cb)
+{
+  callback_t *callback = (callback_t*) cb;
+
+  // figure out the proper handler for this particular event, as
+  // well as convert the callback data into proper ruby values!
+  listener_consume_args_t *args = (listener_consume_args_t*) callback->data;
+  ons::Message *message = args->message;
+  VALUE proc = args->handler;
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, ID2SYM(rb_intern("id")),    rb_str_new2(message->getMsgID().c_str()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("topic")), rb_str_new2(message->getTopic().c_str()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("tag")),   rb_str_new2(message->getTag().c_str()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("body")),  rb_str_new2(message->getBody().c_str()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("key")),   rb_str_new2(message->getKey().c_str()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("reconsume_times")),   INT2NUM(message->getReconsumeTimes()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("store_timestamp")),   LL2NUM(message->getStoreTimestamp()));
+  rb_hash_aset(hash, ID2SYM(rb_intern("deliver_timestamp")), LL2NUM(message->getStartDeliverTime()));
+  VALUE result = rb_funcall(proc, rb_intern("call"), 1, hash);
+
+  // convert it to a C value that our callback can return
+  if (result == Qnil || result == Qfalse) {
+    callback->data = (void *) false;
+  } else {
+    callback->data = (void *) true;
+  }
+
+  // tell the callback that it has been handled, we are done
+  pthread_mutex_lock(&callback->mutex);
+  callback->handled = true;
+  pthread_cond_signal(&callback->cond);
+  pthread_mutex_unlock(&callback->mutex);
+
+  return Qnil;
+}
+
+/*
+   Wait for global callback queue to contain something.
+
+   This function is called while not holding the GVL, so it’s safe
+   to do long waits in here; other threads will still run.
+
+   The job of this function is merely to wait until the callback queue
+   contains something. Once that happens, we remove the item from the
+   queue and return it to our caller through waiting->callback.
+*/
+void *wait_for_callback_signal(void *w)
+{
+  callback_waiting_t *waiting = (callback_waiting_t*) w;
+
+  pthread_mutex_lock(&g_callback_mutex);
+
+  // abort signal is used when ruby wants us to stop waiting
+  while (waiting->abort == false && (waiting->callback = g_callback_queue_pop()) == NULL)
+  {
+    pthread_cond_wait(&g_callback_cond, &g_callback_mutex);
+  }
+
+  pthread_mutex_unlock(&g_callback_mutex);
+
+  return NULL;
+}
+
+/*
+   Stop waiting for callback notification. This function
+   is invoked by Ruby when she wants us to exit.
+
+   As `wait_for_callback_signal` function is executed without holding
+   the GVL, it can potentially take forever. However, when somebody wants
+   to quit the program (for example if somebody presses CTRL-C to exit)
+   we must tell Ruby how to wake up the `wait_for_callback_signal` function
+   so Ruby can exit properly.
+*/
+void stop_waiting_for_callback_signal(void *w)
+{
+  callback_waiting_t *waiting = (callback_waiting_t*) w;
+
+  pthread_mutex_lock(&g_callback_mutex);
+  waiting->abort = true;
+  pthread_cond_signal(&g_callback_cond);
+  pthread_mutex_unlock(&g_callback_mutex);
+}
+
+/*
+  This thread loops continously, waiting for callbacks to happen in C.
+  Once they do, it will handle the callback in a new thread.
+
+  The reason we use a thread for handling the callback is that the handler
+  itself might fire off more callbacks, that might need to be handled before
+  the handler returns. We can’t do that if the event thread is busy handling
+  the first callback.
+
+  Continously, we need to:
+
+  1. Unlock the Ruby GVL (allowing other threads to run while we wait)
+  2. Wait for a callback to fire
+  3. Spawn a new ruby thread to handle the callback
+*/
+VALUE LMFAO_event_thread(void *unused)
+{
+  callback_waiting_t waiting = {
+    .callback = NULL,
+    .abort    = false
+  };
+
+  while (waiting.abort == false)
+  {
+    // release the GVL while waiting for a callback notification
+    rb_thread_call_without_gvl(wait_for_callback_signal, &waiting, stop_waiting_for_callback_signal, &waiting);
+
+    // if ruby wants us to abort, this will be NULL
+    if (waiting.callback)
+    {
+      rb_thread_create((VALUE (*)(...)) LMFAO_handle_callback, (void *) waiting.callback);
+    }
+  }
+
+  return Qnil;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Ruby bindings for LMFAO C library
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+
+Rice::Object start_event_thread()
+{
+  return rb_thread_create((VALUE (*)(...)) LMFAO_event_thread, NULL);
+}
+
+void define_module_lmfao_under_module(Rice::Module module)
+{
+  Rice::Module rb_mLMFAO = module.define_module("LMFAO");
+  rb_mLMFAO.define_singleton_method("start_event_thread", &start_event_thread);
+}

data/ext/ons/lmfao.hpp

@@ -0,0 +1,101 @@
+#ifndef __RBEXT_LMFAO_HPP__
+#define __RBEXT_LMFAO_HPP__
+
+/*
+   Problem:
+
+   You cannot call Ruby functions from a thread not created by Ruby. When it comes to MRI, you
+   must be the owner of the GVL to call ruby functions, and since the thread is not a
+   ruby-created thread you have no way of owning the GVL.
+
+   Workaround:
+
+   1. we have a special ruby thread, waiting to be notified
+   2. when C callback is invoked, it stores its’ parameters somewhere, notifies ruby thread and waits
+   3. ruby thread is notified, reads the callback parameters, and executes the callback handler
+   4. ruby thread puts the return value of the handler in location where C callback can reach it, and notifies C callback
+   5. C callback wakes up again, reads return value and returns it
+
+   Reference:
+
+   * http://www.ruby-forum.com/topic/3149838
+   * http://www.burgestrand.se/articles/asynchronous-callbacks-in-ruby-c-extensions
+*/
+
+#include <rice/Module.hpp>
+#include <ons/Message.h>
+#include <ruby/thread.h>
+#include <pthread.h>
+
+typedef struct listener_consume_args_t listener_consume_args_t;
+struct listener_consume_args_t {
+  VALUE handler;
+  ons::Message *message;
+};
+
+typedef struct callback_t callback_t;
+struct callback_t {
+  /*
+     Each callback needs to store its’ data somewhere; this
+     is how we later on access that data from our Ruby thread.
+
+     We also use this for our return value from the Ruby handler.
+  */
+  void *data;
+
+  /*
+     Once we’ve dispatched our callback data to Ruby, we must
+     wait for a reply before we continue. These two are used
+     for that purpose.
+  */
+  pthread_mutex_t mutex;
+  pthread_cond_t  cond;
+
+  /*
+     Even though we use the condition variable above to wait,
+     we might still be woken up (spurious wakeups). This bool
+     serves as a final check that tells us if we can continue.
+  */
+  bool handled;
+
+  /*
+     We use this to implement a linked list of callback data.
+     This allows multiple callbacks to happen simultaneously
+     without them having to wait for each other.
+  */
+  callback_t *next;
+};
+
+typedef struct callback_waiting_t callback_waiting_t;
+struct callback_waiting_t {
+  callback_t *callback;
+  bool abort;
+};
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Functions related to the global callback queue
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+void g_callback_queue_push(callback_t *callback);
+callback_t *g_callback_queue_pop();
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Functions related to LMFAO Ruby API
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+bool mLMFAO_call(VALUE handler, ons::Message* message);
+void *lmfao_callback(void *data);
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Our special Ruby event-listening thread functions
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+VALUE LMFAO_handle_callback(void *cb);
+void *wait_for_callback_signal(void *w);
+void stop_waiting_for_callback_signal(void *w);
+VALUE LMFAO_event_thread(void *unused);
+
+/* * * * * * * * * * * * * * * * * * * * * * * * *
+ * Ruby bindings for LMFAO C library
+ * * * * * * * * * * * * * * * * * * * * * * * * */
+Rice::Object start_event_thread();
+void define_module_lmfao_under_module(Rice::Module module);
+
+#endif  // __RBEXT_LMFAO_HPP__

data/ext/ons/ons.cpp

@@ -0,0 +1,19 @@
+#include <rice/Module.hpp>
+#include "lmfao.hpp"
+#include "consumer.hpp"
+#include "producer.hpp"
+#include "ons.hpp"
+
+extern "C"
+void Init_ons()
+{
+  RUBY_TRY
+  {
+    Rice::Module rb_mOns = Rice::define_module("Ons");
+    Rice::Module rb_mInternal = rb_mOns.define_module("Internal");
+    define_class_consumer_under_module(rb_mInternal);
+    define_class_producer_under_module(rb_mInternal);
+    define_module_lmfao_under_module(rb_mInternal);
+  }
+  RUBY_CATCH
+}

data/ext/ons/ons.hpp

@@ -0,0 +1,7 @@
+#ifndef __RBEXT_ONS_HPP__
+#define __RBEXT_ONS_HPP__
+
+extern "C"
+void Init_ons();
+
+#endif  // __RBEXT_ONS_HPP__

data/ext/ons/producer.cpp

@@ -0,0 +1,74 @@
+#include <rice/Constructor.hpp>
+#include <rice/Data_Type.hpp>
+#include <rice/Hash.hpp>
+#include <rice/Module.hpp>
+#include <rice/Object.hpp>
+#include <rice/String.hpp>
+#include <rice/Symbol.hpp>
+#include <ons/ONSFactory.h>
+#include "producer.hpp"
+
+Producer::Producer(Rice::String accessKey, Rice::String secretKey, Rice::String producerId, Rice::Hash options)
+{
+  ons::ONSFactoryProperty factoryInfo;
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::AccessKey,   accessKey.str());
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::SecretKey,   secretKey.str());
+  factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::ProducerId, producerId.str());
+
+  Rice::Object namesrvAddr = options.call("[]", Rice::String("namesrv_addr"));
+  if (!namesrvAddr) { namesrvAddr = options.call("[]", Rice::Symbol("namesrv_addr")); }
+  if (namesrvAddr) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::NAMESRV_ADDR, ((Rice::String)namesrvAddr).str()); }
+
+  Rice::Object onsAddr = options.call("[]", Rice::String("ons_addr"));
+  if (!onsAddr) { onsAddr = options.call("[]", Rice::Symbol("ons_addr")); }
+  if (onsAddr) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::ONSAddr, ((Rice::String)onsAddr).str()); }
+
+  Rice::Object sendTimeout = options.call("[]", Rice::String("send_timeout"));
+  if (!sendTimeout) { sendTimeout = options.call("[]", Rice::Symbol("send_timeout")); }
+  if (sendTimeout.rb_type() == T_FIXNUM || sendTimeout.rb_type() == T_BIGNUM) { sendTimeout = sendTimeout.to_s(); }
+  if (sendTimeout) { factoryInfo.setFactoryProperty(ons::ONSFactoryProperty::SendMsgTimeoutMillis, ((Rice::String)sendTimeout).str()); }
+
+  this->onsProducer = ons::ONSFactory::getInstance()->createProducer(factoryInfo);
+}
+
+Rice::String Producer::sendMessage(Rice::String topic, Rice::String tag, Rice::String body, Rice::String key)
+{
+  ons::Message message(topic.str(), tag.str(), body.str());
+  if (key.length() != 0) { message.setKey(key.str()); }
+
+  ons::SendResultONS sendResult = this->onsProducer->send(message);
+  return sendResult.getMessageId();
+}
+
+Rice::String Producer::sendTimerMessage(Rice::String topic, Rice::String tag, Rice::String body, Rice::Object deliverTimestamp, Rice::String key)
+{
+  ons::Message message(topic.str(), tag.str(), body.str());
+  if (key.length() != 0) { message.setKey(key.str()); }
+
+  long long timestamp = NUM2LL(deliverTimestamp.value());
+  if (timestamp != 0) { message.setStartDeliverTime(timestamp); }
+
+  ons::SendResultONS sendResult = this->onsProducer->send(message);
+  return sendResult.getMessageId();
+}
+
+void Producer::start()
+{
+  this->onsProducer->start();
+}
+
+void Producer::shutdown()
+{
+  this->onsProducer->shutdown();
+}
+
+void define_class_producer_under_module(Rice::Module module)
+{
+  Rice::Data_Type<Producer> rb_cProducer = Rice::define_class_under<Producer>(module, "Producer");
+
+  rb_cProducer.define_constructor(Rice::Constructor<Producer, Rice::String, Rice::String, Rice::String, Rice::Hash>());
+  rb_cProducer.define_method("send_message", &Producer::sendMessage);
+  rb_cProducer.define_method("send_timer_message", &Producer::sendTimerMessage);
+  rb_cProducer.define_method("start", &Producer::start);
+  rb_cProducer.define_method("shutdown", &Producer::shutdown);
+}

data/ext/ons/producer.hpp

@@ -0,0 +1,30 @@
+#ifndef __RBEXT_PRODUCER_HPP__
+#define __RBEXT_PRODUCER_HPP__
+
+namespace Rice { class Hash; class Module; class Object; class String; }
+namespace ons { class Producer; }
+
+class Producer {
+
+public:
+  Producer(Rice::String accessKey, Rice::String secretKey, Rice::String producerId, Rice::Hash options);
+  virtual ~Producer() {}
+
+  virtual Rice::String sendMessage(Rice::String topic, Rice::String tag, Rice::String body, Rice::String key);
+  virtual Rice::String sendTimerMessage(Rice::String topic, Rice::String tag, Rice::String body, Rice::Object deliverTimestamp, Rice::String key);
+
+  // call this method once before send any messages.
+  virtual void start();
+
+  // call this method before program exit,
+  // otherwise it would cause a memory leak and some other issues.
+  virtual void shutdown();
+
+private:
+  ons::Producer* onsProducer;
+
+};
+
+void define_class_producer_under_module(Rice::Module module);
+
+#endif  // __RBEXT_PRODUCER_HPP__