rdkafka 0.22.2 → 0.29.0

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

data/lib/rdkafka/callbacks/describe_configs_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT` events
+    # @private
+    class DescribeConfigsHandler < BaseHandler
+      class << self
+        # Resolves the describe-configs handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          describe_configs = DescribeConfigsResult.new(event_ptr)
+          describe_configs_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if describe_configs_handle = Rdkafka::Admin::DescribeConfigsHandle.remove(describe_configs_handle_ptr.address)
+            describe_configs_handle[:response] = describe_configs.result_error
+            describe_configs_handle.broker_message = read_event_string(describe_configs.error_string)
+
+            # Parsing can raise on per-resource errors. The exception is captured and re-raised on
+            # the waiting thread, since an exception leaving this callback would unwind through
+            # librdkafka native frames.
+            describe_configs_handle.result = begin
+              if describe_configs.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::DescribeConfigsReport.new(
+                  config_entries: describe_configs.results,
+                  entry_count: describe_configs.results_count
+                )
+              else
+                Rdkafka::Admin::DescribeConfigsReport.new(config_entries: FFI::Pointer::NULL, entry_count: 0)
+              end
+            rescue => e
+              e
+            end
+
+            describe_configs_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/incremental_alter_configs_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT` events
+    # @private
+    class IncrementalAlterConfigsHandler < BaseHandler
+      class << self
+        # Resolves the incremental-alter-configs handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          incremental_alter = IncrementalAlterConfigsResult.new(event_ptr)
+          incremental_alter_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if incremental_alter_handle = Rdkafka::Admin::IncrementalAlterConfigsHandle.remove(incremental_alter_handle_ptr.address)
+            incremental_alter_handle[:response] = incremental_alter.result_error
+            incremental_alter_handle.broker_message = read_event_string(incremental_alter.error_string)
+
+            # Parsing can raise on per-resource errors. The exception is captured and re-raised on
+            # the waiting thread, since an exception leaving this callback would unwind through
+            # librdkafka native frames.
+            incremental_alter_handle.result = begin
+              if incremental_alter.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::IncrementalAlterConfigsReport.new(
+                  config_entries: incremental_alter.results,
+                  entry_count: incremental_alter.results_count
+                )
+              else
+                Rdkafka::Admin::IncrementalAlterConfigsReport.new(config_entries: FFI::Pointer::NULL, entry_count: 0)
+              end
+            rescue => e
+              e
+            end
+
+            incremental_alter_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/list_offsets_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_LISTOFFSETS_RESULT` events
+    # @private
+    class ListOffsetsHandler < BaseHandler
+      class << self
+        # Resolves the list-offsets handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          list_offsets = ListOffsetsResult.new(event_ptr)
+          list_offsets_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if list_offsets_handle = Rdkafka::Admin::ListOffsetsHandle.remove(list_offsets_handle_ptr.address)
+            list_offsets_handle[:response] = list_offsets.result_error
+            list_offsets_handle.broker_message = read_event_string(list_offsets.error_string)
+
+            # Parsing can raise on per-partition errors. The exception is captured and re-raised
+            # on the waiting thread, since an exception leaving this callback would unwind through
+            # librdkafka native frames.
+            list_offsets_handle.result = begin
+              if list_offsets.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::ListOffsetsReport.new(
+                  result_infos: list_offsets.result_infos,
+                  result_count: list_offsets.result_count
+                )
+              else
+                Rdkafka::Admin::ListOffsetsReport.new(result_infos: FFI::Pointer::NULL, result_count: 0)
+              end
+            rescue => e
+              e
+            end
+
+            list_offsets_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end