pulsar-client 2.4.1.pre.beta.1

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+
+require "pulsar/client"
+require "irb"
+
+IRB.start(__FILE__)

data/bin/example-consumer

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+#
+# 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.
+#
+
+$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?
+  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."
+  exit 1
+end
+
+topic = ARGV[0]
+consumer_name = ARGV[1] || 'example-consumer'
+client = Pulsar::Client.from_environment
+consumer = client.subscribe(topic, consumer_name)
+consumer.listen do |message, id, finish|
+  puts "Received message '#{message}' [id: #{id}]"
+  finish.call if message == "exit"
+end
+client.close

data/bin/example-producer

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+#
+# 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.
+#
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+
+require "pulsar/client"
+
+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."
+  exit 1
+end
+
+topic = ARGV[0]
+client = Pulsar::Client.from_environment
+producer = client.create_producer(topic)
+while data = gets
+  data.chomp!
+  producer.send(data)
+  break if data == "exit"
+end
+client.close

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/ext/bindings/bindings.cpp

@@ -0,0 +1,18 @@
+#include "rice/Module.hpp"
+
+#include "message.hpp"
+#include "producer.hpp"
+#include "consumer.hpp"
+#include "client.hpp"
+
+using namespace Rice;
+
+extern "C"
+void Init_bindings()
+{
+  Module rb_mPulsar = define_module("Pulsar");
+  bind_message(rb_mPulsar);
+  bind_producer(rb_mPulsar);
+  bind_consumer(rb_mPulsar);
+  bind_client(rb_mPulsar);
+}

data/ext/bindings/client.cpp

@@ -0,0 +1,187 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include <pulsar/Client.h>
+#include <ruby/thread.h>
+
+#include "client.hpp"
+#include "util.hpp"
+
+namespace pulsar_rb {
+
+ClientConfiguration::ClientConfiguration() : _config() {
+}
+
+void ClientConfiguration::setAuthFromToken(const std::string &token) {
+  _config.setAuth(pulsar::AuthToken::createWithToken(token));
+}
+
+int ClientConfiguration::getOperationTimeoutSeconds() {
+  return _config.getOperationTimeoutSeconds();
+}
+
+void ClientConfiguration::setOperationTimeoutSeconds(int timeout) {
+  _config.setOperationTimeoutSeconds(timeout);
+}
+
+int ClientConfiguration::getIOThreads() {
+  return _config.getIOThreads();
+}
+
+void ClientConfiguration::setIOThreads(int threads) {
+  _config.setIOThreads(threads);
+}
+
+int ClientConfiguration::getMessageListenerThreads() {
+  return _config.getMessageListenerThreads();
+}
+
+void ClientConfiguration::setMessageListenerThreads(int threads) {
+  _config.setMessageListenerThreads(threads);
+}
+
+int ClientConfiguration::getConcurrentLookupRequest() {
+  return _config.getConcurrentLookupRequest();
+}
+
+void ClientConfiguration::setConcurrentLookupRequest(int n) {
+  _config.setConcurrentLookupRequest(n);
+}
+
+std::string ClientConfiguration::getLogConfFilePath() {
+  return _config.getLogConfFilePath();
+}
+
+void ClientConfiguration::setLogConfFilePath(const std::string& path) {
+  _config.setLogConfFilePath(path);
+}
+
+bool ClientConfiguration::isUseTls() {
+  return _config.isUseTls();
+}
+
+void ClientConfiguration::setUseTls(bool enable) {
+  _config.setUseTls(enable);
+}
+
+std::string ClientConfiguration::getTlsTrustCertsFilePath() {
+  return _config.getTlsTrustCertsFilePath();
+}
+
+void ClientConfiguration::setTlsTrustCertsFilePath(const std::string& path) {
+  _config.setTlsTrustCertsFilePath(path);
+}
+
+bool ClientConfiguration::isTlsAllowInsecureConnection() {
+  return _config.isTlsAllowInsecureConnection();
+}
+
+void ClientConfiguration::setTlsAllowInsecureConnection(bool enable) {
+  _config.setTlsAllowInsecureConnection(enable);
+}
+
+bool ClientConfiguration::isValidateHostName() {
+  return _config.isValidateHostName();
+}
+
+void ClientConfiguration::setValidateHostName(bool enable) {
+  _config.setValidateHostName(enable);
+}
+
+Client::Client(Rice::String service_url, const ClientConfiguration& config) : _client(service_url.str(), config._config) {
+}
+
+typedef struct {
+  pulsar::Client& client;
+  const Rice::String& topic;
+  const pulsar::ProducerConfiguration& config;
+  pulsar::Producer producer;
+  pulsar::Result result;
+} client_create_producer_task;
+
+void* client_create_producer_worker(void* taskPtr) {
+  client_create_producer_task& task = *(client_create_producer_task*)taskPtr;
+  task.result = task.client.createProducer(task.topic.str(), task.config, task.producer);
+  return nullptr;
+}
+
+Producer::ptr Client::create_producer(Rice::String topic, const ProducerConfiguration& config) {
+  client_create_producer_task task = { _client, topic, config };
+  rb_thread_call_without_gvl(&client_create_producer_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+  return Producer::ptr(new Producer(task.producer));
+}
+
+typedef struct {
+  pulsar::Client& client;
+  const Rice::String& topic;
+  const Rice::String& subscriptionName;
+  const pulsar::ConsumerConfiguration& config;
+  pulsar::Consumer consumer;
+  pulsar::Result result;
+} client_subscribe_task;
+
+void* client_subscribe_worker(void* taskPtr) {
+  client_subscribe_task& task = *(client_subscribe_task*)taskPtr;
+  task.result = task.client.subscribe(task.topic.str(), task.subscriptionName.str(), task.config, task.consumer);
+  return nullptr;
+}
+
+Consumer::ptr Client::subscribe(Rice::String topic, Rice::String subscriptionName, const ConsumerConfiguration& config) {
+  client_subscribe_task task = { _client, topic, subscriptionName, config };
+  rb_thread_call_without_gvl(&client_subscribe_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+  return Consumer::ptr(new Consumer(task.consumer));
+}
+
+typedef struct {
+  pulsar::Client& client;
+  pulsar::Result result;
+} client_close_task;
+
+void* client_close_worker(void* taskPtr) {
+  client_close_task& task = *(client_close_task*)taskPtr;
+  task.result = task.client.close();
+  return nullptr;
+}
+
+void Client::close() {
+  client_close_task task = { _client };
+  rb_thread_call_without_gvl(&client_close_worker, &task, RUBY_UBF_IO, nullptr);
+  CheckResult(task.result);
+}
+
+}
+
+using namespace Rice;
+
+void bind_client(Module& module) {
+  define_class_under<pulsar_rb::Client>(module, "Client")
+    .define_constructor(Constructor<pulsar_rb::Client, const std::string&, const pulsar_rb::ClientConfiguration&>())
+    .define_method("create_producer", &pulsar_rb::Client::create_producer)
+    .define_method("subscribe", &pulsar_rb::Client::subscribe)
+    .define_method("close", &pulsar_rb::Client::close)
+    ;
+
+  define_class_under<pulsar_rb::ClientConfiguration>(module, "ClientConfiguration")
+    .define_constructor(Constructor<pulsar_rb::ClientConfiguration>())
+    .define_method("authentication_token=", &pulsar_rb::ClientConfiguration::setAuthFromToken)
+    .define_method("operation_timeout_seconds", &pulsar_rb::ClientConfiguration::getOperationTimeoutSeconds)
+    .define_method("operation_timeout_seconds=", &pulsar_rb::ClientConfiguration::setOperationTimeoutSeconds)
+    .define_method("io_threads", &pulsar_rb::ClientConfiguration::getIOThreads)
+    .define_method("io_threads=", &pulsar_rb::ClientConfiguration::setIOThreads)
+    .define_method("message_listener_threads", &pulsar_rb::ClientConfiguration::getMessageListenerThreads)
+    .define_method("message_listener_threads=", &pulsar_rb::ClientConfiguration::setMessageListenerThreads)
+    .define_method("concurrent_lookup_requests", &pulsar_rb::ClientConfiguration::getConcurrentLookupRequest)
+    .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("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)
+    .define_method("tls_trust_certs_file_path=", &pulsar_rb::ClientConfiguration::setTlsTrustCertsFilePath)
+    .define_method("tls_allow_insecure_connection?", &pulsar_rb::ClientConfiguration::isTlsAllowInsecureConnection)
+    .define_method("tls_allow_insecure_connection=", &pulsar_rb::ClientConfiguration::setTlsAllowInsecureConnection)
+    .define_method("tls_validate_hostname?", &pulsar_rb::ClientConfiguration::isValidateHostName)
+    .define_method("tls_validate_hostname=", &pulsar_rb::ClientConfiguration::setValidateHostName)
+    ;
+}

data/ext/bindings/client.hpp

@@ -0,0 +1,56 @@
+#ifndef __PULSAR_RUBY_CLIENT_CLIENT_HPP
+#define __PULSAR_RUBY_CLIENT_CLIENT_HPP
+
+#include "rice/Module.hpp"
+#include "rice/String.hpp"
+#include "rice/Data_Object.hpp"
+#include <pulsar/Client.h>
+
+#include "producer.hpp"
+#include "consumer.hpp"
+
+namespace pulsar_rb {
+  class ClientConfiguration {
+  public:
+    pulsar::ClientConfiguration _config;
+    ClientConfiguration();
+
+    void setAuthFromToken(const std::string &token);
+    int getOperationTimeoutSeconds();
+    void setOperationTimeoutSeconds(int timeout);
+    int getIOThreads();
+    void setIOThreads(int threads);
+    int getMessageListenerThreads();
+    void setMessageListenerThreads(int threads);
+    int getConcurrentLookupRequest();
+    void setConcurrentLookupRequest(int n);
+    std::string getLogConfFilePath();
+    void setLogConfFilePath(const std::string& path);
+    bool isUseTls();
+    void setUseTls(bool enable);
+    std::string getTlsTrustCertsFilePath();
+    void setTlsTrustCertsFilePath(const std::string& path);
+    bool isTlsAllowInsecureConnection();
+    void setTlsAllowInsecureConnection(bool enable);
+    bool isValidateHostName();
+    void setValidateHostName(bool enable);
+
+    typedef Rice::Data_Object<ClientConfiguration> ptr;
+  };
+
+  class Client {
+  public:
+    pulsar::Client _client;
+    Client(Rice::String service_url, const ClientConfiguration& config);
+
+    Producer::ptr create_producer(Rice::String topic, const ProducerConfiguration& config);
+    Consumer::ptr subscribe(Rice::String topic, Rice::String subscriptionName, const ConsumerConfiguration& config);
+    void close();
+
+    typedef Rice::Data_Object<Client> ptr;
+  };
+};
+
+void bind_client(Rice::Module &module);
+
+#endif

data/ext/bindings/consumer.cpp

@@ -0,0 +1,90 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Enum.hpp"
+#include "rice/Constructor.hpp"
+#include <pulsar/Client.h>
+#include <ruby/thread.h>
+
+#include "consumer.hpp"
+#include "util.hpp"
+
+namespace pulsar_rb {
+
+typedef struct {
+  pulsar::Consumer& consumer;
+  pulsar::Message message;
+  pulsar::Result result;
+} consumer_receive_job;
+
+void* consumer_receive_nogvl(void* jobPtr) {
+  consumer_receive_job& job = *(consumer_receive_job*)jobPtr;
+  job.result = job.consumer.receive(job.message);
+  return nullptr;
+}
+
+pulsar::Message consumer_receive(pulsar::Consumer& consumer) {
+  consumer_receive_job job = { consumer };
+  rb_thread_call_without_gvl(&consumer_receive_nogvl, &job, RUBY_UBF_IO, nullptr);
+  CheckResult(job.result);
+  return job.message;
+}
+
+Message::ptr Consumer::receive() {
+  pulsar::Message message = consumer_receive(_consumer);
+  return Message::ptr(new Message(message));
+}
+
+void Consumer::acknowledge(const Message& message) {
+  _consumer.acknowledgeAsync(message._msg, nullptr);
+}
+
+void Consumer::negative_acknowledge(const Message& message) {
+  _consumer.negativeAcknowledge(message._msg);
+}
+
+}
+
+using namespace Rice;
+
+void bind_consumer(Module &module) {
+  define_class_under<pulsar_rb::Consumer>(module, "Consumer")
+    .define_constructor(Constructor<pulsar_rb::Consumer>())
+    .define_method("receive", &pulsar_rb::Consumer::receive)
+    .define_method("acknowledge", &pulsar_rb::Consumer::acknowledge)
+    .define_method("negative_acknowledge", &pulsar_rb::Consumer::negative_acknowledge)
+    ;
+
+  define_enum<pulsar::ConsumerType>("ConsumerType", module)
+    .define_value("Exclusive", ConsumerExclusive)
+    .define_value("Shared", ConsumerShared)
+    .define_value("Failover", ConsumerFailover)
+    .define_value("KeyShared", ConsumerKeyShared);
+
+  define_class_under<pulsar_rb::ConsumerConfiguration>(module, "ConsumerConfiguration")
+    .define_constructor(Constructor<pulsar_rb::ConsumerConfiguration>())
+    .define_method("consumer_type", &ConsumerConfiguration::getConsumerType)
+    .define_method("consumer_type=", &ConsumerConfiguration::setConsumerType)
+    // TODO .define_method("schema", &ConsumerConfiguration::getSchema)
+    // TODO .define_method("schema=", &ConsumerConfiguration::setSchema)
+    // TODO .define_method("message_listener", &ConsumerConfiguration_setMessageListener)
+    .define_method("receiver_queue_size", &ConsumerConfiguration::getReceiverQueueSize)
+    .define_method("receiver_queue_size=", &ConsumerConfiguration::setReceiverQueueSize)
+    .define_method("max_total_receiver_queue_size_across_partitions", &ConsumerConfiguration::getMaxTotalReceiverQueueSizeAcrossPartitions)
+    .define_method("max_total_receiver_queue_size_across_partitions=", &ConsumerConfiguration::setMaxTotalReceiverQueueSizeAcrossPartitions)
+    .define_method("consumer_name", &ConsumerConfiguration::getConsumerName)
+    .define_method("consumer_name=", &ConsumerConfiguration::setConsumerName)
+    .define_method("unacked_messages_timeout_ms", &ConsumerConfiguration::getUnAckedMessagesTimeoutMs)
+    .define_method("unacked_messages_timeout_ms=", &ConsumerConfiguration::setUnAckedMessagesTimeoutMs)
+    .define_method("negative_ack_redelivery_delay_ms", &ConsumerConfiguration::getNegativeAckRedeliveryDelayMs)
+    .define_method("negative_ack_redelivery_delay_ms=", &ConsumerConfiguration::setNegativeAckRedeliveryDelayMs)
+    .define_method("broker_consumer_stats_cache_time_ms", &ConsumerConfiguration::getBrokerConsumerStatsCacheTimeInMs)
+    .define_method("broker_consumer_stats_cache_time_ms=", &ConsumerConfiguration::setBrokerConsumerStatsCacheTimeInMs)
+    .define_method("pattern_auto_discovery_period", &ConsumerConfiguration::getPatternAutoDiscoveryPeriod)
+    .define_method("pattern_auto_discovery_period=", &ConsumerConfiguration::setPatternAutoDiscoveryPeriod)
+    .define_method("read_compacted?", &ConsumerConfiguration::isReadCompacted)
+    .define_method("read_compacted=", &ConsumerConfiguration::setReadCompacted)
+    .define_method("subscription_initial_position", &ConsumerConfiguration::getSubscriptionInitialPosition)
+    .define_method("subscription_initial_position=", &ConsumerConfiguration::setSubscriptionInitialPosition)
+    .define_method("[]", &ConsumerConfiguration::getProperty)
+    .define_method("[]=", &ConsumerConfiguration::setProperty)
+    ;
+}