karafka-rdkafka 0.27.2-aarch64-linux-gnu → 0.28.0-aarch64-linux-gnu

data/lib/rdkafka/admin.rb

@@ -4,6 +4,8 @@ module Rdkafka
   # Admin client for Kafka administrative operations
   class Admin
     include Helpers::OAuth
+    include Helpers::Metadata
+    include Helpers::ListOffsets
 
     class << self
       # Allows us to retrieve librdkafka errors with descriptions
@@ -130,19 +132,6 @@ module Rdkafka
       end
     end
 
-    # Performs the metadata request using admin
-    #
-    # @param topic_name [String, nil] metadat about particular topic or all if nil
-    # @param timeout_ms [Integer] metadata request timeout
-    # @return [Metadata] requested metadata
-    def metadata(topic_name = nil, timeout_ms = Defaults::METADATA_TIMEOUT_MS)
-      closed_admin_check(__method__)
-
-      @native_kafka.with_inner do |inner|
-        Metadata.new(inner, topic_name, timeout_ms)
-      end
-    end
-
     # Close this admin instance
     def close
       return if closed?
@@ -258,7 +247,7 @@ module Rdkafka
         Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
       end
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_DeleteTopic_destroy(delete_topic_ptr)
+        Rdkafka::Bindings.rd_kafka_DeleteGroup_destroy(delete_groups_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -581,7 +570,7 @@ module Rdkafka
       end
 
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(new_acl_ptr)
+        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(delete_acl_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -677,7 +666,7 @@ module Rdkafka
       end
 
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(new_acl_ptr)
+        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(describe_acl_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -728,6 +717,14 @@ module Rdkafka
     def describe_configs(resources)
       closed_admin_check(__method__)
 
+      # Parse user input before allocating any native resources or registering the handle, so a
+      # missing :resource_type / :resource_name key raises with nothing to clean up. Previously the
+      # KeyError leaked the background queue, the AdminOptions, the registered handle and any
+      # ConfigResources already built.
+      parsed_resources = resources.map do |resource_details|
+        [resource_details.fetch(:resource_type), resource_details.fetch(:resource_name)]
+      end
+
       handle = DescribeConfigsHandle.new
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
@@ -750,12 +747,10 @@ module Rdkafka
       DescribeConfigsHandle.register(handle)
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
-      pointer_array = resources.map do |resource_details|
+      pointer_array = parsed_resources.map do |resource_type, resource_name|
         Rdkafka::Bindings.rd_kafka_ConfigResource_new(
-          resource_details.fetch(:resource_type),
-          FFI::MemoryPointer.from_string(
-            resource_details.fetch(:resource_name)
-          )
+          resource_type,
+          FFI::MemoryPointer.from_string(resource_name)
         )
       end
 
@@ -806,6 +801,19 @@ module Rdkafka
     def incremental_alter_configs(resources_with_configs)
       closed_admin_check(__method__)
 
+      # Parse user input before allocating native resources or registering the handle, so a missing
+      # key raises with nothing to clean up. Previously the KeyError leaked the background queue,
+      # the AdminOptions, the registered handle and any ConfigResources already built.
+      parsed_resources = resources_with_configs.map do |resource_details|
+        [
+          resource_details.fetch(:resource_type),
+          resource_details.fetch(:resource_name),
+          resource_details.fetch(:configs).map do |config|
+            [config.fetch(:name), config.fetch(:op_type), config.fetch(:value)]
+          end
+        ]
+      end
+
       handle = IncrementalAlterConfigsHandle.new
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
@@ -828,23 +836,34 @@ module Rdkafka
       IncrementalAlterConfigsHandle.register(handle)
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
-      # Tu poprawnie tworzyc
-      pointer_array = resources_with_configs.map do |resource_details|
+      add_error = nil
+
+      pointer_array = parsed_resources.map do |resource_type, resource_name, configs|
         # First build the appropriate resource representation
         resource_ptr = Rdkafka::Bindings.rd_kafka_ConfigResource_new(
-          resource_details.fetch(:resource_type),
-          FFI::MemoryPointer.from_string(
-            resource_details.fetch(:resource_name)
-          )
+          resource_type,
+          FFI::MemoryPointer.from_string(resource_name)
         )
 
-        resource_details.fetch(:configs).each do |config|
-          Bindings.rd_kafka_ConfigResource_add_incremental_config(
+        configs.each do |name, op_type, value|
+          # rd_kafka_ConfigResource_add_incremental_config returns a non-NULL rd_kafka_error_t for
+          # an invalid op_type, an empty/nil name, or a nil value on a non-delete op. The result
+          # used to be ignored: the entry was silently dropped, the alter request still reported
+          # success, and the error object leaked. Capture the first error (build_from_c also
+          # destroys the native error object) and raise it below, before the request is sent.
+          error_ptr = Bindings.rd_kafka_ConfigResource_add_incremental_config(
             resource_ptr,
-            config.fetch(:name),
-            config.fetch(:op_type),
-            config.fetch(:value)
+            name,
+            op_type,
+            value
           )
+
+          error = Rdkafka::RdkafkaError.build_from_c(
+            error_ptr,
+            "rd_kafka_ConfigResource_add_incremental_config"
+          )
+
+          add_error ||= error if error
         end
 
         resource_ptr
@@ -854,6 +873,10 @@ module Rdkafka
       configs_array_ptr.write_array_of_pointer(pointer_array)
 
       begin
+        # Raise only after the full array is built so the ensure below frees every ConfigResource
+        # we created, and before the request is sent so a rejected entry can't report success.
+        raise add_error if add_error
+
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_IncrementalAlterConfigs(
             inner,
@@ -882,111 +905,6 @@ module Rdkafka
       handle
     end
 
-    # Queries partition offsets by specification (earliest, latest, max_timestamp, or by
-    # timestamp) without requiring a consumer group.
-    #
-    # @param topic_partition_offsets [Hash{String => Array<Hash>}] hash mapping topic names to
-    #   arrays of partition offset specifications. Each specification is a hash with:
-    #   - `:partition` [Integer] partition number
-    #   - `:offset` [Symbol, Integer] offset specification - `:earliest`, `:latest`,
-    #     `:max_timestamp`, or an integer timestamp in milliseconds
-    # @param isolation_level [Integer, nil] optional isolation level:
-    #   - `RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED` (0) - default
-    #   - `RD_KAFKA_ISOLATION_LEVEL_READ_COMMITTED` (1)
-    #
-    # @return [ListOffsetsHandle] handle that can be used to wait for the result
-    #
-    # @raise [ClosedAdminError] when the admin is closed
-    # @raise [ConfigError] when the background queue is unavailable
-    #
-    # @example Query earliest and latest offsets
-    #   handle = admin.list_offsets(
-    #     { "my_topic" => [
-    #       { partition: 0, offset: :earliest },
-    #       { partition: 1, offset: :latest }
-    #     ] }
-    #   )
-    #   report = handle.wait(max_wait_timeout_ms: 15_000)
-    #   report.offsets
-    #   # => [{ topic: "my_topic", partition: 0, offset: 0, ... }, ...]
-    def list_offsets(topic_partition_offsets, isolation_level: nil)
-      closed_admin_check(__method__)
-
-      # Count total partitions for pre-allocation
-      total = topic_partition_offsets.sum { |_, partitions| partitions.size }
-
-      # Build native topic partition list
-      tpl = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(total)
-
-      topic_partition_offsets.each do |topic, partitions|
-        partitions.each do |spec|
-          partition = spec.fetch(:partition)
-          offset = spec.fetch(:offset)
-
-          native_offset = case offset
-          when :earliest then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_EARLIEST
-          when :latest then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_LATEST
-          when :max_timestamp then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_MAX_TIMESTAMP
-          when Integer then offset
-          else
-            raise ArgumentError, "Unknown offset specification: #{offset.inspect}"
-          end
-
-          Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, partition)
-          Rdkafka::Bindings.rd_kafka_topic_partition_list_set_offset(tpl, topic, partition, native_offset)
-        end
-      end
-
-      # 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?
-        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
-        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 = ListOffsetsHandle.new
-      handle[:pending] = true
-      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
-
-      admin_options_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
-          inner,
-          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_LISTOFFSETS
-        )
-      end
-
-      if isolation_level
-        Rdkafka::Bindings.rd_kafka_AdminOptions_set_isolation_level(admin_options_ptr, isolation_level)
-      end
-
-      ListOffsetsHandle.register(handle)
-      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
-
-      begin
-        @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_ListOffsets(
-            inner,
-            tpl,
-            admin_options_ptr,
-            queue_ptr
-          )
-        end
-      rescue Exception
-        ListOffsetsHandle.remove(handle.to_ptr.address)
-        raise
-      ensure
-        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
-        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
-        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
-      end
-
-      handle
-    end
-
     private
 
     # Checks if the admin is closed and raises an error if so
@@ -995,5 +913,6 @@ module Rdkafka
     def closed_admin_check(method)
       raise Rdkafka::ClosedAdminError.new(method) if closed?
     end
+    alias_method :closed_check, :closed_admin_check
   end
 end

data/lib/rdkafka/bindings.rb

@@ -58,6 +58,7 @@ module Rdkafka
       end
     end
 
+    RD_KAFKA_RESP_ERR__TIMED_OUT = -185
     RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175
     RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174
     RD_KAFKA_RESP_ERR__STATE = -172
@@ -105,8 +106,12 @@ module Rdkafka
     # Metadata
 
     attach_function :rd_kafka_name, [:pointer], :string
-    attach_function :rd_kafka_memberid, [:pointer], :string, blocking: true
-    attach_function :rd_kafka_clusterid, [:pointer], :string, blocking: true
+    # Both return a newly allocated string the caller must release with rd_kafka_mem_free; they
+    # are attached as :pointer (not :string) so we can free them instead of leaking. clusterid
+    # also takes a timeout_ms (the previous arity was wrong, leaving that argument as garbage).
+    attach_function :rd_kafka_memberid, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_clusterid, [:pointer, :int], :pointer, blocking: true
+    attach_function :rd_kafka_mem_free, [:pointer, :pointer], :void
     attach_function :rd_kafka_metadata, [:pointer, :int, :pointer, :pointer, :int], :int, blocking: true
     attach_function :rd_kafka_metadata_destroy, [:pointer], :void, blocking: true
 
@@ -242,6 +247,8 @@ module Rdkafka
 
     attach_function :rd_kafka_conf_new, [], :pointer
     attach_function :rd_kafka_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
+    attach_function :rd_kafka_conf_get, [:pointer, :string, :pointer, :pointer], :kafka_config_response
+    attach_function :rd_kafka_conf, [:pointer], :pointer
     attach_function :rd_kafka_conf_dump, [:pointer, :pointer], :pointer
     attach_function :rd_kafka_conf_dump_free, [:pointer, :size_t], :void
     attach_function :rd_kafka_conf_destroy, [:pointer], :void
@@ -271,6 +278,7 @@ module Rdkafka
     attach_function :rd_kafka_queue_io_event_enable, [:pointer, :int, :pointer, :size_t], :void
     # Per topic configs
     attach_function :rd_kafka_topic_conf_new, [], :pointer
+    attach_function :rd_kafka_topic_conf_destroy, [:pointer], :void
     attach_function :rd_kafka_topic_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
 
     LogCallback = FFI::Function.new(
@@ -493,7 +501,7 @@ module Rdkafka
 
     # Stats
 
-    attach_function :rd_kafka_query_watermark_offsets, [:pointer, :string, :int, :pointer, :pointer, :int], :int
+    attach_function :rd_kafka_query_watermark_offsets, [:pointer, :string, :int, :pointer, :pointer, :int], :int, blocking: true
 
     # Producer
     RD_KAFKA_VTYPE_END = 0
@@ -606,6 +614,7 @@ module Rdkafka
 
     attach_function :rd_kafka_event_type, [:pointer], :int32
     attach_function :rd_kafka_event_opaque, [:pointer], :pointer
+    attach_function :rd_kafka_event_destroy, [:pointer], :void
 
     # Extracting data from topic results
 

data/lib/rdkafka/callbacks/base_handler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Base class for admin background-event result handlers.
+    #
+    # Each subclass handles one librdkafka admin result event type: it extracts the result from
+    # the event, looks up the matching {AbstractHandle} in the registry and resolves it (sets the
+    # response, builds the report, copies the broker message, then unlocks it).
+    #
+    # The event is owned by the application and destroyed by {BackgroundEventCallback} right after
+    # dispatch, so handlers must copy everything they need out of event-owned memory into Ruby
+    # objects before returning.
+    #
+    # @private
+    class BaseHandler
+      class << self
+        # Processes a background event for the operation this handler is responsible for.
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          raise NotImplementedError, "#{name} must implement .call"
+        end
+
+        private
+
+        # Copies an event-owned C string into a Ruby string
+        # @param ptr [FFI::Pointer] pointer to the C string
+        # @return [String, nil] copied string or nil when NULL
+        def read_event_string(ptr)
+          ptr.null? ? nil : ptr.read_string
+        end
+
+        # Resolves a handle directly from an operation-level event error and unlocks it.
+        #
+        # librdkafka signals a failure of the whole admin operation (e.g. `_TIMED_OUT` when the
+        # brokers are unreachable, or `_DESTROY` when the client is closed with the request in
+        # flight) by setting the event error and delivering an *empty* results array. The
+        # per-element result handlers must not index into that empty array; they call this first
+        # and skip results parsing when it returns true. Without this, indexing `results[0]`
+        # raises inside the FFI callback, the handle is never unlocked, and the caller's `wait`
+        # blocks until its own timeout and raises `WaitTimeoutError`, losing the real error code.
+        #
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @param handle [Rdkafka::AbstractHandle] the handle to resolve
+        # @return [Boolean] true when the event carried an operation-level error and the handle
+        #   was resolved here
+        def resolve_operation_error(event_ptr, handle)
+          error_code = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
+
+          return false if error_code == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+          handle[:response] = error_code
+          handle.broker_message = read_event_string(Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr))
+          handle.unlock
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_acl_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_CREATEACLS_RESULT` events
+    # @private
+    class CreateAclHandler < BaseHandler
+      class << self
+        # Resolves the create-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_acls_result = Rdkafka::Bindings.rd_kafka_event_CreateAcls_result(event_ptr)
+
+          # Get the number of acl results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_acl_result_array = Rdkafka::Bindings.rd_kafka_CreateAcls_result_acls(create_acls_result, pointer_to_size_t)
+          create_acl_results = CreateAclResult.create_acl_results_from_array(pointer_to_size_t.read_int, create_acl_result_array)
+          create_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_acl_handle = Rdkafka::Admin::CreateAclHandle.remove(create_acl_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_acl_handle)
+              create_acl_handle[:response] = create_acl_results[0].result_error
+              create_acl_handle.result = Rdkafka::Admin::CreateAclReport.new(
+                rdkafka_response: create_acl_results[0].result_error,
+                rdkafka_response_string: create_acl_results[0].error_string
+              )
+              create_acl_handle.broker_message = create_acl_handle.result.rdkafka_response_string
+
+              create_acl_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_partitions_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT` events
+    # @private
+    class CreatePartitionsHandler < BaseHandler
+      class << self
+        # Resolves the create-partitions handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_partitionss_result = Rdkafka::Bindings.rd_kafka_event_CreatePartitions_result(event_ptr)
+
+          # Get the number of create topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_partitions_result_array = Rdkafka::Bindings.rd_kafka_CreatePartitions_result_topics(create_partitionss_result, pointer_to_size_t)
+          create_partitions_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, create_partitions_result_array)
+          create_partitions_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_partitions_handle = Rdkafka::Admin::CreatePartitionsHandle.remove(create_partitions_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_partitions_handle)
+              create_partitions_handle[:response] = create_partitions_results[0].result_error
+              create_partitions_handle.result = Rdkafka::Admin::CreatePartitionsReport.new(
+                create_partitions_results[0].error_string,
+                create_partitions_results[0].result_name
+              )
+              create_partitions_handle.broker_message = create_partitions_handle.result.error_string
+
+              create_partitions_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_topic_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_CREATETOPICS_RESULT` events
+    # @private
+    class CreateTopicHandler < BaseHandler
+      class << self
+        # Resolves the create-topic handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_topics_result = Rdkafka::Bindings.rd_kafka_event_CreateTopics_result(event_ptr)
+
+          # Get the number of create topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_topic_result_array = Rdkafka::Bindings.rd_kafka_CreateTopics_result_topics(create_topics_result, pointer_to_size_t)
+          create_topic_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, create_topic_result_array)
+          create_topic_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_topic_handle = Rdkafka::Admin::CreateTopicHandle.remove(create_topic_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_topic_handle)
+              create_topic_handle[:response] = create_topic_results[0].result_error
+              create_topic_handle.result = Rdkafka::Admin::CreateTopicReport.new(
+                create_topic_results[0].error_string,
+                create_topic_results[0].result_name
+              )
+              create_topic_handle.broker_message = create_topic_handle.result.error_string
+
+              create_topic_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_acl_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETEACLS_RESULT` events
+    # @private
+    class DeleteAclHandler < BaseHandler
+      class << self
+        # Resolves the delete-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_acls_result = Rdkafka::Bindings.rd_kafka_event_DeleteAcls_result(event_ptr)
+
+          # Get the number of acl results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_acl_result_responses = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_responses(delete_acls_result, pointer_to_size_t)
+          delete_acl_results = DeleteAclResult.delete_acl_results_from_array(pointer_to_size_t.read_int, delete_acl_result_responses)
+          delete_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if delete_acl_handle = Rdkafka::Admin::DeleteAclHandle.remove(delete_acl_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, delete_acl_handle)
+              delete_acl_handle[:response] = delete_acl_results[0].result_error
+              delete_acl_handle.broker_message = read_event_string(delete_acl_results[0].error_string)
+
+              delete_acl_handle.result = if delete_acl_results[0].result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::DeleteAclReport.new(
+                  matching_acls: delete_acl_results[0].matching_acls,
+                  matching_acls_count: delete_acl_results[0].matching_acls_count
+                )
+              else
+                Rdkafka::Admin::DeleteAclReport.new(matching_acls: FFI::Pointer::NULL, matching_acls_count: 0)
+              end
+
+              delete_acl_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_groups_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETEGROUPS_RESULT` events
+    # @private
+    class DeleteGroupsHandler < BaseHandler
+      class << self
+        # Resolves the delete-groups handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_groups_result = Rdkafka::Bindings.rd_kafka_event_DeleteGroups_result(event_ptr)
+
+          # Get the number of delete group results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_group_result_array = Rdkafka::Bindings.rd_kafka_DeleteGroups_result_groups(delete_groups_result, pointer_to_size_t)
+          delete_group_results = GroupResult.create_group_results_from_array(pointer_to_size_t.read_int, delete_group_result_array)
+          delete_group_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if (delete_group_handle = Rdkafka::Admin::DeleteGroupsHandle.remove(delete_group_handle_ptr.address))
+            unless resolve_operation_error(event_ptr, delete_group_handle)
+              delete_group_handle[:response] = delete_group_results[0].result_error
+              delete_group_handle.result = Rdkafka::Admin::DeleteGroupsReport.new(
+                delete_group_results[0].error_string,
+                delete_group_results[0].result_name
+              )
+              delete_group_handle.broker_message = delete_group_handle.result.error_string
+
+              delete_group_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_topic_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETETOPICS_RESULT` events
+    # @private
+    class DeleteTopicHandler < BaseHandler
+      class << self
+        # Resolves the delete-topic handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_topics_result = Rdkafka::Bindings.rd_kafka_event_DeleteTopics_result(event_ptr)
+
+          # Get the number of topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_topic_result_array = Rdkafka::Bindings.rd_kafka_DeleteTopics_result_topics(delete_topics_result, pointer_to_size_t)
+          delete_topic_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, delete_topic_result_array)
+          delete_topic_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if delete_topic_handle = Rdkafka::Admin::DeleteTopicHandle.remove(delete_topic_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, delete_topic_handle)
+              delete_topic_handle[:response] = delete_topic_results[0].result_error
+              delete_topic_handle.result = Rdkafka::Admin::DeleteTopicReport.new(
+                delete_topic_results[0].error_string,
+                delete_topic_results[0].result_name
+              )
+              delete_topic_handle.broker_message = delete_topic_handle.result.error_string
+
+              delete_topic_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/describe_acl_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DESCRIBEACLS_RESULT` events
+    # @private
+    class DescribeAclHandler < BaseHandler
+      class << self
+        # Resolves the describe-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          describe_acl = DescribeAclResult.new(event_ptr)
+          describe_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if describe_acl_handle = Rdkafka::Admin::DescribeAclHandle.remove(describe_acl_handle_ptr.address)
+            describe_acl_handle[:response] = describe_acl.result_error
+            describe_acl_handle.broker_message = read_event_string(describe_acl.error_string)
+
+            describe_acl_handle.result = if describe_acl.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              Rdkafka::Admin::DescribeAclReport.new(
+                acls: describe_acl.matching_acls,
+                acls_count: describe_acl.matching_acls_count
+              )
+            else
+              Rdkafka::Admin::DescribeAclReport.new(acls: FFI::Pointer::NULL, acls_count: 0)
+            end
+
+            describe_acl_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end