omq-ffi 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7ad0a7f4790f7f0cb08c671209d5c22929d9a8cef2c64e31d0433222592c321
-  data.tar.gz: f3cd090c1b603a14e73ed2417b3b72fd4c389e4b78321b8068ed3379bfe311e0
+  metadata.gz: 644d87fb23e1290cbe1a879a705c835e16858479305a2ebf453b996a10e7cf77
+  data.tar.gz: bcd37e11f05619293cb8776b229c2317e488647ae6cfb4b7e401b72e6c614c7e
 SHA512:
-  metadata.gz: 503838fbd444270a982a105ca270a380411ddd8b5038f156de76b0fe66343bfd0c548dbc8d27e9e71144cbead45524e97f495cf4b39122938e814760159f23b6
-  data.tar.gz: 1675ee0f7c5d2a46ec2d31142db8f908ec3e041ae77a770ee14bbb5ac1ef7fc75e58ee756dda9a1096b95d1ea0ac819744666a60888fd47a8b44f878dc6d65c7
+  metadata.gz: e10cb300fdebdfe538149a55e901f0594c1f13d69a2d58adbde5674bb632e90dcfaa2fa11749364df762a7220f4a92ad8cfa09f186bd2869e4e6167f1f4792c1
+  data.tar.gz: b6971619da183b23a3969a6afdaa7ac8a09de80485253b2f1a82cad8d8d81af865d88c227297507f4c945c82bd2596dbc2dd8f85bd8d92338c4a1168b9f4e4f4

data/lib/omq/ffi/engine.rb

@@ -28,8 +28,14 @@ module OMQ
       attr_reader :peer_connected
       # @return [Async::Promise] resolved when all peers have disconnected
       attr_reader :all_peers_gone
+      # @return [Async::Task, nil] root of the engine's task tree
+      attr_reader :parent_task
       # @param value [Boolean] enables or disables automatic reconnection
       attr_writer :reconnect_enabled
+      # @note Monitor events are not yet emitted by the FFI backend; these
+      #   writers exist so Socket#monitor can attach without raising. Wiring
+      #   libzmq's zmq_socket_monitor is a TODO.
+      attr_writer :monitor_queue, :verbose_monitor
 
       # Routing stub that delegates subscribe/unsubscribe/join/leave to
       # libzmq socket options via the I/O thread.
@@ -168,6 +174,12 @@ module OMQ
 
       # Closes the socket and shuts down the I/O thread.
       #
+      # Honors `options.linger`:
+      #   nil → wait forever for Ruby-side queue to drain into libzmq
+      #         and for libzmq's own LINGER to flush to the network
+      #   0   → drop anything not yet in libzmq's kernel buffers, close fast
+      #   N   → up to N seconds for drain + N + 1s grace for join
+      #
       # @return [void]
       def close
         return if @closed
@@ -175,7 +187,15 @@ module OMQ
         if @io_thread
           @cmd_queue.push([:stop])
           wake_io_thread
-          @io_thread.join(2)
+          linger = @options.linger
+          if linger.nil?
+            @io_thread.join
+          elsif linger.zero?
+            @io_thread.join(0.5) # fast path: zmq_close is non-blocking with LINGER=0
+          else
+            @io_thread.join(linger + 1.0)
+          end
+          @io_thread.kill if @io_thread.alive? # hard stop if deadline exceeded
         else
           # IO thread never started — close socket directly
           L.zmq_close(@zmq_socket)
@@ -308,14 +328,48 @@ module OMQ
       rescue
         # Thread exit
       ensure
-        # Flush any messages still queued on the Ruby side into libzmq
-        # before zmq_close, so the socket's LINGER period covers them.
-        drain_sends rescue nil
+        # Drain Ruby-side send queue into libzmq, bounded by linger deadline.
+        # Then re-apply current linger to libzmq (user may have changed it
+        # after apply_options ran in initialize) and zmq_close uses it to
+        # flush libzmq's own queue to TCP.
+        drain_sends_with_deadline(zmq_fd_io, shutdown_deadline) rescue nil
+        linger_ms = @options.linger.nil? ? -1 : (@options.linger * 1000).to_i
+        set_int_option(L::ZMQ_LINGER, linger_ms) rescue nil
         zmq_fd_io&.close rescue nil
         L.zmq_close(@zmq_socket)
       end
 
 
+      # Returns a monotonic deadline for the Ruby-side drain phase, or nil
+      # for infinite, or the current clock for "drop immediately".
+      #
+      def shutdown_deadline
+        linger = @options.linger
+        return nil if linger.nil?
+        now = Async::Clock.now
+        return now if linger.zero?
+        now + linger
+      end
+
+
+      # Retries drain_sends with IO.select until either the Ruby-side queue
+      # is empty or the deadline is hit. nil deadline = wait forever.
+      #
+      def drain_sends_with_deadline(zmq_fd_io, deadline)
+        loop do
+          drain_sends
+          break if @pending_send.nil? && @send_queue.empty?
+          if deadline
+            remaining = deadline - Async::Clock.now
+            break if remaining <= 0
+            IO.select([zmq_fd_io], nil, nil, [remaining, 0.1].min)
+          else
+            IO.select([zmq_fd_io], nil, nil, 0.1)
+          end
+        end
+      end
+
+
       def zmq_has_events?
         @events_buf ||= ::FFI::MemoryPointer.new(:int)
         @events_len ||= ::FFI::MemoryPointer.new(:size_t).tap { |p| p.write(:size_t, ::FFI.type_size(:int)) }
@@ -344,16 +398,16 @@ module OMQ
           return false
         when :bind
           rc = L.zmq_bind(@zmq_socket, args[0])
-          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+          result&.push(rc >= 0 ? nil : syscall_error)
         when :connect
           rc = L.zmq_connect(@zmq_socket, args[0])
-          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+          result&.push(rc >= 0 ? nil : syscall_error)
         when :disconnect
           rc = L.zmq_disconnect(@zmq_socket, args[0])
-          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+          result&.push(rc >= 0 ? nil : syscall_error)
         when :unbind
           rc = L.zmq_unbind(@zmq_socket, args[0])
-          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+          result&.push(rc >= 0 ? nil : syscall_error)
         when :set_identity
           set_bytes_option(L::ZMQ_IDENTITY, args[0])
           result&.push(nil)
@@ -477,7 +531,9 @@ module OMQ
       def apply_options
         set_int_option(L::ZMQ_SNDHWM, @options.send_hwm)
         set_int_option(L::ZMQ_RCVHWM, @options.recv_hwm)
-        set_int_option(L::ZMQ_LINGER, (@options.linger * 1000).to_i)
+        # linger: nil = infinite (-1), N seconds → N*1000 ms, 0 = immediate
+        linger_ms = @options.linger.nil? ? -1 : (@options.linger * 1000).to_i
+        set_int_option(L::ZMQ_LINGER, linger_ms)
         set_int_option(L::ZMQ_CONFLATE, @options.conflate ? 1 : 0)
 
         if @options.identity && !@options.identity.empty?
@@ -531,6 +587,17 @@ module OMQ
       end
 
 
+      # Builds an Errno::XXX exception from the current zmq_errno so callers
+      # can rescue the same classes they would from the pure-Ruby backend
+      # (e.g. `Errno::EADDRINUSE`, `Errno::ECONNREFUSED`). Falls back to a
+      # plain SystemCallError when the errno is libzmq-specific.
+      #
+      def syscall_error
+        errno = L.zmq_errno
+        SystemCallError.new(L.zmq_strerror(errno), errno)
+      end
+
+
       def extract_tcp_port(endpoint)
         return nil unless endpoint
         port = endpoint.split(":").last.to_i

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-ffi
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Patrik Wenger