@platformatic/rdkafka 4.0.0 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0113-cooperative_rebalance.cpp

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2020-2022, Magnus Edenhill
+ *               2023, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -58,9 +59,11 @@ class Toppar {
   }
 
   friend bool operator<(const Toppar &a, const Toppar &b) {
-    if (a.partition < b.partition)
+    if (a.topic < b.topic)
       return true;
-    return a.topic < b.topic;
+    if (a.topic > b.topic)
+      return false;
+    return a.partition < b.partition;
   }
 
   string str() const {
@@ -930,7 +933,8 @@ static void b_subscribe_with_cb_test(rd_bool_t close_consumer) {
     /* Failure case: test will time out. */
     if (Test::assignment_partition_count(c1, NULL) == 1 &&
         Test::assignment_partition_count(c2, NULL) == 1) {
-      if (test_consumer_group_protocol_generic() &&
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic() &&
           !(rebalance_cb1.assign_call_cnt == expected_cb1_assign_call_cnt &&
             rebalance_cb2.assign_call_cnt == expected_cb2_assign_call_cnt))
         continue;
@@ -956,7 +960,8 @@ static void b_subscribe_with_cb_test(rd_bool_t close_consumer) {
    * triggered.
    */
 
-  if (test_consumer_group_protocol_generic()) {
+  /* Callback count can vary in KIP-848 */
+  if (test_consumer_group_protocol_classic()) {
     /* The rebalance cb is always called on assign, even if empty. */
     if (rebalance_cb1.assign_call_cnt != expected_cb1_assign_call_cnt)
       Test::Fail(tostr() << "Expecting " << expected_cb1_assign_call_cnt
@@ -1029,7 +1034,8 @@ static void b_subscribe_with_cb_test(rd_bool_t close_consumer) {
   c1->close();
   c2->close();
 
-  if (test_consumer_group_protocol_generic()) {
+  /* Callback count can vary in KIP-848 */
+  if (test_consumer_group_protocol_classic()) {
     /* Closing the consumer should trigger rebalance_cb (revoke): */
     if (rebalance_cb1.revoke_call_cnt != 2)
       Test::Fail(tostr() << "Expecting 2 revoke calls on consumer 1, not: "
@@ -1405,6 +1411,13 @@ class GTestRebalanceCb : public RdKafka::RebalanceCb {
 static void g_incremental_assign_call_eager() {
   SUB_TEST();
 
+  /* Only classic consumer group protocol supports EAGER protocol*/
+  if (!test_consumer_group_protocol_classic()) {
+    SUB_TEST_SKIP(
+        "Skipping incremental assign call eager test as EAGER protocol is only "
+        "supported in `classic` consumer group protocol");
+  }
+
   std::string topic_name = Test::mk_topic_name("0113-cooperative_rebalance", 1);
   test_create_topic(NULL, topic_name.c_str(), 1, 1);
 
@@ -1473,7 +1486,8 @@ static void h_delete_topic() {
     c->assignment(partitions);
 
     if (partitions.size() == 2 && !deleted) {
-      if (test_consumer_group_protocol_generic() &&
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic() &&
           rebalance_cb.assign_call_cnt != 1)
         Test::Fail(tostr() << "Expected 1 assign call, saw "
                            << rebalance_cb.assign_call_cnt << "\n");
@@ -1537,7 +1551,8 @@ static void i_delete_topic_2() {
     Test::poll_once(c, 500);
 
     if (Test::assignment_partition_count(c, NULL) == 1 && !deleted) {
-      if (test_consumer_group_protocol_generic() &&
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic() &&
           rebalance_cb.assign_call_cnt != 1)
         Test::Fail(tostr() << "Expected one assign call, saw "
                            << rebalance_cb.assign_call_cnt << "\n");
@@ -1644,7 +1659,8 @@ static void k_add_partition() {
     Test::poll_once(c, 500);
 
     if (Test::assignment_partition_count(c, NULL) == 1 && !subscribed) {
-      if (test_consumer_group_protocol_generic()) {
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic()) {
         if (rebalance_cb.assign_call_cnt != 1)
           Test::Fail(tostr() << "Expected 1 assign call, saw "
                              << rebalance_cb.assign_call_cnt);
@@ -1657,7 +1673,8 @@ static void k_add_partition() {
     }
 
     if (Test::assignment_partition_count(c, NULL) == 2 && subscribed) {
-      if (test_consumer_group_protocol_generic()) {
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic()) {
         if (rebalance_cb.assign_call_cnt != 2)
           Test::Fail(tostr() << "Expected 2 assign calls, saw "
                              << rebalance_cb.assign_call_cnt);
@@ -1673,7 +1690,8 @@ static void k_add_partition() {
   c->close();
   delete c;
 
-  if (test_consumer_group_protocol_generic()) {
+  /* Callback count can vary in KIP-848 */
+  if (test_consumer_group_protocol_classic()) {
     if (rebalance_cb.assign_call_cnt != 2)
       Test::Fail(tostr() << "Expected 2 assign calls, saw "
                          << rebalance_cb.assign_call_cnt);
@@ -1730,7 +1748,8 @@ static void l_unsubscribe() {
 
     if (Test::assignment_partition_count(c1, NULL) == 2 &&
         Test::assignment_partition_count(c2, NULL) == 2) {
-      if (test_consumer_group_protocol_generic()) {
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic()) {
         if (rebalance_cb1.assign_call_cnt != expected_cb1_assign_call_cnt)
           Test::Fail(tostr() << "Expecting consumer 1's assign_call_cnt to be "
                              << expected_cb1_assign_call_cnt
@@ -1748,7 +1767,8 @@ static void l_unsubscribe() {
 
     if (unsubscribed && Test::assignment_partition_count(c1, NULL) == 0 &&
         Test::assignment_partition_count(c2, NULL) == 4) {
-      if (test_consumer_group_protocol_generic()) {
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic()) {
         if (rebalance_cb1.assign_call_cnt != expected_cb1_assign_call_cnt)
           /* is now unsubscribed, so rebalance_cb will no longer be called. */
           Test::Fail(tostr() << "Expecting consumer 1's assign_call_cnt to be "
@@ -1779,7 +1799,8 @@ static void l_unsubscribe() {
   Test::Say("Closing consumer 2\n");
   c2->close();
 
-  if (test_consumer_group_protocol_generic()) {
+  /* Callback count can vary in KIP-848 */
+  if (test_consumer_group_protocol_classic()) {
     /* there should be no assign rebalance_cb calls on close */
     if (rebalance_cb1.assign_call_cnt != expected_cb1_assign_call_cnt)
       Test::Fail(tostr() << "Expecting consumer 1's assign_call_cnt to be "
@@ -1899,22 +1920,19 @@ static void n_wildcard() {
   Test::poll_once(c1, 500);
   Test::poll_once(c2, 500);
 
-  if (test_consumer_group_protocol_generic()) {
-    if (rebalance_cb1.assign_call_cnt != 0)
-      Test::Fail(
-          tostr() << "Expecting consumer 1's assign_call_cnt to be 0 not: "
-                  << rebalance_cb1.assign_call_cnt);
-    if (rebalance_cb2.assign_call_cnt != 0)
-      Test::Fail(
-          tostr() << "Expecting consumer 2's assign_call_cnt to be 0 not: "
-                  << rebalance_cb2.assign_call_cnt);
-  }
+  if (rebalance_cb1.assign_call_cnt != 0)
+    Test::Fail(tostr() << "Expecting consumer 1's assign_call_cnt to be 0 not: "
+                       << rebalance_cb1.assign_call_cnt);
+  if (rebalance_cb2.assign_call_cnt != 0)
+    Test::Fail(tostr() << "Expecting consumer 2's assign_call_cnt to be 0 not: "
+                       << rebalance_cb2.assign_call_cnt);
 
   bool done                    = false;
   bool created_topics          = false;
   bool deleted_topic           = false;
   int last_cb1_assign_call_cnt = 0;
   int last_cb2_assign_call_cnt = 0;
+  int expected_lost_cnt        = 0;
   while (!done) {
     Test::poll_once(c1, 500);
     Test::poll_once(c2, 500);
@@ -1925,6 +1943,8 @@ static void n_wildcard() {
           "Creating two topics with 2 partitions each that match regex\n");
       test_create_topic(NULL, topic_name_1.c_str(), 2, 1);
       test_create_topic(NULL, topic_name_2.c_str(), 2, 1);
+      test_wait_topic_exists(NULL, topic_name_1.c_str(), 5000);
+      test_wait_topic_exists(NULL, topic_name_2.c_str(), 5000);
       /* The consumers should autonomously discover these topics and start
        * consuming from them. This happens in the background - is not
        * influenced by whether we wait for the topics to be created before
@@ -1974,22 +1994,26 @@ static void n_wildcard() {
 
     if (Test::assignment_partition_count(c1, NULL) == 1 &&
         Test::assignment_partition_count(c2, NULL) == 1 && deleted_topic) {
-      if (test_consumer_group_protocol_generic()) {
-        /* accumulated in lost case as well */
-        TEST_ASSERT(rebalance_cb1.revoke_call_cnt == 1,
-                    "Expecting C_1's revoke_call_cnt to be 1 not %d",
-                    rebalance_cb1.revoke_call_cnt);
-        TEST_ASSERT(rebalance_cb2.revoke_call_cnt == 1,
-                    "Expecting C_2's revoke_call_cnt to be 1 not %d",
-                    rebalance_cb2.revoke_call_cnt);
+      /* accumulated in lost case as well for the classic protocol*/
+      TEST_ASSERT(rebalance_cb1.revoke_call_cnt == 1,
+                  "Expecting C_1's revoke_call_cnt to be 1 not %d",
+                  rebalance_cb1.revoke_call_cnt);
+      TEST_ASSERT(rebalance_cb2.revoke_call_cnt == 1,
+                  "Expecting C_2's revoke_call_cnt to be 1 not %d",
+                  rebalance_cb2.revoke_call_cnt);
+
+      /* Deleted topics are not counted as lost in KIP-848.
+       * Assignment changes are propogated through ConsumerGroupHeartbeat. */
+      if (test_consumer_group_protocol_classic()) {
+        expected_lost_cnt++;
       }
 
-      TEST_ASSERT(rebalance_cb1.lost_call_cnt == 1,
-                  "Expecting C_1's lost_call_cnt to be 1 not %d",
-                  rebalance_cb1.lost_call_cnt);
-      TEST_ASSERT(rebalance_cb2.lost_call_cnt == 1,
-                  "Expecting C_2's lost_call_cnt to be 1 not %d",
-                  rebalance_cb2.lost_call_cnt);
+      TEST_ASSERT(rebalance_cb1.lost_call_cnt == expected_lost_cnt,
+                  "Expecting C_1's lost_call_cnt to be %d not %d",
+                  expected_lost_cnt, rebalance_cb1.lost_call_cnt);
+      TEST_ASSERT(rebalance_cb2.lost_call_cnt == expected_lost_cnt,
+                  "Expecting C_2's lost_call_cnt to be %d not %d",
+                  expected_lost_cnt, rebalance_cb2.lost_call_cnt);
 
       /* Consumers will rejoin group after revoking the lost partitions.
        * this will result in an rebalance_cb assign (empty partitions).
@@ -2011,12 +2035,10 @@ static void n_wildcard() {
   last_cb1_assign_call_cnt = rebalance_cb1.assign_call_cnt;
   c1->close();
 
-  if (test_consumer_group_protocol_generic()) {
-    /* There should be no assign rebalance_cb calls on close */
-    TEST_ASSERT(rebalance_cb1.assign_call_cnt == last_cb1_assign_call_cnt,
-                "Expecting C_1's assign_call_cnt to be %d not %d",
-                last_cb1_assign_call_cnt, rebalance_cb1.assign_call_cnt);
-  }
+  /* There should be no assign rebalance_cb calls on close */
+  TEST_ASSERT(rebalance_cb1.assign_call_cnt == last_cb1_assign_call_cnt,
+              "Expecting C_1's assign_call_cnt to be %d not %d",
+              last_cb1_assign_call_cnt, rebalance_cb1.assign_call_cnt);
 
   /* Let C_2 catch up on the rebalance and get assigned C_1's partitions. */
   last_cb2_assign_call_cnt = rebalance_cb2.nonempty_assign_call_cnt;
@@ -2027,26 +2049,24 @@ static void n_wildcard() {
   last_cb2_assign_call_cnt = rebalance_cb2.assign_call_cnt;
   c2->close();
 
-  if (test_consumer_group_protocol_generic()) {
-    /* There should be no assign rebalance_cb calls on close */
-    TEST_ASSERT(rebalance_cb2.assign_call_cnt == last_cb2_assign_call_cnt,
-                "Expecting C_2's assign_call_cnt to be %d not %d",
-                last_cb2_assign_call_cnt, rebalance_cb2.assign_call_cnt);
-
-    TEST_ASSERT(rebalance_cb1.revoke_call_cnt == 2,
-                "Expecting C_1's revoke_call_cnt to be 2 not %d",
-                rebalance_cb1.revoke_call_cnt);
-    TEST_ASSERT(rebalance_cb2.revoke_call_cnt == 2,
-                "Expecting C_2's revoke_call_cnt to be 2 not %d",
-                rebalance_cb2.revoke_call_cnt);
-  }
-
-  TEST_ASSERT(rebalance_cb1.lost_call_cnt == 1,
-              "Expecting C_1's lost_call_cnt to be 1, not %d",
-              rebalance_cb1.lost_call_cnt);
-  TEST_ASSERT(rebalance_cb2.lost_call_cnt == 1,
-              "Expecting C_2's lost_call_cnt to be 1, not %d",
-              rebalance_cb2.lost_call_cnt);
+  /* There should be no assign rebalance_cb calls on close */
+  TEST_ASSERT(rebalance_cb2.assign_call_cnt == last_cb2_assign_call_cnt,
+              "Expecting C_2's assign_call_cnt to be %d not %d",
+              last_cb2_assign_call_cnt, rebalance_cb2.assign_call_cnt);
+
+  TEST_ASSERT(rebalance_cb1.revoke_call_cnt == 2,
+              "Expecting C_1's revoke_call_cnt to be 2 not %d",
+              rebalance_cb1.revoke_call_cnt);
+  TEST_ASSERT(rebalance_cb2.revoke_call_cnt == 2,
+              "Expecting C_2's revoke_call_cnt to be 2 not %d",
+              rebalance_cb2.revoke_call_cnt);
+
+  TEST_ASSERT(rebalance_cb1.lost_call_cnt == expected_lost_cnt,
+              "Expecting C_1's lost_call_cnt to be %d, not %d",
+              expected_lost_cnt, rebalance_cb1.lost_call_cnt);
+  TEST_ASSERT(rebalance_cb2.lost_call_cnt == expected_lost_cnt,
+              "Expecting C_2's lost_call_cnt to be %d, not %d",
+              expected_lost_cnt, rebalance_cb2.lost_call_cnt);
 
   delete c1;
   delete c2;
@@ -2119,7 +2139,8 @@ static void o_java_interop() {
 
     if (Test::assignment_partition_count(c, NULL) == 4 && java_pid != 0 &&
         !changed_subscription) {
-      if (test_consumer_group_protocol_generic() &&
+      /* Callback count can vary in KIP-848 */
+      if (test_consumer_group_protocol_classic() &&
           rebalance_cb.assign_call_cnt != 2)
         Test::Fail(tostr() << "Expecting consumer's assign_call_cnt to be 2, "
                               "not "
@@ -2320,7 +2341,8 @@ static void t_max_poll_interval_exceeded(int variation) {
                        << expected_cb1_lost_call_cnt
                        << ", not: " << rebalance_cb1.lost_call_cnt);
 
-  if (test_consumer_group_protocol_generic()) {
+  /* Callback count can vary in KIP-848 */
+  if (test_consumer_group_protocol_classic()) {
     if (rebalance_cb1.nonempty_assign_call_cnt != expected_cb1_assign_call_cnt)
       Test::Fail(tostr() << "Expected consumer 1 non-empty assign count to be "
                          << expected_cb1_assign_call_cnt << ", not: "
@@ -2608,9 +2630,9 @@ static void u_multiple_subscription_changes(bool use_rebalance_cb,
     /* Verify consumer assignments */
     int counts[N_CONSUMERS];
     map<Toppar, RdKafka::KafkaConsumer *> all_assignments;
-    Test::Say(tostr() << "Consumer assignments "
-                      << "(subscription_variation " << subscription_variation
-                      << ")" << (stabilized ? " (stabilized)" : "")
+    Test::Say(tostr() << "Consumer assignments " << "(subscription_variation "
+                      << subscription_variation << ")"
+                      << (stabilized ? " (stabilized)" : "")
                       << (use_rebalance_cb ? " (use_rebalance_cb)"
                                            : " (no rebalance cb)")
                       << ":\n");
@@ -2657,9 +2679,8 @@ static void u_multiple_subscription_changes(bool use_rebalance_cb,
       Test::Say(tostr() << (counts[i] == exp_parts ? "" : _C_YEL) << "Consumer "
                         << consumers[i]->name() << " has " << counts[i]
                         << " assigned partitions (" << consumer_topics[i].size()
-                        << " subscribed topic(s))"
-                        << ", expecting " << exp_parts
-                        << " assigned partitions\n");
+                        << " subscribed topic(s))" << ", expecting "
+                        << exp_parts << " assigned partitions\n");
 
       if (counts[i] != exp_parts)
         done = false;
@@ -2674,8 +2695,13 @@ static void u_multiple_subscription_changes(bool use_rebalance_cb,
 
   Test::Say("Disposing consumers\n");
   for (int i = 0; i < N_CONSUMERS; i++) {
-    TEST_ASSERT(!use_rebalance_cb || !rebalance_cbs[i].wait_rebalance,
-                "Consumer %d still waiting for rebalance", i);
+    /* A consumer will not necessarily get a rebalance after a
+     * subscription change with the consumer protocol */
+    if (test_consumer_group_protocol_classic()) {
+      TEST_ASSERT(!use_rebalance_cb || !rebalance_cbs[i].wait_rebalance,
+                  "Consumer %d still waiting for rebalance", i);
+    }
+
     if (i & 1)
       consumers[i]->close();
     delete consumers[i];
@@ -2801,18 +2827,28 @@ static void p_lost_partitions_heartbeat_illegal_generation_test() {
                    RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS,
                    rd_false /*don't expect lost*/, 5 + 2);
 
-  /* Fail heartbeats */
-  rd_kafka_mock_push_request_errors(mcluster, RD_KAFKAP_Heartbeat, 5,
-                                    RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
-                                    RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
-                                    RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
-                                    RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
-                                    RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION);
+  if (test_consumer_group_protocol_classic()) {
+    /* Fail heartbeats */
+    rd_kafka_mock_push_request_errors(mcluster, RD_KAFKAP_Heartbeat, 5,
+                                      RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
+                                      RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
+                                      RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
+                                      RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
+                                      RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION);
+  } else {
+    /* Fail heartbeats */
+    rd_kafka_mock_broker_push_request_error_rtts(
+        mcluster, 1, RD_KAFKAP_ConsumerGroupHeartbeat, 2,
+        RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH, 0, RD_KAFKA_RESP_ERR_NO_ERROR,
+        1000);
+  }
 
   expect_rebalance("lost partitions", c, RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS,
                    rd_true /*expect lost*/, 10 + 2);
 
   rd_kafka_mock_clear_request_errors(mcluster, RD_KAFKAP_Heartbeat);
+  rd_kafka_mock_clear_request_errors(mcluster,
+                                     RD_KAFKAP_ConsumerGroupHeartbeat);
 
   expect_rebalance("rejoin after lost", c, RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS,
                    rd_false /*don't expect lost*/, 10 + 2);
@@ -2994,6 +3030,78 @@ static void r_lost_partitions_commit_illegal_generation_test_local() {
   test_mock_cluster_destroy(mcluster);
 }
 
+/* Check commit is retried on FENCED_MEMBER_EPOCH, using new epoch taken
+ * from HB. */
+static void t_consumer_group_consumer_retry_commit_on_fenced_member_epoch() {
+  const char *bootstraps;
+  rd_kafka_mock_cluster_t *mcluster;
+  const char *groupid = "mygroup";
+  const char *topic   = "test";
+  const int msgcnt    = 100;
+  rd_kafka_t *c;
+  rd_kafka_conf_t *conf;
+  rd_kafka_topic_partition_list_t *rktpars =
+      rd_kafka_topic_partition_list_new(1);
+
+  SUB_TEST();
+
+  mcluster = test_mock_cluster_new(3, &bootstraps);
+
+  rd_kafka_mock_coordinator_set(mcluster, "group", groupid, 1);
+
+  /* Seed the topic with messages */
+  test_produce_msgs_easy_v(topic, 0, 0, 0, msgcnt, 10, "bootstrap.servers",
+                           bootstraps, "batch.num.messages", "10",
+                           "security.protocol", "plaintext", NULL);
+
+  test_conf_init(&conf, NULL, 30);
+  test_conf_set(conf, "bootstrap.servers", bootstraps);
+  test_conf_set(conf, "security.protocol", "PLAINTEXT");
+  test_conf_set(conf, "group.id", groupid);
+  test_conf_set(conf, "auto.offset.reset", "earliest");
+  test_conf_set(conf, "enable.auto.commit", "false");
+  test_conf_set(conf, "partition.assignment.strategy", "cooperative-sticky");
+
+  c = test_create_consumer(groupid, rebalance_cb, conf, NULL);
+
+  test_consumer_subscribe(c, topic);
+
+  expect_rebalance("initial assignment", c,
+                   RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS,
+                   rd_false /*don't expect lost*/, 5 + 2);
+
+
+  /* Consume some messages so that the commit has something to commit. */
+  test_consumer_poll("consume", c, -1, -1, -1, msgcnt / 2, NULL);
+
+  /* Fail Commit */
+  rd_kafka_mock_push_request_errors(mcluster, RD_KAFKAP_OffsetCommit, 5,
+                                    RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH,
+                                    RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH,
+                                    RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH,
+                                    RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH,
+                                    RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH);
+
+  rd_kafka_commit(c, NULL, rd_false);
+
+  TEST_CALL_ERR__(rd_kafka_committed(c, rktpars, 2000));
+
+  /* Offsets should be committed with retries */
+  TEST_ASSERT(rktpars->cnt == 1);
+  TEST_ASSERT(rktpars->elems[0].offset == msgcnt / 2);
+
+  rd_kafka_topic_partition_list_destroy(rktpars);
+
+  TEST_SAY("Closing consumer\n");
+  test_consumer_close(c);
+
+  TEST_SAY("Destroying consumer\n");
+  rd_kafka_destroy(c);
+
+  TEST_SAY("Destroying mock cluster\n");
+  test_mock_cluster_destroy(mcluster);
+}
+
 /**
  * @brief Test that the consumer is destroyed without segfault if
  *        it happens before first rebalance and there is no assignor
@@ -3064,8 +3172,11 @@ static void v_rebalance_cb(rd_kafka_t *rk,
   if (err == RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS) {
     test_consumer_incremental_assign("assign", rk, parts);
   } else {
-    test_consumer_incremental_unassign("unassign", rk, parts);
-
+    TEST_ASSERT(!rd_kafka_assignment_lost(rk),
+                "Assignment must not be lost, "
+                " that is a sign that an ILLEGAL_GENERATION error, "
+                " during a commit happening during a rebalance is "
+                "causing the assignment to be lost.");
     if (!*auto_commitp) {
       rd_kafka_resp_err_t commit_err;
 
@@ -3074,10 +3185,14 @@ static void v_rebalance_cb(rd_kafka_t *rk,
       rd_sleep(2);
       commit_err = rd_kafka_commit(rk, NULL, 0 /*sync*/);
       TEST_ASSERT(!commit_err || commit_err == RD_KAFKA_RESP_ERR__NO_OFFSET ||
-                      commit_err == RD_KAFKA_RESP_ERR__DESTROY,
+                      commit_err == RD_KAFKA_RESP_ERR__DESTROY ||
+                      commit_err == RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
                   "%s: manual commit failed: %s", rd_kafka_name(rk),
                   rd_kafka_err2str(commit_err));
     }
+
+    /* Unassign must be done after manual commit. */
+    test_consumer_incremental_unassign("unassign", rk, parts);
   }
 }
 
@@ -3091,11 +3206,23 @@ static void v_commit_cb(rd_kafka_t *rk,
   TEST_SAY("%s offset commit for %d offsets: %s\n", rd_kafka_name(rk),
            offsets ? offsets->cnt : -1, rd_kafka_err2name(err));
   TEST_ASSERT(!err || err == RD_KAFKA_RESP_ERR__NO_OFFSET ||
+                  err == RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION ||
                   err == RD_KAFKA_RESP_ERR__DESTROY /* consumer was closed */,
               "%s offset commit failed: %s", rd_kafka_name(rk),
               rd_kafka_err2str(err));
 }
 
+/**
+ * @brief Log callback for the v_.. test.
+ */
+static void v_log_cb(const rd_kafka_t *rk,
+                     int level,
+                     const char *fac,
+                     const char *buf) {
+  /* Slow down logging to make ILLEGAL_GENERATION errors caused by
+   * manual commit more likely. */
+  rd_usleep(1000, 0);
+}
 
 static void v_commit_during_rebalance(bool with_rebalance_cb,
                                       bool auto_commit) {
@@ -3120,9 +3247,7 @@ static void v_commit_during_rebalance(bool with_rebalance_cb,
    */
   p = test_create_producer();
 
-  test_create_topic(p, topic, partition_cnt, 1);
-
-  test_wait_topic_exists(p, topic, 5000);
+  test_create_topic_wait_exists(p, topic, partition_cnt, 1, 5000);
 
   for (i = 0; i < partition_cnt; i++) {
     test_produce_msgs2(p, topic, testid, i, i * msgcnt_per_partition,
@@ -3135,8 +3260,13 @@ static void v_commit_during_rebalance(bool with_rebalance_cb,
 
 
   test_conf_set(conf, "auto.offset.reset", "earliest");
+  test_conf_set(conf, "debug", "consumer,cgrp,topic,fetch");
   test_conf_set(conf, "enable.auto.commit", auto_commit ? "true" : "false");
   test_conf_set(conf, "partition.assignment.strategy", "cooperative-sticky");
+  if (!auto_commit)
+    /* Slowing down logging is necessary only to make assignment lost
+     * errors more evident. */
+    rd_kafka_conf_set_log_cb(conf, v_log_cb);
   rd_kafka_conf_set_offset_commit_cb(conf, v_commit_cb);
   rd_kafka_conf_set_opaque(conf, (void *)&auto_commit);
 
@@ -3161,8 +3291,20 @@ static void v_commit_during_rebalance(bool with_rebalance_cb,
 
   /* Poll both consumers */
   for (i = 0; i < 10; i++) {
-    test_consumer_poll_once(c1, NULL, 1000);
-    test_consumer_poll_once(c2, NULL, 1000);
+    int poll_result1, poll_result2;
+    do {
+      poll_result1 = test_consumer_poll_once(c1, NULL, 1000);
+      poll_result2 = test_consumer_poll_once(c2, NULL, 1000);
+
+      if (poll_result1 == 1 && !auto_commit) {
+        rd_kafka_resp_err_t err;
+        TEST_SAY("Attempting manual commit after poll\n");
+        err = rd_kafka_commit(c1, NULL, 0);
+        TEST_ASSERT(!err || err == RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION,
+                    "Expected not error or ILLEGAL_GENERATION, got: %s",
+                    rd_kafka_err2str(err));
+      }
+    } while (poll_result1 == 0 || poll_result2 == 0);
   }
 
   TEST_SAY("Closing consumers\n");
@@ -3189,7 +3331,7 @@ static void x_incremental_rebalances(void) {
   SUB_TEST();
   test_conf_init(&conf, NULL, 60);
 
-  test_create_topic(NULL, topic, 6, 1);
+  test_create_topic_wait_exists(NULL, topic, 6, 1, 5000);
 
   test_conf_set(conf, "partition.assignment.strategy", "cooperative-sticky");
   for (i = 0; i < _NUM_CONS; i++) {
@@ -3215,7 +3357,7 @@ static void x_incremental_rebalances(void) {
   test_consumer_subscribe(c[1], topic);
   test_consumer_wait_assignment(c[1], rd_true /*poll*/);
   rd_sleep(3);
-  if (test_consumer_group_protocol_generic()) {
+  if (test_consumer_group_protocol_classic()) {
     test_consumer_verify_assignment(c[0], rd_false /*fail later*/, topic, 3,
                                     topic, 4, topic, 5, NULL);
     test_consumer_verify_assignment(c[1], rd_false /*fail later*/, topic, 0,
@@ -3232,7 +3374,7 @@ static void x_incremental_rebalances(void) {
   test_consumer_subscribe(c[2], topic);
   test_consumer_wait_assignment(c[2], rd_true /*poll*/);
   rd_sleep(3);
-  if (test_consumer_group_protocol_generic()) {
+  if (test_consumer_group_protocol_classic()) {
     test_consumer_verify_assignment(c[0], rd_false /*fail later*/, topic, 4,
                                     topic, 5, NULL);
     test_consumer_verify_assignment(c[1], rd_false /*fail later*/, topic, 1,
@@ -3265,9 +3407,18 @@ int main_0113_cooperative_rebalance_local(int argc, char **argv) {
 
   a_assign_rapid();
   p_lost_partitions_heartbeat_illegal_generation_test();
-  q_lost_partitions_illegal_generation_test(rd_false /*joingroup*/);
-  q_lost_partitions_illegal_generation_test(rd_true /*syncgroup*/);
-  r_lost_partitions_commit_illegal_generation_test_local();
+  if (test_consumer_group_protocol_classic()) {
+    /* These tests have no correspondence with
+     * the consumer group protocol "consumer" */
+    q_lost_partitions_illegal_generation_test(rd_false /*joingroup*/);
+    q_lost_partitions_illegal_generation_test(rd_true /*syncgroup*/);
+  }
+  if (test_consumer_group_protocol_classic()) {
+    r_lost_partitions_commit_illegal_generation_test_local();
+  } else if (0) {
+    /* FIXME: enable this once new errors are handled in OffsetCommit. */
+    t_consumer_group_consumer_retry_commit_on_fenced_member_epoch();
+  }
   s_no_segfault_before_first_rebalance();
   return 0;
 }
@@ -3298,10 +3449,7 @@ int main_0113_cooperative_rebalance(int argc, char **argv) {
   k_add_partition();
   l_unsubscribe();
   m_unsubscribe_2();
-  if (test_consumer_group_protocol_generic()) {
-    /* FIXME: should work with next ConsumerGroupHeartbeat version */
-    n_wildcard();
-  }
+  n_wildcard();
   o_java_interop();
   for (i = 1; i <= 6; i++) /* iterate over 6 different test variations */
     s_subscribe_when_rebalancing(i);
@@ -3309,12 +3457,8 @@ int main_0113_cooperative_rebalance(int argc, char **argv) {
     t_max_poll_interval_exceeded(i);
   /* Run all 2*3 variations of the u_.. test */
   for (i = 0; i < 3; i++) {
-    if (test_consumer_group_protocol_generic()) {
-      /* FIXME: check this test, it should fail because of the callback number
-       */
-      u_multiple_subscription_changes(true /*with rebalance_cb*/, i);
-      u_multiple_subscription_changes(false /*without rebalance_cb*/, i);
-    }
+    u_multiple_subscription_changes(true /*with rebalance_cb*/, i);
+    u_multiple_subscription_changes(false /*without rebalance_cb*/, i);
   }
   v_commit_during_rebalance(true /*with rebalance callback*/,
                             true /*auto commit*/);

package/deps/librdkafka/tests/0114-sticky_partitioning.cpp

@@ -44,7 +44,7 @@
  */
 static void do_test_sticky_partitioning(int sticky_delay) {
   std::string topic = Test::mk_topic_name(__FILE__, 1);
-  Test::create_topic(NULL, topic.c_str(), 3, 1);
+  Test::create_topic_wait_exists(NULL, topic.c_str(), 3, 1, 5000);
 
   RdKafka::Conf *conf;
   Test::conf_init(&conf, NULL, 0);
@@ -148,8 +148,8 @@ static void do_test_sticky_partitioning(int sticky_delay) {
   /* When sticky.partitioning.linger.ms is long (greater than expected
    * length of run), one partition should be sticky and receive messages. */
   if (sticky_delay == 5000 && num_partitions_active > 1)
-    Test::Fail(tostr() << "Expected only 1 partition to receive msgs"
-                       << " but " << num_partitions_active
+    Test::Fail(tostr() << "Expected only 1 partition to receive msgs" << " but "
+                       << num_partitions_active
                        << " partitions received msgs.");
 
   /* When sticky.partitioning.linger.ms is short (sufficiently smaller than