pulsar-client 2.4.1.pre.beta.4 → 2.6.1.pre.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c1c7a05a2b9433fa4f42806e8bd137ece22739ac
-  data.tar.gz: b6334ee753db02b55b58c77de39d491ef117e41d
+SHA256:
+  metadata.gz: '0812c85307bcd4017c169592a1547e8249a4193f2d381b0f845f6ce27ab637ec'
+  data.tar.gz: a5581a355348dc9eec95184dfe1a1ff92f2a0858e871c22d6f7cd97f513f50da
 SHA512:
-  metadata.gz: cf2a458f982a7a122605aec8a2adc30082965cddfeaa7c22bea870c980960a10195f79bb23bc0f85da924a224668d195240fdcae63557e9fe8dee482ca0fe67e
-  data.tar.gz: 1ff0ed8fc97b91dbedea5b69d1fc1825fc36fa47d5bded88088c40a128598b8cf72821cc129ace4b0f2c85efa84b429d6247955d3f0005fb4966486af1e4e65e
+  metadata.gz: 76e1855a6cfc363fafe991fbe2e5bd99c9e8f844f7107c79d2494a65185703ea32f30f7b626bcbf0bd26d38227cc7b42f66baee2d15c023fc8d1ea8a115f8f21
+  data.tar.gz: 51cb6884e39d20e8806d17a4ae76954c30b14ef7f19e7c49540ec15411c60845d8c871b03bd0afbf18f17982c2329af60db77a4f4d6ab772b320cba263ad3be7

data/.gitignore

@@ -13,3 +13,10 @@
 # build artifacts
 lib/pulsar/bindings.bundle
 *.gem
+
+spec/pulsar/ext/bindings.bundle
+spec/pulsar/ext/bindings.o
+spec/pulsar/ext/Makefile
+
+# Intellij IDEA
+.idea/

data/.travis.yml

@@ -1,5 +1,16 @@
+dist: bionic # ubuntu 18.04
 sudo: false
 language: ruby
 rvm:
-  - 2.4.3
-before_install: gem install bundler -v 1.16.1
+  - 2.4.9 # oldest pre-install on bionic
+install:
+  - sudo apt-get -y install apt-utils automake
+  # - sudo apt-get upgrade libstdc++6
+  - wget https://archive.apache.org/dist/pulsar/pulsar-2.6.1/DEB/apache-pulsar-client.deb
+  - wget https://archive.apache.org/dist/pulsar/pulsar-2.6.1/DEB/apache-pulsar-client-dev.deb
+  - sudo apt-get -y install ./apache-pulsar-client.deb
+  - sudo apt-get -y install ./apache-pulsar-client-dev.deb
+  - gem install bundler -v 1.16.1
+  - bundle install
+script:
+  - rake

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    pulsar-client (0.0.1)
-      rake-compiler
-      rice
+    pulsar-client (2.6.1.pre.beta.1)
+      rake-compiler (~> 1.0)
+      rice (~> 2.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.3)
     rake (10.5.0)
-    rake-compiler (1.0.7)
+    rake-compiler (1.1.1)
       rake
-    rice (2.1.3)
+    rice (2.2.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)

data/README.md

@@ -5,7 +5,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "pulsar-client", "~> 2.4.1.pre"
+gem "pulsar-client", "~> 2.6.1.pre"
 ```
 
 And then execute:
@@ -18,7 +18,7 @@ Or install it yourself as:
 
 Note #1: You will need libpulsar (for linking) and libpulsar-dev (for
 C++ client header files, for compiling) installed first. For both, the
-Gem currently targets version 2.4.1. If your libpulsar is older, it will
+Gem currently targets version 2.6.1. If your libpulsar is older, it will
 fail to compile. If it is newer, it _might_ compile is not guaranteed.
 
 Note #2: This is a pre-release version of this Gem. You will need the
@@ -30,7 +30,9 @@ the `.pre` suffix in the Gemfile to install it via Bundler.
 Setup and basic `consumer.receive` example:
 
 ```ruby
-# have these in your shell with appropriate values
+# use a standard Pulsar client config (see https://github.com/apache/pulsar/blob/master/conf/client.conf)
+# export PULSAR_CLIENT_CONF=/path/to/your/client/conf/client_conf.conf
+# OR, if not present have these in your shell with appropriate values
 # export PULSAR_BROKER_URI=pulsar://your-pulsar-broker:6651
 # export PULSAR_CERT_PATH=/path/to/your/pulsar-ca.pem
 # export PULSAR_AUTH_TOKEN=your-auth-token

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/extensiontask"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default => [:compile, :spec]
 
 Rake::ExtensionTask.new "bindings" do |ext|
   ext.lib_dir = "lib/pulsar"

data/bin/example-consumer

@@ -23,14 +23,17 @@ $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
 
 require "pulsar/client"
 
-unless ARGV.size >= 1 && ARGV.size <= 2 && !Pulsar::Client.sufficient_environment?
+unless ARGV.size >= 1 && ARGV.size <= 2 && Pulsar::Client.sufficient_environment?
   puts "Usage: #{__FILE__} <topic> [consumer-name]"
   puts
   puts "If not specified, the consumer name defaults to 'example-consumer'."
   puts
-  puts "Additionally, the PULSAR_BROKER_URI environment variable must be set. Optional"
-  puts "PULSAR_CERT_PATH and PULSAR_AUTH_TOKEN environment variables are also"
-  puts "recognized."
+  puts "If set, PULSAR_CLIENT_CONF is loaded and used as a configuration."
+  puts "Broker URI, TLS settings and the authorization token to use is loaded"
+  puts "from this file."
+  puts "If this variable is not present, the PULSAR_BROKER_URI environment variable"
+  puts "must be set. In this case PULSAR_CERT_PATH and PULSAR_AUTH_TOKEN environment"
+  puts "variables are also recognized."
   exit 1
 end
 

data/bin/example-producer

@@ -23,16 +23,19 @@ $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
 
 require "pulsar/client"
 
-unless ARGV.size == 1 && !Pulsar::Client.sufficient_environment?
+unless ARGV.size == 1 && Pulsar::Client.sufficient_environment?
   puts "Usage: #{__FILE__} <topic>"
   puts
-  puts "Additionally, the PULSAR_BROKER_URI environment variable must be set. Optional"
-  puts "PULSAR_CERT_PATH and PULSAR_AUTH_TOKEN environment variables are also"
-  puts "recognized."
+  puts "If set, PULSAR_CLIENT_CONF is loaded and used as a configuration."
+  puts "Broker URI, TLS settings and the authorization token to use is loaded"
+  puts "from this file."
+  puts "If this variable is not present, the PULSAR_BROKER_URI environment variable"
+  puts "must be set. In this case PULSAR_CERT_PATH and PULSAR_AUTH_TOKEN environment"
+  puts "variables are also recognized."
   exit 1
 end
 
-topic = ARGV[0]
+topic = ARGV.shift
 client = Pulsar::Client.from_environment
 producer = client.create_producer(topic)
 while data = gets

data/ext/bindings/client.cpp

@@ -4,6 +4,7 @@
 #include <ruby/thread.h>
 
 #include "client.hpp"
+#include "logger.hpp"
 #include "util.hpp"
 
 namespace pulsar_rb {
@@ -55,6 +56,25 @@ void ClientConfiguration::setLogConfFilePath(const std::string& path) {
   _config.setLogConfFilePath(path);
 }
 
+void ClientConfiguration::setSilentLogging(bool enable) {
+  // The logger can only be set once, so if it's already on we cannot disable it.
+  if (silentLogging) {
+    if (!enable) {
+      throw Rice::Exception(rb_eArgError, "silent_logging can only be set once");
+    }
+  }
+
+  if (enable) {
+    silentLogging = true;
+    std::unique_ptr<LoggerFactory> loggerFactory = SilentLoggerFactory::create();
+    _config.setLogger(loggerFactory.release());
+  }
+}
+
+bool ClientConfiguration::getSilentLogging() {
+  return silentLogging;
+}
+
 bool ClientConfiguration::isUseTls() {
   return _config.isUseTls();
 }
@@ -175,6 +195,8 @@ void bind_client(Module& module) {
     .define_method("concurrent_lookup_requests=", &pulsar_rb::ClientConfiguration::setConcurrentLookupRequest)
     .define_method("log_conf_file_path", &pulsar_rb::ClientConfiguration::getLogConfFilePath)
     .define_method("log_conf_file_path=", &pulsar_rb::ClientConfiguration::setLogConfFilePath)
+    .define_method("silent_logging?", &pulsar_rb::ClientConfiguration::getSilentLogging)
+    .define_method("silent_logging=", &pulsar_rb::ClientConfiguration::setSilentLogging)
     .define_method("use_tls?", &pulsar_rb::ClientConfiguration::isUseTls)
     .define_method("use_tls=", &pulsar_rb::ClientConfiguration::setUseTls)
     .define_method("tls_trust_certs_file_path", &pulsar_rb::ClientConfiguration::getTlsTrustCertsFilePath)

data/ext/bindings/client.hpp

@@ -13,6 +13,7 @@ namespace pulsar_rb {
   class ClientConfiguration {
   public:
     pulsar::ClientConfiguration _config;
+    bool silentLogging = false;
     ClientConfiguration();
 
     void setAuthFromToken(const std::string &token);
@@ -26,6 +27,8 @@ namespace pulsar_rb {
     void setConcurrentLookupRequest(int n);
     std::string getLogConfFilePath();
     void setLogConfFilePath(const std::string& path);
+    void setSilentLogging(bool);
+    bool getSilentLogging();
     bool isUseTls();
     void setUseTls(bool enable);
     std::string getTlsTrustCertsFilePath();

data/ext/bindings/consumer.cpp

@@ -16,6 +16,11 @@ typedef struct {
   pulsar::Result result;
 } consumer_receive_job;
 
+typedef struct {
+  pulsar::Consumer& consumer;
+  pulsar::Result result;
+} consumer_close_task;
+
 void* consumer_receive_nogvl(void* jobPtr) {
   consumer_receive_job& job = *(consumer_receive_job*)jobPtr;
   if (job.timeout_ms > 0) {
@@ -46,6 +51,18 @@ void Consumer::negative_acknowledge(const Message& message) {
   _consumer.negativeAcknowledge(message._msg);
 }
 
+void* consumer_close_worker(void* taskPtr) {
+  consumer_close_task& task = *(consumer_close_task*)taskPtr;
+  task.result = task.consumer.close();
+  return nullptr;
+}
+
+void Consumer::close() {
+  consumer_close_task task = { _consumer };
+  rb_thread_call_without_gvl(&consumer_close_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+}
+
 }
 
 using namespace Rice;
@@ -56,6 +73,7 @@ void bind_consumer(Module &module) {
     .define_method("receive", &pulsar_rb::Consumer::receive, (Arg("timeout_ms") = 0))
     .define_method("acknowledge", &pulsar_rb::Consumer::acknowledge)
     .define_method("negative_acknowledge", &pulsar_rb::Consumer::negative_acknowledge)
+    .define_method("close", &pulsar_rb::Consumer::close)
     ;
 
   define_enum<pulsar::ConsumerType>("ConsumerType", module)

data/ext/bindings/consumer.hpp

@@ -17,6 +17,7 @@ namespace pulsar_rb {
     Message::ptr receive(unsigned int timeout_ms=0);
     void acknowledge(const Message& message);
     void negative_acknowledge(const Message& message);
+    void close();
 
     typedef Rice::Data_Object<Consumer> ptr;
   };

data/ext/bindings/extconf.rb

@@ -1,3 +1,4 @@
 require 'mkmf-rice'
 $LOCAL_LIBS << "-lpulsar"
+$CXXFLAGS += " -std=c++11 "
 create_makefile('pulsar/bindings')

data/ext/bindings/logger.cpp

@@ -0,0 +1,23 @@
+#include <pulsar/Logger.h>
+
+#include "logger.hpp"
+
+namespace pulsar_rb {
+
+class SilentLogger : public pulsar::Logger {
+  std::string _logger;
+
+  public:
+    SilentLogger(const std::string &logger) : _logger(logger) {}
+
+    bool isEnabled(Level level) { return false; }
+    void log(Level level, int line, const std::string &message) { }
+};
+
+pulsar::Logger *SilentLoggerFactory::getLogger(const std::string& file) { return new SilentLogger(file); }
+
+std::unique_ptr<pulsar::LoggerFactory> SilentLoggerFactory::create() {
+  return std::unique_ptr<pulsar::LoggerFactory>(new SilentLoggerFactory());
+}
+
+}

data/ext/bindings/logger.hpp

@@ -0,0 +1,17 @@
+#ifndef __PULSAR_RUBY_CLIENT_LOGGER_HPP
+#define __PULSAR_RUBY_CLIENT_LOGGER_HPP
+
+#include <pulsar/Logger.h>
+
+namespace pulsar_rb {
+
+class SilentLoggerFactory : public pulsar::LoggerFactory {
+  public:
+    pulsar::Logger* getLogger(const std::string& fileName);
+
+    static std::unique_ptr<pulsar::LoggerFactory> create();
+};
+
+}
+
+#endif

data/ext/bindings/message.cpp

@@ -1,8 +1,10 @@
 #include "rice/Data_Type.hpp"
 #include "rice/Constructor.hpp"
+#include "rice/Exception.hpp"
 #include <pulsar/Client.h>
 
 #include "message.hpp"
+#include "stringmap.hpp"
 
 namespace pulsar_rb {
 
@@ -12,9 +14,32 @@ Rice::String MessageId::toString() {
   return Rice::String(ss.str());
 }
 
-Message::Message(const std::string& data) {
+Message::Message(const std::string& data, Rice::Object arg = Rice::Object()) {
   pulsar::MessageBuilder mb;
   mb.setContent(data);
+
+  if (arg && arg.rb_type() != T_NONE) {
+    Rice::Hash opts = Rice::Hash(arg);
+    Rice::Hash::iterator it = opts.begin();
+    Rice::Hash::iterator end = opts.end();
+    std::string key;
+    for (; it != end; ++it) {
+      key = it->key.to_s().str();
+      if (key == "properties"){
+        Rice::Object value = Rice::Object(it->value);
+        if (value.rb_type() != T_NIL) {
+          mb.setProperties(from_ruby<pulsar::StringMap>(value));
+        }
+      } else if (key == "partition_key") {
+        mb.setPartitionKey(Rice::Object(it->value).to_s().str());
+      } else if (key == "ordering_key") {
+        mb.setOrderingKey(Rice::Object(it->value).to_s().str());
+      } else {
+        throw Rice::Exception(rb_eArgError, "Unknown keyword argument: %s", key.c_str());
+      }
+    }
+  }
+
   _msg = mb.build();
 }
 
@@ -28,6 +53,18 @@ MessageId::ptr Message::getMessageId() {
   return MessageId::ptr(new MessageId(messageId));
 }
 
+Rice::Hash Message::getProperties() {
+  return to_ruby(_msg.getProperties());
+}
+
+Rice::String Message::getPartitionKey() {
+  return to_ruby(_msg.getPartitionKey());
+}
+
+Rice::String Message::getOrderingKey() {
+  return to_ruby(_msg.getOrderingKey());
+}
+
 }
 
 using namespace Rice;
@@ -40,8 +77,12 @@ void bind_message(Module& module) {
 
   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_constructor(Constructor<pulsar_rb::Message, const std::string&, const Rice::Object>(),
+          (Rice::Arg("data"), Rice::Arg("options") = Rice::Object()))
     .define_method("data", &pulsar_rb::Message::getData)
     .define_method("message_id", &pulsar_rb::Message::getMessageId)
+    .define_method("properties", &pulsar_rb::Message::getProperties)
+    .define_method("partition_key", &pulsar_rb::Message::getPartitionKey)
+    .define_method("ordering_key", &pulsar_rb::Message::getOrderingKey)
     ;
 }

data/ext/bindings/message.hpp

@@ -1,6 +1,7 @@
 #ifndef __PULSAR_RUBY_CLIENT_MESSAGE_HPP
 #define __PULSAR_RUBY_CLIENT_MESSAGE_HPP
 
+#include "rice/Hash.hpp"
 #include "rice/Module.hpp"
 #include "rice/String.hpp"
 #include "rice/Data_Object.hpp"
@@ -21,10 +22,13 @@ namespace pulsar_rb {
   public:
     pulsar::Message _msg;
     Message(const pulsar::Message& msg) : _msg(msg) {};
-    Message(const std::string& data);
+    Message(const std::string& data, Rice::Object opts);
 
     Rice::String getData();
     MessageId::ptr getMessageId();
+    Rice::Hash getProperties();
+    Rice::String getPartitionKey();
+    Rice::String getOrderingKey();
 
     typedef Rice::Data_Object<Message> ptr;
   };

data/ext/bindings/producer.cpp

@@ -14,6 +14,11 @@ typedef struct {
   pulsar::Result result;
 } producer_send_task;
 
+typedef struct {
+  pulsar::Producer& producer;
+  pulsar::Result result;
+} producer_close_task;
+
 void* producer_send_worker(void* taskPtr) {
   producer_send_task& task = *(producer_send_task*)taskPtr;
   task.result = task.producer.send(task.message);
@@ -26,6 +31,18 @@ void Producer::send(const Message& message) {
   CheckResult(task.result);
 }
 
+void* producer_close_worker(void* taskPtr) {
+  producer_close_task& task = *(producer_close_task*)taskPtr;
+  task.result = task.producer.close();
+  return nullptr;
+}
+
+void Producer::close() {
+  producer_close_task task = { _producer };
+  rb_thread_call_without_gvl(&producer_close_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+}
+
 }
 
 using namespace Rice;
@@ -34,6 +51,7 @@ 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_method("close", &pulsar_rb::Producer::close)
     ;
 
   define_class_under<pulsar_rb::ProducerConfiguration>(module, "ProducerConfiguration")

data/ext/bindings/producer.hpp

@@ -15,6 +15,7 @@ namespace pulsar_rb {
     Producer(const pulsar::Producer& producer) : _producer(producer) {}
 
     void send(const Message& message);
+    void close();
 
     typedef Rice::Data_Object<Producer> ptr;
   };

data/ext/bindings/stringmap.cpp

@@ -0,0 +1,33 @@
+#include "rice/Hash.hpp"
+
+#include "stringmap.hpp"
+
+template<>
+pulsar::StringMap from_ruby<pulsar::StringMap>(Rice::Object o)
+{
+  Rice::Hash h(o);
+  pulsar::StringMap m;
+  Rice::Hash::iterator it = h.begin();
+  Rice::Hash::iterator end = h.end();
+  for(; it != end; ++it) {
+    m[it->key.to_s().str()] = Rice::Object(it->value).to_s().str();
+  }
+  return m;
+}
+
+template<>
+Rice::Object to_ruby<pulsar::StringMap>(pulsar::StringMap const & m)
+{
+  Rice::Hash h = Rice::Hash();
+
+  pulsar::StringMap::const_iterator it = m.begin();
+  pulsar::StringMap::const_iterator end = m.end();
+  for(; it != end; ++it) {
+    h[Rice::String(it->first)] = Rice::String(it->second);
+  }
+
+  // Be clear that calling hash[x]= will have no effect.
+  h.freeze();
+
+  return h;
+}

data/ext/bindings/stringmap.hpp

@@ -0,0 +1,13 @@
+#ifndef __PULSAR_RUBY_CLIENT_STRINGMAP_HPP
+#define __PULSAR_RUBY_CLIENT_STRINGMAP_HPP
+
+#include "rice/Object.hpp"
+#include <pulsar/Client.h>
+
+template<>
+pulsar::StringMap from_ruby<pulsar::StringMap>(Rice::Object o);
+
+template<>
+Rice::Object to_ruby<pulsar::StringMap>(pulsar::StringMap const & m);
+
+#endif

data/ext/bindings/util.cpp

@@ -5,19 +5,179 @@
 
 using namespace Rice;
 
+// Result enum found in pulsar-*/pulsar-client-cpp/include/pulsar/Result.h
+
 VALUE rb_ePulsarError = Qnil;
+VALUE rb_ePulsarError_UnknownError = Qnil;
+VALUE rb_ePulsarError_InvalidConfiguration = Qnil;
 VALUE rb_ePulsarError_Timeout = Qnil;
+VALUE rb_ePulsarError_LookupError = Qnil;
+VALUE rb_ePulsarError_ConnectError = Qnil;
+VALUE rb_ePulsarError_ReadError = Qnil;
+VALUE rb_ePulsarError_AuthenticationError = Qnil;
+VALUE rb_ePulsarError_AuthorizationError = Qnil;
+VALUE rb_ePulsarError_ErrorGettingAuthenticationData = Qnil;
+VALUE rb_ePulsarError_BrokerMetadataError = Qnil;
+VALUE rb_ePulsarError_BrokerPersistenceError = Qnil;
+VALUE rb_ePulsarError_ChecksumError = Qnil;
+VALUE rb_ePulsarError_ConsumerBusy = Qnil;
+VALUE rb_ePulsarError_NotConnected = Qnil;
+VALUE rb_ePulsarError_AlreadyClosed = Qnil;
+VALUE rb_ePulsarError_InvalidMessage = Qnil;
+VALUE rb_ePulsarError_ConsumerNotInitialized = Qnil;
+VALUE rb_ePulsarError_ProducerNotInitialized = Qnil;
+VALUE rb_ePulsarError_ProducerBusy = Qnil;
+VALUE rb_ePulsarError_TooManyLookupRequestException = Qnil;
+VALUE rb_ePulsarError_InvalidTopicName = Qnil;
+VALUE rb_ePulsarError_InvalidUrl = Qnil;
+VALUE rb_ePulsarError_ServiceUnitNotReady = Qnil;
+VALUE rb_ePulsarError_OperationNotSupported = Qnil;
+VALUE rb_ePulsarError_ProducerBlockedQuotaExceededError = Qnil;
+VALUE rb_ePulsarError_ProducerBlockedQuotaExceededException = Qnil;
+VALUE rb_ePulsarError_ProducerQueueIsFull = Qnil;
+VALUE rb_ePulsarError_MessageTooBig = Qnil;
+VALUE rb_ePulsarError_TopicNotFound = Qnil;
+VALUE rb_ePulsarError_SubscriptionNotFound = Qnil;
+VALUE rb_ePulsarError_ConsumerNotFound = Qnil;
+VALUE rb_ePulsarError_UnsupportedVersionError = Qnil;
+VALUE rb_ePulsarError_TopicTerminated = Qnil;
+VALUE rb_ePulsarError_CryptoError = Qnil;
+VALUE rb_ePulsarError_IncompatibleSchema = Qnil;
+VALUE rb_ePulsarError_ConsumerAssignError = Qnil;
+VALUE rb_ePulsarError_CumulativeAcknowledgementNotAllowedError = Qnil;
+VALUE rb_ePulsarError_TransactionCoordinatorNotFoundError = Qnil;
+VALUE rb_ePulsarError_InvalidTxnStatusError = Qnil;
+VALUE rb_ePulsarError_NotAllowedError = Qnil;
 
 void bind_errors(Module &module) {
   rb_ePulsarError = rb_define_class_under(module.value(), "Error", rb_eStandardError);
+  rb_ePulsarError_UnknownError = rb_define_class_under(rb_ePulsarError, "UnknownError", rb_ePulsarError);
+  rb_ePulsarError_InvalidConfiguration = rb_define_class_under(rb_ePulsarError, "InvalidConfiguration", rb_ePulsarError);
   rb_ePulsarError_Timeout = rb_define_class_under(rb_ePulsarError, "Timeout", rb_ePulsarError);
+  rb_ePulsarError_LookupError = rb_define_class_under(rb_ePulsarError, "LookupError", rb_ePulsarError);
+  rb_ePulsarError_ConnectError = rb_define_class_under(rb_ePulsarError, "ConnectError", rb_ePulsarError);
+  rb_ePulsarError_ReadError = rb_define_class_under(rb_ePulsarError, "ReadError", rb_ePulsarError);
+  rb_ePulsarError_AuthenticationError = rb_define_class_under(rb_ePulsarError, "AuthenticationError", rb_ePulsarError);
+  rb_ePulsarError_AuthorizationError = rb_define_class_under(rb_ePulsarError, "AuthorizationError", rb_ePulsarError);
+  rb_ePulsarError_ErrorGettingAuthenticationData = rb_define_class_under(rb_ePulsarError, "ErrorGettingAuthenticationData", rb_ePulsarError);
+  rb_ePulsarError_BrokerMetadataError = rb_define_class_under(rb_ePulsarError, "BrokerMetadataError", rb_ePulsarError);
+  rb_ePulsarError_BrokerPersistenceError = rb_define_class_under(rb_ePulsarError, "BrokerPersistenceError", rb_ePulsarError);
+  rb_ePulsarError_ChecksumError = rb_define_class_under(rb_ePulsarError, "ChecksumError", rb_ePulsarError);
+  rb_ePulsarError_ConsumerBusy = rb_define_class_under(rb_ePulsarError, "ConsumerBusy", rb_ePulsarError);
+  rb_ePulsarError_NotConnected = rb_define_class_under(rb_ePulsarError, "NotConnected", rb_ePulsarError);
+  rb_ePulsarError_AlreadyClosed = rb_define_class_under(rb_ePulsarError, "AlreadyClosed", rb_ePulsarError);
+  rb_ePulsarError_InvalidMessage = rb_define_class_under(rb_ePulsarError, "InvalidMessage", rb_ePulsarError);
+  rb_ePulsarError_ConsumerNotInitialized = rb_define_class_under(rb_ePulsarError, "ConsumerNotInitialized", rb_ePulsarError);
+  rb_ePulsarError_ProducerNotInitialized = rb_define_class_under(rb_ePulsarError, "ProducerNotInitialized", rb_ePulsarError);
+  rb_ePulsarError_ProducerBusy = rb_define_class_under(rb_ePulsarError, "ProducerBusy", rb_ePulsarError);
+  rb_ePulsarError_TooManyLookupRequestException = rb_define_class_under(rb_ePulsarError, "TooManyLookupRequestException", rb_ePulsarError);
+  rb_ePulsarError_InvalidTopicName = rb_define_class_under(rb_ePulsarError, "InvalidTopicName", rb_ePulsarError);
+  rb_ePulsarError_InvalidUrl = rb_define_class_under(rb_ePulsarError, "InvalidUrl", rb_ePulsarError);
+  rb_ePulsarError_ServiceUnitNotReady = rb_define_class_under(rb_ePulsarError, "ServiceUnitNotReady", rb_ePulsarError);
+  rb_ePulsarError_OperationNotSupported = rb_define_class_under(rb_ePulsarError, "OperationNotSupported", rb_ePulsarError);
+  rb_ePulsarError_ProducerBlockedQuotaExceededError = rb_define_class_under(rb_ePulsarError, "ProducerBlockedQuotaExceededError", rb_ePulsarError);
+  rb_ePulsarError_ProducerBlockedQuotaExceededException = rb_define_class_under(rb_ePulsarError, "ProducerBlockedQuotaExceededException", rb_ePulsarError);
+  rb_ePulsarError_ProducerQueueIsFull = rb_define_class_under(rb_ePulsarError, "ProducerQueueIsFull", rb_ePulsarError);
+  rb_ePulsarError_MessageTooBig = rb_define_class_under(rb_ePulsarError, "MessageTooBig", rb_ePulsarError);
+  rb_ePulsarError_TopicNotFound = rb_define_class_under(rb_ePulsarError, "TopicNotFound", rb_ePulsarError);
+  rb_ePulsarError_SubscriptionNotFound = rb_define_class_under(rb_ePulsarError, "SubscriptionNotFound", rb_ePulsarError);
+  rb_ePulsarError_ConsumerNotFound = rb_define_class_under(rb_ePulsarError, "ConsumerNotFound", rb_ePulsarError);
+  rb_ePulsarError_UnsupportedVersionError = rb_define_class_under(rb_ePulsarError, "UnsupportedVersionError", rb_ePulsarError);
+  rb_ePulsarError_TopicTerminated = rb_define_class_under(rb_ePulsarError, "TopicTerminated", rb_ePulsarError);
+  rb_ePulsarError_CryptoError = rb_define_class_under(rb_ePulsarError, "CryptoError", rb_ePulsarError);
+  rb_ePulsarError_IncompatibleSchema = rb_define_class_under(rb_ePulsarError, "IncompatibleSchema", rb_ePulsarError);
+  rb_ePulsarError_ConsumerAssignError = rb_define_class_under(rb_ePulsarError, "ConsumerAssignError", rb_ePulsarError);
+  rb_ePulsarError_CumulativeAcknowledgementNotAllowedError = rb_define_class_under(rb_ePulsarError, "CumulativeAcknowledgementNotAllowedError", rb_ePulsarError);
+  rb_ePulsarError_TransactionCoordinatorNotFoundError = rb_define_class_under(rb_ePulsarError, "TransactionCoordinatorNotFoundError", rb_ePulsarError);
+  rb_ePulsarError_InvalidTxnStatusError = rb_define_class_under(rb_ePulsarError, "InvalidTxnStatusError", rb_ePulsarError);
+  rb_ePulsarError_NotAllowedError = rb_define_class_under(rb_ePulsarError, "NotAllowedError", rb_ePulsarError);
 }
 
 void CheckResult(pulsar::Result res) {
-  if (res == pulsar::ResultTimeout) {
-    throw Exception(rb_ePulsarError_Timeout, "pulsar timeout");
-  }
-  else if (res != ResultOk) {
-    throw Exception(rb_ePulsarError, "unexpected pulsar exception: %d", res);
+  if (res != pulsar::ResultOk) {
+    switch(res) {
+      case pulsar::ResultUnknownError:
+        throw Exception(rb_ePulsarError_UnknownError, "Unknown error happened on broker"); break;
+      case pulsar::ResultInvalidConfiguration:
+        throw Exception(rb_ePulsarError_InvalidConfiguration, "Invalid configuration"); break;
+      case pulsar::ResultTimeout:
+        throw Exception(rb_ePulsarError_Timeout, "Operation timed out"); break;
+      case pulsar::ResultLookupError:
+        throw Exception(rb_ePulsarError_LookupError, "Broker lookup failed"); break;
+      case pulsar::ResultConnectError:
+        throw Exception(rb_ePulsarError_ConnectError, "Failed to connect to broker"); break;
+      case pulsar::ResultReadError:
+        throw Exception(rb_ePulsarError_ReadError, "Failed to read from socket"); break;
+      case pulsar::ResultAuthenticationError:
+        throw Exception(rb_ePulsarError_AuthenticationError, "Authentication failed on broker"); break;
+      case pulsar::ResultAuthorizationError:
+        throw Exception(rb_ePulsarError_AuthorizationError, "Client is not authorized to create producer/consumer"); break;
+      case pulsar::ResultErrorGettingAuthenticationData:
+        throw Exception(rb_ePulsarError_ErrorGettingAuthenticationData, "Client cannot find authorization data"); break;
+      case pulsar::ResultBrokerMetadataError:
+        throw Exception(rb_ePulsarError_BrokerMetadataError, "Broker failed in updating metadata"); break;
+      case pulsar::ResultBrokerPersistenceError:
+        throw Exception(rb_ePulsarError_BrokerPersistenceError, "Broker failed to persist entry"); break;
+      case pulsar::ResultChecksumError:
+        throw Exception(rb_ePulsarError_ChecksumError, "Corrupt message checksum failure"); break;
+      case pulsar::ResultConsumerBusy:
+        throw Exception(rb_ePulsarError_ConsumerBusy, "Exclusive consumer is already connected"); break;
+      case pulsar::ResultNotConnected:
+        throw Exception(rb_ePulsarError_NotConnected, "Producer/Consumer is not currently connected to broker"); break;
+      case pulsar::ResultAlreadyClosed:
+        throw Exception(rb_ePulsarError_AlreadyClosed, "Producer/Consumer is already closed and not accepting any operation"); break;
+      case pulsar::ResultInvalidMessage:
+        throw Exception(rb_ePulsarError_InvalidMessage, "Error in publishing an already used message"); break;
+      case pulsar::ResultConsumerNotInitialized:
+        throw Exception(rb_ePulsarError_ConsumerNotInitialized, "Consumer is not initialized"); break;
+      case pulsar::ResultProducerNotInitialized:
+        throw Exception(rb_ePulsarError_ProducerNotInitialized, "Producer is not initialized"); break;
+      case pulsar::ResultProducerBusy:
+        throw Exception(rb_ePulsarError_ProducerBusy, "Producer with same name is already connected"); break;
+      case pulsar::ResultTooManyLookupRequestException:
+        throw Exception(rb_ePulsarError_TooManyLookupRequestException, "Too Many concurrent LookupRequest"); break;
+      case pulsar::ResultInvalidTopicName:
+        throw Exception(rb_ePulsarError_InvalidTopicName, "Invalid topic name"); break;
+      case pulsar::ResultInvalidUrl:
+        throw Exception(rb_ePulsarError_InvalidUrl, "Client Initialized with Invalid Broker Url (VIP Url passed to Client Constructor)"); break;
+      case pulsar::ResultServiceUnitNotReady:
+        throw Exception(rb_ePulsarError_ServiceUnitNotReady, "Service Unit unloaded between client did lookup and producer/consumer got created"); break;
+      case pulsar::ResultOperationNotSupported:
+        throw Exception(rb_ePulsarError_OperationNotSupported, "Operation not supported"); break;
+      case pulsar::ResultProducerBlockedQuotaExceededError:
+        throw Exception(rb_ePulsarError_ProducerBlockedQuotaExceededError, "Producer is blocked"); break;
+      case pulsar::ResultProducerBlockedQuotaExceededException:
+        throw Exception(rb_ePulsarError_ProducerBlockedQuotaExceededException, "Producer is getting exception"); break;
+      case pulsar::ResultProducerQueueIsFull:
+        throw Exception(rb_ePulsarError_ProducerQueueIsFull, "Producer queue is full"); break;
+      case pulsar::ResultMessageTooBig:
+        throw Exception(rb_ePulsarError_MessageTooBig, "Trying to send a messages exceeding the max size"); break;
+      case pulsar::ResultTopicNotFound:
+        throw Exception(rb_ePulsarError_TopicNotFound, "Topic not found"); break;
+      case pulsar::ResultSubscriptionNotFound:
+        throw Exception(rb_ePulsarError_SubscriptionNotFound, "Subscription not found"); break;
+      case pulsar::ResultConsumerNotFound:
+        throw Exception(rb_ePulsarError_ConsumerNotFound, "Consumer not found"); break;
+      case pulsar::ResultUnsupportedVersionError:
+        throw Exception(rb_ePulsarError_UnsupportedVersionError, "Error when an older client/version doesn't support a required feature"); break;
+      case pulsar::ResultTopicTerminated:
+        throw Exception(rb_ePulsarError_TopicTerminated, "Topic was already terminated"); break;
+      case pulsar::ResultCryptoError:
+        throw Exception(rb_ePulsarError_CryptoError, "Error when crypto operation fails"); break;
+      case pulsar::ResultIncompatibleSchema:
+        throw Exception(rb_ePulsarError_IncompatibleSchema, "Specified schema is incompatible with the topic's schema"); break;
+      case pulsar::ResultConsumerAssignError:
+        throw Exception(rb_ePulsarError_ConsumerAssignError, "Error when a new consumer connected but can't assign messages to this consumer"); break;
+      case pulsar::ResultCumulativeAcknowledgementNotAllowedError:
+        throw Exception(rb_ePulsarError_CumulativeAcknowledgementNotAllowedError, "Not allowed to call cumulativeAcknowledgement in Shared and Key_Shared subscription mode"); break;
+      case pulsar::ResultTransactionCoordinatorNotFoundError:
+        throw Exception(rb_ePulsarError_TransactionCoordinatorNotFoundError, "Transaction coordinator not found"); break;
+      case pulsar::ResultInvalidTxnStatusError:
+        throw Exception(rb_ePulsarError_InvalidTxnStatusError, "Invalid txn status error"); break;
+      case pulsar::ResultNotAllowedError:
+        throw Exception(rb_ePulsarError_NotAllowedError, "Not allowed"); break;
+      default:
+        throw Exception(rb_ePulsarError, "unexpected pulsar exception: %d", res);
+    }
   }
 }

data/lib/pulsar/client.rb

@@ -52,8 +52,8 @@ module Pulsar
     end
 
     def self.from_environment(config={})
-      broker_uri = config[:broker_uri] || ENV['PULSAR_BROKER_URI']
       config = Pulsar::ClientConfiguration.from_environment(config)
+      broker_uri = config[:broker_uri] || ENV['PULSAR_BROKER_URI']
       new(broker_uri, config)
     end
   end

data/lib/pulsar/client/version.rb

@@ -19,6 +19,6 @@
 
 module Pulsar
   class Client
-    VERSION = "2.4.1-beta.4"
+    VERSION = "2.6.1-beta.1"
   end
 end

data/lib/pulsar/client_configuration.rb

@@ -21,6 +21,10 @@ require 'pulsar/bindings'
 
 module Pulsar
   class ClientConfiguration
+    AUTH_TOKEN_PLUGIN_NAME = 'org.apache.pulsar.client.impl.auth.AuthenticationToken'.freeze
+    CLIENT_CONF_KEY_VALUE_SEPARATOR = ': '
+    FILE_URL_PREFIX = 'file://'.freeze
+
     def self.from(config)
       case config
       when self then config # already a config object
@@ -30,29 +34,99 @@ module Pulsar
       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']
+    # Creates a client configuration from a custom and environment configuration
+    # (the environment configuration defaults to OS's ENV)
+    def self.from_environment(config={}, environment=ENV.to_h)
+      environment_config = {}
+      if environment.has_key?('PULSAR_CERT_PATH')
+        environment_config[:use_tls] = true
+        environment_config[:tls_allow_insecure_connection] = false
+        environment_config[:tls_validate_hostname] = false
+        environment_config[:tls_trust_certs_file_path] = environment['PULSAR_CERT_PATH']
+      end
+      if environment.has_key?('PULSAR_AUTH_TOKEN')
+        environment_config[:authentication_token] = environment['PULSAR_AUTH_TOKEN']
+      end
+      if environment.has_key?('PULSAR_CLIENT_CONF')
+        environment_config.merge!(read_from_client_conf(environment['PULSAR_CLIENT_CONF']))
+      end
+      self.from(environment_config.merge(config))
+    end
+
+    # Load configuration from PULSAR_CLIENT_CONF
+    # refer to (see https://github.com/apache/pulsar/blob/master/conf/client.conf)
+    def self.read_from_client_conf(pulsar_client_conf_file)
+      client_config = {}
+      # Read the client config as a Ruby Hashmap
+      pulsar_config = read_config(pulsar_client_conf_file)
+      # Attempt to read as many configuration as possible from the client configuration
+
+      # If a TLS certificate had been given, use it
+      if pulsar_config.has_key? 'tlsTrustCertsFilePath'
+        client_config[:use_tls] = true
+        client_config[:tls_trust_certs_file_path] = pulsar_config['tlsTrustCertsFilePath']
       end
-      if ENV.key?('PULSAR_AUTH_TOKEN')
-        env_config[:authentication_token] = ENV['PULSAR_AUTH_TOKEN']
+      # If 'TLS enable hostname verification' is false, then switch it off in config
+      if (pulsar_config.has_key? 'tlsEnableHostnameVerification') &&
+          pulsar_config['tlsEnableHostnameVerification'].eql?('false')
+        client_config[:tls_validate_hostname] = false
       end
-      self.from(env_config.merge(config))
+      # If 'TLS allow insecure connection' is false, then switch it off in config
+      if (pulsar_config.has_key? 'tlsAllowInsecureConnection') &&
+          pulsar_config['tlsAllowInsecureConnection'].eql?('false')
+        client_config[:tls_allow_insecure_connection] = false
+      end
+      # If token-based authentication is used, load the token
+      # Currently only loading from files is supported
+      if (pulsar_config['authPlugin'].eql? AUTH_TOKEN_PLUGIN_NAME) &&
+          pulsar_config['authParams'].start_with?(FILE_URL_PREFIX)
+        # read the first line from the token file
+        token_file = pulsar_config['authParams'].gsub(FILE_URL_PREFIX, '')
+        begin
+          token_file_lines = File.readlines(token_file)
+          # store the token to the config
+          client_config[:authentication_token] = token_file_lines[0]
+        rescue Errno::ENOENT => e
+          warn("Could not load token file '#{token_file}'. Exception was #{e}.")
+        end
+      end
+      # If we have a broker service URI, use it
+      client_config[:broker_uri] = pulsar_config['brokerServiceUrl'] if pulsar_config.has_key? 'brokerServiceUrl'
+      client_config
+    end
+
+    # read Pulsar client configuration as a Hashmap from a client configuration file
+    def self.read_config(pulsar_config_file)
+      result = []
+      begin
+        config_file_content = File.readlines(pulsar_config_file)
+        result = config_file_content.map do |line|
+          key_value = line.split(CLIENT_CONF_KEY_VALUE_SEPARATOR, 2)
+          [key_value[0], key_value[1].strip]
+        end
+      rescue Errno::ENOENT => e
+        warn("Could not load client config file '#{pulsar_config_file}'. Exception was #{e}.")
+      end
+      return result.to_h
     end
 
     module RubySideTweaks
       def initialize(config={})
         super()
+        # store client configuration inside class
+        @config = config
         populate(config)
       end
     end
 
     prepend RubySideTweaks
 
+    # serve the client configuration to peer objects
+    # (eg. we need to configure the 'broker URI' in a different way)
+    def [](key)
+      @config[key]
+    end
+
     def populate(config={})
       populate_one(config, :authentication_token)
       populate_one(config, :operation_timeout_seconds)
@@ -60,6 +134,7 @@ module Pulsar
       populate_one(config, :message_listener_threads)
       populate_one(config, :concurrent_lookup_requests)
       populate_one(config, :log_conf_file_path)
+      populate_one(config, :silent_logging)
       populate_one(config, :use_tls)
       populate_one(config, :tls_trust_certs_file_path)
       populate_one(config, :tls_allow_insecure_connection)

data/lib/pulsar/consumer_configuration.rb

@@ -36,7 +36,7 @@ module Pulsar
     module RubySideTweaks
       def initialize(config={})
         super()
-        self.consumer_type = config.consumer_type if config.has_key?(:consumer_type)
+        self.consumer_type = config[:consumer_type] if config.has_key?(:consumer_type)
       end
 
       def consumer_type

data/lib/pulsar/producer.rb

@@ -22,10 +22,13 @@ require 'pulsar/bindings'
 module Pulsar
   class Producer
     module RubySideTweaks
-      def send(message)
+      def send(message, **opts)
         unless message.is_a?(Pulsar::Message)
-          message = Pulsar::Message.new(message)
+          message = Pulsar::Message.new(message, opts)
+        else
+          warn "Ignoring options (#{opts.keys.join(", ")}) since message is already a Pulsar::Message" unless opts.empty?
         end
+
         super(message)
       end
     end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: pulsar-client
 version: !ruby/object:Gem::Version
-  version: 2.4.1.pre.beta.4
+  version: 2.6.1.pre.beta.1
 platform: ruby
 authors:
 - Jacob Fugal
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
 date: 2019-10-03 00:00:00.000000000 Z
@@ -109,10 +109,14 @@ files:
 - ext/bindings/consumer.cpp
 - ext/bindings/consumer.hpp
 - ext/bindings/extconf.rb
+- ext/bindings/logger.cpp
+- ext/bindings/logger.hpp
 - ext/bindings/message.cpp
 - ext/bindings/message.hpp
 - ext/bindings/producer.cpp
 - ext/bindings/producer.hpp
+- ext/bindings/stringmap.cpp
+- ext/bindings/stringmap.hpp
 - ext/bindings/util.cpp
 - ext/bindings/util.hpp
 - lib/pulsar/client.rb
@@ -126,7 +130,7 @@ homepage: https://github.com/instructure/pulsar-client-ruby
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,9 +145,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Apache Pulsar Ruby Client
 test_files: []