ruby-kafka-custom 0.7.7.26

data/lib/kafka/protocol/find_coordinator_request.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class FindCoordinatorRequest
+      def initialize(coordinator_key:, coordinator_type:)
+        @coordinator_key  = coordinator_key
+        @coordinator_type = coordinator_type
+      end
+
+      def api_key
+        FIND_COORDINATOR_API
+      end
+
+      def api_version
+        1
+      end
+
+      def encode(encoder)
+        encoder.write_string(@coordinator_key)
+        encoder.write_int8(@coordinator_type)
+      end
+
+      def response_class
+        FindCoordinatorResponse
+      end
+    end
+  end
+end

data/lib/kafka/protocol/find_coordinator_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class FindCoordinatorResponse
+      attr_reader :error_code, :error_message
+
+      attr_reader :coordinator_id, :coordinator_host, :coordinator_port
+
+      def initialize(error_code:, error_message:, coordinator_id:, coordinator_host:, coordinator_port:)
+        @error_code = error_code
+        @coordinator_id = coordinator_id
+        @coordinator_host = coordinator_host
+        @coordinator_port = coordinator_port
+      end
+
+      def self.decode(decoder)
+        _throttle_time_ms = decoder.int32
+        new(
+          error_code: decoder.int16,
+          error_message: decoder.string,
+          coordinator_id: decoder.int32,
+          coordinator_host: decoder.string,
+          coordinator_port: decoder.int32,
+        )
+      end
+    end
+  end
+end

data/lib/kafka/protocol/heartbeat_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class HeartbeatRequest
+      def initialize(group_id:, generation_id:, member_id:)
+        @group_id = group_id
+        @generation_id = generation_id
+        @member_id = member_id
+      end
+
+      def api_key
+        HEARTBEAT_API
+      end
+
+      def response_class
+        HeartbeatResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@group_id)
+        encoder.write_int32(@generation_id)
+        encoder.write_string(@member_id)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/heartbeat_response.rb

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

data/lib/kafka/protocol/init_producer_id_request.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class InitProducerIDRequest
+      def initialize(transactional_id: nil, transactional_timeout:)
+        @transactional_id = transactional_id
+        @transactional_timeout = transactional_timeout
+      end
+
+      def api_key
+        INIT_PRODUCER_ID_API
+      end
+
+      def response_class
+        InitProducerIDResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@transactional_id)
+        # Timeout is in ms unit
+        encoder.write_int32(@transactional_timeout * 1000)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/init_producer_id_response.rb

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

data/lib/kafka/protocol/join_group_request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "kafka/protocol/consumer_group_protocol"
+
+module Kafka
+  module Protocol
+    class JoinGroupRequest
+      PROTOCOL_TYPE = "consumer"
+
+      def initialize(group_id:, session_timeout:, member_id:, topics: [])
+        @group_id = group_id
+        @session_timeout = session_timeout * 1000 # Kafka wants ms.
+        @member_id = member_id || ""
+        @protocol_type = PROTOCOL_TYPE
+        @group_protocols = {
+          "standard" => ConsumerGroupProtocol.new(topics: ["test-messages"]),
+        }
+      end
+
+      def api_key
+        JOIN_GROUP_API
+      end
+
+      def response_class
+        JoinGroupResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@group_id)
+        encoder.write_int32(@session_timeout)
+        encoder.write_string(@member_id)
+        encoder.write_string(@protocol_type)
+
+        encoder.write_array(@group_protocols) do |name, metadata|
+          encoder.write_string(name)
+          encoder.write_bytes(Encoder.encode_with(metadata))
+        end
+      end
+    end
+  end
+end

data/lib/kafka/protocol/join_group_response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class JoinGroupResponse
+      attr_reader :error_code
+
+      attr_reader :generation_id, :group_protocol
+
+      attr_reader :leader_id, :member_id, :members
+
+      def initialize(error_code:, generation_id:, group_protocol:, leader_id:, member_id:, members:)
+        @error_code = error_code
+        @generation_id = generation_id
+        @group_protocol = group_protocol
+        @leader_id = leader_id
+        @member_id = member_id
+        @members = members
+      end
+
+      def self.decode(decoder)
+        new(
+          error_code: decoder.int16,
+          generation_id: decoder.int32,
+          group_protocol: decoder.string,
+          leader_id: decoder.string,
+          member_id: decoder.string,
+          members: Hash[decoder.array { [decoder.string, decoder.bytes] }],
+        )
+      end
+    end
+  end
+end

data/lib/kafka/protocol/leave_group_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class LeaveGroupRequest
+      def initialize(group_id:, member_id:)
+        @group_id = group_id
+        @member_id = member_id
+      end
+
+      def api_key
+        LEAVE_GROUP_API
+      end
+
+      def response_class
+        LeaveGroupResponse
+      end
+
+      def encode(encoder)
+        encoder.write_string(@group_id)
+        encoder.write_string(@member_id)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/leave_group_response.rb

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

data/lib/kafka/protocol/list_groups_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class ListGroupsRequest
+      def api_key
+        LIST_GROUPS_API
+      end
+
+      def api_version
+        0
+      end
+
+      def response_class
+        Protocol::ListGroupsResponse
+      end
+
+      def encode(encoder)
+        # noop
+      end
+    end
+  end
+end

data/lib/kafka/protocol/list_groups_response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    class ListGroupsResponse
+      class GroupEntry
+        attr_reader :group_id, :protocol_type
+
+        def initialize(group_id:, protocol_type:)
+          @group_id = group_id
+          @protocol_type = protocol_type
+        end
+      end
+
+      attr_reader :error_code, :groups
+
+      def initialize(error_code:, groups:)
+        @error_code = error_code
+        @groups = groups
+      end
+
+      def self.decode(decoder)
+        error_code = decoder.int16
+        groups = decoder.array do
+          GroupEntry.new(
+            group_id: decoder.string,
+            protocol_type: decoder.string
+          )
+        end
+
+        new(error_code: error_code, groups: groups)
+      end
+    end
+  end
+end

data/lib/kafka/protocol/list_offset_request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+    # A request to list the available offsets for a set of topics/partitions.
+    #
+    # ## API Specification
+    #
+    #     OffsetRequest => ReplicaId [TopicName [Partition Time MaxNumberOfOffsets]]
+    #       ReplicaId => int32
+    #       IsolationLevel => int8
+    #       TopicName => string
+    #       Partition => int32
+    #       Time => int64
+    #
+    class ListOffsetRequest
+      ISOLATION_READ_UNCOMMITTED = 0
+      ISOLATION_READ_COMMITTED = 1
+
+      # @param topics [Hash]
+      def initialize(topics:)
+        @replica_id = REPLICA_ID
+        @topics = topics
+      end
+
+      def api_version
+        2
+      end
+
+      def api_key
+        LIST_OFFSET_API
+      end
+
+      def response_class
+        Protocol::ListOffsetResponse
+      end
+
+      def encode(encoder)
+        encoder.write_int32(@replica_id)
+        encoder.write_int8(ISOLATION_READ_COMMITTED)
+
+        encoder.write_array(@topics) do |topic, partitions|
+          encoder.write_string(topic)
+
+          encoder.write_array(partitions) do |partition|
+            encoder.write_int32(partition.fetch(:partition))
+            encoder.write_int64(partition.fetch(:time))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kafka/protocol/list_offset_response.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Kafka
+  module Protocol
+
+    # A response to a list offset request.
+    #
+    # ## API Specification
+    #
+    #     OffsetResponse => [TopicName [PartitionOffsets]]
+    #       ThrottleTimeMS => int32
+    #       PartitionOffsets => Partition ErrorCode Timestamp Offset
+    #       Partition => int32
+    #       ErrorCode => int16
+    #       Timestamp => int64
+    #       Offset => int64
+    #
+    class ListOffsetResponse
+      class TopicOffsetInfo
+        attr_reader :name, :partition_offsets
+
+        def initialize(name:, partition_offsets:)
+          @name = name
+          @partition_offsets = partition_offsets
+        end
+      end
+
+      class PartitionOffsetInfo
+        attr_reader :partition, :error_code, :timestamp, :offset
+
+        def initialize(partition:, error_code:, timestamp:, offset:)
+          @partition = partition
+          @error_code = error_code
+          @timestamp = timestamp
+          @offset = offset
+        end
+      end
+
+      attr_reader :topics
+
+      def initialize(topics:)
+        @topics = topics
+      end
+
+      def offset_for(topic, partition)
+        topic_info = @topics.find {|t| t.name == topic }
+
+        if topic_info.nil?
+          raise UnknownTopicOrPartition, "Unknown topic #{topic}"
+        end
+
+        partition_info = topic_info
+          .partition_offsets
+          .find {|p| p.partition == partition }
+
+        if partition_info.nil?
+          raise UnknownTopicOrPartition, "Unknown partition #{topic}/#{partition}"
+        end
+
+        Protocol.handle_error(partition_info.error_code)
+
+        partition_info.offset
+      end
+
+      def self.decode(decoder)
+        _throttle_time_ms = decoder.int32
+        topics = decoder.array do
+          name = decoder.string
+
+          partition_offsets = decoder.array do
+            PartitionOffsetInfo.new(
+              partition: decoder.int32,
+              error_code: decoder.int16,
+              timestamp: decoder.int64,
+              offset: decoder.int64
+            )
+          end
+
+          TopicOffsetInfo.new(
+            name: name,
+            partition_offsets: partition_offsets
+          )
+        end
+
+        new(topics: topics)
+      end
+    end
+  end
+end