rbczmq 1.6.4 → 1.7.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTIyYzk0ZmFkOTc4Y2YwMmRlYzc3ZGE0NmQyZTBhOGRlODQyMDcxMA==
+  data.tar.gz: !binary |-
+    NTI4NzQyMDhkNGRjNGE5NDgxMDE3ZDg5MjU2YTViZWZiMWNjYzQxZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZmQ5NzExNWFhM2ZiODBlZmY4ZDZkMmM5YjBjMDQxODNkZDFlNTUxZmZlMjIz
+    N2JkZGU0Mjg4NzJlZTM2ZTEzYjI5ZDdkMGExNDU5MGMzMDE1ZjM2OTUxOTk4
+    ZDAyYjcwNTcyOGUzYjNhOTFkYzYyZTM5NTBkNjgyNDgyN2Q0ZDg=
+  data.tar.gz: !binary |-
+    NDJmOGNmNmMwNGM3YjY5NmUwYTZmOTYzNzAyNGU5YzFmMTc0NGRhYTUzYjIw
+    YzI0YjJiODBlMjliMGQyYThjNjFhMWE1MWExZTJhNjAzNTMyNjQzZTM2YWZk
+    M2NiYzc5Mzc0NGE0NjlkMmQ1YzBmYTMyYjdiZjkxNmFkMGE5ZTI=

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 = Changelog
 
+== 1.7.0 (July 21, 2013)
+
+* ZMQ::Frame - Implemented an interal wrapper around the underlying czmq frame objects to better manage memory and object ownership. (Matt Connolly)
+* ZMQ::Frame#gone? and ZMQ::Message#gone? - new methods, return true when the frame/message has been sent and is no longer available for accessing. Methods may return nil for read operations or raise ZMQ::Error if the frame/message would be changed by that method. (Matt Connolly)
+* ZMQ::Message - iterators (#first, #next, #last and #to_a) return consistent frame objects (not duplicates as in previous versions) that can be used with #remove. (Matt Connolly)
+* Sending a message or frame marks it as "gone". The underlying data objects will be released by ZeroMQ as the frames/messages are sent over the socket. (Matt Connolly)
+
 == 1.6.4 (July 10, 2013)
 * Depend on a checkout task for vendored submodule init (Matt Connolly)
 

data/Gemfile.lock

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

data/ext/rbczmq/beacon.c

@@ -315,4 +315,4 @@ void _init_rb_czmq_beacon()
     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

@@ -35,4 +35,4 @@ struct nogvl_beacon_subscribe_args {
 
 void _init_rb_czmq_beacon();
 
-#endif
+#endif

data/ext/rbczmq/frame.c

@@ -1,18 +1,6 @@
 #include "rbczmq_ext.h"
 static VALUE intern_data;
 
-/*
- * :nodoc:
- *  Callback invoked by zframe_destroy in libczmq. We track all frames coerced to native objects in a symbol table
- *  to guard against a mismatch between allocated frames and the Ruby object space as zframe_destroy is invoked
- *  throughout libczmq (zmsg.c) where the Ruby GC can't easily track it. Ruby MRI Object finalizers are a real
- *  pita to deal with.
- *
-*/
-void rb_czmq_frame_freed(zframe_t *frame)
-{
-    st_delete(frames_map, (st_data_t*)&frame, 0);
-}
 
 /*
  * :nodoc:
@@ -22,8 +10,11 @@ void rb_czmq_frame_freed(zframe_t *frame)
 VALUE rb_czmq_alloc_frame(zframe_t *frame)
 {
     VALUE frame_obj;
-    ZmqRegisterFrame(frame);
-    frame_obj = Data_Wrap_Struct(rb_cZmqFrame, 0, rb_czmq_free_frame_gc, frame);
+    zmq_frame_wrapper* f;
+    frame_obj = Data_Make_Struct(rb_cZmqFrame, zmq_frame_wrapper, 0, rb_czmq_free_frame_gc, f);
+    f->frame = frame;
+    f->flags = ZMQ_FRAME_OWNED;
+    f->message = NULL;
     rb_obj_call_init(frame_obj, 0, NULL);
     return frame_obj;
 }
@@ -35,13 +26,11 @@ VALUE rb_czmq_alloc_frame(zframe_t *frame)
  *  libczmq.
  *
 */
-void rb_czmq_free_frame(zframe_t *frame)
+void rb_czmq_free_frame(zmq_frame_wrapper *frame)
 {
-    if (frame) {
-        if (st_lookup(frames_map, (st_data_t)frame, 0)) {
-            st_delete(frames_map, (st_data_t*)&frame, 0);
-            zframe_destroy(&frame);
-        }
+    if (frame && frame->frame && (frame->flags & ZMQ_FRAME_OWNED) != 0) {
+        zframe_destroy(&frame->frame);
+        frame->flags &= ~ZMQ_FRAME_OWNED;
     }
 }
 
@@ -52,7 +41,7 @@ void rb_czmq_free_frame(zframe_t *frame)
 */
 void rb_czmq_free_frame_gc(void *ptr)
 {
-    zframe_t *frame = (zframe_t *)ptr;
+    zmq_frame_wrapper *frame = (zmq_frame_wrapper *)ptr;
     rb_czmq_free_frame(frame);
 }
 
@@ -85,10 +74,7 @@ static VALUE rb_czmq_frame_s_new(int argc, VALUE *argv, VALUE frame)
         ZmqAssertSysError();
         rb_memerror();
     }
-    ZmqRegisterFrame(fr);
-    frame = Data_Wrap_Struct(rb_cZmqFrame, 0, rb_czmq_free_frame_gc, fr);
-    rb_obj_call_init(frame, 0, NULL);
-    return frame;
+    return rb_czmq_alloc_frame(fr);
 }
 
 /*
@@ -108,6 +94,7 @@ static VALUE rb_czmq_frame_s_new(int argc, VALUE *argv, VALUE frame)
 static VALUE rb_czmq_frame_destroy(VALUE obj)
 {
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     rb_czmq_free_frame(frame);
     return Qnil;
 }
@@ -128,7 +115,8 @@ static VALUE rb_czmq_frame_size(VALUE obj)
 {
     size_t size;
     ZmqGetFrame(obj);
-    size = zframe_size(frame);
+    ZmqReturnNilUnlessFrameOwned(frame);
+    size = zframe_size(frame->frame);
     return LONG2FIX(size);
 }
 
@@ -148,8 +136,9 @@ static VALUE rb_czmq_frame_data(VALUE obj)
 {
     size_t size;
     ZmqGetFrame(obj);
-    size = zframe_size(frame);
-    return ZmqEncode(rb_str_new((char *)zframe_data(frame), (long)size));
+    ZmqReturnNilUnlessFrameOwned(frame);
+    size = zframe_size(frame->frame);
+    return ZmqEncode(rb_str_new((char *)zframe_data(frame->frame), (long)size));
 }
 
 /*
@@ -184,7 +173,8 @@ static VALUE rb_czmq_frame_to_s(VALUE obj)
 static VALUE rb_czmq_frame_strhex(VALUE obj)
 {
     ZmqGetFrame(obj);
-    return rb_str_new2(zframe_strhex(frame));
+    ZmqReturnNilUnlessFrameOwned(frame);
+    return rb_str_new2(zframe_strhex(frame->frame));
 }
 
 /*
@@ -201,19 +191,15 @@ static VALUE rb_czmq_frame_strhex(VALUE obj)
 
 static VALUE rb_czmq_frame_dup(VALUE obj)
 {
-    VALUE dup;
     zframe_t *dup_fr = NULL;
-    errno = 0;
     ZmqGetFrame(obj);
-    dup_fr = zframe_dup(frame);
+    ZmqAssertFrameOwned(frame);
+    dup_fr = zframe_dup(frame->frame);
     if (dup_fr == NULL) {
         ZmqAssertSysError();
         rb_memerror();
     }
-    ZmqRegisterFrame(dup_fr);
-    dup = Data_Wrap_Struct(rb_cZmqFrame, 0, rb_czmq_free_frame_gc, dup_fr);
-    rb_obj_call_init(dup, 0, NULL);
-    return dup;
+    return rb_czmq_alloc_frame(dup_fr);
 }
 
 /*
@@ -231,8 +217,9 @@ static VALUE rb_czmq_frame_dup(VALUE obj)
 static VALUE rb_czmq_frame_data_equals_p(VALUE obj, VALUE data)
 {
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     Check_Type(data, T_STRING);
-    return (zframe_streq(frame, RSTRING_PTR(data)) == true) ? Qtrue : Qfalse;
+    return (zframe_streq(frame->frame, RSTRING_PTR(data)) == true) ? Qtrue : Qfalse;
 }
 
 /*
@@ -250,7 +237,8 @@ static VALUE rb_czmq_frame_data_equals_p(VALUE obj, VALUE data)
 static VALUE rb_czmq_frame_more_p(VALUE obj)
 {
     ZmqGetFrame(obj);
-    return (zframe_more(frame) == ZFRAME_MORE) ? Qtrue : Qfalse;
+    ZmqReturnNilUnlessFrameOwned(frame);
+    return (zframe_more(frame->frame) == ZFRAME_MORE) ? Qtrue : Qfalse;
 }
 
 /*
@@ -268,13 +256,14 @@ static VALUE rb_czmq_frame_more_p(VALUE obj)
 
 static VALUE rb_czmq_frame_eql_p(VALUE obj, VALUE other_frame)
 {
-    zframe_t *other = NULL;
+    zmq_frame_wrapper *other = NULL;
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     ZmqAssertFrame(other_frame);
-    Data_Get_Struct(other_frame, zframe_t, other);
-    if (!other) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!"); \
-    if (!(st_lookup(frames_map, (st_data_t)other, 0))) rb_raise(rb_eZmqError, "object %p has been destroyed by the ZMQ framework", (void *)other_frame);
-    return (zframe_eq(frame, other)) ? Qtrue : Qfalse;
+    Data_Get_Struct(other_frame, zmq_frame_wrapper, other);
+    if (!other || !other->frame) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!"); \
+    ZmqAssertFrameOwned(other);
+    return (zframe_eq(frame->frame, other->frame)) ? Qtrue : Qfalse;
 }
 
 /*
@@ -313,14 +302,15 @@ static VALUE rb_czmq_frame_equals(VALUE obj, VALUE other_frame)
 static VALUE rb_czmq_frame_cmp(VALUE obj, VALUE other_frame)
 {
     long diff;
-    zframe_t *other = NULL;
+    zmq_frame_wrapper *other = NULL;
     if (obj == other_frame) return INT2NUM(0);
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     ZmqAssertFrame(other_frame);
-    Data_Get_Struct(other_frame, zframe_t, other);
-    if (!other) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!"); \
-    if (!(st_lookup(frames_map, (st_data_t)other, 0))) rb_raise(rb_eZmqError, "object %p has been destroyed by the ZMQ framework", (void *)other_frame);
-    diff = (zframe_size(frame) - zframe_size(other));
+    Data_Get_Struct(other_frame, zmq_frame_wrapper, other);
+    if (!other || !other->frame) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!");
+    ZmqAssertFrameOwned(frame);
+    diff = (zframe_size(frame->frame) - zframe_size(other->frame));
     if (diff == 0) return INT2NUM(0);
     if (diff > 0) return INT2NUM(1);
     return INT2NUM(-1);
@@ -343,6 +333,7 @@ static VALUE rb_czmq_frame_print(int argc, VALUE *argv, VALUE obj)
     VALUE prefix;
     const char *print_prefix = NULL;
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     rb_scan_args(argc, argv, "01", &prefix);
     if (NIL_P(prefix)) {
         print_prefix = "";
@@ -350,7 +341,7 @@ static VALUE rb_czmq_frame_print(int argc, VALUE *argv, VALUE obj)
         Check_Type(prefix, T_STRING);
         print_prefix = RSTRING_PTR(prefix);
     }
-    zframe_print(frame, (char *)print_prefix);
+    zframe_print(frame->frame, (char *)print_prefix);
     return Qnil;
 }
 
@@ -371,12 +362,33 @@ static VALUE rb_czmq_frame_reset(VALUE obj, VALUE data)
 {
     errno = 0;
     ZmqGetFrame(obj);
+    ZmqAssertFrameOwned(frame);
     Check_Type(data, T_STRING);
-    zframe_reset(frame, (char *)RSTRING_PTR(data), (size_t)RSTRING_LEN(data));
+    zframe_reset(frame->frame, (char *)RSTRING_PTR(data), (size_t)RSTRING_LEN(data));
     ZmqAssertSysError();
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *    frame.gone?   #=> false
+ *    frame.destroy # or send
+ *    frame.gone?   #=> true
+ *
+ * Return boolean indicating if the ZMQ::Frame is gone (sent or destroyed). If the message is
+ * gone, accessor methods will return nil and methods requiring data or methods that mutate
+ * the message will raise an exception.
+*/
+
+static VALUE rb_czmq_frame_gone(VALUE obj)
+{
+    ZmqGetFrame(obj);
+    return (frame->flags & ZMQ_FRAME_OWNED) ||
+           (frame->message != NULL && (frame->message->flags & ZMQ_MESSAGE_OWNED))
+               ? Qfalse : Qtrue;
+}
+
+
 void _init_rb_czmq_frame()
 {
     intern_data = rb_intern("data");
@@ -403,4 +415,5 @@ void _init_rb_czmq_frame()
     rb_define_method(rb_cZmqFrame, "print", rb_czmq_frame_print, -1);
     rb_define_alias(rb_cZmqFrame, "dump", "print");
     rb_define_method(rb_cZmqFrame, "reset", rb_czmq_frame_reset, 1);
+    rb_define_method(rb_cZmqFrame, "gone?", rb_czmq_frame_gone, 0);
 }

data/ext/rbczmq/frame.h

@@ -1,21 +1,53 @@
 #ifndef RBCZMQ_FRAME_H
 #define RBCZMQ_FRAME_H
 
+#include "message.h"
+
+/* This flag indicates that the wrapped zframe_t is owned by ruby
+   and can be freed when the ZMQ::Frame object is garbage collected */
+#define ZMQ_FRAME_OWNED 0x01
+
+typedef struct {
+    /* The czmq frame object. This is only valid if the frame is owned
+       by ruby, or the frame has been added to a message and the message
+       is owned by ruby. */
+    zframe_t *frame;
+
+    /* The ruby ZMQ::Message object this frame is attached to, or NULL */
+    zmq_message_wrapper* message;
+
+    int flags;
+} zmq_frame_wrapper;
+
 #define ZmqAssertFrame(obj) ZmqAssertType(obj, rb_cZmqFrame, "ZMQ::Frame")
 #define ZmqGetFrame(obj) \
-    zframe_t *frame = NULL; \
+    zmq_frame_wrapper *frame = NULL; \
     ZmqAssertFrame(obj); \
-    Data_Get_Struct(obj, zframe_t, frame); \
-    if (!frame) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!"); \
-    if (!(st_lookup(frames_map, (st_data_t)frame, 0))) rb_raise(rb_eZmqError, "ZMQ::Frame instance %p has been destroyed by the ZMQ framework", (void *)obj);
+    Data_Get_Struct(obj, zmq_frame_wrapper, frame); \
+    if (!frame) rb_raise(rb_eTypeError, "uninitialized ZMQ frame!");
+
+#define ZmqAssertFrameOwned(wrapper) if (!(\
+      (wrapper->flags & ZMQ_FRAME_OWNED) != 0 || \
+      (wrapper->message != NULL && (wrapper->message->flags & ZMQ_MESSAGE_OWNED) != 0 ) \
+    )) { \
+        rb_raise(rb_eZmqError, "Cannot access frame that belongs to another message or is gone."); \
+    }
+
+#define ZmqAssertFrameOwnedNoMessage(wrapper) if (!(\
+      (wrapper->flags & ZMQ_FRAME_OWNED) != 0 \
+    )) { \
+        rb_raise(rb_eZmqError, "Cannot access frame that belongs to another message or is gone."); \
+    }
 
-#define ZmqRegisterFrame(fr) \
-    zframe_freefn((fr), (zframe_free_fn *)rb_czmq_frame_freed, NULL); \
-    st_insert(frames_map, (st_data_t)(fr), (st_data_t)0);
+#define ZmqReturnNilUnlessFrameOwned(wrapper) if (!(\
+      (wrapper->flags & ZMQ_FRAME_OWNED) != 0 || \
+      (wrapper->message != NULL && (wrapper->message->flags & ZMQ_MESSAGE_OWNED) != 0 ) \
+    )) { \
+        return Qnil; \
+    }
 
-void rb_czmq_free_frame(zframe_t *frame);
+void rb_czmq_free_frame(zmq_frame_wrapper *frame);
 void rb_czmq_free_frame_gc(void *ptr);
-void rb_czmq_frame_freed(zframe_t *frame);
 
 VALUE rb_czmq_alloc_frame(zframe_t *frame);
 

data/ext/rbczmq/message.c

@@ -8,9 +8,12 @@
 void rb_czmq_free_message(zmq_message_wrapper *message)
 {
     errno = 0;
-    zmsg_destroy(&message->message);
-    message->message = NULL;
-    message->flags |= ZMQ_MESSAGE_DESTROYED;
+    if (message != NULL && message->message != NULL && message->flags & ZMQ_MESSAGE_OWNED) {
+        zmsg_destroy(&message->message);
+        message->message = NULL;
+        message->flags &= ~ZMQ_MESSAGE_OWNED;
+        zlist_destroy(&message->frames);
+    }
 }
 
 /*
@@ -22,11 +25,24 @@ static void rb_czmq_free_message_gc(void *ptr)
 {
     zmq_message_wrapper *msg = (zmq_message_wrapper *)ptr;
     if (msg) {
-        if (msg->message != NULL && !(msg->flags & ZMQ_MESSAGE_DESTROYED)) rb_czmq_free_message(msg);
+        rb_czmq_free_message(msg);
         xfree(msg);
     }
 }
 
+/*
+ * :nodoc:
+ * mark the owned ZMQ::Frame objects so that they are not collected.
+*/
+void rb_czmq_mark_message(zmq_message_wrapper *message)
+{
+    VALUE frame = (VALUE)zlist_first(message->frames);
+    while (frame) {
+        rb_gc_mark(frame);
+        frame = (VALUE)zlist_next(message->frames);
+    }
+}
+
 /*
  * :nodoc:
  *  Coerce a zmsg instance to a native Ruby object.
@@ -40,7 +56,22 @@ VALUE rb_czmq_alloc_message(zmsg_t *message)
     message_obj = Data_Make_Struct(rb_cZmqMessage, zmq_message_wrapper, 0, rb_czmq_free_message_gc, m);
     m->message = message;
     ZmqAssertObjOnAlloc(m->message, m);
-    m->flags = 0;
+    m->flags = ZMQ_MESSAGE_OWNED;
+    m->frames = zlist_new();
+
+    /* create ZMQ::Frame objects for all frames in the message and
+       link the ruby objects to this message. */
+    zframe_t* zframe = zmsg_first(message);
+    while (zframe) {
+        VALUE frame_object = rb_czmq_alloc_frame(zframe);
+        ZmqGetFrame(frame_object);
+        frame->flags &= ~ZMQ_FRAME_OWNED;
+        frame->message = m;
+        zlist_append(m->frames, (void*)frame_object);
+        
+        zframe = zmsg_next(message);
+    }
+
     rb_obj_call_init(message_obj, 0, NULL);
     return message_obj;
 }
@@ -58,14 +89,11 @@ VALUE rb_czmq_alloc_message(zmsg_t *message)
 
 static VALUE rb_czmq_message_new(VALUE message)
 {
-    zmq_message_wrapper *msg = NULL;
-    errno = 0;
-    message = Data_Make_Struct(rb_cZmqMessage, zmq_message_wrapper, 0, rb_czmq_free_message_gc, msg);
-    msg->message = zmsg_new();
-    ZmqAssertObjOnAlloc(msg->message, msg);
-    msg->flags = 0;
-    rb_obj_call_init(message, 0, NULL);
-    return message;
+    zmsg_t* msg = zmsg_new();
+    if (msg == NULL) {
+        rb_raise(rb_eZmqError, "Failed to allocate message object (zmsg_new).");
+    }
+    return rb_czmq_alloc_message(msg);
 }
 
 /*
@@ -85,6 +113,7 @@ static VALUE rb_czmq_message_new(VALUE message)
 static VALUE rb_czmq_message_size(VALUE obj)
 {
     ZmqGetMessage(obj);
+    ZmqReturnNilUnlessOwned(message);
     return INT2NUM(zmsg_size(message->message));
 }
 
@@ -105,6 +134,7 @@ static VALUE rb_czmq_message_size(VALUE obj)
 static VALUE rb_czmq_message_content_size(VALUE obj)
 {
     ZmqGetMessage(obj);
+    ZmqReturnNilUnlessOwned(message);
     return INT2NUM(zmsg_content_size(message->message));
 }
 
@@ -127,10 +157,15 @@ static VALUE rb_czmq_message_push(VALUE obj, VALUE frame_obj)
     int rc = 0;
     errno = 0;
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     ZmqGetFrame(frame_obj);
-    rc = zmsg_push(message->message, frame);
+    ZmqAssertFrameOwnedNoMessage(frame);
+
+    rc = zmsg_push(message->message, frame->frame);
     ZmqAssert(rc);
-    rb_czmq_frame_freed(frame);
+    frame->message = message;
+    frame->flags &= ~ZMQ_FRAME_OWNED;
+    zlist_push(message->frames, (void*)frame_obj);
     return Qtrue;
 }
 
@@ -153,10 +188,15 @@ static VALUE rb_czmq_message_add(VALUE obj, VALUE frame_obj)
     int rc = 0;
     errno = 0;
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     ZmqGetFrame(frame_obj);
-    rc = zmsg_add(message->message, frame);
+    ZmqAssertFrameOwnedNoMessage(frame);
+
+    rc = zmsg_add(message->message, frame->frame);
     ZmqAssert(rc);
-    rb_czmq_frame_freed(frame);
+    frame->message = message;
+    frame->flags &= ~ZMQ_FRAME_OWNED;
+    zlist_append(message->frames, (void*)frame_obj);
     return Qtrue;
 }
 
@@ -179,9 +219,11 @@ static VALUE rb_czmq_message_pop(VALUE obj)
 {
     zframe_t *frame = NULL;
     ZmqGetMessage(obj);
-    frame = zmsg_pop(message->message);
+    ZmqAssertMessageOwned(message);
+    frame = zmsg_pop(message->message); /* we now own the frame */
     if (frame == NULL) return Qnil;
-    return rb_czmq_alloc_frame(frame);
+    VALUE frame_obj = (VALUE)zlist_pop(message->frames);
+    return frame_obj ? frame_obj : Qnil;
 }
 
 /*
@@ -200,6 +242,7 @@ static VALUE rb_czmq_message_pop(VALUE obj)
 static VALUE rb_czmq_message_print(VALUE obj)
 {
     ZmqGetMessage(obj);
+    ZmqReturnNilUnlessOwned(message);
     zmsg_dump(message->message);
     return Qnil;
 }
@@ -220,11 +263,10 @@ static VALUE rb_czmq_message_print(VALUE obj)
 
 static VALUE rb_czmq_message_first(VALUE obj)
 {
-    zframe_t *frame = NULL;
     ZmqGetMessage(obj);
-    frame = zmsg_first(message->message);
-    if (frame == NULL) return Qnil;
-    return rb_czmq_alloc_frame(zframe_dup(frame));
+    ZmqReturnNilUnlessOwned(message);
+    VALUE frame_obj = (VALUE)zlist_first(message->frames);
+    return frame_obj ? frame_obj : Qnil;
 }
 
 /*
@@ -244,11 +286,10 @@ static VALUE rb_czmq_message_first(VALUE obj)
 
 static VALUE rb_czmq_message_next(VALUE obj)
 {
-    zframe_t *frame = NULL;
     ZmqGetMessage(obj);
-    frame = zmsg_next(message->message);
-    if (frame == NULL) return Qnil;
-    return rb_czmq_alloc_frame(zframe_dup(frame));
+    ZmqReturnNilUnlessOwned(message);
+    VALUE frame_obj = (VALUE)zlist_next(message->frames);
+    return frame_obj ? frame_obj : Qnil;
 }
 
 /*
@@ -267,11 +308,10 @@ static VALUE rb_czmq_message_next(VALUE obj)
 
 static VALUE rb_czmq_message_last(VALUE obj)
 {
-    zframe_t *frame = NULL;
     ZmqGetMessage(obj);
-    frame = zmsg_last(message->message);
-    if (frame == NULL) return Qnil;
-    return rb_czmq_alloc_frame(zframe_dup(frame));
+    ZmqReturnNilUnlessOwned(message);
+    VALUE frame_obj = (VALUE)zlist_last(message->frames);
+    return frame_obj ? frame_obj : Qnil;
 }
 
 /*
@@ -293,10 +333,18 @@ static VALUE rb_czmq_message_last(VALUE obj)
 static VALUE rb_czmq_message_remove(VALUE obj, VALUE frame_obj)
 {
     ZmqGetMessage(obj);
-    zframe_t *frame = NULL;
-    ZmqAssertFrame(frame_obj);
-    Data_Get_Struct(frame_obj, zframe_t, frame);
-    zmsg_remove(message->message, frame);
+    ZmqAssertMessageOwned(message);
+    ZmqGetFrame(frame_obj);
+
+    /* remove from message and our list of frame objects */
+    zmsg_remove(message->message, frame->frame);
+    zlist_remove(message->frames, (void*)frame_obj);
+
+    /* removing from message does not destroy the frame,
+       therefore, we take ownership of the frame at this point */
+    frame->message = NULL;
+    frame->flags |= ZMQ_FRAME_OWNED;
+
     return Qnil;
 }
 
@@ -317,9 +365,19 @@ static VALUE rb_czmq_message_pushstr(VALUE obj, VALUE str)
     int rc = 0;
     errno = 0;
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     Check_Type(str, T_STRING);
     rc = zmsg_pushmem(message->message, StringValueCStr(str), RSTRING_LEN(str));
     ZmqAssert(rc);
+
+    /* keep zlist of frame ruby objects in sync with message's frame list */
+    zframe_t* zframe = zmsg_first(message->message);
+    VALUE frame_object = rb_czmq_alloc_frame(zframe);
+    ZmqGetFrame(frame_object);
+    frame->flags &= ~ZMQ_FRAME_OWNED;
+    frame->message = message;
+    zlist_push(message->frames, (void*)frame_object);
+
     return Qtrue;
 }
 
@@ -340,9 +398,19 @@ static VALUE rb_czmq_message_addstr(VALUE obj, VALUE str)
     int rc = 0;
     errno = 0;
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     Check_Type(str, T_STRING);
     rc = zmsg_addmem(message->message, StringValueCStr(str), RSTRING_LEN(str));
     ZmqAssert(rc);
+
+    /* keep zlist of frame ruby objects in sync with message's frame list */
+    zframe_t* zframe = zmsg_last(message->message);
+    VALUE frame_object = rb_czmq_alloc_frame(zframe);
+    ZmqGetFrame(frame_object);
+    frame->flags &= ~ZMQ_FRAME_OWNED;
+    frame->message = message;
+    zlist_append(message->frames, (void*)frame_object);
+
     return Qtrue;
 }
 
@@ -363,8 +431,13 @@ static VALUE rb_czmq_message_popstr(VALUE obj)
 {
     char *str = NULL;
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     str = zmsg_popstr(message->message);
     if (str == NULL) return Qnil;
+
+    /* destroys the frame, keep frame objects list in sync: */
+    zlist_pop(message->frames);
+
     return rb_str_new2(str);
 }
 
@@ -386,9 +459,30 @@ static VALUE rb_czmq_message_wrap(VALUE obj, VALUE frame_obj)
 {
     errno = 0;
     ZmqGetMessage(obj);
-    ZmqGetFrame(frame_obj);
-    zmsg_wrap(message->message, frame);
-    rb_czmq_frame_freed(frame);
+    ZmqAssertMessageOwned(message);
+
+    {
+        ZmqGetFrame(frame_obj);
+        ZmqAssertFrameOwned(frame);
+        zmsg_wrap(message->message, frame->frame);
+        frame->flags &= ~ZMQ_FRAME_OWNED;
+        frame->message = message;
+    }
+
+    /* keep frame objects list in sync. Two frames have been added. frame_obj from above
+       and a new one for the empty frame. */
+    {
+        zmsg_first(message->message);
+        zframe_t* empty_frame = zmsg_next(message->message);
+
+        VALUE empty_frame_object = rb_czmq_alloc_frame(empty_frame);
+        ZmqGetFrame(empty_frame_object);
+        frame->flags &= ~ZMQ_FRAME_OWNED;
+        frame->message = message;
+
+        zlist_push(message->frames, (void*)empty_frame_object);
+        zlist_push(message->frames, (void*)frame_obj);
+    }
     return Qnil;
 }
 
@@ -410,11 +504,29 @@ static VALUE rb_czmq_message_wrap(VALUE obj, VALUE frame_obj)
 
 static VALUE rb_czmq_message_unwrap(VALUE obj)
 {
-    zframe_t *frame = NULL;
     ZmqGetMessage(obj);
-    frame = zmsg_unwrap(message->message);
-    if (frame == NULL) return Qnil;
-    return rb_czmq_alloc_frame(frame);
+    ZmqAssertMessageOwned(message);
+
+    /* reimplemented the zmsg_unwrap function for simpler logic: */
+    zframe_t *zframe = zmsg_pop(message->message);
+    VALUE frame_obj = 0;
+    if (zframe != NULL) {
+        frame_obj = (VALUE)zlist_pop(message->frames);
+    }
+
+    zframe_t *empty = zmsg_first(message->message);
+    if (zframe_size(empty) == 0) {
+        empty = zmsg_pop(message->message);
+        zframe_destroy (&empty);
+        zlist_pop(message->frames);
+    }
+    
+    {
+        ZmqGetFrame(frame_obj);
+        frame->message = NULL;
+        frame->flags |= ZMQ_FRAME_OWNED;
+    }
+    return frame_obj ? frame_obj : Qnil;
 }
 
 /*
@@ -431,16 +543,11 @@ static VALUE rb_czmq_message_unwrap(VALUE obj)
 
 static VALUE rb_czmq_message_dup(VALUE obj)
 {
-    VALUE dup;
-    zmq_message_wrapper *dup_msg = NULL;
-    errno = 0;
     ZmqGetMessage(obj);
-    dup = Data_Make_Struct(rb_cZmqMessage, zmq_message_wrapper, 0, rb_czmq_free_message_gc, dup_msg);
-    dup_msg->message = zmsg_dup(message->message);
-    ZmqAssertObjOnAlloc(dup_msg->message, dup_msg);
-    dup_msg->flags = message->flags;
-    rb_obj_call_init(dup, 0, NULL);
-    return dup;
+    ZmqAssertMessageOwned(message);
+
+    zmsg_t* dup_msg = zmsg_dup(message->message);
+    return rb_czmq_alloc_message(dup_msg);
 }
 
 /*
@@ -460,6 +567,7 @@ static VALUE rb_czmq_message_dup(VALUE obj)
 static VALUE rb_czmq_message_destroy(VALUE obj)
 {
     ZmqGetMessage(obj);
+    ZmqAssertMessageOwned(message);
     rb_czmq_free_message(message);
     return Qnil;
 }
@@ -483,6 +591,7 @@ static VALUE rb_czmq_message_encode(VALUE obj)
     byte *buff;
     size_t buff_size;
     ZmqGetMessage(obj);
+    ZmqReturnNilUnlessOwned(message);
     buff_size = zmsg_encode(message->message, &buff);
     return rb_str_new((char *)buff, buff_size);
 }
@@ -531,8 +640,10 @@ static VALUE rb_czmq_message_eql_p(VALUE obj, VALUE other_message)
     size_t other_buff_size;
     ZmqGetMessage(obj);
     ZmqAssertMessage(other_message);
+    ZmqAssertMessageOwned(message);
     Data_Get_Struct(other_message, zmq_message_wrapper, other);
     if (!other) rb_raise(rb_eTypeError, "uninitialized ZMQ message!");
+    ZmqAssertMessageOwned(other);
 
     if (zmsg_size(message->message) != zmsg_size(other->message)) return Qfalse;
     if (zmsg_content_size(message->message) != zmsg_content_size(other->message)) return Qfalse;
@@ -580,15 +691,33 @@ static VALUE rb_czmq_message_to_a(VALUE obj)
 {
     VALUE ary;
     ZmqGetMessage(obj);
-    ary = rb_ary_new2(zmsg_size(message->message));
-    zframe_t *frame = zmsg_first(message->message);
-    while (frame) {
-        rb_ary_push(ary, rb_czmq_alloc_frame(zframe_dup(frame)));
-        frame = zmsg_next(message->message);
+    ZmqAssertMessageOwned(message);
+    ary = rb_ary_new2(zlist_size(message->frames));
+    VALUE frame_obj = (VALUE)zlist_first(message->frames);
+    while (frame_obj) {
+        rb_ary_push(ary, frame_obj);
+        frame_obj = (VALUE)zlist_next(message->frames);
     }
     return ary;
 }
 
+/*
+ * call-seq:
+ *    msg.gone?   #=> false
+ *    msg.destroy # or send
+ *    msg.gone?   #=> true
+ *
+ * Return boolean indicating if the ZMQ::Message is gone (sent or destroyed). If the message is
+ * gone, accessor methods will return nil and methods requiring data or methods that mutate
+ * the message will raise an exception.
+*/
+
+static VALUE rb_czmq_message_gone(VALUE obj)
+{
+    ZmqGetMessage(obj);
+    return (message->flags & ZMQ_MESSAGE_OWNED) ? Qfalse : Qtrue;
+}
+
 void _init_rb_czmq_message()
 {
     rb_cZmqMessage = rb_define_class_under(rb_mZmq, "Message", rb_cObject);
@@ -617,4 +746,5 @@ void _init_rb_czmq_message()
     rb_define_method(rb_cZmqMessage, "eql?", rb_czmq_message_equals, 1);
     rb_define_method(rb_cZmqMessage, "==", rb_czmq_message_equals, 1);
     rb_define_method(rb_cZmqMessage, "to_a", rb_czmq_message_to_a, 0);
+    rb_define_method(rb_cZmqMessage, "gone?", rb_czmq_message_gone, 0);
 }

data/ext/rbczmq/message.h

@@ -1,11 +1,15 @@
 #ifndef RBCZMQ_MESSAGE_H
 #define RBCZMQ_MESSAGE_H
 
-#define ZMQ_MESSAGE_DESTROYED 0x01
+/* This flag indicates that the wrapped zmsg_t is owned by ruby
+   and can be freed when the ZMQ::Message object is garbage collected */
+#define ZMQ_MESSAGE_OWNED 0x01
 
 typedef struct {
     zmsg_t  *message;
     int flags;
+    /* a zlist of frame wrapper objects for the frames in this message */
+    zlist_t *frames;
 } zmq_message_wrapper;
 
 #define ZmqAssertMessage(obj) ZmqAssertType(obj, rb_cZmqMessage, "ZMQ::Message")
@@ -13,11 +17,23 @@ typedef struct {
     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) 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);
+    */
+
+#define ZmqReturnNilUnlessOwned(wrapper) if (wrapper && (wrapper->flags & ZMQ_MESSAGE_OWNED) == 0) { \
+    return Qnil; \
+}
+
+#define ZmqAssertMessageOwned(wrapper) if (wrapper && (wrapper->flags & ZMQ_MESSAGE_OWNED) == 0) { \
+    rb_raise(rb_eTypeError, "Cannot modify a message that is gone."); \
+}
 
 VALUE rb_czmq_alloc_message(zmsg_t *message);
 void rb_czmq_free_message(zmq_message_wrapper *message);
+void rb_czmq_mark_message(zmq_message_wrapper *message);
 
 void _init_rb_czmq_message();
 

data/ext/rbczmq/pollitem.c

@@ -250,4 +250,4 @@ void _init_rb_czmq_pollitem()
     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);
-}
+}

data/ext/rbczmq/rbczmq_ext.c

@@ -25,8 +25,6 @@ VALUE rb_cZmqPoller;
 VALUE rb_cZmqPollitem;
 VALUE rb_cZmqBeacon;
 
-st_table *frames_map = NULL;
-
 VALUE intern_call;
 VALUE intern_readable;
 VALUE intern_writable;
@@ -216,8 +214,6 @@ static VALUE rb_czmq_m_proxy(int argc, VALUE *argv, ZMQ_UNUSED VALUE klass)
 
 void Init_rbczmq_ext()
 {
-    frames_map = st_init_numtable();
-
     intern_call = rb_intern("call");
     intern_readable = rb_intern("on_readable");
     intern_writable = rb_intern("on_writable");

data/ext/rbczmq/rbczmq_ext.h

@@ -75,8 +75,6 @@ extern VALUE rb_cZmqPoller;
 extern VALUE rb_cZmqPollitem;
 extern VALUE rb_cZmqBeacon;
 
-extern st_table *frames_map;
-
 extern VALUE intern_call;
 extern VALUE intern_readable;
 extern VALUE intern_writable;

data/ext/rbczmq/socket.c

@@ -229,7 +229,7 @@ static VALUE rb_czmq_socket_bind(VALUE obj, VALUE endpoint)
     args.endpoint = StringValueCStr(endpoint);
     rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_socket_bind, (void *)&args, RUBY_UBF_IO, 0);
     /* ZmqAssert will return false on any non-zero return code. Bind returns the port number */
-    if (rc < 0) { 
+    if (rc < 0) {
         ZmqAssert(rc);
     }
     if (sock->verbose)
@@ -562,6 +562,7 @@ static VALUE rb_czmq_socket_send_frame(int argc, VALUE *argv, VALUE obj)
     ZmqSockGuardCrossThread(sock);
     rb_scan_args(argc, argv, "11", &frame_obj, &flags);
     ZmqGetFrame(frame_obj);
+    ZmqAssertFrameOwnedNoMessage(frame);
 
     if (NIL_P(flags)) {
         flgs = 0;
@@ -573,13 +574,17 @@ static VALUE rb_czmq_socket_send_frame(int argc, VALUE *argv, VALUE obj)
 
     if (sock->verbose) {
         cur_time = rb_czmq_formatted_current_time();
-        print_frame = (flgs & ZFRAME_REUSE) ? frame : zframe_dup(frame);
+        print_frame = (flgs & ZFRAME_REUSE) ? frame->frame : zframe_dup(frame->frame);
     }
     args.socket = sock;
-    args.frame = frame;
+    args.frame = frame->frame;
     args.flags = flgs;
     rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_send_frame, (void *)&args, RUBY_UBF_IO, 0);
     ZmqAssert(rc);
+    if ((flgs & ZFRAME_REUSE) == 0) {
+        /* frame has been destroyed, clear the owns flag */
+        frame->flags &= ~ZMQ_FRAME_OWNED;
+    }
     if (sock->verbose) ZmqDumpFrame("send_frame", print_frame);
     return Qtrue;
 }
@@ -623,11 +628,12 @@ static VALUE rb_czmq_socket_send_message(VALUE obj, VALUE message_obj)
     ZmqAssertSocketNotPending(sock, "can only send on a bound or connected socket!");
     ZmqSockGuardCrossThread(sock);
     ZmqGetMessage(message_obj);
+    ZmqAssertMessageOwned(message);
     if (sock->verbose) print_message = zmsg_dup(message->message);
     args.socket = sock;
     args.message = message->message;
     rb_thread_blocking_region(rb_czmq_nogvl_send_message, (void *)&args, RUBY_UBF_IO, 0);
-    message->flags |= ZMQ_MESSAGE_DESTROYED;
+    message->flags &= ~ZMQ_MESSAGE_OWNED;
     if (sock->verbose) ZmqDumpMessage("send_message", print_message);
     return Qnil;
 }
@@ -1652,7 +1658,7 @@ static VALUE rb_czmq_socket_monitor_thread(void *arg)
 
     args.monitored_socket_wrapper = sock;
     args.socket = s;
-    
+
     while (1) {
         zmq_msg_init (&args.msg);
         rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_monitor_recv, (void *)&args, RUBY_UBF_IO, 0);

data/lib/zmq.rb

@@ -82,4 +82,5 @@ require "zmq/timer"
 require "zmq/frame"
 require "zmq/message"
 require "zmq/poller"
-require "zmq/pollitem"
+require "zmq/pollitem"
+require "zmq/logger"

data/lib/zmq/logger.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'logger'
+
+module ZMQ
+
+  # A logging class that sends its output to a ZMQ socket. This allows log messages to be sent
+  # asynchronously to another process and across a network if required. The receiving socket
+  # will receive messages, each with text of one log message.
+  #
+  # Example usage:
+  #
+  #   socket = context.socket(ZMQ::PUSH)
+  #   socket.connect("tcp://logserver:5555")
+  #   logger = ZMQ::Logger.new(socket)
+  #   logger.debug("Hello logger")
+  #
+  class Logger < ::Logger
+
+    class InvalidSocketError < ZMQ::Error ; end
+
+    # only these socket classes are allowed to be used for sending
+    VALID_SOCKET_CLASSES = [
+      Socket::Pub,
+      Socket::Push,
+      Socket::Pair
+    ]
+
+    # Initialise a new logger object. The logger sends log messages to a socket.
+    # The caller is responsible for connecting the socket before using the logger to
+    # send log output to the socket.
+    #
+    # Supported socket types are a Socket::Pub, Socket::Push, and Socket::Pair
+    def initialize(socket)
+      raise InvalidSocketError unless VALID_SOCKET_CLASSES.any? { |klass| socket.is_a?(klass) }
+      super(nil)
+      @logdev = LogDevice.new(socket)
+    end
+
+    # implements an interface similar to ::Logger::LogDevice. This is the recipient of the
+    # formatted log messages
+    class LogDevice
+      # :nodoc:
+      def initialize(socket)
+        @socket = socket
+      end
+
+      # write the formatted log message to the socket.
+      def write(message)
+        @socket.send(message)
+      end
+
+      def close
+      end
+    end
+
+  end
+end

data/lib/zmq/version.rb

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

data/test/test_frame.rb

@@ -11,10 +11,9 @@ class TestZmqFrame < ZmqTestCase
 
   def test_destroyed_frame
     frame = ZMQ::Frame("message")
+    assert !frame.gone?
     frame.destroy
-    assert_raises ZMQ::Error do
-      frame.data
-    end
+    assert frame.gone?
   end
 
   def test_alloc_empty

data/test/test_logger.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqLogger < ZmqTestCase
+
+  def setup
+    @ctx = ZMQ::Context.new
+  end
+
+  def teardown
+    @ctx.destroy
+  end
+
+  def test_invalid_socket
+    socket = @ctx.socket(ZMQ::REQ)
+    assert_raises ZMQ::Logger::InvalidSocketError do
+      ZMQ::Logger.new(socket)
+    end
+  end
+
+  def test_valid_socket
+    socket = @ctx.socket(ZMQ::PUSH)
+    assert_nothing_raised do
+      ZMQ::Logger.new(socket)
+    end
+  end
+
+  def test_send_message
+    reader = @ctx.socket(ZMQ::PULL)
+    port = reader.bind("tcp://*:*")
+    assert port > 0
+    writer = @ctx.socket(ZMQ::PUSH)
+    writer.connect("tcp://localhost:#{port}")
+    logger = ZMQ::Logger.new(writer)
+    assert logger.debug("hellö world")
+    message = reader.recv.force_encoding Encoding::UTF_8
+    assert_not_nil message =~ /hellö world/
+  end
+
+end

data/test/test_message.rb

@@ -11,10 +11,11 @@ class TestZmqMessage < ZmqTestCase
 
   def test_destroyed
     msg = ZMQ::Message("one", "two")
+    assert_not_nil msg.encode
+    assert !msg.gone?
     msg.destroy
-    assert_raises ZMQ::Error do
-      msg.encode
-    end
+    assert msg.gone?
+    assert_nil msg.encode
   end
 
   def test_message_sugar
@@ -182,7 +183,7 @@ class TestZmqMessage < ZmqTestCase
   end
 
   def test_equals
-    msg =  ZMQ::Message.new
+    msg = ZMQ::Message.new
     msg.pushstr "body"
     msg.pushstr "header"
 
@@ -198,4 +199,96 @@ class TestZmqMessage < ZmqTestCase
     assert !msg.eql?(other)
     assert other.eql?(other)
   end
-end
+
+  def test_message_with_frames
+    msg = ZMQ::Message.new
+    frame = ZMQ::Frame.new("hello")
+    assert_equal "hello", frame.data
+    msg.add frame
+    # frame is owned by message, but message is still owned by ruby,
+    # so the frame data should still be accessible:
+    assert_equal "hello", frame.data
+  end
+
+  def test_messge_add_frame_twice
+    msg = ZMQ::Message.new
+    frame = ZMQ::Frame.new("hello")
+    msg.add frame
+    assert_raises ZMQ::Error do
+      msg.add frame
+    end
+  end
+
+  def test_message_is_gone_after_send
+    ctx = ZMQ::Context.new
+    endpoint = "inproc://test.test_message_is_gone_after_send"
+    push = ctx.bind(:PUSH, endpoint)
+    pull = ctx.connect(:PULL, endpoint)
+    msg = ZMQ::Message.new
+    frame = ZMQ::Frame.new("hello")
+    msg.add frame
+    push.send_message(msg)
+    assert msg.gone?
+    assert frame.gone?
+  ensure
+    ctx.destroy
+  end
+
+  def test_message_has_frames_on_receive
+    ctx = ZMQ::Context.new
+    endpoint = "inproc://test.test_message_is_gone_after_send"
+    push = ctx.bind(:PUSH, endpoint)
+    pull = ctx.connect(:PULL, endpoint)
+    msg = ZMQ::Message.new
+    msg.add ZMQ::Frame.new("hello")
+    msg.add ZMQ::Frame.new("world")
+    push.send_message(msg)
+    received = pull.recv_message
+    assert_not_nil received
+    assert_equal 2, received.size
+    assert_equal "hello", received.first.data
+    assert_equal "world", received.next.data
+  ensure
+    ctx.destroy
+  end
+
+  def test_message_remove_frame
+    msg = ZMQ::Message.new
+    frame = ZMQ::Frame.new("hello")
+    msg.add frame
+    assert_equal 1, msg.size
+    # same object is returned
+    assert_equal frame.object_id, msg.first.object_id
+    msg.remove frame
+    assert_equal 0, msg.size
+  end
+
+  def test_message_array_same_frame_objects
+    msg = ZMQ::Message.new
+    frame = ZMQ::Frame.new("hello")
+    msg.add frame
+    ary = msg.to_a
+    assert_equal 1, ary.count
+    assert_equal frame, ary.first
+    assert_equal frame.object_id, ary.first.object_id
+  end
+
+  def test_message_unwrap_dup
+    ctx = ZMQ::Context.new
+    router = ctx.socket(ZMQ::ROUTER)
+    port = router.bind("tcp://127.0.0.1:*")
+    req = ctx.connect(ZMQ::REQ, "tcp://127.0.0.1:#{port}")
+    msg = ZMQ::Message.new
+    msg.addstr "hello world"
+    req.send_message msg
+    msg2 = router.recv_message
+    identity = msg2.unwrap
+    assert_equal "hello world", msg2.first.data
+    msg3 = ZMQ::Message.new
+    msg3.addstr "reply"
+    msg3.wrap identity.dup
+    assert_equal 3, msg3.size
+  ensure
+    ctx.destroy
+  end
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbczmq
 version: !ruby/object:Gem::Version
-  version: 1.6.4
-  prerelease: 
+  version: 1.7.0
 platform: ruby
 authors:
 - Lourens Naudé
@@ -11,12 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-09 00:00:00.000000000 Z
+date: 2013-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -24,7 +22,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -86,6 +83,7 @@ files:
 - lib/zmq/default_handler.rb
 - lib/zmq/frame.rb
 - lib/zmq/handler.rb
+- lib/zmq/logger.rb
 - lib/zmq/loop.rb
 - lib/zmq/message.rb
 - lib/zmq/monitor.rb
@@ -136,6 +134,7 @@ files:
 - test/test_context.rb
 - test/test_frame.rb
 - test/test_handler.rb
+- test/test_logger.rb
 - test/test_loop.rb
 - test/test_message.rb
 - test/test_monitoring.rb
@@ -529,28 +528,27 @@ files:
 - ext/zeromq/version.sh
 homepage: http://github.com/methodmissing/rbczmq
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --charset=UTF-8
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby extension for ZeroMQ (ZMQ) using CZMQ - High-level C Binding for ØMQ
   (http://czmq.zeromq.org)
 test_files:
@@ -573,6 +571,7 @@ test_files:
 - test/test_context.rb
 - test/test_frame.rb
 - test/test_handler.rb
+- test/test_logger.rb
 - test/test_loop.rb
 - test/test_message.rb
 - test/test_monitoring.rb
@@ -582,4 +581,3 @@ test_files:
 - test/test_threading.rb
 - test/test_timer.rb
 - test/test_zmq.rb
-has_rdoc: true