pulsar-client 1.6.2 → 1.8.0-rc.1

package/src/Client.cc

@@ -17,11 +17,12 @@
  * under the License.
  */
 
+#include "Authentication.h"
 #include "Client.h"
 #include "Consumer.h"
 #include "Producer.h"
 #include "Reader.h"
-#include "Authentication.h"
+#include "ThreadSafeDeferred.h"
 #include <pulsar/c/client.h>
 #include <pulsar/c/client_configuration.h>
 #include <pulsar/c/result.h>
@@ -40,6 +41,34 @@ static const std::string CFG_TLS_ALLOW_INSECURE = "tlsAllowInsecureConnection";
 static const std::string CFG_STATS_INTERVAL = "statsIntervalInSeconds";
 static const std::string CFG_LOG = "log";
 
+LogCallback *Client::logCallback = nullptr;
+
+void Client::SetLogHandler(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Napi::Value jsFunction = info[0];
+
+  if (jsFunction.IsNull()) {
+    if (Client::logCallback != nullptr) {
+      Client::logCallback->callback.Release();
+      delete Client::logCallback;
+      Client::logCallback = nullptr;
+    }
+  } else if (jsFunction.IsFunction()) {
+    Napi::ThreadSafeFunction logFunction =
+        Napi::ThreadSafeFunction::New(env, jsFunction.As<Napi::Function>(), "Pulsar Logging", 0, 1);
+    logFunction.Unref(env);
+    if (Client::logCallback != nullptr) {
+      Client::logCallback->callback.Release();
+    } else {
+      Client::logCallback = new LogCallback();
+    }
+    Client::logCallback->callback = std::move(logFunction);
+  } else {
+    Napi::Error::New(env, "Client log handler must be a function or null").ThrowAsJavaScriptException();
+  }
+}
+
 Napi::FunctionReference Client::constructor;
 
 Napi::Object Client::Init(Napi::Env env, Napi::Object exports) {
@@ -47,7 +76,8 @@ Napi::Object Client::Init(Napi::Env env, Napi::Object exports) {
 
   Napi::Function func = DefineClass(
       env, "Client",
-      {InstanceMethod("createProducer", &Client::CreateProducer),
+      {StaticMethod("setLogHandler", &Client::SetLogHandler),
+       InstanceMethod("createProducer", &Client::CreateProducer),
        InstanceMethod("subscribe", &Client::Subscribe), InstanceMethod("createReader", &Client::CreateReader),
        InstanceMethod("close", &Client::Close)});
 
@@ -72,95 +102,95 @@ Client::Client(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Client>(info)
   }
   Napi::String serviceUrl = clientConfig.Get(CFG_SERVICE_URL).ToString();
 
-  pulsar_client_configuration_t *cClientConfig = pulsar_client_configuration_create();
+  this->cClientConfig = std::shared_ptr<pulsar_client_configuration_t>(pulsar_client_configuration_create(),
+                                                                       pulsar_client_configuration_free);
+
+  // The logger can only be set once per process, so we will take control of it
+  pulsar_client_configuration_set_logger(cClientConfig.get(), &LogMessage, nullptr);
 
+  // log config option should be deprecated in favour of static setLogHandler method
   if (clientConfig.Has(CFG_LOG) && clientConfig.Get(CFG_LOG).IsFunction()) {
     Napi::ThreadSafeFunction logFunction = Napi::ThreadSafeFunction::New(
         env, clientConfig.Get(CFG_LOG).As<Napi::Function>(), "Pulsar Logging", 0, 1);
-    this->logCallback = new LogCallback();
-    this->logCallback->callback = logFunction;
+    logFunction.Unref(env);
 
-    pulsar_client_configuration_set_logger(cClientConfig, &LogMessage, this->logCallback);
-  } else {
-    this->logCallback = nullptr;
+    if (Client::logCallback != nullptr) {
+      Client::logCallback->callback.Release();
+    } else {
+      Client::logCallback = new LogCallback();
+    }
+    Client::logCallback->callback = std::move(logFunction);
   }
 
   if (clientConfig.Has(CFG_AUTH) && clientConfig.Get(CFG_AUTH).IsObject()) {
     Napi::Object obj = clientConfig.Get(CFG_AUTH).ToObject();
     if (obj.Has(CFG_AUTH_PROP) && obj.Get(CFG_AUTH_PROP).IsObject()) {
       Authentication *auth = Authentication::Unwrap(obj.Get(CFG_AUTH_PROP).ToObject());
-      pulsar_client_configuration_set_auth(cClientConfig, auth->GetCAuthentication());
+      pulsar_client_configuration_set_auth(cClientConfig.get(), auth->GetCAuthentication());
     }
   }
 
   if (clientConfig.Has(CFG_OP_TIMEOUT) && clientConfig.Get(CFG_OP_TIMEOUT).IsNumber()) {
     int32_t operationTimeoutSeconds = clientConfig.Get(CFG_OP_TIMEOUT).ToNumber().Int32Value();
     if (operationTimeoutSeconds > 0) {
-      pulsar_client_configuration_set_operation_timeout_seconds(cClientConfig, operationTimeoutSeconds);
+      pulsar_client_configuration_set_operation_timeout_seconds(cClientConfig.get(), operationTimeoutSeconds);
     }
   }
 
   if (clientConfig.Has(CFG_IO_THREADS) && clientConfig.Get(CFG_IO_THREADS).IsNumber()) {
     int32_t ioThreads = clientConfig.Get(CFG_IO_THREADS).ToNumber().Int32Value();
     if (ioThreads > 0) {
-      pulsar_client_configuration_set_io_threads(cClientConfig, ioThreads);
+      pulsar_client_configuration_set_io_threads(cClientConfig.get(), ioThreads);
     }
   }
 
   if (clientConfig.Has(CFG_LISTENER_THREADS) && clientConfig.Get(CFG_LISTENER_THREADS).IsNumber()) {
     int32_t messageListenerThreads = clientConfig.Get(CFG_LISTENER_THREADS).ToNumber().Int32Value();
     if (messageListenerThreads > 0) {
-      pulsar_client_configuration_set_message_listener_threads(cClientConfig, messageListenerThreads);
+      pulsar_client_configuration_set_message_listener_threads(cClientConfig.get(), messageListenerThreads);
     }
   }
 
   if (clientConfig.Has(CFG_CONCURRENT_LOOKUP) && clientConfig.Get(CFG_CONCURRENT_LOOKUP).IsNumber()) {
     int32_t concurrentLookupRequest = clientConfig.Get(CFG_CONCURRENT_LOOKUP).ToNumber().Int32Value();
     if (concurrentLookupRequest > 0) {
-      pulsar_client_configuration_set_concurrent_lookup_request(cClientConfig, concurrentLookupRequest);
+      pulsar_client_configuration_set_concurrent_lookup_request(cClientConfig.get(), concurrentLookupRequest);
     }
   }
 
   if (clientConfig.Has(CFG_USE_TLS) && clientConfig.Get(CFG_USE_TLS).IsBoolean()) {
     Napi::Boolean useTls = clientConfig.Get(CFG_USE_TLS).ToBoolean();
-    pulsar_client_configuration_set_use_tls(cClientConfig, useTls.Value());
+    pulsar_client_configuration_set_use_tls(cClientConfig.get(), useTls.Value());
   }
 
   if (clientConfig.Has(CFG_TLS_TRUST_CERT) && clientConfig.Get(CFG_TLS_TRUST_CERT).IsString()) {
     Napi::String tlsTrustCertsFilePath = clientConfig.Get(CFG_TLS_TRUST_CERT).ToString();
-    pulsar_client_configuration_set_tls_trust_certs_file_path(cClientConfig,
+    pulsar_client_configuration_set_tls_trust_certs_file_path(cClientConfig.get(),
                                                               tlsTrustCertsFilePath.Utf8Value().c_str());
   }
 
   if (clientConfig.Has(CFG_TLS_VALIDATE_HOSTNAME) &&
       clientConfig.Get(CFG_TLS_VALIDATE_HOSTNAME).IsBoolean()) {
     Napi::Boolean tlsValidateHostname = clientConfig.Get(CFG_TLS_VALIDATE_HOSTNAME).ToBoolean();
-    pulsar_client_configuration_set_validate_hostname(cClientConfig, tlsValidateHostname.Value());
+    pulsar_client_configuration_set_validate_hostname(cClientConfig.get(), tlsValidateHostname.Value());
   }
 
   if (clientConfig.Has(CFG_TLS_ALLOW_INSECURE) && clientConfig.Get(CFG_TLS_ALLOW_INSECURE).IsBoolean()) {
     Napi::Boolean tlsAllowInsecureConnection = clientConfig.Get(CFG_TLS_ALLOW_INSECURE).ToBoolean();
-    pulsar_client_configuration_set_tls_allow_insecure_connection(cClientConfig,
+    pulsar_client_configuration_set_tls_allow_insecure_connection(cClientConfig.get(),
                                                                   tlsAllowInsecureConnection.Value());
   }
 
   if (clientConfig.Has(CFG_STATS_INTERVAL) && clientConfig.Get(CFG_STATS_INTERVAL).IsNumber()) {
     uint32_t statsIntervalInSeconds = clientConfig.Get(CFG_STATS_INTERVAL).ToNumber().Uint32Value();
-    pulsar_client_configuration_set_stats_interval_in_seconds(cClientConfig, statsIntervalInSeconds);
+    pulsar_client_configuration_set_stats_interval_in_seconds(cClientConfig.get(), statsIntervalInSeconds);
   }
 
-  this->cClient = pulsar_client_create(serviceUrl.Utf8Value().c_str(), cClientConfig);
-  pulsar_client_configuration_free(cClientConfig);
-  this->Ref();
+  this->cClient = std::shared_ptr<pulsar_client_t>(
+      pulsar_client_create(serviceUrl.Utf8Value().c_str(), cClientConfig.get()), pulsar_client_free);
 }
 
-Client::~Client() {
-  pulsar_client_free(this->cClient);
-  if (this->logCallback != nullptr) {
-    this->logCallback->callback.Release();
-    this->logCallback = nullptr;
-  }
-}
+Client::~Client() {}
 
 Napi::Value Client::CreateProducer(const Napi::CallbackInfo &info) {
   return Producer::NewInstance(info, this->cClient);
@@ -183,8 +213,13 @@ void LogMessageProxy(Napi::Env env, Napi::Function jsCallback, struct LogMessage
   jsCallback.Call({logLevel, file, line, message});
 }
 
-void LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message, void *ctx) {
-  LogCallback *logCallback = (LogCallback *)ctx;
+void Client::LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message,
+                        void *ctx) {
+  LogCallback *logCallback = Client::logCallback;
+
+  if (logCallback == nullptr) {
+    return;
+  }
 
   if (logCallback->callback.Acquire() != napi_ok) {
     return;
@@ -196,33 +231,24 @@ void LogMessage(pulsar_logger_level_t level, const char *file, int line, const c
   logCallback->callback.Release();
 }
 
-class ClientCloseWorker : public Napi::AsyncWorker {
- public:
-  ClientCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cClient(cClient) {}
-  ~ClientCloseWorker() {}
-  void Execute() {
-    pulsar_result result = pulsar_client_close(this->cClient);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
-  }
-  void OnOK() { this->deferred.Resolve(Env().Null()); }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to close client: ") + e.Message()).Value());
-  }
-
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_client_t *cClient;
-};
-
 Napi::Value Client::Close(const Napi::CallbackInfo &info) {
-  this->Unref();
-
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ClientCloseWorker *wk = new ClientCloseWorker(deferred, this->cClient);
-  wk->Queue();
-  return deferred.Promise();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_client_close_async(
+      this->cClient.get(),
+      [](pulsar_result result, void *ctx) {
+        auto deferredContext = static_cast<ExtDeferredContext *>(ctx);
+        auto deferred = deferredContext->deferred;
+        delete deferredContext;
+
+        if (result != pulsar_result_Ok) {
+          deferred->Reject(std::string("Failed to close client: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }

package/src/Client.h

@@ -37,20 +37,22 @@ struct LogCallback {
   Napi::ThreadSafeFunction callback;
 };
 
-void LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message, void *ctx);
-
 class Client : public Napi::ObjectWrap<Client> {
  public:
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static void SetLogHandler(const Napi::CallbackInfo &info);
 
   Client(const Napi::CallbackInfo &info);
   ~Client();
 
  private:
+  static LogCallback *logCallback;
   static Napi::FunctionReference constructor;
-  pulsar_client_t *cClient;
-  LogCallback *logCallback;
+  std::shared_ptr<pulsar_client_t> cClient;
+  std::shared_ptr<pulsar_client_configuration_t> cClientConfig;
 
+  static void LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message,
+                         void *ctx);
   Napi::Value CreateProducer(const Napi::CallbackInfo &info);
   Napi::Value Subscribe(const Napi::CallbackInfo &info);
   Napi::Value CreateReader(const Napi::CallbackInfo &info);