rbczmq 0.1

data/lib/zmq/socket/push.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Push
+
+# == ZMQ::Socket::Push
+#
+# A socket of type ZMQ::Socket::Push is used by a pipeline node to send messages to downstream pipeline nodes. Messages are
+# load-balanced to all connected downstream nodes. The ZMQ::Socket#recv function is not implemented for this socket type.
+#
+# When a ZMQ::Socket::Push socket enters an exceptional state due to having reached the high water mark for all downstream
+# nodes, or if there are no downstream nodes at all, then any ZMQ::Socket#send operations on the socket shall block until
+# the exceptional state ends or at least one downstream node becomes available for sending; messages are not discarded.
+#
+# Deprecated alias: ZMQ_DOWNSTREAM.
+#
+# === Summary of ZMQ::Socket::Push characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Pull
+# [Direction] Unidirectional
+# [Send/receive pattern] Send only
+# [Incoming routing strategy] N/A
+# [Outgoing routing strategy] Load-balanced
+# [ZMQ::Socket#hwm option action] Block
+
+  TYPE_STR = "PUSH"
+
+  def type
+    ZMQ::PUSH
+  end
+
+  include ZMQ::UpstreamSocket
+end

data/lib/zmq/socket/rep.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Rep
+
+# == ZMQ::Socket::Rep
+#
+# A socket of type ZMQ::Socket::Rep is used by a service to receive requests from and send replies to a client. This socket type
+# allows only an alternating sequence of ZMQ::Socket#recv and subsequent ZMQ::Socket#send calls. Each request received is
+# fair-queued from among all clients, and each reply sent is routed to the client that issued the last request. If the
+# original requester doesn't exist any more the reply is silently discarded.
+#
+# When a ZMQ::Socket::Rep socket enters an exceptional state due to having reached the high water mark for a client, then any replies
+# sent to the client in question shall be dropped until the exceptional state ends.
+#
+# === Summary of ZMQ::Socket#rep characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Rep
+# [Direction] Bidirectional
+# [Send/receive pattern] Receive, Send, Receive, Send, …
+# [Incoming routing strategy] Fair-queued
+# [Outgoing routing strategy] Last peer
+# [ZMQ::Socket#hwm option action] Drop
+
+  TYPE_STR = "REP"
+
+  def type
+    ZMQ::REP
+  end
+
+  unsupported_api :sendm
+  handle_fsm_errors "REP sockets allows only an alternating sequence of receive and subsequent send calls.", :send, :send_frame, :send_message, :recv, :recv_nonblock, :recv_frame, :recv_frame_nonblock, :recv_message
+
+  def send_frame(frame, flags = 0)
+    raise ZMQ::Error, "cannot send multiple frames on REP sockets" if (flags & ZMQ::Frame::MORE) == ZMQ::Frame::MORE
+    super
+  end
+end

data/lib/zmq/socket/req.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Req
+
+# == ZMQ::Socket::Req
+#
+# A socket of type ZMQ::Socket::Req is used by a client to send requests to and receive replies from a service. This socket type allows
+# only an alternating sequence of ZMQ::Socket#send and subsequent ZMQ::Socket#recv calls. Each request sent is load-balanced
+# among all services, and each reply received is matched with the last issued request.
+#
+# When a ZMQ::Socket::Req socket enters an exceptional state due to having reached the high water mark for all services, or if there
+# are no services at all, then any ZMQ::Socket#send operations on the socket shall block until the exceptional state ends or at
+# least one service becomes available for sending; messages are not discarded.
+#
+# === Summary of ZMQ::Socket::Req characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Rep
+# [Direction] Bidirectional
+# [Send/receive pattern] Send, Receive, Send, Receive, …
+# [Outgoing routing strategy] Load-balanced
+# [Incoming routing strategy] Last peer
+# [ZMQ::Socket#hwm option action] Block
+
+  TYPE_STR = "REQ"
+
+  def type
+    ZMQ::REQ
+  end
+
+  unsupported_api :sendm
+  handle_fsm_errors "REQ sockets allows only an alternating sequence of send and receive calls.", :send, :send_frame, :send_message, :recv, :recv_nonblock, :recv_frame, :recv_frame_nonblock, :recv_message
+
+  def send_frame(frame, flags = 0)
+    raise ZMQ::Error, "cannot send multiple frames on REQ sockets" if (flags & ZMQ::Frame::MORE) == ZMQ::Frame::MORE
+    super
+  end
+end

data/lib/zmq/socket/router.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Router
+
+# == ZMQ::Socket::Router
+# 
+# A socket of type ZMQ::Socket::Router is an advanced pattern used for extending request/reply sockets. When receiving messages
+# a ZMQ::Socket::Router socket shall prepend a message part containing the identity of the originating peer to the message before
+# passing it to the application. Messages received are fair-queued from among all connected peers. When sending messages a
+# ZMQ::Socket::Router socket shall remove the first part of the message and use it to determine the identity of the peer the message
+# shall be routed to. If the peer does not exist anymore the message shall be silently discarded.
+#
+# Previously this socket was called ZMQ_XREP and that name remains available for backwards compatibility.
+#
+# When a ZMQ::Socket::Router 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 messages sent to the socket shall be dropped until the exceptional state ends. Likewise, any
+# messages routed to a non-existent peer or a peer for which the individual high water mark has been reached shall also be dropped.
+#
+# When a ZMQ::Socket::Request socket is connected to a ZMQ::Socket::Router socket, in addition to the identity of the originating
+# peer each message received shall contain an empty delimiter message part. Hence, the entire structure of each received message as
+# seen by the application becomes: one or more identity parts, delimiter part, one or more body parts. When sending replies to a
+# ZMQ::Socket::Request socket the application must include the delimiter part.
+#
+# === Summary of ZMQ_ROUTER characteristics
+#
+# [Compatible peer socket] ZMQ::Socket::Dealer, ZMQ::Socket::Req, ZMQ::Socket::Rep
+# [Direction] Bidirectional
+# [Send/receive pattern] Unrestricted
+# [Outgoing routing strategy] See text
+# [Incoming routing strategy] Fair-queued
+# [ZMQ::Socket#hwm option action] Drop
+
+  TYPE_STR = "ROUTER"
+
+  def type
+    ZMQ::ROUTER
+  end
+end

data/lib/zmq/socket/sub.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+class ZMQ::Socket::Sub
+
+# == ZMQ::Socket::Sub
+#
+# A socket of type ZMQ::Socket::Sub is used by a subscriber to subscribe to data distributed by a publisher. Initially a
+# ZMQ::Socket::Sub socket is not subscribed to any messages, use ZMQ::Socket#subscribe to specify which messages to
+# subscribe to. The ZMQ::Socket#send function is not implemented for this socket type.
+#
+# === Summary of ZMQ::Socket::Sub characteristics
+#
+# [Compatible peer sockets] ZMQ::Socket::Pub
+# [Direction] Unidirectional
+# [Send/receive pattern] Receive only
+# [Incoming routing strategy] Fair-queued
+# [Outgoing routing strategy] N/A
+# [ZMQ::Socket#hwm option action] Drop
+
+  TYPE_STR = "SUB"
+
+  def type
+    ZMQ::SUB
+  end
+
+  include ZMQ::DownstreamSocket
+end

data/lib/zmq/timer.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+class ZMQ::Timer
+
+  # Callback for error conditions such as exceptions raised in timer callbacks. Receives an exception instance as argument and raises by default.
+  #
+  # handler.on_error(err)  =>  raise
+  #
+  def on_error(exception)
+    raise exception
+  end
+end

data/lib/zmq/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module ZMQ
+  VERSION = "0.1"
+end

data/perf/pair.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+$:.unshift('.')
+require File.join(File.dirname(__FILE__), 'runner')
+
+$runner = ThreadRunner.new(ENV["MSG_COUNT"], ENV["MSG_SIZE"], ENV["MSG_ENCODING"])
+$runner.start(:pair)

data/perf/pair/local.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+pair = ctx.socket(:PAIR)
+sleep 2
+pair.connect($runner.endpoint)
+
+messages, start_time = 0, nil
+while (case $runner.encoding
+  when :string
+    pair.recv
+  when :frame
+    pair.recv_frame
+  when :message
+    pair.recv_message
+  end) do
+  start_time ||= Time.now
+  messages += 1
+  break if messages == $runner.msg_count
+end
+
+$runner.stats(start_time)

data/perf/pair/remote.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+ctx = ZMQ.context
+pair = ctx.socket(:PAIR);
+pair.bind($runner.endpoint);
+
+msg = $runner.payload
+
+start_time = Time.now
+$runner.msg_count.times do
+  case $runner.encoding
+  when :string
+    pair.send(msg)
+  when :frame
+    pair.send_frame(ZMQ::Frame(msg))
+  when :message
+    m =  ZMQ::Message.new
+    m.pushstr "header"
+    m.pushstr msg
+    m.pushstr "body"
+    pair.send_message(m)
+  end
+end
+
+puts "Sent #{$runner.msg_count} messages in %ss ..." % (Time.now - start_time)

data/perf/pub_sub.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+$:.unshift('.')
+require File.join(File.dirname(__FILE__), 'runner')
+
+$runner = ProcessRunner.new(ENV["MSG_COUNT"], ENV["MSG_SIZE"], ENV["MSG_ENCODING"], ENV["PROCESSES"])
+$runner.start(:pub_sub)

data/perf/pub_sub/local.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+sub = ctx.socket(:SUB)
+sub.subscribe("")
+sub.connect($runner.endpoint)
+
+messages, start_time = 0, nil
+while (case $runner.encoding
+  when :string
+    sub.recv
+  when :frame
+    sub.recv_frame
+  when :message
+    sub.recv_message
+  end) do
+  start_time ||= Time.now
+  messages += 1
+  break if messages == $runner.msg_count
+end
+
+$runner.stats(start_time)

data/perf/pub_sub/remote.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+pub = ctx.socket(:PUB);
+pub.bind($runner.endpoint);
+
+msg = $runner.payload
+
+start_time = Time.now
+$runner.msg_count.times do
+  case $runner.encoding
+  when :string
+    pub.send(msg)
+  when :frame
+    pub.send_frame(ZMQ::Frame(msg))
+  when :message
+    m =  ZMQ::Message.new
+    m.pushstr "header"
+    m.pushstr msg
+    m.pushstr "body"
+    pub.send_message(m)
+  end
+end
+
+puts "Sent #{$runner.msg_count} messages in %ss ..." % (Time.now - start_time)

data/perf/push_pull.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+$:.unshift('.')
+require File.join(File.dirname(__FILE__), 'runner')
+
+$runner = ProcessRunner.new(ENV["MSG_COUNT"], ENV["MSG_SIZE"], ENV["MSG_ENCODING"], ENV["PROCESSES"])
+$runner.start(:push_pull)

data/perf/push_pull/local.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+pull = ctx.socket(:PULL)
+pull.connect($runner.endpoint)
+
+messages, start_time = 0, nil
+while (case $runner.encoding
+  when :string
+    pull.recv
+  when :frame
+    pull.recv_frame
+  when :message
+    pull.recv_message
+  end) do
+  start_time ||= Time.now
+  messages += 1
+  break if messages == $runner.process_msg_count
+end
+
+$runner.stats(start_time)

data/perf/push_pull/remote.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+push = ctx.socket(:PUSH);
+push.bind($runner.endpoint);
+
+msg = $runner.payload
+
+start_time = Time.now
+$runner.msg_count.times do
+  case $runner.encoding
+  when :string
+    push.send(msg)
+  when :frame
+    push.send_frame(ZMQ::Frame(msg))
+  when :message
+    m =  ZMQ::Message.new
+    m.pushstr "header"
+    m.pushstr msg
+    m.pushstr "body"
+    push.send_message(m)
+  end
+end
+
+puts "Sent #{$runner.msg_count} messages in %ss ..." % (Time.now - start_time)

data/perf/req_rep.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+$:.unshift('.')
+require File.join(File.dirname(__FILE__), 'runner')
+
+$runner = ProcessRunner.new(ENV["MSG_COUNT"], ENV["MSG_SIZE"], ENV["MSG_ENCODING"])
+$runner.start(:req_rep)

data/perf/req_rep/local.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+req = ctx.socket(:REQ)
+req.connect($runner.endpoint)
+
+msg = $runner.payload
+
+messages, start_time = 0, nil
+while (case $runner.encoding
+       when :string
+         req.send(msg)
+       when :frame
+         req.send_frame(ZMQ::Frame(msg))
+       when :message
+         m =  ZMQ::Message.new
+         m.pushstr "header"
+         m.pushstr msg
+         m.pushstr "body"
+         req.send_message(m)
+       end) do
+  start_time ||= Time.now
+  messages += 1
+  case $runner.encoding
+    when :string
+      req.recv
+    when :frame
+      req.recv_frame
+    when :message
+      req.recv_message
+    end
+  break if messages == $runner.msg_count
+end
+
+$runner.stats(start_time)

data/perf/req_rep/remote.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+ctx = ZMQ::Context.new
+rep = ctx.socket(:REP);
+rep.bind($runner.endpoint);
+
+start_time = Time.now
+$runner.msg_count.times do
+  msg = case $runner.encoding
+    when :string
+      rep.recv
+    when :frame
+      rep.recv_frame
+    when :message
+      rep.recv_message
+    end
+
+    case $runner.encoding
+      when :string
+        rep.send(msg)
+      when :frame
+        rep.send_frame(msg)
+      when :message
+        rep.send_message(msg)
+      end
+end
+
+puts "Sent #{$runner.msg_count} messages in %ss ..." % (Time.now - start_time)