omq 0.11.0 → 0.12.0

data/lib/omq/routing/server.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module OMQ
-  module Routing
-    # SERVER socket routing: identity-based routing with auto-generated
-    # 4-byte routing IDs.
-    #
-    # Prepends routing ID on receive. Strips routing ID on send and
-    # routes to the identified connection.
-    #
-    class Server
-      # @param engine [Engine]
-      #
-      def initialize(engine)
-        @engine                     = engine
-        @recv_queue                 = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue                 = Async::LimitedQueue.new(engine.options.send_hwm)
-        @connections_by_routing_id  = {}
-        @routing_id_by_connection   = {}
-        @tasks                      = []
-        @send_pump_started          = false
-        @send_pump_idle             = true
-        @written                    = Set.new
-      end
-
-      # @return [Async::LimitedQueue]
-      #
-      attr_reader :recv_queue, :send_queue
-
-      # @param connection [Connection]
-      #
-      def connection_added(connection)
-        routing_id = SecureRandom.bytes(4)
-        @connections_by_routing_id[routing_id] = connection
-        @routing_id_by_connection[connection]  = routing_id
-
-        task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
-          [routing_id, *msg]
-        end
-        @tasks << task if task
-
-        start_send_pump unless @send_pump_started
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        routing_id = @routing_id_by_connection.delete(connection)
-        @connections_by_routing_id.delete(routing_id) if routing_id
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        @send_queue.enqueue(parts)
-      end
-
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      def send_pump_idle? = @send_pump_idle
-
-      private
-
-      def start_send_pump
-        @send_pump_started = true
-        @tasks << @engine.spawn_pump_task(annotation: "send pump") do
-          loop do
-            @send_pump_idle = true
-            batch = [@send_queue.dequeue]
-            @send_pump_idle = false
-            Routing.drain_send_queue(@send_queue, batch)
-
-            @written.clear
-            batch.each do |parts|
-              routing_id = parts.first
-              conn       = @connections_by_routing_id[routing_id]
-              next unless conn # silently drop if peer gone
-              begin
-                conn.write_message(parts[1..])
-                @written << conn
-              rescue *CONNECTION_LOST
-                # will be cleaned up
-              end
-            end
-
-            @written.each do |conn|
-              conn.flush
-            rescue *CONNECTION_LOST
-              # will be cleaned up
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/omq/scatter_gather.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class SCATTER < Socket
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil, backend: nil)
-      _init_engine(:SCATTER, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
-      _attach(endpoints, default: :connect)
-    end
-  end
-
-  class GATHER < Socket
-    include Readable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil, backend: nil)
-      _init_engine(:GATHER, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)
-      _attach(endpoints, default: :bind)
-    end
-  end
-end

data/lib/omq/single_frame.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  # Mixin that rejects multipart messages.
-  #
-  # All draft socket types (CLIENT, SERVER, RADIO, DISH, SCATTER,
-  # GATHER, PEER, CHANNEL) require single-frame messages for
-  # thread-safe atomic operations.
-  #
-  module SingleFrame
-    def send(message)
-      if message.is_a?(Array) && message.size > 1
-        raise ArgumentError, "#{self.class} does not support multipart messages"
-      end
-      super
-    end
-  end
-end

data/lib/omq/transport/tls.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-require "uri"
-require "openssl"
-require "io/stream"
-
-module OMQ
-  module Transport
-    # TLS transport — TLS v1.3 on top of TCP.
-    #
-    # Requires the socket's +tls_context+ to be set to an
-    # +OpenSSL::SSL::SSLContext+ before bind or connect.
-    #
-    module TLS
-      TLS_PREFIX = "tls+tcp://"
-
-      class << self
-        # Binds a TLS server.
-        #
-        # @param endpoint [String] e.g. "tls+tcp://127.0.0.1:5555" or "tls+tcp://*:0"
-        # @param engine [Engine]
-        # @return [Listener]
-        #
-        def bind(endpoint, engine)
-          ctx = require_context!(engine)
-          host, port = parse_endpoint(endpoint)
-          host = "0.0.0.0" if host == "*"
-
-          addrs = Addrinfo.getaddrinfo(host, port, nil, :STREAM, nil, ::Socket::AI_PASSIVE)
-          raise ::Socket::ResolutionError, "no addresses for #{host}" if addrs.empty?
-
-          servers     = []
-          actual_port = nil
-
-          addrs.each do |addr|
-            server = TCPServer.new(addr.ip_address, actual_port || port)
-            actual_port ||= server.local_address.ip_port
-            servers << server
-          end
-
-          host_part = host.include?(":") ? "[#{host}]" : host
-          resolved  = "#{TLS_PREFIX}#{host_part}:#{actual_port}"
-          Listener.new(resolved, servers, actual_port, ctx)
-        end
-
-        # Connects to a TLS endpoint.
-        #
-        # @param endpoint [String] e.g. "tls+tcp://127.0.0.1:5555"
-        # @param engine [Engine]
-        # @return [void]
-        #
-        def connect(endpoint, engine)
-          ctx = require_context!(engine)
-          host, port = parse_endpoint(endpoint)
-          tcp_sock   = TCPSocket.new(host, port)
-
-          ssl            = OpenSSL::SSL::SSLSocket.new(tcp_sock, ctx)
-          ssl.sync_close = true
-          ssl.hostname   = host
-          ssl.connect
-
-          engine.handle_connected(IO::Stream::Buffered.wrap(ssl), endpoint: endpoint)
-        rescue
-          tcp_sock&.close unless ssl&.sync_close
-          raise
-        end
-
-        private
-
-        # Validates and freezes the TLS context from engine options.
-        #
-        # The context SHOULD have min_version set to TLS1_3_VERSION.
-        # We cannot validate this because SSLContext#min_version is
-        # write-only in Ruby's OpenSSL binding.
-        #
-        # @return [OpenSSL::SSL::SSLContext]
-        # @raise [ArgumentError] if no context is set
-        #
-        def require_context!(engine)
-          ctx = engine.options.tls_context
-          raise ArgumentError, "tls_context must be set for tls+tcp:// endpoints" unless ctx
-          ctx.freeze unless ctx.frozen?
-          ctx
-        end
-
-        # Parses a tls+tcp:// endpoint URI into host and port.
-        #
-        # @param endpoint [String]
-        # @return [Array(String, Integer)]
-        #
-        def parse_endpoint(endpoint)
-          uri = URI.parse("http://#{endpoint.delete_prefix(TLS_PREFIX)}")
-          [uri.hostname, uri.port]
-        end
-      end
-
-      # A bound TLS listener.
-      #
-      class Listener
-        # @return [String] resolved endpoint with actual port
-        attr_reader :endpoint
-
-        # @return [Integer] bound port
-        attr_reader :port
-
-        # @return [Array<TCPServer>] bound server sockets
-        attr_reader :servers
-
-        # @return [OpenSSL::SSL::SSLContext]
-        attr_reader :ssl_context
-
-
-        # @param endpoint [String] resolved endpoint URI
-        # @param servers [Array<TCPServer>]
-        # @param port [Integer] bound port number
-        # @param ssl_context [OpenSSL::SSL::SSLContext]
-        #
-        def initialize(endpoint, servers, port, ssl_context)
-          @endpoint    = endpoint
-          @servers     = servers
-          @port        = port
-          @ssl_context = ssl_context
-          @tasks       = []
-        end
-
-
-        # Registers accept loop tasks owned by the engine.
-        #
-        # @param tasks [Array<Async::Task>]
-        #
-        def accept_tasks=(tasks)
-          @tasks = tasks
-        end
-
-
-        # Stops the listener.
-        #
-        def stop
-          @tasks.each(&:stop)
-          @servers.each { |s| s.close rescue nil }
-        end
-      end
-    end
-  end
-end