rdkafka 0.29.2 → 0.31.0

data/lib/rdkafka/admin/describe_topics_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for describe topics operation
+    class DescribeTopicsHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "describe topics"
+      end
+
+      # @return [DescribeTopicsReport] report prepared by the background event callback, with
+      #   the described topics.
+      def create_result
+        prepared_result
+      end
+
+      # Raises an error if the operation failed
+      # @raise [RdkafkaError]
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: broker_message
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_topics_report.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for describe topics operation result
+    class DescribeTopicsReport
+      include DescribeResultParsing
+
+      # Described topics, one per requested topic name. Each entry is a hash with:
+      #   - `:name` [String] the topic name
+      #   - `:topic_id` [String, nil] the topic id (KIP-516), base64 encoded, or `nil` when the
+      #     topic could not be described
+      #   - `:is_internal` [Boolean] whether the topic is internal (e.g. `__consumer_offsets`)
+      #   - `:partitions` [Array<Hash>] each with `:partition` [Integer], `:leader` [Hash, nil] and
+      #     `:replicas` / `:isr` [Array<Hash>]; nodes have `:id`, `:host`, `:port` and `:rack`
+      #   - `:authorized_operations` [Array<Integer>, nil] `Bindings::RD_KAFKA_ACL_OPERATION_*`
+      #     codes, `nil` unless requested with `include_authorized_operations: true`
+      #   - `:error` [RdkafkaError, nil] per-topic error (e.g. `unknown_topic_or_part`), `nil`
+      #     on success
+      # @return [Array<Hash>]
+      attr_reader :topics
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_DescribeTopics_result_t`
+      def initialize(result_ptr)
+        @topics = []
+
+        return if result_ptr.null?
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_DescribeTopics_result_topics(result_ptr, count_ptr)
+
+        return if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).each do |topic_ptr|
+          @topics << extract_topic(topic_ptr)
+        end
+      end
+
+      private
+
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [Hash]
+      def extract_topic(topic_ptr)
+        name_ptr = Bindings.rd_kafka_TopicDescription_name(topic_ptr)
+        operations_count_ptr = FFI::MemoryPointer.new(:size_t)
+
+        {
+          name: name_ptr.null? ? nil : name_ptr.read_string,
+          topic_id: extract_topic_id(topic_ptr),
+          is_internal: Bindings.rd_kafka_TopicDescription_is_internal(topic_ptr) != 0,
+          partitions: extract_partitions(topic_ptr),
+          authorized_operations: extract_authorized_operations(
+            Bindings.rd_kafka_TopicDescription_authorized_operations(topic_ptr, operations_count_ptr),
+            operations_count_ptr
+          ),
+          error: extract_error(topic_ptr)
+        }
+      end
+
+      # librdkafka reports the zero UUID for a topic it could not describe
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [String, nil]
+      def extract_topic_id(topic_ptr)
+        uuid_ptr = Bindings.rd_kafka_TopicDescription_topic_id(topic_ptr)
+
+        return nil if uuid_ptr.null?
+        return nil if Bindings.rd_kafka_Uuid_most_significant_bits(uuid_ptr).zero? &&
+          Bindings.rd_kafka_Uuid_least_significant_bits(uuid_ptr).zero?
+
+        string_ptr = Bindings.rd_kafka_Uuid_base64str(uuid_ptr)
+        string_ptr.null? ? nil : string_ptr.read_string
+      end
+
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [Array<Hash>]
+      def extract_partitions(topic_ptr)
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_TopicDescription_partitions(topic_ptr, count_ptr)
+
+        return [] if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).map do |partition_ptr|
+          replicas_count_ptr = FFI::MemoryPointer.new(:size_t)
+          isr_count_ptr = FFI::MemoryPointer.new(:size_t)
+
+          {
+            partition: Bindings.rd_kafka_TopicPartitionInfo_partition(partition_ptr),
+            leader: extract_node(Bindings.rd_kafka_TopicPartitionInfo_leader(partition_ptr)),
+            replicas: extract_nodes(
+              Bindings.rd_kafka_TopicPartitionInfo_replicas(partition_ptr, replicas_count_ptr),
+              replicas_count_ptr
+            ),
+            isr: extract_nodes(
+              Bindings.rd_kafka_TopicPartitionInfo_isr(partition_ptr, isr_count_ptr),
+              isr_count_ptr
+            )
+          }
+        end
+      end
+
+      # The error is owned by the result, so it is copied and not destroyed here.
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [RdkafkaError, nil]
+      def extract_error(topic_ptr)
+        error_ptr = Bindings.rd_kafka_TopicDescription_error(topic_ptr)
+
+        return nil if error_ptr.null?
+
+        code = Bindings.rd_kafka_error_code(error_ptr)
+
+        return nil if code == Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+        string_ptr = Bindings.rd_kafka_error_string(error_ptr)
+        RdkafkaError.new(code, broker_message: string_ptr.null? ? nil : string_ptr.read_string)
+      end
+    end
+  end
+end

data/lib/rdkafka/admin.rb

@@ -224,6 +224,78 @@ module Rdkafka
       create_topic_handle
     end
 
+    # Sets the committed offsets of a consumer group from outside the group.
+    #
+    # Kafka requires the group to be empty (no active members) for this to be accepted; when it
+    # is not, the broker rejects the request and the handle raises with `group_not_empty` rather
+    # than reporting success.
+    #
+    # @param group_id [String] the group whose offsets we want to set
+    # @param topic_partition_list [TopicPartitionList] partitions with the offsets to commit
+    # @return [AlterConsumerGroupOffsetsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when altering the offsets fails
+    def alter_consumer_group_offsets(group_id, topic_partition_list)
+      closed_admin_check(__method__)
+
+      native_tpl = topic_partition_list.to_native_tpl
+
+      begin
+        alter_ptr = Rdkafka::Bindings.rd_kafka_AlterConsumerGroupOffsets_new(
+          FFI::MemoryPointer.from_string(group_id),
+          native_tpl
+        )
+      rescue Exception
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+        raise
+      end
+
+      # librdkafka copies the list into the request object, so ours is no longer needed
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+
+      enqueue_group_offsets_op(
+        request_ptr: alter_ptr,
+        handle: AlterConsumerGroupOffsetsHandle.new,
+        admin_op: Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS,
+        destroy: Rdkafka::Bindings.method(:rd_kafka_AlterConsumerGroupOffsets_destroy),
+        enqueue: Rdkafka::Bindings.method(:rd_kafka_AlterConsumerGroupOffsets)
+      )
+    end
+
+    # Deletes the committed offsets of specific partitions of a consumer group, leaving the
+    # group and its remaining offsets in place.
+    #
+    # This is the partition scoped counterpart of {#delete_group}, which removes the whole group.
+    #
+    # @param group_id [String] the group whose offsets we want to delete
+    # @param topic_partition_list [TopicPartitionList] partitions whose offsets to delete
+    # @return [DeleteConsumerGroupOffsetsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when deleting the offsets fails
+    def delete_consumer_group_offsets(group_id, topic_partition_list)
+      closed_admin_check(__method__)
+
+      native_tpl = topic_partition_list.to_native_tpl
+
+      begin
+        delete_ptr = Rdkafka::Bindings.rd_kafka_DeleteConsumerGroupOffsets_new(
+          FFI::MemoryPointer.from_string(group_id),
+          native_tpl
+        )
+      rescue Exception
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+        raise
+      end
+
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+
+      enqueue_group_offsets_op(
+        request_ptr: delete_ptr,
+        handle: DeleteConsumerGroupOffsetsHandle.new,
+        admin_op: Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS,
+        destroy: Rdkafka::Bindings.method(:rd_kafka_DeleteConsumerGroupOffsets_destroy),
+        enqueue: Rdkafka::Bindings.method(:rd_kafka_DeleteConsumerGroupOffsets)
+      )
+    end
+
     # Deletes a consumer group
     #
     # @param group_id [String] the group id to delete
@@ -448,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
@@ -1139,6 +1436,74 @@ module Rdkafka
 
     private
 
+    # Shared enqueue path for the two consumer group offset admin operations. They differ only
+    # in their C entry points, so keeping one body avoids two near identical copies of the
+    # queue/handle/options dance and its cleanup.
+    #
+    # @param request_ptr [FFI::Pointer] the op specific request object
+    # @param handle [AbstractHandle] the handle to register and return
+    # @param admin_op [Integer] the RD_KAFKA_ADMIN_OP_* constant for this operation
+    # @param destroy [Method] bound function used to free the request object
+    # @param enqueue [Method] bound function used to enqueue the request
+    # @return [AbstractHandle] the registered handle
+    def enqueue_group_offsets_op(request_ptr:, handle:, admin_op:, destroy:, enqueue:)
+      array_ptr = FFI::MemoryPointer.new(:pointer)
+      array_ptr.write_array_of_pointer([request_ptr])
+
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        destroy.call(request_ptr)
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      handle.class.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, admin_op)
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          enqueue.call(inner, array_ptr, 1, admin_options_ptr, queue_ptr)
+        end
+      rescue Exception
+        handle.class.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        destroy.call(request_ptr)
+      end
+
+      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