@platformatic/rdkafka 4.0.1 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0075-retry.c

@@ -2,6 +2,7 @@
  * 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
@@ -57,6 +58,10 @@ static struct {
 
         } next;
         int term;
+        /* Number of created sockets */
+        int num_sockets;
+        /* Current test, available to all threads as it's not TLS */
+        struct test *test_curr;
 } ctrl;
 
 static int ctrl_thrd_main(void *arg) {
@@ -67,6 +72,10 @@ static int ctrl_thrd_main(void *arg) {
                 int64_t now;
 
                 cnd_timedwait_ms(&ctrl.cnd, &ctrl.lock, 10);
+                if (!test_socket_find(ctrl.test_curr, ctrl.skm))
+                        /* Socket was closed and destroyed when
+                         * releasing the lock. */
+                        break;
 
                 if (ctrl.cmd.ts_at) {
                         ctrl.next.ts_at = ctrl.cmd.ts_at;
@@ -106,8 +115,16 @@ static int ctrl_thrd_main(void *arg) {
 static int connect_cb(struct test *test, sockem_t *skm, const char *id) {
 
         mtx_lock(&ctrl.lock);
+        if (ctrl.num_sockets < 1) {
+                /* Since librdkafka is decommissioning brokers,
+                 * first connection is with a bootstrap broker,
+                 * next one is with a learned one. */
+                ctrl.num_sockets++;
+                mtx_unlock(&ctrl.lock);
+                return 0;
+        }
         if (ctrl.skm) {
-                /* Reject all but the first connect */
+                /* Reject all but the first two connects */
                 mtx_unlock(&ctrl.lock);
                 return ECONNREFUSED;
         }
@@ -170,14 +187,26 @@ static void do_test_low_socket_timeout(const char *topic) {
 
         mtx_init(&ctrl.lock, mtx_plain);
         cnd_init(&ctrl.cnd);
+        ctrl.test_curr = test_curr;
 
         TEST_SAY("Test Metadata request retries on timeout\n");
 
+        test_create_topic_wait_exists(NULL, topic, 1, -1, 5000);
+
         test_conf_init(&conf, NULL, 60);
         test_conf_set(conf, "socket.timeout.ms", "1000");
         test_conf_set(conf, "socket.max.fails", "12345");
         test_conf_set(conf, "retry.backoff.ms", "5000");
         test_conf_set(conf, "retry.backoff.max.ms", "5000");
+        /* Sparse re-connect interval depends on `reconnect.backoff.ms` / 2
+         * increasing it allows to saturate the sparse re-connect interval
+         * and avoid to concurrent connects: the first for setting the bootstrap
+         * brokers and the second for adding a new topic to get metadata for.
+         * This way the test is more reliable especially when using valgrind
+         * as it needs to keep the last connection only,
+         * to add a delay later. */
+        test_conf_set(conf, "reconnect.backoff.ms", "2000");
+
         /* Avoid api version requests (with their own timeout) to get in
          * the way of our test */
         test_conf_set(conf, "api.version.request", "false");
@@ -244,6 +273,14 @@ static void do_test_low_socket_timeout(const char *topic) {
 int main_0075_retry(int argc, char **argv) {
         const char *topic = test_mk_topic_name("0075_retry", 1);
 
+        if (test_needs_auth()) {
+                /* When authentication is involved there's the need
+                 * for additional SASL calls. These are delayed too and
+                 * it changes test timing. */
+                TEST_SKIP("Cannot run this test with SSL/SASL\n");
+                return 0;
+        }
+
         do_test_low_socket_timeout(topic);
 
         return 0;

package/deps/librdkafka/tests/0076-produce_retry.c

@@ -128,6 +128,7 @@ static void do_test_produce_retries(const char *topic,
 
         rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         /* Create the topic to make sure connections are up and ready. */
         err = test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
@@ -277,6 +278,7 @@ static void do_test_produce_retries_disconnect(const char *topic,
 
         rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         err = test_produce_sync(rk, rkt, testid, 0);
 

package/deps/librdkafka/tests/0077-compaction.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2023, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -193,6 +194,7 @@ static void do_test_compaction(int msgs_per_key, const char *compression) {
             "--config file.delete.delay.ms=10000 "
             "--config max.compaction.lag.ms=100",
             topic, partition + 1);
+        test_wait_topic_exists(NULL, topic, 5000);
 
         test_conf_init(&conf, NULL, 120);
         rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
@@ -300,8 +302,12 @@ static void do_test_compaction(int msgs_per_key, const char *compression) {
          * this doesn't really work because the low watermark offset
          * is not updated on compaction if the first segment is not deleted.
          * But it serves as a pause to let compaction kick in
-         * which is triggered by the dummy produce above. */
-        wait_compaction(rk, topic, partition, 0, 20 * 1000);
+         * which is triggered by the dummy produce above.
+         * Compaction timer is every 15 seconds and
+         * with a large number of segments it can
+         * take the same time. */
+        wait_compaction(rk, topic, partition, 0,
+                        msgcnt > 50 ? 30 * 1000 : 20 * 1000);
 
         TEST_SAY(_C_YEL "Verify messages after compaction\n");
         /* After compaction we expect the following messages:

package/deps/librdkafka/tests/0080-admin_ut.c

@@ -528,22 +528,44 @@ static void do_test_ListConsumerGroups(const char *what,
         q = useq ? useq : rd_kafka_queue_new(rk);
 
         if (with_options) {
-                rd_kafka_consumer_group_state_t duplicate[2] = {
+                rd_kafka_error_t *error;
+                rd_kafka_consumer_group_state_t duplicate_states[2] = {
                     RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY,
                     RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY};
+                rd_kafka_consumer_group_type_t duplicate_types[2] = {
+                    RD_KAFKA_CONSUMER_GROUP_TYPE_CLASSIC,
+                    RD_KAFKA_CONSUMER_GROUP_TYPE_CLASSIC};
+                rd_kafka_consumer_group_type_t unknown_type[1] = {
+                    RD_KAFKA_CONSUMER_GROUP_TYPE_UNKNOWN};
 
                 options = rd_kafka_AdminOptions_new(
                     rk, RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS);
 
                 /* Test duplicate error on match states */
-                rd_kafka_error_t *error =
-                    rd_kafka_AdminOptions_set_match_consumer_group_states(
-                        options, duplicate, 2);
+                error = rd_kafka_AdminOptions_set_match_consumer_group_states(
+                    options, duplicate_states, 2);
                 TEST_ASSERT(error && rd_kafka_error_code(error), "%s",
                             "Expected error on duplicate states,"
                             " got no error");
                 rd_kafka_error_destroy(error);
 
+                /* Test duplicate error on match group types */
+                error = rd_kafka_AdminOptions_set_match_consumer_group_types(
+                    options, duplicate_types, 2);
+                TEST_ASSERT(error && rd_kafka_error_code(error), "%s",
+                            "Expected error on duplicate group types,"
+                            " got no error");
+                rd_kafka_error_destroy(error);
+
+                /* Test invalid args error on setting UNKNOWN group type in
+                 * match group types */
+                error = rd_kafka_AdminOptions_set_match_consumer_group_types(
+                    options, unknown_type, 1);
+                TEST_ASSERT(error && rd_kafka_error_code(error), "%s",
+                            "Expected error on Unknown group type,"
+                            " got no error");
+                rd_kafka_error_destroy(error);
+
                 exp_timeout = MY_SOCKET_TIMEOUT_MS * 2;
                 TEST_CALL_ERR__(rd_kafka_AdminOptions_set_request_timeout(
                     options, exp_timeout, errstr, sizeof(errstr)));
@@ -2686,6 +2708,10 @@ static void do_test_unclean_destroy(rd_kafka_type_t cltype, int with_mainq) {
          * rely on the controller not being found. */
         test_conf_set(conf, "bootstrap.servers", "");
         test_conf_set(conf, "socket.timeout.ms", "60000");
+        if (test_consumer_group_protocol()) {
+                test_conf_set(conf, "group.protocol",
+                              test_consumer_group_protocol());
+        }
 
         rk = rd_kafka_new(cltype, conf, errstr, sizeof(errstr));
         TEST_ASSERT(rk, "kafka_new(%d): %s", cltype, errstr);
@@ -2893,6 +2919,10 @@ static rd_kafka_t *create_admin_client(rd_kafka_type_t cltype) {
          * rely on the controller not being found. */
         test_conf_set(conf, "bootstrap.servers", "");
         test_conf_set(conf, "socket.timeout.ms", MY_SOCKET_TIMEOUT_MS_STR);
+        if (test_consumer_group_protocol()) {
+                test_conf_set(conf, "group.protocol",
+                              test_consumer_group_protocol());
+        }
         /* For use with the background queue */
         rd_kafka_conf_set_background_event_cb(conf, background_event_cb);