rbczmq 1.6 → 1.6.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzgxOTQ4ZWU1YWMzNjdkYzdkOGY0ODgxYzFkODIxMTA0ODUxYTM1Ng==
+  data.tar.gz: !binary |-
+    M2Y5NGY3ZmQ4MGJiOTkyMzQ2YWJkMTJkMWU2NTQ3MjEzZTU5ZDY0ZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Yzc3ZmQyOWE1ZDY2ZTdjZjU4MjI5ZjZhNjBmYjhjMTc3YTA3MGM4N2I4NjNk
+    OGE1NTQyMThhMzQyZWUwM2MzNWIzNjBiN2Q0OWMxNGY5Mzg0YWNhMmE1M2Vh
+    NTVjYjY5MjdlYTc3YjM3NjZhMzcxYWEyY2UyYTAxMjc1MzNjN2M=
+  data.tar.gz: !binary |-
+    NDQ3NGZmMGIxNTVkYTk0YzY0ZjcwZmEwZjZlMmJlOWZlNDY0ZjQwYTYyZjNm
+    YjM3NDlhODUwYTEwZTNkZTVlNGUyZjZkNmI2NmUxNDdlZmZhMTQ0NGNmYzI5
+    MjdiMDliNWZlNWQ1MGFkMmJjOTU1OWUzZjhmOWM3NzEyZGI2ODU=

data/.travis.yml

@@ -1,9 +1,6 @@
 language: ruby
 rvm:
-  - rbx-18mode
   - rbx-19mode
-  - ree
-  - 1.8.7
   - 1.9.2
   - 1.9.3
   - ruby-head

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 = Changelog
 
+== 1.6.1 (May 15, 2013 )
+* Bump czmq to 1.4.1
+* Introduce ZMQ::Beacon for service announcement and discovery
+* Implement ZMQ::Socket#poll
+* Implement ZMQ::Socket#disconnect
+* Drop support for ZeroMQ 2.x
+
 == 1.6 (May 2, 2013 )
 * Bump czmq to 1.4.0
 * Bump zeromq to 3.2.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbczmq (1.4)
+    rbczmq (1.6.2)
 
 GEM
   remote: https://rubygems.org/

data/ext/rbczmq/beacon.c

@@ -0,0 +1,318 @@
+#include "rbczmq_ext.h"
+
+/*
+ * :nodoc:
+ *  Destroy the beacon while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_beacon_destroy(void *ptr)
+{
+    zmq_beacon_wrapper *beacon = ptr;
+    zbeacon_destroy(&beacon->beacon);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *
+*/
+static void rb_czmq_free_beacon_gc(void *ptr)
+{
+    zmq_beacon_wrapper *beacon = (zmq_beacon_wrapper *)ptr;
+    if (beacon) {
+        rb_thread_blocking_region(rb_czmq_nogvl_beacon_destroy, beacon, RUBY_UBF_IO, 0);
+        xfree(beacon);
+    }
+}
+
+/*
+ * :nodoc:
+ *  Allocate a beacon while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_new_beacon(void *ptr)
+{
+    int port = (int)ptr;
+    return (VALUE)zbeacon_new(port);
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Beacon.new(9999)   =>  ZMQ::Beacon
+ *
+ *  Create a new beacon.
+ *
+ * === Examples
+ *     ZMQ::Beacon.new(9999)    =>  ZMQ::Beacon
+ *
+*/
+static VALUE rb_czmq_beacon_s_new(VALUE beacon, VALUE port)
+{
+    zmq_beacon_wrapper *bcn = NULL;
+    int prt;
+    Check_Type(port, T_FIXNUM);
+    beacon = Data_Make_Struct(rb_cZmqBeacon, zmq_beacon_wrapper, 0, rb_czmq_free_beacon_gc, bcn);
+    prt = FIX2INT(port);
+    bcn->beacon = (zbeacon_t*)rb_thread_blocking_region(rb_czmq_nogvl_new_beacon, (void *)&prt, RUBY_UBF_IO, 0);
+    ZmqAssertObjOnAlloc(bcn->beacon, bcn);
+    rb_obj_call_init(beacon, 0, NULL);
+    return beacon;
+}
+
+/*
+ *  call-seq:
+ *     beacon.destroy   =>  nil
+ *
+ *  Stop broadcasting a beacon. The GC will take the same action if a beacon object is not reachable anymore on the next
+ *  GC cycle. This is a lower level API.
+ *
+ * === Examples
+ *     beacon.destroy    =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_destroy(VALUE obj)
+{
+    GetZmqBeacon(obj);
+    rb_thread_blocking_region(rb_czmq_nogvl_beacon_destroy, beacon, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.hostname   =>  String
+ *
+ *  Returns the beacon's IP address
+ *
+ * === Examples
+ *     beacon.hostname   =>  "127.0.0.1"
+ *
+*/
+static VALUE rb_czmq_beacon_hostname(VALUE obj)
+{
+    GetZmqBeacon(obj);
+    return rb_str_new2(zbeacon_hostname(beacon->beacon));
+}
+
+/*
+ * :nodoc:
+ *  Set the beacon broadcast interval while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_set_interval(void *ptr)
+{
+    struct nogvl_beacon_interval_args *args = ptr;
+    zmq_beacon_wrapper *beacon = args->beacon;
+    zbeacon_set_interval(beacon->beacon, args->interval);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.interval = 100   =>  nil
+ *
+ *  Sets the broadcast interval in milliseconds
+ *
+ * === Examples
+ *     beacon.interval = 100   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_set_interval(VALUE obj, VALUE interval)
+{
+    struct nogvl_beacon_interval_args args;
+    GetZmqBeacon(obj);
+    Check_Type(interval, T_FIXNUM);
+    args.beacon = beacon;
+    args.interval = FIX2INT(interval);
+    rb_thread_blocking_region(rb_czmq_nogvl_set_interval, (void *)&args, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Filter beacons while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_noecho(void *ptr)
+{
+    zmq_beacon_wrapper *beacon = ptr;
+    zbeacon_noecho(beacon->beacon);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.noecho   =>  nil
+ *
+ *  Filter out any beacon that looks exactly like ours
+ *
+ * === Examples
+ *     beacon.noecho   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_noecho(VALUE obj)
+{
+    GetZmqBeacon(obj);
+    rb_thread_blocking_region(rb_czmq_nogvl_noecho, (void *)beacon, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Broadcast beacon while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_publish(void *ptr)
+{
+    struct nogvl_beacon_publish_args *args = ptr;
+    zmq_beacon_wrapper *beacon = args->beacon;
+    zbeacon_publish(beacon->beacon, (byte *)args->transmit ,args->length);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.publish("address")   =>  nil
+ *
+ *  Start broadcasting beacon to peers.
+ *
+ * === Examples
+ *     beacon.publish("address")   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_publish(VALUE obj, VALUE transmit)
+{
+    struct nogvl_beacon_publish_args args;
+    GetZmqBeacon(obj);
+    Check_Type(transmit, T_STRING);
+    args.beacon = beacon;
+    args.transmit = StringValueCStr(transmit);
+    args.length = (int)RSTRING_LEN(transmit);
+    rb_thread_blocking_region(rb_czmq_nogvl_publish, (void *)&args, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Silence beacon while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_silence(void *ptr)
+{
+    zmq_beacon_wrapper *beacon = ptr;
+    zbeacon_silence(beacon->beacon);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.silence   =>  nil
+ *
+ *  Stop broadcasting beacons to peers.
+ *
+ * === Examples
+ *     beacon.silence   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_silence(VALUE obj)
+{
+    GetZmqBeacon(obj);
+    rb_thread_blocking_region(rb_czmq_nogvl_silence, (void *)beacon, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Start listening to peers while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_subscribe(void *ptr)
+{
+    struct nogvl_beacon_subscribe_args *args = ptr;
+    zmq_beacon_wrapper *beacon = args->beacon;
+    zbeacon_subscribe(beacon->beacon, (byte *)args->filter ,args->length);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.subscribe("channel")   =>  nil
+ *
+ *  Start listening to other peers.
+ *
+ * === Examples
+ *     beacon.subscribe("channel")   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_subscribe(VALUE obj, VALUE filter)
+{
+    struct nogvl_beacon_subscribe_args args;
+    GetZmqBeacon(obj);
+    args.beacon = beacon;
+    if (NIL_P(filter)) {
+        args.filter = NULL;
+        args.length = 0;
+    } else {
+        Check_Type(filter, T_STRING);
+        args.filter = StringValueCStr(filter);
+        args.length = (int)RSTRING_LEN(filter);
+    }
+    rb_thread_blocking_region(rb_czmq_nogvl_subscribe, (void *)&args, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Stop listening to peers while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_unsubscribe(void *ptr)
+{
+    zmq_beacon_wrapper *beacon = ptr;
+    zbeacon_unsubscribe(beacon->beacon);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     beacon.unsubscribe   =>  nil
+ *
+ *  Stop broadcasting beacons to peers.
+ *
+ * === Examples
+ *     beacon.unsubscribe   =>  nil
+ *
+*/
+static VALUE rb_czmq_beacon_unsubscribe(VALUE obj)
+{
+    GetZmqBeacon(obj);
+    rb_thread_blocking_region(rb_czmq_nogvl_unsubscribe, (void *)beacon, RUBY_UBF_IO, 0);
+    return Qnil;
+}
+
+static VALUE rb_czmq_beacon_pipe(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    VALUE socket;
+    GetZmqBeacon(obj);
+    socket = rb_czmq_socket_alloc(Qnil, NULL, zbeacon_pipe(beacon->beacon));
+    GetZmqSocket(socket);
+    sock->state = ZMQ_SOCKET_BOUND;
+    return socket;
+}
+
+void _init_rb_czmq_beacon()
+{
+    rb_cZmqBeacon = rb_define_class_under(rb_mZmq, "Beacon", rb_cObject);
+
+    rb_define_singleton_method(rb_cZmqBeacon, "new", rb_czmq_beacon_s_new, 1);
+    rb_define_method(rb_cZmqBeacon, "destroy", rb_czmq_beacon_destroy, 0);
+    rb_define_method(rb_cZmqBeacon, "hostname", rb_czmq_beacon_hostname, 0);
+    rb_define_method(rb_cZmqBeacon, "interval=", rb_czmq_beacon_set_interval, 1);
+    rb_define_method(rb_cZmqBeacon, "noecho", rb_czmq_beacon_noecho, 0);
+    rb_define_method(rb_cZmqBeacon, "publish", rb_czmq_beacon_publish, 1);
+    rb_define_method(rb_cZmqBeacon, "silence", rb_czmq_beacon_silence, 0);
+    rb_define_method(rb_cZmqBeacon, "subscribe", rb_czmq_beacon_subscribe, 1);
+    rb_define_method(rb_cZmqBeacon, "unsubscribe", rb_czmq_beacon_unsubscribe, 0);
+    rb_define_method(rb_cZmqBeacon, "pipe", rb_czmq_beacon_pipe, 0);
+}

data/ext/rbczmq/beacon.h

@@ -0,0 +1,38 @@
+#ifndef RBCZMQ_BEACON_H
+#define RBCZMQ_BEACON_H
+
+typedef struct {
+    zbeacon_t *beacon;
+} zmq_beacon_wrapper;
+
+#define ZmqAssertBeacon(obj) ZmqAssertType(obj, rb_cZmqBeacon, "ZMQ::Beacon")
+#define GetZmqBeacon(obj) \
+    zmq_beacon_wrapper *beacon = NULL; \
+    ZmqAssertBeacon(obj); \
+    Data_Get_Struct(obj, zmq_beacon_wrapper, beacon); \
+    if (!beacon) rb_raise(rb_eTypeError, "uninitialized ZMQ beacon!!"); \
+
+struct nogvl_beacon_destroy_args {
+    zmq_beacon_wrapper *beacon;
+};
+
+struct nogvl_beacon_interval_args {
+    zmq_beacon_wrapper *beacon;
+    int interval;
+};
+
+struct nogvl_beacon_publish_args {
+    zmq_beacon_wrapper *beacon;
+    char *transmit;
+    int length;
+};
+
+struct nogvl_beacon_subscribe_args {
+    zmq_beacon_wrapper *beacon;
+    char *filter;
+    int length;
+};
+
+void _init_rb_czmq_beacon();
+
+#endif

data/ext/rbczmq/context.c

@@ -140,7 +140,6 @@ static VALUE rb_czmq_ctx_set_iothreads(VALUE obj, VALUE threads)
     ZmqGetContext(obj);
     Check_Type(threads, T_FIXNUM);
     iothreads = FIX2INT(threads);
-    if (iothreads > 1) rb_warn("You probably don't want to spawn more than 1 I/O thread per ZMQ context.");
     if (iothreads < 0) rb_raise(rb_eZmqError, "negative I/O threads count is not supported.");
     zctx_set_iothreads(ctx->ctx, iothreads);
     if (zmq_errno() == EINVAL) ZmqRaiseSysError();
@@ -173,52 +172,6 @@ static VALUE rb_czmq_ctx_set_linger(VALUE obj, VALUE linger)
     return Qnil;
 }
 
-/*
- *  call-seq:
- *     ctx.hwm    =>  Fixnum
- *
- *  Returns High Water Mark (HWM) option used for native thread creation (non-Ruby threads, ahead of time API addition)
- *
- * === Examples
- *     ctx = ZMQ::Context.new
- *     ctx.hwm    =>   1
- *
-*/
-
-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));
-}
-
-/*
- *  call-seq:
- *     ctx.hwm = 100    =>  nil
- *
- *  Sets the High Water Mark (HWM) option used for native thread creation (non-Ruby threads, ahead of time API addition)
- *
- * === Examples
- *     ctx = ZMQ::Context.new
- *     ctx.hwm = 100    =>   nil
- *
-*/
-
-static VALUE rb_czmq_ctx_set_hwm(VALUE obj, VALUE hwm)
-{
-    errno = 0;
-    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);
-    return Qnil;
-}
-
 /*
  * :nodoc:
  *  Creates a new socket while the GIL is released.
@@ -266,6 +219,27 @@ static inline VALUE rb_czmq_ctx_socket_klass(int socket_type)
     }
 }
 
+VALUE rb_czmq_socket_alloc(VALUE context, zctx_t *ctx, void *s)
+{
+    VALUE socket;
+    zmq_sock_wrapper *sock = NULL;
+    socket = Data_Make_Struct(rb_czmq_ctx_socket_klass(zsocket_type(s)), zmq_sock_wrapper, rb_czmq_mark_sock, rb_czmq_free_sock_gc, sock);
+    sock->socket = s;
+    ZmqAssertObjOnAlloc(sock->socket, sock);
+    sock->flags = 0;
+    sock->ctx = ctx;
+    sock->verbose = false;
+    sock->state = ZMQ_SOCKET_PENDING;
+    sock->endpoints = rb_ary_new();
+    sock->thread = rb_thread_current();
+    sock->context = context;
+    sock->monitor_endpoint = Qnil;
+    sock->monitor_handler = Qnil;
+    sock->monitor_thread = Qnil;
+    rb_obj_call_init(socket, 0, NULL);
+    return socket;
+}
+
 /*
  *  call-seq:
  *     ctx.socket(:PUSH)    =>  ZMQ::Socket
@@ -284,37 +258,16 @@ static inline VALUE rb_czmq_ctx_socket_klass(int socket_type)
 
 static VALUE rb_czmq_ctx_socket(VALUE obj, VALUE type)
 {
-    VALUE socket;
     int socket_type;
     struct nogvl_socket_args args;
-    zmq_sock_wrapper *sock = NULL;
     errno = 0;
     ZmqGetContext(obj);
     if (TYPE(type) != T_FIXNUM && TYPE(type) != T_SYMBOL) rb_raise(rb_eTypeError, "wrong socket type %s (expected Fixnum or Symbol)", RSTRING_PTR(rb_obj_as_string(type)));
     socket_type = FIX2INT((SYMBOL_P(type)) ? rb_const_get_at(rb_mZmq, rb_to_id(type)) : type);
 
-    socket = Data_Make_Struct(rb_czmq_ctx_socket_klass(socket_type), zmq_sock_wrapper, rb_czmq_mark_sock, rb_czmq_free_sock_gc, sock);
     args.ctx = ctx->ctx;
     args.type = socket_type;
-    sock->socket = (void*)rb_thread_blocking_region(rb_czmq_nogvl_socket_new, (void *)&args, RUBY_UBF_IO, 0);
-    ZmqAssertObjOnAlloc(sock->socket, sock);
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
-    sock->str_buffer = zlist_new();
-    sock->frame_buffer = zlist_new();
-    sock->msg_buffer = zlist_new();
-#endif
-    sock->flags = 0;
-    sock->ctx = ctx->ctx;
-    sock->verbose = false;
-    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;
+    return rb_czmq_socket_alloc(obj, ctx->ctx, (void*)rb_thread_blocking_region(rb_czmq_nogvl_socket_new, (void *)&args, RUBY_UBF_IO, 0));
 }
 
 void _init_rb_czmq_context()
@@ -329,6 +282,4 @@ void _init_rb_czmq_context()
     rb_define_method(rb_cZmqContext, "iothreads=", rb_czmq_ctx_set_iothreads, 1);
     rb_define_method(rb_cZmqContext, "linger=", rb_czmq_ctx_set_linger, 1);
     rb_define_method(rb_cZmqContext, "socket", rb_czmq_ctx_socket, 1);
-    rb_define_method(rb_cZmqContext, "hwm", rb_czmq_ctx_hwm, 0);
-    rb_define_method(rb_cZmqContext, "hwm=", rb_czmq_ctx_set_hwm, 1);
 }