@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/src/common.h

@@ -0,0 +1,192 @@
+/*
+ * confluent-kafka-javascript - Node.js wrapper  for RdKafka C/C++ library
+ *
+ * Copyright (c) 2016-2023 Blizzard Entertainment
+ *           (c) 2024 Confluent, Inc.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE.txt file for details.
+ */
+
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+#include <nan.h>
+
+#include <list>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "rdkafkacpp.h" // NOLINT
+#include "rdkafka.h"  // NOLINT
+
+#include "src/errors.h"
+
+typedef std::vector<const RdKafka::BrokerMetadata*> BrokerMetadataList;
+typedef std::vector<const RdKafka::PartitionMetadata*> PartitionMetadataList;
+typedef std::vector<const RdKafka::TopicMetadata *> TopicMetadataList;
+
+namespace NodeKafka {
+
+void Log(std::string);
+
+template<typename T> T GetParameter(v8::Local<v8::Object>, std::string, T);
+template<> std::string GetParameter<std::string>(
+  v8::Local<v8::Object>, std::string, std::string);
+template<> std::vector<std::string> GetParameter<std::vector<std::string> >(
+  v8::Local<v8::Object>, std::string, std::vector<std::string>);
+template<> v8::Local<v8::Array> GetParameter<v8::Local<v8::Array> >(
+  v8::Local<v8::Object>, std::string, v8::Local<v8::Array>);
+// template int GetParameter<int>(v8::Local<v8::Object, std::string, int);
+std::vector<std::string> v8ArrayToStringVector(v8::Local<v8::Array>);
+std::list<std::string> v8ArrayToStringList(v8::Local<v8::Array>);
+
+class scoped_mutex_lock {
+ public:
+  explicit scoped_mutex_lock(uv_mutex_t& lock_) :  // NOLINT
+    async_lock(lock_) {
+      uv_mutex_lock(&async_lock);
+  }
+
+  ~scoped_mutex_lock() {
+    uv_mutex_unlock(&async_lock);
+  }
+
+ private:
+  uv_mutex_t &async_lock;
+};
+
+/*
+int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock)
+
+int uv_rwlock_trywrlock(uv_rwlock_t* rwlock)
+ */
+
+class scoped_shared_write_lock {
+ public:
+  explicit scoped_shared_write_lock(uv_rwlock_t& lock_) :  // NOLINT
+    async_lock(lock_) {
+      uv_rwlock_wrlock(&async_lock);
+    }
+
+  ~scoped_shared_write_lock() {
+    uv_rwlock_wrunlock(&async_lock);
+  }
+
+ private:
+  uv_rwlock_t &async_lock;
+};
+
+class scoped_shared_read_lock {
+ public:
+  explicit scoped_shared_read_lock(uv_rwlock_t& lock_) :  // NOLINT
+    async_lock(lock_) {
+      uv_rwlock_rdlock(&async_lock);
+    }
+
+  ~scoped_shared_read_lock() {
+    uv_rwlock_rdunlock(&async_lock);
+  }
+
+ private:
+  uv_rwlock_t &async_lock;
+};
+
+namespace Conversion {
+
+namespace Util {
+std::vector<std::string> ToStringVector(v8::Local<v8::Array>);
+v8::Local<v8::Array> ToV8Array(std::vector<std::string>);
+v8::Local<v8::Array> ToV8Array(const rd_kafka_error_t **error_list,
+                               size_t error_cnt);
+v8::Local<v8::Object> UuidToV8Object(const rd_kafka_Uuid_t* uuid);
+v8::Local<v8::Array> ToV8Array(const rd_kafka_AclOperation_t *, size_t);
+
+v8::Local<v8::Object> ToV8Object(const rd_kafka_Node_t *);
+}  // namespace Util
+
+namespace Admin {
+// Topics from topic object, or topic object array
+rd_kafka_NewTopic_t *FromV8TopicObject(v8::Local<v8::Object>,
+                                       std::string &errstr);
+rd_kafka_NewTopic_t **FromV8TopicObjectArray(v8::Local<v8::Array>);
+
+// ListGroups: request
+std::vector<rd_kafka_consumer_group_state_t> FromV8GroupStateArray(
+    v8::Local<v8::Array>);
+
+// ListGroups: request
+std::vector<rd_kafka_consumer_group_type_t> FromV8GroupTypeArray(
+    v8::Local<v8::Array> array);
+
+// ListGroups: response
+v8::Local<v8::Object> FromListConsumerGroupsResult(
+    const rd_kafka_ListConsumerGroups_result_t *);
+
+// DescribeGroups: response
+v8::Local<v8::Object> FromMemberDescription(
+    const rd_kafka_MemberDescription_t *member);
+v8::Local<v8::Object> FromConsumerGroupDescription(
+    const rd_kafka_ConsumerGroupDescription_t *desc);
+v8::Local<v8::Object> FromDescribeConsumerGroupsResult(
+    const rd_kafka_DescribeConsumerGroups_result_t *);
+
+// DeleteGroups: Response
+v8::Local<v8::Array> FromDeleteGroupsResult(
+    const rd_kafka_DeleteGroups_result_t *);
+
+// ListConsumerGroupOffsets: Response
+v8::Local<v8::Array> FromListConsumerGroupOffsetsResult(
+    const rd_kafka_ListConsumerGroupOffsets_result_t *result);
+
+// DeleteRecords: Response
+v8::Local<v8::Array> FromDeleteRecordsResult(
+    const rd_kafka_DeleteRecords_result_t* result);
+
+// DescribeTopics: Response
+v8::Local<v8::Array> FromDescribeTopicsResult(
+    const rd_kafka_DescribeTopics_result_t* result);
+
+// ListOffsets: Response
+v8::Local<v8::Array> FromListOffsetsResult(
+    const rd_kafka_ListOffsets_result_t* result);
+}  // namespace Admin
+
+namespace TopicPartition {
+
+v8::Local<v8::Array> ToV8Array(std::vector<RdKafka::TopicPartition *> &);
+v8::Local<v8::Array> ToTopicPartitionV8Array(
+    const rd_kafka_topic_partition_list_t *, bool include_offset);
+RdKafka::TopicPartition *FromV8Object(v8::Local<v8::Object>);
+std::vector<RdKafka::TopicPartition *> FromV8Array(const v8::Local<v8::Array> &);  // NOLINT
+rd_kafka_topic_partition_list_t *TopicPartitionv8ArrayToTopicPartitionList(
+    v8::Local<v8::Array> parameter, bool include_offset);
+rd_kafka_topic_partition_list_t *
+TopicPartitionOffsetSpecv8ArrayToTopicPartitionList(
+    v8::Local<v8::Array> parameter);
+
+}  // namespace TopicPartition
+
+namespace Metadata {
+
+v8::Local<v8::Object> ToV8Object(RdKafka::Metadata*);
+
+}  // namespace Metadata
+
+namespace Message {
+
+v8::Local<v8::Object> ToV8Object(RdKafka::Message*);
+v8::Local<v8::Object> ToV8Object(RdKafka::Message*, bool, bool);
+
+}
+
+}  // namespace Conversion
+
+namespace Util {
+  std::string FromV8String(v8::Local<v8::String>);
+}
+
+}  // namespace NodeKafka
+
+#endif  // SRC_COMMON_H_

package/src/config.cc

@@ -0,0 +1,219 @@
+/*
+ * confluent-kafka-javascript - Node.js wrapper  for RdKafka C/C++ library
+ *
+ * Copyright (c) 2016-2023 Blizzard Entertainment
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE.txt file for details.
+ */
+#include "src/config.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+
+using Nan::MaybeLocal;
+using Nan::Maybe;
+using v8::Local;
+using v8::String;
+using v8::Object;
+using std::cout;
+using std::endl;
+
+namespace NodeKafka {
+
+void Conf::DumpConfig(std::list<std::string> *dump) {
+  for (std::list<std::string>::iterator it = dump->begin();
+         it != dump->end(); ) {
+    std::cout << *it << " = ";
+    it++;
+    std::cout << *it << std::endl;
+    it++;
+  }
+  std::cout << std::endl;
+}
+
+Conf * Conf::create(RdKafka::Conf::ConfType type, v8::Local<v8::Object> object, std::string &errstr) {  // NOLINT
+  v8::Local<v8::Context> context = Nan::GetCurrentContext();
+  Conf* rdconf = static_cast<Conf*>(RdKafka::Conf::create(type));
+
+  v8::MaybeLocal<v8::Array> _property_names = object->GetOwnPropertyNames(
+    Nan::GetCurrentContext());
+  v8::Local<v8::Array> property_names = _property_names.ToLocalChecked();
+
+  for (unsigned int i = 0; i < property_names->Length(); ++i) {
+    std::string string_value;
+    std::string string_key;
+
+    v8::Local<v8::Value> key = Nan::Get(property_names, i).ToLocalChecked();
+    v8::Local<v8::Value> value = Nan::Get(object, key).ToLocalChecked();
+
+    if (key->IsString()) {
+      Nan::Utf8String utf8_key(key);
+      string_key = std::string(*utf8_key);
+    } else {
+      continue;
+    }
+
+    if (!value->IsFunction()) {
+#if NODE_MAJOR_VERSION > 6
+      if (value->IsInt32()) {
+        string_value = std::to_string(
+          value->Int32Value(context).ToChecked());
+      } else if (value->IsUint32()) {
+        string_value = std::to_string(
+          value->Uint32Value(context).ToChecked());
+      } else if (value->IsBoolean()) {
+        const bool v = Nan::To<bool>(value).ToChecked();
+        string_value = v ? "true" : "false";
+      } else {
+        Nan::Utf8String utf8_value(value.As<v8::String>());
+        string_value = std::string(*utf8_value);
+      }
+#else
+      Nan::Utf8String utf8_value(value.As<v8::String>());
+      string_value = std::string(*utf8_value);
+#endif
+      if (rdconf->set(string_key, string_value, errstr)
+        != Conf::CONF_OK) {
+          delete rdconf;
+          return NULL;
+      }
+    } else {
+     // Do nothing - NodeConfigureCallbacks will handle this for each
+     // of the three client types, called from within JavaScript.
+    }
+  }
+
+  return rdconf;
+}
+
+void Conf::ConfigureCallback(
+  const std::string &string_key,
+  const v8::Local<v8::Function> &cb,
+  bool add, std::string &errstr) {
+  if (string_key.compare("rebalance_cb") == 0) {
+    NodeKafka::Callbacks::Rebalance *rebalance = rebalance_cb();
+    if (add) {
+      if (rebalance == NULL) {
+        rebalance = new NodeKafka::Callbacks::Rebalance();
+        this->set(string_key, rebalance, errstr);
+      }
+      rebalance->dispatcher.AddCallback(cb);
+      this->set(string_key, rebalance, errstr);
+    } else {
+      if (rebalance == NULL) {
+        rebalance->dispatcher.RemoveCallback(cb);
+        this->set(string_key, rebalance, errstr);
+      }
+    }
+  } else if (string_key.compare("offset_commit_cb") == 0) {
+    NodeKafka::Callbacks::OffsetCommit *offset_commit = offset_commit_cb();
+    if (add) {
+      if (offset_commit == NULL) {
+        offset_commit = new NodeKafka::Callbacks::OffsetCommit();
+        this->set(string_key, offset_commit, errstr);
+      }
+      offset_commit->dispatcher.AddCallback(cb);
+    } else {
+      if (offset_commit != NULL) {
+        offset_commit->dispatcher.RemoveCallback(cb);
+      }
+    }
+  } else if (string_key.compare("oauthbearer_token_refresh_cb") == 0) {
+    NodeKafka::Callbacks::OAuthBearerTokenRefresh *oauthbearer_token_refresh =
+        oauthbearer_token_refresh_cb();
+    if (add) {
+      if (oauthbearer_token_refresh == NULL) {
+        oauthbearer_token_refresh =
+            new NodeKafka::Callbacks::OAuthBearerTokenRefresh();
+        this->set(string_key, oauthbearer_token_refresh, errstr);
+      }
+      oauthbearer_token_refresh->dispatcher.AddCallback(cb);
+    } else {
+      if (oauthbearer_token_refresh != NULL) {
+        oauthbearer_token_refresh->dispatcher.RemoveCallback(cb);
+      }
+    }
+  } else {
+    errstr = "Invalid callback type";
+  }
+}
+
+void Conf::listen() {
+  NodeKafka::Callbacks::Rebalance *rebalance = rebalance_cb();
+  if (rebalance) {
+    rebalance->dispatcher.Activate();
+  }
+
+  NodeKafka::Callbacks::OffsetCommit *offset_commit = offset_commit_cb();
+  if (offset_commit) {
+    offset_commit->dispatcher.Activate();
+  }
+
+  NodeKafka::Callbacks::OAuthBearerTokenRefresh *oauthbearer_token_refresh =
+      oauthbearer_token_refresh_cb();
+  if (oauthbearer_token_refresh) {
+    oauthbearer_token_refresh->dispatcher.Activate();
+  }
+}
+
+void Conf::stop() {
+  NodeKafka::Callbacks::Rebalance *rebalance = rebalance_cb();
+  if (rebalance) {
+    rebalance->dispatcher.Deactivate();
+  }
+
+  NodeKafka::Callbacks::OffsetCommit *offset_commit = offset_commit_cb();
+  if (offset_commit) {
+    offset_commit->dispatcher.Deactivate();
+  }
+
+  NodeKafka::Callbacks::OAuthBearerTokenRefresh *oauthbearer_token_refresh =
+      oauthbearer_token_refresh_cb();
+  if (oauthbearer_token_refresh) {
+    oauthbearer_token_refresh->dispatcher.Deactivate();
+  }
+}
+
+Conf::~Conf() {
+  // Delete the rdconf object, since that's what we are internally.
+  RdKafka::Conf *rdconf = static_cast<RdKafka::Conf*>(this);
+  delete rdconf;
+}
+
+NodeKafka::Callbacks::Rebalance* Conf::rebalance_cb() const {
+  RdKafka::RebalanceCb *cb = NULL;
+  if (this->get(cb) != RdKafka::Conf::CONF_OK) {
+    return NULL;
+  }
+  return static_cast<NodeKafka::Callbacks::Rebalance*>(cb);
+}
+
+NodeKafka::Callbacks::OffsetCommit* Conf::offset_commit_cb() const {
+  RdKafka::OffsetCommitCb *cb = NULL;
+  if (this->get(cb) != RdKafka::Conf::CONF_OK) {
+    return NULL;
+  }
+  return static_cast<NodeKafka::Callbacks::OffsetCommit*>(cb);
+}
+
+NodeKafka::Callbacks::OAuthBearerTokenRefresh *
+Conf::oauthbearer_token_refresh_cb() const {
+  RdKafka::OAuthBearerTokenRefreshCb *cb = NULL;
+  if (this->get(cb) != RdKafka::Conf::CONF_OK) {
+    return NULL;
+  }
+  return static_cast<NodeKafka::Callbacks::OAuthBearerTokenRefresh *>(cb);
+}
+
+bool Conf::is_sasl_oauthbearer() const {
+  std::string sasl_mechanism;
+  if (this->get("sasl.mechanisms", sasl_mechanism) != RdKafka::Conf::CONF_OK) {
+    return false;
+  }
+  return sasl_mechanism.compare("OAUTHBEARER") == 0;
+}
+
+}  // namespace NodeKafka

package/src/config.h

@@ -0,0 +1,61 @@
+/*
+ * confluent-kafka-javascript - Node.js wrapper  for RdKafka C/C++ library
+ *
+ * Copyright (c) 2016-2023 Blizzard Entertainment
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE.txt file for details.
+ */
+
+#ifndef SRC_CONFIG_H_
+#define SRC_CONFIG_H_
+
+#include <nan.h>
+#include <iostream>
+#include <vector>
+#include <list>
+#include <string>
+
+#include "rdkafkacpp.h" // NOLINT
+#include "src/common.h"
+#include "src/callbacks.h"
+
+namespace NodeKafka {
+
+class Conf : public RdKafka::Conf {
+ public:
+  ~Conf();
+
+  static Conf* create(RdKafka::Conf::ConfType, v8::Local<v8::Object>, std::string &);  // NOLINT
+  static void DumpConfig(std::list<std::string> *);
+
+  void listen();
+  void stop();
+
+  void ConfigureCallback(
+    const std::string &string_key,
+    const v8::Local<v8::Function> &cb,
+    bool add, std::string &errstr);
+
+  bool is_sasl_oauthbearer() const;
+
+ private:
+  NodeKafka::Callbacks::Rebalance *rebalance_cb() const;
+  NodeKafka::Callbacks::OffsetCommit *offset_commit_cb() const;
+  NodeKafka::Callbacks::OAuthBearerTokenRefresh *oauthbearer_token_refresh_cb()
+      const;
+
+  // NOTE: Do NOT add any members to this class.
+  // Internally, to get an instance of this class, we just cast RdKafka::Conf*
+  // that we obtain from RdKafka::Conf::create(). However, that's internally an
+  // instance of a sub-class, ConfImpl. This means that any members here are
+  // aliased to that with the wrong name (for example, the first member of this
+  // class, if it's a pointer, will be aliased to consume_cb_ in the ConfImpl,
+  // and and changing one will change the other!)
+  // TODO: Just don't inherit from RdKafka::Conf, and instead have a member of
+  // type RdKafka::Conf*.
+};
+
+}  // namespace NodeKafka
+
+#endif  // SRC_CONFIG_H_