rbczmq 0.1

data/lib/zmq/loop.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+require "set"
+require "forwardable"
+
+class ZMQ::Loop
+
+  # The ZMQ::Loop class provides an event-driven reactor pattern. The reactor handles ZMQ::Socket or IO instances and
+  # once-off or repeated timers. Its resolution is 1 msec. It uses a tickless timer to reduce CPU interrupts in inactive
+  # processes.
+
+  class << self
+    extend Forwardable
+    def_delegators :instance, :context, :stop, :running?, :verbose=, :register_timer, :cancel_timer, :register, :remove
+    private
+    attr_accessor :instance
+  end
+
+  # Start the reactor. Takes control of the current thread and returns when :
+  #
+  # * the 0MQ context is terminated or
+  # * the process is interrupted or
+  # * any event handler raises an error
+  # * any event handler returns false
+  #
+  # ZMQ::Loop.run do # or ZMQ::Loop.run(&proc)
+  #   ZL.add_oneshot_timer(0.2){ ZL.stop }
+  # end
+  #
+  def self.run(proc = nil, &blk)
+    self.instance = ZMQ::Loop.new
+    (proc || blk).call
+    instance.start
+  end
+
+  # A higher level API for ZMQ socket bind and loop registration.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.bind(pub, "inproc://fanout", Producer)
+  # end
+  #
+  def self.bind(socket, address, handler = ZMQ::DefaultHandler, *args)
+    attach(socket, :bind, address, handler, *args)
+  end
+
+  # A higher level API for ZMQ socket bind and loop registration.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.bind(pub, "inproc://fanout", Producer)
+  #   ZL.connect(sub, "inproc://fanout", Consumer)
+  # end
+  #
+  def self.connect(socket, address, handler = ZMQ::DefaultHandler, *args)
+    attach(socket, :connect, address, handler, *args)
+  end
+
+  # Registers a given ZMQ::Socket or IO instance for readable events notification.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.register_readable(sub, "inproc://fanout", Consumer)
+  # end
+  #
+  def self.register_readable(pollable, handler = ZMQ::DefaultHandler, *args)
+    pollitem = ZMQ::Pollitem.new(pollable, ZMQ::POLLIN)
+    pollitem.handler = handler.new(pollitem, *args) if handler
+    assert_handler_for_event(pollitem, :on_readable)
+    instance.register(pollitem)
+  end
+
+  # Registers a given ZMQ::Socket or IO instance for writable events notification.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.register_writable(pub, "inproc://fanout", Producer)
+  # end
+  #
+  def self.register_writable(pollable, handler = ZMQ::DefaultHandler, *args)
+    pollitem = ZMQ::Pollitem.new(pollable, ZMQ::POLLOUT)
+    pollitem.handler = handler.new(pollitem, *args) if handler
+    assert_handler_for_event(pollitem, :on_writable)
+    instance.register(pollitem)
+  end
+
+  # Registers a oneshot timer with the event loop.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.add_oneshot_timer(0.2){ :work } # Fires once after 0.2s
+  # end
+  #
+  def self.add_oneshot_timer(delay, p = nil, &blk)
+    add_timer(delay, 1, p, &blk)
+  end
+
+  # Registers a periodic timer with the event loop.
+  #
+  # ZMQ::Loop.run do
+  #   ZL.add_oneshot_timer(0.2){ :work } # Fires every 0.2s
+  # end
+  #
+  def self.add_periodic_timer(delay, p = nil, &blk)
+    add_timer(delay, 0, p, &blk)
+  end
+
+  # Lower level interface for timer registration
+  #
+  # ZMQ::Loop.run do
+  #  timer = ZL.add_timer(0.1, 5){ :work } # Fires 5 times at 0.1s intervals
+  # end
+  #
+  def self.add_timer(delay, times, p = nil, &blk)
+    timer = ZMQ::Timer.new(delay, times, p, &blk)
+    instance.register_timer(timer)
+    timer
+  end
+
+  private
+  def self.attach(socket, action, address, handler, *args)
+    ret = socket.__send__(action, address)
+    register_readable(socket, handler, args) if socket.poll_readable?
+    register_writable(socket, handler, args) if socket.poll_writable?
+    ret
+  end
+
+  def self.assert_handler_for_event(pollitem, cb)
+    unless pollitem.handler.respond_to?(cb)
+      pollitem.handler = nil
+      raise ZMQ::Error, "Pollable entity #{pollitem.pollable}'s handler #{pollitem.handler.class} expected to implement an #{cb} callback!"
+    end
+  end
+end
+
+ZL = ZMQ::Loop

data/lib/zmq/message.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+class ZMQ::Message
+
+  # The ZMQ::Message class provides methods to send and receive multipart messages across 0MQ sockets. This class provides
+  # a list-like container interface, with methods to work with the overall container.
+
+  include Comparable
+end

data/lib/zmq/poller.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+class ZMQ::Poller
+
+  # API sugar to poll non-blocking. Returns immediately if there's no items in a ready state.
+  #
+  def poll_nonblock
+    poll(0)
+  end
+
+  # API sugar for registering a ZMQ::Socket or IO for readability
+  #
+  def register_readable(pollable)
+    register ZMQ::Pollitem.new(pollable, ZMQ::POLLIN)
+  end
+
+  # API sugar for registering a ZMQ::Socket or IO for writability
+  #
+  def register_writable(pollable)
+    register ZMQ::Pollitem.new(pollable, ZMQ::POLLOUT)
+  end
+end

data/lib/zmq/pollitem.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+class ZMQ::Pollitem
+  # API that allows poll items to send data regardless of the underlying pollable item type (ZMQ::Socket or IO).
+  #
+  def send(*args)
+    case pollable
+    when BasicSocket
+      pollable.send(args.shift, 0)
+    when IO
+      pollable.write_nonblock(*args)
+    when ZMQ::Socket
+      pollable.send(*args)
+    end
+  end
+
+  # API that allows poll items to recv data regardless of the underlying pollable item type (ZMQ::Socket or IO).
+  #
+  def recv
+    case pollable
+    when BasicSocket
+      # XXX assumed page size
+      pollable.recv_nonblock(4096)
+    when IO
+      # XXX assumed page size
+      pollable.read_nonblock(4096)
+    when ZMQ::Socket
+      pollable.recv_nonblock
+    end
+  end
+end

data/lib/zmq/socket.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+class ZMQ::Socket
+  def self.unsupported_api(*methods)
+    methods.each do |m|
+      class_eval <<-"evl", __FILE__, __LINE__
+        def #{m}(*args); raise(ZMQ::Error, "API #{m} not supported for #{const_get(:TYPE_STR)} sockets!");  end
+      evl
+    end
+  end
+
+  def self.handle_fsm_errors(error, *methods)
+    methods.each do |m|
+      class_eval <<-"evl", __FILE__, __LINE__
+        def #{m}(*args);
+          super
+        rescue SystemCallError => e
+          raise(ZMQ::Error, "#{error} Please assert that you're not sending / receiving out of band data when using the REQ / REP socket pairs.") if e.errno == ZMQ::EFSM
+          raise
+        end
+      evl
+    end
+  end
+
+  # Determines if there are one or more messages to read from this socket. Should be used in conjunction with the
+  # ZMQ_FD socket option for edge-triggered notifications.
+  #
+  # socket.readable? => true
+  #
+  def readable?
+    (events & ZMQ::POLLIN) == ZMQ::POLLIN
+  end
+
+  # Determines if this socket is in a writable state. Should be used in conjunction with the ZMQ_FD socket option for
+  # edge-triggered notifications.
+  #
+  # socket.writable? => true
+  #
+  def writable?
+    (events & ZMQ::POLLOUT) == ZMQ::POLLOUT
+  end
+
+  # Generates a string representation of this socket type
+  #
+  # socket = ctx.socket(:PUB)
+  # socket.type_str => "PUB"
+  #
+  def type_str
+    self.class.const_get(:TYPE_STR)
+  end
+
+  # Generates a string representation of the current socket state
+  #
+  # socket = ctx.bind(:PUB, "tcp://127.0.0.1:5000")
+  # socket.to_s => "PUB socket bound to tcp://127.0.0.1:5000"
+  #
+  def to_s
+    case state
+    when BOUND
+      "#{type_str} socket bound to #{endpoint}"
+    when CONNECTED
+      "#{type_str} socket connected to #{endpoint}"
+    else
+      "#{type_str} socket"
+    end
+  end
+
+  # Poll all sockets for readbable states by default
+  def poll_readable?
+    true
+  end
+
+  # Poll all sockets for writable states by default
+  def poll_writable?
+    true
+  end
+end
+
+module ZMQ::DownstreamSocket
+  # An interface for sockets that can only receive (read) data
+  #
+  # === Behavior
+  #
+  # [Disabled methods] ZMQ::Socket#bind, ZMQ::Socket#send, ZMQ::Socket#sendm, ZMQ::Socket#send_frame,
+  #                    ZMQ::Socket#send_message
+  # [Socket types] ZMQ::Socket::Pull, ZMQ::Socket::Sub
+
+  def self.included(sock)
+    sock.unsupported_api :send, :sendm, :send_frame, :send_message
+  end
+
+  # Upstream sockets should never be polled for writable states
+  def poll_writable?
+    false
+  end
+end
+
+module ZMQ::UpstreamSocket
+  # An interface for sockets that can only send (write) data
+  #
+  # === Behavior
+  #
+  # [Disabled methods] ZMQ::Socket#connect, ZMQ::Socket#recv, ZMQ::Socket#recv_nonblock, ZMQ::Socket#recv_frame,
+  #                    ZMQ::Socket#recv_frame_nonblock, ZMQ::Socket#recv_message
+  # [Socket types] ZMQ::Socket::Push, ZMQ::Socket::Pub
+
+  def self.included(sock)
+    sock.unsupported_api :recv, :recv_nonblock, :recv_frame, :recv_frame_nonblock, :recv_message
+  end
+
+  # Upstream sockets should never be polled for readable states
+  def poll_readable?
+    false
+  end
+end
+
+require "zmq/socket/pub"
+require "zmq/socket/sub"
+require "zmq/socket/push"
+require "zmq/socket/pull"
+require "zmq/socket/pair"
+require "zmq/socket/req"
+require "zmq/socket/rep"
+require "zmq/socket/router"
+require "zmq/socket/dealer"

data/lib/zmq/socket/dealer.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Dealer
+
+# == ZMQ::Socket::Dealer
+#
+# A socket of type ZMQ::Socket::Dealer is an advanced pattern used for extending request/reply sockets. Each message sent is
+# load-balanced among all connected peers, and each message received is fair-queued from all connected peers.
+#
+# Previously this socket was called ZMQ_XREQ and that name remains available for backwards compatibility.
+#
+# When a ZMQ::Socket::Dealer socket enters an exceptional state due to having reached the high water mark for all peers, or if
+# there are no peers at all, then any ZMQ::Socket#send operations on the socket shall block until the exceptional state ends
+# or at least one peer becomes available for sending; messages are not discarded.
+#
+# When a ZMQ::Socket::Dealer socket is connected to a ZMQ::Socket::Rep socket each message sent must consist of an empty message part,
+# the delimiter, followed by one or more body parts.
+#
+# === Summary of ZMQ::Socket::Dealer characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Router, ZMQ::Socket::Request, ZMQ::Socket::Reply
+# [Direction] Bidirectional
+# [Send/receive pattern] Unrestricted
+# [Outgoing routing strategy] Load-balanced
+# [Incoming routing strategy] Fair-queued
+# [ZMQ_HWM option action] Block
+
+  TYPE_STR = "DEALER"
+
+  def type
+    ZMQ::DEALER
+  end
+end

data/lib/zmq/socket/pair.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Pair
+
+# == ZMQ::Socket::Pair
+#
+# A socket of type ZMQ::Socket::Pair can only be connected to a single peer at any one time. No message routing or filtering
+# is performed on messages sent over a ZMQ::Socket::Pair socket.
+#
+# When a ZMQ::Socket::Pair socket enters an exceptional state due to having reached the high water mark for the connected
+# peer, or if no peer is connected, then any ZMQ::Socket#send operations on the socket shall block until the peer becomes
+# available for sending; messages are not discarded.
+#
+# === Summary of ZMQ::Socket::Pair characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Pair
+# [Direction] Bidirectional
+# [Send/receive pattern] Unrestricted
+# [Incoming routing strategy] N/A
+# [Outgoing routing strategy] N/A
+# [ZMQ::Socket#hwm option action] Block
+
+  TYPE_STR = "PAIR"
+  REXP_INPROC = /inproc:\/\//
+
+  def bind(endpoint)
+    raise(ZMQ::Error, "PAIR sockets can only listen using the inproc:// transport") unless endpoint =~ REXP_INPROC
+    super
+  end
+
+  def connect(endpoint)
+    raise(ZMQ::Error, "PAIR sockets can only connect using the inproc:// transport") unless endpoint =~ REXP_INPROC
+    super
+  end
+
+  def type
+    ZMQ::PAIR
+  end
+end

data/lib/zmq/socket/pub.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Pub
+
+# == ZMQ::Socket::Pub
+#
+# A socket of type ZMQ::Socket::Pub is used by a publisher to distribute data. Messages sent are distributed in a fan out fashion
+# to all connected peers. The ZMQ::Socket#recv function is not implemented for this socket type.
+#
+# When a ZMQ::Socket::Pub socket enters an exceptional state due to having reached the high water mark for a subscriber, then
+# any messages that would be sent to the subscriber in question shall instead be dropped until the exceptional state ends. The
+# ZMQ::Socket#send function shall never block for this socket type.
+#
+# === Summary of ZMQ::Socket::Pub characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Sub
+# [Direction] Unidirectional
+# [Send/receive pattern] Send only
+# [Incoming routing strategy] N/A
+# [Outgoing routing strategy] Fan out
+# [ZMQ::Socket#hwm option action] Drop
+
+  TYPE_STR = "PUB"
+
+  def type
+    ZMQ::PUB
+  end
+
+  include ZMQ::UpstreamSocket
+end

data/lib/zmq/socket/pull.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Pull
+
+# == ZMQ::Socket::Pull
+#
+# A socket of type ZMQ::Socket::Pull is used by a pipeline node to receive messages from upstream pipeline nodes. Messages
+# are fair-queued from among all connected upstream nodes. The ZMQ::Socket#send function is not implemented for this
+# socket type.
+#
+# Deprecated alias: ZMQ_UPSTREAM.
+#
+# === Summary of ZMQ::Socket::Pull characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Push
+# [Direction] Unidirectional
+# [Send/receive pattern] Receive only
+# [Incoming routing strategy] Fair-queued
+# [Outgoing routing strategy] N/A
+# [ZMQ::Socket#hwm option action] N/A
+
+  TYPE_STR = "PULL"
+
+  def type
+    ZMQ::PULL
+  end
+
+  include ZMQ::DownstreamSocket
+end