pulsar-client 1.6.2 → 1.7.0

package/src/Consumer.cc

@@ -21,6 +21,7 @@
 #include "ConsumerConfig.h"
 #include "Message.h"
 #include "MessageId.h"
+#include "ThreadSafeDeferred.h"
 #include <pulsar/c/result.h>
 #include <atomic>
 #include <thread>
@@ -50,10 +51,10 @@ void Consumer::Init(Napi::Env env, Napi::Object exports) {
 }
 
 struct MessageListenerProxyData {
-  pulsar_message_t *cMessage;
+  std::shared_ptr<pulsar_message_t> cMessage;
   Consumer *consumer;
 
-  MessageListenerProxyData(pulsar_message_t *cMessage, Consumer *consumer)
+  MessageListenerProxyData(std::shared_ptr<pulsar_message_t> cMessage, Consumer *consumer)
       : cMessage(cMessage), consumer(consumer) {}
 };
 
@@ -62,11 +63,16 @@ void MessageListenerProxy(Napi::Env env, Napi::Function jsCallback, MessageListe
   Consumer *consumer = data->consumer;
   delete data;
 
-  jsCallback.Call({msg, consumer->Value()});
+  // `consumer` might be null in certain cases, segmentation fault might happend without this null check. We
+  // need to handle this rare case in future.
+  if (consumer) {
+    jsCallback.Call({msg, consumer->Value()});
+  }
 }
 
-void MessageListener(pulsar_consumer_t *cConsumer, pulsar_message_t *cMessage, void *ctx) {
-  ListenerCallback *listenerCallback = (ListenerCallback *)ctx;
+void MessageListener(pulsar_consumer_t *rawConsumer, pulsar_message_t *rawMessage, void *ctx) {
+  std::shared_ptr<pulsar_message_t> cMessage(rawMessage, pulsar_message_free);
+  MessageListenerCallback *listenerCallback = (MessageListenerCallback *)ctx;
 
   Consumer *consumer = (Consumer *)listenerCallback->consumer;
 
@@ -79,144 +85,131 @@ void MessageListener(pulsar_consumer_t *cConsumer, pulsar_message_t *cMessage, v
   listenerCallback->callback.Release();
 }
 
-void Consumer::SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer) { this->wrapper = cConsumer; }
-void Consumer::SetListenerCallback(ListenerCallback *listener) {
-  if (listener) {
-    // Maintain reference to consumer, so it won't get garbage collected
-    // since, when we have a listener, we don't have to maintain reference to consumer (in js code)
-    this->Ref();
+void Consumer::SetCConsumer(std::shared_ptr<pulsar_consumer_t> cConsumer) { this->cConsumer = cConsumer; }
+void Consumer::SetListenerCallback(MessageListenerCallback *listener) {
+  if (this->listener != nullptr) {
+    // It is only safe to set the listener once for the lifecycle of the Consumer
+    return;
+  }
 
-    // Pass consumer as argument
+  if (listener != nullptr) {
     listener->consumer = this;
+    // If a consumer listener is set, the Consumer instance is kept alive even if it goes out of scope in JS
+    // code.
+    this->Ref();
+    this->listener = listener;
   }
-
-  this->listener = listener;
 }
 
 Consumer::Consumer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Consumer>(info), listener(nullptr) {}
 
-class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
- public:
-  ConsumerNewInstanceWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient,
-                            ConsumerConfig *consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cClient(cClient),
-        consumerConfig(consumerConfig),
-        consumerWrapper(consumerWrapper) {}
-  ~ConsumerNewInstanceWorker() {}
-  void Execute() {
-    const std::string &topic = this->consumerConfig->GetTopic();
-    const std::vector<std::string> &topics = this->consumerConfig->GetTopics();
-    const std::string &topicsPattern = this->consumerConfig->GetTopicsPattern();
-    if (topic.empty() && topics.size() == 0 && topicsPattern.empty()) {
-      SetError(
-          std::string("Topic, topics or topicsPattern is required and must be specified as a string when "
-                      "creating consumer"));
-      return;
-    }
-    const std::string &subscription = this->consumerConfig->GetSubscription();
-    if (subscription.empty()) {
-      SetError(
-          std::string("Subscription is required and must be specified as a string when creating consumer"));
-      return;
-    }
-    int32_t ackTimeoutMs = this->consumerConfig->GetAckTimeoutMs();
-    if (ackTimeoutMs != 0 && ackTimeoutMs < MIN_ACK_TIMEOUT_MILLIS) {
-      std::string msg("Ack timeout should be 0 or greater than or equal to " +
-                      std::to_string(MIN_ACK_TIMEOUT_MILLIS));
-      SetError(msg);
-      return;
-    }
-    int32_t nAckRedeliverTimeoutMs = this->consumerConfig->GetNAckRedeliverTimeoutMs();
-    if (nAckRedeliverTimeoutMs < 0) {
-      std::string msg("NAck timeout should be greater than or equal to zero");
-      SetError(msg);
-      return;
-    }
+struct ConsumerNewInstanceContext {
+  ConsumerNewInstanceContext(std::shared_ptr<ThreadSafeDeferred> deferred,
+                             std::shared_ptr<pulsar_client_t> cClient,
+                             std::shared_ptr<ConsumerConfig> consumerConfig)
+      : deferred(deferred), cClient(cClient), consumerConfig(consumerConfig){};
+  std::shared_ptr<ThreadSafeDeferred> deferred;
+  std::shared_ptr<pulsar_client_t> cClient;
+  std::shared_ptr<ConsumerConfig> consumerConfig;
+
+  static void subscribeCallback(pulsar_result result, pulsar_consumer_t *rawConsumer, void *ctx) {
+    auto instanceContext = static_cast<ConsumerNewInstanceContext *>(ctx);
+    auto deferred = instanceContext->deferred;
+    auto cClient = instanceContext->cClient;
+    auto consumerConfig = instanceContext->consumerConfig;
+    delete instanceContext;
 
-    this->done = false;
-    if (!topicsPattern.empty()) {
-      pulsar_client_subscribe_pattern_async(this->cClient, topicsPattern.c_str(), subscription.c_str(),
-                                            this->consumerConfig->GetCConsumerConfig(),
-                                            &ConsumerNewInstanceWorker::subscribeCallback, (void *)this);
-    } else if (topics.size() > 0) {
-      const char **cTopics = new const char *[topics.size()];
-      for (size_t i = 0; i < topics.size(); i++) {
-        cTopics[i] = topics[i].c_str();
-      }
-      pulsar_client_subscribe_multi_topics_async(this->cClient, cTopics, topics.size(), subscription.c_str(),
-                                                 this->consumerConfig->GetCConsumerConfig(),
-                                                 &ConsumerNewInstanceWorker::subscribeCallback, (void *)this);
-      delete cTopics;
-    } else {
-      pulsar_client_subscribe_async(this->cClient, topic.c_str(), subscription.c_str(),
-                                    this->consumerConfig->GetCConsumerConfig(),
-                                    &ConsumerNewInstanceWorker::subscribeCallback, (void *)this);
-    }
-    while (!done) {
-      std::this_thread::yield();
+    if (result != pulsar_result_Ok) {
+      return deferred->Reject(std::string("Failed to create consumer: ") + pulsar_result_str(result));
     }
-  }
-  void OnOK() {
-    Napi::Object obj = Consumer::constructor.New({});
-    Consumer *consumer = Consumer::Unwrap(obj);
 
-    consumer->SetCConsumer(this->consumerWrapper);
-    consumer->SetListenerCallback(this->listener);
+    auto cConsumer = std::shared_ptr<pulsar_consumer_t>(rawConsumer, pulsar_consumer_free);
+    auto listener = consumerConfig->GetListenerCallback();
 
-    if (this->listener) {
-      // resume to enable MessageListener function callback
-      resume_message_listener(this->consumerWrapper->cConsumer);
+    if (listener) {
+      // pause, will resume in OnOK, to prevent MessageListener get a nullptr of consumer
+      pulsar_consumer_pause_message_listener(cConsumer.get());
     }
 
-    this->deferred.Resolve(obj);
-  }
-  void OnError(const Napi::Error &e) { this->deferred.Reject(Napi::Error::New(Env(), e.Message()).Value()); }
+    deferred->Resolve([cConsumer, consumerConfig, listener](const Napi::Env env) {
+      Napi::Object obj = Consumer::constructor.New({});
+      Consumer *consumer = Consumer::Unwrap(obj);
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_client_t *cClient;
-  pulsar_consumer_t *cConsumer;
-  ConsumerConfig *consumerConfig;
-  ListenerCallback *listener;
-  std::shared_ptr<CConsumerWrapper> consumerWrapper;
-  std::atomic<bool> done;
-  static void subscribeCallback(pulsar_result result, pulsar_consumer_t *consumer, void *ctx) {
-    ConsumerNewInstanceWorker *worker = (ConsumerNewInstanceWorker *)ctx;
-    if (result != pulsar_result_Ok) {
-      worker->SetError(std::string("Failed to create consumer: ") + pulsar_result_str(result));
-    } else {
-      worker->consumerWrapper->cConsumer = consumer;
-      worker->listener = worker->consumerConfig->GetListenerCallback();
+      consumer->SetCConsumer(cConsumer);
+      consumer->SetListenerCallback(listener);
 
-      if (worker->listener) {
-        // pause, will resume in OnOK, to prevent MessageListener get a nullptr of consumer
-        pulsar_consumer_pause_message_listener(consumer);
+      if (listener) {
+        // resume to enable MessageListener function callback
+        resume_message_listener(cConsumer.get());
       }
-    }
 
-    delete worker->consumerConfig;
-    worker->done = true;
+      return obj;
+    });
   }
 };
 
-Napi::Value Consumer::NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  Napi::Object config = info[0].As<Napi::Object>();
+Napi::Value Consumer::NewInstance(const Napi::CallbackInfo &info, std::shared_ptr<pulsar_client_t> cClient) {
+  auto deferred = ThreadSafeDeferred::New(info.Env());
+  auto config = info[0].As<Napi::Object>();
+  std::shared_ptr<ConsumerConfig> consumerConfig = std::make_shared<ConsumerConfig>(config, &MessageListener);
+
+  const std::string &topic = consumerConfig->GetTopic();
+  const std::vector<std::string> &topics = consumerConfig->GetTopics();
+  const std::string &topicsPattern = consumerConfig->GetTopicsPattern();
+  if (topic.empty() && topics.size() == 0 && topicsPattern.empty()) {
+    deferred->Reject(
+        std::string("Topic, topics or topicsPattern is required and must be specified as a string when "
+                    "creating consumer"));
+    return deferred->Promise();
+  }
+  const std::string &subscription = consumerConfig->GetSubscription();
+  if (subscription.empty()) {
+    deferred->Reject(
+        std::string("Subscription is required and must be specified as a string when creating consumer"));
+    return deferred->Promise();
+  }
+  int32_t ackTimeoutMs = consumerConfig->GetAckTimeoutMs();
+  if (ackTimeoutMs != 0 && ackTimeoutMs < MIN_ACK_TIMEOUT_MILLIS) {
+    std::string msg("Ack timeout should be 0 or greater than or equal to " +
+                    std::to_string(MIN_ACK_TIMEOUT_MILLIS));
+    deferred->Reject(msg);
+    return deferred->Promise();
+  }
+  int32_t nAckRedeliverTimeoutMs = consumerConfig->GetNAckRedeliverTimeoutMs();
+  if (nAckRedeliverTimeoutMs < 0) {
+    std::string msg("NAck timeout should be greater than or equal to zero");
+    deferred->Reject(msg);
+    return deferred->Promise();
+  }
 
-  std::shared_ptr<CConsumerWrapper> consumerWrapper = std::make_shared<CConsumerWrapper>();
+  auto ctx = new ConsumerNewInstanceContext(deferred, cClient, consumerConfig);
 
-  ConsumerConfig *consumerConfig = new ConsumerConfig(config, consumerWrapper, &MessageListener);
-  ConsumerNewInstanceWorker *wk =
-      new ConsumerNewInstanceWorker(deferred, cClient, consumerConfig, consumerWrapper);
-  wk->Queue();
-  return deferred.Promise();
+  if (!topicsPattern.empty()) {
+    pulsar_client_subscribe_pattern_async(cClient.get(), topicsPattern.c_str(), subscription.c_str(),
+                                          consumerConfig->GetCConsumerConfig().get(),
+                                          &ConsumerNewInstanceContext::subscribeCallback, ctx);
+  } else if (topics.size() > 0) {
+    const char **cTopics = new const char *[topics.size()];
+    for (size_t i = 0; i < topics.size(); i++) {
+      cTopics[i] = topics[i].c_str();
+    }
+    pulsar_client_subscribe_multi_topics_async(cClient.get(), cTopics, topics.size(), subscription.c_str(),
+                                               consumerConfig->GetCConsumerConfig().get(),
+                                               &ConsumerNewInstanceContext::subscribeCallback, ctx);
+    delete[] cTopics;
+  } else {
+    pulsar_client_subscribe_async(cClient.get(), topic.c_str(), subscription.c_str(),
+                                  consumerConfig->GetCConsumerConfig().get(),
+                                  &ConsumerNewInstanceContext::subscribeCallback, ctx);
+  }
+
+  return deferred->Promise();
 }
 
+// We still need a receive worker because the c api is missing the equivalent async definition
 class ConsumerReceiveWorker : public Napi::AsyncWorker {
  public:
-  ConsumerReceiveWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer,
+  ConsumerReceiveWorker(const Napi::Promise::Deferred &deferred, std::shared_ptr<pulsar_consumer_t> cConsumer,
                         int64_t timeout = -1)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
@@ -225,14 +218,17 @@ class ConsumerReceiveWorker : public Napi::AsyncWorker {
   ~ConsumerReceiveWorker() {}
   void Execute() {
     pulsar_result result;
+    pulsar_message_t *rawMessage;
     if (timeout > 0) {
-      result = pulsar_consumer_receive_with_timeout(this->cConsumer, &(this->cMessage), timeout);
+      result = pulsar_consumer_receive_with_timeout(this->cConsumer.get(), &rawMessage, timeout);
     } else {
-      result = pulsar_consumer_receive(this->cConsumer, &(this->cMessage));
+      result = pulsar_consumer_receive(this->cConsumer.get(), &rawMessage);
     }
 
     if (result != pulsar_result_Ok) {
-      SetError(std::string("Failed to received message ") + pulsar_result_str(result));
+      SetError(std::string("Failed to receive message: ") + pulsar_result_str(result));
+    } else {
+      this->cMessage = std::shared_ptr<pulsar_message_t>(rawMessage, pulsar_message_free);
     }
   }
   void OnOK() {
@@ -243,160 +239,193 @@ class ConsumerReceiveWorker : public Napi::AsyncWorker {
 
  private:
   Napi::Promise::Deferred deferred;
-  pulsar_consumer_t *cConsumer;
-  pulsar_message_t *cMessage;
+  std::shared_ptr<pulsar_consumer_t> cConsumer;
+  std::shared_ptr<pulsar_message_t> cMessage;
   int64_t timeout;
 };
 
 Napi::Value Consumer::Receive(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   if (info[0].IsUndefined()) {
-    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->wrapper->cConsumer);
+    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->cConsumer);
     wk->Queue();
   } else {
     Napi::Number timeout = info[0].As<Napi::Object>().ToNumber();
-    ConsumerReceiveWorker *wk =
-        new ConsumerReceiveWorker(deferred, this->wrapper->cConsumer, timeout.Int64Value());
+    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->cConsumer, timeout.Int64Value());
     wk->Queue();
   }
   return deferred.Promise();
 }
 
-void Consumer::Acknowledge(const Napi::CallbackInfo &info) {
-  Napi::Object obj = info[0].As<Napi::Object>();
-  Message *msg = Message::Unwrap(obj);
-  pulsar_consumer_acknowledge_async(this->wrapper->cConsumer, msg->GetCMessage(), NULL, NULL);
+Napi::Value Consumer::Acknowledge(const Napi::CallbackInfo &info) {
+  auto obj = info[0].As<Napi::Object>();
+  auto msg = Message::Unwrap(obj);
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_consumer_acknowledge_async(
+      this->cConsumer.get(), msg->GetCMessage().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 acknowledge: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
-void Consumer::AcknowledgeId(const Napi::CallbackInfo &info) {
-  Napi::Object obj = info[0].As<Napi::Object>();
-  MessageId *msgId = MessageId::Unwrap(obj);
-  pulsar_consumer_acknowledge_async_id(this->wrapper->cConsumer, msgId->GetCMessageId(), NULL, NULL);
+Napi::Value Consumer::AcknowledgeId(const Napi::CallbackInfo &info) {
+  auto obj = info[0].As<Napi::Object>();
+  auto *msgId = MessageId::Unwrap(obj);
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_consumer_acknowledge_async_id(
+      this->cConsumer.get(), msgId->GetCMessageId().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 acknowledge id: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
 void Consumer::NegativeAcknowledge(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   Message *msg = Message::Unwrap(obj);
-  pulsar_consumer_negative_acknowledge(this->wrapper->cConsumer, msg->GetCMessage());
+  std::shared_ptr<pulsar_message_t> cMessage = msg->GetCMessage();
+  pulsar_consumer_negative_acknowledge(this->cConsumer.get(), cMessage.get());
 }
 
 void Consumer::NegativeAcknowledgeId(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   MessageId *msgId = MessageId::Unwrap(obj);
-  pulsar_consumer_negative_acknowledge_id(this->wrapper->cConsumer, msgId->GetCMessageId());
+  std::shared_ptr<pulsar_message_id_t> cMessageId = msgId->GetCMessageId();
+  pulsar_consumer_negative_acknowledge_id(this->cConsumer.get(), cMessageId.get());
 }
 
-void Consumer::AcknowledgeCumulative(const Napi::CallbackInfo &info) {
-  Napi::Object obj = info[0].As<Napi::Object>();
-  Message *msg = Message::Unwrap(obj);
-  pulsar_consumer_acknowledge_cumulative_async(this->wrapper->cConsumer, msg->GetCMessage(), NULL, NULL);
+Napi::Value Consumer::AcknowledgeCumulative(const Napi::CallbackInfo &info) {
+  auto obj = info[0].As<Napi::Object>();
+  auto *msg = Message::Unwrap(obj);
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_consumer_acknowledge_cumulative_async(
+      this->cConsumer.get(), msg->GetCMessage().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 acknowledge cumulatively: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
-void Consumer::AcknowledgeCumulativeId(const Napi::CallbackInfo &info) {
-  Napi::Object obj = info[0].As<Napi::Object>();
-  MessageId *msgId = MessageId::Unwrap(obj);
-  pulsar_consumer_acknowledge_cumulative_async_id(this->wrapper->cConsumer, msgId->GetCMessageId(), NULL,
-                                                  NULL);
+Napi::Value Consumer::AcknowledgeCumulativeId(const Napi::CallbackInfo &info) {
+  auto obj = info[0].As<Napi::Object>();
+  auto *msgId = MessageId::Unwrap(obj);
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_consumer_acknowledge_cumulative_async_id(
+      this->cConsumer.get(), msgId->GetCMessageId().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 acknowledge cumulatively by id: ") +
+                           pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
 Napi::Value Consumer::IsConnected(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  return Napi::Boolean::New(env, pulsar_consumer_is_connected(this->wrapper->cConsumer));
+  return Napi::Boolean::New(env, pulsar_consumer_is_connected(this->cConsumer.get()));
 }
 
-class ConsumerCloseWorker : public Napi::AsyncWorker {
- public:
-  ConsumerCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer,
-                      Consumer *consumer)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cConsumer(cConsumer),
-        consumer(consumer) {}
-
-  ~ConsumerCloseWorker() {}
-  void Execute() {
-    pulsar_consumer_pause_message_listener(this->cConsumer);
-    pulsar_result result = pulsar_consumer_close(this->cConsumer);
-    if (result != pulsar_result_Ok) {
-      SetError(pulsar_result_str(result));
-    }
-  }
-  void OnOK() {
-    this->consumer->Cleanup();
-    this->deferred.Resolve(Env().Null());
-  }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to close consumer: ") + e.Message()).Value());
-  }
-
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_consumer_t *cConsumer;
-  Consumer *consumer;
-};
-
-class ConsumerUnsubscribeWorker : public Napi::AsyncWorker {
- public:
-  ConsumerUnsubscribeWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer,
-                            Consumer *consumer)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cConsumer(cConsumer),
-        consumer(consumer) {}
-
-  ~ConsumerUnsubscribeWorker() {}
-  void Execute() {
-    pulsar_consumer_pause_message_listener(this->cConsumer);
-    pulsar_result result = pulsar_consumer_unsubscribe(this->cConsumer);
-    if (result != pulsar_result_Ok) {
-      SetError(pulsar_result_str(result));
-    }
-  }
-  void OnOK() {
-    this->consumer->Cleanup();
-    this->deferred.Resolve(Env().Null());
-  }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to unsubscribe consumer: ") + e.Message()).Value());
-  }
-
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_consumer_t *cConsumer;
-  Consumer *consumer;
-};
-
 void Consumer::Cleanup() {
-  if (this->listener) {
-    this->CleanupListener();
+  if (this->listener != nullptr) {
+    pulsar_consumer_pause_message_listener(this->cConsumer.get());
+    this->listener->callback.Release();
+    this->listener = nullptr;
+    this->Unref();
   }
 }
 
-void Consumer::CleanupListener() {
-  pulsar_consumer_pause_message_listener(this->wrapper->cConsumer);
-  this->Unref();
-  this->listener->callback.Release();
-  this->listener = nullptr;
-}
-
 Napi::Value Consumer::Close(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ConsumerCloseWorker *wk = new ConsumerCloseWorker(deferred, this->wrapper->cConsumer, this);
-  wk->Queue();
-  return deferred.Promise();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+  this->Cleanup();
+
+  pulsar_consumer_close_async(
+      this->cConsumer.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 consumer: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
 Napi::Value Consumer::Unsubscribe(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ConsumerUnsubscribeWorker *wk = new ConsumerUnsubscribeWorker(deferred, this->wrapper->cConsumer, this);
-  wk->Queue();
-  return deferred.Promise();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_consumer_pause_message_listener(this->cConsumer.get());
+  pulsar_consumer_unsubscribe_async(
+      this->cConsumer.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 unsubscribe consumer: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
-Consumer::~Consumer() {
-  if (this->listener) {
-    this->CleanupListener();
-  }
-}
+Consumer::~Consumer() { this->Cleanup(); }

package/src/Consumer.h

@@ -28,26 +28,26 @@
 class Consumer : public Napi::ObjectWrap<Consumer> {
  public:
   static void Init(Napi::Env env, Napi::Object exports);
-  static Napi::Value NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient);
+  static Napi::Value NewInstance(const Napi::CallbackInfo &info, std::shared_ptr<pulsar_client_t> cClient);
   static Napi::FunctionReference constructor;
   Consumer(const Napi::CallbackInfo &info);
   ~Consumer();
-  void SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer);
-  void SetListenerCallback(ListenerCallback *listener);
+  void SetCConsumer(std::shared_ptr<pulsar_consumer_t> cConsumer);
+  void SetListenerCallback(MessageListenerCallback *listener);
   void Cleanup();
   void CleanupListener();
 
  private:
-  std::shared_ptr<CConsumerWrapper> wrapper;
-  ListenerCallback *listener;
+  std::shared_ptr<pulsar_consumer_t> cConsumer;
+  MessageListenerCallback *listener;
 
   Napi::Value Receive(const Napi::CallbackInfo &info);
-  void Acknowledge(const Napi::CallbackInfo &info);
-  void AcknowledgeId(const Napi::CallbackInfo &info);
+  Napi::Value Acknowledge(const Napi::CallbackInfo &info);
+  Napi::Value AcknowledgeId(const Napi::CallbackInfo &info);
   void NegativeAcknowledge(const Napi::CallbackInfo &info);
   void NegativeAcknowledgeId(const Napi::CallbackInfo &info);
-  void AcknowledgeCumulative(const Napi::CallbackInfo &info);
-  void AcknowledgeCumulativeId(const Napi::CallbackInfo &info);
+  Napi::Value AcknowledgeCumulative(const Napi::CallbackInfo &info);
+  Napi::Value AcknowledgeCumulativeId(const Napi::CallbackInfo &info);
   Napi::Value IsConnected(const Napi::CallbackInfo &info);
   Napi::Value Close(const Napi::CallbackInfo &info);
   Napi::Value Unsubscribe(const Napi::CallbackInfo &info);