rbczmq 0.1

data/ext/rbczmq/context.h

@@ -0,0 +1,26 @@
+#ifndef RBCZMQ_CONTEXT_H
+#define RBCZMQ_CONTEXT_H
+
+#define ZMQ_CONTEXT_DESTROYED 0x01
+
+typedef struct {
+    zctx_t *ctx;
+    int flags;
+} zmq_ctx_wrapper;
+
+#define ZmqAssertContext(obj) ZmqAssertType(obj, rb_cZmqContext, "ZMQ::Context")
+#define ZmqGetContext(obj) \
+    zmq_ctx_wrapper *ctx = NULL; \
+    ZmqAssertContext(obj); \
+    Data_Get_Struct(obj, zmq_ctx_wrapper, ctx); \
+    if (!ctx) rb_raise(rb_eTypeError, "uninitialized ZMQ context!"); \
+    if (ctx->flags & ZMQ_CONTEXT_DESTROYED) rb_raise(rb_eZmqError, "ZMQ::Context instance %p has been destroyed by the ZMQ framework", (void *)obj);
+
+struct nogvl_socket_args {
+    zctx_t *ctx;
+    int type;
+};
+
+void _init_rb_czmq_context();
+
+#endif

data/ext/rbczmq/extconf.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'mkmf'
+require 'pathname'
+
+def sys(cmd, err_msg)
+  p cmd
+  system(cmd) || fail(err_msg)
+end
+
+def fail(msg)
+  STDERR.puts msg
+  exit(1)
+end
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+# XXX fallbacks specific to Darwin for JRuby (does not set these values in RbConfig::CONFIG)
+LIBEXT = RbConfig::CONFIG['LIBEXT'] || 'a'
+DLEXT = RbConfig::CONFIG['DLEXT'] || 'bundle'
+
+cwd = Pathname(File.expand_path(File.dirname(__FILE__)))
+dst_path = cwd + 'dst'
+libs_path = dst_path + 'lib'
+vendor_path = cwd + '..'
+zmq_path = vendor_path + 'zeromq'
+czmq_path = vendor_path + 'czmq'
+zmq_include_path = zmq_path + 'include'
+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) }
+end
+
+def check_heads heads = [], fatal = false
+  heads.all? { |head| have_header(head) || (abort("could not find header: #{head}") if fatal)}
+end
+
+case RUBY_PLATFORM
+when /mswin32/, /mingw32/, /bccwin32/
+  check_heads(%w[windows.h winsock.h], true)
+  check_libs(%w[kernel32 rpcrt4 gdi32], true)
+
+  if GNU_CHAIN
+    CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
+  else
+    $defs.push "-EHs"
+    $defs.push "-GR"
+  end
+
+when /solaris/
+  add_define 'OS_SOLARIS8'
+
+  if CONFIG['CC'] == 'cc' and `cc -flags 2>&1` =~ /Sun/ # detect SUNWspro compiler
+    # SUN CHAIN
+    add_define 'CC_SUNWspro'
+    $preload = ["\nCXX = CC"] # hack a CXX= line into the makefile
+    $CFLAGS = CONFIG['CFLAGS'] = "-KPIC"
+    CONFIG['CCDLFLAGS'] = "-KPIC"
+    CONFIG['LDSHARED'] = "$(CXX) -G -KPIC -lCstd"
+  else
+    # GNU CHAIN
+    # on Unix we need a g++ link, not gcc.
+    CONFIG['LDSHARED'] = "$(CXX) -shared"
+  end
+
+when /openbsd/
+  # OpenBSD branch contributed by Guillaume Sellier.
+
+  # on Unix we need a g++ link, not gcc. On OpenBSD, linking against libstdc++ have to be explicitly done for shared libs
+  CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++ -fPIC"
+  CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
+
+when /darwin/
+  # on Unix we need a g++ link, not gcc.
+  # Ff line contributed by Daniel Harple.
+  CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+when /aix/
+  CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G -Wl,-brtl"
+
+else
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+# extract dependencies
+unless File.directory?(zmq_path) && File.directory?(czmq_path)
+  fail "The 'tar' (creates and manipulates streaming archive files) utility is required to extract dependencies" if `which tar`.strip.empty?
+  Dir.chdir(vendor_path) do
+    sys "tar xvzf zeromq.tar.gz", "Could not extract the ZeroMQ archive!"
+    sys "tar xvzf czmq.tar.gz", "Could not extract the CZMQ archive!"
+  end
+end
+
+# build libzmq
+lib = libs_path + "libzmq.#{LIBEXT}"
+Dir.chdir zmq_path do
+  sys "./autogen.sh", "ZeroMQ autogen failed!" unless File.exist?(zmq_path + 'configure')
+  sys "./configure --prefix=#{dst_path} --without-documentation --enable-shared && make && make install", "ZeroMQ compile error!"
+end unless File.exist?(lib)
+
+# build libczmq
+lib = libs_path + "libczmq.#{LIBEXT}"
+Dir.chdir czmq_path do
+  sys "./autogen.sh", "CZMQ autogen failed!" unless File.exist?(czmq_path + 'configure')
+  sys "./configure LDFLAGS=-L#{libs_path} --prefix=#{dst_path} --with-libzmq=#{dst_path} --disable-shared && make all && make install", "CZMQ compile error!"
+end unless File.exist?(lib)
+
+dir_config('rbczmq')
+
+have_func('rb_thread_blocking_region')
+
+$INCFLAGS << " -I#{zmq_include_path}" if find_header("zmq.h", zmq_include_path)
+$INCFLAGS << " -I#{czmq_include_path}" if find_header("czmq.h", czmq_include_path)
+
+$LIBPATH << libs_path.to_s
+
+# Special case to prevent Rubinius compile from linking system libzmq if present
+if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+  CONFIG['LDSHARED'] = "#{CONFIG['LDSHARED']} -Wl,-rpath=#{libs_path.to_s}"
+end
+
+fail "Error compiling and linking libzmq" unless have_library("zmq")
+fail "Error compiling and linking libczmq" unless have_library("czmq")
+
+$defs << "-pedantic"
+
+$CFLAGS << ' -Wall -funroll-loops'
+$CFLAGS << ' -Wextra -O0 -ggdb3' if ENV['DEBUG']
+
+create_makefile('rbczmq_ext')

data/ext/rbczmq/frame.c

@@ -0,0 +1,401 @@
+#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:
+ *  Coerce a zframe instance to a native Ruby object.
+ *
+*/
+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);
+    rb_obj_call_init(frame_obj, 0, NULL);
+    return frame_obj;
+}
+
+/*
+ * :nodoc:
+ *  Free all resources for a frame - invoked by the lower level ZMQ::Frame#destroy as well as the GC callback. We also
+ *  do a symbol table lookup here to ensure we don't double free a struct that's already been recycled from within
+ *  libczmq.
+ *
+*/
+void rb_czmq_free_frame(zframe_t *frame)
+{
+    if (frame)
+        if (st_lookup(frames_map, (st_data_t)frame, 0)) zframe_destroy(&frame);
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *
+*/
+void rb_czmq_free_frame_gc(void *ptr)
+{
+    zframe_t *frame = (zframe_t *)ptr;
+    rb_czmq_free_frame(frame);
+}
+
+/*
+ *  call-seq:
+ *     ZMQ::Frame.new    =>  ZMQ::Frame
+ *     ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *
+ *  Creates a new ZMQ::Frame instance. Can be initialized with or without data. A frame corresponds to one zmq_msg_t.
+ *
+ * === Examples
+ *     ZMQ::Frame.new    =>  ZMQ::Frame
+ *     ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *
+*/
+
+static VALUE rb_czmq_frame_s_new(int argc, VALUE *argv, VALUE frame)
+{
+    VALUE data;
+    errno = 0;
+    zframe_t *fr;
+    rb_scan_args(argc, argv, "01", &data);
+    if (NIL_P(data)) {
+        fr = zframe_new(NULL, 0);
+    } else {
+        Check_Type(data, T_STRING);
+        fr = zframe_new(RSTRING_PTR(data), (size_t)RSTRING_LEN(data));
+    }
+    if (fr == NULL) {
+        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;
+}
+
+/*
+ *  call-seq:
+ *     frame.destroy    =>  nil
+ *
+ *  Explicitly destroys an allocated ZMQ::Frame instance. Useful for manual memory management, otherwise the GC
+ *  will take the same action if a frame object is not reachable anymore on the next GC cycle. This is
+ *  a lower level API.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *     frame.destroy     =>  nil
+ *
+*/
+
+static VALUE rb_czmq_frame_destroy(VALUE obj)
+{
+    ZmqGetFrame(obj);
+    rb_czmq_free_frame(frame);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     frame.size    =>  Fixnum
+ *
+ *  Returns the size of the frame.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *     frame.size     =>  4
+ *
+*/
+
+static VALUE rb_czmq_frame_size(VALUE obj)
+{
+    size_t size;
+    ZmqGetFrame(obj);
+    size = zframe_size(frame);
+    return LONG2FIX(size);
+}
+
+/*
+ *  call-seq:
+ *     frame.data    =>  String
+ *
+ *  Returns the data represented by the frame as a string.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *     frame.data     =>  "data"
+ *
+*/
+
+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));
+}
+
+/*
+ *  call-seq:
+ *     frame.to_s    =>  String
+ *
+ *  Returns a String representation of this frame.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("data")    =>  ZMQ::Frame
+ *     frame.to_s     =>  "data"
+ *
+*/
+
+static VALUE rb_czmq_frame_to_s(VALUE obj)
+{
+    return rb_funcall(obj, intern_data, 0, 0);
+}
+
+/*
+ *  call-seq:
+ *     frame.strhex    =>  String
+ *
+ *  Returns a printable hex representation of this frame
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.strhex     =>  "6D657373616765"
+ *
+*/
+
+static VALUE rb_czmq_frame_strhex(VALUE obj)
+{
+    ZmqGetFrame(obj);
+    return rb_str_new2(zframe_strhex(frame));
+}
+
+/*
+ *  call-seq:
+ *     frame.dup    =>  ZMQ::Frame
+ *
+ *  Returns a copy of the current frame
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.dup     =>  ZMQ::Frame
+ *
+*/
+
+static VALUE rb_czmq_frame_dup(VALUE obj)
+{
+    VALUE dup;
+    zframe_t *dup_fr = NULL;
+    errno = 0;
+    ZmqGetFrame(obj);
+    dup_fr = zframe_dup(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;
+}
+
+/*
+ *  call-seq:
+ *     frame.data_equals?("data")    =>  boolean
+ *
+ *  Determines if the current frame's payload matches a given string
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.data_equals?("message")     =>  true
+ *
+*/
+
+static VALUE rb_czmq_frame_data_equals_p(VALUE obj, VALUE data)
+{
+    ZmqGetFrame(obj);
+    Check_Type(data, T_STRING);
+    return (zframe_streq(frame, RSTRING_PTR(data)) == TRUE) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     frame.more?    =>  boolean
+ *
+ *  Determines if the current frame is part of a multipart message.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.more?     =>  false
+ *
+*/
+
+static VALUE rb_czmq_frame_more_p(VALUE obj)
+{
+    ZmqGetFrame(obj);
+    return (zframe_more(frame) == ZFRAME_MORE) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     frame.eql?(other)    =>  boolean
+ *
+ *  Determines if the current frame is equal to another (identical size and data).
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     other_frame = ZMQ::Frame.new("other")
+ *     frame.eql?(other_frame)     =>  false
+ *
+*/
+
+static VALUE rb_czmq_frame_eql_p(VALUE obj, VALUE other_frame)
+{
+    zframe_t *other = NULL;
+    ZmqGetFrame(obj);
+    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;
+}
+
+/*
+ *  call-seq:
+ *     frame == other    =>  boolean
+ *
+ *  Determines if the current frame is equal to another (identical size and data).
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     other_frame = ZMQ::Frame.new("other")
+ *     frame == other_frame     =>  false
+ *     frame == frame      =>  true
+ *
+*/
+
+static VALUE rb_czmq_frame_equals(VALUE obj, VALUE other_frame)
+{
+    if (obj == other_frame) return Qtrue;
+    return rb_czmq_frame_eql_p(obj, other_frame);
+}
+
+/*
+ *  call-seq:
+ *     frame <=> other    =>  boolean
+ *
+ *  Comparable support for ZMQ::Frame instances.
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     other_frame = ZMQ::Frame.new("other")
+ *     frame > other_frame     =>  true
+ *
+*/
+
+static VALUE rb_czmq_frame_cmp(VALUE obj, VALUE other_frame)
+{
+    long diff;
+    zframe_t *other = NULL;
+    if (obj == other_frame) return INT2NUM(0);
+    ZmqGetFrame(obj);
+    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));
+    if (diff == 0) return INT2NUM(0);
+    if (diff > 0) return INT2NUM(1);
+    return INT2NUM(-1);
+}
+
+/*
+ *  call-seq:
+ *     frame.print    =>  nil
+ *
+ *  Dumps out frame contents to stderr
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.print  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_frame_print(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE prefix;
+    const char *print_prefix = NULL;
+    ZmqGetFrame(obj);
+    rb_scan_args(argc, argv, "01", &prefix);
+    if (NIL_P(prefix)) {
+        print_prefix = "";
+    } else {
+        Check_Type(prefix, T_STRING);
+        print_prefix = RSTRING_PTR(prefix);
+    }
+    zframe_print(frame, (char *)print_prefix);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     frame.reset("new")   =>  nil
+ *
+ *  Sets new content for this frame
+ *
+ * === Examples
+ *     frame = ZMQ::Frame.new("message")    =>  ZMQ::Frame
+ *     frame.reset("new")   =>  nil
+ *     frame.data   =>   "new"
+ *
+*/
+
+static VALUE rb_czmq_frame_reset(VALUE obj, VALUE data)
+{
+    errno = 0;
+    ZmqGetFrame(obj);
+    Check_Type(data, T_STRING);
+    zframe_reset(frame, (char *)RSTRING_PTR(data), (size_t)RSTRING_LEN(data));
+    ZmqAssertSysError();
+    return Qnil;
+}
+
+void _init_rb_czmq_frame()
+{
+    intern_data = rb_intern("data");
+
+    rb_cZmqFrame = rb_define_class_under(rb_mZmq, "Frame", rb_cObject);
+
+    rb_define_const(rb_cZmqFrame, "MORE", INT2NUM(ZFRAME_MORE));
+    rb_define_const(rb_cZmqFrame, "REUSE", INT2NUM(ZFRAME_REUSE));
+
+    rb_define_singleton_method(rb_cZmqFrame, "new", rb_czmq_frame_s_new, -1);
+    rb_define_method(rb_cZmqFrame, "destroy", rb_czmq_frame_destroy, 0);
+    rb_define_method(rb_cZmqFrame, "size", rb_czmq_frame_size, 0);
+    rb_define_method(rb_cZmqFrame, "dup", rb_czmq_frame_dup, 0);
+    rb_define_method(rb_cZmqFrame, "data", rb_czmq_frame_data, 0);
+    rb_define_method(rb_cZmqFrame, "to_s", rb_czmq_frame_to_s, 0);
+    rb_define_method(rb_cZmqFrame, "to_str", rb_czmq_frame_to_s, 0);
+    rb_define_method(rb_cZmqFrame, "strhex", rb_czmq_frame_strhex, 0);
+    rb_define_method(rb_cZmqFrame, "data_equals?", rb_czmq_frame_data_equals_p, 1);
+    rb_define_method(rb_cZmqFrame, "more?", rb_czmq_frame_more_p, 0);
+    rb_define_method(rb_cZmqFrame, "eql?", rb_czmq_frame_eql_p, 1);
+    rb_define_method(rb_cZmqFrame, "==", rb_czmq_frame_equals, 1);
+    rb_define_method(rb_cZmqFrame, "<=>", rb_czmq_frame_cmp, 1);
+    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);
+}