omq 0.1.0

data/lib/omq/zmtp/transport/tcp.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "socket"
+require "uri"
+require "io/stream"
+
+module OMQ
+  module ZMTP
+    module Transport
+      # TCP transport using Ruby sockets with Async.
+      #
+      module TCP
+        class << self
+          # Binds a TCP server.
+          #
+          # @param endpoint [String] e.g. "tcp://127.0.0.1:5555" or "tcp://*:0"
+          # @param engine [Engine]
+          # @return [Listener]
+          #
+          def bind(endpoint, engine)
+            host, port = parse_endpoint(endpoint)
+            host = "0.0.0.0" if host == "*"
+            server = TCPServer.new(host, port)
+            actual_port = server.local_address.ip_port
+            host_part   = host.include?(":") ? "[#{host}]" : host
+            resolved    = "tcp://#{host_part}:#{actual_port}"
+
+            accept_task = Reactor.spawn_pump do
+              loop do
+                client = server.accept
+                Reactor.run do
+                  engine.handle_accepted(IO::Stream::Buffered.wrap(client, minimum_write_size: 0), endpoint: resolved)
+                rescue => e
+                  client.close rescue nil
+                  raise if !e.is_a?(ProtocolError) && !e.is_a?(EOFError)
+                end
+              end
+            rescue IOError
+              # server closed
+            end
+
+            Listener.new(resolved, server, accept_task, actual_port)
+          end
+
+          # Connects to a TCP endpoint.
+          #
+          # @param endpoint [String] e.g. "tcp://127.0.0.1:5555"
+          # @param engine [Engine]
+          # @return [void]
+          #
+          def connect(endpoint, engine)
+            host, port = parse_endpoint(endpoint)
+            timeout = engine.options.connect_timeout
+            sock = if timeout
+                     ::Socket.tcp(host, port, connect_timeout: timeout)
+                   else
+                     TCPSocket.new(host, port)
+                   end
+            engine.handle_connected(IO::Stream::Buffered.wrap(sock, minimum_write_size: 0), endpoint: endpoint)
+          end
+
+          private
+
+          def parse_endpoint(endpoint)
+            uri = URI.parse(endpoint)
+            [uri.hostname, uri.port]
+          end
+        end
+
+        # A bound TCP listener.
+        #
+        class Listener
+          # @return [String] resolved endpoint with actual port
+          #
+          attr_reader :endpoint
+
+          # @return [Integer] bound port
+          #
+          attr_reader :port
+
+          def initialize(endpoint, server, accept_task, port)
+            @endpoint    = endpoint
+            @server      = server
+            @accept_task = accept_task
+            @port        = port
+          end
+
+          # Stops the listener.
+          #
+          def stop
+            @accept_task.stop
+            @server.close rescue nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/valid_peers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    # Valid socket type peer combinations per ZMTP spec.
+    #
+    VALID_PEERS = {
+      PAIR:   %i[PAIR].freeze,
+      REQ:    %i[REP ROUTER].freeze,
+      REP:    %i[REQ DEALER].freeze,
+      DEALER: %i[REP DEALER ROUTER].freeze,
+      ROUTER: %i[REQ DEALER ROUTER].freeze,
+      PUB:    %i[SUB XSUB].freeze,
+      SUB:    %i[PUB XPUB].freeze,
+      XPUB:   %i[SUB XSUB].freeze,
+      XSUB:   %i[PUB XPUB].freeze,
+      PUSH:   %i[PULL].freeze,
+      PULL:   %i[PUSH].freeze,
+    }.freeze
+  end
+end

data/lib/omq/zmtp/writable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module OMQ
+  module ZMTP
+    # Pure Ruby Writable mixin. Enqueues messages to the engine's send path.
+    #
+    module Writable
+      # Sends a message.
+      #
+      # @param message [String, Array<String>] message parts
+      # @return [self]
+      # @raise [IO::TimeoutError] if write_timeout exceeded
+      #
+      def send(message)
+        parts = message.is_a?(Array) ? message : [message]
+        raise ArgumentError, "message has no parts" if parts.empty?
+        parts = parts.map { |p| p.b.freeze }
+
+        with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
+        self
+      end
+
+      # Sends a message (chainable).
+      #
+      # @param message [String, Array<String>]
+      # @return [self]
+      #
+      def <<(message)
+        send(message)
+      end
+
+      # Waits until the socket is writable.
+      #
+      # @param timeout [Numeric, nil] timeout in seconds
+      # @return [true]
+      #
+      def wait_writable(timeout = @options.write_timeout)
+        true
+      end
+    end
+  end
+end

data/lib/omq/zmtp.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module OMQ
+  # ZMTP 3.1 protocol internals.
+  #
+  # These classes implement the wire protocol, transports, and routing
+  # strategies. They are not part of the public API.
+  #
+  module ZMTP
+  end
+end
+
+# Constants
+require_relative "zmtp/valid_peers"
+
+# Codec
+require_relative "zmtp/codec"
+
+# Transport
+require_relative "zmtp/transport/inproc"
+require_relative "zmtp/transport/tcp"
+require_relative "zmtp/transport/ipc"
+
+# Mechanisms
+require_relative "zmtp/mechanism/null"
+
+# Core
+require_relative "zmtp/reactor"
+require_relative "zmtp/options"
+require_relative "zmtp/connection"
+require_relative "zmtp/routing"
+require_relative "zmtp/routing/round_robin"
+require_relative "zmtp/routing/fan_out"
+require_relative "zmtp/routing/pair"
+require_relative "zmtp/routing/req"
+require_relative "zmtp/routing/rep"
+require_relative "zmtp/routing/dealer"
+require_relative "zmtp/routing/router"
+require_relative "zmtp/routing/pub"
+require_relative "zmtp/routing/sub"
+require_relative "zmtp/routing/xpub"
+require_relative "zmtp/routing/xsub"
+require_relative "zmtp/routing/push"
+require_relative "zmtp/routing/pull"
+require_relative "zmtp/engine"
+require_relative "zmtp/readable"
+require_relative "zmtp/writable"

data/lib/omq.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# OMQ — pure Ruby ZeroMQ (ZMTP 3.1).
+#
+# Socket types live directly under OMQ:: for a clean API:
+#   OMQ::PUSH, OMQ::PULL, OMQ::PUB, OMQ::SUB, etc.
+#
+# Protocol internals live under OMQ::ZMTP:: and are not part
+# of the public API.
+#
+
+require_relative "omq/version"
+require_relative "omq/zmtp"
+require_relative "omq/socket"
+require_relative "omq/req_rep"
+require_relative "omq/router_dealer"
+require_relative "omq/pub_sub"
+require_relative "omq/push_pull"
+require_relative "omq/pair"

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: omq
+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: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: io-stream
+  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'
+description: Pure Ruby implementation of the ZMTP 3.1 wire protocol (ZeroMQ) using
+  the Async gem. No native libraries required.
+email:
+- paddor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/omq.rb
+- lib/omq/pair.rb
+- lib/omq/pub_sub.rb
+- lib/omq/push_pull.rb
+- lib/omq/req_rep.rb
+- lib/omq/router_dealer.rb
+- lib/omq/socket.rb
+- lib/omq/version.rb
+- lib/omq/zmtp.rb
+- lib/omq/zmtp/codec.rb
+- lib/omq/zmtp/codec/command.rb
+- lib/omq/zmtp/codec/frame.rb
+- lib/omq/zmtp/codec/greeting.rb
+- lib/omq/zmtp/connection.rb
+- lib/omq/zmtp/engine.rb
+- lib/omq/zmtp/mechanism/null.rb
+- lib/omq/zmtp/options.rb
+- lib/omq/zmtp/reactor.rb
+- lib/omq/zmtp/readable.rb
+- lib/omq/zmtp/routing.rb
+- lib/omq/zmtp/routing/dealer.rb
+- lib/omq/zmtp/routing/fan_out.rb
+- lib/omq/zmtp/routing/pair.rb
+- lib/omq/zmtp/routing/pub.rb
+- lib/omq/zmtp/routing/pull.rb
+- lib/omq/zmtp/routing/push.rb
+- lib/omq/zmtp/routing/rep.rb
+- lib/omq/zmtp/routing/req.rb
+- lib/omq/zmtp/routing/round_robin.rb
+- lib/omq/zmtp/routing/router.rb
+- lib/omq/zmtp/routing/sub.rb
+- lib/omq/zmtp/routing/xpub.rb
+- lib/omq/zmtp/routing/xsub.rb
+- lib/omq/zmtp/transport/inproc.rb
+- lib/omq/zmtp/transport/ipc.rb
+- lib/omq/zmtp/transport/tcp.rb
+- lib/omq/zmtp/valid_peers.rb
+- lib/omq/zmtp/writable.rb
+homepage: https://github.com/paddor/omq
+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: OMQ — pure Ruby ZeroMQ (ZMTP 3.1)
+test_files: []