karafka-rdkafka 0.14.10 → 0.15.0.alpha1

data/lib/rdkafka/callbacks.rb

@@ -113,6 +113,42 @@ module Rdkafka
       end
     end
 
+    class DescribeConfigsResult
+      attr_reader :result_error, :error_string, :results, :results_count
+
+      def initialize(event_ptr)
+        @results=[]
+        @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
+        @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
+
+        if @result_error == 0
+          configs_describe_result = Rdkafka::Bindings.rd_kafka_event_DescribeConfigs_result(event_ptr)
+          # Get the number of matching acls
+          pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+          @results = Rdkafka::Bindings.rd_kafka_DescribeConfigs_result_resources(configs_describe_result, pointer_to_size_t)
+          @results_count = pointer_to_size_t.read_int
+        end
+      end
+    end
+
+    class IncrementalAlterConfigsResult
+      attr_reader :result_error, :error_string, :results, :results_count
+
+      def initialize(event_ptr)
+        @results=[]
+        @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
+        @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
+
+        if @result_error == 0
+          incremental_alter_result = Rdkafka::Bindings.rd_kafka_event_IncrementalAlterConfigs_result(event_ptr)
+          # Get the number of matching acls
+          pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+          @results = Rdkafka::Bindings.rd_kafka_IncrementalAlterConfigs_result_resources(incremental_alter_result, pointer_to_size_t)
+          @results_count = pointer_to_size_t.read_int
+        end
+      end
+    end
+
     # FFI Function used for Create Topic and Delete Topic callbacks
     BackgroundEventCallbackFunction = FFI::Function.new(
         :void, [:pointer, :pointer, :pointer]
@@ -123,20 +159,24 @@ module Rdkafka
     # @private
     class BackgroundEventCallback
       def self.call(_, event_ptr, _)
-        event_type = Rdkafka::Bindings.rd_kafka_event_type(event_ptr)
-        if event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_CREATETOPICS_RESULT
+        case Rdkafka::Bindings.rd_kafka_event_type(event_ptr)
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_CREATETOPICS_RESULT
           process_create_topic(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_DELETETOPICS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT
+          process_describe_configs(event_ptr)
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT
+          process_incremental_alter_configs(event_ptr)
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETETOPICS_RESULT
           process_delete_topic(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT
           process_create_partitions(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_CREATEACLS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_CREATEACLS_RESULT
           process_create_acl(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEACLS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEACLS_RESULT
           process_delete_acl(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_DESCRIBEACLS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DESCRIBEACLS_RESULT
           process_describe_acl(event_ptr)
-        elsif event_type == Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEGROUPS_RESULT
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEGROUPS_RESULT
           process_delete_groups(event_ptr)
         end
       end
@@ -156,7 +196,44 @@ module Rdkafka
           create_topic_handle[:response] = create_topic_results[0].result_error
           create_topic_handle[:error_string] = create_topic_results[0].error_string
           create_topic_handle[:result_name] = create_topic_results[0].result_name
-          create_topic_handle[:pending] = false
+
+          create_topic_handle.unlock
+        end
+      end
+
+      def self.process_describe_configs(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[:response_string] = describe_configs.error_string
+          describe_configs_handle[:pending] = false
+
+          if describe_configs.result_error == 0
+            describe_configs_handle[:config_entries] = describe_configs.results
+            describe_configs_handle[:entry_count] = describe_configs.results_count
+          end
+
+          describe_configs_handle.unlock
+        end
+      end
+
+      def self.process_incremental_alter_configs(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[:response_string] = incremental_alter.error_string
+          incremental_alter_handle[:pending] = false
+
+          if incremental_alter.result_error == 0
+            incremental_alter_handle[:config_entries] = incremental_alter.results
+            incremental_alter_handle[:entry_count] = incremental_alter.results_count
+          end
+
+          incremental_alter_handle.unlock
         end
       end
 
@@ -173,7 +250,8 @@ module Rdkafka
           delete_group_handle[:response] = delete_group_results[0].result_error
           delete_group_handle[:error_string] = delete_group_results[0].error_string
           delete_group_handle[:result_name] = delete_group_results[0].result_name
-          delete_group_handle[:pending] = false
+
+          delete_group_handle.unlock
         end
       end
 
@@ -190,7 +268,8 @@ module Rdkafka
           delete_topic_handle[:response] = delete_topic_results[0].result_error
           delete_topic_handle[:error_string] = delete_topic_results[0].error_string
           delete_topic_handle[:result_name] = delete_topic_results[0].result_name
-          delete_topic_handle[:pending] = false
+
+          delete_topic_handle.unlock
         end
       end
 
@@ -207,7 +286,8 @@ module Rdkafka
           create_partitions_handle[:response] = create_partitions_results[0].result_error
           create_partitions_handle[:error_string] = create_partitions_results[0].error_string
           create_partitions_handle[:result_name] = create_partitions_results[0].result_name
-          create_partitions_handle[:pending] = false
+
+          create_partitions_handle.unlock
         end
       end
 
@@ -223,7 +303,8 @@ module Rdkafka
         if create_acl_handle = Rdkafka::Admin::CreateAclHandle.remove(create_acl_handle_ptr.address)
           create_acl_handle[:response] = create_acl_results[0].result_error
           create_acl_handle[:response_string] = create_acl_results[0].error_string
-          create_acl_handle[:pending] = false
+
+          create_acl_handle.unlock
         end
       end
 
@@ -239,11 +320,13 @@ module Rdkafka
         if delete_acl_handle = Rdkafka::Admin::DeleteAclHandle.remove(delete_acl_handle_ptr.address)
           delete_acl_handle[:response] = delete_acl_results[0].result_error
           delete_acl_handle[:response_string] = delete_acl_results[0].error_string
-          delete_acl_handle[:pending] = false
+
           if delete_acl_results[0].result_error == 0
             delete_acl_handle[:matching_acls] = delete_acl_results[0].matching_acls
             delete_acl_handle[:matching_acls_count] = delete_acl_results[0].matching_acls_count
           end
+
+          delete_acl_handle.unlock
         end
       end
 
@@ -254,17 +337,18 @@ module Rdkafka
         if describe_acl_handle = Rdkafka::Admin::DescribeAclHandle.remove(describe_acl_handle_ptr.address)
           describe_acl_handle[:response] = describe_acl.result_error
           describe_acl_handle[:response_string] = describe_acl.error_string
-          describe_acl_handle[:pending] = false
+
           if describe_acl.result_error == 0
-            describe_acl_handle[:acls]       = describe_acl.matching_acls
+            describe_acl_handle[:acls] = describe_acl.matching_acls
             describe_acl_handle[:acls_count] = describe_acl.matching_acls_count
           end
+
+          describe_acl_handle.unlock
         end
       end
     end
 
     # FFI Function used for Message Delivery callbacks
-
     DeliveryCallbackFunction = FFI::Function.new(
         :void, [:pointer, :pointer, :pointer]
     ) do |client_ptr, message_ptr, opaque_ptr|
@@ -284,7 +368,6 @@ module Rdkafka
           delivery_handle[:partition] = message[:partition]
           delivery_handle[:offset] = message[:offset]
           delivery_handle[:topic_name] = FFI::MemoryPointer.from_string(topic_name)
-          delivery_handle[:pending] = false
 
           # Call delivery callback on opaque
           if opaque = Rdkafka::Config.opaques[opaque_ptr.to_i]
@@ -299,9 +382,10 @@ module Rdkafka
               delivery_handle
             )
           end
+
+          delivery_handle.unlock
         end
       end
     end
-
   end
 end

data/lib/rdkafka/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  VERSION = "0.14.10"
+  VERSION = "0.15.0.alpha1"
   LIBRDKAFKA_VERSION = "2.3.0"
   LIBRDKAFKA_SOURCE_SHA256 = "2d49c35c77eeb3d42fa61c43757fcbb6a206daa560247154e60642bcdcc14d12"
 end

data/lib/rdkafka.rb

@@ -23,7 +23,13 @@ require "rdkafka/admin/delete_acl_handle"
 require "rdkafka/admin/delete_acl_report"
 require "rdkafka/admin/describe_acl_handle"
 require "rdkafka/admin/describe_acl_report"
+require "rdkafka/admin/describe_configs_handle"
+require "rdkafka/admin/describe_configs_report"
+require "rdkafka/admin/incremental_alter_configs_handle"
+require "rdkafka/admin/incremental_alter_configs_report"
 require "rdkafka/admin/acl_binding_result"
+require "rdkafka/admin/config_binding_result"
+require "rdkafka/admin/config_resource_binding_result"
 require "rdkafka/bindings"
 require "rdkafka/callbacks"
 require "rdkafka/config"

data/spec/rdkafka/abstract_handle_spec.rb

@@ -76,37 +76,50 @@ describe Rdkafka::AbstractHandle do
   end
 
   describe "#wait" do
-    let(:pending_handle) { true }
+    context 'when pending_handle true' do
+      let(:pending_handle) { true }
 
-    it "should wait until the timeout and then raise an error" do
-      expect {
-        subject.wait(max_wait_timeout: 0.1)
-      }.to raise_error Rdkafka::AbstractHandle::WaitTimeoutError, /test_operation/
+      it "should wait until the timeout and then raise an error" do
+        expect(Kernel).not_to receive(:warn)
+        expect {
+          subject.wait(max_wait_timeout: 0.1)
+        }.to raise_error Rdkafka::AbstractHandle::WaitTimeoutError, /test_operation/
+      end
     end
 
-    context "when not pending anymore and no error" do
+    context 'when pending_handle false' do
       let(:pending_handle) { false }
-      let(:result) { 1 }
 
-      it "should return a result" do
-        wait_result = subject.wait
-        expect(wait_result).to eq(result)
+      it 'should show a deprecation warning when wait_timeout is set' do
+        expect(Kernel).to receive(:warn).with(Rdkafka::AbstractHandle::WAIT_TIMEOUT_DEPRECATION_MESSAGE)
+        subject.wait(wait_timeout: 0.1)
       end
 
-      it "should wait without a timeout" do
-        wait_result = subject.wait(max_wait_timeout: nil)
-        expect(wait_result).to eq(result)
+      context "without error" do
+        let(:result) { 1 }
+
+        it "should return a result" do
+          expect(Kernel).not_to receive(:warn)
+          wait_result = subject.wait
+          expect(wait_result).to eq(result)
+        end
+
+        it "should wait without a timeout" do
+          expect(Kernel).not_to receive(:warn)
+          wait_result = subject.wait(max_wait_timeout: nil)
+          expect(wait_result).to eq(result)
+        end
       end
-    end
 
-    context "when not pending anymore and there was an error" do
-      let(:pending_handle) { false }
-      let(:response) { 20 }
+      context "with error" do
+        let(:response) { 20 }
 
-      it "should raise an rdkafka error" do
-        expect {
-          subject.wait
-        }.to raise_error Rdkafka::RdkafkaError
+        it "should raise an rdkafka error" do
+          expect(Kernel).not_to receive(:warn)
+          expect {
+            subject.wait
+          }.to raise_error Rdkafka::RdkafkaError
+        end
       end
     end
   end

data/spec/rdkafka/admin_spec.rb

@@ -16,12 +16,12 @@ describe Rdkafka::Admin do
     admin.close
   end
 
-  let(:topic_name)               { "test-topic-#{Random.new.rand(0..1_000_000)}" }
+  let(:topic_name)               { "test-topic-#{SecureRandom.uuid}" }
   let(:topic_partition_count)    { 3 }
   let(:topic_replication_factor) { 1 }
   let(:topic_config)             { {"cleanup.policy" => "compact", "min.cleanable.dirty.ratio" => 0.8} }
   let(:invalid_topic_config)     { {"cleeeeenup.policee" => "campact"} }
-  let(:group_name)               { "test-group-#{Random.new.rand(0..1_000_000)}" }
+  let(:group_name)               { "test-group-#{SecureRandom.uuid}" }
 
   let(:resource_name)         {"acl-test-topic"}
   let(:resource_type)         {Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC}
@@ -129,6 +129,275 @@ describe Rdkafka::Admin do
     end
   end
 
+  describe "describe_configs" do
+    subject(:resources_results) { admin.describe_configs(resources).wait.resources }
+
+    before do
+      admin.create_topic(topic_name, 2, 1).wait
+      sleep(1)
+    end
+
+    context 'when describing config of an existing topic' do
+      let(:resources) { [{ resource_type: 2, resource_name: topic_name }] }
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq(topic_name)
+        expect(resources_results.first.configs.size).to be > 25
+        expect(resources_results.first.configs.first.name).to eq('compression.type')
+        expect(resources_results.first.configs.first.value).to eq('producer')
+        expect(resources_results.first.configs.map(&:synonyms)).not_to be_empty
+      end
+    end
+
+    context 'when describing config of a non-existing topic' do
+      let(:resources) { [{ resource_type: 2, resource_name: SecureRandom.uuid }] }
+
+      it 'expect to raise error' do
+        expect { resources_results }.to raise_error(Rdkafka::RdkafkaError, /unknown_topic_or_part/)
+      end
+    end
+
+    context 'when describing both existing and non-existing topics' do
+      let(:resources) do
+        [
+          { resource_type: 2, resource_name: topic_name },
+          { resource_type: 2, resource_name: SecureRandom.uuid }
+        ]
+      end
+
+      it 'expect to raise error' do
+        expect { resources_results }.to raise_error(Rdkafka::RdkafkaError, /unknown_topic_or_part/)
+      end
+    end
+
+    context 'when describing multiple existing topics' do
+      let(:resources) do
+        [
+          { resource_type: 2, resource_name: 'example_topic' },
+          { resource_type: 2, resource_name: topic_name }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(2)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq('example_topic')
+        expect(resources_results.last.type).to eq(2)
+        expect(resources_results.last.name).to eq(topic_name)
+      end
+    end
+
+    context 'when trying to describe invalid resource type' do
+      let(:resources) { [{ resource_type: 0, resource_name: SecureRandom.uuid }] }
+
+      it 'expect to raise error' do
+        expect { resources_results }.to raise_error(Rdkafka::RdkafkaError, /invalid_request/)
+      end
+    end
+
+    context 'when trying to describe invalid broker' do
+      let(:resources) { [{ resource_type: 4, resource_name: 'non-existing' }] }
+
+      it 'expect to raise error' do
+        expect { resources_results }.to raise_error(Rdkafka::RdkafkaError, /invalid_arg/)
+      end
+    end
+
+    context 'when trying to describe valid broker' do
+      let(:resources) { [{ resource_type: 4, resource_name: '1' }] }
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(4)
+        expect(resources_results.first.name).to eq('1')
+        expect(resources_results.first.configs.size).to be > 230
+        expect(resources_results.first.configs.first.name).to eq('log.cleaner.min.compaction.lag.ms')
+        expect(resources_results.first.configs.first.value).to eq('0')
+        expect(resources_results.first.configs.map(&:synonyms)).not_to be_empty
+      end
+    end
+
+    context 'when describing valid broker with topics in one request' do
+      let(:resources) do
+        [
+          { resource_type: 4, resource_name: '1' },
+          { resource_type: 2, resource_name: topic_name }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(2)
+        expect(resources_results.first.type).to eq(4)
+        expect(resources_results.first.name).to eq('1')
+        expect(resources_results.first.configs.size).to be > 230
+        expect(resources_results.first.configs.first.name).to eq('log.cleaner.min.compaction.lag.ms')
+        expect(resources_results.first.configs.first.value).to eq('0')
+        expect(resources_results.last.type).to eq(2)
+        expect(resources_results.last.name).to eq(topic_name)
+        expect(resources_results.last.configs.size).to be > 25
+        expect(resources_results.last.configs.first.name).to eq('compression.type')
+        expect(resources_results.last.configs.first.value).to eq('producer')
+      end
+    end
+  end
+
+  describe "incremental_alter_configs" do
+    subject(:resources_results) { admin.incremental_alter_configs(resources_with_configs).wait.resources }
+
+    before do
+      admin.create_topic(topic_name, 2, 1).wait
+      sleep(1)
+    end
+
+    context 'when altering one topic with one valid config via set' do
+      let(:target_retention) { (86400002 + rand(10_000)).to_s }
+      let(:resources_with_configs) do
+        [
+          {
+            resource_type: 2,
+            resource_name: topic_name,
+            configs: [
+              {
+                name: 'delete.retention.ms',
+                value: target_retention,
+                op_type: 0
+              }
+            ]
+          }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq(topic_name)
+
+        ret_config = admin.describe_configs(resources_with_configs).wait.resources.first.configs.find do |config|
+          config.name == 'delete.retention.ms'
+        end
+
+        expect(ret_config.value).to eq(target_retention)
+      end
+    end
+
+    context 'when altering one topic with one valid config via delete' do
+      let(:target_retention) { (8640002 + rand(10_000)).to_s }
+      let(:resources_with_configs) do
+        [
+          {
+            resource_type: 2,
+            resource_name: topic_name,
+            configs: [
+              {
+                name: 'delete.retention.ms',
+                value: target_retention,
+                op_type: 1
+              }
+            ]
+          }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq(topic_name)
+        ret_config = admin.describe_configs(resources_with_configs).wait.resources.first.configs.find do |config|
+          config.name == 'delete.retention.ms'
+        end
+
+        expect(ret_config.value).to eq('86400000')
+      end
+    end
+
+    context 'when altering one topic with one valid config via append' do
+      let(:target_policy) { 'compact' }
+      let(:resources_with_configs) do
+        [
+          {
+            resource_type: 2,
+            resource_name: topic_name,
+            configs: [
+              {
+                name: 'cleanup.policy',
+                value: target_policy,
+                op_type: 2
+              }
+            ]
+          }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq(topic_name)
+
+        ret_config = admin.describe_configs(resources_with_configs).wait.resources.first.configs.find do |config|
+          config.name == 'cleanup.policy'
+        end
+
+        expect(ret_config.value).to eq("delete,#{target_policy}")
+      end
+    end
+
+    context 'when altering one topic with one valid config via subtrack' do
+      let(:target_policy) { 'delete' }
+      let(:resources_with_configs) do
+        [
+          {
+            resource_type: 2,
+            resource_name: topic_name,
+            configs: [
+              {
+                name: 'cleanup.policy',
+                value: target_policy,
+                op_type: 3
+              }
+            ]
+          }
+        ]
+      end
+
+      it do
+        expect(resources_results.size).to eq(1)
+        expect(resources_results.first.type).to eq(2)
+        expect(resources_results.first.name).to eq(topic_name)
+
+        ret_config = admin.describe_configs(resources_with_configs).wait.resources.first.configs.find do |config|
+          config.name == 'cleanup.policy'
+        end
+
+        expect(ret_config.value).to eq('')
+      end
+    end
+
+    context 'when altering one topic with invalid config' do
+      let(:target_retention) { '-10' }
+      let(:resources_with_configs) do
+        [
+          {
+            resource_type: 2,
+            resource_name: topic_name,
+            configs: [
+              {
+                name: 'delete.retention.ms',
+                value: target_retention,
+                op_type: 0
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'expect to raise error' do
+        expect { resources_results }.to raise_error(Rdkafka::RdkafkaError, /invalid_config/)
+      end
+    end
+  end
+
   describe "#delete_topic" do
     describe "called with invalid input" do
       # https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/common/internals/Topic.java#L29
@@ -396,7 +665,10 @@ describe Rdkafka::Admin do
     end
 
     context 'when topic has less then desired number of partitions' do
-      before { admin.create_topic(topic_name, 1, 1).wait }
+      before do
+        admin.create_topic(topic_name, 1, 1).wait
+        sleep(1)
+      end
 
       it 'expect to change number of partitions' do
         admin.create_partitions(topic_name, 10).wait

data/spec/rdkafka/consumer_spec.rb

@@ -214,7 +214,7 @@ describe Rdkafka::Consumer do
 
         # This is needed because `enable.auto.offset.store` is true but when running in CI that
         # is overloaded, offset store lags
-        sleep(1)
+        sleep(2)
 
         consumer.commit
         expect(message1.offset).to eq message2.offset

data/spec/spec_helper.rb

@@ -139,7 +139,7 @@ RSpec.configure do |config|
     }.each do |topic, partitions|
       create_topic_handle = admin.create_topic(topic.to_s, partitions, 1)
       begin
-        create_topic_handle.wait(max_wait_timeout: 15)
+        create_topic_handle.wait(max_wait_timeout: 1.0)
       rescue Rdkafka::RdkafkaError => ex
         raise unless ex.message.match?(/topic_already_exists/)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.14.10
+  version: 0.15.0.alpha1
 platform: ruby
 authors:
 - Thijs Cadier
@@ -36,7 +36,7 @@ cert_chain:
   AnG1dJU+yL2BK7vaVytLTstJME5mepSZ46qqIJXMuWob/YPDmVaBF39TDSG9e34s
   msG3BiCqgOgHAnL23+CN3Rt8MsuRfEtoTKpJVcCfoEoNHOkc
   -----END CERTIFICATE-----
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2024-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -194,6 +194,8 @@ files:
 - lib/rdkafka/abstract_handle.rb
 - lib/rdkafka/admin.rb
 - lib/rdkafka/admin/acl_binding_result.rb
+- lib/rdkafka/admin/config_binding_result.rb
+- lib/rdkafka/admin/config_resource_binding_result.rb
 - lib/rdkafka/admin/create_acl_handle.rb
 - lib/rdkafka/admin/create_acl_report.rb
 - lib/rdkafka/admin/create_partitions_handle.rb
@@ -208,6 +210,10 @@ files:
 - lib/rdkafka/admin/delete_topic_report.rb
 - lib/rdkafka/admin/describe_acl_handle.rb
 - lib/rdkafka/admin/describe_acl_report.rb
+- lib/rdkafka/admin/describe_configs_handle.rb
+- lib/rdkafka/admin/describe_configs_report.rb
+- lib/rdkafka/admin/incremental_alter_configs_handle.rb
+- lib/rdkafka/admin/incremental_alter_configs_report.rb
 - lib/rdkafka/bindings.rb
 - lib/rdkafka/callbacks.rb
 - lib/rdkafka/config.rb