omq 0.10.0 → 0.12.0

data/lib/omq/transport/inproc.rb

@@ -118,11 +118,12 @@ module OMQ
                   "incompatible socket types: #{client_type} cannot connect to #{server_type}"
           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.
+          # PUB/SUB-family types exchange commands (SUBSCRIBE/CANCEL)
+          # over inproc. QoS >= 1 needs command queues for ACK/NACK.
           needs_commands = COMMAND_TYPES.include?(client_type) ||
-                           COMMAND_TYPES.include?(server_type)
+                           COMMAND_TYPES.include?(server_type) ||
+                           client_engine.options.qos >= 1 ||
+                           server_engine.options.qos >= 1
 
           if needs_commands
             a_to_b = Async::Queue.new
@@ -301,13 +302,30 @@ module OMQ
 
         # Receives a multi-frame message.
         #
+        # When a block is given, command items ([:command, cmd]) are
+        # yielded as command frames — matching the Protocol::ZMTP::Connection
+        # interface. Without a block, commands are silently skipped if
+        # the pipe has command queues.
+        #
         # @return [Array<String>]
         # @raise [EOFError] if closed
         #
         def receive_message
-          msg = @receive_queue.dequeue
-          raise EOFError, "connection closed" if msg.nil?
-          msg
+          loop do
+            item = @receive_queue.dequeue
+            raise EOFError, "connection closed" if item.nil?
+
+            if item.is_a?(Array) && item.first == :command
+              if block_given?
+                cmd   = item[1]
+                frame = Protocol::ZMTP::Codec::Frame.new(cmd.to_body, command: true)
+                yield frame
+              end
+              next
+            end
+
+            return item
+          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.10.0"
+  VERSION = "0.12.0"
 end

data/lib/omq/writable.rb

@@ -6,6 +6,7 @@ module OMQ
   # Pure Ruby Writable mixin. Enqueues messages to the engine's send path.
   #
   module Writable
+    include QueueWritable
     # Sends a message.
     #
     # @param message [String, Array<String>] message parts

data/lib/omq.rb

@@ -10,6 +10,7 @@ require "protocol/zmtp"
 require "io/stream"
 
 require_relative "omq/version"
+require_relative "omq/monitor_event"
 
 module OMQ
   # Raised when an internal pump task crashes unexpectedly.
@@ -18,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,
@@ -26,7 +29,7 @@ module OMQ
     Errno::ECONNABORTED,
     Errno::ENOTCONN,
     IO::Stream::ConnectionResetError,
-  ].freeze
+  ]
 
   # Errors raised when a peer cannot be reached.
   CONNECTION_FAILED = [
@@ -36,7 +39,7 @@ module OMQ
     Errno::EHOSTUNREACH,
     Errno::ENETUNREACH,
     Socket::ResolutionError,
-  ].freeze
+  ]
 end
 
 # Transport
@@ -61,16 +64,8 @@ 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"
 require_relative "omq/writable"
 
@@ -81,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.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -65,43 +65,32 @@ 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/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/radio_dish.rb
+- lib/omq/queue_interface.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/dealer.rb
-- lib/omq/routing/dish.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/ipc.rb

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)
-      _init_engine(:CHANNEL, linger: linger)
-      _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)
-      _init_engine(:CLIENT, linger: linger)
-      _attach(endpoints, default: :connect)
-    end
-  end
-
-  class SERVER < Socket
-    include Readable
-    include Writable
-    include SingleFrame
-
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:SERVER, linger: linger)
-      _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)
-      _init_engine(:PEER, linger: linger)
-      _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)
-      _init_engine(:RADIO, linger: linger, conflate: conflate)
-      _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)
-      _init_engine(:DISH, linger: linger)
-      _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

data/lib/omq/routing/channel.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module Routing
-    # CHANNEL socket routing: exclusive 1-to-1 bidirectional.
-    #
-    class Channel
-
-      # @param engine [Engine]
-      #
-      def initialize(engine)
-        @engine     = engine
-        @connection = nil
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue = Async::LimitedQueue.new(engine.options.send_hwm)
-        @tasks          = []
-        @send_pump_idle = true
-      end
-
-      # @return [Async::LimitedQueue]
-      #
-      attr_reader :recv_queue, :send_queue
-
-      # @param connection [Connection]
-      # @raise [RuntimeError] if a connection already exists
-      #
-      def connection_added(connection)
-        raise "CHANNEL allows only one peer" if @connection
-        @connection = connection
-        task = @engine.start_recv_pump(connection, @recv_queue)
-        @tasks << task if task
-        start_send_pump(connection) unless connection.is_a?(Transport::Inproc::DirectPipe)
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        if @connection == connection
-          @connection = nil
-          @send_pump&.stop
-          @send_pump = nil
-        end
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        conn = @connection
-        if conn.is_a?(Transport::Inproc::DirectPipe) && conn.direct_recv_queue
-          conn.send_message(parts)
-        else
-          @send_queue.enqueue(parts)
-        end
-      end
-
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      def send_pump_idle? = @send_pump_idle
-
-      private
-
-      def start_send_pump(conn)
-        @send_pump = @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)
-            batch.each { |parts| conn.write_message(parts) }
-            conn.flush
-          end
-        rescue *CONNECTION_LOST
-          @engine.connection_lost(conn)
-        end
-        @tasks << @send_pump
-      end
-    end
-  end
-end

data/lib/omq/routing/client.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module Routing
-    # CLIENT socket routing: round-robin send, fair-queue receive.
-    #
-    # Same as DEALER — no envelope manipulation.
-    #
-    class Client
-      include RoundRobin
-
-      # @param engine [Engine]
-      #
-      def initialize(engine)
-        @engine     = engine
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @tasks      = []
-        init_round_robin(engine)
-      end
-
-      # @return [Async::LimitedQueue]
-      #
-      attr_reader :recv_queue, :send_queue
-
-      # @param connection [Connection]
-      #
-      def connection_added(connection)
-        @connections << connection
-        signal_connection_available
-        update_direct_pipe
-        task = @engine.start_recv_pump(connection, @recv_queue)
-        @tasks << task if task
-        start_send_pump unless @send_pump_started
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        @connections.delete(connection)
-        update_direct_pipe
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        enqueue_round_robin(parts)
-      end
-
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-    end
-  end
-end

data/lib/omq/routing/dish.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module Routing
-    # DISH socket routing: group-based receive from RADIO peers.
-    #
-    # Sends JOIN/LEAVE commands to connected RADIO peers.
-    # Receives two-frame messages (group + body) from RADIO.
-    #
-    class Dish
-
-      # @param engine [Engine]
-      #
-      def initialize(engine)
-        @engine      = engine
-        @connections = []
-        @recv_queue  = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @groups      = Set.new
-        @tasks       = []
-      end
-
-      # @return [Async::LimitedQueue]
-      #
-      attr_reader :recv_queue
-
-      # @param connection [Connection]
-      #
-      def connection_added(connection)
-        @connections << connection
-        # Send existing group memberships to new peer
-        @groups.each do |group|
-          connection.send_command(Protocol::ZMTP::Codec::Command.join(group))
-        end
-        task = @engine.start_recv_pump(connection, @recv_queue)
-        @tasks << task if task
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        @connections.delete(connection)
-      end
-
-      # DISH is read-only.
-      #
-      def enqueue(_parts)
-        raise "DISH sockets cannot send"
-      end
-
-      # Joins a group.
-      #
-      # @param group [String]
-      #
-      def join(group)
-        @groups << group
-        @connections.each do |conn|
-          conn.send_command(Protocol::ZMTP::Codec::Command.join(group))
-        end
-      end
-
-      # Leaves a group.
-      #
-      # @param group [String]
-      #
-      def leave(group)
-        @groups.delete(group)
-        @connections.each do |conn|
-          conn.send_command(Protocol::ZMTP::Codec::Command.leave(group))
-        end
-      end
-
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-    end
-  end
-end