rbczmq 0.1

data/ext/rbczmq/message.h

@@ -0,0 +1,24 @@
+#ifndef RBCZMQ_MESSAGE_H
+#define RBCZMQ_MESSAGE_H
+
+#define ZMQ_MESSAGE_DESTROYED 0x01
+
+typedef struct {
+    zmsg_t  *message;
+    int flags;
+} zmq_message_wrapper;
+
+#define ZmqAssertMessage(obj) ZmqAssertType(obj, rb_cZmqMessage, "ZMQ::Message")
+#define ZmqGetMessage(obj) \
+    zmq_message_wrapper *message = NULL; \
+    ZmqAssertMessage(obj); \
+    Data_Get_Struct(obj, zmq_message_wrapper, message); \
+    if (!message) rb_raise(rb_eTypeError, "uninitialized ZMQ message!"); \
+    if (message->flags & ZMQ_MESSAGE_DESTROYED) rb_raise(rb_eZmqError, "ZMQ::Message instance %p has been destroyed by the ZMQ framework", (void *)obj);
+
+VALUE rb_czmq_alloc_message(zmsg_t *message);
+void rb_czmq_free_message(zmq_message_wrapper *message);
+
+void _init_rb_czmq_message();
+
+#endif

data/ext/rbczmq/poller.c

@@ -0,0 +1,308 @@
+#include <rbczmq_ext.h>
+
+/*
+ * :nodoc:
+ *  GC mark callback
+ *
+*/
+static void rb_czmq_mark_poller(void *ptr)
+{
+    zmq_poll_wrapper *poller =  (zmq_poll_wrapper *)ptr;
+    if (poller) {
+        rb_gc_mark(poller->pollables);
+        rb_gc_mark(poller->readables);
+        rb_gc_mark(poller->writables);
+    }
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *                  
+*/
+static void rb_czmq_free_poller_gc(void *ptr)
+{
+    zmq_poll_wrapper *poller = (zmq_poll_wrapper *)ptr;
+    if (poller) {
+        xfree(poller->pollset);
+        xfree(poller);
+    }
+}
+
+/*
+ * :nodoc:
+ *  Rebuild the pollset from the sockets registered with this poller
+ *
+*/
+int rb_czmq_poller_rebuild_pollset(zmq_poll_wrapper *poller)
+{
+    VALUE pollable;
+    int rebuilt;
+    xfree(poller->pollset);
+    poller->pollset = NULL;
+    poller->pollset = ALLOC_N(zmq_pollitem_t, poller->poll_size);
+    if (!poller->pollset) return -1;
+    for (rebuilt = 0; rebuilt < poller->poll_size; rebuilt++) {
+        pollable = rb_ary_entry(poller->pollables, (long)rebuilt);
+        ZmqGetPollitem(pollable);
+        poller->pollset[rebuilt] = *pollitem->item;
+    }
+    poller->dirty = FALSE;
+    return 0;
+}
+
+/*
+ * :nodoc:
+ *  Rebuild the readable and writable arrays if any spoll items are in a ready state
+ *
+*/
+int rb_czmq_poller_rebuild_selectables(zmq_poll_wrapper *poller)
+{
+    VALUE pollable;
+    int rebuilt;
+    rb_ary_clear(poller->readables);
+    rb_ary_clear(poller->writables);
+    for (rebuilt = 0; rebuilt < poller->poll_size; rebuilt++) {
+        zmq_pollitem_t item = poller->pollset[rebuilt];
+        pollable = rb_ary_entry(poller->pollables, (long)rebuilt);
+        ZmqGetPollitem(pollable);
+        if (item.revents & ZMQ_POLLIN)
+            rb_ary_push(poller->readables, rb_czmq_pollitem_pollable(pollable));
+        if (item.revents & ZMQ_POLLOUT)
+            rb_ary_push(poller->writables, rb_czmq_pollitem_pollable(pollable));
+    }
+    return 0;
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Poller.new    =>  ZMQ::Poller
+ *
+ *  Initializes a new ZMQ::Poller instance.
+ *
+ * === Examples
+ *
+ *     ZMQ::Poller.new    =>  ZMQ::Poller
+ *
+*/
+VALUE rb_czmq_poller_new(VALUE obj)
+{
+    zmq_poll_wrapper *poller = NULL;
+    obj = Data_Make_Struct(rb_cZmqPoller, zmq_poll_wrapper, rb_czmq_mark_poller, rb_czmq_free_poller_gc, poller);
+    poller->pollset = NULL;
+    poller->pollables = rb_ary_new();
+    poller->readables = rb_ary_new();
+    poller->writables = rb_ary_new();
+    poller->dirty = FALSE;
+    poller->verbose = FALSE;
+    rb_obj_call_init(obj, 0, NULL);
+    return obj;
+}
+
+/*
+ * :nodoc:
+ *  Polls a set of sockets / IOs while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_poll(void *ptr)
+{
+    struct nogvl_poll_args *args = ptr;
+    int rc;
+    rc = zmq_poll(args->items, args->nitems, args->timeout);
+    return (VALUE)rc;
+}
+
+/*
+ *  call-seq:
+ *     poller.poll(1)    =>  Fixnum
+ *
+ *  Multiplexes input/output events in a level-triggered fashion over a set of registered sockets.
+ *
+ * === Examples
+ *
+ *  Supported timeout values :
+ *
+ *  -1  : block until any sockets are ready (no timeout)
+ *   0  : non-blocking poll
+ *   1  : block for up to 1 second (1000ms)
+ *  0.1 : block for up to 0.1 seconds (100ms)
+ *
+ *     poller = ZMQ::Poller.new             =>  ZMQ::Poller
+ *     poller.register(req)                 =>  true
+ *     poller.poll(1)                       =>  Fixnum
+ *
+*/
+VALUE rb_czmq_poller_poll(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE tmout;
+    size_t timeout;
+    struct nogvl_poll_args args;
+    int rc;
+    ZmqGetPoller(obj);
+    rb_scan_args(argc, argv, "01", &tmout);
+    if (NIL_P(tmout)) tmout = INT2NUM(0);
+    if (TYPE(tmout) != T_FIXNUM && TYPE(tmout) != T_FLOAT) rb_raise(rb_eTypeError, "wrong timeout type %s (expected Fixnum or Float)", RSTRING_PTR(rb_obj_as_string(tmout)));
+    if (poller->poll_size == 0) return INT2NUM(0);
+    if (poller->dirty == TRUE) {
+        rc = rb_czmq_poller_rebuild_pollset(poller);
+        if (rc == -1) rb_raise(rb_eZmqError, "failed in rebuilding the pollset!");
+    }
+    timeout = (size_t)(((TYPE(tmout) == T_FIXNUM) ? FIX2LONG(tmout) : RFLOAT_VALUE(tmout)) * 1000); 
+    if (timeout < 0) timeout = -1;
+
+    args.items = poller->pollset;
+    args.nitems = poller->poll_size;
+    args.timeout = (long)timeout;
+
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_poll, (void *)&args, RUBY_UBF_IO, 0);
+    ZmqAssert(rc);
+    if (rc == 0) {
+        rb_ary_clear(poller->readables);
+        rb_ary_clear(poller->writables);
+    } else {
+        rb_czmq_poller_rebuild_selectables(poller);
+    }
+    return INT2NUM(rc);
+}
+
+/*
+ *  call-seq:
+ *     poller.register(pollitem)    =>  boolean
+ *
+ *  Registers a poll item for a particular I/O event (ZMQ::POLLIN or ZMQ::POLLOUT) with this poller instance.
+ *  ZMQ::Socket or Ruby IO instances will automatically be coerced to ZMQ::Pollitem instances with the default
+ *  events mask (ZMQ::POLLIN | ZMQ::POLLOUT)
+ *
+ * === Examples
+ *
+ *  Supported events :
+ *
+ *  ZMQ::POLLIN   : readable state
+ *  ZMQ::POLLOUT  : writable state
+ *
+ *     poller = ZMQ::Poller.new                              =>  ZMQ::Poller
+ *     poller.register(ZMQ::Pollitem.new(req, ZMQ::POLLIN))  =>  true
+ *
+ *     poller.register(pub_socket)                           =>  true
+ *     poller.register(STDIN)                                =>  true
+ *
+*/
+VALUE rb_czmq_poller_register(VALUE obj, VALUE pollable)
+{
+    ZmqGetPoller(obj);
+    pollable = rb_czmq_pollitem_coerce(pollable);
+    ZmqGetPollitem(pollable);
+    /* Let pollable item be verbose if poller is verbose */
+    if (poller->verbose == TRUE) rb_czmq_pollitem_set_verbose(pollable, Qtrue);
+    rb_ary_push(poller->pollables, pollable);
+    poller->poll_size++;
+    poller->dirty = TRUE;
+    return pollable;
+}
+
+/*
+ *  call-seq:
+ *     poller.remove(pollitem)    =>  boolean
+ *
+ *  Removes a poll item from this poller. Deregisters the socket for *any* previously registered events.
+ *  Note that we match on both poll items as well as pollable entities for all registered poll items.
+ *
+ * === Examples
+ *
+ *     poller = ZMQ::Poller.new             =>  ZMQ::Poller
+ *     poller.register(req)                 =>  true
+ *     poller.remove(req)                   =>  true
+ *
+*/
+VALUE rb_czmq_poller_remove(VALUE obj, VALUE pollable)
+{
+    int pos;
+    VALUE rpollable;
+    ZmqGetPoller(obj);
+    pollable = rb_czmq_pollitem_coerce(pollable);
+    ZmqGetPollitem(pollable);
+    for (pos = 0; pos < poller->poll_size; pos++) {
+        rpollable = rb_ary_entry(poller->pollables, (long)pos);
+        if (pollable == rpollable || rb_czmq_pollitem_pollable(pollable) == rb_czmq_pollitem_pollable(rpollable)) {
+            rb_ary_delete(poller->pollables, rpollable);
+            poller->poll_size--;
+            poller->dirty = TRUE;
+            return rpollable;
+        }
+    }
+    return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     poller.readables    =>  Array
+ *
+ *  All poll items in a readable state after the last poll.
+ *
+ * === Examples
+ *
+ *     poller = ZMQ::Poller.new                          =>  ZMQ::Poller
+ *     poller.register(ZMQ::Pollitem(req, ZMQ::POLLIN))  =>  true
+ *     poller.poll(1)                                    =>  1
+ *     poller.readables                                  =>  [req]
+ *
+*/
+VALUE rb_czmq_poller_readables(VALUE obj)
+{
+    ZmqGetPoller(obj);
+    return poller->readables;
+}
+
+/*
+ *  call-seq:
+ *     poller.writables    =>  Array
+ *
+ *  All poll items in a writable state after the last poll.
+ *
+ * === Examples
+ *
+ *     poller = ZMQ::Poller.new                           =>  ZMQ::Poller
+ *     poller.register(ZMQ::Pollitem(req, ZMQ::POLLOUT))  =>  true
+ *     poller.poll(1)                                     =>  1
+ *     poller.writables                                   =>  [req]
+ *
+*/
+VALUE rb_czmq_poller_writables(VALUE obj)
+{
+    ZmqGetPoller(obj);
+    return poller->writables;
+}
+
+/*
+ *  call-seq:
+ *     poller.verbose = true    =>  nil
+ *
+ *  Logs poller activity to stdout - useful for debugging, but can be quite noisy with lots of activity.
+ *
+ * === Examples
+ *     poller = ZMQ::Poller.new    =>   ZMQ::Poller
+ *     poller.verbose = true   =>    nil
+ *
+*/
+
+static VALUE rb_czmq_poller_set_verbose(VALUE obj, VALUE level)
+{
+    Bool vlevel;
+    ZmqGetPoller(obj);
+    vlevel = (level == Qtrue) ? TRUE : FALSE;
+    poller->verbose = vlevel;
+    return Qnil;
+}
+
+void _init_rb_czmq_poller()
+{
+    rb_cZmqPoller = rb_define_class_under(rb_mZmq, "Poller", rb_cObject);
+
+    rb_define_alloc_func(rb_cZmqPoller, rb_czmq_poller_new);
+    rb_define_method(rb_cZmqPoller, "poll", rb_czmq_poller_poll, -1);
+    rb_define_method(rb_cZmqPoller, "register", rb_czmq_poller_register, 1);
+    rb_define_method(rb_cZmqPoller, "remove", rb_czmq_poller_remove, 1);
+    rb_define_method(rb_cZmqPoller, "readables", rb_czmq_poller_readables, 0);
+    rb_define_method(rb_cZmqPoller, "writables", rb_czmq_poller_writables, 0);
+    rb_define_method(rb_cZmqPoller, "verbose=", rb_czmq_poller_set_verbose, 1);
+}

data/ext/rbczmq/poller.h

@@ -0,0 +1,29 @@
+#ifndef RBCZMQ_POLLER_H
+#define RBCZMQ_POLLER_H
+
+typedef struct {
+    VALUE pollables;
+    VALUE readables;
+    VALUE writables;
+    zmq_pollitem_t *pollset;
+    int poll_size;
+    Bool dirty;
+    Bool verbose;
+} zmq_poll_wrapper;
+
+#define ZmqAssertPoller(obj) ZmqAssertType(obj, rb_cZmqPoller, "ZMQ::Poller")
+#define ZmqGetPoller(obj) \
+    zmq_poll_wrapper *poller = NULL; \
+    ZmqAssertPoller(obj); \
+    Data_Get_Struct(obj, zmq_poll_wrapper, poller); \
+    if (!poller) rb_raise(rb_eTypeError, "uninitialized ZMQ poller!");
+
+struct nogvl_poll_args {
+    zmq_pollitem_t *items;
+    int nitems;
+    long timeout;
+};
+
+void _init_rb_czmq_poller();
+
+#endif

data/ext/rbczmq/pollitem.c

@@ -0,0 +1,251 @@
+#include <rbczmq_ext.h>
+
+/*
+ * :nodoc:
+ *  GC mark callback
+ *
+*/
+void rb_czmq_mark_pollitem(void *ptr)
+{
+    zmq_pollitem_wrapper *pollitem = (zmq_pollitem_wrapper *)ptr;
+    if (ptr) {
+        rb_gc_mark(pollitem->socket);
+        rb_gc_mark(pollitem->io);
+        rb_gc_mark(pollitem->events);
+        rb_gc_mark(pollitem->handler);
+    }
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *
+*/
+void rb_czmq_free_pollitem_gc(void *ptr)
+{
+    zmq_pollitem_wrapper *pollitem = (zmq_pollitem_wrapper *)ptr;
+    if (ptr) {
+        xfree(pollitem->item);
+        xfree(pollitem);
+    }
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Pollitem.new(io, ZMQ:POLLIN)    =>  ZMQ::Pollitem
+ *
+ *  A generic poll item that supports Ruby I/O objects as well as native ZMQ sockets. Poll items are primarily used
+ *  for registering pollable entities with ZMQ::Poller and ZMQ::Loop instances. If no events given, we default to
+ *  observing both readable and writable state.
+ *
+ * === Examples
+ *
+ *  Supported pollable types :
+ *
+ *  IO           : any Ruby I/O object (must respond to #fileno as well)
+ *  ZMQ::Socket  : native ZMQ socket
+ *
+ *  Supported events :
+ *
+ *  ZMQ::POLLIN  : register for readable events
+ *  ZMQ::POLLOUT : register for writable events
+ *
+ *     ZMQ::Pollitem.new(io)                    =>  ZMQ::Pollitem
+ *     ZMQ::Pollitem.new(io, ZMQ:POLLIN)        =>  ZMQ::Pollitem
+ *     ZMQ::Pollitem.new(socket, ZMQ:POLLOUT)   =>  ZMQ::Pollitem
+ *
+*/
+static VALUE rb_czmq_pollitem_s_new(int argc, VALUE *argv, VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    VALUE pollable, events;
+    int evts;
+    zmq_pollitem_wrapper *pollitem = NULL;
+    rb_scan_args(argc, argv, "11", &pollable, &events);
+    if (NIL_P(events)) events = INT2NUM((ZMQ_POLLIN | ZMQ_POLLOUT));
+    Check_Type(events, T_FIXNUM);
+    evts = NUM2INT(events);
+    if (!(evts & ZMQ_POLLIN) && !(evts & ZMQ_POLLOUT))
+        rb_raise(rb_eZmqError, "invalid socket event: Only ZMQ::POLLIN and ZMQ::POLLOUT events are supported!");
+
+    /* XXX: Cleanup allocated struct on any failures below */
+    obj = Data_Make_Struct(rb_cZmqPollitem, zmq_pollitem_wrapper, rb_czmq_mark_pollitem, rb_czmq_free_pollitem_gc, pollitem);
+    pollitem->events = events;
+    pollitem->handler = Qnil;
+    pollitem->item = ALLOC(zmq_pollitem_t);
+    if (!pollitem->item) rb_memerror();
+    pollitem->item->events = evts;
+    if (rb_obj_is_kind_of(pollable, rb_cZmqSocket)) {
+       GetZmqSocket(pollable);
+       ZmqAssertSocketNotPending(sock, "socket in a pending state (not bound or connected) and thus cannot be registered as a poll item!");
+       ZmqSockGuardCrossThread(sock);
+       pollitem->socket = pollable;
+       pollitem->io = Qnil;
+       pollitem->item->fd = 0;
+       pollitem->item->socket = sock->socket;
+       /* Do not block on socket close */
+       zsockopt_set_linger(sock->socket, 1);
+    } else if (rb_obj_is_kind_of(pollable, rb_cIO)) {
+       pollitem->io = pollable;
+       pollitem->socket = Qnil;
+       pollitem->item->socket = NULL;
+       pollitem->item->fd = NUM2INT(rb_funcall(pollable, rb_intern("fileno"), 0));
+   /* XXX: handle coercion of other I/O like objects as well ? respond_to?(:fileno) ? */
+    } else {
+       rb_raise(rb_eTypeError, "wrong pollable type %s (%s). Only objects of type ZMQ::Socket and IO supported.", rb_obj_classname(pollable), RSTRING_PTR(rb_obj_as_string(pollable)));
+    }
+    rb_obj_call_init(obj, 0, NULL);
+    return obj;
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Pollitem.coerce(sock) =>  ZMQ::Pollitem
+ *
+ *  Attempts to coerce a ZMQ::Socket or IO to a ZMQ::Pollitem instance
+ *
+ * === Examples
+ *
+ *     ZMQ::Pollitem.coerce(sock)   =>  ZMQ::Pollitem
+ *     ZMQ::Pollitem.coerce(STDOUT) =>  IO
+ *
+*/
+
+VALUE rb_czmq_pollitem_s_coerce(ZMQ_UNUSED VALUE obj, VALUE pollable)
+{
+    VALUE pollitem;
+    VALUE args[1];
+    if (rb_obj_is_kind_of(pollable, rb_cZmqPollitem)) return pollable;
+    args[0] = pollable;
+    pollitem = Qnil;
+    return rb_czmq_pollitem_s_new(1, args, pollitem);
+}
+
+/*
+ * :nodoc:
+ *  Attempt to coerce an object to a ZMQ::Pollitem instance
+ *
+*/
+VALUE rb_czmq_pollitem_coerce(VALUE pollable)
+{
+    return rb_czmq_pollitem_s_coerce(Qnil, pollable);
+}
+
+/*
+ *  call-seq:
+ *     pollitem.pollable   =>  IO or ZMQ::Socket
+ *
+ *  Returns the pollable entity for this poll item.
+ *
+ * === Examples
+ *
+ *     item = ZMQ::Pollitem.new(STDOUT)         =>  ZMQ::Pollitem
+ *     item.pollable                            =>  STDOUT
+ *
+ *     item = ZMQ::Pollitem.new(pub_sock)       =>  ZMQ::Pollitem
+ *     item.pollable                            =>  ZMQ::Socket
+ *
+*/
+
+VALUE rb_czmq_pollitem_pollable(VALUE obj)
+{
+    ZmqGetPollitem(obj);
+    if (NIL_P(pollitem->socket)) return pollitem->io;
+    return pollitem->socket;
+}
+
+/*
+ *  call-seq:
+ *     pollitem.events   =>  Fixnum
+ *
+ *  Returns the I/O events the pollable entity is interested in.
+ *
+ * === Examples
+ *
+ *     item = ZMQ::Pollitem.new(sock, ZMQ::POLLIN)   =>  ZMQ::Pollitem
+ *     item.events                                   =>  ZMQ::POLLIN
+ *
+*/
+
+VALUE rb_czmq_pollitem_events(VALUE obj)
+{
+    ZmqGetPollitem(obj);
+    return pollitem->events;
+}
+
+/*
+ *  call-seq:
+ *     pollitem.handler =>  Object or nil
+ *
+ *  Returns the callback handler currently associated with this poll item.
+ *
+ * === Examples
+ *     item = ZMQ::Pollitem.new(sock)
+ *     item.handler = MyFrameHandler   => nil
+ *     item.handler                    => MyFrameHandler
+ *
+*/
+
+VALUE rb_czmq_pollitem_handler(VALUE obj)
+{
+    ZmqGetPollitem(obj);
+    return pollitem->handler;
+}
+
+/*
+ *  call-seq:
+ *     pollitem.handler = MyFrameHandler =>  nil
+ *
+ *  Associates a callback handler with this poll item.
+ *
+ * === Examples
+ *     item = ZMQ::Pollitem.new(sock)
+ *     item.handler = MyFrameHandler => nil
+ *
+*/
+
+VALUE rb_czmq_pollitem_handler_equals(VALUE obj, VALUE handler)
+{
+    ZmqGetPollitem(obj);
+    pollitem->handler = handler;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     pollitem.verbose = true    =>  nil
+ *
+ *  Logs pollitem activity to stdout - useful for debugging, but can be quite noisy with lots of activity. Only applicable
+ *  to pollable items of type ZMQ::Socket.
+ *
+ * === Examples
+ *     item = ZMQ::Pollitem.new(sock)    =>   ZMQ::Pollitem
+ *     item.verbose = true   =>    nil
+ *
+*/
+
+VALUE rb_czmq_pollitem_set_verbose(VALUE obj, VALUE level)
+{
+    Bool vlevel;
+    zmq_sock_wrapper *sock = NULL;
+    ZmqGetPollitem(obj);
+    vlevel = (level == Qtrue) ? TRUE : FALSE;
+    if (rb_obj_is_kind_of(pollitem->socket, rb_cZmqSocket)) {
+        GetZmqSocket(pollitem->socket);
+        sock->verbose = vlevel;
+    }
+    return Qnil;
+}
+
+void _init_rb_czmq_pollitem()
+{
+    rb_cZmqPollitem = rb_define_class_under(rb_mZmq, "Pollitem", rb_cObject);
+
+    rb_define_singleton_method(rb_cZmqPollitem, "new", rb_czmq_pollitem_s_new, -1);
+    rb_define_singleton_method(rb_cZmqPollitem, "coerce", rb_czmq_pollitem_s_coerce, 1);
+    rb_define_method(rb_cZmqPollitem, "pollable", rb_czmq_pollitem_pollable, 0);
+    rb_define_method(rb_cZmqPollitem, "events", rb_czmq_pollitem_events, 0);
+    rb_define_method(rb_cZmqPollitem, "handler", rb_czmq_pollitem_handler, 0);
+    rb_define_method(rb_cZmqPollitem, "handler=", rb_czmq_pollitem_handler_equals, 1);
+    rb_define_method(rb_cZmqPollitem, "verbose=", rb_czmq_pollitem_set_verbose, 1);
+}