omq 0.11.0 → 0.13.0

data/lib/omq/transport/inproc.rb

@@ -2,6 +2,7 @@
 
 require "async"
 require "async/queue"
+require_relative "inproc/direct_pipe"
 
 module OMQ
   module Transport
@@ -54,25 +55,7 @@ module OMQ
         #
         def connect(endpoint, engine)
           bound_engine = @mutex.synchronize { @registry[endpoint] }
-
-          unless bound_engine
-            # Endpoint not bound yet. Wait with timeout derived from
-            # reconnect_interval. If it doesn't appear, silently return —
-            # matching ZMQ 4.x behavior where inproc connect to an
-            # unbound endpoint succeeds but messages go nowhere.
-            # A background task retries periodically.
-            ri      = engine.options.reconnect_interval
-            timeout = ri.is_a?(Range) ? ri.begin : ri
-            promise = Async::Promise.new
-            @mutex.synchronize { @waiters[endpoint] << promise }
-            unless promise.wait?(timeout: timeout)
-              @mutex.synchronize { @waiters[endpoint].delete(promise) }
-              start_connect_retry(endpoint, engine)
-              return
-            end
-            bound_engine = @mutex.synchronize { @registry[endpoint] }
-          end
-
+          bound_engine ||= await_bind(endpoint, engine) or return
           establish_link(engine, bound_engine, endpoint)
         end
 
@@ -112,41 +95,51 @@ module OMQ
         def establish_link(client_engine, server_engine, endpoint)
           client_type = client_engine.socket_type
           server_type = server_engine.socket_type
-
           unless Protocol::ZMTP::VALID_PEERS[client_type]&.include?(server_type)
             raise Protocol::ZMTP::Error,
                   "incompatible socket types: #{client_type} cannot connect to #{server_type}"
           end
+          needs_cmds = needs_commands?(client_engine, server_engine, client_type, server_type)
+          client_pipe, server_pipe = make_pipe_pair(client_engine, server_engine, client_type, server_type, needs_cmds)
+          client_engine.connection_ready(client_pipe, endpoint: endpoint)
+          server_engine.connection_ready(server_pipe, endpoint: endpoint)
+        end
 
-          # Only PUB/SUB-family types exchange commands (SUBSCRIBE/CANCEL)
-          # over inproc. All other types use only the direct recv queue
-          # bypass for data, so no internal queues are needed.
-          needs_commands = COMMAND_TYPES.include?(client_type) ||
-                           COMMAND_TYPES.include?(server_type)
+        def needs_commands?(ce, se, ct, st)
+          COMMAND_TYPES.include?(ct) || COMMAND_TYPES.include?(st) ||
+            ce.options.qos >= 1 || se.options.qos >= 1
+        end
 
-          if needs_commands
+        def make_pipe_pair(ce, se, ct, st, needs_cmds)
+          if needs_cmds
             a_to_b = Async::Queue.new
             b_to_a = Async::Queue.new
           end
+          client = DirectPipe.new(send_queue: needs_cmds ? a_to_b : nil,
+                                  receive_queue: needs_cmds ? b_to_a : nil,
+                                  peer_identity: se.options.identity, peer_type: st.to_s)
+          server = DirectPipe.new(send_queue: needs_cmds ? b_to_a : nil,
+                                  receive_queue: needs_cmds ? a_to_b : nil,
+                                  peer_identity: ce.options.identity, peer_type: ct.to_s)
+          client.peer = server
+          server.peer = client
+          [client, server]
+        end
 
-          client_pipe = DirectPipe.new(
-            send_queue:    needs_commands ? a_to_b : nil,
-            receive_queue: needs_commands ? b_to_a : nil,
-            peer_identity: server_engine.options.identity,
-            peer_type:     server_type.to_s,
-          )
-          server_pipe = DirectPipe.new(
-            send_queue:    needs_commands ? b_to_a : nil,
-            receive_queue: needs_commands ? a_to_b : nil,
-            peer_identity: client_engine.options.identity,
-            peer_type:     client_type.to_s,
-          )
-
-          client_pipe.peer = server_pipe
-          server_pipe.peer = client_pipe
-
-          client_engine.connection_ready(client_pipe, endpoint: endpoint)
-          server_engine.connection_ready(server_pipe, endpoint: endpoint)
+        def await_bind(endpoint, engine)
+          # Endpoint not bound yet — wait briefly then start background retry.
+          # Matches ZMQ 4.x: connect to unbound inproc succeeds silently.
+          ri      = engine.options.reconnect_interval
+          timeout = ri.is_a?(Range) ? ri.begin : ri
+          promise = Async::Promise.new
+          @mutex.synchronize { @waiters[endpoint] << promise }
+          if promise.wait?(timeout: timeout)
+            @mutex.synchronize { @registry[endpoint] }
+          else
+            @mutex.synchronize { @waiters[endpoint].delete(promise) }
+            start_connect_retry(endpoint, engine)
+            nil
+          end
         end
 
 
@@ -194,162 +187,6 @@ module OMQ
         end
       end
 
-      # A direct in-process pipe that transfers Ruby arrays through queues.
-      #
-      # Implements the same interface as Connection so routing strategies
-      # can use it transparently.
-      #
-      # When a routing strategy sets {#direct_recv_queue} on a pipe,
-      # {#send_message} enqueues directly into the peer's recv queue,
-      # bypassing the intermediate pipe queues and the recv pump task.
-      # This reduces inproc from 3 queue hops to 2 (send_queue →
-      # recv_queue), eliminating the internal pipe queue in between.
-      #
-      class DirectPipe
-        # @return [String] peer's socket type
-        #
-        attr_reader :peer_socket_type
-
-
-        # @return [String] peer's identity
-        #
-        attr_reader :peer_identity
-
-
-        # @return [DirectPipe, nil] the other end of this pipe pair
-        #
-        attr_accessor :peer
-
-
-        # @return [Async::LimitedQueue, nil] when set, {#send_message}
-        #   enqueues directly here instead of using the internal queue
-        #
-        attr_reader :direct_recv_queue
-
-
-        # @return [Proc, nil] optional transform applied before
-        #   enqueuing into {#direct_recv_queue}
-        #
-        attr_accessor :direct_recv_transform
-
-
-        # @param send_queue [Async::Queue, nil] outgoing command queue
-        #   (nil for non-PUB/SUB types that don't exchange commands)
-        # @param receive_queue [Async::Queue, nil] incoming command queue
-        # @param peer_identity [String]
-        # @param peer_type [String]
-        #
-        def initialize(send_queue: nil, receive_queue: nil, peer_identity:, peer_type:)
-          @send_queue            = send_queue
-          @receive_queue         = receive_queue
-          @peer_identity         = peer_identity || "".b
-          @peer_socket_type      = peer_type
-          @closed                = false
-          @peer                  = nil
-          @direct_recv_queue     = nil
-          @direct_recv_transform = nil
-          @pending_direct        = nil
-        end
-
-
-        # Sets the direct recv queue. Drains any messages that were
-        # buffered before the queue was available.
-        #
-        def direct_recv_queue=(queue)
-          @direct_recv_queue = queue
-          if queue && @pending_direct
-            @pending_direct.each do |msg|
-              queue.enqueue(msg)
-            end
-            @pending_direct = nil
-          end
-        end
-
-
-        # Sends a multi-frame message.
-        #
-        # When {#direct_recv_queue} is set (inproc fast path), the
-        # message is delivered directly to the peer's recv queue,
-        # skipping the internal pipe queues and the recv pump.
-        #
-        # @param parts [Array<String>]
-        # @return [void]
-        #
-        def send_message(parts)
-          raise IOError, "closed" if @closed
-          if @direct_recv_queue
-            msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
-            @direct_recv_queue.enqueue(msg)
-          elsif @send_queue
-            @send_queue.enqueue(parts)
-          else
-            msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
-            (@pending_direct ||= []) << msg
-          end
-        end
-
-
-        alias write_message send_message
-
-
-        # No-op — inproc has no IO buffer to flush.
-        #
-        # @return [void]
-        #
-        def flush = nil
-
-
-        # Receives a multi-frame message.
-        #
-        # @return [Array<String>]
-        # @raise [EOFError] if closed
-        #
-        def receive_message
-          msg = @receive_queue.dequeue
-          raise EOFError, "connection closed" if msg.nil?
-          msg
-        end
-
-
-        # Sends a command via the internal command queue.
-        # Only available for PUB/SUB-family pipes.
-        #
-        # @param command [Protocol::ZMTP::Codec::Command]
-        # @return [void]
-        #
-        def send_command(command)
-          raise IOError, "closed" if @closed
-          @send_queue.enqueue([:command, command])
-        end
-
-
-        # Reads one command frame from the internal command queue.
-        # Used by PUB/XPUB subscription listeners.
-        #
-        # @return [Protocol::ZMTP::Codec::Frame]
-        #
-        def read_frame
-          loop do
-            item = @receive_queue.dequeue
-            raise EOFError, "connection closed" if item.nil?
-            if item.is_a?(Array) && item.first == :command
-              cmd = item[1]
-              return Protocol::ZMTP::Codec::Frame.new(cmd.to_body, command: true)
-            end
-          end
-        end
-
-
-        # Closes this pipe end.
-        #
-        # @return [void]
-        #
-        def close
-          return if @closed
-          @closed = true
-          @send_queue&.enqueue(nil) # close sentinel
-        end
-      end
     end
   end
 end

data/lib/omq/transport/ipc.rb

@@ -92,12 +92,24 @@ module OMQ
         end
 
 
-        # Registers the accept loop task owned by the engine.
+        # Spawns an accept loop task under +parent_task+.
+        # Yields an IO::Stream-wrapped client socket for each accepted connection.
         #
-        # @param task [Async::Task]
+        # @param parent_task [Async::Task]
+        # @yieldparam io [IO::Stream::Buffered]
         #
-        def accept_task=(task)
-          @task = task
+        def start_accept_loops(parent_task, &on_accepted)
+          @task = parent_task.async(transient: true, annotation: "ipc accept #{@endpoint}") do
+            loop do
+              client = @server.accept
+              Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
+            end
+          rescue Async::Stop
+          rescue IOError
+            # server closed
+          ensure
+            @server.close rescue nil
+          end
         end
 
 

data/lib/omq/transport/tcp.rb

@@ -17,7 +17,7 @@ module OMQ
         # @return [Listener]
         #
         def bind(endpoint, engine)
-          host, port = parse_endpoint(endpoint)
+          host, port = self.parse_endpoint(endpoint)
           host = "0.0.0.0" if host == "*"
 
           addrs = Addrinfo.getaddrinfo(host, port, nil, :STREAM, nil, ::Socket::AI_PASSIVE)
@@ -43,14 +43,23 @@ module OMQ
         # @param engine [Engine]
         # @return [void]
         #
+        # Validates that the endpoint's host can be resolved.
+        #
+        # @param endpoint [String]
+        # @return [void]
+        #
+        def validate_endpoint!(endpoint)
+          host, _port = parse_endpoint(endpoint)
+          Addrinfo.getaddrinfo(host, nil, nil, :STREAM) if host
+        end
+
+
         def connect(endpoint, engine)
-          host, port = parse_endpoint(endpoint)
+          host, port = self.parse_endpoint(endpoint)
           sock = TCPSocket.new(host, port)
           engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
         end
 
-        private
-
         # Parses a TCP endpoint URI into host and port.
         #
         # @param endpoint [String]
@@ -90,12 +99,26 @@ module OMQ
         end
 
 
-        # Registers accept loop tasks owned by the engine.
+        # Spawns accept loop tasks under +parent_task+.
+        # Yields an IO::Stream-wrapped client socket for each accepted connection.
         #
-        # @param tasks [Array<Async::Task>]
+        # @param parent_task [Async::Task]
+        # @yieldparam io [IO::Stream::Buffered]
         #
-        def accept_tasks=(tasks)
-          @tasks = tasks
+        def start_accept_loops(parent_task, &on_accepted)
+          @tasks = @servers.map do |server|
+            parent_task.async(transient: true, annotation: "tcp accept #{@endpoint}") do
+              loop do
+                client = server.accept
+                Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
+              end
+            rescue Async::Stop
+            rescue IOError
+              # server closed
+            ensure
+              server.close rescue nil
+            end
+          end
         end
 
 

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/lib/omq.rb

@@ -8,9 +8,9 @@
 
 require "protocol/zmtp"
 require "io/stream"
-require "openssl"
 
 require_relative "omq/version"
+require_relative "omq/monitor_event"
 
 module OMQ
   # Raised when an internal pump task crashes unexpectedly.
@@ -19,6 +19,8 @@ module OMQ
   class SocketDeadError < RuntimeError; end
 
   # Errors raised when a peer disconnects or resets the connection.
+  # Not frozen at load time — transport plugins append to this before
+  # the first bind/connect, which freezes both arrays.
   CONNECTION_LOST = [
     EOFError,
     IOError,
@@ -27,8 +29,7 @@ module OMQ
     Errno::ECONNABORTED,
     Errno::ENOTCONN,
     IO::Stream::ConnectionResetError,
-    OpenSSL::SSL::SSLError,
-  ].freeze
+  ]
 
   # Errors raised when a peer cannot be reached.
   CONNECTION_FAILED = [
@@ -38,13 +39,12 @@ module OMQ
     Errno::EHOSTUNREACH,
     Errno::ENETUNREACH,
     Socket::ResolutionError,
-  ].freeze
+  ]
 end
 
 # Transport
 require_relative "omq/transport/inproc"
 require_relative "omq/transport/tcp"
-require_relative "omq/transport/tls"
 require_relative "omq/transport/ipc"
 
 # Core
@@ -64,15 +64,6 @@ require_relative "omq/routing/xpub"
 require_relative "omq/routing/xsub"
 require_relative "omq/routing/push"
 require_relative "omq/routing/pull"
-require_relative "omq/routing/scatter"
-require_relative "omq/routing/gather"
-require_relative "omq/routing/channel"
-require_relative "omq/routing/client"
-require_relative "omq/routing/server"
-require_relative "omq/routing/radio"
-require_relative "omq/routing/dish"
-require_relative "omq/routing/peer"
-require_relative "omq/single_frame"
 require_relative "omq/engine"
 require_relative "omq/queue_interface"
 require_relative "omq/readable"
@@ -85,11 +76,6 @@ require_relative "omq/router_dealer"
 require_relative "omq/pub_sub"
 require_relative "omq/push_pull"
 require_relative "omq/pair"
-require_relative "omq/scatter_gather"
-require_relative "omq/channel"
-require_relative "omq/client_server"
-require_relative "omq/radio_dish"
-require_relative "omq/peer"
 
 # For the purists.
 ØMQ = OMQ

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -65,49 +65,44 @@ files:
 - LICENSE
 - README.md
 - lib/omq.rb
-- lib/omq/channel.rb
-- lib/omq/client_server.rb
+- lib/omq/drop_queue.rb
 - lib/omq/engine.rb
+- lib/omq/engine/connection_setup.rb
+- lib/omq/engine/heartbeat.rb
+- lib/omq/engine/reconnect.rb
+- lib/omq/engine/recv_pump.rb
+- lib/omq/monitor_event.rb
 - lib/omq/options.rb
 - lib/omq/pair.rb
-- lib/omq/peer.rb
 - lib/omq/pub_sub.rb
 - lib/omq/push_pull.rb
 - lib/omq/queue_interface.rb
-- lib/omq/radio_dish.rb
 - lib/omq/reactor.rb
 - lib/omq/readable.rb
 - lib/omq/req_rep.rb
 - lib/omq/router_dealer.rb
 - lib/omq/routing.rb
-- lib/omq/routing/channel.rb
-- lib/omq/routing/client.rb
+- lib/omq/routing/conn_send_pump.rb
 - lib/omq/routing/dealer.rb
-- lib/omq/routing/dish.rb
+- lib/omq/routing/fair_queue.rb
+- lib/omq/routing/fair_recv.rb
 - lib/omq/routing/fan_out.rb
-- lib/omq/routing/gather.rb
 - lib/omq/routing/pair.rb
-- lib/omq/routing/peer.rb
 - lib/omq/routing/pub.rb
 - lib/omq/routing/pull.rb
 - lib/omq/routing/push.rb
-- lib/omq/routing/radio.rb
 - lib/omq/routing/rep.rb
 - lib/omq/routing/req.rb
 - lib/omq/routing/round_robin.rb
 - lib/omq/routing/router.rb
-- lib/omq/routing/scatter.rb
-- lib/omq/routing/server.rb
 - lib/omq/routing/sub.rb
 - lib/omq/routing/xpub.rb
 - lib/omq/routing/xsub.rb
-- lib/omq/scatter_gather.rb
-- lib/omq/single_frame.rb
 - lib/omq/socket.rb
 - lib/omq/transport/inproc.rb
+- lib/omq/transport/inproc/direct_pipe.rb
 - lib/omq/transport/ipc.rb
 - lib/omq/transport/tcp.rb
-- lib/omq/transport/tls.rb
 - lib/omq/version.rb
 - lib/omq/writable.rb
 homepage: https://github.com/zeromq/omq

data/lib/omq/channel.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class CHANNEL < Socket
-    include Readable
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      _init_engine(:CHANNEL, linger: linger, backend: backend)
-      _attach(endpoints, default: :connect)
-    end
-  end
-end

data/lib/omq/client_server.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class CLIENT < Socket
-    include Readable
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      _init_engine(:CLIENT, linger: linger, backend: backend)
-      _attach(endpoints, default: :connect)
-    end
-  end
-
-  class SERVER < Socket
-    include Readable
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      _init_engine(:SERVER, linger: linger, backend: backend)
-      _attach(endpoints, default: :bind)
-    end
-
-    # Sends a message to a specific peer by routing ID.
-    #
-    # @param routing_id [String] 4-byte routing ID
-    # @param message [String] message body
-    # @return [self]
-    #
-    def send_to(routing_id, message)
-      parts = [routing_id.b.freeze, message.b.freeze]
-      with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
-      self
-    end
-  end
-end

data/lib/omq/peer.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class PEER < Socket
-    include Readable
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      _init_engine(:PEER, linger: linger, backend: backend)
-      _attach(endpoints, default: :connect)
-    end
-
-    # Sends a message to a specific peer by routing ID.
-    #
-    # @param routing_id [String] 4-byte routing ID
-    # @param message [String] message body
-    # @return [self]
-    #
-    def send_to(routing_id, message)
-      parts = [routing_id.b.freeze, message.b.freeze]
-      with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
-      self
-    end
-  end
-end

data/lib/omq/radio_dish.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class RADIO < Socket
-    include Writable
-
-    def initialize(endpoints = nil, linger: 0, conflate: false, backend: nil)
-      _init_engine(:RADIO, linger: linger, conflate: conflate, backend: backend)
-      _attach(endpoints, default: :bind)
-    end
-
-    # Publishes a message to a group.
-    #
-    # @param group [String] group name
-    # @param body [String] message body
-    # @return [self]
-    #
-    def publish(group, body)
-      with_timeout(@options.write_timeout) do
-        @engine.enqueue_send([group.b.freeze, body.b.freeze])
-      end
-      self
-    end
-
-    # Sends a message to a group.
-    #
-    # @param message [String] message body (requires group: kwarg)
-    # @param group [String] group name
-    # @return [self]
-    #
-    def send(message, group: nil)
-      raise ArgumentError, "RADIO requires a group (use group: kwarg, publish, or << [group, body])" unless group
-      publish(group, message)
-    end
-
-    # Sends a message to a group via [group, body] array.
-    #
-    # @param message [Array<String>] [group, body]
-    # @return [self]
-    #
-    def <<(message)
-      raise ArgumentError, "RADIO requires [group, body] array" unless message.is_a?(Array) && message.size == 2
-      publish(message[0], message[1])
-    end
-  end
-
-  class DISH < Socket
-    include Readable
-
-    def initialize(endpoints = nil, linger: 0, group: nil, backend: nil)
-      _init_engine(:DISH, linger: linger, backend: backend)
-      _attach(endpoints, default: :connect)
-      join(group) if group
-    end
-
-    # Joins a group.
-    #
-    # @param group [String]
-    # @return [void]
-    #
-    def join(group)
-      @engine.routing.join(group)
-    end
-
-    # Leaves a group.
-    #
-    # @param group [String]
-    # @return [void]
-    #
-    def leave(group)
-      @engine.routing.leave(group)
-    end
-  end
-end