pulsar-client 2.4.1.pre.beta.1

data/ext/bindings/consumer.hpp

@@ -0,0 +1,31 @@
+#ifndef __PULSAR_RUBY_CLIENT_CONSUMER_HPP
+#define __PULSAR_RUBY_CLIENT_CONSUMER_HPP
+
+#include "rice/Module.hpp"
+#include "rice/Data_Object.hpp"
+#include <pulsar/Client.h>
+
+#include "message.hpp"
+
+namespace pulsar_rb {
+  class Consumer {
+  public:
+    pulsar::Consumer _consumer;
+    Consumer() {};
+    Consumer(const pulsar::Consumer& consumer) : _consumer(consumer) {}
+
+    Message::ptr receive();
+    void acknowledge(const Message& message);
+    void negative_acknowledge(const Message& message);
+
+    typedef Rice::Data_Object<Consumer> ptr;
+  };
+
+  // direct typedef instead of wrapping because implementations don't need any
+  // wrapping. but still re-namespaced for consistency
+  typedef pulsar::ConsumerConfiguration ConsumerConfiguration;
+};
+
+void bind_consumer(Rice::Module& module);
+
+#endif

data/ext/bindings/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf-rice'
+$LOCAL_LIBS << "-lpulsar"
+create_makefile('pulsar/bindings')

data/ext/bindings/message.cpp

@@ -0,0 +1,47 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include <pulsar/Client.h>
+
+#include "message.hpp"
+
+namespace pulsar_rb {
+
+Rice::String MessageId::toString() {
+  std::stringstream ss;
+  ss << _msgId;
+  return Rice::String(ss.str());
+}
+
+Message::Message(const std::string& data) {
+  pulsar::MessageBuilder mb;
+  mb.setContent(data);
+  _msg = mb.build();
+}
+
+Rice::String Message::getData() {
+  std::string str((const char*)_msg.getData(), _msg.getLength());
+  return Rice::String(str);
+}
+
+MessageId::ptr Message::getMessageId() {
+  pulsar::MessageId messageId = _msg.getMessageId();
+  return MessageId::ptr(new MessageId(messageId));
+}
+
+}
+
+using namespace Rice;
+
+void bind_message(Module& module) {
+  define_class_under<pulsar_rb::MessageId>(module, "MessageId")
+    .define_constructor(Constructor<pulsar_rb::MessageId, const pulsar::MessageId&>())
+    .define_method("to_s", &pulsar_rb::MessageId::toString)
+    ;
+
+  define_class_under<pulsar_rb::Message>(module, "Message")
+    .define_constructor(Constructor<pulsar_rb::Message, const pulsar::Message&>())
+    .define_constructor(Constructor<pulsar_rb::Message, const std::string&>())
+    .define_method("data", &pulsar_rb::Message::getData)
+    .define_method("message_id", &pulsar_rb::Message::getMessageId)
+    ;
+}

data/ext/bindings/message.hpp

@@ -0,0 +1,35 @@
+#ifndef __PULSAR_RUBY_CLIENT_MESSAGE_HPP
+#define __PULSAR_RUBY_CLIENT_MESSAGE_HPP
+
+#include "rice/Module.hpp"
+#include "rice/String.hpp"
+#include "rice/Data_Object.hpp"
+#include <pulsar/Client.h>
+
+namespace pulsar_rb {
+  class MessageId {
+  public:
+    pulsar::MessageId _msgId;
+    MessageId(const pulsar::MessageId& msgId) : _msgId(msgId) {};
+
+    Rice::String toString();
+
+    typedef Rice::Data_Object<MessageId> ptr;
+  };
+
+  class Message {
+  public:
+    pulsar::Message _msg;
+    Message(const pulsar::Message& msg) : _msg(msg) {};
+    Message(const std::string& data);
+
+    Rice::String getData();
+    MessageId::ptr getMessageId();
+
+    typedef Rice::Data_Object<Message> ptr;
+  };
+};
+
+void bind_message(Rice::Module& module);
+
+#endif

data/ext/bindings/producer.cpp

@@ -0,0 +1,69 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include <pulsar/Client.h>
+#include <ruby/thread.h>
+
+#include "producer.hpp"
+#include "util.hpp"
+
+namespace pulsar_rb {
+
+typedef struct {
+  pulsar::Producer& producer;
+  const pulsar::Message& message;
+  pulsar::Result result;
+} producer_send_task;
+
+void* producer_send_worker(void* taskPtr) {
+  producer_send_task& task = *(producer_send_task*)taskPtr;
+  task.result = task.producer.send(task.message);
+  return nullptr;
+}
+
+void Producer::send(const Message& message) {
+  producer_send_task task = { _producer, message._msg };
+  rb_thread_call_without_gvl(&producer_send_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+}
+
+}
+
+using namespace Rice;
+
+void bind_producer(Module& module) {
+  define_class_under<pulsar_rb::Producer>(module, "Producer")
+    .define_constructor(Constructor<pulsar_rb::Producer>())
+    .define_method("send", &pulsar_rb::Producer::send)
+    ;
+
+  define_class_under<pulsar_rb::ProducerConfiguration>(module, "ProducerConfiguration")
+    .define_constructor(Constructor<pulsar_rb::ProducerConfiguration>())
+    .define_method("producer_name", &ProducerConfiguration::getProducerName)
+    .define_method("producer_name=", &ProducerConfiguration::setProducerName)
+    // TODO .define_method("schema", &ProducerConfiguration::getSchema)
+    // TODO .define_method("schema=", &ProducerConfiguration::setSchema)
+    .define_method("send_timeout_millis", &ProducerConfiguration::getSendTimeout)
+    .define_method("send_timeout_millis=", &ProducerConfiguration::setSendTimeout)
+    .define_method("initial_sequence_id", &ProducerConfiguration::getInitialSequenceId)
+    .define_method("initial_sequence_id=", &ProducerConfiguration::setInitialSequenceId)
+    .define_method("compression_type", &ProducerConfiguration::getCompressionType)
+    .define_method("compression_type=", &ProducerConfiguration::setCompressionType)
+    .define_method("max_pending_messages", &ProducerConfiguration::getMaxPendingMessages)
+    .define_method("max_pending_messages=", &ProducerConfiguration::setMaxPendingMessages)
+    .define_method("max_pending_messages_across_partitions", &ProducerConfiguration::getMaxPendingMessagesAcrossPartitions)
+    .define_method("max_pending_messages_across_partitions=", &ProducerConfiguration::setMaxPendingMessagesAcrossPartitions)
+    .define_method("block_if_queue_full", &ProducerConfiguration::getBlockIfQueueFull)
+    .define_method("block_if_queue_full=", &ProducerConfiguration::setBlockIfQueueFull)
+    .define_method("partitions_routing_mode", &ProducerConfiguration::getPartitionsRoutingMode)
+    .define_method("partitions_routing_mode=", &ProducerConfiguration::setPartitionsRoutingMode)
+    .define_method("batching_enabled", &ProducerConfiguration::getBatchingEnabled)
+    .define_method("batching_enabled=", &ProducerConfiguration::setBatchingEnabled)
+    .define_method("batching_max_messages", &ProducerConfiguration::getBatchingMaxMessages)
+    .define_method("batching_max_messages=", &ProducerConfiguration::setBatchingMaxMessages)
+    .define_method("batching_max_allowed_size_in_bytes", &ProducerConfiguration::getBatchingMaxAllowedSizeInBytes)
+    .define_method("batching_max_allowed_size_in_bytes=", &ProducerConfiguration::setBatchingMaxAllowedSizeInBytes)
+    .define_method("batching_max_publish_delay_ms", &ProducerConfiguration::getBatchingMaxPublishDelayMs)
+    .define_method("batching_max_publish_delay_ms=", &ProducerConfiguration::setBatchingMaxPublishDelayMs)
+    .define_method("[]", &ProducerConfiguration::getProperty)
+    .define_method("[]=", &ProducerConfiguration::setProperty);
+}

data/ext/bindings/producer.hpp

@@ -0,0 +1,29 @@
+#ifndef __PULSAR_RUBY_CLIENT_PRODUCER_HPP
+#define __PULSAR_RUBY_CLIENT_PRODUCER_HPP
+
+#include "rice/Module.hpp"
+#include "rice/Data_Object.hpp"
+#include <pulsar/Client.h>
+
+#include "message.hpp"
+
+namespace pulsar_rb {
+  class Producer {
+  public:
+    pulsar::Producer _producer;
+    Producer() {};
+    Producer(const pulsar::Producer& producer) : _producer(producer) {}
+
+    void send(const Message& message);
+
+    typedef Rice::Data_Object<Producer> ptr;
+  };
+
+  // direct typedef instead of wrapping because implementations don't need any
+  // wrapping. but still re-namespaced for consistency
+  typedef pulsar::ProducerConfiguration ProducerConfiguration;
+};
+
+void bind_producer(Rice::Module& module);
+
+#endif

data/ext/bindings/util.cpp

@@ -0,0 +1,11 @@
+#include <pulsar/Client.h>
+
+#include "util.hpp"
+
+using namespace pulsar;
+
+void CheckResult(Result res) {
+  if (res != ResultOk) {
+    throw PulsarException(res);
+  }
+}

data/ext/bindings/util.hpp

@@ -0,0 +1,16 @@
+#ifndef __PULSAR_RUBY_CLIENT_UTIL_HPP
+#define __PULSAR_RUBY_CLIENT_UTIL_HPP
+
+#include <pulsar/Client.h>
+
+using namespace pulsar;
+
+struct PulsarException {
+    Result _result;
+    PulsarException(Result res) :
+            _result(res) {}
+};
+
+void CheckResult(Result res);
+
+#endif

data/lib/pulsar/client.rb

@@ -0,0 +1,58 @@
+#
+# 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 'pulsar/client/version'
+require 'pulsar/bindings'
+require 'pulsar/client_configuration'
+require 'pulsar/consumer'
+require 'pulsar/consumer_configuration'
+require 'pulsar/producer'
+
+module Pulsar
+  class Client
+    module RubySideTweaks
+      def initialize(service_url, config=nil)
+        config = Pulsar::ClientConfiguration.from(config)
+        super(service_url, config)
+      end
+
+      def create_producer(topic, config=nil)
+        config ||= Pulsar::ProducerConfiguration.new
+        super(topic, config)
+      end
+
+      def subscribe(topic, subscription_name, config=nil)
+        config ||= Pulsar::ConsumerConfiguration.new
+        super(topic, subscription_name, config)
+      end
+    end
+
+    prepend RubySideTweaks
+
+    def self.sufficient_environment?(config={})
+      config[:broker_uri] || ENV['PULSAR_BROKER_URI']
+    end
+
+    def self.from_environment(config={})
+      broker_uri = config[:broker_uri] || ENV['PULSAR_BROKER_URI']
+      config = Pulsar::ClientConfiguration.from_environment(config)
+      new(broker_uri, config)
+    end
+  end
+end

data/lib/pulsar/client/version.rb

@@ -0,0 +1,24 @@
+#
+# 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 Pulsar
+  class Client
+    VERSION = "2.4.1-beta.1"
+  end
+end

data/lib/pulsar/client_configuration.rb

@@ -0,0 +1,77 @@
+#
+# 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 'pulsar/bindings'
+
+module Pulsar
+  class ClientConfiguration
+    def self.from(config)
+      case config
+      when self then config # already a config object
+      when nil then self.new # empty (all defaults) config object
+      when Hash then self.new(config) # config object from hash
+      else raise ArgumentError
+      end
+    end
+
+    def self.from_environment(config={})
+      env_config = {}
+      if ENV.key?('PULSAR_CERT_PATH')
+        env_config[:use_tls] = true
+        env_config[:tls_allow_insecure_connection] = false
+        env_config[:tls_validate_hostname] = false
+        env_config[:tls_trust_certs_file_path] = ENV['PULSAR_CERT_PATH']
+      end
+      if ENV.key?('PULSAR_AUTH_TOKEN')
+        env_config[:authentication_token] = ENV['PULSAR_AUTH_TOKEN']
+      end
+      self.from(env_config.merge(config))
+    end
+
+    module RubySideTweaks
+      def initialize(config={})
+        super()
+        populate(config)
+      end
+    end
+
+    prepend RubySideTweaks
+
+    def populate(config={})
+      populate_one(config, :authentication_token)
+      populate_one(config, :operation_timeout_seconds)
+      populate_one(config, :io_threads)
+      populate_one(config, :message_listener_threads)
+      populate_one(config, :concurrent_lookup_requests)
+      populate_one(config, :log_conf_file_path)
+      populate_one(config, :use_tls)
+      populate_one(config, :tls_trust_certs_file_path)
+      populate_one(config, :tls_allow_insecure_connection)
+      populate_one(config, :tls_validate_hostname)
+    end
+
+    def populate_one(config, key)
+      if config.key?(key)
+        self.send(:"#{key}=", config[key])
+      elsif config.key?(key.to_s)
+        self.send(:"#{key}=", config[key.to_s])
+      end
+    end
+  end
+end

data/lib/pulsar/consumer.rb

@@ -0,0 +1,51 @@
+#
+# 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 'pulsar/bindings'
+
+module Pulsar
+  class Consumer
+    class ListenerToken
+      def initialize
+        @active = true
+      end
+
+      def finish
+        @active = false
+      end
+
+      def active?
+        @active
+      end
+    end
+
+    def listen
+      listener = ListenerToken.new
+      while listener.active?
+        msg = receive
+        yield msg.data, msg.message_id, lambda { listener.finish }
+        acknowledge(msg)
+      end
+    end
+
+    def listen_in_thread
+      Thread.new { listen }
+    end
+  end
+end