omq-ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88e0942ce849494a8af0baa0cc5d894a27c6c64c7ea2e15a726a203df262296d
+  data.tar.gz: 4d9e966c9bbdb5317112dd1aed5f7037f4b911f3096cfe3e103f75dbd019588d
+SHA512:
+  metadata.gz: 83f0e5f7e637634e5d07a56d91f4e3887b4d542b3cad88fc2189755b3857b01693871a10f0a5a2c4939981b634acd3a7915e8cd247947694fdb9c3afe4ce74d6
+  data.tar.gz: 4f1e5da9f453d8fa90816b16c712e718e1ad7855be0dfa53fa18582cbb52c217057034e2dbe1c432b073c12a0d50debc21989321817e4462bec927637c2fdfeb

data/README.md

@@ -0,0 +1,38 @@
+# OMQ::FFI -- libzmq Backend for OMQ
+
+Use libzmq under the same OMQ socket API. Requires libzmq 4.x installed
+on the system.
+
+```ruby
+require "omq"
+require "omq/ffi"
+
+push = OMQ::PUSH.new(backend: :ffi)
+push.connect("tcp://127.0.0.1:5555")
+push.send("hello from libzmq")
+```
+
+The FFI backend replaces the entire pure-Ruby ZMTP stack with libzmq.
+The socket API, options, and Async integration remain identical. A
+dedicated I/O thread per socket handles all libzmq operations (libzmq
+sockets are not thread-safe).
+
+## Interop
+
+FFI and native (pure Ruby) backends are wire-compatible. You can mix
+them freely:
+
+```ruby
+# native REP server
+rep = OMQ::REP.bind("tcp://127.0.0.1:5555")
+
+# FFI REQ client
+req = OMQ::REQ.new(backend: :ffi)
+req.connect("tcp://127.0.0.1:5555")
+```
+
+## Requirements
+
+- Ruby >= 3.3
+- libzmq 4.x (`libzmq5` / `libzmq3-dev` on Debian/Ubuntu)
+- [omq](https://github.com/paddor/omq) >= 0.10

data/lib/omq/ffi/engine.rb

@@ -0,0 +1,448 @@
+# frozen_string_literal: true
+
+require "async"
+
+module OMQ
+  module FFI
+    # FFI Engine — wraps a libzmq socket to implement the OMQ Engine contract.
+    #
+    # A dedicated I/O thread owns the zmq_socket exclusively (libzmq sockets
+    # are not thread-safe). Send and recv flow through queues, with an IO pipe
+    # to wake the Async fiber scheduler.
+    #
+    class Engine
+      L = Libzmq
+
+      attr_reader :options, :last_endpoint, :last_tcp_port, :connections, :routing
+      attr_reader :peer_connected, :all_peers_gone
+      attr_writer :reconnect_enabled
+
+      # Routing stub that delegates subscribe/unsubscribe/join/leave to
+      # libzmq socket options via the I/O thread.
+      #
+      class RoutingStub
+        attr_reader :subscriber_joined
+
+        def initialize(engine)
+          @engine            = engine
+          @subscriber_joined = Async::Promise.new
+        end
+
+        def subscribe(prefix)
+          @engine.send_cmd(:subscribe, prefix.b)
+        end
+
+        def unsubscribe(prefix)
+          @engine.send_cmd(:unsubscribe, prefix.b)
+        end
+
+        def join(group)
+          @engine.send_cmd(:join, group)
+        end
+
+        def leave(group)
+          @engine.send_cmd(:leave, group)
+        end
+      end
+
+      # @param socket_type [Symbol] e.g. :REQ, :PAIR
+      # @param options [Options]
+      #
+      def initialize(socket_type, options)
+        @socket_type    = socket_type
+        @options        = options
+        @last_endpoint  = nil
+        @last_tcp_port  = nil
+        @peer_connected = Async::Promise.new
+        @all_peers_gone = Async::Promise.new
+        @connections    = []
+        @closed         = false
+        @parent_task    = nil
+        @on_io_thread   = false
+
+        @zmq_socket = L.zmq_socket(OMQ::FFI.context, L::SOCKET_TYPES.fetch(@socket_type))
+        raise "zmq_socket failed: #{L.zmq_strerror(L.zmq_errno)}" if @zmq_socket.null?
+
+        apply_options
+
+        @routing = RoutingStub.new(self)
+
+        # Queues for cross-thread communication
+        @send_queue = Thread::Queue.new   # main → io thread
+        @recv_queue = Thread::Queue.new   # io thread → main
+        @cmd_queue  = Thread::Queue.new   # control commands → io thread
+
+        # Signal pipe: io thread → Async fiber (message received)
+        @recv_signal_r, @recv_signal_w = IO.pipe
+        # Wake pipe: main thread → io thread (send/cmd enqueued)
+        @wake_r, @wake_w = IO.pipe
+
+        @io_thread = nil
+      end
+
+      # --- Socket lifecycle ---
+
+      def bind(endpoint)
+        sync_identity
+        send_cmd(:bind, endpoint)
+        @last_endpoint = get_string_option(L::ZMQ_LAST_ENDPOINT)
+        @last_tcp_port = extract_tcp_port(@last_endpoint)
+        @connections << :ffi
+        @peer_connected.resolve(:ffi) unless @peer_connected.resolved?
+      end
+
+      def connect(endpoint)
+        sync_identity
+        send_cmd(:connect, endpoint)
+        @last_endpoint ||= endpoint
+        @last_tcp_port ||= extract_tcp_port(endpoint)
+        @connections << :ffi
+        @peer_connected.resolve(:ffi) unless @peer_connected.resolved?
+      end
+
+      def disconnect(endpoint)
+        send_cmd(:disconnect, endpoint)
+      end
+
+      def unbind(endpoint)
+        send_cmd(:unbind, endpoint)
+      end
+
+      def close
+        return if @closed
+        @closed = true
+        if @io_thread
+          @cmd_queue.push([:stop])
+          wake_io_thread
+          @io_thread.join(2)
+        else
+          # IO thread never started — close socket directly
+          L.zmq_close(@zmq_socket)
+        end
+        @recv_signal_r&.close rescue nil
+        @recv_signal_w&.close rescue nil
+        @wake_r&.close rescue nil
+        @wake_w&.close rescue nil
+      end
+
+      def capture_parent_task
+        return if @parent_task
+        if Async::Task.current?
+          @parent_task = Async::Task.current
+        else
+          @parent_task  = Reactor.root_task
+          @on_io_thread = true
+          Reactor.track_linger(@options.linger)
+        end
+      end
+
+      # --- Send ---
+
+      def enqueue_send(parts)
+        ensure_io_thread
+        @send_queue.push(parts)
+        wake_io_thread
+      end
+
+      # --- Recv ---
+
+      def dequeue_recv_batch(max)
+        ensure_io_thread
+        msg = wait_for_message
+        batch = [msg]
+        while batch.size < max
+          begin
+            batch << @recv_queue.pop(true)
+          rescue ThreadError
+            break
+          end
+        end
+        batch
+      end
+
+      def dequeue_recv_sentinel
+        @recv_queue.push(nil)
+        @recv_signal_w.write_nonblock(".", exception: false) rescue nil
+      end
+
+      # Send a control command to the I/O thread.
+      # @api private
+      #
+      def send_cmd(cmd, *args)
+        ensure_io_thread
+        result = Thread::Queue.new
+        @cmd_queue.push([cmd, args, result])
+        wake_io_thread
+        r = result.pop
+        raise r if r.is_a?(Exception)
+        r
+      end
+
+      def wake_io_thread
+        @wake_w.write_nonblock(".", exception: false)
+      end
+
+      private
+
+      # Waits for a message from the I/O thread's recv queue.
+      # Uses the signal pipe so Async can yield the fiber.
+      #
+      def wait_for_message
+        loop do
+          begin
+            return @recv_queue.pop(true)
+          rescue ThreadError
+            # empty
+          end
+          @recv_signal_r.wait_readable
+          @recv_signal_r.read_nonblock(256, exception: false)
+        end
+      end
+
+      def ensure_io_thread
+        return if @io_thread
+        @io_thread = Thread.new { io_loop }
+      end
+
+      # The I/O loop runs on a dedicated thread. It owns the zmq_socket
+      # exclusively and processes commands, sends, and recvs.
+      #
+      def io_loop
+        zmq_fd_io = IO.for_fd(get_zmq_fd, autoclose: false)
+
+        loop do
+          drain_cmds or break
+          drain_sends
+          try_recv
+
+          # Block until ZMQ or wake pipe has activity.
+          IO.select([zmq_fd_io, @wake_r], nil, nil, 0.1)
+          @wake_r.read_nonblock(4096, exception: false)
+        end
+      rescue
+        # Thread exit
+      ensure
+        zmq_fd_io&.close rescue nil
+        L.zmq_close(@zmq_socket)
+      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)) }
+        L.zmq_getsockopt(@zmq_socket, L::ZMQ_EVENTS, @events_buf, @events_len)
+        @events_buf.read_int != 0
+      end
+
+      def drain_cmds
+        loop do
+          begin
+            cmd = @cmd_queue.pop(true)
+          rescue ThreadError
+            return true  # queue empty, continue
+          end
+          return false unless process_cmd(cmd)
+        end
+      end
+
+      def process_cmd(cmd)
+        name, args, result = cmd
+        case name
+        when :stop
+          result&.push(nil)
+          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)))
+        when :connect
+          rc = L.zmq_connect(@zmq_socket, args[0])
+          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+        when :disconnect
+          rc = L.zmq_disconnect(@zmq_socket, args[0])
+          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+        when :unbind
+          rc = L.zmq_unbind(@zmq_socket, args[0])
+          result&.push(rc >= 0 ? nil : RuntimeError.new(L.zmq_strerror(L.zmq_errno)))
+        when :set_identity
+          set_bytes_option(L::ZMQ_IDENTITY, args[0])
+          result&.push(nil)
+        when :subscribe
+          set_bytes_option(L::ZMQ_SUBSCRIBE, args[0])
+          result&.push(nil)
+        when :unsubscribe
+          set_bytes_option(L::ZMQ_UNSUBSCRIBE, args[0])
+          result&.push(nil)
+        when :join
+          rc = L.respond_to?(:zmq_join) ? L.zmq_join(@zmq_socket, args[0]) : -1
+          result&.push(rc >= 0 ? nil : RuntimeError.new("zmq_join not available"))
+        when :leave
+          rc = L.respond_to?(:zmq_leave) ? L.zmq_leave(@zmq_socket, args[0]) : -1
+          result&.push(rc >= 0 ? nil : RuntimeError.new("zmq_leave not available"))
+        when :drain_send
+          # handled in drain_sends
+          result&.push(nil)
+        end
+        true
+      end
+
+      def try_recv
+        loop do
+          parts = recv_multipart_nonblock
+          break unless parts
+          @recv_queue.push(parts.freeze)
+          @recv_signal_w.write_nonblock(".", exception: false)
+        end
+      end
+
+      def drain_sends
+        @pending_send ||= nil
+        loop do
+          parts = @pending_send || begin
+            @send_queue.pop(true)
+          rescue ThreadError
+            break
+          end
+          if send_multipart_nonblock(parts)
+            @pending_send = nil
+          else
+            @pending_send = parts  # retry next cycle (HWM reached)
+            break
+          end
+        end
+      end
+
+      # Returns true if fully sent, false if would block (HWM).
+      #
+      def send_multipart_nonblock(parts)
+        parts.each_with_index do |part, i|
+          flags = L::ZMQ_DONTWAIT
+          flags |= L::ZMQ_SNDMORE if i < parts.size - 1
+          msg = L.alloc_msg
+          L.zmq_msg_init_size(msg, part.bytesize)
+          L.zmq_msg_data(msg).write_bytes(part)
+          rc = L.zmq_msg_send(msg, @zmq_socket, flags)
+          if rc < 0
+            L.zmq_msg_close(msg)
+            return false  # EAGAIN — would block
+          end
+        end
+        true
+      end
+
+      def recv_multipart_nonblock
+        parts = []
+        loop do
+          msg = L.alloc_msg
+          L.zmq_msg_init(msg)
+          rc = L.zmq_msg_recv(msg, @zmq_socket, L::ZMQ_DONTWAIT)
+          if rc < 0
+            L.zmq_msg_close(msg)
+            return parts.empty? ? nil : parts  # EAGAIN = no more data
+          end
+
+          size = L.zmq_msg_size(msg)
+          data = L.zmq_msg_data(msg).read_bytes(size)
+          L.zmq_msg_close(msg)
+          parts << data.freeze
+
+          break unless rcvmore?
+        end
+        parts.empty? ? nil : parts
+      end
+
+      def rcvmore?
+        buf = ::FFI::MemoryPointer.new(:int)
+        len = ::FFI::MemoryPointer.new(:size_t)
+        len.write(:size_t, ::FFI.type_size(:int))
+        L.zmq_getsockopt(@zmq_socket, L::ZMQ_RCVMORE, buf, len)
+        buf.read_int != 0
+      end
+
+      def get_zmq_fd
+        buf = ::FFI::MemoryPointer.new(:int)
+        len = ::FFI::MemoryPointer.new(:size_t)
+        len.write(:size_t, ::FFI.type_size(:int))
+        L.zmq_getsockopt(@zmq_socket, L::ZMQ_FD, buf, len)
+        buf.read_int
+      end
+
+      # Re-syncs identity to libzmq (user may set it after construction).
+      #
+      def sync_identity
+        id = @options.identity
+        if id && !id.empty?
+          send_cmd(:set_identity, id)
+        end
+      end
+
+      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)
+        set_int_option(L::ZMQ_CONFLATE, @options.conflate ? 1 : 0)
+
+        if @options.identity && !@options.identity.empty?
+          set_bytes_option(L::ZMQ_IDENTITY, @options.identity)
+        end
+
+        if @options.max_message_size
+          set_int64_option(L::ZMQ_MAXMSGSIZE, @options.max_message_size)
+        end
+
+        if @options.reconnect_interval
+          ivl = @options.reconnect_interval
+          if ivl.is_a?(Range)
+            set_int_option(L::ZMQ_RECONNECT_IVL, (ivl.begin * 1000).to_i)
+            set_int_option(L::ZMQ_RECONNECT_IVL_MAX, (ivl.end * 1000).to_i)
+          else
+            set_int_option(L::ZMQ_RECONNECT_IVL, (ivl * 1000).to_i)
+          end
+        end
+
+        set_int_option(L::ZMQ_ROUTER_MANDATORY, 1) if @options.router_mandatory
+      end
+
+      def set_int_option(opt, value)
+        buf = ::FFI::MemoryPointer.new(:int)
+        buf.write_int(value)
+        L.zmq_setsockopt(@zmq_socket, opt, buf, ::FFI.type_size(:int))
+      end
+
+      def set_int64_option(opt, value)
+        buf = ::FFI::MemoryPointer.new(:int64)
+        buf.write_int64(value)
+        L.zmq_setsockopt(@zmq_socket, opt, buf, ::FFI.type_size(:int64))
+      end
+
+      def set_bytes_option(opt, value)
+        buf = ::FFI::MemoryPointer.from_string(value)
+        L.zmq_setsockopt(@zmq_socket, opt, buf, value.bytesize)
+      end
+
+      def get_string_option(opt)
+        buf = ::FFI::MemoryPointer.new(:char, 256)
+        len = ::FFI::MemoryPointer.new(:size_t)
+        len.write(:size_t, 256)
+        L.check!(L.zmq_getsockopt(@zmq_socket, opt, buf, len), "zmq_getsockopt")
+        buf.read_string(len.read(:size_t) - 1)
+      end
+
+      def extract_tcp_port(endpoint)
+        return nil unless endpoint
+        port = endpoint.split(":").last.to_i
+        port.positive? ? port : nil
+      end
+    end
+
+    # Shared ZMQ context — one per process.
+    #
+    def self.context
+      @context ||= Libzmq.zmq_ctx_new.tap do |ctx|
+        raise "zmq_ctx_new failed" if ctx.null?
+        at_exit do
+          Libzmq.zmq_ctx_shutdown(ctx) rescue nil
+          Libzmq.zmq_ctx_term(ctx) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/omq/ffi/libzmq.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module OMQ
+  module FFI
+    # Minimal libzmq FFI bindings — only what OMQ needs.
+    #
+    module Libzmq
+      extend ::FFI::Library
+      ffi_lib ["libzmq.so.5", "libzmq.5.dylib", "libzmq"]
+
+      # Context
+      attach_function :zmq_ctx_new,  [], :pointer
+      attach_function :zmq_ctx_term,     [:pointer], :int
+      attach_function :zmq_ctx_shutdown, [:pointer], :int
+
+      # Socket
+      attach_function :zmq_socket,     [:pointer, :int], :pointer
+      attach_function :zmq_close,      [:pointer], :int
+      attach_function :zmq_bind,       [:pointer, :string], :int
+      attach_function :zmq_connect,    [:pointer, :string], :int
+      attach_function :zmq_disconnect, [:pointer, :string], :int
+      attach_function :zmq_unbind,     [:pointer, :string], :int
+
+      # Message
+      attach_function :zmq_msg_init,      [:pointer], :int
+      attach_function :zmq_msg_init_size, [:pointer, :size_t], :int
+      attach_function :zmq_msg_data,      [:pointer], :pointer
+      attach_function :zmq_msg_size,      [:pointer], :size_t
+      attach_function :zmq_msg_close,     [:pointer], :int
+      attach_function :zmq_msg_send,      [:pointer, :pointer, :int], :int
+      attach_function :zmq_msg_recv,      [:pointer, :pointer, :int], :int
+
+      # Socket options
+      attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :size_t], :int
+      attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
+
+      # Group membership (RADIO/DISH) — draft API, may not be available
+      begin
+        attach_function :zmq_join,  [:pointer, :string], :int
+        attach_function :zmq_leave, [:pointer, :string], :int
+      rescue ::FFI::NotFoundError
+        # libzmq built without ZMQ_BUILD_DRAFT_API
+      end
+
+      # Error
+      attach_function :zmq_errno,    [], :int
+      attach_function :zmq_strerror, [:int], :string
+
+      # Socket types
+      ZMQ_PAIR    = 0
+      ZMQ_PUB     = 1
+      ZMQ_SUB     = 2
+      ZMQ_REQ     = 3
+      ZMQ_REP     = 4
+      ZMQ_DEALER  = 5
+      ZMQ_ROUTER  = 6
+      ZMQ_PULL    = 7
+      ZMQ_PUSH    = 8
+      ZMQ_XPUB    = 9
+      ZMQ_XSUB    = 10
+      ZMQ_SERVER  = 12
+      ZMQ_CLIENT  = 13
+      ZMQ_RADIO   = 14
+      ZMQ_DISH    = 15
+      ZMQ_GATHER  = 16
+      ZMQ_SCATTER = 17
+      ZMQ_PEER    = 19
+      ZMQ_CHANNEL = 20
+
+      # Socket type name → constant
+      SOCKET_TYPES = {
+        PAIR: ZMQ_PAIR, PUB: ZMQ_PUB, SUB: ZMQ_SUB,
+        REQ: ZMQ_REQ, REP: ZMQ_REP,
+        DEALER: ZMQ_DEALER, ROUTER: ZMQ_ROUTER,
+        PULL: ZMQ_PULL, PUSH: ZMQ_PUSH,
+        XPUB: ZMQ_XPUB, XSUB: ZMQ_XSUB,
+        SERVER: ZMQ_SERVER, CLIENT: ZMQ_CLIENT,
+        RADIO: ZMQ_RADIO, DISH: ZMQ_DISH,
+        GATHER: ZMQ_GATHER, SCATTER: ZMQ_SCATTER,
+        PEER: ZMQ_PEER, CHANNEL: ZMQ_CHANNEL,
+      }.freeze
+
+      # Send/recv flags
+      ZMQ_DONTWAIT = 1
+      ZMQ_SNDMORE  = 2
+
+      # Socket options
+      ZMQ_IDENTITY     = 5
+      ZMQ_SUBSCRIBE    = 6
+      ZMQ_UNSUBSCRIBE  = 7
+      ZMQ_RCVMORE      = 13
+      ZMQ_FD           = 14
+      ZMQ_EVENTS       = 15
+      ZMQ_LINGER       = 17
+      ZMQ_SNDHWM       = 23
+      ZMQ_RCVHWM       = 24
+      ZMQ_RCVTIMEO     = 27
+      ZMQ_SNDTIMEO     = 28
+      ZMQ_MAXMSGSIZE   = 22
+      ZMQ_LAST_ENDPOINT = 32
+      ZMQ_ROUTER_MANDATORY = 33
+      ZMQ_RECONNECT_IVL     = 18
+      ZMQ_RECONNECT_IVL_MAX = 21
+      ZMQ_CONFLATE     = 54
+
+      # zmq_msg_t is 64 bytes on all platforms
+      MSG_T_SIZE = 64
+
+      # Allocates a zmq_msg_t on the heap.
+      #
+      # @return [FFI::MemoryPointer]
+      #
+      def self.alloc_msg
+        ::FFI::MemoryPointer.new(MSG_T_SIZE)
+      end
+
+      # Raises an error with the current zmq_errno message.
+      #
+      def self.check!(rc, label = "zmq")
+        return rc if rc >= 0
+        errno = zmq_errno
+        raise "#{label}: #{zmq_strerror(errno)} (errno #{errno})"
+      end
+    end
+  end
+end

data/lib/omq/ffi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Load the FFI backend for OMQ.
+#
+# Usage:
+#   require "omq/ffi"
+#   push = OMQ::PUSH.new(backend: :ffi)
+#
+# Raises LoadError if libzmq is not installed.
+
+require_relative "ffi/libzmq"
+require_relative "ffi/engine"

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: omq-ffi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrik Wenger
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: omq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- paddor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/omq/ffi.rb
+- lib/omq/ffi/engine.rb
+- lib/omq/ffi/libzmq.rb
+homepage: https://github.com/paddor/omq-ffi
+licenses:
+- ISC
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: libzmq FFI backend for OMQ — use libzmq under the same OMQ socket API
+test_files: []