karafka-rdkafka 0.30.2-aarch64-linux-gnu → 0.32.0-aarch64-linux-gnu

data/lib/rdkafka/admin.rb

@@ -95,7 +95,7 @@ module Rdkafka
 
     # Polls for events in a non-blocking loop, yielding the count after each iteration.
     #
-    # This method processes events (stats, errors, etc.) in a single GVL/mutex session,
+    # This method processes events (stats, errors, etc.) in a single GVL session,
     # which is more efficient than repeated individual polls. It uses non-blocking polls
     # internally (no GVL release between polls).
     #
@@ -116,8 +116,9 @@ module Rdkafka
     #   admin.events_poll_nb_each do |_count|
     #     :stop if monotonic_now >= deadline
     #   end
-    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
-    #   Other admin operations will wait until this method returns.
+    # @note This method runs inside `with_inner` and does not hold a lock while it loops.
+    #   Other operations on the same client run concurrently. `close` waits until this
+    #   method returns.
     # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
     def events_poll_nb_each
       closed_admin_check(__method__)
@@ -149,14 +150,35 @@ module Rdkafka
     # @param partition_count [Integer] number of partitions for the topic
     # @param replication_factor [Integer] replication factor for the topic
     # @param topic_config [Hash] optional topic configuration settings
+    # @param validate_only [Boolean] when true, the broker only validates the request and does not
+    #   create the topic
+    # @param operation_timeout_ms [Integer, nil] how long the broker waits for the topic creation
+    #   to complete before it responds (librdkafka default: 60 seconds)
+    # @param request_timeout_ms [Integer, nil] overall request timeout (librdkafka default:
+    #   `socket.timeout.ms`)
+    # @param braceless_topic_config [Hash] topic configuration given as a hash without braces,
+    #   e.g. `create_topic("t", 1, 1, "retention.ms" => "1000")`, merged into `topic_config`
+    # @option braceless_topic_config [String] any topic configuration name, e.g. `"retention.ms"`
     # @return [CreateTopicHandle] Create topic handle that can be used to wait for the result of
     #   creating the topic
     # @raise [ConfigError] When the partition count or replication factor are out of valid range
     # @raise [RdkafkaError] When the topic name is invalid or the topic already exists
     # @raise [RdkafkaError] When the topic configuration is invalid
-    def create_topic(topic_name, partition_count, replication_factor, topic_config = {})
+    # @raise [RdkafkaError] When librdkafka rejects a timeout value
+    def create_topic(
+      topic_name,
+      partition_count,
+      replication_factor,
+      topic_config = {},
+      validate_only: false,
+      operation_timeout_ms: nil,
+      request_timeout_ms: nil,
+      **braceless_topic_config
+    )
       closed_admin_check(__method__)
 
+      topic_config = (topic_config || {}).merge(braceless_topic_config) unless braceless_topic_config.empty?
+
       # Create a rd_kafka_NewTopic_t representing the new topic
       error_buffer = FFI::MemoryPointer.from_string(" " * 256)
       new_topic_ptr = Rdkafka::Bindings.rd_kafka_NewTopic_new(
@@ -203,6 +225,13 @@ module Rdkafka
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, create_topic_handle.to_ptr)
 
       begin
+        set_admin_options(
+          admin_options_ptr,
+          validate_only: validate_only,
+          operation_timeout_ms: operation_timeout_ms,
+          request_timeout_ms: request_timeout_ms
+        )
+
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_CreateTopics(
             inner,
@@ -224,6 +253,51 @@ module Rdkafka
       create_topic_handle
     end
 
+    # Reads the committed offsets of a consumer group from outside the group.
+    #
+    # Unlike {Consumer#committed}, this works for any group and does not join it, so it does not
+    # trigger a rebalance of the group it inspects.
+    #
+    # While the group coordinator is loading, not known yet or has moved (e.g. on a fresh cluster
+    # or after a broker restart), the handle raises `coordinator_load_in_progress`,
+    # `not_coordinator` or `coordinator_not_available`. Retry the call on these codes;
+    # `RdkafkaError#retryable?` is false for them.
+    #
+    # @param group_id [String] the group whose committed offsets we want to read
+    # @param topic_partition_list [TopicPartitionList, nil] partitions to read the offsets for, or
+    #   nil to read every partition the group has committed offsets for. List the partitions
+    #   explicitly: a topic without partitions is not expanded to its partitions
+    # @param require_stable_offsets [Boolean] pending offsets of an open transaction are never
+    #   returned. Without this option the last committed offset is returned for such a partition.
+    #   With it, the call fails with `unstable_offset_commit` until that transaction is committed
+    #   or aborted; retry on this code
+    # @return [ListConsumerGroupOffsetsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when listing the offsets fails
+    def list_consumer_group_offsets(group_id, topic_partition_list = nil, require_stable_offsets: false)
+      closed_admin_check(__method__)
+
+      native_tpl = topic_partition_list&.to_native_tpl
+
+      begin
+        list_ptr = Rdkafka::Bindings.rd_kafka_ListConsumerGroupOffsets_new(
+          FFI::MemoryPointer.from_string(group_id),
+          native_tpl || FFI::Pointer::NULL
+        )
+      ensure
+        # librdkafka copies the list into the request object, so ours is no longer needed
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl) if native_tpl
+      end
+
+      enqueue_group_offsets_op(
+        request_ptr: list_ptr,
+        handle: ListConsumerGroupOffsetsHandle.new,
+        admin_op: Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPOFFSETS,
+        destroy: Rdkafka::Bindings.method(:rd_kafka_ListConsumerGroupOffsets_destroy),
+        enqueue: Rdkafka::Bindings.method(:rd_kafka_ListConsumerGroupOffsets),
+        configure: ->(admin_options_ptr) { set_require_stable_offsets(admin_options_ptr) if require_stable_offsets }
+      )
+    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
@@ -520,13 +594,243 @@ 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
+    # @param operation_timeout_ms [Integer, nil] how long the broker waits for the topic deletion
+    #   to complete before it responds (librdkafka default: 60 seconds)
+    # @param request_timeout_ms [Integer, nil] overall request timeout (librdkafka default:
+    #   `socket.timeout.ms`)
     # @return [DeleteTopicHandle] Delete topic handle that can be used to wait for the result of
     #   deleting the topic
     # @raise [RdkafkaError] When the topic name is invalid or the topic does not exist
-    def delete_topic(topic_name)
+    # @raise [RdkafkaError] When librdkafka rejects a timeout value
+    def delete_topic(topic_name, operation_timeout_ms: nil, request_timeout_ms: nil)
       closed_admin_check(__method__)
 
       # Create a rd_kafka_DeleteTopic_t representing the topic to be deleted
@@ -557,6 +861,12 @@ module Rdkafka
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, delete_topic_handle.to_ptr)
 
       begin
+        set_admin_options(
+          admin_options_ptr,
+          operation_timeout_ms: operation_timeout_ms,
+          request_timeout_ms: request_timeout_ms
+        )
+
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_DeleteTopics(
             inner,
@@ -582,12 +892,25 @@ module Rdkafka
     #
     # @param topic_name [String] name of the topic
     # @param partition_count [Integer] how many partitions we want to end up with for given topic
+    # @param validate_only [Boolean] when true, the broker only validates the request and does not
+    #   add the partitions
+    # @param operation_timeout_ms [Integer, nil] how long the broker waits for the partitions to be
+    #   created before it responds (librdkafka default: 60 seconds)
+    # @param request_timeout_ms [Integer, nil] overall request timeout (librdkafka default:
+    #   `socket.timeout.ms`)
     # @return [CreatePartitionsHandle] Create partitions handle that can be used to wait for the
     #   result
     # @raise [ConfigError] When the partition count or replication factor are out of valid range
     # @raise [RdkafkaError] When the topic name is invalid or the topic already exists
     # @raise [RdkafkaError] When the topic configuration is invalid
-    def create_partitions(topic_name, partition_count)
+    # @raise [RdkafkaError] When librdkafka rejects a timeout value
+    def create_partitions(
+      topic_name,
+      partition_count,
+      validate_only: false,
+      operation_timeout_ms: nil,
+      request_timeout_ms: nil
+    )
       closed_admin_check(__method__)
 
       @native_kafka.with_inner do |inner|
@@ -622,6 +945,13 @@ module Rdkafka
         Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, create_partitions_handle.to_ptr)
 
         begin
+          set_admin_options(
+            admin_options_ptr,
+            validate_only: validate_only,
+            operation_timeout_ms: operation_timeout_ms,
+            request_timeout_ms: request_timeout_ms
+          )
+
           Rdkafka::Bindings.rd_kafka_CreatePartitions(
             inner,
             topics_array_ptr,
@@ -1206,8 +1536,8 @@ 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
+    # Shared enqueue path for the consumer group offset admin operations. They differ only in
+    # their C entry points, so keeping one body avoids near identical copies of the
     # queue/handle/options dance and its cleanup.
     #
     # @param request_ptr [FFI::Pointer] the op specific request object
@@ -1215,8 +1545,13 @@ module Rdkafka
     # @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
+    # @param configure [Proc, nil] called with the `rd_kafka_AdminOptions_t` pointer before the
+    #   request is enqueued, to set an option only this operation supports. For example
+    #   `#list_consumer_group_offsets` always passes a lambda that takes `admin_options_ptr` and
+    #   calls `set_require_stable_offsets(admin_options_ptr)` only when
+    #   `require_stable_offsets: true`. nil (alter and delete) sets no extra option
     # @return [AbstractHandle] the registered handle
-    def enqueue_group_offsets_op(request_ptr:, handle:, admin_op:, destroy:, enqueue:)
+    def enqueue_group_offsets_op(request_ptr:, handle:, admin_op:, destroy:, enqueue:, configure: nil)
       array_ptr = FFI::MemoryPointer.new(:pointer)
       array_ptr.write_array_of_pointer([request_ptr])
 
@@ -1239,6 +1574,8 @@ module Rdkafka
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
       begin
+        configure&.call(admin_options_ptr)
+
         @native_kafka.with_inner do |inner|
           enqueue.call(inner, array_ptr, 1, admin_options_ptr, queue_ptr)
         end
@@ -1254,6 +1591,84 @@ 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)
+      raise_admin_option_error(
+        Rdkafka::Bindings.rd_kafka_AdminOptions_set_include_authorized_operations(admin_options_ptr, 1)
+      )
+    end
+
+    # Makes the broker fail a partition with `unstable_offset_commit` while a transaction with
+    # pending offsets for it is open, instead of returning its last committed offset
+    # @param admin_options_ptr [FFI::Pointer] the admin options to update
+    # @raise [RdkafkaError] when librdkafka rejects the option
+    def set_require_stable_offsets(admin_options_ptr)
+      raise_admin_option_error(
+        Rdkafka::Bindings.rd_kafka_AdminOptions_set_require_stable_offsets(admin_options_ptr, 1)
+      )
+    end
+
+    # Raises and releases the error librdkafka returned from setting an admin option
+    # @param error_ptr [FFI::Pointer] the returned `rd_kafka_error_t*`, NULL on success
+    # @raise [RdkafkaError] when the error pointer is not NULL
+    def raise_admin_option_error(error_ptr)
+      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
+
+    # Applies the optional request settings to admin options
+    # @param admin_options_ptr [FFI::Pointer] the admin options to update
+    # @param validate_only [Boolean] whether the broker should only validate the request
+    # @param operation_timeout_ms [Integer, nil] broker operation timeout, librdkafka default if nil
+    # @param request_timeout_ms [Integer, nil] request timeout, librdkafka default if nil
+    # @raise [RdkafkaError] when librdkafka rejects a value
+    def set_admin_options(admin_options_ptr, validate_only: false, operation_timeout_ms: nil, request_timeout_ms: nil)
+      error_buffer = FFI::MemoryPointer.new(:char, 256)
+
+      if validate_only
+        check_admin_option(
+          Rdkafka::Bindings.rd_kafka_AdminOptions_set_validate_only(admin_options_ptr, 1, error_buffer, 256),
+          error_buffer
+        )
+      end
+
+      if operation_timeout_ms
+        check_admin_option(
+          Rdkafka::Bindings.rd_kafka_AdminOptions_set_operation_timeout(admin_options_ptr, operation_timeout_ms, error_buffer, 256),
+          error_buffer
+        )
+      end
+
+      if request_timeout_ms
+        check_admin_option(
+          Rdkafka::Bindings.rd_kafka_AdminOptions_set_request_timeout(admin_options_ptr, request_timeout_ms, error_buffer, 256),
+          error_buffer
+        )
+      end
+    end
+
+    # Raises when an admin options setter failed
+    # @param response [Integer] result code of an admin options setter
+    # @param error_buffer [FFI::MemoryPointer] buffer the setter wrote its error into
+    # @raise [RdkafkaError] when the setter failed
+    def check_admin_option(response, error_buffer)
+      return if response == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+      raise RdkafkaError.new(response, broker_message: error_buffer.read_string)
+    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, :size_t], :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