rdkafka 0.22.0.beta1-x86_64-linux-gnu

data/lib/rdkafka/admin/acl_binding_result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Extracts attributes of rd_kafka_AclBinding_t
+    #
+    class AclBindingResult
+      attr_reader :result_error, :error_string, :matching_acl_resource_type,
+                  :matching_acl_resource_name, :matching_acl_resource_pattern_type,
+                  :matching_acl_principal, :matching_acl_host, :matching_acl_operation,
+                  :matching_acl_permission_type
+
+      # This attribute was initially released under the name that is now an alias
+      # We keep it for backwards compatibility but it was changed for the consistency
+      alias matching_acl_pattern_type matching_acl_resource_pattern_type
+
+      def initialize(matching_acl)
+        rd_kafka_error_pointer = Rdkafka::Bindings.rd_kafka_AclBinding_error(matching_acl)
+        @result_error = Rdkafka::Bindings.rd_kafka_error_code(rd_kafka_error_pointer)
+        error_string = Rdkafka::Bindings.rd_kafka_error_string(rd_kafka_error_pointer)
+
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+
+        @matching_acl_resource_type = Rdkafka::Bindings.rd_kafka_AclBinding_restype(matching_acl)
+        matching_acl_resource_name = Rdkafka::Bindings.rd_kafka_AclBinding_name(matching_acl)
+
+        if matching_acl_resource_name != FFI::Pointer::NULL
+          @matching_acl_resource_name = matching_acl_resource_name.read_string
+        end
+
+        @matching_acl_resource_pattern_type = Rdkafka::Bindings.rd_kafka_AclBinding_resource_pattern_type(matching_acl)
+        matching_acl_principal = Rdkafka::Bindings.rd_kafka_AclBinding_principal(matching_acl)
+
+        if matching_acl_principal != FFI::Pointer::NULL
+          @matching_acl_principal = matching_acl_principal.read_string
+        end
+
+        matching_acl_host = Rdkafka::Bindings.rd_kafka_AclBinding_host(matching_acl)
+
+        if matching_acl_host != FFI::Pointer::NULL
+          @matching_acl_host = matching_acl_host.read_string
+        end
+
+        @matching_acl_operation = Rdkafka::Bindings.rd_kafka_AclBinding_operation(matching_acl)
+        @matching_acl_permission_type = Rdkafka::Bindings.rd_kafka_AclBinding_permission_type(matching_acl)
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/config_binding_result.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # A single config binding result that represents its values extracted from C
+    class ConfigBindingResult
+      attr_reader :name, :value, :read_only, :default, :sensitive, :synonym, :synonyms
+
+      # @param config_ptr [FFI::Pointer] config pointer
+      def initialize(config_ptr)
+        @name = Bindings.rd_kafka_ConfigEntry_name(config_ptr)
+        @value = Bindings.rd_kafka_ConfigEntry_value(config_ptr)
+        @read_only = Bindings.rd_kafka_ConfigEntry_is_read_only(config_ptr)
+        @default = Bindings.rd_kafka_ConfigEntry_is_default(config_ptr)
+        @sensitive = Bindings.rd_kafka_ConfigEntry_is_sensitive(config_ptr)
+        @synonym = Bindings.rd_kafka_ConfigEntry_is_synonym(config_ptr)
+        @synonyms = []
+
+        # The code below builds up the config synonyms using same config binding
+        pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+        synonym_ptr = Bindings.rd_kafka_ConfigEntry_synonyms(config_ptr, pointer_to_size_t)
+        synonyms_ptr = synonym_ptr.read_array_of_pointer(pointer_to_size_t.read_int)
+
+        (1..pointer_to_size_t.read_int).map do |ar|
+          self.class.new synonyms_ptr[ar - 1]
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/config_resource_binding_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # A simple binding that represents the requested config resource
+    class ConfigResourceBindingResult
+      attr_reader :name, :type, :configs, :configs_count
+
+      def initialize(config_resource_ptr)
+        ffi_binding = Bindings::ConfigResource.new(config_resource_ptr)
+
+        @name = ffi_binding[:name]
+        @type = ffi_binding[:type]
+        @configs = []
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_acl_handle.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "create acl"
+      end
+
+      # @return [CreateAclReport] instance with rdkafka_response value as 0 and rdkafka_response_string value as empty string if the acl creation was successful
+      def create_result
+        CreateAclReport.new(rdkafka_response: self[:response], rdkafka_response_string: self[:response_string])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_acl_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateAclReport
+
+      # Upon successful creation of Acl RD_KAFKA_RESP_ERR_NO_ERROR - 0 is returned as rdkafka_response
+      # @return [Integer]
+      attr_reader :rdkafka_response
+
+
+      # Upon successful creation of Acl empty string will be returned as rdkafka_response_string
+      # @return [String]
+      attr_reader :rdkafka_response_string
+
+      def initialize(rdkafka_response:, rdkafka_response_string:)
+        @rdkafka_response = rdkafka_response
+        if rdkafka_response_string != FFI::Pointer::NULL
+          @rdkafka_response_string = rdkafka_response_string.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_partitions_handle.rb

@@ -0,0 +1,27 @@
+module Rdkafka
+  class Admin
+    class CreatePartitionsHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "create partitions"
+      end
+
+      # @return [Boolean] whether the create topic was successful
+      def create_result
+        CreatePartitionsReport.new(self[:error_string], self[:result_name])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: CreateTopicReport.new(self[:error_string], self[:result_name]).error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_partitions_report.rb

@@ -0,0 +1,6 @@
+module Rdkafka
+  class Admin
+    class CreatePartitionsReport < CreateTopicReport
+    end
+  end
+end

data/lib/rdkafka/admin/create_topic_handle.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateTopicHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "create topic"
+      end
+
+      # @return [Boolean] whether the create topic was successful
+      def create_result
+        CreateTopicReport.new(self[:error_string], self[:result_name])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: CreateTopicReport.new(self[:error_string], self[:result_name]).error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_topic_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateTopicReport
+      # Any error message generated from the CreateTopic
+      # @return [String]
+      attr_reader :error_string
+
+      # The name of the topic created
+      # @return [String]
+      attr_reader :result_name
+
+      def initialize(error_string, result_name)
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+        if result_name != FFI::Pointer::NULL
+          @result_name = result_name.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_acl_handle.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :matching_acls, :pointer,
+             :matching_acls_count, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "delete acl"
+      end
+
+      # @return [DeleteAclReport] instance with an array of matching_acls
+      def create_result
+        DeleteAclReport.new(matching_acls: self[:matching_acls], matching_acls_count: self[:matching_acls_count])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_acl_report.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteAclReport
+
+      # deleted acls
+      # @return [Rdkafka::Bindings::AclBindingResult]
+      attr_reader :deleted_acls
+
+      def initialize(matching_acls:, matching_acls_count:)
+        @deleted_acls=[]
+        if matching_acls != FFI::Pointer::NULL
+          acl_binding_result_pointers  = matching_acls.read_array_of_pointer(matching_acls_count)
+          (1..matching_acls_count).map do |matching_acl_index|
+            acl_binding_result = AclBindingResult.new(acl_binding_result_pointers[matching_acl_index - 1])
+            @deleted_acls << acl_binding_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_groups_handle.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteGroupsHandle < AbstractHandle
+      layout :pending, :bool, # TODO: ???
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "delete groups"
+      end
+
+      def create_result
+        DeleteGroupsReport.new(self[:error_string], self[:result_name])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: create_result.error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_groups_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteGroupsReport
+      # Any error message generated from the DeleteTopic
+      # @return [String]
+      attr_reader :error_string
+
+      # The name of the topic deleted
+      # @return [String]
+      attr_reader :result_name
+
+      def initialize(error_string, result_name)
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+        if result_name != FFI::Pointer::NULL
+          @result_name = result_name.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_topic_handle.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteTopicHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "delete topic"
+      end
+
+      # @return [Boolean] whether the delete topic was successful
+      def create_result
+        DeleteTopicReport.new(self[:error_string], self[:result_name])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: DeleteTopicReport.new(self[:error_string], self[:result_name]).error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_topic_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteTopicReport
+      # Any error message generated from the DeleteTopic
+      # @return [String]
+      attr_reader :error_string
+
+      # The name of the topic deleted
+      # @return [String]
+      attr_reader :result_name
+
+      def initialize(error_string, result_name)
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+        if result_name != FFI::Pointer::NULL
+          @result_name = result_name.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_acl_handle.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :acls, :pointer,
+             :acls_count, :int
+
+      # @return [String] the name of the operation.
+      def operation_name
+        "describe acl"
+      end
+
+      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      def create_result
+        DescribeAclReport.new(acls: self[:acls], acls_count: self[:acls_count])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_acl_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeAclReport
+
+      # acls that exists in the cluster for the resource_type, resource_name and pattern_type filters provided in the request.
+      # @return [Rdkafka::Bindings::AclBindingResult] array of matching acls.
+      attr_reader :acls
+
+      def initialize(acls:, acls_count:)
+        @acls=[]
+
+        if acls != FFI::Pointer::NULL
+          acl_binding_result_pointers  = acls.read_array_of_pointer(acls_count)
+          (1..acls_count).map do |acl_index|
+            acl_binding_result = AclBindingResult.new(acl_binding_result_pointers[acl_index - 1])
+            @acls << acl_binding_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_configs_handle.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeConfigsHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :config_entries, :pointer,
+             :entry_count, :int
+
+      # @return [String] the name of the operation.
+      def operation_name
+        "describe configs"
+      end
+
+      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      def create_result
+        DescribeConfigsReport.new(
+          config_entries: self[:config_entries],
+          entry_count: self[:entry_count]
+        )
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_configs_report.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeConfigsReport
+      attr_reader :resources
+
+      def initialize(config_entries:, entry_count:)
+        @resources=[]
+
+        return if config_entries == FFI::Pointer::NULL
+
+        config_entries
+          .read_array_of_pointer(entry_count)
+          .each { |config_resource_result_ptr| validate!(config_resource_result_ptr) }
+          .each do |config_resource_result_ptr|
+            config_resource_result = ConfigResourceBindingResult.new(config_resource_result_ptr)
+
+            pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+            configs_ptr = Bindings.rd_kafka_ConfigResource_configs(
+              config_resource_result_ptr,
+              pointer_to_size_t
+            )
+
+            configs_ptr
+              .read_array_of_pointer(pointer_to_size_t.read_int)
+              .map { |config_ptr| ConfigBindingResult.new(config_ptr) }
+              .each { |config_binding| config_resource_result.configs << config_binding }
+
+            @resources << config_resource_result
+          end
+      ensure
+        return if config_entries == FFI::Pointer::NULL
+
+        Bindings.rd_kafka_ConfigResource_destroy_array(config_entries, entry_count)
+      end
+
+      private
+
+      def validate!(config_resource_result_ptr)
+        code = Bindings.rd_kafka_ConfigResource_error(config_resource_result_ptr)
+
+        return if code.zero?
+
+        raise(
+          RdkafkaError.new(
+            code,
+            Bindings.rd_kafka_ConfigResource_error_string(config_resource_result_ptr)
+          )
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/incremental_alter_configs_handle.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class IncrementalAlterConfigsHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :config_entries, :pointer,
+             :entry_count, :int
+
+      # @return [String] the name of the operation.
+      def operation_name
+        "incremental alter configs"
+      end
+
+      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      def create_result
+        IncrementalAlterConfigsReport.new(
+          config_entries: self[:config_entries],
+          entry_count: self[:entry_count]
+        )
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/incremental_alter_configs_report.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class IncrementalAlterConfigsReport
+      attr_reader :resources
+
+      def initialize(config_entries:, entry_count:)
+        @resources=[]
+
+        return if config_entries == FFI::Pointer::NULL
+
+        config_entries
+          .read_array_of_pointer(entry_count)
+          .each { |config_resource_result_ptr| validate!(config_resource_result_ptr) }
+          .each do |config_resource_result_ptr|
+            config_resource_result = ConfigResourceBindingResult.new(config_resource_result_ptr)
+
+            pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+            configs_ptr = Bindings.rd_kafka_ConfigResource_configs(
+              config_resource_result_ptr,
+              pointer_to_size_t
+            )
+
+            configs_ptr
+              .read_array_of_pointer(pointer_to_size_t.read_int)
+              .map { |config_ptr| ConfigBindingResult.new(config_ptr) }
+              .each { |config_binding| config_resource_result.configs << config_binding }
+
+            @resources << config_resource_result
+          end
+      ensure
+        return if config_entries == FFI::Pointer::NULL
+
+        Bindings.rd_kafka_ConfigResource_destroy_array(config_entries, entry_count)
+      end
+
+      private
+
+      def validate!(config_resource_result_ptr)
+        code = Bindings.rd_kafka_ConfigResource_error(config_resource_result_ptr)
+
+        return if code.zero?
+
+        raise(
+          RdkafkaError.new(
+            code,
+            Bindings.rd_kafka_ConfigResource_error_string(config_resource_result_ptr)
+          )
+        )
+      end
+    end
+  end
+end