pulsar-client 1.6.2-rc.1 → 1.7.0

package/README.md

@@ -40,13 +40,14 @@ Also, this library works only in Node.js 10.x or later because it uses the
 
 Compatibility between each version of the Node.js client and the C++ client is as follows:
 
-| Node.js client | C++ client     |
-|----------------|----------------|
-| 1.0.x          | 2.3.0 or later |
-| 1.1.x          | 2.4.0 or later |
-| 1.2.x          | 2.5.0 or later |
-| 1.3.x          | 2.7.0 or later |
-| 1.4.x - 1.5.x  | 2.8.0 or later |
+| Node.js client | C++ client      |
+|----------------|-----------------|
+| 1.0.x          | 2.3.0 or later  |
+| 1.1.x          | 2.4.0 or later  |
+| 1.2.x          | 2.5.0 or later  |
+| 1.3.x          | 2.7.0 or later  |
+| 1.4.x - 1.6.x  | 2.8.0 or later  |
+| 1.7.x          | 2.10.1 or later |
 
 If an incompatible version of the C++ client is installed, you may fail to build or run this library.
 
@@ -99,7 +100,46 @@ brew info libpulsar
 
 ```shell
 # for example
+## Intel x86_64
 export PULSAR_CPP_DIR=/usr/local/Cellar/libpulsar/2.9.1_1
+
+## Apple Silicon and Homebrew since 3.0.0
+## cf. https://brew.sh/2021/02/05/homebrew-3.0.0/
+export PULSAR_CPP_DIR=/opt/homebrew/Cellar/libpulsar/2.9.1_1
+```
+
+### Install on Linux
+
+1. Require g++ and make commands to install pulsar-client
+```
+# rpm
+$ yum install gcc-c++ make
+
+# debian
+$ apt-get install g++ make
+```
+
+2. Download rpm or debian packages.
+```
+# Set the version of Pulsar C++ client to install
+$ PULSAR_CPP_CLIENT_VERSION=2.9.1
+
+# rpm
+$ wget https://archive.apache.org/dist/pulsar/pulsar-${PULSAR_CPP_CLIENT_VERSION}/RPMS/apache-pulsar-client-${PULSAR_CPP_CLIENT_VERSION}-1.x86_64.rpm
+$ wget https://archive.apache.org/dist/pulsar/pulsar-${PULSAR_CPP_CLIENT_VERSION}/RPMS/apache-pulsar-client-devel-${PULSAR_CPP_CLIENT_VERSION}-1.x86_64.rpm
+
+# debian
+$ wget https://archive.apache.org/dist/pulsar/pulsar-${PULSAR_CPP_CLIENT_VERSION}/DEB/apache-pulsar-client.deb
+$ wget https://archive.apache.org/dist/pulsar/pulsar-${PULSAR_CPP_CLIENT_VERSION}/DEB/apache-pulsar-client-dev.deb
+```
+
+3. Install the Pulsar C++ client.
+```shell
+# rpm
+$ rpm -ivh apache-pulsar-client*.rpm
+
+# debian
+$ apt install ./apache-pulsar-client*.deb
 ```
 
 
@@ -132,3 +172,6 @@ $ npm install
 ```shell
 $ npm run build
 ```
+
+## Documentation
+* Please see https://pulsar.apache.org/docs/en/client-libraries-node for more details about the Pulsar Node.js client.  

package/binding.gyp

@@ -21,9 +21,9 @@
   'conditions': [
     ['OS=="win"', {
       'variables': {
-       'pulsar_cpp_dir%': '<!(echo %PULSAR_CPP_DIR%)',
-       'os_arch%': '<!(echo %OS_ARCH%)',
-      },
+        'pulsar_cpp_dir%': '<!(echo %PULSAR_CPP_DIR%)',
+        'os_arch%': '<!(echo %OS_ARCH%)',
+      }
     }],
     ['OS=="mac"', {
       'variables': {
@@ -40,30 +40,47 @@
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")",
       ],
-      "defines": ["NAPI_VERSION=4", "NAPI_DISABLE_CPP_EXCEPTIONS=1"],
+      "defines": ["NAPI_VERSION=4"],
       "sources": [
         "src/addon.cc",
         "src/Message.cc",
         "src/MessageId.cc",
         "src/Authentication.cc",
         "src/Client.cc",
+        "src/SchemaInfo.cc",
         "src/Producer.cc",
         "src/ProducerConfig.cc",
         "src/Consumer.cc",
         "src/ConsumerConfig.cc",
         "src/Reader.cc",
         "src/ReaderConfig.cc",
+        "src/ThreadSafeDeferred.cc"
       ],
       'conditions': [
         ['OS=="mac"', {
+          'xcode_settings': {
+            'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+            'CLANG_CXX_LIBRARY': 'libc++'
+          },
           "include_dirs": [
             "<(pulsar_cpp_dir)/include",
           ],
           "libraries": [
             "<(pulsar_cpp_dir)/lib/libpulsar.dylib"
           ],
+          "dependencies": [
+            "<!@(node -p \"require('node-addon-api').gyp\")"
+          ],
         }],
         ['OS=="win"', {
+          "defines": [
+            "_HAS_EXCEPTIONS=1"
+          ],
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1
+            },
+          },
           "include_dirs": [
             "<(pulsar_cpp_dir)\include",
           ],
@@ -89,7 +106,8 @@
               ]
             }
           ]
-        }, {  # 'OS!="win"'
+        }],
+        ['OS!="mac" and OS!="win"', {
           "libraries": [
             "-lpulsar",
           ],

package/docker-tests.sh

@@ -18,11 +18,11 @@
 # under the License.
 #
 
-ROOT_DIR=$(git rev-parse --show-toplevel)
+ROOT_DIR=${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}"
+BUILD_IMAGE_VERSION="${BUILD_IMAGE_VERSION:-ubuntu-20.04}"
 
 IMAGE="$BUILD_IMAGE_NAME:$BUILD_IMAGE_VERSION"
 
@@ -30,7 +30,8 @@ echo "---- Testing Pulsar node client using image $IMAGE"
 
 docker pull $IMAGE
 
-DOCKER_CMD="docker run -i -v $ROOT_DIR:/pulsar-client-node $IMAGE"
+TARGET_DIR=/pulsar-client-node
+DOCKER_CMD="docker run -i -e ROOT_DIR=$TARGET_DIR -v $ROOT_DIR:$TARGET_DIR $IMAGE"
 
 # Start Pulsar standalone instance
 # and execute the tests

package/index.d.ts

@@ -34,6 +34,7 @@ export interface ClientConfig {
 }
 
 export class Client {
+  static setLogHandler(logHandler: (level: LogLevel, file: string, line: number, message: string) => void): void;
   constructor(config: ClientConfig);
   createProducer(config: ProducerConfig): Promise<Producer>;
   subscribe(config: ConsumerConfig): Promise<Consumer>;
@@ -91,12 +92,12 @@ export interface ConsumerConfig {
 
 export class Consumer {
   receive(timeout?: number): Promise<Message>;
-  acknowledge(message: Message): void;
-  acknowledgeId(messageId: MessageId): void;
+  acknowledge(message: Message): Promise<null>;
+  acknowledgeId(messageId: MessageId): Promise<null>;
   negativeAcknowledge(message: Message): void;
   negativeAcknowledgeId(messageId: MessageId): void;
-  acknowledgeCumulative(message: Message): void;
-  acknowledgeCumulativeId(messageId: MessageId): void;
+  acknowledgeCumulative(message: Message): Promise<null>;
+  acknowledgeCumulativeId(messageId: MessageId): Promise<null>;
   isConnected(): boolean;
   close(): Promise<null>;
   unsubscribe(): Promise<null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.6.2-rc.1",
+  "version": "1.7.0",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,7 +9,7 @@
     "example": "examples"
   },
   "scripts": {
-    "install": "node-pre-gyp install --fallback-to-build",
+    "install": "node-gyp rebuild",
     "clean": "node-gyp clean",
     "configure": "node-gyp configure",
     "lint": "clang-format-lint src/*.cc src/*.h && eslint --ext .js .",
@@ -25,6 +25,7 @@
     "type": "git",
     "url": "https://github.com/apache/pulsar-client-node.git"
   },
+  "homepage": "https://pulsar.apache.org/docs/en/client-libraries-node",
   "author": "Apache Software Foundation",
   "license": "Apache-2.0",
   "gypfile": true,
@@ -51,15 +52,8 @@
     "typescript": "^4.1.3"
   },
   "dependencies": {
-    "@mapbox/node-pre-gyp": "^1.0.7",
     "bindings": "^1.5.0",
-    "node-addon-api": "^3.2.1",
-    "node-gyp": "^8.4.1"
-  },
-  "binary": {
-    "module_name": "libpulsar",
-    "module_path": "./build/Release",
-    "host": "https://pulsar.apache.org/docs/en/client-libraries-cpp/"
+    "node-addon-api": "^4.3.0"
   },
   "license-check-and-add-config": {
     "folder": ".",

package/pulsar-test-service-start.sh

@@ -20,7 +20,7 @@
 
 set -e
 
-ROOT_DIR=$(git rev-parse --show-toplevel)
+ROOT_DIR=${ROOT_DIR:-$(git rev-parse --show-toplevel)}
 cd $ROOT_DIR
 
 VERSION="${VERSION:-`cat ./pulsar-version.txt`}"

package/pulsar-version.txt

@@ -1 +1 @@
-2.8.0
+2.10.1

package/run-unit-tests.sh

@@ -20,7 +20,7 @@
 
 set -e
 
-ROOT_DIR=$(git rev-parse --show-toplevel)
+ROOT_DIR=${ROOT_DIR:-$(git rev-parse --show-toplevel)}
 cd $ROOT_DIR
 
 # install pulsar cpp client pkg

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