nanomsg 0.1.0

data/LICENSE

@@ -0,0 +1,23 @@
+
+ Copyright (c) 2013 Kaspar Schiess
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,47 @@
+
+TLDR
+
+An idiomatic nanomsg wrapper for Ruby. (http://nanomsg.org/) 
+
+NANOMSG
+
+nanomsg library is a high-performance implementation of several "scalability 
+protocols". Scalability protocol's job is to define how multiple applications 
+communicate to form a single distributed application. Implementation of 
+following scalability protocols is available at the moment:
+
+ * PAIR - simple one-to-one communication
+ * BUS - simple many-to-many communication
+ * REQREP - allows to build clusters of stateless services to process user requests
+ * PUBSUB - distributes messages to large sets of interested subscribers
+ * FANIN - aggregates messages from multiple sources
+ * FANOUT - load balances messages among many destinations
+ * SURVEY - allows to query state of multiple applications in a single go
+
+Scalability protocols are layered on top of transport layer in the network 
+stack. At the moment, nanomsg library supports following transports:
+
+ * INPROC - transport within a process (between threads, modules etc.)
+ * IPC - transport between processes on a single machine
+ * TCP - network transport via TCP
+
+SYNOPSIS
+
+  require 'nanomsg'
+
+  socket1 = NanoMsg::PairSocket.new
+  socket1.bind('inproc://test')
+  
+  socket1.send('test')
+  socket1.recv
+
+STATUS
+
+Very early alpha, not much testing has been done. Only the PAIR communication
+type works. Nonblocking mode doesn't even begin to work. This will break your
+application. 
+
+LICENSE
+
+MIT, 2013, Kaspar Schiess
+

data/examples/pair.rb

@@ -0,0 +1,16 @@
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'nanomsg'
+
+sock1 = NanoMsg::PairSocket.new(NanoMsg::AF_SP)
+sock1.bind("ipc:///tmp/test.ipc")
+
+sock2 = NanoMsg::PairSocket.new(NanoMsg::AF_SP)
+sock2.connect("ipc:///tmp/test.ipc")
+
+sock1.send 'test'
+sock1.send 'nanomsg'
+
+puts sock2.recv
+puts sock2.recv
+

data/examples/roundtrip_latency.rb

@@ -0,0 +1,140 @@
+
+# Example adapted from nn-cores roundtrip_latency. 
+# (https://raw.github.com/chuckremes/nn-core/master/examples/roundtrip_latency.rb)
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'nanomsg'
+
+# Within a single process, we start up two threads. One thread has a REQ (request)
+# socket and the second thread has a REP (reply) socket. We measure the
+# *round-trip* latency between these sockets. Only *one* message is in flight at
+# any given moment.
+#
+#  % ruby roundtrip_latency.rb tcp://127.0.0.1:5555 1024 1_000_000
+#
+#  % ruby roundtrip_latency.rb inproc://lm_sock 1024 1_000_000
+#
+
+if ARGV.length < 3
+  puts "usage: ruby roundtrip_latency.rb <connect-to> <message-size> <roundtrip-count>"
+  exit
+end
+
+link = ARGV[0]
+message_size = ARGV[1].to_i
+roundtrip_count = ARGV[2].to_i
+
+def set_signal_handler(receiver, transmitter)
+  trap(:INT) do
+    puts "got ctrl-c"
+    receiver.terminate
+    transmitter.terminate
+  end
+end
+
+class Node
+  def initialize(endpoint, size, count)
+    @endpoint = endpoint
+    @size = size
+    @count = count
+    @msg = 'a' * @size
+
+    setup_socket
+    set_endpoint
+  end
+
+  def setup_socket
+    @socket = NanoMsg::PairSocket.new
+  end
+
+  def send_msg
+    nbytes = @socket.send(@msg)
+    assert(nbytes)
+    nbytes
+  end
+
+  def recv_msg
+    msg = @socket.recv
+    nbytes = msg.bytesize
+    assert(nbytes)
+    nbytes
+  end
+
+  def terminate
+    # TODO
+    # assert(NNCore::LibNanomsg.nn_close(@socket))
+  end
+
+  def assert(rc)
+    raise "Last API call failed at #{caller(1)}" unless rc >= 0
+  end
+end
+
+class Receiver < Node
+  def set_endpoint
+    @socket.bind(@endpoint)
+  end
+
+  def run
+    @count.times do
+      nbytes = recv_msg
+
+      raise "Message size doesn't match, expected [#{@size}] but received [#{string.size}]" if @size != nbytes
+
+      send_msg
+    end
+
+    terminate
+  end
+end
+
+class Transmitter < Node
+  def set_endpoint
+    @socket.connect(@endpoint)
+  end
+
+  def run
+    elapsed = elapsed_microseconds do
+      @count.times do
+        send_msg
+
+        nbytes = recv_msg
+
+        raise "Message size doesn't match, expected [#{@size}] but received [#{nbytes}]" if @size != nbytes
+      end
+    end
+
+    latency = elapsed / @count / 2
+
+    puts "message size: %i [B]" % @size
+    puts "roundtrip count: %i" % @count
+    puts "throughput (msgs/s): %i" % (@count / (elapsed / 1_000_000))
+    puts "mean latency: %.3f [us]" % latency
+    terminate
+  end
+
+  def elapsed_microseconds(&blk)
+    start = Time.now
+    yield
+    value = ((Time.now - start) * 1_000_000)
+  end
+end
+
+threads = []
+receiver = transmitter = nil
+
+threads << Thread.new do
+  receiver = Receiver.new(link, message_size, roundtrip_count)
+  receiver.run
+end
+
+sleep 1
+
+threads << Thread.new do
+  transmitter = Transmitter.new(link, message_size, roundtrip_count)
+  transmitter.run
+end
+
+set_signal_handler(receiver, transmitter)
+
+threads.each {|t| t.join}

data/ext/Makefile

@@ -0,0 +1,218 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+n=$(NULLCMD)
+ECHO1 = $(V:1=@$n)
+ECHO = $(ECHO1:0=@echo)
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1
+hdrdir = /Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1
+arch_hdrdir = /Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitedir = $(rubylibprefix)/site_ruby
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+NULLCMD = :
+
+CC = /usr/local/bin/gcc-4.2
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration
+CFLAGS   = -fno-common $(cflags)  -fno-common -pipe $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags) -I/usr/local/opt/libyaml/include -I/usr/local/opt/readline/include -I/usr/local/opt/libxml2/include -I/usr/local/opt/libxslt/include -I/usr/local/opt/libksba/include -I/usr/local/opt/openssl/include -I/usr/local/opt/sqlite/include
+CXXFLAGS = $(CFLAGS) $(cxxflags)
+ldflags  = -L. -L/usr/local/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib 
+dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress -Wl,-flat_namespace -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_BASE_NAME = ruby
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby.1.9.1
+arch = x86_64-darwin12.3.0
+sitearch = $(arch)
+ruby_version = 1.9.1
+ruby = /Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir) /usr/local/opt/libyaml/lib /usr/local/opt/readline/lib /usr/local/opt/libxml2/lib /usr/local/opt/libxslt/lib /usr/local/opt/libksba/lib /usr/local/opt/openssl/lib /usr/local/opt/sqlite/lib
+LIBPATH =  -L. -L$(libdir) -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) -lnanomsg  -lpthread -ldl -lobjc 
+SRCS = init.c
+OBJS = init.o
+TARGET = nanomsg
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		@-$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	-$(Q)$(MAKEDIRS) $(@D)
+	$(INSTALL_PROG) $(DLLIB) $(@D)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	$(ECHO) installing default nanomsg libraries
+./.RUBYARCHDIR.time:
+	$(Q) $(MAKEDIRS) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .C .o
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+have_library 'nanomsg'
+
+create_makefile('nanomsg')

data/ext/init.c

@@ -0,0 +1,271 @@
+
+#include "ruby/ruby.h"
+
+#include <nanomsg/nn.h>
+#include <nanomsg/pair.h>
+
+static VALUE cNanoMsg;
+static VALUE cSocket; 
+static VALUE cPairSocket; 
+static VALUE ceSocketError;
+
+struct nmsg_socket {
+  int socket; 
+};
+
+
+static void
+sock_mark(void *ptr)
+{
+  // struct nmsg_socket *sock = ptr;
+}
+
+static void
+sock_free(void *ptr)
+{
+  struct nmsg_socket *sock = ptr;
+  xfree(sock);
+}
+
+static size_t
+sock_memsize(const void *ptr)
+{
+  return ptr ? sizeof(struct nmsg_socket) : 0;
+}
+
+static const rb_data_type_t socket_data_type = {
+  "nanomsg_socket",
+  {sock_mark, sock_free, sock_memsize,},
+};
+
+static struct nmsg_socket*
+sock_get_ptr(VALUE socket) 
+{
+  struct nmsg_socket *psock; 
+  TypedData_Get_Struct(socket, struct nmsg_socket, &socket_data_type, psock); 
+
+  return psock; 
+}
+
+static int 
+sock_get(VALUE socket)
+{
+  struct nmsg_socket *psock = sock_get_ptr(socket);
+  return psock->socket;
+}
+
+static VALUE
+sock_alloc(VALUE klass) 
+{
+  VALUE obj;
+  struct nmsg_socket *psock;
+
+  obj = TypedData_Make_Struct(klass, struct nmsg_socket, &socket_data_type, psock);
+  return obj;
+}
+
+static void
+sock_raise_error(int code)
+{
+  printf("socket error %d errno %d\n", code, errno);
+
+  // TODO allow querying of the errno at the very least.
+  switch (errno) {
+    case EBADF:
+      rb_raise(ceSocketError, "The provided socket is invalid.");
+      break; 
+    case ENOTSUP:
+      rb_raise(ceSocketError, "The operation is not supported by this socket type.");
+      break; 
+    case EFSM:
+      rb_raise(ceSocketError, "The operation cannot be performed on this socket at the moment because the socket is not in the appropriate state.");
+      break; 
+    case EAGAIN: 
+      rb_raise(ceSocketError, "Non-blocking mode was requested and the message cannot be sent at the moment.");
+      break; 
+    case EINTR: 
+      rb_raise(ceSocketError, "The operation was interrupted by delivery of a signal before the message was sent.");
+      break; 
+    case ETIMEDOUT: 
+      rb_raise(ceSocketError, "Individual socket types may define their own specific timeouts. If such timeout is hit, this error will be returned.");
+      break; 
+    case EAFNOSUPPORT: 
+      rb_raise(ceSocketError, "Specified address family is not supported.");
+      break; 
+    case EINVAL: 
+      rb_raise(ceSocketError, "Unknown protocol.");
+      break; 
+    case EMFILE: 
+      rb_raise(ceSocketError, "The limit on the total number of open SP sockets or OS limit for file descriptors has been reached.");
+      break; 
+    case ETERM: 
+      rb_raise(ceSocketError, "The library is terminating.");
+      break; 
+    default: 
+      rb_raise(ceSocketError, "Unknown error code %d", errno);
+  }
+}
+
+static VALUE
+sock_bind(VALUE socket, VALUE bind)
+{
+  int sock = sock_get(socket);
+  int endpoint; 
+
+  endpoint = nn_bind(sock, StringValueCStr(bind));
+  if (endpoint < 0) 
+    sock_raise_error(endpoint); 
+
+  // TODO do something with the endpoint, returning it in a class for example. 
+  return Qnil; 
+}
+
+static VALUE
+sock_connect(VALUE socket, VALUE connect)
+{
+  int sock = sock_get(socket);
+  int endpoint; 
+
+  endpoint = nn_connect(sock, StringValueCStr(connect));
+  if (endpoint < 0) 
+    sock_raise_error(endpoint); 
+
+  // TODO do something with the endpoint, returning it in a class for example. 
+  return Qnil; 
+}
+
+struct ioop {
+  int last_code; 
+  int sock; 
+  char* buffer; 
+  long len; 
+  int abort; 
+};
+
+static VALUE
+sock_send_no_gvl(void* data)
+{
+  struct ioop *pio = data; 
+
+  while (pio->last_code == EAGAIN && !pio->abort) {
+    pio->last_code = nn_send(pio->sock, pio->buffer, pio->len, NN_DONTWAIT /* flags */);
+
+    if (pio->last_code < 0)
+      pio->last_code = errno; 
+  }
+
+  return Qnil;
+}
+
+static void
+sock_send_abort(void* data)
+{
+  struct ioop *pio = data; 
+  pio->abort = Qtrue;  
+}
+
+static VALUE
+sock_send(VALUE socket, VALUE buffer)
+{
+  struct ioop io; 
+
+  io.sock = sock_get(socket);
+  io.last_code = EAGAIN; 
+  io.buffer = StringValuePtr(buffer);
+  io.len = RSTRING_LEN(buffer);
+  io.abort = Qfalse; 
+
+  rb_thread_blocking_region(sock_send_no_gvl, &io, sock_send_abort, &io);
+
+  // Unclear what to do in this situation, but we'll simply return nil, 
+  // leaving Ruby to handle the abort. 
+  if (io.abort) 
+    return Qnil; 
+
+  if (io.last_code < 0)
+    sock_raise_error(io.last_code);
+
+  return INT2NUM(io.last_code);
+}
+
+static VALUE
+sock_recv_no_gvl(void* data)
+{
+  struct ioop *pio = data; 
+
+  while (pio->last_code == EAGAIN && !pio->abort) {
+    pio->last_code = nn_recv(pio->sock, &pio->buffer, NN_MSG, NN_DONTWAIT /* flags */);
+
+    if (pio->last_code < 0)
+      pio->last_code = errno; 
+  }
+
+  return Qnil; 
+}
+
+static void
+sock_recv_abort(void* data) 
+{
+  struct ioop *pio = data; 
+
+  pio->abort = Qtrue; 
+}
+
+static VALUE
+sock_recv(VALUE socket)
+{
+  VALUE result; 
+  struct ioop io; 
+
+  io.sock = sock_get(socket);
+  io.buffer = (char*) 0; 
+  io.abort  = Qfalse; 
+  io.last_code = EAGAIN;
+
+  rb_thread_blocking_region(sock_recv_no_gvl, &io, sock_recv_abort, &io); 
+
+  if (io.abort) 
+    return Qnil; 
+
+  if (io.last_code < 0)
+    sock_raise_error(io.last_code);
+
+  result = rb_str_new(io.buffer, io.last_code);
+  nn_freemsg(io.buffer); io.buffer = (char*) 0;
+
+  return result;
+}
+
+static VALUE 
+pair_sock_init(VALUE socket)
+{
+  struct nmsg_socket *psock = sock_get_ptr(socket); 
+
+  psock->socket = nn_socket(AF_SP, NN_PAIR);
+  if (psock->socket < 0) {
+    sock_raise_error(psock->socket);
+  }
+
+  return socket; 
+}
+
+void
+Init_nanomsg(void)
+{
+  printf("loading nanomsg extension\n");
+
+  cNanoMsg = rb_define_module("NanoMsg"); 
+  cSocket = rb_define_class_under(cNanoMsg, "Socket", rb_cObject);
+  cPairSocket = rb_define_class_under(cNanoMsg, "PairSocket", cSocket);
+
+  ceSocketError = rb_define_class_under(cNanoMsg, "SocketError", rb_eIOError);
+
+  rb_define_method(cSocket, "bind", sock_bind, 1);
+  rb_define_method(cSocket, "connect", sock_connect, 1);
+  rb_define_method(cSocket, "send", sock_send, 1);
+  rb_define_method(cSocket, "recv", sock_recv, 0);
+
+  rb_define_alloc_func(cPairSocket, sock_alloc);
+  rb_define_method(cPairSocket, "initialize", pair_sock_init, 0);
+}
+

data/ext/mkmf.log

@@ -0,0 +1,22 @@
+have_library: checking for main() in -lnanomsg... -------------------- yes
+
+"/usr/local/bin/gcc-4.2 -o conftest -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1/x86_64-darwin12.3.0 -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1/ruby/backward -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1 -I. -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE   -I/usr/local/opt/libyaml/include -I/usr/local/opt/readline/include -I/usr/local/opt/libxml2/include -I/usr/local/opt/libxslt/include -I/usr/local/opt/libksba/include -I/usr/local/opt/openssl/include -I/usr/local/opt/sqlite/include  -O3 -ggdb -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration  -fno-common -pipe conftest.c  -L. -L/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib -L. -L/usr/local/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib      -lruby.1.9.1  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main() {return 0;}
+/* end */
+
+"/usr/local/bin/gcc-4.2 -o conftest -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1/x86_64-darwin12.3.0 -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1/ruby/backward -I/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/include/ruby-1.9.1 -I. -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE   -I/usr/local/opt/libyaml/include -I/usr/local/opt/readline/include -I/usr/local/opt/libxml2/include -I/usr/local/opt/libxslt/include -I/usr/local/opt/libksba/include -I/usr/local/opt/openssl/include -I/usr/local/opt/sqlite/include  -O3 -ggdb -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration  -fno-common -pipe conftest.c  -L. -L/Users/kschiess/.rvm/rubies/ruby-1.9.3-p392-turbo/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib -L. -L/usr/local/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libxml2/lib -L/usr/local/opt/libxslt/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/sqlite/lib      -lruby.1.9.1 -lnanomsg  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: /*top*/
+4: int main() {return 0;}
+5: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+

data/lib/nanomsg.rb

@@ -0,0 +1,10 @@
+
+$:.unshift File.dirname(__FILE__) + "/../ext"
+require 'nanomsg.bundle'
+
+module NanoMsg
+  class Socket
+  end
+end
+
+require 'nanomsg/pair_socket'

data/lib/nanomsg/pair_socket.rb

@@ -0,0 +1,6 @@
+
+
+module NanoMsg
+  class PairSocket < Socket
+  end
+end

data/spec/lib/nanomsg/pair_socket_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe NanoMsg::PairSocket do
+  let(:sock1) { NanoMsg::PairSocket.new }
+  let(:sock2) { NanoMsg::PairSocket.new }
+
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      it 'allows simple send/recv' do
+        sock1.bind(tbind)
+        sock2.connect(tbind)
+
+        sock1.send('1234').should == 4
+        sock2.recv.should == '1234'
+
+        sock2.send('5678').should == 4
+        sock1.recv.should == '5678'    
+      end      
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/test.ipc"
+  examples_for_transport "tcp://127.0.0.1:5555"
+  examples_for_transport "inproc://test"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+
+
+$:.unshift File.dirname(__FILE__) + "/../ext"
+require 'nanomsg'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: nanomsg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Kaspar Schiess
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-22 00:00:00.000000000 Z
+dependencies: []
+description: ! "    nanomsg provides idiomatic Ruby bindings to the C library nanomsg
+  (nanomsg.org)\n\n    nanomsg library is a high-performance implementation of several
+  \"scalability \n    protocols\". Scalability protocol's job is to define how multiple
+  applications \n    communicate to form a single distributed application. Implementation
+  of \n    following scalability protocols is available at the moment:\n\n      PAIR
+  - simple one-to-one communication\n      BUS - simple many-to-many communication\n
+  \     REQREP - allows to build clusters of stateless services to process user requests\n
+  \     PUBSUB - distributes messages to large sets of interested subscribers\n      FANIN
+  - aggregates messages from multiple sources\n      FANOUT - load balances messages
+  among many destinations\n      SURVEY - allows to query state of multiple applications
+  in a single go\n\n    WARNING: nanomsg is still in alpha stage!\n"
+email: kaspar.schiess@absurd.li
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README
+files:
+- HISTORY
+- LICENSE
+- README
+- lib/nanomsg/pair_socket.rb
+- lib/nanomsg.rb
+- ext/extconf.rb
+- ext/init.c
+- ext/init.o
+- ext/Makefile
+- ext/mkmf.log
+- ext/nanomsg.bundle
+- ext/nanomsg.o
+- examples/pair.rb
+- examples/roundtrip_latency.rb
+- spec/lib/nanomsg/pair_socket_spec.rb
+- spec/spec_helper.rb
+homepage: https://bitbucket.org/kschiess/nanomsg
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README
+require_paths:
+- lib
+- ext
+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.25
+signing_key: 
+specification_version: 3
+summary: Ruby binding for nanomsg. nanomsg library is a high-performance implementation
+  of several "scalability protocols".
+test_files: []
+has_rdoc: