omq 0.11.0 → 0.12.0

data/lib/omq/routing/req.rb

@@ -12,9 +12,10 @@ module OMQ
       # @param engine [Engine]
       #
       def initialize(engine)
-        @engine     = engine
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @tasks      = []
+        @engine          = engine
+        @recv_queue      = Routing.build_queue(engine.options.recv_hwm, :block)
+        @tasks           = []
+        @state           = :ready        # :ready or :waiting_reply
         init_round_robin(engine)
       end
 
@@ -22,6 +23,7 @@ module OMQ
       #
       attr_reader :recv_queue, :send_queue
 
+
       # @param connection [Connection]
       #
       def connection_added(connection)
@@ -29,6 +31,7 @@ module OMQ
         signal_connection_available
         update_direct_pipe
         task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+          @state = :ready
           msg.first&.empty? ? msg[1..] : msg
         end
         @tasks << task if task
@@ -45,6 +48,8 @@ module OMQ
       # @param parts [Array<String>]
       #
       def enqueue(parts)
+        raise SocketError, "REQ socket expects send/recv/send/recv order" unless @state == :ready
+        @state = :waiting_reply
         enqueue_round_robin(parts)
       end
 

data/lib/omq/routing/round_robin.rb

@@ -12,6 +12,9 @@ module OMQ
     # their #initialize.
     #
     module RoundRobin
+      # @return [Boolean] true when the send pump is idle (not sending a batch)
+      def send_pump_idle? = @send_pump_idle
+
       private
 
 
@@ -23,7 +26,7 @@ module OMQ
         @connections          = []
         @cycle                = @connections.cycle
         @connection_available = Async::Promise.new
-        @send_queue           = Async::LimitedQueue.new(engine.options.send_hwm)
+        @send_queue           = Routing.build_queue(engine.options.send_hwm, :block)
         @send_pump_started    = false
         @send_pump_idle       = true
         @direct_pipe          = nil
@@ -90,13 +93,6 @@ module OMQ
       def transform_send(parts) = parts
 
 
-      # Starts the background send pump that dequeues messages
-      # and dispatches them round-robin across connections.
-      #
-      # @return [Boolean] true when the send pump is idle (not sending a batch)
-      def send_pump_idle? = @send_pump_idle
-
-
       def start_send_pump
         @send_pump_started = true
         @tasks << @engine.spawn_pump_task(annotation: "send pump") do
@@ -144,14 +140,11 @@ module OMQ
             @written << conn
           rescue *CONNECTION_LOST
             @engine.connection_lost(conn)
-            # Flush what we've written so far
             @written.each do |c|
               c.flush
             rescue *CONNECTION_LOST
-              # will be cleaned up
             end
             @written.clear
-            # Fall back to send_with_retry for this and remaining
             send_with_retry(parts)
             batch[(i + 1)..].each { |p| send_with_retry(p) }
             return
@@ -160,7 +153,6 @@ module OMQ
         @written.each do |conn|
           conn.flush
         rescue *CONNECTION_LOST
-          # will be cleaned up
         end
       end
     end

data/lib/omq/routing/router.rb

@@ -15,8 +15,8 @@ module OMQ
       #
       def initialize(engine)
         @engine                  = engine
-        @recv_queue              = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue              = Async::LimitedQueue.new(engine.options.send_hwm)
+        @recv_queue              = Routing.build_queue(engine.options.recv_hwm, :block)
+        @send_queue              = Routing.build_queue(engine.options.send_hwm, :block)
         @connections_by_identity = {}
         @identity_by_connection  = {}
         @tasks                   = []

data/lib/omq/routing/sub.rb

@@ -13,7 +13,7 @@ module OMQ
       def initialize(engine)
         @engine        = engine
         @connections   = []
-        @recv_queue    = Async::LimitedQueue.new(engine.options.recv_hwm)
+        @recv_queue    = Routing.build_queue(engine.options.recv_hwm, engine.options.on_mute)
         @subscriptions = Set.new
         @tasks         = []
       end
@@ -26,7 +26,6 @@ module OMQ
       #
       def connection_added(connection)
         @connections << connection
-        # Send existing subscriptions to new peer
         @subscriptions.each do |prefix|
           connection.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
         end

data/lib/omq/routing/xpub.rb

@@ -15,7 +15,7 @@ module OMQ
       #
       def initialize(engine)
         @engine     = engine
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
         @tasks      = []
         init_fan_out(engine)
       end

data/lib/omq/routing/xsub.rb

@@ -14,8 +14,8 @@ module OMQ
       def initialize(engine)
         @engine            = engine
         @connections       = []
-        @recv_queue        = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue        = Async::LimitedQueue.new(engine.options.send_hwm)
+        @recv_queue        = Routing.build_queue(engine.options.recv_hwm, engine.options.on_mute)
+        @send_queue        = Routing.build_queue(engine.options.send_hwm, :block)
         @tasks             = []
         @send_pump_started = false
         @send_pump_idle    = true

data/lib/omq/routing.rb

@@ -3,6 +3,7 @@
 require "async"
 require "async/queue"
 require "async/limited_queue"
+require_relative "drop_queue"
 
 module OMQ
   # Routing strategies for each ZMQ socket type.
@@ -14,6 +15,42 @@ module OMQ
     # Shared frozen empty binary string to avoid repeated allocations.
     EMPTY_BINARY = "".b.freeze
 
+    # Plugin registry for socket types not built into omq.
+    # Populated by sister gems via +Routing.register+.
+    #
+    @registry = {}
+
+    class << self
+      # Registers a routing strategy class for a socket type.
+      # Called by omq-draft (and other plugins) at require time.
+      #
+      # @param socket_type [Symbol] e.g. :RADIO, :CLIENT
+      # @param strategy_class [Class]
+      #
+      def register(socket_type, strategy_class)
+        @registry[socket_type] = strategy_class
+      end
+    end
+
+    # Builds a send or recv queue based on the mute strategy.
+    #
+    # @param hwm [Integer] high water mark
+    # @param on_mute [Symbol] :block, :drop_newest, or :drop_oldest
+    # @return [Async::LimitedQueue, DropQueue]
+    #
+    def self.build_queue(hwm, on_mute)
+      return Async::Queue.new if hwm.nil? || hwm == 0
+
+      case on_mute
+      when :block
+        Async::LimitedQueue.new(hwm)
+      when :drop_newest, :drop_oldest
+        DropQueue.new(hwm, strategy: on_mute)
+      else
+        raise ArgumentError, "unknown on_mute strategy: #{on_mute.inspect}"
+      end
+    end
+
     # Drains all available messages from +queue+ into +batch+ without
     # blocking. Call after the initial blocking dequeue.
     #
@@ -49,17 +86,10 @@ module OMQ
       when :SUB    then Sub
       when :XPUB   then XPub
       when :XSUB   then XSub
-      when :PUSH    then Push
-      when :PULL    then Pull
-      when :CLIENT  then Client
-      when :SERVER  then Server
-      when :RADIO   then Radio
-      when :DISH    then Dish
-      when :SCATTER then Scatter
-      when :GATHER  then Gather
-      when :PEER    then Peer
-      when :CHANNEL then Channel
-      else raise ArgumentError, "unknown socket type: #{socket_type}"
+      when :PUSH   then Push
+      when :PULL   then Pull
+      else
+        @registry[socket_type] or raise ArgumentError, "unknown socket type: #{socket_type.inspect}"
       end
     end
   end

data/lib/omq/socket.rb

@@ -36,8 +36,8 @@ module OMQ
       :heartbeat_ttl,         :heartbeat_ttl=,
       :heartbeat_timeout,     :heartbeat_timeout=,
       :max_message_size,      :max_message_size=,
-      :mechanism,             :mechanism=,
-      :tls_context,           :tls_context=
+      :on_mute,               :on_mute=,
+      :mechanism,             :mechanism=
 
 
     # Creates a new socket and binds it to the given endpoint.
@@ -141,6 +141,46 @@ module OMQ
     end
 
 
+    # Yields lifecycle events for this socket.
+    #
+    # Spawns a background fiber that reads from an internal event queue.
+    # The block receives {MonitorEvent} instances until the socket is
+    # closed or the returned task is stopped.
+    #
+    # @yield [event] called for each lifecycle event
+    # @yieldparam event [MonitorEvent]
+    # @return [Async::Task] the monitor task (call +#stop+ to end early)
+    #
+    # @example
+    #   task = socket.monitor do |event|
+    #     case event
+    #     in type: :connected, endpoint:
+    #       puts "peer up: #{endpoint}"
+    #     in type: :disconnected, endpoint:
+    #       puts "peer down: #{endpoint}"
+    #     end
+    #   end
+    #   # later:
+    #   task.stop
+    #
+    def monitor(&block)
+      ensure_parent_task
+      queue = Async::Queue.new
+      @engine.monitor_queue = queue
+      Reactor.run do
+        @engine.parent_task.async(transient: true, annotation: "monitor") do
+          while (event = queue.dequeue)
+            block.call(event)
+          end
+        rescue Async::Stop
+        ensure
+          @engine.monitor_queue = nil
+          block.call(MonitorEvent.new(type: :monitor_stopped))
+        end
+      end
+    end
+
+
     # Disable auto-reconnect for connected endpoints.
     def reconnect_enabled=(val)
       @engine.reconnect_enabled = val
@@ -226,13 +266,14 @@ module OMQ
     #
     def _init_engine(socket_type, linger:, send_hwm: nil, recv_hwm: nil,
                      send_timeout: nil, recv_timeout: nil, conflate: false,
-                     backend: nil)
+                     on_mute: nil, backend: nil)
       @options = Options.new(linger: linger)
       @options.send_hwm      = send_hwm     if send_hwm
       @options.recv_hwm      = recv_hwm     if recv_hwm
       @options.send_timeout   = send_timeout if send_timeout
       @options.recv_timeout   = recv_timeout if recv_timeout
       @options.conflate       = conflate
+      @options.on_mute        = on_mute      if on_mute
       @recv_buffer = []
       @recv_mutex  = Mutex.new
       @engine      = case backend

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.11.0"
+  VERSION = "0.12.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.12.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -65,49 +65,36 @@ 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/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/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
 - 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