@platformatic/rdkafka 4.0.0 → 4.1.0-alpha.1

package/deps/librdkafka/src/rdkafka_mock_int.h

@@ -30,6 +30,8 @@
 #ifndef _RDKAFKA_MOCK_INT_H_
 #define _RDKAFKA_MOCK_INT_H_
 
+#include "rdkafka_request.h"
+
 /**
  * @name Mock cluster - internal data types
  *
@@ -65,33 +67,33 @@ typedef TAILQ_HEAD(rd_kafka_mock_error_stack_head_s,
 /**
  * @struct Consumer group protocol name and metadata.
  */
-typedef struct rd_kafka_mock_cgrp_proto_s {
+typedef struct rd_kafka_mock_cgrp_classic_proto_s {
         rd_kafkap_str_t *name;
         rd_kafkap_bytes_t *metadata;
-} rd_kafka_mock_cgrp_proto_t;
+} rd_kafka_mock_cgrp_classic_proto_t;
 
 /**
  * @struct Consumer group member
  */
-typedef struct rd_kafka_mock_cgrp_member_s {
-        TAILQ_ENTRY(rd_kafka_mock_cgrp_member_s) link;
+typedef struct rd_kafka_mock_cgrp_classic_member_s {
+        TAILQ_ENTRY(rd_kafka_mock_cgrp_classic_member_s) link;
         char *id;                 /**< MemberId */
         char *group_instance_id;  /**< Group instance id */
         rd_ts_t ts_last_activity; /**< Last activity, e.g., Heartbeat */
-        rd_kafka_mock_cgrp_proto_t *protos;      /**< Protocol names */
-        int proto_cnt;                           /**< Number of protocols */
-        rd_kafkap_bytes_t *assignment;           /**< Current assignment */
+        rd_kafka_mock_cgrp_classic_proto_t *protos; /**< Protocol names */
+        int proto_cnt;                              /**< Number of protocols */
+        rd_kafkap_bytes_t *assignment;              /**< Current assignment */
         rd_kafka_buf_t *resp;                    /**< Current response buffer */
         struct rd_kafka_mock_connection_s *conn; /**< Connection, may be NULL
                                                   *   if there is no ongoing
                                                   *   request. */
-} rd_kafka_mock_cgrp_member_t;
+} rd_kafka_mock_cgrp_classic_member_t;
 
 /**
- * @struct Consumer group.
+ * @struct Classic consumer group.
  */
-typedef struct rd_kafka_mock_cgrp_s {
-        TAILQ_ENTRY(rd_kafka_mock_cgrp_s) link;
+typedef struct rd_kafka_mock_cgrp_classic_s {
+        TAILQ_ENTRY(rd_kafka_mock_cgrp_classic_s) link;
         struct rd_kafka_mock_cluster_s *cluster; /**< Cluster */
         struct rd_kafka_mock_connection_s *conn; /**< Connection */
         char *id;                                /**< Group Id */
@@ -99,20 +101,83 @@ typedef struct rd_kafka_mock_cgrp_s {
         char *protocol_name;                     /**< Elected protocol name */
         int32_t generation_id;                   /**< Generation Id */
         int session_timeout_ms;                  /**< Session timeout */
-        enum { RD_KAFKA_MOCK_CGRP_STATE_EMPTY,   /* No members */
-               RD_KAFKA_MOCK_CGRP_STATE_JOINING, /* Members are joining */
-               RD_KAFKA_MOCK_CGRP_STATE_SYNCING, /* Syncing assignments */
-               RD_KAFKA_MOCK_CGRP_STATE_REBALANCING, /* Rebalance triggered */
-               RD_KAFKA_MOCK_CGRP_STATE_UP,          /* Group is operational */
+        enum {
+                RD_KAFKA_MOCK_CGRP_STATE_EMPTY,       /* No members */
+                RD_KAFKA_MOCK_CGRP_STATE_JOINING,     /* Members are joining */
+                RD_KAFKA_MOCK_CGRP_STATE_SYNCING,     /* Syncing assignments */
+                RD_KAFKA_MOCK_CGRP_STATE_REBALANCING, /* Rebalance triggered */
+                RD_KAFKA_MOCK_CGRP_STATE_UP,          /* Group is operational */
         } state;                        /**< Consumer group state */
         rd_kafka_timer_t session_tmr;   /**< Session timeout timer */
         rd_kafka_timer_t rebalance_tmr; /**< Rebalance state timer */
-        TAILQ_HEAD(, rd_kafka_mock_cgrp_member_s) members; /**< Group members */
+        TAILQ_HEAD(, rd_kafka_mock_cgrp_classic_member_s)
+        members;             /**< Group members */
         int member_cnt;      /**< Number of group members */
         int last_member_cnt; /**< Mumber of group members at last election */
         int assignment_cnt;  /**< Number of member assignments in last Sync */
-        rd_kafka_mock_cgrp_member_t *leader; /**< Elected leader */
-} rd_kafka_mock_cgrp_t;
+        rd_kafka_mock_cgrp_classic_member_t *leader; /**< Elected leader */
+} rd_kafka_mock_cgrp_classic_t;
+
+
+/**
+ * @struct "Consumer" Consumer group (KIP-848).
+ */
+typedef struct rd_kafka_mock_cgrp_consumer_s {
+        TAILQ_ENTRY(rd_kafka_mock_cgrp_consumer_s) link;
+        struct rd_kafka_mock_cluster_s *cluster; /**< Cluster */
+        char *id;                                /**< Group Id */
+        int32_t group_epoch;                     /**< Group epoch */
+        int session_timeout_ms;                  /**< Session timeout */
+        rd_kafka_timer_t session_tmr;            /**< Session timeout timer */
+        int heartbeat_interval_ms;               /**< Heartbeat interval */
+        TAILQ_HEAD(, rd_kafka_mock_cgrp_consumer_member_s)
+        members;                     /**< Group members */
+        int member_cnt;              /**< Number of group members */
+        rd_bool_t manual_assignment; /**< Use manual assignment */
+} rd_kafka_mock_cgrp_consumer_t;
+
+
+/**
+ * @struct "Consumer" Consumer group member (KIP-848).
+ */
+typedef struct rd_kafka_mock_cgrp_consumer_member_s {
+        TAILQ_ENTRY(rd_kafka_mock_cgrp_consumer_member_s) link;
+        char *id;                     /**< MemberId */
+        char *instance_id;            /**< Group instance id */
+        rd_ts_t ts_last_activity;     /**< Last activity, e.g.,
+                                       *   ConsumerGroupHeartbeat */
+        int32_t current_member_epoch; /**< Current member epoch,
+                                       *   updated only on heartbeat. */
+        int32_t
+            target_member_epoch; /**< Target member epoch,
+                                  *   updated only when calling
+                                  *   rd_kafka_mock_cgrp_consumer_target_assignment.
+                                  */
+        rd_kafka_topic_partition_list_t
+            *current_assignment; /**< Current assignment,
+                                  *   only updated when reported by the client.
+                                  */
+        rd_kafka_topic_partition_list_t *
+            target_assignment; /**< Target assignment,
+                                *   only updated when calling
+                                *   rd_kafka_mock_cgrp_consumer_target_assignment.
+                                */
+        rd_kafka_topic_partition_list_t
+            *returned_assignment; /**< Returned assignment */
+
+        rd_list_t *subscribed_topics; /**< Final list of Subscribed topics after
+                                         considering regex as well*/
+        rd_list_t *subscribed_topic_names; /**< Subscribed topic names received
+                                              in the heartbeat */
+        char *subscribed_topic_regex;      /**< Subscribed regex */
+
+        rd_bool_t left_static_membership;        /**< Member left the group
+                                                  *   with static membership. */
+        struct rd_kafka_mock_connection_s *conn; /**< Connection, may be NULL
+                                                  *   if there is no ongoing
+                                                  *   request. */
+        rd_kafka_mock_cgrp_consumer_t *mcgrp;    /**< Consumer group */
+} rd_kafka_mock_cgrp_consumer_member_t;
 
 
 /**
@@ -360,7 +425,9 @@ struct rd_kafka_mock_cluster_s {
         TAILQ_HEAD(, rd_kafka_mock_topic_s) topics;
         int topic_cnt;
 
-        TAILQ_HEAD(, rd_kafka_mock_cgrp_s) cgrps;
+        TAILQ_HEAD(, rd_kafka_mock_cgrp_classic_s) cgrps_classic;
+
+        TAILQ_HEAD(, rd_kafka_mock_cgrp_consumer_s) cgrps_consumer;
 
         /** Explicit coordinators (set with mock_set_coordinator()) */
         TAILQ_HEAD(, rd_kafka_mock_coord_s) coords;
@@ -396,13 +463,17 @@ struct rd_kafka_mock_cluster_s {
                 int replication_factor; /**< Auto topic create repl factor */
                 /** Group initial rebalance delay */
                 int32_t group_initial_rebalance_delay_ms;
+                /** Session timeout (KIP 848) */
+                int group_consumer_session_timeout_ms;
+                /** Heartbeat interval (KIP 848) */
+                int group_consumer_heartbeat_interval_ms;
         } defaults;
 
         /**< Dynamic array of IO handlers for corresponding fd in .fds */
         struct {
                 rd_kafka_mock_io_handler_t *cb; /**< Callback */
                 void *opaque;                   /**< Callbacks' opaque */
-        } * handlers;
+        } *handlers;
 
         /**< Per-protocol request error stack. */
         rd_kafka_mock_error_stack_head_t errstacks;
@@ -538,47 +609,95 @@ rd_kafka_mock_pid_find(rd_kafka_mock_cluster_t *mcluster,
  * @name Mock consumer group (rdkafka_mock_cgrp.c)
  * @{
  */
-void rd_kafka_mock_cgrp_member_active(rd_kafka_mock_cgrp_t *mcgrp,
-                                      rd_kafka_mock_cgrp_member_t *member);
-void rd_kafka_mock_cgrp_member_assignment_set(
-    rd_kafka_mock_cgrp_t *mcgrp,
-    rd_kafka_mock_cgrp_member_t *member,
+void rd_kafka_mock_cgrp_classic_member_active(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member);
+void rd_kafka_mock_cgrp_classic_member_assignment_set(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
     const rd_kafkap_bytes_t *Metadata);
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_sync_set(rd_kafka_mock_cgrp_t *mcgrp,
-                                   rd_kafka_mock_cgrp_member_t *member,
-                                   rd_kafka_mock_connection_t *mconn,
-                                   rd_kafka_buf_t *resp);
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_leave(rd_kafka_mock_cgrp_t *mcgrp,
-                                rd_kafka_mock_cgrp_member_t *member);
-void rd_kafka_mock_cgrp_protos_destroy(rd_kafka_mock_cgrp_proto_t *protos,
-                                       int proto_cnt);
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_add(rd_kafka_mock_cgrp_t *mcgrp,
-                              rd_kafka_mock_connection_t *mconn,
-                              rd_kafka_buf_t *resp,
-                              const rd_kafkap_str_t *MemberId,
-                              const rd_kafkap_str_t *GroupInstanceId,
-                              const rd_kafkap_str_t *ProtocolType,
-                              rd_kafka_mock_cgrp_proto_t *protos,
-                              int proto_cnt,
-                              int session_timeout_ms);
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_check_state(rd_kafka_mock_cgrp_t *mcgrp,
-                               rd_kafka_mock_cgrp_member_t *member,
-                               const rd_kafka_buf_t *request,
-                               int32_t generation_id);
-rd_kafka_mock_cgrp_member_t *
-rd_kafka_mock_cgrp_member_find(const rd_kafka_mock_cgrp_t *mcgrp,
-                               const rd_kafkap_str_t *MemberId);
-void rd_kafka_mock_cgrp_destroy(rd_kafka_mock_cgrp_t *mcgrp);
-rd_kafka_mock_cgrp_t *rd_kafka_mock_cgrp_find(rd_kafka_mock_cluster_t *mcluster,
-                                              const rd_kafkap_str_t *GroupId);
-rd_kafka_mock_cgrp_t *
-rd_kafka_mock_cgrp_get(rd_kafka_mock_cluster_t *mcluster,
-                       const rd_kafkap_str_t *GroupId,
-                       const rd_kafkap_str_t *ProtocolType);
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_sync_set(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
+    rd_kafka_mock_connection_t *mconn,
+    rd_kafka_buf_t *resp);
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_leave(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member);
+void rd_kafka_mock_cgrp_classic_protos_destroy(
+    rd_kafka_mock_cgrp_classic_proto_t *protos,
+    int proto_cnt);
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_add(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_connection_t *mconn,
+    rd_kafka_buf_t *resp,
+    const rd_kafkap_str_t *MemberId,
+    const rd_kafkap_str_t *GroupInstanceId,
+    const rd_kafkap_str_t *ProtocolType,
+    rd_kafka_mock_cgrp_classic_proto_t *protos,
+    int proto_cnt,
+    int session_timeout_ms);
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_check_state(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
+    const rd_kafka_buf_t *request,
+    int32_t generation_id);
+rd_kafka_mock_cgrp_classic_member_t *rd_kafka_mock_cgrp_classic_member_find(
+    const rd_kafka_mock_cgrp_classic_t *mcgrp,
+    const rd_kafkap_str_t *MemberId);
+void rd_kafka_mock_cgrp_classic_destroy(rd_kafka_mock_cgrp_classic_t *mcgrp);
+rd_kafka_mock_cgrp_classic_t *
+rd_kafka_mock_cgrp_classic_find(rd_kafka_mock_cluster_t *mcluster,
+                                const rd_kafkap_str_t *GroupId);
+rd_kafka_mock_cgrp_classic_t *
+rd_kafka_mock_cgrp_classic_get(rd_kafka_mock_cluster_t *mcluster,
+                               const rd_kafkap_str_t *GroupId,
+                               const rd_kafkap_str_t *ProtocolType);
+
+/* "consumer" consumer group (KIP-848) */
+
+rd_kafka_topic_partition_list_t *
+rd_kafka_mock_cgrp_consumer_member_next_assignment(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_kafka_topic_partition_list_t *current_assignment,
+    int *member_epoch);
+
+void rd_kafka_mock_cgrp_consumer_member_active(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member);
+
+void rd_kafka_mock_cgrp_consumer_destroy(rd_kafka_mock_cgrp_consumer_t *mcgrp);
+
+rd_kafka_mock_cgrp_consumer_t *
+rd_kafka_mock_cgrp_consumer_find(const rd_kafka_mock_cluster_t *mcluster,
+                                 const rd_kafkap_str_t *GroupId);
+
+rd_kafka_mock_cgrp_consumer_t *
+rd_kafka_mock_cgrp_consumer_get(rd_kafka_mock_cluster_t *mcluster,
+                                const rd_kafkap_str_t *GroupId);
+
+void rd_kafka_mock_cgrp_consumer_member_leave(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_bool_t static_leave);
+
+void rd_kafka_mock_cgrp_consumer_member_fenced(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member);
+
+rd_kafka_mock_cgrp_consumer_member_t *rd_kafka_mock_cgrp_consumer_member_find(
+    const rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    const rd_kafkap_str_t *MemberId);
+
+rd_kafka_mock_cgrp_consumer_member_t *rd_kafka_mock_cgrp_consumer_member_add(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    struct rd_kafka_mock_connection_s *conn,
+    const rd_kafkap_str_t *MemberId,
+    const rd_kafkap_str_t *InstanceId,
+    rd_kafkap_str_t *SubscribedTopicNames,
+    int32_t SubscribedTopicNamesCnt,
+    const rd_kafkap_str_t *SubscribedTopicRegex);
+
 void rd_kafka_mock_cgrps_connection_closed(rd_kafka_mock_cluster_t *mcluster,
                                            rd_kafka_mock_connection_t *mconn);
 /**

package/deps/librdkafka/src/rdkafka_msg.c

@@ -383,6 +383,7 @@ rd_kafka_produceva(rd_kafka_t *rk, const rd_kafka_vu_t *vus, size_t cnt) {
         rd_kafka_error_t *error      = NULL;
         rd_kafka_headers_t *hdrs     = NULL;
         rd_kafka_headers_t *app_hdrs = NULL; /* App-provided headers list */
+        int existing                 = 0;
         size_t i;
 
         if (unlikely(rd_kafka_check_produce(rk, &error)))
@@ -392,8 +393,11 @@ rd_kafka_produceva(rd_kafka_t *rk, const rd_kafka_vu_t *vus, size_t cnt) {
                 const rd_kafka_vu_t *vu = &vus[i];
                 switch (vu->vtype) {
                 case RD_KAFKA_VTYPE_TOPIC:
-                        rkt =
-                            rd_kafka_topic_new0(rk, vu->u.cstr, NULL, NULL, 1);
+                        rkt = rd_kafka_topic_new0(rk, vu->u.cstr, NULL,
+                                                  &existing, 1);
+                        if (!existing)
+                                rd_kafka_topic_fast_leader_query(
+                                    rk, rd_true /* force */);
                         break;
 
                 case RD_KAFKA_VTYPE_RKT:
@@ -487,6 +491,8 @@ rd_kafka_produceva(rd_kafka_t *rk, const rd_kafka_vu_t *vus, size_t cnt) {
                                            rd_kafka_err2str(err));
                 goto err;
         }
+        /* 'hdrs' is now owned by 'rkm' */
+        hdrs = NULL;
 
         /* Partition the message */
         err = rd_kafka_msg_partitioner(rkt, rkm, 1);
@@ -549,6 +555,7 @@ rd_kafka_resp_err_t rd_kafka_producev(rd_kafka_t *rk, ...) {
         rd_kafka_resp_err_t err;
         rd_kafka_headers_t *hdrs     = NULL;
         rd_kafka_headers_t *app_hdrs = NULL; /* App-provided headers list */
+        int existing                 = 0;
 
         if (unlikely((err = rd_kafka_check_produce(rk, NULL))))
                 return err;
@@ -559,7 +566,10 @@ rd_kafka_resp_err_t rd_kafka_producev(rd_kafka_t *rk, ...) {
                 switch (vtype) {
                 case RD_KAFKA_VTYPE_TOPIC:
                         rkt = rd_kafka_topic_new0(rk, va_arg(ap, const char *),
-                                                  NULL, NULL, 1);
+                                                  NULL, &existing, 1);
+                        if (!existing)
+                                rd_kafka_topic_fast_leader_query(
+                                    rk, rd_true /* force */);
                         break;
 
                 case RD_KAFKA_VTYPE_RKT:
@@ -2528,22 +2538,28 @@ int unittest_msg(void) {
                                            {10, 10},
                                            {33692865, 33692865},
                                            {0, 0}});
-        fails += unittest_msgq_insert_sort(
-            "many messages", insert_baseline, NULL,
-            (const struct ut_msg_range[]) {{100000, 200000},
-                                           {400000, 450000},
-                                           {900000, 920000},
-                                           {33692864, 33751992},
-                                           {33906868, 33993690},
-                                           {40000000, 44000000},
-                                           {0, 0}},
-            (const struct ut_msg_range[]) {{1, 199},
-                                           {350000, 360000},
-                                           {500000, 500010},
-                                           {1000000, 1000200},
-                                           {33751993, 33906867},
-                                           {50000001, 50000001},
-                                           {0, 0}});
+        if (rd_unittest_with_valgrind) {
+                RD_UT_WARN(
+                    "Skipping large message range test "
+                    "when using Valgrind");
+        } else {
+                fails += unittest_msgq_insert_sort(
+                    "many messages", insert_baseline, NULL,
+                    (const struct ut_msg_range[]) {{100000, 200000},
+                                                   {400000, 450000},
+                                                   {900000, 920000},
+                                                   {33692864, 33751992},
+                                                   {33906868, 33993690},
+                                                   {40000000, 44000000},
+                                                   {0, 0}},
+                    (const struct ut_msg_range[]) {{1, 199},
+                                                   {350000, 360000},
+                                                   {500000, 500010},
+                                                   {1000000, 1000200},
+                                                   {33751993, 33906867},
+                                                   {50000001, 50000001},
+                                                   {0, 0}});
+        }
         fails += unittest_msgq_insert_sort(
             "issue #2508", insert_baseline, NULL,
             (const struct ut_msg_range[]) {

package/deps/librdkafka/src/rdkafka_msg.h

@@ -535,9 +535,9 @@ rd_kafka_msgq_overlap(const rd_kafka_msgq_t *a, const rd_kafka_msgq_t *b) {
         la = rd_kafka_msgq_last(a);
         lb = rd_kafka_msgq_last(b);
 
-        return (rd_bool_t)(
-            fa->rkm_u.producer.msgid <= lb->rkm_u.producer.msgid &&
-            fb->rkm_u.producer.msgid <= la->rkm_u.producer.msgid);
+        return (
+            rd_bool_t)(fa->rkm_u.producer.msgid <= lb->rkm_u.producer.msgid &&
+                       fb->rkm_u.producer.msgid <= la->rkm_u.producer.msgid);
 }
 
 /**

package/deps/librdkafka/src/rdkafka_msgset_writer.c

@@ -114,9 +114,9 @@ rd_kafka_msgset_writer_select_MsgVersion(rd_kafka_msgset_writer_t *msetw) {
                 int feature;
                 int16_t ApiVersion;
         } compr_req[RD_KAFKA_COMPRESSION_NUM] = {
-                [RD_KAFKA_COMPRESSION_LZ4] = {RD_KAFKA_FEATURE_LZ4, 0},
+            [RD_KAFKA_COMPRESSION_LZ4] = {RD_KAFKA_FEATURE_LZ4, 0},
 #if WITH_ZSTD
-                [RD_KAFKA_COMPRESSION_ZSTD] = {RD_KAFKA_FEATURE_ZSTD, 7},
+            [RD_KAFKA_COMPRESSION_ZSTD] = {RD_KAFKA_FEATURE_ZSTD, 7},
 #endif
         };
 
@@ -145,12 +145,16 @@ rd_kafka_msgset_writer_select_MsgVersion(rd_kafka_msgset_writer_t *msetw) {
          * by both client and broker, else disable compression.
          */
         if (msetw->msetw_compression &&
-            (rd_kafka_broker_ApiVersion_supported(
-                 rkb, RD_KAFKAP_Produce, 0,
-                 compr_req[msetw->msetw_compression].ApiVersion, NULL) == -1 ||
-             (compr_req[msetw->msetw_compression].feature &&
-              !(msetw->msetw_rkb->rkb_features &
-                compr_req[msetw->msetw_compression].feature)))) {
+            (
+                /* ApiVersion is smaller than the minimum one */
+                !rd_kafka_broker_ApiVersion_at_least(
+                    rkb, RD_KAFKAP_Produce,
+                    compr_req[msetw->msetw_compression].ApiVersion) ||
+                /* There's a corresponding feature and it isn't supported
+                 * by this broker. */
+                (compr_req[msetw->msetw_compression].feature &&
+                 !(msetw->msetw_rkb->rkb_features &
+                   compr_req[msetw->msetw_compression].feature)))) {
                 if (unlikely(
                         rd_interval(&rkb->rkb_suppress.unsupported_compression,
                                     /* at most once per day */
@@ -705,8 +709,8 @@ rd_kafka_msgset_writer_write_msg_v2(rd_kafka_msgset_writer_t *msetw,
                                             sizeof(varint_OffsetDelta), Offset);
         sz_KeyLen   = rd_uvarint_enc_i32(varint_KeyLen, sizeof(varint_KeyLen),
                                        rkm->rkm_key
-                                           ? (int32_t)rkm->rkm_key_len
-                                           : (int32_t)RD_KAFKAP_BYTES_LEN_NULL);
+                                             ? (int32_t)rkm->rkm_key_len
+                                             : (int32_t)RD_KAFKAP_BYTES_LEN_NULL);
         sz_ValueLen = rd_uvarint_enc_i32(
             varint_ValueLen, sizeof(varint_ValueLen),
             rkm->rkm_payload ? (int32_t)rkm->rkm_len

package/deps/librdkafka/src/rdkafka_offset.c

@@ -900,7 +900,21 @@ static void rd_kafka_offset_validate_tmr_cb(rd_kafka_timers_t *rkts,
         rd_kafka_toppar_t *rktp = arg;
 
         rd_kafka_toppar_lock(rktp);
-        rd_kafka_offset_validate(rktp, "retrying offset validation");
+        /* Retry validation only when it's still needed.
+         * Even if validation can be started in fetch states ACTIVE and
+         * VALIDATE_EPOCH_WAIT, its retry should be done only
+         * in fetch state VALIDATE_EPOCH_WAIT. */
+        if (rktp->rktp_fetch_state == RD_KAFKA_TOPPAR_FETCH_VALIDATE_EPOCH_WAIT)
+                rd_kafka_offset_validate(rktp, "retrying offset validation");
+        else {
+                rd_kafka_dbg(rktp->rktp_rkt->rkt_rk, FETCH, "VALIDATE",
+                             "%.*s [%" PRId32
+                             "]: skipping offset "
+                             "validation retry in fetch state %s",
+                             RD_KAFKAP_STR_PR(rktp->rktp_rkt->rkt_topic),
+                             rktp->rktp_partition,
+                             rd_kafka_fetch_states[rktp->rktp_fetch_state]);
+        }
         rd_kafka_toppar_unlock(rktp);
 }
 
@@ -923,6 +937,9 @@ static void rd_kafka_toppar_handle_OffsetForLeaderEpoch(rd_kafka_t *rk,
         rd_kafka_topic_partition_t *rktpar;
         int64_t end_offset;
         int32_t end_offset_leader_epoch;
+        rd_kafka_toppar_lock(rktp);
+        rktp->rktp_flags &= ~RD_KAFKA_TOPPAR_F_VALIDATING;
+        rd_kafka_toppar_unlock(rktp);
 
         if (err == RD_KAFKA_RESP_ERR__DESTROY) {
                 rd_kafka_toppar_destroy(rktp); /* Drop refcnt */
@@ -1142,12 +1159,10 @@ void rd_kafka_offset_validate(rd_kafka_toppar_t *rktp, const char *fmt, ...) {
                 rd_kafka_dbg(rktp->rktp_rkt->rkt_rk, FETCH, "VALIDATE",
                              "%.*s [%" PRId32
                              "]: unable to perform offset "
-                             "validation: partition leader not available",
+                             "validation: partition leader not available. "
+                             "Retrying when available",
                              RD_KAFKAP_STR_PR(rktp->rktp_rkt->rkt_topic),
                              rktp->rktp_partition);
-
-                rd_kafka_toppar_set_fetch_state(rktp,
-                                                RD_KAFKA_TOPPAR_FETCH_ACTIVE);
                 return;
         }
 
@@ -1169,8 +1184,21 @@ void rd_kafka_offset_validate(rd_kafka_toppar_t *rktp, const char *fmt, ...) {
                 return;
         }
 
+        if (rktp->rktp_flags & RD_KAFKA_TOPPAR_F_VALIDATING) {
+                rd_kafka_dbg(
+                    rktp->rktp_rkt->rkt_rk, FETCH, "VALIDATE",
+                    "%.*s [%" PRId32
+                    "]: skipping offset "
+                    "validation for %s: validation is already ongoing",
+                    RD_KAFKAP_STR_PR(rktp->rktp_rkt->rkt_topic),
+                    rktp->rktp_partition,
+                    rd_kafka_fetch_pos2str(rktp->rktp_offset_validation_pos));
+                return;
+        }
+
         rd_kafka_toppar_set_fetch_state(
             rktp, RD_KAFKA_TOPPAR_FETCH_VALIDATE_EPOCH_WAIT);
+        rktp->rktp_flags |= RD_KAFKA_TOPPAR_F_VALIDATING;
 
         /* Construct and send OffsetForLeaderEpochRequest */
         parts  = rd_kafka_topic_partition_list_new(1);

package/deps/librdkafka/src/rdkafka_op.c

@@ -228,7 +228,7 @@ rd_kafka_op_t *rd_kafka_op_new0(const char *source, rd_kafka_op_type_t type) {
             [RD_KAFKA_OP_PARTITION_JOIN]   = _RD_KAFKA_OP_EMPTY,
             [RD_KAFKA_OP_PARTITION_LEAVE]  = _RD_KAFKA_OP_EMPTY,
             [RD_KAFKA_OP_REBALANCE]        = sizeof(rko->rko_u.rebalance),
-            [RD_KAFKA_OP_TERMINATE]        = _RD_KAFKA_OP_EMPTY,
+            [RD_KAFKA_OP_TERMINATE]        = sizeof(rko->rko_u.terminated),
             [RD_KAFKA_OP_COORD_QUERY]      = _RD_KAFKA_OP_EMPTY,
             [RD_KAFKA_OP_SUBSCRIBE]        = sizeof(rko->rko_u.subscribe),
             [RD_KAFKA_OP_ASSIGN]           = sizeof(rko->rko_u.assign),