pulsar-client 1.3.1 → 1.4.1-rc.1

package/examples/certificate/private-key.client-rsa.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAtKWwgqdnTYrOCv+j1MkTWfSH0wCsHZZca9wAW3qP4uuhlBvn
+b10JcFf5ZjzP9BSXK+tHmI8uoN368vEv6yhURHM4yuXqzCxzuAwkQSo39rzX8PGC
+7qdjCN7LDJ3MnqiBIrUsSaEP1wrNsB1kI+o9ER1e5O/uEPAotP933hHQ0J2hMEek
+HqL7sBlJ98h6NmsicEaUkardk0TOXrlkjC+cMd8ZbGScPqI9M38bmn3OLxFTn1vt
+hpvnXLvCmG4M+6xtYtD+npcVPZw1i1R90fMs7ppZnRbv8Hc/DFdOKVQIgam6CDdn
+NKgW7c7IBMrP0AEm37HTu0LSOjP2OHXlvvlQGQIDAQABAoIBAAaJFAi2C7u3cNrf
+AstY9vVDLoLIvHFZlkBktjKZDYmVIsRb+hSCViwVUrWLL67R6+Iv4eg4DeTOAx00
+8pncXKgZTw2wIb1/QjR/Y/RjlaC8lkdmRWli7udMQCZVsyhuSjW6Pj7vr8YE4woj
+FhNijxEGcf9wWrmMJrzdnTWQiXByo+eTvUQ9BPgPGrRjsMZmTkLyAVJff2DfxO5b
+IWFDYDJcyYAMCIMQu7vys/I50ou6ilb1CO6QM6Z7KpPeOoVFPwtzbh8cf9xM8UNS
+j6J/JmdWhgI34GS3NA68xTQ6PV7zjnhCc+iccm3JKyzGXwaApAZ+Eoce/9j4WKmu
+5B4ziR0CgYEA3l/9OHbl1zmyV+rRxWOIj/i2rTvHzwBnbnPJyuemL5VMFdpGodQ3
+vwHvyQmcECRVRxmXojQ4QuPPHs3qp6wEEFPCWxChLSTxlUc85SOFHWU2O99jV7zI
+7+JOpDK/Mstsx9nHgXduJF+glTFtA3LH8Oqylzu2aFPsprwKuZf94Q8CgYEAz/Zx
+akEG+PEMtP5YS28cX5XfjsIX/V26Fs6/sH16QjUIEddE5T4fCuokxCjSiwUcWhml
+pHEJ5S5xp3VYRfISW3jRW3qstIH1tpZipB6+S0zTuJmLJbA3IiWEg2rtMt7X1uJv
+A/bYOqe0hOPTuXuZdtVZ0nMTKk7GG8O6VkBI7FcCgYEAkDfCmscJgs7JahlBWHmX
+zH9pwem+SPKjIc/4NB6N+dgikx2Pp05hpP/VihUwYIufvs/LNogVYNQrtHepUnrN
+2+TmbHbZgNSv1Ldxt82UfB7y0FutKu6lhmXHyNecho3Fi8sih0V0aiSWmYuHfrAH
+GaiskEZKo1iiZvQXJIx9O2MCgYATBf0r9hTYMtyxtc6H3/sdd01C9thQ8gDy0yjP
+0Tqc0dMSJroDqmIWkoKYew9/bhFA4LW5TCnWkCAPbHmNtG4fdfbYwmkH/hdnA2y0
+jKdlpfp8GXeUFAGHGx17FA3sqFvgKUh0eWEgRHUL7vdQMVFBgJS93o7zQM94fLgP
+6cOB8wKBgFcGV4GjI2Ww9cillaC554MvoSjf8B/+04kXzDOh8iYIIzO9EUil1jjK
+Jvxp4hnLzTKWbux3MEWqurLkYas6GpKBjw+iNOCar6YdqWGVqM3RUx7PTUaZwkKx
+UdP63IfY7iZCIT/QbyHQvIUe2MaiVnH+ulxdkK6Y5e7gxcbckIH4
+-----END RSA PRIVATE KEY-----

package/examples/certificate/public-key.client-rsa.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtKWwgqdnTYrOCv+j1MkT
+WfSH0wCsHZZca9wAW3qP4uuhlBvnb10JcFf5ZjzP9BSXK+tHmI8uoN368vEv6yhU
+RHM4yuXqzCxzuAwkQSo39rzX8PGC7qdjCN7LDJ3MnqiBIrUsSaEP1wrNsB1kI+o9
+ER1e5O/uEPAotP933hHQ0J2hMEekHqL7sBlJ98h6NmsicEaUkardk0TOXrlkjC+c
+Md8ZbGScPqI9M38bmn3OLxFTn1vthpvnXLvCmG4M+6xtYtD+npcVPZw1i1R90fMs
+7ppZnRbv8Hc/DFdOKVQIgam6CDdnNKgW7c7IBMrP0AEm37HTu0LSOjP2OHXlvvlQ
+GQIDAQAB
+-----END PUBLIC KEY-----

package/examples/encryption-consumer.js

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+
+const Pulsar = require('pulsar-client');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30
+  });
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+    privateKeyPath: "./certificate/private-key.client-rsa.pem"
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/encryption-producer.js

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+const Pulsar = require('pulsar-client');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  // Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/my-topic',
+    sendTimeoutMs: 30000,
+    batchingEnabled: true,
+    publicKeyPath: "./certificate/public-key.client-rsa.pem",
+    encryptionKey: "encryption-key"
+  });
+
+  // Send messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = `my-message-${i}`;
+    producer.send({
+      data: Buffer.from(msg),
+    });
+    console.log(`Sent message: ${msg}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();
+})();

package/examples/reader_listener.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+const Pulsar = require('pulsar-client');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  // Create a reader
+  const reader = await client.createReader({
+    topic: 'persistent://public/default/my-topic',
+    startMessageId: Pulsar.MessageId.latest(),
+    listener: (msg, reader) => {
+      console.log(msg.getData().toString());
+    },
+  });
+})();

package/index.d.ts

@@ -56,6 +56,9 @@ export interface ProducerConfig {
   batchingMaxPublishDelayMs?: number;
   batchingMaxMessages?: number;
   properties?: { [key: string]: string };
+  publicKeyPath?: string;
+  encryptionKey?: string;
+  cryptoFailureAction?: ProducerCryptoFailureAction;
 }
 
 export class Producer {
@@ -64,6 +67,7 @@ export class Producer {
   close(): Promise<null>;
   getProducerName(): string;
   getTopic(): string;
+  isConnected(): boolean;
 }
 
 export interface ConsumerConfig {
@@ -81,6 +85,8 @@ export interface ConsumerConfig {
   properties?: { [key: string]: string };
   listener?: (message: Message, consumer: Consumer) => void;
   readCompacted?: boolean;
+  privateKeyPath?: string;
+  cryptoFailureAction?: ConsumerCryptoFailureAction;
 }
 
 export class Consumer {
@@ -91,6 +97,7 @@ export class Consumer {
   negativeAcknowledgeId(messageId: MessageId): void;
   acknowledgeCumulative(message: Message): void;
   acknowledgeCumulativeId(messageId: MessageId): void;
+  isConnected(): boolean;
   close(): Promise<null>;
   unsubscribe(): Promise<null>;
 }
@@ -102,11 +109,13 @@ export interface ReaderConfig {
   readerName?: string;
   subscriptionRolePrefix?: string;
   readCompacted?: boolean;
+  listener?: (message: Message, reader: Reader) => void;
 }
 
 export class Reader {
   readNext(timeout?: number): Promise<Message>;
   hasNext(): boolean;
+  isConnected(): boolean;
   close(): Promise<null>;
 }
 
@@ -116,9 +125,11 @@ export interface ProducerMessage {
   eventTimestamp?: number;
   sequenceId?: number;
   partitionKey?: string;
+  orderingKey?: string;
   replicationClusters?: string[];
   deliverAfter?: number;
   deliverAt?: number;
+  disableReplication?: boolean;
 }
 
 export class Message {
@@ -187,6 +198,10 @@ export type CompressionType =
   'ZSTD' |
   'SNAPPY';
 
+export type ProducerCryptoFailureAction =
+  'FAIL' |
+  'SEND';
+
 export type SubscriptionType =
   'Exclusive' |
   'Shared' |
@@ -196,3 +211,8 @@ export type SubscriptionType =
 export type InitialPosition =
   'Latest' |
   'Earliest';
+
+export type ConsumerCryptoFailureAction =
+  'FAIL' |
+  'DISCARD' |
+  'CONSUME';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.3.1",
+  "version": "1.4.1-rc.1",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "types": "index.d.ts",
@@ -42,10 +42,10 @@
     "eslint-config-airbnb-base": "^14.2.0",
     "eslint-plugin-import": "^2.22.0",
     "eslint-plugin-jest": "^24.3.6",
-    "grunt": "^1.3.0",
+    "grunt": "^1.4.1",
     "grunt-license-report": "^0.0.8",
     "hdr-histogram-js": "^2.0.1",
-    "jest": "^26.4.2",
+    "jest": "^27.2.4",
     "license-check-and-add": "^2.3.6",
     "lodash": "^4.17.21",
     "typescript": "^4.1.3"
@@ -53,7 +53,7 @@
   "dependencies": {
     "bindings": "^1.5.0",
     "node-addon-api": "^3.0.0",
-    "node-gyp": "^7.1.0",
+    "node-gyp": "^8.2.0",
     "node-pre-gyp": "^0.15.0"
   },
   "binary": {

package/pulsar-version.txt

@@ -1 +1 @@
-2.7.0
+2.8.0

package/src/Consumer.cc

@@ -40,6 +40,7 @@ void Consumer::Init(Napi::Env env, Napi::Object exports) {
                       InstanceMethod("negativeAcknowledgeId", &Consumer::NegativeAcknowledgeId),
                       InstanceMethod("acknowledgeCumulative", &Consumer::AcknowledgeCumulative),
                       InstanceMethod("acknowledgeCumulativeId", &Consumer::AcknowledgeCumulativeId),
+                      InstanceMethod("isConnected", &Consumer::IsConnected),
                       InstanceMethod("close", &Consumer::Close),
                       InstanceMethod("unsubscribe", &Consumer::Unsubscribe),
                   });
@@ -287,6 +288,11 @@ void Consumer::AcknowledgeCumulativeId(const Napi::CallbackInfo &info) {
                                                   NULL);
 }
 
+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));
+}
+
 class ConsumerCloseWorker : public Napi::AsyncWorker {
  public:
   ConsumerCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer,

package/src/Consumer.h

@@ -48,6 +48,7 @@ class Consumer : public Napi::ObjectWrap<Consumer> {
   void NegativeAcknowledgeId(const Napi::CallbackInfo &info);
   void AcknowledgeCumulative(const Napi::CallbackInfo &info);
   void 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);
 };

package/src/ConsumerConfig.cc

@@ -38,6 +38,8 @@ static const std::string CFG_CONSUMER_NAME = "consumerName";
 static const std::string CFG_PROPS = "properties";
 static const std::string CFG_LISTENER = "listener";
 static const std::string CFG_READ_COMPACTED = "readCompacted";
+static const std::string CFG_PRIVATE_KEY_PATH = "privateKeyPath";
+static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
 
 static const std::map<std::string, pulsar_consumer_type> SUBSCRIPTION_TYPE = {
     {"Exclusive", pulsar_ConsumerExclusive},
@@ -48,6 +50,12 @@ static const std::map<std::string, pulsar_consumer_type> SUBSCRIPTION_TYPE = {
 static const std::map<std::string, initial_position> INIT_POSITION = {
     {"Latest", initial_position_latest}, {"Earliest", initial_position_earliest}};
 
+static const std::map<std::string, pulsar_consumer_crypto_failure_action> CONSUMER_CRYPTO_FAILURE_ACTION = {
+    {"FAIL", pulsar_ConsumerFail},
+    {"DISCARD", pulsar_ConsumerDiscard},
+    {"CONSUME", pulsar_ConsumerConsume},
+};
+
 void FinalizeListenerCallback(Napi::Env env, ListenerCallback *cb, void *) { delete cb; }
 
 ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
@@ -163,6 +171,21 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
       pulsar_consumer_set_read_compacted(this->cConsumerConfig, 1);
     }
   }
+
+  if (consumerConfig.Has(CFG_PRIVATE_KEY_PATH) && consumerConfig.Get(CFG_PRIVATE_KEY_PATH).IsString()) {
+    std::string publicKeyPath = "";
+    std::string privateKeyPath = consumerConfig.Get(CFG_PRIVATE_KEY_PATH).ToString().Utf8Value();
+    pulsar_consumer_configuration_set_default_crypto_key_reader(this->cConsumerConfig, publicKeyPath.c_str(),
+                                                                privateKeyPath.c_str());
+    if (consumerConfig.Has(CFG_CRYPTO_FAILURE_ACTION) &&
+        consumerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).IsString()) {
+      std::string cryptoFailureAction = consumerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).ToString().Utf8Value();
+      if (CONSUMER_CRYPTO_FAILURE_ACTION.count(cryptoFailureAction)) {
+        pulsar_consumer_configuration_set_crypto_failure_action(
+            this->cConsumerConfig, CONSUMER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
+      }
+    }
+  }
 }
 
 ConsumerConfig::~ConsumerConfig() {

package/src/Message.cc

@@ -29,6 +29,8 @@ static const std::string CFG_PARTITION_KEY = "partitionKey";
 static const std::string CFG_REPL_CLUSTERS = "replicationClusters";
 static const std::string CFG_DELIVER_AFTER = "deliverAfter";
 static const std::string CFG_DELIVER_AT = "deliverAt";
+static const std::string CFG_DISABLE_REPLICATION = "disableReplication";
+static const std::string CFG_ORDERING_KEY = "orderingKey";
 
 Napi::FunctionReference Message::constructor;
 
@@ -206,6 +208,19 @@ pulsar_message_t *Message::BuildMessage(Napi::Object conf) {
     Napi::Number deliverAt = conf.Get(CFG_DELIVER_AT).ToNumber();
     pulsar_message_set_deliver_at(cMessage, deliverAt.Int64Value());
   }
+
+  if (conf.Has(CFG_DISABLE_REPLICATION) && conf.Get(CFG_DISABLE_REPLICATION).IsBoolean()) {
+    Napi::Boolean disableReplication = conf.Get(CFG_DISABLE_REPLICATION).ToBoolean();
+    if (disableReplication.Value()) {
+      pulsar_message_disable_replication(cMessage, 1);
+    }
+  }
+
+  if (conf.Has(CFG_ORDERING_KEY) && conf.Get(CFG_ORDERING_KEY).IsString()) {
+    Napi::String orderingKey = conf.Get(CFG_ORDERING_KEY).ToString();
+    pulsar_message_set_ordering_key(cMessage, orderingKey.Utf8Value().c_str());
+  }
+
   return cMessage;
 }
 

package/src/Producer.cc

@@ -33,7 +33,8 @@ void Producer::Init(Napi::Env env, Napi::Object exports) {
                   {InstanceMethod("send", &Producer::Send), InstanceMethod("flush", &Producer::Flush),
                    InstanceMethod("close", &Producer::Close),
                    InstanceMethod("getProducerName", &Producer::GetProducerName),
-                   InstanceMethod("getTopic", &Producer::GetTopic)});
+                   InstanceMethod("getTopic", &Producer::GetTopic),
+                   InstanceMethod("isConnected", &Producer::IsConnected)});
 
   constructor = Napi::Persistent(func);
   constructor.SuppressDestruct();
@@ -199,4 +200,9 @@ Napi::Value Producer::GetTopic(const Napi::CallbackInfo &info) {
   return Napi::String::New(env, pulsar_producer_get_topic(this->cProducer));
 }
 
+Napi::Value Producer::IsConnected(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, pulsar_producer_is_connected(this->cProducer));
+}
+
 Producer::~Producer() { pulsar_producer_free(this->cProducer); }

package/src/Producer.h

@@ -40,6 +40,7 @@ class Producer : public Napi::ObjectWrap<Producer> {
   Napi::Value Close(const Napi::CallbackInfo &info);
   Napi::Value GetProducerName(const Napi::CallbackInfo &info);
   Napi::Value GetTopic(const Napi::CallbackInfo &info);
+  Napi::Value IsConnected(const Napi::CallbackInfo &info);
 };
 
 #endif

package/src/ProducerConfig.cc

@@ -34,6 +34,9 @@ static const std::string CFG_BATCH_ENABLED = "batchingEnabled";
 static const std::string CFG_BATCH_MAX_DELAY = "batchingMaxPublishDelayMs";
 static const std::string CFG_BATCH_MAX_MSG = "batchingMaxMessages";
 static const std::string CFG_PROPS = "properties";
+static const std::string CFG_PUBLIC_KEY_PATH = "publicKeyPath";
+static const std::string CFG_ENCRYPTION_KEY = "encryptionKey";
+static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
 
 static const std::map<std::string, pulsar_partitions_routing_mode> MESSAGE_ROUTING_MODE = {
     {"UseSinglePartition", pulsar_UseSinglePartition},
@@ -53,6 +56,11 @@ static std::map<std::string, pulsar_compression_type> COMPRESSION_TYPE = {
     {"SNAPPY", pulsar_CompressionSNAPPY},
 };
 
+static std::map<std::string, pulsar_producer_crypto_failure_action> PRODUCER_CRYPTO_FAILURE_ACTION = {
+    {"FAIL", pulsar_ProducerFail},
+    {"SEND", pulsar_ProducerSend},
+};
+
 ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
   this->cProducerConfig = pulsar_producer_configuration_create();
 
@@ -153,6 +161,24 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
                                                  value.Utf8Value().c_str());
     }
   }
+
+  if (producerConfig.Has(CFG_PUBLIC_KEY_PATH) && producerConfig.Get(CFG_PUBLIC_KEY_PATH).IsString()) {
+    std::string publicKeyPath = producerConfig.Get(CFG_PUBLIC_KEY_PATH).ToString().Utf8Value();
+    std::string privateKeyPath = "";
+    pulsar_producer_configuration_set_default_crypto_key_reader(this->cProducerConfig, publicKeyPath.c_str(),
+                                                                privateKeyPath.c_str());
+    if (producerConfig.Has(CFG_ENCRYPTION_KEY) && producerConfig.Get(CFG_ENCRYPTION_KEY).IsString()) {
+      std::string encryptionKey = producerConfig.Get(CFG_ENCRYPTION_KEY).ToString().Utf8Value();
+      pulsar_producer_configuration_set_encryption_key(this->cProducerConfig, encryptionKey.c_str());
+    }
+    if (producerConfig.Has(CFG_CRYPTO_FAILURE_ACTION) &&
+        producerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).IsString()) {
+      std::string cryptoFailureAction = producerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).ToString().Utf8Value();
+      if (PRODUCER_CRYPTO_FAILURE_ACTION.count(cryptoFailureAction))
+        pulsar_producer_configuration_set_crypto_failure_action(
+            this->cProducerConfig, PRODUCER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
+    }
+  }
 }
 
 ProducerConfig::~ProducerConfig() { pulsar_producer_configuration_free(this->cProducerConfig); }

package/src/Reader.cc

@@ -22,6 +22,8 @@
 #include "ReaderConfig.h"
 #include <pulsar/c/result.h>
 #include <pulsar/c/reader.h>
+#include <atomic>
+#include <thread>
 
 Napi::FunctionReference Reader::constructor;
 
@@ -32,6 +34,7 @@ void Reader::Init(Napi::Env env, Napi::Object exports) {
                                     {
                                         InstanceMethod("readNext", &Reader::ReadNext),
                                         InstanceMethod("hasNext", &Reader::HasNext),
+                                        InstanceMethod("isConnected", &Reader::IsConnected),
                                         InstanceMethod("close", &Reader::Close),
                                     });
 
@@ -39,44 +42,86 @@ void Reader::Init(Napi::Env env, Napi::Object exports) {
   constructor.SuppressDestruct();
 }
 
-void Reader::SetCReader(pulsar_reader_t *cReader) { this->cReader = cReader; }
+struct ReaderListenerProxyData {
+  pulsar_message_t *cMessage;
+  Reader *reader;
+
+  ReaderListenerProxyData(pulsar_message_t *cMessage, Reader *reader) : cMessage(cMessage), reader(reader) {}
+};
+
+void ReaderListenerProxy(Napi::Env env, Napi::Function jsCallback, ReaderListenerProxyData *data) {
+  Napi::Object msg = Message::NewInstance({}, data->cMessage);
+  Reader *reader = data->reader;
+  delete data;
+
+  jsCallback.Call({msg, reader->Value()});
+}
 
-Reader::Reader(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Reader>(info) {}
+void ReaderListener(pulsar_reader_t *cReader, pulsar_message_t *cMessage, void *ctx) {
+  ReaderListenerCallback *readerListenerCallback = (ReaderListenerCallback *)ctx;
+  Reader *reader = (Reader *)readerListenerCallback->reader;
+  if (readerListenerCallback->callback.Acquire() != napi_ok) {
+    return;
+  }
+  ReaderListenerProxyData *dataPtr = new ReaderListenerProxyData(cMessage, reader);
+  readerListenerCallback->callback.BlockingCall(dataPtr, ReaderListenerProxy);
+  readerListenerCallback->callback.Release();
+}
+
+void Reader::SetCReader(std::shared_ptr<CReaderWrapper> cReader) { this->wrapper = cReader; }
+void Reader::SetListenerCallback(ReaderListenerCallback *listener) {
+  if (listener) {
+    // Maintain reference to reader, so it won't get garbage collected
+    // since, when we have a listener, we don't have to maintain reference to reader (in js code)
+    this->Ref();
+
+    // Pass reader as argument
+    listener->reader = this;
+  }
+
+  this->listener = listener;
+}
+
+Reader::Reader(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Reader>(info), listener(nullptr) {}
 
 class ReaderNewInstanceWorker : public Napi::AsyncWorker {
  public:
   ReaderNewInstanceWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient,
-                          ReaderConfig *readerConfig)
+                          ReaderConfig *readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
         cClient(cClient),
-        readerConfig(readerConfig) {}
+        readerConfig(readerConfig),
+        readerWrapper(readerWrapper),
+        done(false) {}
   ~ReaderNewInstanceWorker() {}
   void Execute() {
     const std::string &topic = this->readerConfig->GetTopic();
     if (topic.empty()) {
-      SetError(std::string("Topic is required and must be specified as a string when creating reader"));
+      std::string msg("Topic is required and must be specified as a string when creating reader");
+      SetError(msg);
       return;
     }
     if (this->readerConfig->GetCStartMessageId() == nullptr) {
-      SetError(std::string(
-          "StartMessageId is required and must be specified as a MessageId object when creating reader"));
+      std::string msg(
+          "StartMessageId is required and must be specified as a MessageId object when creating reader");
+      SetError(msg);
       return;
     }
 
-    pulsar_result result =
-        pulsar_client_create_reader(this->cClient, topic.c_str(), this->readerConfig->GetCStartMessageId(),
-                                    this->readerConfig->GetCReaderConfig(), &(this->cReader));
-    delete this->readerConfig;
-    if (result != pulsar_result_Ok) {
-      SetError(std::string("Failed to create reader: ") + pulsar_result_str(result));
-      return;
+    pulsar_client_create_reader_async(this->cClient, topic.c_str(), this->readerConfig->GetCStartMessageId(),
+                                      this->readerConfig->GetCReaderConfig(),
+                                      &ReaderNewInstanceWorker::createReaderCallback, (void *)this);
+
+    while (!done) {
+      std::this_thread::yield();
     }
   }
   void OnOK() {
     Napi::Object obj = Reader::constructor.New({});
     Reader *reader = Reader::Unwrap(obj);
-    reader->SetCReader(this->cReader);
+    reader->SetCReader(this->readerWrapper);
+    reader->SetListenerCallback(this->listener);
     this->deferred.Resolve(obj);
   }
   void OnError(const Napi::Error &e) { this->deferred.Reject(Napi::Error::New(Env(), e.Message()).Value()); }
@@ -84,15 +129,33 @@ class ReaderNewInstanceWorker : public Napi::AsyncWorker {
  private:
   Napi::Promise::Deferred deferred;
   pulsar_client_t *cClient;
-  ReaderConfig *readerConfig;
   pulsar_reader_t *cReader;
+  ReaderConfig *readerConfig;
+  ReaderListenerCallback *listener;
+  std::shared_ptr<CReaderWrapper> readerWrapper;
+  std::atomic<bool> done;
+  static void createReaderCallback(pulsar_result result, pulsar_reader_t *reader, void *ctx) {
+    ReaderNewInstanceWorker *worker = (ReaderNewInstanceWorker *)ctx;
+    if (result != pulsar_result_Ok) {
+      worker->SetError(std::string("Failed to create reader: ") + pulsar_result_str(result));
+    } else {
+      worker->readerWrapper->cReader = reader;
+      worker->listener = worker->readerConfig->GetListenerCallback();
+    }
+
+    delete worker->readerConfig;
+    worker->done = true;
+  }
 };
 
 Napi::Value Reader::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>();
-  ReaderConfig *readerConfig = new ReaderConfig(config);
-  ReaderNewInstanceWorker *wk = new ReaderNewInstanceWorker(deferred, cClient, readerConfig);
+
+  std::shared_ptr<CReaderWrapper> readerWrapper = std::make_shared<CReaderWrapper>();
+
+  ReaderConfig *readerConfig = new ReaderConfig(config, readerWrapper, &ReaderListener);
+  ReaderNewInstanceWorker *wk = new ReaderNewInstanceWorker(deferred, cClient, readerConfig, readerWrapper);
   wk->Queue();
   return deferred.Promise();
 }
@@ -133,11 +196,12 @@ class ReaderReadNextWorker : public Napi::AsyncWorker {
 Napi::Value Reader::ReadNext(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   if (info[0].IsUndefined()) {
-    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->cReader);
+    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->wrapper->cReader);
     wk->Queue();
   } else {
     Napi::Number timeout = info[0].As<Napi::Object>().ToNumber();
-    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->cReader, timeout.Int64Value());
+    ReaderReadNextWorker *wk =
+        new ReaderReadNextWorker(deferred, this->wrapper->cReader, timeout.Int64Value());
     wk->Queue();
   }
   return deferred.Promise();
@@ -145,7 +209,7 @@ Napi::Value Reader::ReadNext(const Napi::CallbackInfo &info) {
 
 Napi::Value Reader::HasNext(const Napi::CallbackInfo &info) {
   int value = 0;
-  pulsar_result result = pulsar_reader_has_message_available(this->cReader, &value);
+  pulsar_result result = pulsar_reader_has_message_available(this->wrapper->cReader, &value);
   if (result != pulsar_result_Ok) {
     Napi::Error::New(info.Env(), "Failed to check if next message is available").ThrowAsJavaScriptException();
     return Napi::Boolean::New(info.Env(), false);
@@ -156,18 +220,27 @@ Napi::Value Reader::HasNext(const Napi::CallbackInfo &info) {
   }
 }
 
+Napi::Value Reader::IsConnected(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, pulsar_reader_is_connected(this->wrapper->cReader));
+}
+
 class ReaderCloseWorker : public Napi::AsyncWorker {
  public:
-  ReaderCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_reader_t *cReader)
+  ReaderCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_reader_t *cReader, Reader *reader)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
-        cReader(cReader) {}
+        cReader(cReader),
+        reader(reader) {}
   ~ReaderCloseWorker() {}
   void Execute() {
     pulsar_result result = pulsar_reader_close(this->cReader);
     if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
   }
-  void OnOK() { this->deferred.Resolve(Env().Null()); }
+  void OnOK() {
+    this->reader->Cleanup();
+    this->deferred.Resolve(Env().Null());
+  }
   void OnError(const Napi::Error &e) {
     this->deferred.Reject(
         Napi::Error::New(Env(), std::string("Failed to close reader: ") + e.Message()).Value());
@@ -176,13 +249,30 @@ class ReaderCloseWorker : public Napi::AsyncWorker {
  private:
   Napi::Promise::Deferred deferred;
   pulsar_reader_t *cReader;
+  Reader *reader;
 };
 
 Napi::Value Reader::Close(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ReaderCloseWorker *wk = new ReaderCloseWorker(deferred, this->cReader);
+  ReaderCloseWorker *wk = new ReaderCloseWorker(deferred, this->wrapper->cReader, this);
   wk->Queue();
   return deferred.Promise();
 }
 
-Reader::~Reader() { pulsar_reader_free(this->cReader); }
+void Reader::Cleanup() {
+  if (this->listener) {
+    this->CleanupListener();
+  }
+}
+
+void Reader::CleanupListener() {
+  this->Unref();
+  this->listener->callback.Release();
+  this->listener = nullptr;
+}
+
+Reader::~Reader() {
+  if (this->listener) {
+    this->CleanupListener();
+  }
+}

package/src/Reader.h

@@ -22,6 +22,7 @@
 
 #include <napi.h>
 #include <pulsar/c/client.h>
+#include "ReaderConfig.h"
 
 class Reader : public Napi::ObjectWrap<Reader> {
  public:
@@ -30,14 +31,19 @@ class Reader : public Napi::ObjectWrap<Reader> {
   static Napi::FunctionReference constructor;
   Reader(const Napi::CallbackInfo &info);
   ~Reader();
-  void SetCReader(pulsar_reader_t *cReader);
+  void SetCReader(std::shared_ptr<CReaderWrapper> cReader);
+  void SetListenerCallback(ReaderListenerCallback *listener);
+  void Cleanup();
 
  private:
-  pulsar_reader_t *cReader;
+  std::shared_ptr<CReaderWrapper> wrapper;
+  ReaderListenerCallback *listener;
 
   Napi::Value ReadNext(const Napi::CallbackInfo &info);
   Napi::Value HasNext(const Napi::CallbackInfo &info);
+  Napi::Value IsConnected(const Napi::CallbackInfo &info);
   Napi::Value Close(const Napi::CallbackInfo &info);
+  void CleanupListener();
 };
 
 #endif

package/src/ReaderConfig.cc

@@ -27,8 +27,13 @@ static const std::string CFG_RECV_QUEUE = "receiverQueueSize";
 static const std::string CFG_READER_NAME = "readerName";
 static const std::string CFG_SUBSCRIPTION_ROLE_PREFIX = "subscriptionRolePrefix";
 static const std::string CFG_READ_COMPACTED = "readCompacted";
+static const std::string CFG_LISTENER = "listener";
 
-ReaderConfig::ReaderConfig(const Napi::Object &readerConfig) : topic(""), cStartMessageId(NULL) {
+void FinalizeListenerCallback(Napi::Env env, ReaderListenerCallback *cb, void *) { delete cb; }
+
+ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper,
+                           pulsar_reader_listener readerListener)
+    : topic(""), cStartMessageId(NULL), listener(nullptr) {
   this->cReaderConfig = pulsar_reader_configuration_create();
 
   if (readerConfig.Has(CFG_TOPIC) && readerConfig.Get(CFG_TOPIC).IsString()) {
@@ -67,12 +72,40 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig) : topic(""), cStart
       pulsar_reader_configuration_set_read_compacted(this->cReaderConfig, 1);
     }
   }
+
+  if (readerConfig.Has(CFG_LISTENER) && readerConfig.Get(CFG_LISTENER).IsFunction()) {
+    this->listener = new ReaderListenerCallback();
+    Napi::ThreadSafeFunction callback = Napi::ThreadSafeFunction::New(
+        readerConfig.Env(), readerConfig.Get(CFG_LISTENER).As<Napi::Function>(), "Reader Listener Callback",
+        1, 1, (void *)NULL, FinalizeListenerCallback, listener);
+    this->listener->callback = std::move(callback);
+    pulsar_reader_configuration_set_reader_listener(this->cReaderConfig, readerListener, this->listener);
+  }
 }
 
-ReaderConfig::~ReaderConfig() { pulsar_reader_configuration_free(this->cReaderConfig); }
+ReaderConfig::~ReaderConfig() {
+  pulsar_reader_configuration_free(this->cReaderConfig);
+  if (this->listener) {
+    this->listener->callback.Release();
+  }
+}
 
 pulsar_reader_configuration_t *ReaderConfig::GetCReaderConfig() { return this->cReaderConfig; }
 
 std::string ReaderConfig::GetTopic() { return this->topic; }
 
 pulsar_message_id_t *ReaderConfig::GetCStartMessageId() { return this->cStartMessageId; }
+
+ReaderListenerCallback *ReaderConfig::GetListenerCallback() {
+  ReaderListenerCallback *cb = this->listener;
+  this->listener = nullptr;
+  return cb;
+}
+
+CReaderWrapper::CReaderWrapper() : cReader(nullptr) {}
+
+CReaderWrapper::~CReaderWrapper() {
+  if (this->cReader) {
+    pulsar_reader_free(this->cReader);
+  }
+}

package/src/ReaderConfig.h

@@ -24,19 +24,23 @@
 #include <pulsar/c/reader.h>
 #include <pulsar/c/reader_configuration.h>
 #include <pulsar/c/message_id.h>
+#include "ReaderListener.h"
 
 class ReaderConfig {
  public:
-  ReaderConfig(const Napi::Object &readerConfig);
+  ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper,
+               pulsar_reader_listener readerListener);
   ~ReaderConfig();
   pulsar_reader_configuration_t *GetCReaderConfig();
   pulsar_message_id_t *GetCStartMessageId();
   std::string GetTopic();
+  ReaderListenerCallback *GetListenerCallback();
 
  private:
   std::string topic;
   pulsar_message_id_t *cStartMessageId;
   pulsar_reader_configuration_t *cReaderConfig;
+  ReaderListenerCallback *listener;
 };
 
 #endif

package/src/ReaderListener.h

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+
+#ifndef READER_LISTENER_H
+#define READER_LISTENER_H
+
+#include <napi.h>
+#include <pulsar/c/client.h>
+
+struct CReaderWrapper {
+  pulsar_reader_t *cReader;
+  CReaderWrapper();
+  ~CReaderWrapper();
+};
+
+struct ReaderListenerCallback {
+  Napi::ThreadSafeFunction callback;
+
+  // Using reader as void* since the ReaderListenerCallback is shared between Config and Reader.
+  void *reader;
+};
+
+#endif

package/tests/certificate/private-key.client-rsa.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAtKWwgqdnTYrOCv+j1MkTWfSH0wCsHZZca9wAW3qP4uuhlBvn
+b10JcFf5ZjzP9BSXK+tHmI8uoN368vEv6yhURHM4yuXqzCxzuAwkQSo39rzX8PGC
+7qdjCN7LDJ3MnqiBIrUsSaEP1wrNsB1kI+o9ER1e5O/uEPAotP933hHQ0J2hMEek
+HqL7sBlJ98h6NmsicEaUkardk0TOXrlkjC+cMd8ZbGScPqI9M38bmn3OLxFTn1vt
+hpvnXLvCmG4M+6xtYtD+npcVPZw1i1R90fMs7ppZnRbv8Hc/DFdOKVQIgam6CDdn
+NKgW7c7IBMrP0AEm37HTu0LSOjP2OHXlvvlQGQIDAQABAoIBAAaJFAi2C7u3cNrf
+AstY9vVDLoLIvHFZlkBktjKZDYmVIsRb+hSCViwVUrWLL67R6+Iv4eg4DeTOAx00
+8pncXKgZTw2wIb1/QjR/Y/RjlaC8lkdmRWli7udMQCZVsyhuSjW6Pj7vr8YE4woj
+FhNijxEGcf9wWrmMJrzdnTWQiXByo+eTvUQ9BPgPGrRjsMZmTkLyAVJff2DfxO5b
+IWFDYDJcyYAMCIMQu7vys/I50ou6ilb1CO6QM6Z7KpPeOoVFPwtzbh8cf9xM8UNS
+j6J/JmdWhgI34GS3NA68xTQ6PV7zjnhCc+iccm3JKyzGXwaApAZ+Eoce/9j4WKmu
+5B4ziR0CgYEA3l/9OHbl1zmyV+rRxWOIj/i2rTvHzwBnbnPJyuemL5VMFdpGodQ3
+vwHvyQmcECRVRxmXojQ4QuPPHs3qp6wEEFPCWxChLSTxlUc85SOFHWU2O99jV7zI
+7+JOpDK/Mstsx9nHgXduJF+glTFtA3LH8Oqylzu2aFPsprwKuZf94Q8CgYEAz/Zx
+akEG+PEMtP5YS28cX5XfjsIX/V26Fs6/sH16QjUIEddE5T4fCuokxCjSiwUcWhml
+pHEJ5S5xp3VYRfISW3jRW3qstIH1tpZipB6+S0zTuJmLJbA3IiWEg2rtMt7X1uJv
+A/bYOqe0hOPTuXuZdtVZ0nMTKk7GG8O6VkBI7FcCgYEAkDfCmscJgs7JahlBWHmX
+zH9pwem+SPKjIc/4NB6N+dgikx2Pp05hpP/VihUwYIufvs/LNogVYNQrtHepUnrN
+2+TmbHbZgNSv1Ldxt82UfB7y0FutKu6lhmXHyNecho3Fi8sih0V0aiSWmYuHfrAH
+GaiskEZKo1iiZvQXJIx9O2MCgYATBf0r9hTYMtyxtc6H3/sdd01C9thQ8gDy0yjP
+0Tqc0dMSJroDqmIWkoKYew9/bhFA4LW5TCnWkCAPbHmNtG4fdfbYwmkH/hdnA2y0
+jKdlpfp8GXeUFAGHGx17FA3sqFvgKUh0eWEgRHUL7vdQMVFBgJS93o7zQM94fLgP
+6cOB8wKBgFcGV4GjI2Ww9cillaC554MvoSjf8B/+04kXzDOh8iYIIzO9EUil1jjK
+Jvxp4hnLzTKWbux3MEWqurLkYas6GpKBjw+iNOCar6YdqWGVqM3RUx7PTUaZwkKx
+UdP63IfY7iZCIT/QbyHQvIUe2MaiVnH+ulxdkK6Y5e7gxcbckIH4
+-----END RSA PRIVATE KEY-----

package/tests/certificate/public-key.client-rsa.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtKWwgqdnTYrOCv+j1MkT
+WfSH0wCsHZZca9wAW3qP4uuhlBvnb10JcFf5ZjzP9BSXK+tHmI8uoN368vEv6yhU
+RHM4yuXqzCxzuAwkQSo39rzX8PGC7qdjCN7LDJ3MnqiBIrUsSaEP1wrNsB1kI+o9
+ER1e5O/uEPAotP933hHQ0J2hMEekHqL7sBlJ98h6NmsicEaUkardk0TOXrlkjC+c
+Md8ZbGScPqI9M38bmn3OLxFTn1vthpvnXLvCmG4M+6xtYtD+npcVPZw1i1R90fMs
+7ppZnRbv8Hc/DFdOKVQIgam6CDdnNKgW7c7IBMrP0AEm37HTu0LSOjP2OHXlvvlQ
+GQIDAQAB
+-----END PUBLIC KEY-----

package/tests/end_to_end.test.js

@@ -213,6 +213,56 @@ const Pulsar = require('../index.js');
       await client.close();
     });
 
+    test('Produce/Read Listener', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/produce-read-listener';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+      });
+      expect(producer).not.toBeNull();
+
+      let finish;
+      const results = [];
+      const finishPromise = new Promise((resolve) => {
+        finish = resolve;
+      });
+
+      const reader = await client.createReader({
+        topic,
+        startMessageId: Pulsar.MessageId.latest(),
+        listener: (message) => {
+          const data = message.getData().toString();
+          results.push(data);
+          if (results.length === 10) finish();
+        },
+      });
+
+      expect(reader).not.toBeNull();
+
+      const messages = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      await finishPromise;
+      expect(lodash.difference(messages, results)).toEqual([]);
+
+      await producer.close();
+      await reader.close();
+      await client.close();
+    });
+
     test('acknowledgeCumulative', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',
@@ -708,10 +758,94 @@ const Pulsar = require('../index.js');
       }
       expect(lodash.difference(messages, results)).toEqual([]);
       expect(lodash.difference(messageIds, resultIds)).toEqual([]);
+      await producer.close();
+      await consumer.close();
+      await client.close();
+    });
+    test('Basic produce and consume encryption', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
 
+      const topic = 'persistent://public/default/encryption-produce-consume';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+        publicKeyPath: `${__dirname}/certificate/public-key.client-rsa.pem`,
+        encryptionKey: 'encryption-key',
+      });
+
+      const consumer = await client.subscribe({
+        topic,
+        subscription: 'sub1',
+        subscriptionType: 'Shared',
+        ackTimeoutMs: 10000,
+        privateKeyPath: `${__dirname}/certificate/private-key.client-rsa.pem`,
+      });
+
+      const messages = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      const results = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = await consumer.receive();
+        consumer.acknowledge(msg);
+        results.push(msg.getData().toString());
+      }
+      expect(lodash.difference(messages, results)).toEqual([]);
       await producer.close();
       await consumer.close();
       await client.close();
     });
+    test('Produce/Consume/Read/IsConnected', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/produce-consume';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+      });
+      expect(producer).not.toBeNull();
+      expect(producer.isConnected()).toEqual(true);
+
+      const consumer = await client.subscribe({
+        topic,
+        subscription: 'sub1',
+        ackTimeoutMs: 10000,
+      });
+      expect(consumer).not.toBeNull();
+      expect(consumer.isConnected()).toEqual(true);
+
+      const reader = await client.createReader({
+        topic,
+        startMessageId: Pulsar.MessageId.latest(),
+      });
+      expect(reader).not.toBeNull();
+      expect(reader.isConnected()).toEqual(true);
+
+      await producer.close();
+      expect(producer.isConnected()).toEqual(false);
+
+      await consumer.close();
+      expect(consumer.isConnected()).toEqual(false);
+
+      await reader.close();
+      expect(reader.isConnected()).toEqual(false);
+
+      await client.close();
+    });
   });
 })();

package/tstest.ts

@@ -91,6 +91,9 @@ import Pulsar = require('./index');
       key1: 'value1',
       key2: 'value2',
     },
+    publicKeyPath: '/path/to/public.key',
+    encryptionKey: 'encryption-key',
+    cryptoFailureAction: 'FAIL',
   });
 
   const producer2: Pulsar.Producer = await client.createProducer({
@@ -98,6 +101,7 @@ import Pulsar = require('./index');
     messageRoutingMode: 'RoundRobinDistribution',
     hashingScheme: 'BoostHash',
     compressionType: 'LZ4',
+    cryptoFailureAction: 'SEND',
   });
 
   const producer3: Pulsar.Producer = await client.createProducer({
@@ -127,6 +131,8 @@ import Pulsar = require('./index');
       key2: 'value2',
     },
     readCompacted: false,
+    privateKeyPath: '/path/to/private.key',
+    cryptoFailureAction: 'FAIL',
   });
 
   const consumer2: Pulsar.Consumer = await client.subscribe({
@@ -134,6 +140,7 @@ import Pulsar = require('./index');
     subscription: 'my-sub2',
     subscriptionType: 'Shared',
     subscriptionInitialPosition: 'Earliest',
+    cryptoFailureAction: 'DISCARD',
   });
 
   const consumer3: Pulsar.Consumer = await client.subscribe({
@@ -142,6 +149,7 @@ import Pulsar = require('./index');
     subscriptionType: 'KeyShared',
     listener: (message: Pulsar.Message, consumer: Pulsar.Consumer) => {
     },
+    cryptoFailureAction: 'CONSUME',
   });
 
   const consumer4: Pulsar.Consumer = await client.subscribe({
@@ -164,8 +172,16 @@ import Pulsar = require('./index');
     startMessageId: Pulsar.MessageId.earliest(),
   });
 
+  const reader3: Pulsar.Reader = await client.createReader({
+    topic: 'persistent://public/default/my-topic',
+    startMessageId: Pulsar.MessageId.earliest(),
+    listener: (message: Pulsar.Message, reader: Pulsar.Reader) => {
+    },
+  });
+
   const producerName: string = producer1.getProducerName();
   const topicName1: string = producer1.getTopic();
+  const producerIsConnected: boolean = producer1.isConnected();
 
   const messageId1: Pulsar.MessageId = await producer1.send({
     data: Buffer.from('my-message'),
@@ -176,12 +192,14 @@ import Pulsar = require('./index');
     eventTimestamp: Date.now(),
     sequenceId: 10,
     partitionKey: 'key1',
+    orderingKey: 'orderingKey1',
     replicationClusters: [
       'cluster1',
       'cluster2',
     ],
     deliverAfter: 30000,
     deliverAt: Date.now() + 30000,
+    disableReplication: false,
   });
 
   const messageIdString: string = messageId1.toString();
@@ -190,6 +208,7 @@ import Pulsar = require('./index');
 
   const message1: Pulsar.Message = await consumer1.receive();
   const message2: Pulsar.Message = await consumer2.receive(1000);
+  const consumerIsConnected: boolean = consumer1.isConnected();
 
   consumer1.negativeAcknowledge(message1);
   consumer1.negativeAcknowledgeId(messageId1);
@@ -210,6 +229,7 @@ import Pulsar = require('./index');
   const message3: Pulsar.Message = await reader1.readNext();
   const message4: Pulsar.Message = await reader2.readNext(1000);
   const hasNext: boolean = reader1.hasNext();
+  const readerIsConnected: boolean = reader1.isConnected();
 
   await producer1.flush();
   await producer1.close();
@@ -222,6 +242,7 @@ import Pulsar = require('./index');
   await consumer4.close();
   await reader1.close();
   await reader2.close();
+  await reader3.close();
   await client.close();
 })();