pulsar-client 1.6.2 → 1.8.0-rc1

package/pkg/mac/build-cpp-deps-lib.sh

@@ -0,0 +1,186 @@
+#!/usr/bin/env bash
+#
+# 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.
+#
+
+source $(dirname $0)/common.sh
+
+cd $ROOT_DIR
+
+pip3 install pyyaml
+
+dep=$ROOT_DIR/build-support/dep-version.py
+ZLIB_VERSION=$($dep zlib)
+OPENSSL_VERSION=$($dep openssl)
+BOOST_VERSION=$($dep boost)
+PROTOBUF_VERSION=$($dep protobuf)
+ZSTD_VERSION=$($dep zstd)
+SNAPPY_VERSION=$($dep snappy)
+CURL_VERSION=$($dep curl)
+
+cd $MAC_BUILD_DIR/build
+
+##############################################################################
+if [ ! -f zlib-${ZLIB_VERSION}.done ]; then
+    echo "Building ZLib"
+    curl -O -L https://zlib.net/fossils/zlib-${ZLIB_VERSION}.tar.gz
+    tar xfz zlib-$ZLIB_VERSION.tar.gz
+    pushd zlib-$ZLIB_VERSION
+      CFLAGS="-fPIC -O3 -arch ${ARCH} -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" ./configure --prefix=$PREFIX
+      make -j16
+      make install
+    popd
+
+    rm -rf zlib-$ZLIB_VERSION.tar.gz zlib-$ZLIB_VERSION
+    touch zlib-${ZLIB_VERSION}.done
+else
+    echo "Using cached ZLib"
+fi
+
+###############################################################################
+OPENSSL_VERSION_UNDERSCORE=$(echo $OPENSSL_VERSION | sed 's/\./_/g')
+if [ ! -f openssl-OpenSSL_${OPENSSL_VERSION_UNDERSCORE}.done ]; then
+    echo "Building OpenSSL"
+    curl -O -L https://github.com/openssl/openssl/archive/OpenSSL_${OPENSSL_VERSION_UNDERSCORE}.tar.gz
+    tar xfz OpenSSL_${OPENSSL_VERSION_UNDERSCORE}.tar.gz
+    pushd openssl-OpenSSL_${OPENSSL_VERSION_UNDERSCORE}
+        if [ $ARCH = 'arm64' ]; then
+          PLATFORM=darwin64-arm64-cc
+        else
+          PLATFORM=darwin64-x86_64-cc
+        fi
+        ./Configure --prefix=$PREFIX no-shared no-unit-test $PLATFORM
+        make -j8
+        make install_sw
+    popd
+
+    rm -rf OpenSSL_${OPENSSL_VERSION_UNDERSCORE}.tar.gz openssl-OpenSSL_${OPENSSL_VERSION_UNDERSCORE}
+    touch openssl-OpenSSL_${OPENSSL_VERSION_UNDERSCORE}.done
+else
+    echo "Using cached OpenSSL"
+fi
+
+###############################################################################
+BOOST_VERSION_=${BOOST_VERSION//./_}
+DIR=boost-src-${BOOST_VERSION}
+if [ ! -f $DIR.done ]; then
+    echo "Building Boost"
+    curl -O -L https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_}.tar.gz
+    tar xfz boost_${BOOST_VERSION_}.tar.gz
+    rm -rf $DIR
+    mv boost_${BOOST_VERSION_} $DIR
+
+    pushd $DIR
+      ./bootstrap.sh --prefix=$PREFIX --with-libraries=system
+      ./b2 address-model=64 cxxflags="-fPIC -arch ${ARCH} -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" \
+                link=static threading=multi \
+                variant=release \
+                install
+    popd
+
+    rm -rf $DIR boost_${BOOST_VERSION_}.tar.gz
+    touch $DIR.done
+else
+    echo "Using cached Boost"
+fi
+
+###############################################################################
+if [ ! -f protobuf-${PROTOBUF_VERSION}.done ]; then
+    echo "Building Protobuf"
+    curl -O -L  https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-cpp-${PROTOBUF_VERSION}.tar.gz
+    tar xfz protobuf-cpp-${PROTOBUF_VERSION}.tar.gz
+    pushd protobuf-${PROTOBUF_VERSION}
+      CXXFLAGS="-fPIC -arch arm64 -arch x86_64 -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" \
+            ./configure --prefix=$PREFIX
+      make -j16 V=1
+      make install
+    popd
+
+    pushd install/lib
+      echo "Propose target arch static lib" ${ARCH}
+      mv libprotobuf.a libprotobuf_universal.a
+      lipo libprotobuf_universal.a -thin ${ARCH} -output libprotobuf.a
+    popd
+
+    rm -rf protobuf-${PROTOBUF_VERSION} protobuf-cpp-${PROTOBUF_VERSION}.tar.gz
+    touch protobuf-${PROTOBUF_VERSION}.done
+else
+    echo "Using cached Protobuf"
+fi
+
+###############################################################################
+if [ ! -f zstd-${ZSTD_VERSION}.done ]; then
+    echo "Building ZStd"
+    curl -O -L https://github.com/facebook/zstd/releases/download/v${ZSTD_VERSION}/zstd-${ZSTD_VERSION}.tar.gz
+    tar xfz zstd-${ZSTD_VERSION}.tar.gz
+    pushd zstd-${ZSTD_VERSION}
+      CFLAGS="-fPIC -O3 -arch ${ARCH} -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" \
+          PREFIX=$PREFIX  \
+          make -j16 -C lib install
+    popd
+
+    rm -rf zstd-${ZSTD_VERSION} zstd-${ZSTD_VERSION}.tar.gz
+    touch zstd-${ZSTD_VERSION}.done
+else
+    echo "Using cached ZStd"
+fi
+
+###############################################################################
+if [ ! -f snappy-${SNAPPY_VERSION}.done ]; then
+    echo "Building Snappy"
+    curl -O -L https://github.com/google/snappy/archive/refs/tags/${SNAPPY_VERSION}.tar.gz
+    tar xfz ${SNAPPY_VERSION}.tar.gz
+    pushd snappy-${SNAPPY_VERSION}
+      CXXFLAGS="-fPIC -O3 -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" \
+          cmake . -DCMAKE_OSX_ARCHITECTURES=${ARCH} -DCMAKE_INSTALL_PREFIX=$PREFIX -DSNAPPY_BUILD_TESTS=OFF -DSNAPPY_BUILD_BENCHMARKS=OFF
+      make -j16
+      make install
+      touch .done
+    popd
+
+    rm -rf snappy-${SNAPPY_VERSION} ${SNAPPY_VERSION}.tar.gz
+    touch snappy-${SNAPPY_VERSION}.done
+else
+    echo "Using cached Snappy"
+fi
+
+###############################################################################
+if [ ! -f curl-${CURL_VERSION}.done ]; then
+    echo "Building LibCurl"
+    CURL_VERSION_=${CURL_VERSION//./_}
+    curl -O -L  https://github.com/curl/curl/releases/download/curl-${CURL_VERSION_}/curl-${CURL_VERSION}.tar.gz
+    tar xfz curl-${CURL_VERSION}.tar.gz
+    pushd curl-${CURL_VERSION}
+      CFLAGS="-fPIC -arch ${ARCH} -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}" \
+            ./configure --with-ssl=$PREFIX \
+              --without-nghttp2 \
+              --without-libidn2 \
+              --disable-ldap \
+              --without-brotli \
+              --without-secure-transport \
+              --disable-ipv6 \
+              --prefix=$PREFIX \
+              --host=$ARCH-apple-darwin
+      make -j16 install
+    popd
+
+    rm -rf curl-${CURL_VERSION} curl-${CURL_VERSION}.tar.gz
+    touch curl-${CURL_VERSION}.done
+else
+    echo "Using cached LibCurl"
+fi

package/pkg/mac/build-cpp-lib.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+#
+# 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.
+#
+
+source $(dirname $0)/common.sh
+
+PULSAR_DIR=${MAC_BUILD_DIR}/build-pulsar
+PULSAR_PREFIX=${PULSAR_DIR}/install
+mkdir -p $PULSAR_PREFIX
+cd $PULSAR_DIR
+
+## Fetch from official release
+curl -O -L "$CPP_CLIENT_BASE_URL"/apache-pulsar-client-cpp-${CPP_CLIENT_VERSION}.tar.gz
+tar xfz apache-pulsar-client-cpp-${CPP_CLIENT_VERSION}.tar.gz
+pushd apache-pulsar-client-cpp-${CPP_CLIENT_VERSION}
+  rm -f CMakeCache.txt
+  cmake . \
+      -DCMAKE_OSX_ARCHITECTURES=${ARCH} \
+      -DCMAKE_OSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET} \
+      -DCMAKE_INSTALL_PREFIX=$PULSAR_PREFIX \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_PREFIX_PATH=$PREFIX \
+      -DCMAKE_INSTALL_LIBDIR=$PULSAR_PREFIX/lib \
+      -DLINK_STATIC=ON \
+      -DBUILD_TESTS=OFF \
+      -DBUILD_PYTHON_WRAPPER=OFF \
+      -DBUILD_DYNAMIC_LIB=OFF \
+      -DPROTOC_PATH=$PREFIX/bin/protoc
+  make -j16 install
+  mkdir -p $ROOT_DIR/pkg/lib/
+  cp -r lib/libpulsarwithdeps.a $ROOT_DIR/pkg/lib/
+popd
+
+rm -rf apache-pulsar-client-cpp-${CPP_CLIENT_VERSION}.tar.gz apache-pulsar-client-cpp-${CPP_CLIENT_VERSION}
+

package/{docker-tests.sh → pkg/mac/common.sh}

@@ -1,4 +1,3 @@
-#!/bin/bash
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
@@ -18,20 +17,21 @@
 # under the License.
 #
 
-ROOT_DIR=$(git rev-parse --show-toplevel)
-cd $ROOT_DIR
-
-BUILD_IMAGE_NAME="${BUILD_IMAGE_NAME:-apachepulsar/pulsar-build}"
-BUILD_IMAGE_VERSION="${BUILD_IMAGE_VERSION:-ubuntu-16.04}"
+set -e -x
 
-IMAGE="$BUILD_IMAGE_NAME:$BUILD_IMAGE_VERSION"
+if [ -z "$ARCH" ]; then
+   export ARCH=$(uname -m)
+fi
 
-echo "---- Testing Pulsar node client using image $IMAGE"
+export MACOSX_DEPLOYMENT_TARGET=11.0
 
-docker pull $IMAGE
+MAC_BUILD_DIR=`cd $(dirname $0); pwd`
+ROOT_DIR=$(git rev-parse --show-toplevel)
+source $ROOT_DIR/pulsar-client-cpp.txt
 
-DOCKER_CMD="docker run -i -v $ROOT_DIR:/pulsar-client-node $IMAGE"
+cd $MAC_BUILD_DIR
+mkdir -p build
+cd build
+mkdir -p install
+export PREFIX=`pwd`/install
 
-# Start Pulsar standalone instance
-# and execute the tests
-$DOCKER_CMD bash -c "cd /pulsar-client-node && ./run-unit-tests.sh"

package/pkg/windows/download-cpp-client.bat

@@ -0,0 +1,12 @@
+cd %~dp0
+set arch=%1
+if "%arch%" == "" (
+reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x86" > NUL && set arch=x86 || set arch=x64
+)
+for /F "delims== tokens=1,2" %%a in (..\..\pulsar-client-cpp.txt) do set "%%a=%%b"
+curl -O -L %CPP_CLIENT_BASE_URL%/%arch%-windows-static.tar.gz
+tar -xvzf %arch%-windows-static.tar.gz
+move %arch%-windows-static pulsar-cpp
+dir
+
+

package/pulsar-client-cpp.txt

@@ -0,0 +1,2 @@
+CPP_CLIENT_BASE_URL=https://archive.apache.org/dist/pulsar/pulsar-client-cpp-3.1.0/
+CPP_CLIENT_VERSION=3.1.0

package/src/AuthenticationAthenz.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-const PulsarBinding = require('bindings')('Pulsar');
+const PulsarBinding = require('./pulsar-binding');
 
 class AuthenticationAthenz {
   constructor(params) {

package/src/AuthenticationOauth2.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-const PulsarBinding = require('bindings')('Pulsar');
+const PulsarBinding = require('./pulsar-binding');
 
 class AuthenticationOauth2 {
   constructor(params) {

package/src/AuthenticationTls.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-const PulsarBinding = require('bindings')('Pulsar');
+const PulsarBinding = require('./pulsar-binding');
 
 class AuthenticationTls {
   constructor(params) {

package/src/AuthenticationToken.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-const PulsarBinding = require('bindings')('Pulsar');
+const PulsarBinding = require('./pulsar-binding');
 
 class AuthenticationToken {
   constructor(params) {

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);