[KIP-848 EA] Admin API for listing consumer groups now has (#2323)

emasab · mahajanadhitya · web-flow · commit dc5aff25a18f · 2024-10-10T14:48:47.000+02:00
an optional filter to return only groups of given types


Co-authored-by: mahajanadhitya &lt;amahajan@confluent.io&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,12 @@
-# 2.5.3
+# 2.6.0
+
+## Enhancements
 
-v2.5.3 is a maintenance release with the following fixes and enhancements:
+* References librdkafka.redist 2.6.0. Refer to the [librdkafka v2.6.0 release notes](https://github.com/confluentinc/librdkafka/releases/tag/v2.6.0) for more information.
+* [KIP-848 EA](https://cwiki.apache.org/confluence/display/KAFKA/KIP-848%3A+The+Next+Generation+of+the+Consumer+Rebalance+Protocol): Admin API for listing consumer groups now has an optional filter to return only groups of given types (#2323).
+
+
+# 2.5.3
 
 ## Enhancements
 
diff --git a/examples/AdminClient/Program.cs b/examples/AdminClient/Program.cs
@@ -313,6 +313,86 @@ static Tuple<IsolationLevel, List<TopicPartitionOffsetSpec>> ParseListOffsetsArg
             return Tuple.Create(isolationLevel, topicPartitionOffsetSpecs);
         }
 
+        static bool ParseListConsumerGroupsArgs(string[] commandArgs,
+            ref TimeSpan timeout,
+            ref List<ConsumerGroupState> states,
+            ref List<ConsumerGroupType> types,
+            ref string error)
+        {
+            try
+            {
+                var typeArray = false;
+                var stateArray = false;
+                var lastArray = 0;
+                for (var i = 0; i < commandArgs.Length; i++)
+                {
+                    var commandArg = commandArgs[i];
+                    if (commandArg == "-states")
+                    {
+                        if (stateArray)
+                        {
+                            error = "Cannot pass the states flag (-states) more than once";
+                            return false;
+                        }
+                        stateArray = true;
+                        lastArray = 1;
+                    }
+                    else if (commandArg == "-types")
+                    {
+                        if (typeArray)
+                        {
+                            error = "Cannot pass the types flag (-types) more than once";
+                            return false;
+                        }
+                        typeArray = true;
+                        lastArray = 2;
+                    }
+                    else
+                    {
+                        if (lastArray == 1)
+                        {
+                            try
+                            {
+                                states.Add(Enum.Parse<ConsumerGroupState>(commandArg));
+                            }
+                            catch (Exception)
+                            {
+                                error = $"Invalid state: {commandArg}";
+                                return false;
+                            }
+                        }
+                        else if (lastArray == 2)
+                        {
+                            try
+                            {
+                                types.Add(Enum.Parse<ConsumerGroupType>(commandArg));
+                            }
+                            catch (Exception)
+                            {
+                                 error = $"Invalid type: {commandArg}";
+                                 return false;
+                            }
+                        }
+                        else if (i == 0)
+                        {
+                            timeout = TimeSpan.FromSeconds(int.Parse(commandArg));
+                        }
+                        else
+                        {
+                            error = $"Unknown argument: {commandArg}";
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            catch (SystemException e)
+            {
+                error = e.Message;
+                return false;
+            }
+        }
+
        static void PrintListOffsetsResultInfos(List<ListOffsetsResultInfo> ListOffsetsResultInfos)
        {
             foreach(var listOffsetsResultInfo in ListOffsetsResultInfos)
@@ -581,24 +661,15 @@ static async Task ListConsumerGroupOffsetsAsync(string bootstrapServers, string[
         static async Task ListConsumerGroupsAsync(string bootstrapServers, string[] commandArgs)
         {
             var timeout = TimeSpan.FromSeconds(30);
-            var statesList = new List<ConsumerGroupState>();
-            try
-            {
-                if (commandArgs.Length > 0)
-                {
-                    timeout = TimeSpan.FromSeconds(Int32.Parse(commandArgs[0]));
-                }
-                if (commandArgs.Length > 1)
-                {
-                    for (int i = 1; i < commandArgs.Length; i++)
-                    {
-                        statesList.Add(Enum.Parse<ConsumerGroupState>(commandArgs[i]));
-                    }
-                }
-            }
-            catch (SystemException)
+            string error = "";
+            var states = new List<ConsumerGroupState>();
+            var types = new List<ConsumerGroupType>();
+
+            if (!ParseListConsumerGroupsArgs(commandArgs,
+                ref timeout,  ref states, ref types, ref error))
             {
-                Console.WriteLine("usage: .. <bootstrapServers> list-consumer-groups [<timeout_seconds> <match_state_1> <match_state_2> ... <match_state_N>]");
+                Console.WriteLine(error);
+                Console.WriteLine("usage: .. <bootstrapServers> list-consumer-groups [timeout] [-states <match_state_1> .. <match_state_N>] [-types <match_type_1> .. <match_type_M>]");
                 Environment.ExitCode = 1;
                 return;
             }
@@ -610,7 +681,8 @@ static async Task ListConsumerGroupsAsync(string bootstrapServers, string[] comm
                     var result = await adminClient.ListConsumerGroupsAsync(new ListConsumerGroupsOptions()
                     { 
                         RequestTimeout = timeout,
-                        MatchStates = statesList,
+                        MatchStates = states,
+                        MatchTypes = types,
                     });
                     Console.WriteLine(result);
                 }
diff --git a/src/Confluent.Kafka/Admin/ConsumerGroupListing.cs b/src/Confluent.Kafka/Admin/ConsumerGroupListing.cs
@@ -32,6 +32,11 @@ public class ConsumerGroupListing
         /// </summary>
         public ConsumerGroupState State { get; set; }
 
+        /// <summary>
+        ///     The type of the consumer group.
+        /// </summary>
+        public ConsumerGroupType Type { get; set; }
+
         /// <summary>
         ///     Whether the consumer group is simple or not.
         /// </summary>
@@ -42,7 +47,7 @@ public class ConsumerGroupListing
         /// </summary>
         public override string ToString()
         {
-            return $"{GroupId}, State = {State}, IsSimpleConsumerGroup = {IsSimpleConsumerGroup}";
+            return $"{GroupId}, State = {State}, Type = {Type}, IsSimpleConsumerGroup = {IsSimpleConsumerGroup}";
         }
     }
 }
diff --git a/src/Confluent.Kafka/Admin/ListConsumerGroupsOptions.cs b/src/Confluent.Kafka/Admin/ListConsumerGroupsOptions.cs
@@ -41,5 +41,13 @@ public class ListConsumerGroupsOptions
         ///     Default: null
         /// </summary>
         public IEnumerable<ConsumerGroupState> MatchStates { get; set; } = null;
+
+        /// <summary>
+        ///      An enumerable with the types to query, null to query for all
+        ///      the types.
+        ///
+        ///     Default: null
+        /// </summary>
+        public IEnumerable<ConsumerGroupType> MatchTypes { get; set; } = null;
     }
 }
diff --git a/src/Confluent.Kafka/AdminClient.cs b/src/Confluent.Kafka/AdminClient.cs
@@ -282,6 +282,7 @@ private ListConsumerGroupsReport extractListConsumerGroupsResults(IntPtr resultP
                         IsSimpleConsumerGroup =
                             (int)Librdkafka.ConsumerGroupListing_is_simple_consumer_group(cglPtr) == 1,
                         State = Librdkafka.ConsumerGroupListing_state(cglPtr),
+                        Type = Librdkafka.ConsumerGroupListing_type(cglPtr),
                     };
                 }).ToList();
             }
diff --git a/src/Confluent.Kafka/ConsumerGroupType.cs b/src/Confluent.Kafka/ConsumerGroupType.cs
@@ -0,0 +1,40 @@
+// Copyright 2024 Confluent Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Refer to LICENSE for more information.
+
+
+namespace Confluent.Kafka
+{
+    /// <summary>
+    ///     Enumerates the different consumer group types.
+    /// </summary>
+    public enum ConsumerGroupType : int
+    {
+        /// <summary>
+        ///     Unknown type
+        /// </summary>
+        Unknown = 0,
+
+        /// <summary>
+        ///     Consumer type (KIP-848)
+        /// </summary>
+        Consumer = 1,
+
+        /// <summary>
+        ///     Classic type
+        /// </summary>
+        Classic = 2,
+    };
+}
diff --git a/src/Confluent.Kafka/Impl/LibRdKafka.cs b/src/Confluent.Kafka/Impl/LibRdKafka.cs
@@ -299,7 +299,8 @@ static bool SetDelegates(Type nativeMethodsClass)
             _AdminOptions_set_opaque = (Action<IntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_opaque").CreateDelegate(typeof(Action<IntPtr, IntPtr>));
             _AdminOptions_set_require_stable_offsets = (Func<IntPtr, IntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_require_stable_offsets").CreateDelegate(typeof(Func<IntPtr, IntPtr, IntPtr>));
             _AdminOptions_set_include_authorized_operations = (Func<IntPtr, IntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_include_authorized_operations").CreateDelegate(typeof(Func<IntPtr, IntPtr, IntPtr>));
-            _AdminOptions_set_match_consumer_group_states = (Func<IntPtr, ConsumerGroupState[], UIntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_match_consumer_group_states").CreateDelegate(typeof(Func<IntPtr, ConsumerGroupState[], UIntPtr, IntPtr>));
+            _AdminOptions_set_match_consumer_group_states = (AdminOptions_set_match_consumer_group_states_delegate)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_match_consumer_group_states").CreateDelegate(typeof(AdminOptions_set_match_consumer_group_states_delegate));
+            _AdminOptions_set_match_consumer_group_types = (AdminOptions_set_match_consumer_group_types_delegate)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_match_consumer_group_types").CreateDelegate(typeof(AdminOptions_set_match_consumer_group_types_delegate));
             _AdminOptions_set_isolation_level = (Func<IntPtr, IntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_AdminOptions_set_isolation_level").CreateDelegate(typeof(Func<IntPtr, IntPtr, IntPtr>));
 
             _NewTopic_new = (Func<string, IntPtr, IntPtr, StringBuilder, UIntPtr, IntPtr>)methods.Single(m => m.Name == "rd_kafka_NewTopic_new").CreateDelegate(typeof(Func<string, IntPtr, IntPtr, StringBuilder, UIntPtr, IntPtr>));
@@ -410,6 +411,7 @@ static bool SetDelegates(Type nativeMethodsClass)
             _ConsumerGroupListing_group_id = (_ConsumerGroupListing_group_id_delegate)methods.Single(m => m.Name == "rd_kafka_ConsumerGroupListing_group_id").CreateDelegate(typeof (_ConsumerGroupListing_group_id_delegate));
             _ConsumerGroupListing_is_simple_consumer_group = (_ConsumerGroupListing_is_simple_consumer_group_delegate)methods.Single(m => m.Name == "rd_kafka_ConsumerGroupListing_is_simple_consumer_group").CreateDelegate(typeof (_ConsumerGroupListing_is_simple_consumer_group_delegate));
             _ConsumerGroupListing_state = (_ConsumerGroupListing_state_delegate)methods.Single(m => m.Name == "rd_kafka_ConsumerGroupListing_state").CreateDelegate(typeof (_ConsumerGroupListing_state_delegate));
+            _ConsumerGroupListing_type = (_ConsumerGroupListing_type_delegate)methods.Single(m => m.Name == "rd_kafka_ConsumerGroupListing_type").CreateDelegate(typeof (_ConsumerGroupListing_type_delegate));
             _ListConsumerGroups_result_valid = (_ListConsumerGroups_result_valid_delegate)methods.Single(m => m.Name == "rd_kafka_ListConsumerGroups_result_valid").CreateDelegate(typeof (_ListConsumerGroups_result_valid_delegate));
             _ListConsumerGroups_result_errors = (_ListConsumerGroups_result_errors_delegate)methods.Single(m => m.Name == "rd_kafka_ListConsumerGroups_result_errors").CreateDelegate(typeof (_ListConsumerGroups_result_errors_delegate));
 
@@ -1336,10 +1338,16 @@ internal static IntPtr AdminOptions_set_include_authorized_operations(
             IntPtr options,
             IntPtr true_or_false) => _AdminOptions_set_include_authorized_operations(options, true_or_false);
 
-        private static Func<IntPtr, ConsumerGroupState[], UIntPtr, IntPtr> _AdminOptions_set_match_consumer_group_states;
+        private delegate IntPtr AdminOptions_set_match_consumer_group_states_delegate(IntPtr options, ConsumerGroupState[] states, UIntPtr statesCnt);
+        private static AdminOptions_set_match_consumer_group_states_delegate _AdminOptions_set_match_consumer_group_states;
         internal static IntPtr AdminOptions_set_match_consumer_group_states(IntPtr options, ConsumerGroupState[] states, UIntPtr statesCnt)
             => _AdminOptions_set_match_consumer_group_states(options, states, statesCnt);
 
+        private delegate IntPtr AdminOptions_set_match_consumer_group_types_delegate(IntPtr options, ConsumerGroupType[] types, UIntPtr typesCnt);
+        private static AdminOptions_set_match_consumer_group_types_delegate _AdminOptions_set_match_consumer_group_types;
+        internal static IntPtr AdminOptions_set_match_consumer_group_types(IntPtr options, ConsumerGroupType[] types, UIntPtr typesCnt)
+            => _AdminOptions_set_match_consumer_group_types(options, types, typesCnt);
+
         private static Func<IntPtr, IntPtr, IntPtr> _AdminOptions_set_isolation_level;
         internal static IntPtr AdminOptions_set_isolation_level(IntPtr options, IntPtr IsolationLevel)
             => _AdminOptions_set_isolation_level(options, IsolationLevel);
@@ -1883,6 +1891,11 @@ internal static IntPtr  ConsumerGroupListing_is_simple_consumer_group(IntPtr grp
          internal static ConsumerGroupState  ConsumerGroupListing_state(IntPtr grplist)
             => _ConsumerGroupListing_state(grplist);
 
+         private delegate ConsumerGroupType _ConsumerGroupListing_type_delegate(IntPtr grplist);
+         private static _ConsumerGroupListing_type_delegate _ConsumerGroupListing_type;
+         internal static ConsumerGroupType  ConsumerGroupListing_type(IntPtr grplist)
+            => _ConsumerGroupListing_type(grplist);
+
          private delegate IntPtr  _ListConsumerGroups_result_valid_delegate(IntPtr result, out UIntPtr cntp);
          private static _ListConsumerGroups_result_valid_delegate _ListConsumerGroups_result_valid;
          internal static IntPtr  ListConsumerGroups_result_valid(IntPtr result, out UIntPtr cntp)
diff --git a/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods.cs b/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods.cs
@@ -564,6 +564,12 @@ internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_sta
                         ConsumerGroupState[] states,
                         UIntPtr statesCnt);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_types(
+                        IntPtr options,
+                        ConsumerGroupType[] types,
+                        UIntPtr typesCnt);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_NewTopic_new(
                         [MarshalAs(UnmanagedType.LPStr)] string topic,
@@ -1032,6 +1038,9 @@ internal static extern void rd_kafka_ListConsumerGroups(
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern ConsumerGroupState rd_kafka_ConsumerGroupListing_state(IntPtr grplist);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern ConsumerGroupType rd_kafka_ConsumerGroupListing_type(IntPtr grplist);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_ListConsumerGroups_result_valid(IntPtr result, out UIntPtr cntp);
 
diff --git a/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods_Alpine.cs b/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods_Alpine.cs
@@ -568,6 +568,12 @@ internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_sta
                         ConsumerGroupState[] states,
                         UIntPtr statesCnt);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_types(
+                        IntPtr options,
+                        ConsumerGroupType[] types,
+                        UIntPtr typesCnt);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_NewTopic_new(
                         [MarshalAs(UnmanagedType.LPStr)] string topic,
@@ -1036,6 +1042,9 @@ internal static extern void rd_kafka_ListConsumerGroups(
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern ConsumerGroupState rd_kafka_ConsumerGroupListing_state(IntPtr grplist);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern ConsumerGroupType rd_kafka_ConsumerGroupListing_type(IntPtr grplist);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_ListConsumerGroups_result_valid(IntPtr result, out UIntPtr cntp);
 
diff --git a/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods_Centos8.cs b/src/Confluent.Kafka/Impl/NativeMethods/NativeMethods_Centos8.cs
@@ -568,6 +568,12 @@ internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_sta
                         ConsumerGroupState[] states,
                         UIntPtr statesCnt);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr rd_kafka_AdminOptions_set_match_consumer_group_types(
+                        IntPtr options,
+                        ConsumerGroupType[] types,
+                        UIntPtr typesCnt);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_NewTopic_new(
                         [MarshalAs(UnmanagedType.LPStr)] string topic,
@@ -1036,6 +1042,9 @@ internal static extern void rd_kafka_ListConsumerGroups(
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern ConsumerGroupState rd_kafka_ConsumerGroupListing_state(IntPtr grplist);
 
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern ConsumerGroupType rd_kafka_ConsumerGroupListing_type(IntPtr grplist);
+
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr rd_kafka_ListConsumerGroups_result_valid(IntPtr result, out UIntPtr cntp);
 
diff --git a/src/Confluent.Kafka/Impl/SafeKafkaHandle.cs b/src/Confluent.Kafka/Impl/SafeKafkaHandle.cs
@@ -1472,6 +1472,15 @@ private void setOption_MatchConsumerGroupStates(IntPtr optionsPtr, ConsumerGroup
             }
         }
 
+        private void setOption_MatchConsumerGroupTypes(IntPtr optionsPtr, ConsumerGroupType[] types)
+        {
+            var error = Librdkafka.AdminOptions_set_match_consumer_group_types(optionsPtr, types, (UIntPtr)types.Count());
+            if (error != IntPtr.Zero)
+            {
+                throw new KafkaException(new Error(error, true));
+            }
+        }
+
         private void setOption_IsolationLevel(IntPtr optionsPtr, IsolationLevel IsolationLevel)
         {
             var rError = Librdkafka.AdminOptions_set_isolation_level(optionsPtr, (IntPtr)(int)IsolationLevel);
@@ -2337,6 +2346,10 @@ internal void ListConsumerGroups(
                 {
                     setOption_MatchConsumerGroupStates(optionsPtr, options.MatchStates.ToArray());
                 }
+                if (options.MatchTypes != null)
+                {
+                    setOption_MatchConsumerGroupTypes(optionsPtr, options.MatchTypes.ToArray());
+                }
                 setOption_completionSource(optionsPtr, completionSourcePtr);
 
                 // Call ListConsumerGroups (async).
diff --git a/test/Confluent.Kafka.IntegrationTests/Tests/AdminClient_ListConsumerGroups.cs b/test/Confluent.Kafka.IntegrationTests/Tests/AdminClient_ListConsumerGroups.cs

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,11 @@ public class ConsumerGroupListing`
`32`	`32`	`/// </summary>`
`33`	`33`	`public ConsumerGroupState State { get; set; }`
`34`	`34`
	`35`	`+ /// <summary>`
	`36`	`+ /// The type of the consumer group.`
	`37`	`+ /// </summary>`
	`38`	`+ public ConsumerGroupType Type { get; set; }`
	`39`	`+`
`35`	`40`	`/// <summary>`
`36`	`41`	`/// Whether the consumer group is simple or not.`
`37`	`42`	`/// </summary>`
`@@ -42,7 +47,7 @@ public class ConsumerGroupListing`
`42`	`47`	`/// </summary>`
`43`	`48`	`public override string ToString()`
`44`	`49`	`{`
`45`		`- return $"{GroupId}, State = {State}, IsSimpleConsumerGroup = {IsSimpleConsumerGroup}";`
	`50`	`+ return $"{GroupId}, State = {State}, Type = {Type}, IsSimpleConsumerGroup = {IsSimpleConsumerGroup}";`
`46`	`51`	`}`
`47`	`52`	`}`
`48`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,5 +41,13 @@ public class ListConsumerGroupsOptions`
`41`	`41`	`/// Default: null`
`42`	`42`	`/// </summary>`
`43`	`43`	`public IEnumerable<ConsumerGroupState> MatchStates { get; set; } = null;`
	`44`	`+`
	`45`	`+ /// <summary>`
	`46`	`+ /// An enumerable with the types to query, null to query for all`
	`47`	`+ /// the types.`
	`48`	`+ ///`
	`49`	`+ /// Default: null`
	`50`	`+ /// </summary>`
	`51`	`+ public IEnumerable<ConsumerGroupType> MatchTypes { get; set; } = null;`
`44`	`52`	`}`
`45`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,6 +282,7 @@ private ListConsumerGroupsReport extractListConsumerGroupsResults(IntPtr resultP`
`282`	`282`	`IsSimpleConsumerGroup =`
`283`	`283`	`(int)Librdkafka.ConsumerGroupListing_is_simple_consumer_group(cglPtr) == 1,`
`284`	`284`	`State = Librdkafka.ConsumerGroupListing_state(cglPtr),`
	`285`	`+ Type = Librdkafka.ConsumerGroupListing_type(cglPtr),`
`285`	`286`	`};`
`286`	`287`	`}).ToList();`
`287`	`288`	`}`