ruby-kafka-temp-fork 0.0.1

data/lib/kafka/protocol/add_offsets_to_txn_request.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class AddOffsetsToTxnRequest
+      def initialize(transactional_id: nil, producer_id:, producer_epoch:, group_id:)
+        @transactional_id = transactional_id
+        @producer_id = producer_id
+        @producer_epoch = producer_epoch
+        @group_id = group_id
+      end
+
+      def api_key
+        ADD_OFFSETS_TO_TXN_API
+      end
+
+      def response_class
+        AddOffsetsToTxnResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@transactional_id.to_s)
+        encoder.write_int64(@producer_id)
+        encoder.write_int16(@producer_epoch)
+        encoder.write_string(@group_id)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/add_offsets_to_txn_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class AddOffsetsToTxnResponse
+
+      attr_reader :error_code
+
+      def initialize(error_code:)
+        @error_code = error_code
+      end
+
+      def self.decode(decoder)
+        _throttle_time_ms = decoder.int32
+        error_code = decoder.int16
+        new(error_code: error_code)
+      end
+
+    end
+  end
+end

data/lib/kafka/protocol/add_partitions_to_txn_request.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class AddPartitionsToTxnRequest
+      def initialize(transactional_id: nil, producer_id:, producer_epoch:, topics:)
+        @transactional_id = transactional_id
+        @producer_id = producer_id
+        @producer_epoch = producer_epoch
+        @topics = topics
+      end
+
+      def api_key
+        ADD_PARTITIONS_TO_TXN_API
+      end
+
+      def response_class
+        AddPartitionsToTxnResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@transactional_id.to_s)
+        encoder.write_int64(@producer_id)
+        encoder.write_int16(@producer_epoch)
+        encoder.write_array(@topics.to_a) do |topic, partitions|
+          encoder.write_string(topic)
+          encoder.write_array(partitions) do |partition|
+            encoder.write_int32(partition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kafka/protocol/add_partitions_to_txn_response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class AddPartitionsToTxnResponse
+      class PartitionError
+        attr_reader :partition, :error_code
+
+        def initialize(partition:, error_code:)
+          @partition = partition
+          @error_code = error_code
+        end
+      end
+
+      class TopicPartitionsError
+        attr_reader :topic, :partitions
+
+        def initialize(topic:, partitions:)
+          @topic = topic
+          @partitions = partitions
+        end
+      end
+
+      attr_reader :errors
+
+      def initialize(errors:)
+        @errors = errors
+      end
+
+      def self.decode(decoder)
+        _throttle_time_ms = decoder.int32
+        errors = decoder.array do
+          TopicPartitionsError.new(
+            topic: decoder.string,
+            partitions: decoder.array do
+              PartitionError.new(
+                partition: decoder.int32,
+                error_code: decoder.int16
+              )
+            end
+          )
+        end
+        new(errors: errors)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/alter_configs_request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class AlterConfigsRequest
+      def initialize(resources:)
+        @resources = resources
+      end
+
+      def api_key
+        ALTER_CONFIGS_API
+      end
+
+      def api_version
+        0
+      end
+
+      def response_class
+        Protocol::AlterConfigsResponse
+      end
+
+      def encode(encoder)
+        encoder.write_array(@resources) do |type, name, configs|
+          encoder.write_int8(type)
+          encoder.write_string(name)
+
+          configs = configs.to_a
+          encoder.write_array(configs) do |config_name, config_value|
+            # Config value is nullable. In other cases, we must write the
+            # stringified value.
+            config_value = config_value.to_s unless config_value.nil?
+
+            encoder.write_string(config_name)
+            encoder.write_string(config_value)
+          end
+        end
+        # validate_only. We'll skip this feature.
+        encoder.write_boolean(false)
+      end
+    end
+
+  end
+end

data/lib/kafka/protocol/alter_configs_response.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class AlterConfigsResponse
+      class ResourceDescription
+        attr_reader :name, :type, :error_code, :error_message
+
+        def initialize(name:, type:, error_code:, error_message:)
+          @name = name
+          @type = type
+          @error_code = error_code
+          @error_message = error_message
+        end
+      end
+
+      attr_reader :resources
+
+      def initialize(throttle_time_ms:, resources:)
+        @throttle_time_ms = throttle_time_ms
+        @resources = resources
+      end
+
+      def self.decode(decoder)
+        throttle_time_ms = decoder.int32
+        resources = decoder.array do
+          error_code = decoder.int16
+          error_message = decoder.string
+
+          resource_type = decoder.int8
+          if Kafka::Protocol::RESOURCE_TYPES[resource_type].nil?
+            raise Kafka::ProtocolError, "Resource type not supported: #{resource_type}"
+          end
+          resource_name = decoder.string
+
+          ResourceDescription.new(
+            type: RESOURCE_TYPES[resource_type],
+            name: resource_name,
+            error_code: error_code,
+            error_message: error_message
+          )
+        end
+
+        new(throttle_time_ms: throttle_time_ms, resources: resources)
+      end
+    end
+
+  end
+end

data/lib/kafka/protocol/api_versions_request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class ApiVersionsRequest
+      def api_key
+        API_VERSIONS_API
+      end
+
+      def encode(encoder)
+        # Nothing to do.
+      end
+
+      def response_class
+        Protocol::ApiVersionsResponse
+      end
+    end
+
+  end
+end

data/lib/kafka/protocol/api_versions_response.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class ApiVersionsResponse
+      class ApiInfo
+        attr_reader :api_key, :min_version, :max_version
+
+        def initialize(api_key:, min_version:, max_version:)
+          @api_key, @min_version, @max_version = api_key, min_version, max_version
+        end
+
+        def api_name
+          Protocol.api_name(api_key)
+        end
+
+        def version_supported?(version)
+          (min_version..max_version).include?(version)
+        end
+
+        def to_s
+          "#{api_name}=#{min_version}..#{max_version}"
+        end
+
+        def inspect
+          "#<Kafka api version #{to_s}>"
+        end
+      end
+
+      attr_reader :error_code, :apis
+
+      def initialize(error_code:, apis:)
+        @error_code = error_code
+        @apis = apis
+      end
+
+      def self.decode(decoder)
+        error_code = decoder.int16
+
+        apis = decoder.array do
+          ApiInfo.new(
+            api_key: decoder.int16,
+            min_version: decoder.int16,
+            max_version: decoder.int16,
+          )
+        end
+
+        new(error_code: error_code, apis: apis)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/consumer_group_protocol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class ConsumerGroupProtocol
+      def initialize(version: 0, topics:, user_data: nil)
+        @version = version
+        @topics = topics
+        @user_data = user_data
+      end
+
+      def encode(encoder)
+        encoder.write_int16(@version)
+        encoder.write_array(@topics) {|topic| encoder.write_string(topic) }
+        encoder.write_bytes(@user_data)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/create_partitions_request.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class CreatePartitionsRequest
+      def initialize(topics:, timeout:)
+        @topics, @timeout = topics, timeout
+      end
+
+      def api_key
+        CREATE_PARTITIONS_API
+      end
+
+      def api_version
+        0
+      end
+
+      def response_class
+        Protocol::CreatePartitionsResponse
+      end
+
+      def encode(encoder)
+        encoder.write_array(@topics) do |topic, count, assignments|
+          encoder.write_string(topic)
+          encoder.write_int32(count)
+          encoder.write_array(assignments) do |assignment|
+            encoder.write_array(assignment) do |broker|
+              encoder.write_int32(broker)
+            end
+          end
+        end
+        # Timeout is in ms.
+        encoder.write_int32(@timeout * 1000)
+        # validate_only. There isn't any use case for this in real life. So
+        # let's ignore it for now
+        encoder.write_boolean(false)
+      end
+    end
+
+  end
+end

data/lib/kafka/protocol/create_partitions_response.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class CreatePartitionsResponse
+      attr_reader :errors
+
+      def initialize(throttle_time_ms:, errors:)
+        @throttle_time_ms = throttle_time_ms
+        @errors = errors
+      end
+
+      def self.decode(decoder)
+        throttle_time_ms = decoder.int32
+        errors = decoder.array do
+          topic = decoder.string
+          error_code = decoder.int16
+          error_message = decoder.string
+          [topic, error_code, error_message]
+        end
+
+        new(throttle_time_ms: throttle_time_ms, errors: errors)
+      end
+    end
+
+  end
+end

data/lib/kafka/protocol/create_topics_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    class CreateTopicsRequest
+      def initialize(topics:, timeout:)
+        @topics, @timeout = topics, timeout
+      end
+
+      def api_key
+        CREATE_TOPICS_API
+      end
+
+      def api_version
+        0
+      end
+
+      def response_class
+        Protocol::CreateTopicsResponse
+      end
+
+      def encode(encoder)
+        encoder.write_array(@topics) do |topic, config|
+          encoder.write_string(topic)
+          encoder.write_int32(config.fetch(:num_partitions))
+          encoder.write_int16(config.fetch(:replication_factor))
+
+          # Replica assignments. We don't care.
+          encoder.write_array([])
+
+          encoder.write_array(config.fetch(:config)) do |config_name, config_value|
+            config_value = config_value.to_s unless config_value.nil?
+            encoder.write_string(config_name)
+            encoder.write_string(config_value)
+          end
+        end
+
+        # Timeout is in ms.
+        encoder.write_int32(@timeout * 1000)
+      end
+    end
+
+  end
+end