pulsar-ruby 0.1.0.pre

data/lib/pulsar/internal/producer_impl.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Pulsar
+  module Internal
+    # Implements broker-side producer creation and unbatched sends.
+    class ProducerImpl
+      attr_reader :topic, :producer_id, :producer_name
+
+      def self.create(topic:, producer_id:, operation_timeout:, max_pending_messages: 1000,
+                      connection: nil, connection_provider: nil)
+        connection_provider ||= -> { connection }
+        new(
+          connection_provider: connection_provider,
+          topic: topic,
+          producer_id: producer_id,
+          operation_timeout: operation_timeout,
+          max_pending_messages: max_pending_messages
+        ).tap(&:attach)
+      end
+
+      def initialize(connection_provider:, topic:, producer_id:, operation_timeout:, max_pending_messages:)
+        @connection_provider = connection_provider
+        @connection = nil
+        @topic = topic
+        @producer_id = producer_id
+        @producer_name = nil
+        @operation_timeout = operation_timeout
+        @max_pending_messages = max_pending_messages
+        @pending_sends = 0
+        @pending_condition = ConditionVariable.new
+        @sequence_id = -1
+        @mutex = Mutex.new
+        @closed = false
+      end
+
+      def send(payload, properties: {}, key: nil, event_time: nil, timeout: nil)
+        raise ClosedError, 'producer is closed' if closed?
+
+        send_timeout = timeout || @operation_timeout
+        acquire_pending_send(timeout: send_timeout)
+
+        begin
+          attach unless attached?
+          sequence_id = next_sequence_id
+          command, metadata = CommandFactory.send_message(
+            producer_id: producer_id,
+            sequence_id: sequence_id,
+            producer_name: producer_name,
+            properties: properties,
+            key: key,
+            event_time: event_time,
+            publish_time: current_time_millis
+          )
+          response = @connection.send_message(command, metadata, String(payload).b, timeout: send_timeout)
+
+          raise BrokerError, "send failed: #{response.type}" unless response.type == :SEND_RECEIPT
+
+          message_id_from(response.send_receipt.message_id)
+        ensure
+          release_pending_send
+        end
+      end
+
+      def close
+        return nil if closed?
+
+        if attached?
+          request_id = @connection.next_request_id
+          command = CommandFactory.close_producer(producer_id: producer_id, request_id: request_id)
+          response = @connection.request(command, timeout: @operation_timeout)
+          raise BrokerError, "producer close failed: #{response.type}" unless response.type == :SUCCESS
+        end
+
+        @closed = true
+        nil
+      end
+
+      def closed?
+        @closed
+      end
+
+      private
+
+      def attach
+        @connection = @connection_provider.call
+        request_id = @connection.next_request_id
+        command = CommandFactory.producer(topic: topic, producer_id: producer_id, request_id: request_id)
+        response = @connection.request(command, timeout: @operation_timeout)
+
+        raise BrokerError, "producer creation failed: #{response.type}" unless response.type == :PRODUCER_SUCCESS
+
+        @producer_name = response.producer_success.producer_name
+        nil
+      end
+
+      def attached?
+        @connection&.connected?
+      end
+
+      def next_sequence_id
+        @mutex.synchronize do
+          @sequence_id += 1
+        end
+      end
+
+      def acquire_pending_send(timeout:)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        @mutex.synchronize do
+          loop do
+            raise ClosedError, 'producer is closed' if @closed
+
+            if @pending_sends < @max_pending_messages
+              @pending_sends += 1
+              return nil
+            end
+
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            raise TimeoutError, 'operation timed out' if remaining <= 0
+
+            @pending_condition.wait(@mutex, remaining)
+          end
+        end
+      end
+
+      def release_pending_send
+        @mutex.synchronize do
+          @pending_sends -= 1
+          @pending_condition.broadcast
+        end
+      end
+
+      def current_time_millis
+        (Time.now.to_f * 1000).to_i
+      end
+
+      def message_id_from(data)
+        MessageId.new(
+          ledger_id: data.ledgerId,
+          entry_id: data.entryId,
+          partition_index: data.partition,
+          batch_index: data.batch_index
+        )
+      end
+    end
+  end
+end

data/lib/pulsar/internal/promise.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pulsar
+  module Internal
+    # Thread-safe one-shot completion primitive for async broker responses.
+    class Promise
+      def initialize
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @completed = false
+        @value = nil
+        @error = nil
+      end
+
+      def fulfill(value)
+        complete(value, nil)
+      end
+
+      def reject(error)
+        complete(nil, error)
+      end
+
+      def wait(timeout:)
+        @mutex.synchronize do
+          @condition.wait(@mutex, timeout) unless @completed
+          raise TimeoutError, 'operation timed out' unless @completed
+          raise @error if @error
+
+          @value
+        end
+      end
+
+      def completed?
+        @mutex.synchronize { @completed }
+      end
+
+      private
+
+      def complete(value, error)
+        @mutex.synchronize do
+          return if @completed
+
+          @completed = true
+          @value = value
+          @error = error
+          @condition.broadcast
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/pulsar/internal/tcp_transport.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module Pulsar
+  module Internal
+    # Plain TCP transport for reading and writing broker frames.
+    class TcpTransport
+      def self.connect(host:, port:, connection_timeout:)
+        socket = Socket.tcp(host, port, connect_timeout: connection_timeout)
+        new(socket)
+      rescue SystemCallError, SocketError, IOError => e
+        raise ConnectionError, "failed to connect to #{host}:#{port}: #{e.message}"
+      end
+
+      def initialize(socket)
+        @socket = socket
+        @mutex = Mutex.new
+        @closed = false
+      end
+
+      def write(bytes)
+        ensure_open!
+        @socket.write(String(bytes).b)
+        nil
+      rescue SystemCallError, IOError => e
+        raise ConnectionError, "failed to write to socket: #{e.message}"
+      end
+
+      def read_exact(size, timeout:)
+        ensure_open!
+
+        Timeout.timeout(timeout, TimeoutError) do
+          buffer = +''
+          buffer.force_encoding(Encoding::BINARY)
+
+          while buffer.bytesize < size
+            chunk = @socket.read(size - buffer.bytesize)
+            raise ConnectionError, 'socket closed while reading' if chunk.nil?
+
+            buffer << chunk
+          end
+
+          buffer
+        end
+      rescue TimeoutError
+        raise TimeoutError, 'operation timed out'
+      rescue SystemCallError, IOError => e
+        raise ConnectionError, "failed to read from socket: #{e.message}"
+      end
+
+      def close
+        socket = @mutex.synchronize do
+          return nil if @closed
+
+          @closed = true
+          @socket
+        end
+
+        socket.close unless socket.closed?
+        nil
+      end
+
+      def closed?
+        @mutex.synchronize { @closed }
+      end
+
+      private
+
+      def ensure_open!
+        raise ClosedError, 'transport is closed' if closed?
+      end
+    end
+  end
+end

data/lib/pulsar/internal/thread_runtime.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pulsar
+  module Internal
+    # Tracks background threads and queues for coordinated shutdown.
+    class ThreadRuntime
+      def initialize
+        @mutex = Mutex.new
+        @threads = []
+        @queues = []
+        @shutdown = false
+      end
+
+      def promise
+        Promise.new
+      end
+
+      def queue(capacity:)
+        raise ClosedError, 'runtime is shut down' if shutdown?
+
+        BoundedQueue.new(capacity: capacity).tap do |queue|
+          @mutex.synchronize { @queues << queue }
+        end
+      end
+
+      def spawn(&block)
+        raise ClosedError, 'runtime is shut down' if shutdown?
+
+        thread = Thread.new(&block)
+        @mutex.synchronize { @threads << thread }
+        thread
+      end
+
+      def shutdown
+        threads, queues = @mutex.synchronize do
+          @shutdown = true
+          [@threads.dup, @queues.dup].tap do
+            @threads.clear
+            @queues.clear
+          end
+        end
+
+        queues.each(&:close)
+        threads.each(&:kill)
+        threads.each { |thread| thread.join(0.1) }
+        nil
+      end
+
+      def shutdown?
+        @mutex.synchronize { @shutdown }
+      end
+    end
+  end
+end

data/lib/pulsar/internal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pulsar
+  # Internal implementation namespace; not part of the public API.
+  module Internal
+  end
+end

data/lib/pulsar/message.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pulsar
+  # Immutable message value returned by consumers.
+  class Message
+    attr_reader :payload, :message_id, :properties, :key, :topic, :publish_time, :event_time
+
+    def initialize(payload:, message_id:, properties: {}, key: nil, topic: nil, publish_time: nil, event_time: nil)
+      raise ArgumentError, 'message_id must be a Pulsar::MessageId' unless message_id.is_a?(MessageId)
+
+      @payload = String(payload).b.freeze
+      @message_id = message_id
+      @properties = properties.transform_keys(&:to_s).transform_values(&:to_s).freeze
+      @key = key
+      @topic = topic
+      @publish_time = publish_time
+      @event_time = event_time
+      freeze
+    end
+  end
+end

data/lib/pulsar/message_id.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pulsar
+  # Comparable Pulsar message identifier.
+  class MessageId
+    include Comparable
+
+    attr_reader :ledger_id, :entry_id, :partition_index, :batch_index
+
+    def initialize(ledger_id:, entry_id:, partition_index: -1, batch_index: -1)
+      @ledger_id = Integer(ledger_id)
+      @entry_id = Integer(entry_id)
+      @partition_index = Integer(partition_index)
+      @batch_index = Integer(batch_index)
+      freeze
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(MessageId)
+
+      to_a <=> other.to_a
+    end
+
+    def eql?(other)
+      other.is_a?(MessageId) && to_a == other.to_a
+    end
+
+    def hash
+      to_a.hash
+    end
+
+    def inspect
+      "#<#{self.class.name} ledger_id=#{ledger_id} entry_id=#{entry_id} " \
+        "partition_index=#{partition_index} batch_index=#{batch_index}>"
+    end
+
+    protected
+
+    def to_a
+      [ledger_id, entry_id, partition_index, batch_index]
+    end
+  end
+end

data/lib/pulsar/producer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pulsar
+  # Public producer API for sending messages to one Pulsar topic.
+  class Producer
+    attr_reader :topic
+
+    def initialize(topic:, impl: nil)
+      @topic = String(topic)
+      @impl = impl
+      @closed = false
+    end
+
+    def send(payload, properties: {}, key: nil, event_time: nil, timeout: nil)
+      ensure_open!
+      raise UnsupportedFeatureError, 'producer send is not implemented yet' unless @impl
+
+      @impl.send(payload, properties: properties, key: key, event_time: event_time, timeout: timeout)
+    end
+
+    def close
+      return if closed?
+
+      @impl&.close
+      @closed = true
+      nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def ensure_open!
+      raise ClosedError, 'producer is closed' if closed?
+    end
+  end
+end