rbczmq 0.9 → 1.0

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
 = Changelog
 
+== 1.0 (November 24, 2012)
+* Supports ZeroMQ 3.2.2 (first stable and backwards compatible 3.x release)
+* Monitoring API for handling socket state changes / events
+* Support for raw TCP sockets (ROUTER sockets only)
+* Not dependent on libuuid anymore
+
 == 0.9 (August 18, 2012)
 * Sockets now record and show all endpoints
 * Support connect_all for SRV managed topologies

data/README.rdoc

@@ -224,10 +224,10 @@ Running tests
 
 OS X notes:
 
-If you are installing the package on a new mack ensure you have libtool and autoconf isntalled.  
+If you are installing the package on a new mack ensure you have libtool and autoconf installed.
 You can get those with brew packaging system:
 
-    brew insatll libtool autoconf automake
+    brew install libtool autoconf automake
 
 == TODO
 

data/ext/rbczmq/context.c

@@ -190,6 +190,7 @@ static VALUE rb_czmq_ctx_hwm(VALUE obj)
     errno = 0;
     int wm;
     ZmqGetContext(obj);
+    rb_warn("Deprecated method ZMQ::Context#hwm, does nothing - to be removed after 2013/05/14");
     return INT2FIX(zctx_hwm(ctx->ctx));
 }
 
@@ -211,6 +212,7 @@ static VALUE rb_czmq_ctx_set_hwm(VALUE obj, VALUE hwm)
     int wm;
     ZmqGetContext(obj);
     Check_Type(hwm, T_FIXNUM);
+    rb_warn("Deprecated method ZMQ::Context#hwm=, does nothing - to be removed after 2013/05/14");
     wm = FIX2INT(hwm);
     if (wm < 0) rb_raise(rb_eZmqError, "negative HWM values is not supported.");
     zctx_set_hwm(ctx->ctx, wm);
@@ -303,6 +305,10 @@ static VALUE rb_czmq_ctx_socket(VALUE obj, VALUE type)
     sock->state = ZMQ_SOCKET_PENDING;
     sock->endpoints = rb_ary_new();
     sock->thread = rb_thread_current();
+    sock->context = obj;
+    sock->monitor_endpoint = Qnil;
+    sock->monitor_handler = Qnil;
+    sock->monitor_thread = Qnil;
     rb_obj_call_init(socket, 0, NULL);
     return socket;
 }

data/ext/rbczmq/extconf.rb

@@ -30,9 +30,6 @@ czmq_include_path = czmq_path + 'include'
 
 # Fail early if we don't meet the following dependencies.
 
-# Present on OS X and BSD systems, package install required on Linux
-fail("package uuid-dev required (apt-get install uuid-dev)") unless have_header('uuid/uuid.h')
-
 # Courtesy of EventMachine and @tmm1
 def check_libs libs = [], fatal = false
   libs.all? { |lib| have_library(lib) || (abort("could not find library: #{lib}") if fatal) }

data/ext/rbczmq/rbczmq_ext.c

@@ -197,6 +197,18 @@ void Init_rbczmq_ext()
     rb_define_const(rb_mZmq, "ETERM", INT2NUM(ETERM));
     rb_define_const(rb_mZmq, "EMTHREAD", INT2NUM(EMTHREAD));
 
+    rb_define_const(rb_mZmq, "EVENT_CONNECTED", INT2NUM(ZMQ_EVENT_CONNECTED));
+    rb_define_const(rb_mZmq, "EVENT_CONNECT_DELAYED", INT2NUM(ZMQ_EVENT_CONNECT_DELAYED));
+    rb_define_const(rb_mZmq, "EVENT_CONNECT_RETRIED", INT2NUM(ZMQ_EVENT_CONNECT_RETRIED));
+    rb_define_const(rb_mZmq, "EVENT_LISTENING", INT2NUM(ZMQ_EVENT_LISTENING));
+    rb_define_const(rb_mZmq, "EVENT_BIND_FAILED", INT2NUM(ZMQ_EVENT_BIND_FAILED));
+    rb_define_const(rb_mZmq, "EVENT_ACCEPTED", INT2NUM(ZMQ_EVENT_ACCEPTED));
+    rb_define_const(rb_mZmq, "EVENT_ACCEPT_FAILED", INT2NUM(ZMQ_EVENT_ACCEPT_FAILED));
+    rb_define_const(rb_mZmq, "EVENT_CLOSED", INT2NUM(ZMQ_EVENT_CLOSED));
+    rb_define_const(rb_mZmq, "EVENT_CLOSE_FAILED", INT2NUM(ZMQ_EVENT_CLOSE_FAILED));
+    rb_define_const(rb_mZmq, "EVENT_DISCONNECTED", INT2NUM(ZMQ_EVENT_DISCONNECTED));
+    rb_define_const(rb_mZmq, "EVENT_ALL", INT2NUM(ZMQ_EVENT_ALL));
+
     _init_rb_czmq_context();
     _init_rb_czmq_socket();
     _init_rb_czmq_frame();

data/ext/rbczmq/rbczmq_ext.h

@@ -92,15 +92,4 @@ static inline char *rb_czmq_formatted_current_time()
     return formatted;
 }
 
-struct nogvl_device_args {
-    int type;
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
-    zctx_t *ctx;
-#endif
-    zmq_sock_wrapper *in;
-    zmq_sock_wrapper *out;
-    int rc;
-};
-typedef struct nogvl_device_args nogvl_device_args_t;
-
 #endif

data/ext/rbczmq/socket.c

@@ -1,5 +1,16 @@
 #include "rbczmq_ext.h"
 
+VALUE intern_on_connected;
+VALUE intern_on_connect_delayed;
+VALUE intern_on_connect_retried;
+VALUE intern_on_listening;
+VALUE intern_on_bind_failed;
+VALUE intern_on_accepted;
+VALUE intern_on_accept_failed;
+VALUE intern_on_closed;
+VALUE intern_on_close_failed;
+VALUE intern_on_disconnected;
+
 /*
  * :nodoc:
  *  Destroy the socket while the GIL is released - may block depending on socket linger value.
@@ -42,6 +53,10 @@ void rb_czmq_mark_sock(void *ptr)
             zclock_log ("I: %s socket %p, context %p: GC mark", zsocket_type_str(sock->socket), sock, sock->ctx);
         rb_gc_mark(sock->endpoints);
         rb_gc_mark(sock->thread);
+        rb_gc_mark(sock->context);
+        rb_gc_mark(sock->monitor_endpoint);
+        rb_gc_mark(sock->monitor_handler);
+        rb_gc_mark(sock->monitor_thread);
     }
 }
 
@@ -788,6 +803,8 @@ static VALUE rb_czmq_socket_recv_message(VALUE obj)
     return rb_czmq_alloc_message(message);
 }
 
+#if ZMQ_VERSION_MAJOR == 2
+
 /*
  *  call-seq:
  *     sock.hwm =>  Fixnum
@@ -866,6 +883,89 @@ static VALUE rb_czmq_socket_set_opt_swap(VALUE obj, VALUE value)
     zmq_sock_wrapper *sock = NULL;
     ZmqSetSockOpt(obj, zsocket_set_swap, "SWAP", value);
 }
+#endif
+
+#if ZMQ_VERSION_MAJOR == 3
+/*
+ *  call-seq:
+ *     sock.sndhwm =>  Fixnum
+ *
+ *  Returns the socket send HWM (High Water Mark) value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.sndhwm  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_sndhwm(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsocket_sndhwm(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.sndhwm = 100 =>  nil
+ *
+ *  Sets the socket send HWM (High Water Mark() value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.sndhwm = 100  =>  nil
+ *     sock.sndhwm  =>  100
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_sndhwm(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsocket_set_sndhwm, "SNDHWM", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.rcvhwm =>  Fixnum
+ *
+ *  Returns the socket receive HWM (High Water Mark) value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.sndhwm  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_rcvhwm(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsocket_rcvhwm(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.rcvhwm = 100 =>  nil
+ *
+ *  Sets the socket receive HWM (High Water Mark() value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.rcvhwm = 100  =>  nil
+ *     sock.rcvhwm  =>  100
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_rcvhwm(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsocket_set_rcvhwm, "RCVHWM", value);
+}
+#endif
 
 /*
  *  call-seq:
@@ -984,6 +1084,7 @@ static VALUE rb_czmq_socket_set_opt_recovery_ivl(VALUE obj, VALUE value)
     ZmqSetSockOpt(obj, zsocket_set_recovery_ivl, "RECOVERY_IVL", value);
 }
 
+#if ZMQ_VERSION_MAJOR == 2
 /*
  *  call-seq:
  *     sock.recovery_ivl_msec =>  Fixnum
@@ -1061,6 +1162,7 @@ static VALUE rb_czmq_socket_set_opt_mcast_loop(VALUE obj, VALUE value)
     zmq_sock_wrapper *sock = NULL;
     ZmqSetBooleanSockOpt(obj, zsocket_set_mcast_loop, "MCAST_LOOP", value);
 }
+#endif
 
 /*
  *  call-seq:
@@ -1485,6 +1587,155 @@ static VALUE rb_czmq_socket_set_opt_sndtimeo(VALUE obj, VALUE value)
     ZmqSetSockOpt(obj, zsocket_set_sndtimeo, "SNDTIMEO", value);
 }
 
+#if defined (ZMQ_ROUTER_RAW)
+/*
+ *  call-seq:
+ *     sock.raw = true =>  nil
+ *
+ *  Define this as a RAW socket - applicable to ROUTER sockets only.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:ROUTER)
+ *     sock.router = 200  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_raw(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetBooleanSockOpt(obj, zsocket_set_router_raw, "ROUTER_RAW", value);
+}
+#endif
+
+/*
+ * :nodoc:
+ *  Receives a monitoring event message while the GIL is released.
+ *
+*/
+
+static VALUE rb_czmq_nogvl_monitor_recv(void *ptr)
+{
+    struct nogvl_monitor_recv_args *args = ptr;
+    int rc;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    rc = zmq_recvmsg (args->socket, &args->msg, 0);
+#else
+    int fd;
+    size_t option_len = sizeof (int);
+    zmq_getsockopt (args->socket, ZMQ_FD, &fd, &option_len);
+try_readable:
+    if ((zsocket_events(args->socket) & ZMQ_POLLIN) == ZMQ_POLLIN) {
+        rc = zmq_recvmsg (args->socket, &args->msg, 0);
+     } else {
+        rb_thread_wait_fd(fd);
+        goto try_readable;
+     }
+#endif
+    return (VALUE)rc;
+}
+
+/*
+ * :nodoc:
+ *  Runs with the context of a new Ruby thread and spawns a PAIR socket for handling monitoring events
+ *
+*/
+
+static VALUE rb_czmq_socket_monitor_thread(void *arg)
+{
+    zmq_event_t event;
+    struct nogvl_monitor_recv_args args;
+    int rc;
+    zmq_sock_wrapper *sock = (zmq_sock_wrapper *)arg;
+
+    void *s = zsocket_new (sock->ctx, ZMQ_PAIR);
+    assert (s);
+
+    rc = zmq_connect (s, StringValueCStr(sock->monitor_endpoint));
+    assert (rc == 0);
+
+    THREAD_PASS;
+
+    while (1) {
+        args.socket = s;
+        zmq_msg_init (&args.msg);
+        rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_monitor_recv, (void *)&args, RUBY_UBF_IO, 0);
+        if (rc == -1 && (zmq_errno() == ETERM || zmq_errno() == ENOTSOCK || zmq_errno() == EINTR)) break;
+        assert (rc != -1);
+        memcpy (&event, zmq_msg_data (&args.msg), sizeof (event));
+        switch (event.event) {
+        case ZMQ_EVENT_CONNECTED: rb_funcall(sock->monitor_handler, intern_on_connected, 2, rb_str_new2(event.data.connected.addr), INT2FIX(event.data.connected.fd));
+                                  break;
+        case ZMQ_EVENT_CONNECT_DELAYED: rb_funcall(sock->monitor_handler, intern_on_connect_delayed, 2, rb_str_new2(event.data.connect_delayed.addr), INT2FIX(event.data.connect_delayed.err));
+                                        break;
+        case ZMQ_EVENT_CONNECT_RETRIED: rb_funcall(sock->monitor_handler, intern_on_connect_retried, 2, rb_str_new2(event.data.connect_retried.addr), INT2FIX(event.data.connect_retried.interval));
+                                        break;
+        case ZMQ_EVENT_LISTENING: rb_funcall(sock->monitor_handler, intern_on_listening, 2, rb_str_new2(event.data.listening.addr), INT2FIX(event.data.listening.fd));
+                                  break;
+        case ZMQ_EVENT_BIND_FAILED: rb_funcall(sock->monitor_handler, intern_on_bind_failed, 2, rb_str_new2(event.data.bind_failed.addr), INT2FIX(event.data.bind_failed.err));
+                                    break;
+        case ZMQ_EVENT_ACCEPTED: rb_funcall(sock->monitor_handler, intern_on_accepted, 2, rb_str_new2(event.data.accepted.addr), INT2FIX(event.data.accepted.fd));
+                                 break;
+        case ZMQ_EVENT_ACCEPT_FAILED: rb_funcall(sock->monitor_handler, intern_on_accept_failed, 2, rb_str_new2(event.data.accept_failed.addr), INT2FIX(event.data.accept_failed.err));
+                                      break;
+        case ZMQ_EVENT_CLOSE_FAILED: rb_funcall(sock->monitor_handler, intern_on_close_failed, 2, rb_str_new2(event.data.close_failed.addr), INT2FIX(event.data.close_failed.err));
+                                     break;
+        case ZMQ_EVENT_CLOSED: rb_funcall(sock->monitor_handler, intern_on_closed, 2, rb_str_new2(event.data.closed.addr), INT2FIX(event.data.closed.fd));
+                               break;
+        case ZMQ_EVENT_DISCONNECTED: rb_funcall(sock->monitor_handler, intern_on_disconnected, 2, rb_str_new2(event.data.disconnected.addr), INT2FIX(event.data.disconnected.fd));
+                                     break;
+        }
+    }
+    zmq_close (s);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.monitor("inproc://monitoring", callback, events) =>  nil
+ *
+ *  Registers a monitoring callback for this socket
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     rep = ctx.socket(:REP)
+ *     rep.monitor("inproc://monitoring.rep", RepMonitor)
+ *     req = ctx.socket(:REQ)
+ *     req.monitor("inproc://monitoring.req", ReqMonitor, ZMQ_EVENT_DISCONNECTED)
+ *     rep.bind("tcp://127.0.0.1:5331")
+ *     rep.bind("tcp://127.0.0.1:5332")
+ *
+*/
+
+static VALUE rb_czmq_socket_monitor(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE endpoint;
+    VALUE handler;
+    VALUE events;
+    int rc;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqSockGuardCrossThread(sock);
+    rb_scan_args(argc, argv, "12", &endpoint, &handler, &events);
+    Check_Type(endpoint, T_STRING);
+    if (NIL_P(events))
+        events = rb_const_get_at(rb_mZmq, rb_intern("EVENT_ALL"));
+    if (NIL_P(handler)) {
+        handler = rb_class_new_instance(0, NULL, rb_const_get_at(rb_mZmq, rb_intern("Monitor")));
+    }
+    Check_Type(events, T_FIXNUM);
+    rc = zmq_socket_monitor(sock->socket, StringValueCStr(endpoint), NUM2INT(events));
+    if (rc == 0) {
+        sock->monitor_endpoint = endpoint;
+        sock->monitor_handler = handler;
+        sock->monitor_thread = rb_thread_create(rb_czmq_socket_monitor_thread, (void*)sock);
+        rb_thread_run(sock->monitor_thread);
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
 void _init_rb_czmq_socket()
 {
     rb_cZmqSocket = rb_define_class_under(rb_mZmq, "Socket", rb_cObject);
@@ -1498,6 +1749,17 @@ void _init_rb_czmq_socket()
     rb_cZmqReqSocket = rb_define_class_under(rb_cZmqSocket, "Req", rb_cZmqSocket);;
     rb_cZmqPairSocket = rb_define_class_under(rb_cZmqSocket, "Pair", rb_cZmqSocket);;
 
+    intern_on_connected = rb_intern("on_connected");
+    intern_on_connect_delayed = rb_intern("on_connect_delayed");
+    intern_on_connect_retried = rb_intern("on_connect_retried");
+    intern_on_listening = rb_intern("on_listening");
+    intern_on_bind_failed = rb_intern("on_bind_failed");
+    intern_on_accepted = rb_intern("on_accepted");
+    intern_on_accept_failed = rb_intern("on_accept_failed");
+    intern_on_closed = rb_intern("on_closed");
+    intern_on_close_failed = rb_intern("on_close_failed");
+    intern_on_disconnected = rb_intern("on_disconnected");
+
     rb_define_const(rb_cZmqSocket, "PENDING", INT2NUM(ZMQ_SOCKET_PENDING));
     rb_define_const(rb_cZmqSocket, "BOUND", INT2NUM(ZMQ_SOCKET_BOUND));
     rb_define_const(rb_cZmqSocket, "CONNECTED", INT2NUM(ZMQ_SOCKET_CONNECTED));
@@ -1520,20 +1782,34 @@ void _init_rb_czmq_socket()
     rb_define_method(rb_cZmqSocket, "recv_frame_nonblock", rb_czmq_socket_recv_frame_nonblock, 0);
     rb_define_method(rb_cZmqSocket, "recv_message", rb_czmq_socket_recv_message, 0);
 
-    rb_define_method(rb_cZmqSocket, "hwm", rb_czmq_socket_opt_hwm, 0);
-    rb_define_method(rb_cZmqSocket, "hwm=", rb_czmq_socket_set_opt_hwm, 1);
+#if ZMQ_VERSION_MAJOR == 2
     rb_define_method(rb_cZmqSocket, "swap", rb_czmq_socket_opt_swap, 0);
     rb_define_method(rb_cZmqSocket, "swap=", rb_czmq_socket_set_opt_swap, 1);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec", rb_czmq_socket_opt_recovery_ivl_msec, 0);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec=", rb_czmq_socket_set_opt_recovery_ivl_msec, 1);
+    rb_define_method(rb_cZmqSocket, "mcast_loop?", rb_czmq_socket_opt_mcast_loop, 0);
+    rb_define_method(rb_cZmqSocket, "mcast_loop=", rb_czmq_socket_set_opt_mcast_loop, 1);
+    rb_define_method(rb_cZmqSocket, "hwm", rb_czmq_socket_opt_hwm, 0);
+    rb_define_method(rb_cZmqSocket, "hwm=", rb_czmq_socket_set_opt_hwm, 1);
+#endif
+
+#if ZMQ_VERSION_MAJOR == 3
+    rb_define_method(rb_cZmqSocket, "sndhwm", rb_czmq_socket_opt_sndhwm, 0);
+    rb_define_method(rb_cZmqSocket, "sndhwm=", rb_czmq_socket_set_opt_sndhwm, 1);
+    rb_define_method(rb_cZmqSocket, "rcvhwm", rb_czmq_socket_opt_rcvhwm, 0);
+    rb_define_method(rb_cZmqSocket, "rcvhwm=", rb_czmq_socket_set_opt_rcvhwm, 1);
+
+#if defined (ZMQ_ROUTER_RAW)
+    rb_define_method(rb_cZmqSocket, "raw=", rb_czmq_socket_set_opt_raw, 1);
+#endif
+#endif
+
     rb_define_method(rb_cZmqSocket, "affinity", rb_czmq_socket_opt_affinity, 0);
     rb_define_method(rb_cZmqSocket, "affinity=", rb_czmq_socket_set_opt_affinity, 1);
     rb_define_method(rb_cZmqSocket, "rate", rb_czmq_socket_opt_rate, 0);
     rb_define_method(rb_cZmqSocket, "rate=", rb_czmq_socket_set_opt_rate, 1);
     rb_define_method(rb_cZmqSocket, "recovery_ivl", rb_czmq_socket_opt_recovery_ivl, 0);
     rb_define_method(rb_cZmqSocket, "recovery_ivl=", rb_czmq_socket_set_opt_recovery_ivl, 1);
-    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec", rb_czmq_socket_opt_recovery_ivl_msec, 0);
-    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec=", rb_czmq_socket_set_opt_recovery_ivl_msec, 1);
-    rb_define_method(rb_cZmqSocket, "mcast_loop?", rb_czmq_socket_opt_mcast_loop, 0);
-    rb_define_method(rb_cZmqSocket, "mcast_loop=", rb_czmq_socket_set_opt_mcast_loop, 1);
     rb_define_method(rb_cZmqSocket, "sndbuf", rb_czmq_socket_opt_sndbuf, 0);
     rb_define_method(rb_cZmqSocket, "sndbuf=", rb_czmq_socket_set_opt_sndbuf, 1);
     rb_define_method(rb_cZmqSocket, "rcvbuf", rb_czmq_socket_opt_rcvbuf, 0);
@@ -1555,4 +1831,5 @@ void _init_rb_czmq_socket()
     rb_define_method(rb_cZmqSocket, "rcvtimeo=", rb_czmq_socket_set_opt_rcvtimeo, 1);
     rb_define_method(rb_cZmqSocket, "sndtimeo", rb_czmq_socket_opt_sndtimeo, 0);
     rb_define_method(rb_cZmqSocket, "sndtimeo=", rb_czmq_socket_set_opt_sndtimeo, 1);
+    rb_define_method(rb_cZmqSocket, "monitor", rb_czmq_socket_monitor, -1);
 }

data/ext/rbczmq/socket.h

@@ -22,6 +22,10 @@ typedef struct {
 #endif
     VALUE endpoints;
     VALUE thread;
+    VALUE context;
+    VALUE monitor_endpoint;
+    VALUE monitor_handler;
+    VALUE monitor_thread;
 } zmq_sock_wrapper;
 
 #define ZmqAssertSocket(obj) ZmqAssertType(obj, rb_cZmqSocket, "ZMQ::Socket")
@@ -122,11 +126,27 @@ struct nogvl_recv_args {
     zmq_sock_wrapper *socket;
 };
 
+struct nogvl_monitor_recv_args {
+    void *socket;
+    zmq_msg_t msg;
+};
+
 struct nogvl_conn_args {
     zmq_sock_wrapper *socket;
     char *endpoint;
 };
 
+extern VALUE intern_on_connected;
+extern VALUE intern_on_connect_delayed;
+extern VALUE intern_on_connect_retried;
+extern VALUE intern_on_listening;
+extern VALUE intern_on_bind_failed;
+extern VALUE intern_on_accepted;
+extern VALUE intern_on_accept_failed;
+extern VALUE intern_on_closed;
+extern VALUE intern_on_close_failed;
+extern VALUE intern_on_disconnected;
+
 void _init_rb_czmq_socket();
 
 #endif

data/lib/zmq.rb

@@ -13,6 +13,20 @@ require 'zmq/version' unless defined? ZMQ::VERSION
 require 'socket'
 
 module ZMQ
+  def self.version3?
+    version[0] == 3
+  end
+
+  def self.stable_version?
+    version[0] == 3 &&
+    version[1] == 2 &&
+    version[2] == 2
+  end
+
+  def self.version2?
+    !version3?
+  end
+
   # Sugaring for creating new ZMQ frames
   #
   # ZMQ::Frame("frame")  =>  ZMQ::Frame
@@ -75,6 +89,7 @@ module ZMQ
 end
 
 require "zmq/context"
+require "zmq/monitor"
 require "zmq/socket"
 require "zmq/loop"
 require "zmq/timer"

data/lib/zmq/monitor.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class ZMQ::Monitor
+  def on_connected(addr, fd)
+  end
+
+  def on_connect_delayed(addr, err)
+  end
+
+  def on_connect_retried(addr, interval)
+  end
+
+  def on_listening(addr, fd)
+  end
+
+  def on_bind_failed(addr, err)
+  end
+
+  def on_accepted(addr, fd)
+  end
+
+  def on_accept_failed(addr, err)
+  end
+
+  def on_closed(addr, fd)
+  end
+
+  def on_close_failed(addr, err)
+  end
+
+  def on_disconnected(addr, fd)
+  end
+end

data/lib/zmq/version.rb

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

data/test/test_context.rb

@@ -68,7 +68,8 @@ class TestZmqContext < ZmqTestCase
     assert_raises ZMQ::Error do
       ctx.hwm = -2
     end
-    assert_equal 10, ctx.hwm
+    # deprecated method
+    assert_equal 0, ctx.hwm
   ensure
     ctx.destroy
   end

data/test/test_monitoring.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+if ZMQ.stable_version?
+
+class TestMonitor
+  attr_reader :listening, :closed
+
+  def on_listening(addr, fd)
+    @listening = true
+  end
+
+  def on_closed(addr, fd)
+    @closed = true
+  end
+end
+
+class TestZmqMonitoring < ZmqTestCase
+  def test_monitoring
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert_raises TypeError do
+      sock.monitor(:invalid)
+    end
+
+    assert_raises TypeError do
+      sock.monitor("inproc://monitor.rep", nil, :invalid)
+    end
+
+    cb = TestMonitor.new
+
+    assert !sock.monitor("tcp://0.0.0.0:5000")
+    assert sock.monitor("inproc://monitor.rep", cb)
+    sleep 1
+    sock.bind("tcp://0.0.0.0:5555")
+    sleep 1
+    assert cb.listening
+    sock.close
+    sleep 1
+    assert cb.closed
+  ensure
+    ctx.destroy
+  end
+end
+
+end

data/test/test_socket.rb

@@ -18,7 +18,11 @@ class TestZmqSocket < ZmqTestCase
   def test_send_timeout
     ctx = ZMQ::Context.new
     rep = ctx.socket(:REP)
-    rep.hwm = 1
+    if ZMQ.version3?
+      rep.sndhwm = 1
+    else
+      rep.hwm = 1
+    end
     rep.bind("inproc://test.socket-send-timeout")
     req = ctx.connect(:REQ, "inproc://test.socket-send-timeout")
     # Cannot test much other than normal transfer's not disrupted
@@ -408,35 +412,60 @@ class TestZmqSocket < ZmqTestCase
 
   def test_sock_options
     ctx = ZMQ::Context.new
-    sock = ctx.socket(:PAIR)
+    sock = ctx.socket(:ROUTER)
     sock.verbose = true
-    assert_equal 0, sock.hwm
-    sock.hwm = 1000
-    assert_equal 1000, sock.hwm
 
-    assert_equal 0, sock.swap
-    sock.swap = 1000
-    assert_equal 1000, sock.swap
+    if ZMQ.version3?
+      assert_equal 1000, sock.sndhwm
+      sock.sndhwm = 10000
+      assert_equal 10000, sock.sndhwm      
+
+      assert_equal 1000, sock.rcvhwm
+      sock.rcvhwm = 10000
+      assert_equal 10000, sock.rcvhwm
+    else
+      assert_equal 0, sock.hwm
+      sock.hwm = 1000
+      assert_equal 1000, sock.hwm
+
+      assert_equal 0, sock.swap
+      sock.swap = 1000
+      assert_equal 1000, sock.swap
+
+      assert_equal(-1, sock.recovery_ivl_msec)
+      sock.recovery_ivl_msec = 20
+      assert_equal 20, sock.recovery_ivl_msec
+    end
 
     assert_equal 0, sock.affinity
     sock.affinity = 1
     assert_equal 1, sock.affinity
 
-    assert_equal 40000, sock.rate
-    sock.rate = 50000
-    assert_equal 50000, sock.rate
-
-    assert_equal 10, sock.recovery_ivl
-    sock.recovery_ivl = 20
-    assert_equal 20, sock.recovery_ivl
+    if ZMQ.version3?
+      assert_equal 100, sock.rate
+      sock.rate = 50000
+      assert_equal 50000, sock.rate
+    else
+      assert_equal 40000, sock.rate
+      sock.rate = 50000
+      assert_equal 50000, sock.rate
+    end
 
-    assert_equal(-1, sock.recovery_ivl_msec)
-    sock.recovery_ivl_msec = 20
-    assert_equal 20, sock.recovery_ivl_msec
+    if ZMQ.version3?
+      assert_equal 10000, sock.recovery_ivl
+      sock.recovery_ivl = 20
+      assert_equal 20, sock.recovery_ivl
+    else
+      assert_equal 10, sock.recovery_ivl
+      sock.recovery_ivl = 20
+      assert_equal 20, sock.recovery_ivl
+    end
 
-    assert_equal true, sock.mcast_loop?
-    sock.mcast_loop = false
-    assert !sock.mcast_loop?
+    if ZMQ.version2?
+      assert_equal true, sock.mcast_loop?
+      sock.mcast_loop = false
+      assert !sock.mcast_loop?
+    end
 
     assert_equal 0, sock.sndbuf
     sock.sndbuf = 1000
@@ -470,6 +499,10 @@ class TestZmqSocket < ZmqTestCase
     sock.sndtimeo = 200
     assert_equal 200, sock.sndtimeo
 
+if sock.respond_to?(:raw=)
+    sock.raw = true
+end
+
     sock.identity = "anonymous"
     assert_raises ZMQ::Error do
       sock.identity = ""
@@ -480,7 +513,7 @@ class TestZmqSocket < ZmqTestCase
 
     assert !sock.rcvmore?
 
-    assert_equal 0, sock.events
+    assert_equal 2, sock.events
 
     sub_sock = ctx.socket(:SUB)
     sub_sock.verbose = true

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rbczmq
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 15
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 9
-  version: "0.9"
+  version: "1.0"
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-19 00:00:00 Z
+date: 2012-11-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake-compiler
@@ -58,6 +58,7 @@ files:
 - examples/push_pull.rb
 - examples/req_rep.rb
 - ext/czmq.tar.gz
+- ext/libzmq.tar.gz
 - ext/rbczmq/context.c
 - ext/rbczmq/context.h
 - ext/rbczmq/extconf.rb
@@ -91,6 +92,7 @@ files:
 - lib/zmq/handler.rb
 - lib/zmq/loop.rb
 - lib/zmq/message.rb
+- lib/zmq/monitor.rb
 - lib/zmq/poller.rb
 - lib/zmq/pollitem.rb
 - lib/zmq/socket.rb
@@ -139,6 +141,7 @@ files:
 - test/test_handler.rb
 - test/test_loop.rb
 - test/test_message.rb
+- test/test_monitoring.rb
 - test/test_poller.rb
 - test/test_pollitem.rb
 - test/test_socket.rb
@@ -199,6 +202,7 @@ test_files:
 - test/test_handler.rb
 - test/test_loop.rb
 - test/test_message.rb
+- test/test_monitoring.rb
 - test/test_poller.rb
 - test/test_pollitem.rb
 - test/test_socket.rb