@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0066-plugins.cpp

@@ -0,0 +1,129 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <iostream>
+#include <cstring>
+#include <cstdlib>
+#include "testcpp.h"
+
+#ifdef _WIN32
+#include <direct.h>
+#endif
+
+
+extern "C" {
+#include "interceptor_test/interceptor_test.h"
+
+struct ictest ictest;
+};
+
+
+/**
+ * Verify plugin.library.paths and interceptors
+ * using interceptor_test/...
+ *
+ */
+
+
+static void do_test_plugin() {
+  std::string errstr;
+  std::string topic           = Test::mk_topic_name("0066_plugins", 1);
+  static const char *config[] = {
+      "session.timeout.ms",
+      "6000", /* Before plugin */
+      "plugin.library.paths",
+      "interceptor_test/interceptor_test",
+      "socket.timeout.ms",
+      "12", /* After plugin */
+      "interceptor_test.config1",
+      "one",
+      "interceptor_test.config2",
+      "two",
+      "topic.metadata.refresh.interval.ms",
+      "1234",
+      NULL,
+  };
+
+  char cwd[512], *pcwd;
+#ifdef _WIN32
+  pcwd = _getcwd(cwd, sizeof(cwd) - 1);
+#else
+  pcwd = getcwd(cwd, sizeof(cwd) - 1);
+#endif
+  if (pcwd)
+    Test::Say(tostr() << "running test from cwd " << cwd << "\n");
+
+  /* Interceptor back-channel config */
+  ictest_init(&ictest);
+  ictest_cnt_init(&ictest.conf_init, 1, 1000);
+  ictest_cnt_init(&ictest.on_new, 1, 1);
+
+  /* Config for intercepted client */
+  RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
+
+  for (int i = 0; config[i]; i += 2) {
+    Test::Say(tostr() << "set(" << config[i] << ", " << config[i + 1] << ")\n");
+    if (conf->set(config[i], config[i + 1], errstr))
+      Test::Fail(tostr() << "set(" << config[i] << ") failed: " << errstr);
+  }
+
+  /* Create producer */
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create producer: " + errstr);
+
+  if (ictest.on_new.cnt < ictest.on_new.min ||
+      ictest.on_new.cnt > ictest.on_new.max)
+    Test::Fail(tostr() << "on_new.cnt " << ictest.on_new.cnt
+                       << " not within range " << ictest.on_new.min << ".."
+                       << ictest.on_new.max);
+
+  /* Verification */
+  if (!ictest.config1 || strcmp(ictest.config1, "one"))
+    Test::Fail(tostr() << "config1 was " << ictest.config1);
+  if (!ictest.config2 || strcmp(ictest.config2, "two"))
+    Test::Fail(tostr() << "config2 was " << ictest.config2);
+  if (!ictest.session_timeout_ms || strcmp(ictest.session_timeout_ms, "6000"))
+    Test::Fail(tostr() << "session.timeout.ms was "
+                       << ictest.session_timeout_ms);
+  if (!ictest.socket_timeout_ms || strcmp(ictest.socket_timeout_ms, "12"))
+    Test::Fail(tostr() << "socket.timeout.ms was " << ictest.socket_timeout_ms);
+
+  delete conf;
+
+  delete p;
+
+  ictest_free(&ictest);
+}
+
+extern "C" {
+int main_0066_plugins(int argc, char **argv) {
+  do_test_plugin();
+  return 0;
+}
+}

package/deps/librdkafka/tests/0067-empty_topic.cpp

@@ -0,0 +1,151 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <iostream>
+#include "testcpp.h"
+
+
+
+/**
+ * Issue #1306
+ *
+ * Consume from an empty topic using Consumer and KafkaConsumer.
+ */
+
+
+static void do_test_empty_topic_consumer() {
+  std::string errstr;
+  std::string topic       = Test::mk_topic_name("0067_empty_topic", 1);
+  const int32_t partition = 0;
+
+  RdKafka::Conf *conf;
+
+  Test::conf_init(&conf, NULL, 0);
+
+  Test::conf_set(conf, "enable.partition.eof", "true");
+  Test::conf_set(conf, "allow.auto.create.topics", "true");
+
+  /* Create simple consumer */
+  RdKafka::Consumer *consumer = RdKafka::Consumer::create(conf, errstr);
+  if (!consumer)
+    Test::Fail("Failed to create Consumer: " + errstr);
+
+  RdKafka::Topic *rkt = RdKafka::Topic::create(consumer, topic, NULL, errstr);
+  if (!rkt)
+    Test::Fail("Simple Topic failed: " + errstr);
+
+
+  /* Create the topic through a metadata request. */
+  Test::Say("Creating empty topic " + topic + "\n");
+  RdKafka::Metadata *md;
+  RdKafka::ErrorCode err =
+      consumer->metadata(false, rkt, &md, tmout_multip(10 * 1000));
+  if (err)
+    Test::Fail("Failed to create topic " + topic + ": " +
+               RdKafka::err2str(err));
+  delete md;
+
+  /* Await propagation to the whole cluster */
+  test_wait_topic_exists(consumer->c_ptr(), topic.c_str(), 1 * 1000);
+
+  /* Start consumer */
+  err = consumer->start(rkt, partition, RdKafka::Topic::OFFSET_BEGINNING);
+  if (err)
+    Test::Fail("Consume start() failed: " + RdKafka::err2str(err));
+
+  /* Consume using legacy consumer, should give an EOF and nothing else. */
+  Test::Say("Simple Consumer: consuming\n");
+  RdKafka::Message *msg =
+      consumer->consume(rkt, partition, tmout_multip(10 * 1000));
+  if (msg->err() != RdKafka::ERR__PARTITION_EOF)
+    Test::Fail("Simple consume() expected EOF, got " +
+               RdKafka::err2str(msg->err()));
+  delete msg;
+
+  /* Nothing else should come now, just a consume() timeout */
+  msg = consumer->consume(rkt, partition, 1 * 1000);
+  if (msg->err() != RdKafka::ERR__TIMED_OUT)
+    Test::Fail("Simple consume() expected timeout, got " +
+               RdKafka::err2str(msg->err()));
+  delete msg;
+
+  consumer->stop(rkt, partition);
+
+  delete rkt;
+  delete consumer;
+
+
+  /*
+   * Now do the same thing using the high-level KafkaConsumer.
+   */
+
+  Test::conf_set(conf, "group.id", topic);
+
+  Test::conf_set(conf, "enable.partition.eof", "true");
+  Test::conf_set(conf, "allow.auto.create.topics", "true");
+
+  RdKafka::KafkaConsumer *kconsumer =
+      RdKafka::KafkaConsumer::create(conf, errstr);
+  if (!kconsumer)
+    Test::Fail("Failed to create KafkaConsumer: " + errstr);
+
+  std::vector<RdKafka::TopicPartition *> part;
+  part.push_back(RdKafka::TopicPartition::create(topic, partition));
+
+  err = kconsumer->assign(part);
+  if (err)
+    Test::Fail("assign() failed: " + RdKafka::err2str(err));
+
+  RdKafka::TopicPartition::destroy(part);
+
+  Test::Say("KafkaConsumer: consuming\n");
+  msg = kconsumer->consume(tmout_multip(5 * 1000));
+  if (msg->err() != RdKafka::ERR__PARTITION_EOF)
+    Test::Fail("KafkaConsumer consume() expected EOF, got " +
+               RdKafka::err2str(msg->err()));
+  delete msg;
+
+  /* Nothing else should come now, just a consume() timeout */
+  msg = kconsumer->consume(1 * 1000);
+  if (msg->err() != RdKafka::ERR__TIMED_OUT)
+    Test::Fail("KafkaConsumer consume() expected timeout, got " +
+               RdKafka::err2str(msg->err()));
+  delete msg;
+
+  kconsumer->close();
+
+  delete kconsumer;
+  delete conf;
+}
+
+extern "C" {
+int main_0067_empty_topic(int argc, char **argv) {
+  do_test_empty_topic_consumer();
+  return 0;
+}
+}

package/deps/librdkafka/tests/0068-produce_timeout.c

@@ -0,0 +1,136 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+#include "rdkafka.h"
+#include "../src/rdkafka_protocol.h"
+
+#include <stdarg.h>
+
+static int
+is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
+        /* Ignore connectivity errors since we'll be bringing down
+         * .. connectivity.
+         * SASL auther will think a connection-down even in the auth
+         * state means the broker doesn't support SASL PLAIN. */
+        TEST_SAY("is_fatal?: %s: %s\n", rd_kafka_err2str(err), reason);
+        if (err == RD_KAFKA_RESP_ERR__TRANSPORT ||
+            err == RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN ||
+            err == RD_KAFKA_RESP_ERR__AUTHENTICATION ||
+            err == RD_KAFKA_RESP_ERR__TIMED_OUT)
+                return 0;
+        return 1;
+}
+
+static int msg_dr_cnt      = 0;
+static int msg_dr_fail_cnt = 0;
+
+static void
+dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *rkmessage, void *opaque) {
+        msg_dr_cnt++;
+        if (rkmessage->err != RD_KAFKA_RESP_ERR__MSG_TIMED_OUT)
+                TEST_FAIL_LATER(
+                    "Expected message to fail with MSG_TIMED_OUT, "
+                    "got: %s",
+                    rd_kafka_err2str(rkmessage->err));
+        else {
+                TEST_ASSERT_LATER(rd_kafka_message_status(rkmessage) ==
+                                      RD_KAFKA_MSG_STATUS_POSSIBLY_PERSISTED,
+                                  "Message should have status "
+                                  "PossiblyPersisted (%d), not %d",
+                                  RD_KAFKA_MSG_STATUS_POSSIBLY_PERSISTED,
+                                  rd_kafka_message_status(rkmessage));
+                msg_dr_fail_cnt++;
+        }
+}
+
+
+
+int main_0068_produce_timeout(int argc, char **argv) {
+        rd_kafka_t *rk;
+        const char *topic = test_mk_topic_name("0068_produce_timeout", 1);
+        uint64_t testid;
+        const int msgcnt = 10;
+        rd_kafka_conf_t *conf;
+        rd_kafka_topic_t *rkt;
+        int msgcounter = 0;
+        const char *bootstraps;
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        rd_kafka_mock_cluster_t *mcluster =
+            test_mock_cluster_new(3, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 1, 3);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+
+        testid = test_id_generate();
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb);
+
+        test_curr->is_fatal_cb = is_fatal_cb;
+
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+        /* message timeout should be less that rtt */
+        rkt = test_create_producer_topic(rk, topic, "message.timeout.ms",
+                                         "2000", NULL);
+
+        TEST_SAY("Auto-creating topic %s\n", topic);
+        test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
+
+        TEST_SAY("Producing %d messages that should timeout\n", msgcnt);
+        rd_kafka_mock_broker_push_request_error_rtts(
+            mcluster, 1, RD_KAFKAP_Produce, 1, RD_KAFKA_RESP_ERR_NO_ERROR,
+            6000);
+
+        test_produce_msgs_nowait(rk, rkt, testid, 0, 0, msgcnt, NULL, 0, 0,
+                                 &msgcounter);
+
+        TEST_SAY("Flushing..\n");
+        rd_kafka_flush(rk, 10000);
+
+        TEST_SAY("%d/%d delivery reports, where of %d with proper error\n",
+                 msg_dr_cnt, msgcnt, msg_dr_fail_cnt);
+
+        TEST_ASSERT(msg_dr_cnt == msgcnt, "expected %d, got %d", msgcnt,
+                    msg_dr_cnt);
+        TEST_ASSERT(msg_dr_fail_cnt == msgcnt, "expected %d, got %d", msgcnt,
+                    msg_dr_fail_cnt);
+
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+
+        test_mock_cluster_destroy(mcluster);
+
+        TEST_LATER_CHECK();
+
+        return 0;
+}

package/deps/librdkafka/tests/0069-consumer_add_parts.c

@@ -0,0 +1,119 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+/**
+ * Issue #1371:
+ * Run two consumers in the same group for a 2-partition topic,
+ * alter the topic to have 4 partitions, kill off the first consumer,
+ * the second consumer will segfault.
+ */
+
+#include "rdkafka.h"
+
+
+static rd_kafka_t *c1, *c2;
+static rd_kafka_resp_err_t state1, state2;
+
+static void rebalance_cb(rd_kafka_t *rk,
+                         rd_kafka_resp_err_t err,
+                         rd_kafka_topic_partition_list_t *parts,
+                         void *opaque) {
+        rd_kafka_resp_err_t *statep = NULL;
+
+        if (rk == c1)
+                statep = &state1;
+        else if (rk == c2)
+                statep = &state2;
+        else
+                TEST_FAIL("Invalid rk %p", rk);
+
+        TEST_SAY("Rebalance for %s: %s:\n", rd_kafka_name(rk),
+                 rd_kafka_err2str(err));
+        test_print_partition_list(parts);
+
+        test_rebalance_cb(rk, err, parts, opaque);
+
+        *statep = err;
+}
+
+
+int main_0069_consumer_add_parts(int argc, char **argv) {
+        const char *topic = test_mk_topic_name(__FUNCTION__ + 5, 1);
+        int64_t ts_start;
+        int wait_sec;
+
+        test_conf_init(NULL, NULL, 60);
+
+        TEST_SAY("Creating 2 consumers\n");
+        c1 = test_create_consumer(topic, rebalance_cb, NULL, NULL);
+        c2 = test_create_consumer(topic, rebalance_cb, NULL, NULL);
+
+        TEST_SAY("Creating topic %s with 2 partitions\n", topic);
+        test_create_topic_wait_exists(c1, topic, 2, 1, 10 * 5000);
+
+        TEST_SAY("Subscribing\n");
+        test_consumer_subscribe(c1, topic);
+        test_consumer_subscribe(c2, topic);
+
+
+        TEST_SAY("Waiting for initial assignment for both consumers\n");
+        while (state1 != RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS ||
+               state2 != RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS) {
+                test_consumer_poll_no_msgs("wait-rebalance", c1, 0, 1000);
+                test_consumer_poll_no_msgs("wait-rebalance", c2, 0, 1000);
+        }
+
+
+        TEST_SAY("Changing partition count for topic %s\n", topic);
+        test_create_partitions(NULL, topic, 4);
+
+        TEST_SAY(
+            "Closing consumer 1 (to quickly trigger rebalance with new "
+            "partitions)\n");
+        test_consumer_close(c1);
+        rd_kafka_destroy(c1);
+
+        TEST_SAY("Wait 10 seconds for consumer 2 not to crash\n");
+        wait_sec = test_quick ? 5 : 10;
+        ts_start = test_clock();
+        do {
+                test_consumer_poll_no_msgs("wait-stable", c2, 0, 1000);
+        } while (test_clock() < ts_start + (wait_sec * 1000000));
+
+        TEST_ASSERT(state2 == RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS,
+                    "Expected consumer 2 to have assignment, not in state %s",
+                    rd_kafka_err2str(state2));
+
+        test_consumer_close(c2);
+        rd_kafka_destroy(c2);
+
+        return 0;
+}