@platformatic/rdkafka 4.0.1 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0129-fetch_aborted_msgs.c

@@ -60,6 +60,7 @@ int main_0129_fetch_aborted_msgs(int argc, char **argv) {
                                 (const char *[]) {"max.message.bytes", "10000",
                                                   "segment.bytes", "20000",
                                                   NULL});
+        test_wait_topic_exists(rk, topic, 5000);
 
         TEST_CALL_ERROR__(rd_kafka_init_transactions(rk, -1));
         TEST_CALL_ERROR__(rd_kafka_begin_transaction(rk));

package/deps/librdkafka/tests/0132-strategy_ordering.c

@@ -109,7 +109,7 @@ static void verify_range_assignment(rd_kafka_t *c[]) {
         rd_kafka_topic_partition_list_destroy(assignment2);
 }
 
-static void do_test_stragety_ordering(const char *assignor,
+static void do_test_strategy_ordering(const char *assignor,
                                       const char *expected_assignor) {
         rd_kafka_conf_t *conf;
 #define _C_CNT 2
@@ -125,7 +125,7 @@ static void do_test_stragety_ordering(const char *assignor,
         testid = test_id_generate();
 
         topic = test_mk_topic_name("0132-strategy_ordering", 1);
-        test_create_topic(NULL, topic, _PART_CNT, 1);
+        test_create_topic_wait_exists(NULL, topic, _PART_CNT, 1, 5000);
         test_produce_msgs_easy(topic, testid, RD_KAFKA_PARTITION_UA, msgcnt);
 
         test_conf_init(&conf, NULL, 30);
@@ -165,7 +165,15 @@ static void do_test_stragety_ordering(const char *assignor,
 
 
 int main_0132_strategy_ordering(int argc, char **argv) {
-        do_test_stragety_ordering("roundrobin,range", "roundrobin");
-        do_test_stragety_ordering("range,roundrobin", "range");
+        if (!test_consumer_group_protocol_classic()) {
+                TEST_SKIP(
+                    "Test meaningful only with classic librdkafka"
+                    " assignors\n");
+                return 0;
+        }
+
+        do_test_strategy_ordering("roundrobin,range", "roundrobin");
+        do_test_strategy_ordering("range,roundrobin", "range");
+
         return 0;
 }

package/deps/librdkafka/tests/0133-ssl_keys.c

@@ -53,7 +53,11 @@ static void do_test_ssl_keys(const char *type, rd_bool_t correct_password) {
         SUB_TEST_QUICK("keystore type = %s, correct password = %s", type,
                        RD_STR_ToF(correct_password));
 
-        test_conf_init(&conf, NULL, 30);
+        /* Don't use test_conf_init otherwise
+         * key file configuration value conflicts
+         * with PEM string configuration,
+         * when running in --ssl mode. */
+        conf = rd_kafka_conf_new();
         test_conf_set(conf, "security.protocol", "SSL");
 
         if (!strcmp(type, "PKCS12")) {
@@ -74,17 +78,33 @@ static void do_test_ssl_keys(const char *type, rd_bool_t correct_password) {
                         test_conf_set(conf, "ssl.key.password",
                                       TEST_FIXTURES_KEY_PASSWORD);
                 else
-                        test_conf_set(conf, "ssl.keystore.password",
-                                      TEST_FIXTURES_KEYSTORE_PASSWORD
-                                      " and more");
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD " and more");
+        } else if (!strcmp(type, "PEM_STRING")) {
+                char buf[1024 * 50];
+                if (!test_read_file(TEST_CERTIFICATE_LOCATION, buf,
+                                    sizeof(buf)))
+                        TEST_FAIL("Failed to read certificate file\n");
+                test_conf_set(conf, "ssl.certificate.pem", buf);
+
+                if (!test_read_file(TEST_KEY_LOCATION, buf, sizeof(buf)))
+                        TEST_FAIL("Failed to read key file\n");
+                test_conf_set(conf, "ssl.key.pem", buf);
+
+                if (correct_password)
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD " and more");
         } else {
                 TEST_FAIL("Unexpected key type\n");
         }
 
         rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
         if ((rk != NULL) != correct_password) {
-                TEST_FAIL("Expected rd_kafka creation to %s\n",
-                          correct_password ? "succeed" : "fail");
+                TEST_FAIL("Expected rd_kafka creation to %s: %s\n",
+                          correct_password ? "succeed" : "fail", errstr);
         }
 
         if (rk)
@@ -124,5 +144,7 @@ int main_0133_ssl_keys(int argc, char **argv) {
         do_test_ssl_keys("PKCS12", rd_false);
         do_test_ssl_keys("PEM", rd_true);
         do_test_ssl_keys("PEM", rd_false);
+        do_test_ssl_keys("PEM_STRING", rd_true);
+        do_test_ssl_keys("PEM_STRING", rd_false);
         return 0;
 }

package/deps/librdkafka/tests/0137-barrier_batch_consume.c

@@ -47,7 +47,7 @@ typedef struct consumer_s {
 static int consumer_batch_queue(void *arg) {
         consumer_t *arguments = arg;
         int msg_cnt           = 0;
-        int i;
+        int i, err_cnt = 0;
         test_timing_t t_cons;
 
         rd_kafka_queue_t *rkq     = arguments->rkq;
@@ -72,19 +72,29 @@ static int consumer_batch_queue(void *arg) {
                                                     consume_msg_cnt);
         TIMING_STOP(&t_cons);
 
-        TEST_SAY("%s consumed %d/%d/%d message(s)\n", rd_kafka_name(rk),
-                 msg_cnt, arguments->consume_msg_cnt,
-                 arguments->expected_msg_cnt);
-        TEST_ASSERT(msg_cnt == arguments->expected_msg_cnt,
-                    "consumed %d messages, expected %d", msg_cnt,
-                    arguments->expected_msg_cnt);
-
         for (i = 0; i < msg_cnt; i++) {
-                if (test_msgver_add_msg(rk, arguments->mv, rkmessage[i]) == 0)
+                rd_kafka_message_t *rkm = rkmessage[i];
+                if (rkm->err) {
+                        TEST_WARN("Consumer error: %s: %s\n",
+                                  rd_kafka_err2name(rkm->err),
+                                  rd_kafka_message_errstr(rkm));
+                        err_cnt++;
+                } else if (test_msgver_add_msg(rk, arguments->mv,
+                                               rkmessage[i]) == 0) {
                         TEST_FAIL(
                             "The message is not from testid "
                             "%" PRId64,
                             testid);
+                }
+        }
+        TEST_SAY("%s consumed %d/%d/%d message(s)\n", rd_kafka_name(rk),
+                 msg_cnt, arguments->consume_msg_cnt,
+                 arguments->expected_msg_cnt);
+        TEST_ASSERT((msg_cnt - err_cnt) == arguments->expected_msg_cnt,
+                    "consumed %d messages, %d errors, expected %d", msg_cnt,
+                    err_cnt, arguments->expected_msg_cnt);
+
+        for (i = 0; i < msg_cnt; i++) {
                 rd_kafka_message_destroy(rkmessage[i]);
         }
 
@@ -126,7 +136,7 @@ static void do_test_consume_batch_with_seek(void) {
         /* Produce messages */
         topic = test_mk_topic_name("0137-barrier_batch_consume", 1);
 
-        test_create_topic(NULL, topic, partition_cnt, 1);
+        test_create_topic_wait_exists(NULL, topic, partition_cnt, 1, 5000);
 
         for (p = 0; p < partition_cnt; p++)
                 test_produce_msgs_easy(topic, testid, p,
@@ -216,7 +226,7 @@ static void do_test_consume_batch_with_pause_and_resume_different_batch(void) {
         /* Produce messages */
         topic = test_mk_topic_name("0137-barrier_batch_consume", 1);
 
-        test_create_topic(NULL, topic, partition_cnt, 1);
+        test_create_topic_wait_exists(NULL, topic, partition_cnt, 1, 5000);
 
         for (p = 0; p < partition_cnt; p++)
                 test_produce_msgs_easy(topic, testid, p,
@@ -321,7 +331,7 @@ static void do_test_consume_batch_with_pause_and_resume_same_batch(void) {
         /* Produce messages */
         topic = test_mk_topic_name("0137-barrier_batch_consume", 1);
 
-        test_create_topic(NULL, topic, partition_cnt, 1);
+        test_create_topic_wait_exists(NULL, topic, partition_cnt, 1, 5000);
 
         for (p = 0; p < partition_cnt; p++)
                 test_produce_msgs_easy(topic, testid, p,
@@ -417,7 +427,7 @@ static void do_test_consume_batch_store_offset(void) {
         /* Produce messages */
         topic = test_mk_topic_name("0137-barrier_batch_consume", 1);
 
-        test_create_topic(NULL, topic, partition_cnt, 1);
+        test_create_topic_wait_exists(NULL, topic, partition_cnt, 1, 5000);
 
         for (p = 0; p < partition_cnt; p++)
                 test_produce_msgs_easy(topic, testid, p,
@@ -498,7 +508,7 @@ static void do_test_consume_batch_control_msgs(void) {
 
         producer = test_create_handle(RD_KAFKA_PRODUCER, conf);
 
-        test_create_topic(producer, topic, partition_cnt, 1);
+        test_create_topic_wait_exists(producer, topic, partition_cnt, 1, 5000);
 
         TEST_CALL_ERROR__(rd_kafka_init_transactions(producer, 30 * 1000));