rbczmq 0.1

data/ext/rbczmq/socket.h

@@ -0,0 +1,136 @@
+#ifndef RBCZMQ_SOCKET_H
+#define RBCZMQ_SOCKET_H
+
+#define ZMQ_SOCKET_DESTROYED 0x01
+
+/* Connection states */
+
+#define ZMQ_SOCKET_PENDING 0x01
+#define ZMQ_SOCKET_BOUND 0x02
+#define ZMQ_SOCKET_CONNECTED 0x04
+
+typedef struct {
+    zctx_t *ctx;
+    void *socket;
+    int flags;
+    Bool verbose;
+    int state;
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+    zlist_t *str_buffer;
+    zlist_t *frame_buffer;
+    zlist_t *msg_buffer;
+#endif
+    VALUE endpoint;
+    VALUE thread;
+    VALUE recv_timeout;
+    VALUE send_timeout;
+} zmq_sock_wrapper;
+
+#define ZMQ_SOCKET_DEFAULT_TIMEOUT Qnil
+
+#define ZmqAssertSocket(obj) ZmqAssertType(obj, rb_cZmqSocket, "ZMQ::Socket")
+#define GetZmqSocket(obj) \
+    ZmqAssertSocket(obj); \
+    Data_Get_Struct(obj, zmq_sock_wrapper, sock); \
+    if (!sock) rb_raise(rb_eTypeError, "uninitialized ZMQ socket!"); \
+    if (sock->flags & ZMQ_SOCKET_DESTROYED) rb_raise(rb_eZmqError, "ZMQ::Socket instance %p has been destroyed by the ZMQ framework", (void *)obj);
+
+#define ZmqDumpFrame(method, frame) \
+  do { \
+      sprintf(print_prefix, "%sI: %s socket %p: %s", cur_time, zsocket_type_str(sock->socket), (void *)sock->socket, method); \
+      zframe_print((frame), print_prefix); \
+      xfree(cur_time); \
+  } while(0)
+
+#define ZmqDumpMessage(method, message) \
+  do { \
+      zclock_log("I: %s socket %p: %s", zsocket_type_str(sock->socket), (void *)sock->socket, method); \
+      zmsg_dump((message)); \
+  } while(0)
+
+#define ZmqSockGuardCrossThread(sock) \
+  if ((sock)->thread != rb_thread_current()) \
+      rb_raise(rb_eZmqError, "Cross thread violation for %s socket %p: created in thread %p, invoked on thread %p", zsocket_type_str((sock)->socket), (void *)(sock), (void *)(sock)->thread, (void *)rb_thread_current());
+
+#define ZmqAssertSockOptFor(sock_type) \
+    if (zsockopt_type(sock->socket) != sock_type) \
+        rb_raise(rb_eZmqError, "Socket option not supported on a %s socket!", zsocket_type_str(sock->socket));
+
+#define CheckBoolean(arg) \
+    if (TYPE((arg)) != T_TRUE && TYPE((arg)) != T_FALSE) \
+        rb_raise(rb_eTypeError, "wrong argument %s (expected true or false)", RSTRING_PTR(rb_obj_as_string((arg))));
+
+#define ZmqSetSockOpt(obj, opt, desc, value) \
+    int val; \
+    GetZmqSocket(obj); \
+    ZmqSockGuardCrossThread(sock); \
+    Check_Type(value, T_FIXNUM); \
+    val = FIX2INT(value); \
+    (opt)(sock->socket, val); \
+    if (sock->verbose) \
+        zclock_log ("I: %s socket %p: set option \"%s\" %d", zsocket_type_str(sock->socket), (void *)obj, (desc),  val); \
+    return Qnil;
+
+#define ZmqSetStringSockOpt(obj, opt, desc, value, assertion) \
+    char *val; \
+    GetZmqSocket(obj); \
+    ZmqSockGuardCrossThread(sock); \
+    Check_Type(value, T_STRING); \
+    (assertion); \
+    val = StringValueCStr(value); \
+    (opt)(sock->socket, val); \
+    if (sock->verbose) \
+        zclock_log ("I: %s socket %p: set option \"%s\" \"%s\"", zsocket_type_str(sock->socket), (void *)obj, (desc),  val); \
+    return Qnil;
+
+#define ZmqSetBooleanSockOpt(obj, opt, desc, value) \
+    int val; \
+    GetZmqSocket(obj); \
+    ZmqSockGuardCrossThread(sock); \
+    CheckBoolean(value); \
+    val = (value == Qtrue) ? 1 : 0; \
+    (opt)(sock->socket, val); \
+    if (sock->verbose) \
+        zclock_log ("I: %s socket %p: set option \"%s\" %d", zsocket_type_str(sock->socket), (void *)obj, (desc),  val); \
+    return Qnil;
+
+#define ZmqAssertSocketNotPending(sock, msg) \
+    if (!((sock)->state & (ZMQ_SOCKET_BOUND | ZMQ_SOCKET_CONNECTED))) \
+        rb_raise(rb_eZmqError, msg);
+
+void rb_czmq_free_sock(zmq_sock_wrapper *sock);
+
+void rb_czmq_mark_sock(void *ptr);
+void rb_czmq_free_sock_gc(void *ptr);
+
+struct nogvl_send_args {
+    zmq_sock_wrapper *socket;
+    const char *msg;
+    Bool read;
+};
+
+struct nogvl_send_frame_args {
+    zmq_sock_wrapper *socket;
+    zframe_t *frame;
+    int flags;
+    Bool read;
+};
+
+struct nogvl_send_message_args {
+    zmq_sock_wrapper *socket;
+    zmsg_t *message;
+    Bool read;
+};
+
+struct nogvl_recv_args {
+    zmq_sock_wrapper *socket;
+};
+
+struct nogvl_conn_args {
+    zmq_sock_wrapper *socket;
+    char *endpoint;
+};
+
+void _init_rb_czmq_socket();
+
+#endif

data/ext/rbczmq/timer.c

@@ -0,0 +1,110 @@
+#include <rbczmq_ext.h>
+
+static VALUE intern_call;
+
+/*
+ * :nodoc:
+ *  GC mark callback
+ *
+*/
+static void rb_czmq_mark_timer(void *ptr)
+{
+    zmq_timer_wrapper *timer =  (zmq_timer_wrapper *)ptr;
+    rb_gc_mark(timer->callback);
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *
+*/
+static void rb_czmq_free_timer_gc(void *ptr)
+{
+    zmq_timer_wrapper *timer = (zmq_timer_wrapper *)ptr;
+    if (timer) xfree(timer);
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Timer.new(1, 2){ :fired }    =>  ZMQ::Timer
+ *
+ *  Initializes a new ZMQ::Timer instance.
+ *
+ * === Examples
+ *     ZMQ::Timer.new(1, 2){ :fired }    =>  ZMQ::Timer
+ *
+*/
+
+VALUE rb_czmq_timer_s_new(int argc, VALUE *argv, VALUE timer)
+{
+    VALUE delay, times, proc, callback;
+    size_t timer_delay;
+    zmq_timer_wrapper *tr = NULL;
+    rb_scan_args(argc, argv, "21&", &delay, &times, &proc, &callback);
+    if (NIL_P(proc) && NIL_P(callback)) rb_raise(rb_eArgError, "no callback given!");
+    if (NIL_P(proc)) {
+        rb_need_block();
+    } else {
+        callback = proc;
+    }
+    if (TYPE(delay) != T_FIXNUM && TYPE(delay) != T_FLOAT) rb_raise(rb_eTypeError, "wrong delay type %s (expected Fixnum or Float)", RSTRING_PTR(rb_obj_as_string(delay)));
+    Check_Type(times, T_FIXNUM);
+    timer_delay = (size_t)(((TYPE(delay) == T_FIXNUM) ? FIX2LONG(delay) : RFLOAT_VALUE(delay)) * 1000); 
+    timer = Data_Make_Struct(rb_cZmqTimer, zmq_timer_wrapper, rb_czmq_mark_timer, rb_czmq_free_timer_gc, tr);
+    tr->cancelled = FALSE;
+    tr->delay = timer_delay;
+    tr->times = FIX2INT(times);
+    tr->callback = callback;
+    rb_obj_call_init(timer, 0, NULL);
+    return timer;
+}
+
+/*
+ *  call-seq:
+ *     timer.fire   =>  Object
+ *
+ *  Fires a timer.
+ *
+ * === Examples
+ *     timer = ZMQ::Timer.new(1, 2){|arg| :fired }    =>  ZMQ::Timer
+ *     timer.fire(arg)
+ *
+*/
+
+static VALUE rb_czmq_timer_fire(VALUE obj, VALUE args)
+{
+    ZmqGetTimer(obj);
+    if (timer->cancelled == TRUE) rb_raise(rb_eZmqError, "cannot fire timer, already cancelled!");
+    return rb_apply(timer->callback, intern_call, args); 
+}
+
+/*
+ *  call-seq:
+ *     timer.cancel   =>  nil
+ *
+ *  Fires a timer.
+ *
+ * === Examples
+ *     timer = ZMQ::Timer.new(1, 2){|arg| :fired }    =>  ZMQ::Timer
+ *     timer.cancel   => nil
+ *
+*/
+
+static VALUE rb_czmq_timer_cancel(VALUE obj)
+{
+    ZmqGetTimer(obj);
+    timer->cancelled = TRUE;
+    return Qnil; 
+}
+
+void _init_rb_czmq_timer()
+{
+    intern_call = rb_intern("call");
+
+    rb_cZmqTimer = rb_define_class_under(rb_mZmq, "Timer", rb_cObject);
+
+    rb_define_singleton_method(rb_cZmqTimer, "new", rb_czmq_timer_s_new, -1);
+    rb_define_method(rb_cZmqTimer, "fire", rb_czmq_timer_fire, -2);
+    rb_define_alias(rb_cZmqTimer, "call", "fire");
+    rb_define_method(rb_cZmqTimer, "cancel", rb_czmq_timer_cancel, 0);
+}

data/ext/rbczmq/timer.h

@@ -0,0 +1,23 @@
+#ifndef RBCZMQ_TIMER_H
+#define RBCZMQ_TIMER_H
+
+typedef struct {
+    size_t delay;
+    size_t times;
+    Bool cancelled;
+    VALUE callback;
+} zmq_timer_wrapper;
+
+#define ZmqAssertTimer(obj) ZmqAssertType(obj, rb_cZmqTimer, "ZMQ::Timer")
+#define ZmqGetTimer(obj) \
+    zmq_timer_wrapper *timer = NULL; \
+    ZmqAssertTimer(obj); \
+    Data_Get_Struct(obj, zmq_timer_wrapper, timer); \
+    if (!timer) rb_raise(rb_eTypeError, "uninitialized ZMQ timer!");
+
+VALUE rb_czmq_timer_s_new(int argc, VALUE *argv, VALUE timer);
+
+void _init_rb_czmq_timer();
+
+#endif
+

data/lib/rbczmq.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'zmq')

data/lib/zmq.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+# Prefer compiled Rubinius bytecode in .rbx/
+ENV["RBXOPT"] = "-Xrbc.db"
+
+begin
+require "zmq/rbczmq_ext"
+rescue LoadError
+  require "rbczmq_ext"
+end
+
+require 'zmq/version' unless defined? ZMQ::VERSION
+require 'socket'
+
+module ZMQ
+  # Sugaring for creating new ZMQ frames
+  #
+  # ZMQ::Frame("frame")  =>  ZMQ::Frame
+  #
+  def self.Frame(data = nil)
+    ZMQ::Frame.new(data)
+  end
+
+  # Sugaring for creating new ZMQ messages
+  #
+  # ZMQ::Message("one", "two", "three")  =>  ZMQ::Message
+  #
+  def self.Message(*parts)
+    m = ZMQ::Message.new
+    parts.each{|p| m.addstr(p) }
+    m
+  end
+
+  # Sugaring for creating new poll items
+  #
+  # ZMQ::Pollitem(STDIN, ZMQ::POLLIN)  =>  ZMQ::Pollitem
+  #
+  def self.Pollitem(pollable, events = nil)
+    ZMQ::Pollitem.new(pollable, events)
+  end
+
+  # Returns the ZMQ context for this process, if any
+  #
+  def self.context
+    @__zmq_ctx_process[Process.pid]
+  end
+
+  # Higher level loop API.
+  #
+  # XXX: Handle cases where context is nil
+  #
+  def self.loop
+    @loop ||= ZMQ::Loop.new(context)
+  end
+
+  # API sugaring: IO.select compatible API, but for ZMQ sockets.
+  #
+  def self.select(read = [], write = [], error = [], timeout = nil)
+    poller = ZMQ::Poller.new
+    read.each{|s| poller.register_readable(s) } if read
+    write.each{|s| poller.register_writable(s) } if write
+    ready = poller.poll(timeout)
+    [poller.readables, poller.writables, []] if ready
+  end
+
+  autoload :Handler, 'zmq/handler'
+  autoload :DefaultHandler, 'zmq/default_handler'
+end
+
+require "zmq/context"
+require "zmq/socket"
+require "zmq/loop"
+require "zmq/timer"
+require "zmq/frame"
+require "zmq/message"
+require "zmq/poller"
+require "zmq/pollitem"

data/lib/zmq/context.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+class ZMQ::Context
+
+  # Overload the libczmq handler installed for SIGINT and SIGTERM on context init. This ensures we fallback to the default
+  # Ruby signal handlers which is least likely to violate the principle of least surprise. As an alternative fallback, we
+  # expose ZMQ.interrupted! which reverts back to the libczmq default actions when called from a Ruby signal handler. The
+  # following restores the default libczmq behavior :
+  #
+  # def initialize(*args)
+  #   super
+  #   trap(:INT){ ZMQ.interrupted! }
+  #   trap(:TERM){ ZMQ.interrupted! }
+  # end
+  #
+
+  def initialize(*args)
+    super
+    trap(:INT, "DEFAULT")
+    trap(:TERM, "DEFAULT")
+  end
+
+  # Before using any ØMQ library functions the caller must initialise a ØMQ context.
+  #
+  # The context manages open sockets and automatically closes these before termination. Other responsibilities include :
+  #
+  # * A simple way to set the linger timeout on sockets
+  # * C onfigure contexts for a number of I/O threads
+  # * Sets-up signal (interrrupt) handling for the process.
+
+  # Sugaring for spawning a new socket and bind to a given endpoint
+  #
+  # ctx.bind(:PUB, "tcp://127.0.0.1:5000")
+  #
+  def bind(sock_type, endpoint)
+    s = socket(sock_type)
+    s.bind(endpoint)
+    s
+  end
+
+  # Sugaring for spawning a new socket and connect to a given endpoint
+  #
+  # ctx.connect(:SUB, "tcp://127.0.0.1:5000")
+  #
+  def connect(sock_type, endpoint)
+    s = socket(sock_type)
+    s.connect(endpoint)
+    s
+  end
+end

data/lib/zmq/default_handler.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+class ZMQ::DefaultHandler < ZMQ::Handler
+
+  # A default / blanket pollitem callback handler for when a socket or IO is registered on a ZMQ::Loop instance.
+  #
+  # XXX: Likely a massive fail for some socket / IO pairs as a default - look into removing this.
+
+  def on_readable
+    p recv
+  end
+
+  def on_writable
+    send("")
+  end
+end

data/lib/zmq/frame.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+class ZMQ::Frame
+
+  # The ZMQ::Frame class provides methods to send and receive single message rames across 0MQ sockets. When reading a frame
+  # from a socket, the ZMQ::Frame#more? method indicates if the frame is part of an unfinished multipart message. The
+  # ZMQ::Socket#send_frame method normally destroys the frame, but with the ZFRAME_REUSE flag, you can send the same frame
+  # many times. Frames are binary, and this class has no special support for text data.
+
+  include Comparable
+end

data/lib/zmq/handler.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+class ZMQ::Handler
+
+  # The ZMQ::Pollitem instance wrapped by this handler.
+  attr_reader :pollitem
+
+  # A ZMQ::Pollitem instance is compulsary on init, with support for optional arguments if a subclasses do require them.
+  #
+  # pub = ctx.bind(:PUB, "tcp://127.0.0.1:5000") # lower level API
+  # item = ZMQ::Pollitem.new(pub)
+  # item.handler = ZMQ::Handler.new(pub)
+  #
+  # class ProducerHandler < ZMQ::Handler
+  #   def initialize(item, producer)
+  #     super
+  #     @producer = producer
+  #   end
+  #
+  #   def on_writable
+  #     @producer.work
+  #   end
+  # end
+  #
+  # ZMQ::Loop.bind(:PUB, "tcp://127.0.0.1:5000", ProducerHandler, producer) # higher level API
+  #
+  def initialize(pollitem, *args)
+    raise TypeError.new("#{pollitem.inspect} is not a valid ZMQ::Pollitem instance") unless ZMQ::Pollitem === pollitem
+    @pollitem = pollitem
+  end
+
+  # Callback invoked from ZMQ::Loop handlers when the pollable item is ready for reading. Subclasses are expected to implement
+  # this contract as the default just raises NotImplementedError. It's reccommended to read in a non-blocking manner
+  # from within this callback.
+  #
+  # def on_readable
+  #   msgs << recv
+  # end
+  #
+  def on_readable
+    raise NotImplementedError, "ZMQ handlers are expected to implement an #on_readable contract"
+  end
+
+  # Callback invoked from ZMQ::Loop handlers when the pollable item is ready for writing. Subclasses are expected to implement
+  # this contract as the default just raises NotImplementedError. It's reccommended to write data out as fast as possible
+  # from within this callback.
+  #
+  # def on_writable
+  #   send buffer.shift
+  # end
+  #
+  def on_writable
+    raise NotImplementedError, "ZMQ handlers are expected to implement an #on_writable contract"
+  end
+
+  # Callback for error conditions such as pollable item errors on poll and exceptions raised in callbacks. Receives an exception
+  # instance as argument and raises by default.
+  #
+  # handler.on_error(err)  =>  raise
+  #
+  def on_error(exception)
+    raise exception
+  end
+
+  # API that allows handlers to send data regardless of the underlying pollable item type (ZMQ::Socket or IO).
+  #
+  def send(*args)
+    pollitem.send(*args)
+  end
+
+  # API that allows handlers to receive data regardless of the underlying pollable item type (ZMQ::Socket or IO).
+  #
+  def recv
+    pollitem.recv
+  end
+end