karafka-rdkafka 0.30.1-aarch64-linux-gnu → 0.31.0-aarch64-linux-gnu

data/lib/rdkafka/admin.rb

@@ -520,6 +520,231 @@ module Rdkafka
       handle
     end
 
+    # Describes the cluster: its id, the current controller and the broker nodes (with racks).
+    #
+    # Unlike {#metadata}, this does not fetch any topic metadata.
+    #
+    # @param include_authorized_operations [Boolean] when true, also return the operations this
+    #   client is authorized to perform on the cluster
+    # @return [DescribeClusterHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when describing the cluster fails
+    #
+    # @example Print the cluster id, the controller and every broker
+    #   report = admin.describe_cluster.wait(max_wait_timeout_ms: 15_000)
+    #
+    #   puts "cluster: #{report.cluster_id}, controller: #{report.controller[:id]}"
+    #   report.nodes.each do |node|
+    #     puts "#{node[:id]} #{node[:host]}:#{node[:port]} #{node[:rack]}"
+    #   end
+    def describe_cluster(include_authorized_operations: false)
+      closed_admin_check(__method__)
+
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      handle = DescribeClusterHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      DescribeClusterHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+          inner,
+          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DESCRIBECLUSTER
+        )
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        set_include_authorized_operations(admin_options_ptr) if include_authorized_operations
+
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_DescribeCluster(
+            inner,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        DescribeClusterHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+      end
+
+      handle
+    end
+
+    # Describes the given topics: their topic ids, partitions (leader, replicas and in-sync
+    # replicas, with racks) and, optionally, the operations this client is authorized to perform.
+    #
+    # A topic that cannot be described (e.g. it does not exist) does not fail the whole request;
+    # its entry in the report carries an `:error` instead.
+    #
+    # @param topic_names [Array<String>] names of the topics to describe
+    # @param include_authorized_operations [Boolean] when true, also return the operations this
+    #   client is authorized to perform on each topic
+    # @return [DescribeTopicsHandle] handle that can be used to wait for the result
+    # @raise [ArgumentError] when topic_names is not an Array of Strings
+    # @raise [RdkafkaError] when describing the topics fails
+    #
+    # @example Print the topic id and partition leaders of a topic
+    #   report = admin.describe_topics(["events"]).wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.topics.each do |topic|
+    #     next warn("#{topic[:name]}: #{topic[:error].message}") if topic[:error]
+    #
+    #     puts "#{topic[:name]} (#{topic[:topic_id]})"
+    #     topic[:partitions].each do |partition|
+    #       puts "  #{partition[:partition]} -> #{partition[:leader]&.fetch(:id)}"
+    #     end
+    #   end
+    def describe_topics(topic_names, include_authorized_operations: false)
+      closed_admin_check(__method__)
+
+      unless topic_names.is_a?(Array) && topic_names.all?(String)
+        raise ArgumentError, "topic_names must be an Array of Strings"
+      end
+
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      handle = DescribeTopicsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      DescribeTopicsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+          inner,
+          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DESCRIBETOPICS
+        )
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      topic_collection_ptr = nil
+
+      begin
+        set_include_authorized_operations(admin_options_ptr) if include_authorized_operations
+
+        # librdkafka copies the names, so the Ruby-owned strings only need to outlive this call
+        name_ptrs = topic_names.map { |name| FFI::MemoryPointer.from_string(name) }
+        names_array_ptr = FFI::MemoryPointer.new(:pointer, [name_ptrs.size, 1].max)
+        names_array_ptr.write_array_of_pointer(name_ptrs)
+
+        topic_collection_ptr = Rdkafka::Bindings.rd_kafka_TopicCollection_of_topic_names(
+          names_array_ptr,
+          name_ptrs.size
+        )
+
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_DescribeTopics(
+            inner,
+            topic_collection_ptr,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        DescribeTopicsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_TopicCollection_destroy(topic_collection_ptr) if topic_collection_ptr
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+      end
+
+      handle
+    end
+
+    # Describes the given consumer groups: their state, partition assignor, coordinator and
+    # members with their partition assignments.
+    #
+    # Each requested group is reported separately, with its own `:error`. A group id the cluster
+    # does not know is not an error: it is reported in the `Dead` state with no members.
+    #
+    # @param group_ids [Array<String>] ids of the consumer groups to describe
+    # @param include_authorized_operations [Boolean] whether to also fetch the ACL operations the
+    #   client is authorized to perform on each group (reported as `:authorized_operations`)
+    # @return [DescribeConsumerGroupsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when describing the consumer groups fails as a whole
+    #
+    # @example Describe a consumer group and print its members and their assignments
+    #   report = admin.describe_consumer_groups(["example-group"]).wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.groups.each do |group|
+    #     next warn "#{group[:group_id]}: #{group[:error].message}" if group[:error]
+    #
+    #     puts "#{group[:group_id]} - #{group[:state_name]} (#{group[:members].size} members)"
+    #
+    #     group[:members].each do |member|
+    #       puts "  #{member[:client_id]}@#{member[:host]}: #{member[:assignment]}"
+    #     end
+    #   end
+    def describe_consumer_groups(group_ids, include_authorized_operations: false)
+      closed_admin_check(__method__)
+
+      group_id_ptrs = group_ids.map { |group_id| FFI::MemoryPointer.from_string(group_id) }
+      group_ids_ptr = FFI::MemoryPointer.new(:pointer, group_id_ptrs.size)
+      group_ids_ptr.write_array_of_pointer(group_id_ptrs)
+
+      # Get a pointer to the queue that our request will be enqueued on
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      # Create and register the handle we will return to the caller
+      handle = DescribeConsumerGroupsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      DescribeConsumerGroupsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+          inner,
+          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DESCRIBECONSUMERGROUPS
+        )
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        set_include_authorized_operations(admin_options_ptr) if include_authorized_operations
+
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_DescribeConsumerGroups(
+            inner,
+            group_ids_ptr,
+            group_id_ptrs.size,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        DescribeConsumerGroupsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+      end
+
+      handle
+    end
+
     # Deletes the named topic
     #
     # @param topic_name [String] name of the topic to delete
@@ -1254,6 +1479,26 @@ module Rdkafka
       handle
     end
 
+    # Asks librdkafka to include authorized operations in a describe result
+    # @param admin_options_ptr [FFI::Pointer] the admin options to update
+    # @raise [RdkafkaError] when librdkafka rejects the option
+    def set_include_authorized_operations(admin_options_ptr)
+      error_ptr = Rdkafka::Bindings.rd_kafka_AdminOptions_set_include_authorized_operations(admin_options_ptr, 1)
+
+      return if error_ptr.null?
+
+      begin
+        string_ptr = Rdkafka::Bindings.rd_kafka_error_string(error_ptr)
+
+        raise RdkafkaError.new(
+          Rdkafka::Bindings.rd_kafka_error_code(error_ptr),
+          broker_message: string_ptr.null? ? nil : string_ptr.read_string
+        )
+      ensure
+        Rdkafka::Bindings.rd_kafka_error_destroy(error_ptr)
+      end
+    end
+
     # Checks if the admin is closed and raises an error if so
     # @param method [Symbol] name of the calling method for error context
     # @raise [ClosedAdminError] when the admin is closed

data/lib/rdkafka/bindings/admin/acls.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Bindings
+    # Create Acls
+    RD_KAFKA_ADMIN_OP_CREATEACLS = 9
+    RD_KAFKA_EVENT_CREATEACLS_RESULT = 1024
+
+    attach_function :rd_kafka_CreateAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
+    attach_function :rd_kafka_event_CreateAcls_result, [:pointer], :pointer
+    attach_function :rd_kafka_CreateAcls_result_acls, [:pointer, :pointer], :pointer
+
+    # Delete Acls
+    RD_KAFKA_ADMIN_OP_DELETEACLS = 11
+    RD_KAFKA_EVENT_DELETEACLS_RESULT = 4096
+
+    attach_function :rd_kafka_DeleteAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
+    attach_function :rd_kafka_event_DeleteAcls_result, [:pointer], :pointer
+    attach_function :rd_kafka_DeleteAcls_result_responses, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_DeleteAcls_result_response_error, [:pointer], :pointer
+    attach_function :rd_kafka_DeleteAcls_result_response_matching_acls, [:pointer, :pointer], :pointer
+
+    # Describe Acls
+    RD_KAFKA_ADMIN_OP_DESCRIBEACLS = 10
+    RD_KAFKA_EVENT_DESCRIBEACLS_RESULT = 2048
+
+    attach_function :rd_kafka_DescribeAcls, [:pointer, :pointer, :pointer, :pointer], :void
+    attach_function :rd_kafka_event_DescribeAcls_result, [:pointer], :pointer
+    attach_function :rd_kafka_DescribeAcls_result_acls, [:pointer, :pointer], :pointer
+
+    # Acl Bindings
+
+    attach_function :rd_kafka_AclBinding_restype, [:pointer], :int32
+    attach_function :rd_kafka_AclBinding_name, [:pointer], :pointer
+    attach_function :rd_kafka_AclBinding_resource_pattern_type, [:pointer], :int32
+    attach_function :rd_kafka_AclBinding_principal, [:pointer], :pointer
+    attach_function :rd_kafka_AclBinding_host, [:pointer], :pointer
+    attach_function :rd_kafka_AclBinding_operation, [:pointer], :int32
+    attach_function :rd_kafka_AclBinding_permission_type, [:pointer], :int32
+    attach_function :rd_kafka_AclBinding_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t], :pointer
+    attach_function :rd_kafka_AclBindingFilter_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t], :pointer
+    attach_function :rd_kafka_AclBinding_destroy, [:pointer], :void
+
+    # rd_kafka_ResourceType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L7307
+    RD_KAFKA_RESOURCE_ANY = 1
+    RD_KAFKA_RESOURCE_TOPIC = 2
+    RD_KAFKA_RESOURCE_GROUP = 3
+    RD_KAFKA_RESOURCE_BROKER = 4
+    RD_KAFKA_RESOURCE_TRANSACTIONAL_ID = 5
+
+    # rd_kafka_ResourcePatternType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L7320
+    RD_KAFKA_RESOURCE_PATTERN_UNKNOWN = 0
+    RD_KAFKA_RESOURCE_PATTERN_ANY = 1
+    RD_KAFKA_RESOURCE_PATTERN_MATCH = 2
+    RD_KAFKA_RESOURCE_PATTERN_LITERAL = 3
+    RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
+
+    # rd_kafka_AclOperation_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L8403
+    RD_KAFKA_ACL_OPERATION_ANY = 1
+    RD_KAFKA_ACL_OPERATION_ALL = 2
+    RD_KAFKA_ACL_OPERATION_READ = 3
+    RD_KAFKA_ACL_OPERATION_WRITE = 4
+    RD_KAFKA_ACL_OPERATION_CREATE = 5
+    RD_KAFKA_ACL_OPERATION_DELETE = 6
+    RD_KAFKA_ACL_OPERATION_ALTER = 7
+    RD_KAFKA_ACL_OPERATION_DESCRIBE = 8
+    RD_KAFKA_ACL_OPERATION_CLUSTER_ACTION = 9
+    RD_KAFKA_ACL_OPERATION_DESCRIBE_CONFIGS = 10
+    RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS = 11
+    RD_KAFKA_ACL_OPERATION_IDEMPOTENT_WRITE = 12
+
+    # rd_kafka_AclPermissionType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L8435
+    RD_KAFKA_ACL_PERMISSION_TYPE_ANY = 1
+    RD_KAFKA_ACL_PERMISSION_TYPE_DENY = 2
+    RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
+
+    # Extracting error details from Acl results
+    attach_function :rd_kafka_acl_result_error, [:pointer], :pointer
+    attach_function :rd_kafka_AclBinding_error, [:pointer], :pointer
+  end
+end

data/lib/rdkafka/bindings/admin/configs.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Bindings
+    attach_function :rd_kafka_DescribeConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_ConfigResource_new, [:int32, :pointer], :pointer
+    attach_function :rd_kafka_ConfigResource_destroy, [:pointer], :void
+    attach_function :rd_kafka_ConfigResource_destroy_array, [:pointer, :int32], :void
+    attach_function :rd_kafka_event_DescribeConfigs_result, [:pointer], :pointer
+    attach_function :rd_kafka_DescribeConfigs_result_resources, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_ConfigResource_configs, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_ConfigEntry_name, [:pointer], :string
+    attach_function :rd_kafka_ConfigEntry_value, [:pointer], :string
+    attach_function :rd_kafka_ConfigEntry_is_read_only, [:pointer], :int
+    attach_function :rd_kafka_ConfigEntry_is_default, [:pointer], :int
+    attach_function :rd_kafka_ConfigEntry_is_sensitive, [:pointer], :int
+    attach_function :rd_kafka_ConfigEntry_is_synonym, [:pointer], :int
+    attach_function :rd_kafka_ConfigEntry_synonyms, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_ConfigResource_error, [:pointer], :int
+    attach_function :rd_kafka_ConfigResource_error_string, [:pointer], :string
+    attach_function :rd_kafka_IncrementalAlterConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_IncrementalAlterConfigs_result_resources, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_ConfigResource_add_incremental_config, [:pointer, :string, :int32, :string], :pointer
+    attach_function :rd_kafka_event_IncrementalAlterConfigs_result, [:pointer], :pointer
+
+    RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS = 5
+    RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT = 104
+
+    RD_KAFKA_ADMIN_OP_INCREMENTALALTERCONFIGS = 16
+    RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT = 131072
+
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_SET = 0
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_DELETE = 1
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_APPEND = 2
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_SUBTRACT = 3
+  end
+end

data/lib/rdkafka/bindings/admin/list_offsets.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Bindings
+    # List Offsets
+    RD_KAFKA_ADMIN_OP_LISTOFFSETS = 21
+    RD_KAFKA_EVENT_LISTOFFSETS_RESULT = 0x400000
+
+    # rd_kafka_IsolationLevel_t
+    RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED = 0
+    RD_KAFKA_ISOLATION_LEVEL_READ_COMMITTED = 1
+
+    # rd_kafka_OffsetSpec_t
+    RD_KAFKA_OFFSET_SPEC_MAX_TIMESTAMP = -3
+    RD_KAFKA_OFFSET_SPEC_EARLIEST = -2
+    RD_KAFKA_OFFSET_SPEC_LATEST = -1
+
+    attach_function :rd_kafka_ListOffsets, [:pointer, :pointer, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_ListOffsets_result, [:pointer], :pointer
+    attach_function :rd_kafka_ListOffsets_result_infos, [:pointer, :pointer], :pointer
+    attach_function :rd_kafka_ListOffsetsResultInfo_topic_partition, [:pointer], :pointer
+    attach_function :rd_kafka_ListOffsetsResultInfo_timestamp, [:pointer], :int64
+    attach_function :rd_kafka_AdminOptions_set_isolation_level, [:pointer, :int], :pointer
+    attach_function :rd_kafka_topic_partition_get_leader_epoch, [:pointer], :int32
+  end
+end

data/lib/rdkafka/bindings/admin.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Bindings
+    # Create Topics
+    RD_KAFKA_ADMIN_OP_CREATETOPICS = 1   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_CREATETOPICS_RESULT = 100 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_CreateTopics, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_NewTopic_new, [:pointer, :size_t, :size_t, :pointer, :size_t], :pointer, blocking: true
+    attach_function :rd_kafka_NewTopic_set_config, [:pointer, :string, :string], :int32, blocking: true
+    attach_function :rd_kafka_NewTopic_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_CreateTopics_result, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_CreateTopics_result_topics, [:pointer, :pointer], :pointer, blocking: true
+
+    # Delete Topics
+    RD_KAFKA_ADMIN_OP_DELETETOPICS = 2   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETETOPICS_RESULT = 101 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteTopics, [:pointer, :pointer, :size_t, :pointer, :pointer], :int32, blocking: true
+    attach_function :rd_kafka_DeleteTopic_new, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_DeleteTopic_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteTopics_result, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_DeleteTopics_result_topics, [:pointer, :pointer], :pointer, blocking: true
+
+    # Create partitions
+    RD_KAFKA_ADMIN_OP_CREATEPARTITIONS = 3
+    RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT = 102
+
+    attach_function :rd_kafka_CreatePartitions, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
+    attach_function :rd_kafka_NewPartitions_new, %i[pointer size_t pointer size_t], :pointer
+    attach_function :rd_kafka_NewPartitions_destroy, [:pointer], :void
+    attach_function :rd_kafka_event_CreatePartitions_result, [:pointer], :pointer
+    attach_function :rd_kafka_CreatePartitions_result_topics, [:pointer, :pointer], :pointer
+
+    # Delete Group
+    RD_KAFKA_ADMIN_OP_DELETEGROUPS = 7   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETEGROUPS_RESULT = 106 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteGroups, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_DeleteGroup_new, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_DeleteGroup_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteGroups_result_t*
+    attach_function :rd_kafka_DeleteGroups_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteGroups_result_t*, size_t* => rd_kafka_group_result_t**
+
+    # Alter Consumer Group Offsets
+    RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS = 15   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT = 0x10000 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_AlterConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_AlterConsumerGroupOffsets_t*
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_AlterConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_AlterConsumerGroupOffsets_result_t*
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_AlterConsumerGroupOffsets_result_t*, size_t* => rd_kafka_group_result_t**
+
+    # Delete Consumer Group Offsets
+    RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS = 8   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT = 107 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_DeleteConsumerGroupOffsets_t*
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteConsumerGroupOffsets_result_t*
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteConsumerGroupOffsets_result_t*, size_t* => rd_kafka_group_result_t**
+
+    # Delete Records
+    RD_KAFKA_ADMIN_OP_DELETERECORDS = 6   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETERECORDS_RESULT = 105 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteRecords, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_DeleteRecords_new, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_DeleteRecords_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteRecords_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteRecords_result_t*
+    attach_function :rd_kafka_DeleteRecords_result_offsets, [:pointer], :pointer, blocking: true # rd_kafka_DeleteRecords_result_t* => rd_kafka_topic_partition_list_t*
+
+    # List Consumer Groups
+    RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS = 12   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT = 0x2000 # rd_kafka_event_type_t
+
+    # Consumer group states (rd_kafka_consumer_group_state_t)
+    RD_KAFKA_CONSUMER_GROUP_STATE_UNKNOWN = 0
+    RD_KAFKA_CONSUMER_GROUP_STATE_PREPARING_REBALANCE = 1
+    RD_KAFKA_CONSUMER_GROUP_STATE_COMPLETING_REBALANCE = 2
+    RD_KAFKA_CONSUMER_GROUP_STATE_STABLE = 3
+    RD_KAFKA_CONSUMER_GROUP_STATE_DEAD = 4
+    RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY = 5
+
+    attach_function :rd_kafka_ListConsumerGroups, [:pointer, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_ListConsumerGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_ListConsumerGroups_result_t*
+    attach_function :rd_kafka_ListConsumerGroups_result_valid, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_ConsumerGroupListing_t**
+    attach_function :rd_kafka_ListConsumerGroups_result_errors, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_error_t**
+    attach_function :rd_kafka_ConsumerGroupListing_group_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_ConsumerGroupListing_is_simple_consumer_group, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_ConsumerGroupListing_state, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_consumer_group_state_name, [:int], :pointer, blocking: true # => const char*
+
+    # Describe Consumer Groups
+    RD_KAFKA_ADMIN_OP_DESCRIBECONSUMERGROUPS = 13   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DESCRIBECONSUMERGROUPS_RESULT = 0x4000 # rd_kafka_event_type_t
+
+    # Consumer group types (rd_kafka_consumer_group_type_t)
+    RD_KAFKA_CONSUMER_GROUP_TYPE_UNKNOWN = 0
+    RD_KAFKA_CONSUMER_GROUP_TYPE_CONSUMER = 1
+    RD_KAFKA_CONSUMER_GROUP_TYPE_CLASSIC = 2
+
+    attach_function :rd_kafka_DescribeConsumerGroups, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DescribeConsumerGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DescribeConsumerGroups_result_t*
+    attach_function :rd_kafka_DescribeConsumerGroups_result_groups, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_ConsumerGroupDescription_t**
+    attach_function :rd_kafka_ConsumerGroupDescription_group_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_ConsumerGroupDescription_error, [:pointer], :pointer, blocking: true # => const rd_kafka_error_t*
+    attach_function :rd_kafka_ConsumerGroupDescription_is_simple_consumer_group, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_ConsumerGroupDescription_partition_assignor, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_ConsumerGroupDescription_state, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_ConsumerGroupDescription_type, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_ConsumerGroupDescription_authorized_operations, [:pointer, :pointer], :pointer, blocking: true # grpdesc*, size_t* => const rd_kafka_AclOperation_t*
+    attach_function :rd_kafka_ConsumerGroupDescription_coordinator, [:pointer], :pointer, blocking: true # => const rd_kafka_Node_t*
+    attach_function :rd_kafka_ConsumerGroupDescription_member_count, [:pointer], :size_t, blocking: true
+    attach_function :rd_kafka_ConsumerGroupDescription_member, [:pointer, :size_t], :pointer, blocking: true # => const rd_kafka_MemberDescription_t*
+    attach_function :rd_kafka_MemberDescription_client_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_MemberDescription_group_instance_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_MemberDescription_consumer_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_MemberDescription_host, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_MemberDescription_assignment, [:pointer], :pointer, blocking: true # => const rd_kafka_MemberAssignment_t*
+    attach_function :rd_kafka_MemberDescription_target_assignment, [:pointer], :pointer, blocking: true # => const rd_kafka_MemberAssignment_t*
+    attach_function :rd_kafka_MemberAssignment_partitions, [:pointer], :pointer, blocking: true # => const rd_kafka_topic_partition_list_t*
+    attach_function :rd_kafka_consumer_group_type_name, [:int], :pointer, blocking: true # => const char*
+
+    # Describe Topics and Describe Cluster
+    RD_KAFKA_ADMIN_OP_DESCRIBETOPICS = 19   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DESCRIBETOPICS_RESULT = 0x100000 # rd_kafka_event_type_t
+    RD_KAFKA_ADMIN_OP_DESCRIBECLUSTER = 20   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DESCRIBECLUSTER_RESULT = 0x200000 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_AdminOptions_set_include_authorized_operations, [:pointer, :int], :pointer, blocking: true # => rd_kafka_error_t*
+    attach_function :rd_kafka_TopicCollection_of_topic_names, [:pointer, :size_t], :pointer, blocking: true # const char**, size_t => rd_kafka_TopicCollection_t*
+    attach_function :rd_kafka_TopicCollection_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_DescribeTopics, [:pointer, :pointer, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DescribeTopics_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DescribeTopics_result_t*
+    attach_function :rd_kafka_DescribeTopics_result_topics, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_TopicDescription_t**
+    attach_function :rd_kafka_TopicDescription_name, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_TopicDescription_topic_id, [:pointer], :pointer, blocking: true # => rd_kafka_Uuid_t*
+    attach_function :rd_kafka_TopicDescription_is_internal, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_TopicDescription_partitions, [:pointer, :pointer], :pointer, blocking: true # desc*, size_t* => rd_kafka_TopicPartitionInfo_t**
+    attach_function :rd_kafka_TopicDescription_authorized_operations, [:pointer, :pointer], :pointer, blocking: true # desc*, size_t* => rd_kafka_AclOperation_t*
+    attach_function :rd_kafka_TopicDescription_error, [:pointer], :pointer, blocking: true # => rd_kafka_error_t*
+    attach_function :rd_kafka_TopicPartitionInfo_partition, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_TopicPartitionInfo_leader, [:pointer], :pointer, blocking: true # => rd_kafka_Node_t*
+    attach_function :rd_kafka_TopicPartitionInfo_replicas, [:pointer, :pointer], :pointer, blocking: true # info*, size_t* => rd_kafka_Node_t**
+    attach_function :rd_kafka_TopicPartitionInfo_isr, [:pointer, :pointer], :pointer, blocking: true # info*, size_t* => rd_kafka_Node_t**
+    attach_function :rd_kafka_Uuid_base64str, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_Uuid_most_significant_bits, [:pointer], :int64, blocking: true
+    attach_function :rd_kafka_Uuid_least_significant_bits, [:pointer], :int64, blocking: true
+    attach_function :rd_kafka_DescribeCluster, [:pointer, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DescribeCluster_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DescribeCluster_result_t*
+    attach_function :rd_kafka_DescribeCluster_result_nodes, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_Node_t**
+    attach_function :rd_kafka_DescribeCluster_result_controller, [:pointer], :pointer, blocking: true # => rd_kafka_Node_t*
+    attach_function :rd_kafka_DescribeCluster_result_cluster_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_DescribeCluster_result_authorized_operations, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_AclOperation_t*
+    attach_function :rd_kafka_Node_id, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_Node_host, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_Node_port, [:pointer], :uint16, blocking: true
+    attach_function :rd_kafka_Node_rack, [:pointer], :pointer, blocking: true # => const char*
+
+    # Background Queue and Callback
+
+    attach_function :rd_kafka_conf_set_background_event_cb, [:pointer, :pointer], :void
+    attach_function :rd_kafka_queue_destroy, [:pointer], :void
+
+    # Admin Options
+
+    attach_function :rd_kafka_AdminOptions_new, [:pointer, :int32], :pointer
+    attach_function :rd_kafka_AdminOptions_set_opaque, [:pointer, :pointer], :void
+    attach_function :rd_kafka_AdminOptions_destroy, [:pointer], :void
+
+    # Extracting data from event types
+
+    attach_function :rd_kafka_event_type, [:pointer], :int32
+    attach_function :rd_kafka_event_opaque, [:pointer], :pointer
+    attach_function :rd_kafka_event_destroy, [:pointer], :void
+    attach_function :rd_kafka_event_error, [:pointer], :int32
+    attach_function :rd_kafka_event_error_string, [:pointer], :pointer
+
+    # Extracting data from topic results
+
+    attach_function :rd_kafka_topic_result_error, [:pointer], :int32
+    attach_function :rd_kafka_topic_result_error_string, [:pointer], :pointer
+    attach_function :rd_kafka_topic_result_name, [:pointer], :pointer
+
+    attach_function :rd_kafka_group_result_error, [:pointer], NativeError.by_ref # rd_kafka_group_result_t* => rd_kafka_error_t*
+    attach_function :rd_kafka_group_result_name, [:pointer], :pointer
+    attach_function :rd_kafka_group_result_partitions, [:pointer], :pointer # rd_kafka_group_result_t* => rd_kafka_topic_partition_list_t*
+  end
+end
+
+require_relative "admin/configs"
+require_relative "admin/list_offsets"
+require_relative "admin/acls"