nanomsg 0.1.0 → 0.2.0

data/HISTORY

@@ -0,0 +1,16 @@
+
+= 0.2 /
+
+  * Adds REQ/REP socket type (ReqSocket, RepSocket).
+  * Adds PUB/SUB socket type. 
+  * Adds SURVEYOR/RESPONDENT socket types. (SurveySocket, RespondSocket)
+  * Adds PUSH/PULL socket types. (PushSocket, PullSocket)
+  * Adds BUS socket type. (BusSocket)
+  * There's an experimental API for devices (.run_loopback, .run_device). 
+    Devices block a Ruby thread until .terminate is called.
+  * Exceptions raised are now subclasses of NanoMsg::Errno
+  * Added NanoMsg.terminate, calls nn_term. 
+
+= 0.1 / 22Aug2013
+
+  * Initial release, only PAIR sockets supported. 

data/README

@@ -1,7 +1,7 @@
 
 TLDR
 
-An idiomatic nanomsg wrapper for Ruby. (http://nanomsg.org/) 
+An idiomatic nanomsg wrapper for Ruby. 
 
 NANOMSG
 
@@ -25,6 +25,11 @@ stack. At the moment, nanomsg library supports following transports:
  * IPC - transport between processes on a single machine
  * TCP - network transport via TCP
 
+DOCUMENTATION
+
+Check out the examples folder of the project. See http://nanomsg.org/ for more 
+documentation. 
+
 SYNOPSIS
 
   require 'nanomsg'
@@ -37,11 +42,10 @@ SYNOPSIS
 
 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. 
+Very early alpha, not much testing has been done. All socket types and devices
+should work. 
 
 LICENSE
 
-MIT, 2013, Kaspar Schiess
+See file LICENSE, Copyright (c) 2013 Kaspar Schiess
 

data/examples/bus.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'nanomsg'
+include NanoMsg
+
+buses = 3.times.map { BusSocket.new }
+
+a = 'tcp://127.0.0.1:5432'
+b = 'tcp://127.0.0.1:5433'
+
+one, two, three = *buses
+
+one.bind a
+
+two.bind b
+two.connect a
+
+three.connect a 
+three.connect b
+
+sleep 0.1
+
+one.send 'A'
+p two.recv
+p three.recv
+
+two.send 'B'
+p one.recv
+p three.recv
+
+three.send 'C'
+p one.recv
+p two.recv

data/examples/bus_device.rb

@@ -0,0 +1,39 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'nanomsg'
+include NanoMsg
+
+a = 'tcp://127.0.0.1:5432'
+b = 'tcp://127.0.0.1:5433'
+c = 'tcp://127.0.0.1:5434'
+
+one, two, three = 3.times.map { BusSocket.new }
+four, five, six = 3.times.map { BusSocket.new(AF_SP_RAW) }
+
+one.bind a
+two.bind b
+three.bind c
+
+# one -> four -> four -> two
+four.connect a
+four.connect b
+Thread.start do
+  NanoMsg.run_loopback(four)
+end.abort_on_exception = true
+
+# one -> five -> six -> three
+five.connect a
+six.connect c
+Thread.start do
+  NanoMsg.run_device(five, six)
+end.abort_on_exception = true
+
+sleep 0.2
+one.send 'A'
+
+# Gets sent to three, which forwards it to two. 
+puts two.recv
+
+# Gets sent to five, which forwards it through six to three.
+puts three.recv
+
+NanoMsg.terminate

data/examples/pair.rb

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

data/ext/Makefile

@@ -117,8 +117,8 @@ extout_prefix =
 target_prefix = 
 LOCAL_LIBS = 
 LIBS = $(LIBRUBYARG_SHARED) -lnanomsg  -lpthread -ldl -lobjc 
-SRCS = init.c
-OBJS = init.o
+SRCS = constants.c init.c
+OBJS = constants.o init.o
 TARGET = nanomsg
 DLLIB = $(TARGET).bundle
 EXTSTATIC = 

data/ext/constants.c

@@ -0,0 +1,89 @@
+
+#include "ruby/ruby.h"
+#include "ruby/st.h"
+
+#include <nanomsg/nn.h>
+
+static st_table *syserr_tbl;
+
+static VALUE
+errno_initialize(VALUE self)
+{
+  VALUE error; 
+  VALUE klass = rb_obj_class(self);
+
+  const char *explanation; 
+  VALUE message; 
+
+  error = rb_const_get(klass, rb_intern("Errno"));
+  explanation = nn_strerror(FIX2INT(error));
+
+  message = rb_str_new(explanation, strlen(explanation));
+  rb_call_super(1, &message);
+
+  rb_iv_set(self, "errno", error);
+
+  return self;
+}
+
+static VALUE
+errno_errno(VALUE self)
+{
+    return rb_attr_get(self, rb_intern("errno"));
+}
+
+static VALUE
+err_add(VALUE module, int n, const char *name)
+{
+  st_data_t error;
+
+  if (!st_lookup(syserr_tbl, n, &error)) {
+    error = rb_define_class_under(module, name, rb_eStandardError);
+
+    rb_define_const(error, "Errno", INT2NUM(n));
+    rb_define_method(error, "initialize", errno_initialize, 0);
+    rb_define_method(error, "errno", errno_errno, 0);
+
+    st_add_direct(syserr_tbl, n, error);
+  }
+
+  return error;
+}
+
+VALUE
+errno_lookup(int n)
+{
+  st_data_t error;
+
+  if (!st_lookup(syserr_tbl, n, &error)) 
+    return Qnil; 
+
+  return error;
+}
+
+void 
+Init_constants(VALUE module)
+{
+  VALUE mErrno; 
+  int i, value; 
+
+  syserr_tbl = st_init_numtable();
+
+  mErrno = rb_define_module_under(module, "Errno");
+
+  // Define all constants that nanomsg knows about: 
+  for (i = 0; ; ++i) {
+    const char* name = nn_symbol (i, &value);
+    if (name == NULL) break;
+
+    // I see no point in declaring values other than those starting with NN_: 
+    if (strncmp(name, "NN_", 3) == 0) 
+      rb_const_set(module, rb_intern(name), INT2NUM(value));
+
+    if (strncmp(name, "AF_", 3) == 0) 
+      rb_const_set(module, rb_intern(name), INT2NUM(value));
+
+    if (strncmp(name, "E", 1) == 0) 
+      err_add(mErrno, value, name);
+  }
+}

data/ext/constants.h

@@ -0,0 +1,9 @@
+
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+
+void Init_constants(VALUE module);
+VALUE errno_lookup(int n);
+
+
+#endif

data/ext/init.c

@@ -2,11 +2,34 @@
 #include "ruby/ruby.h"
 
 #include <nanomsg/nn.h>
+#include <nanomsg/reqrep.h>
 #include <nanomsg/pair.h>
+#include <nanomsg/pubsub.h>
+#include <nanomsg/survey.h>
+#include <nanomsg/pipeline.h>
+#include <nanomsg/bus.h>
 
-static VALUE cNanoMsg;
+#include "constants.h"
+
+static VALUE mNanoMsg;
 static VALUE cSocket; 
+
 static VALUE cPairSocket; 
+
+static VALUE cReqSocket;
+static VALUE cRepSocket;
+
+static VALUE cPubSocket;
+static VALUE cSubSocket;
+
+static VALUE cSurveySocket;
+static VALUE cRespondSocket;
+
+static VALUE cPushSocket;
+static VALUE cPullSocket;
+
+static VALUE cBusSocket;
+
 static VALUE ceSocketError;
 
 struct nmsg_socket {
@@ -65,46 +88,18 @@ sock_alloc(VALUE klass)
 }
 
 static void
-sock_raise_error(int code)
+sock_raise_error(int nn_errno)
 {
-  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);
-  }
+  VALUE error = errno_lookup(nn_errno);
+
+  if (error != Qnil) {
+    VALUE exc = rb_class_new_instance(0, NULL, error);
+    rb_exc_raise(exc);
+  } 
+
+  rb_raise(ceSocketError, "General failure, no such error code %d found.", nn_errno);
 }
+#define RAISE_SOCK_ERROR { sock_raise_error(nn_errno()); }
 
 static VALUE
 sock_bind(VALUE socket, VALUE bind)
@@ -114,7 +109,7 @@ sock_bind(VALUE socket, VALUE bind)
 
   endpoint = nn_bind(sock, StringValueCStr(bind));
   if (endpoint < 0) 
-    sock_raise_error(endpoint); 
+    RAISE_SOCK_ERROR; 
 
   // TODO do something with the endpoint, returning it in a class for example. 
   return Qnil; 
@@ -128,14 +123,25 @@ sock_connect(VALUE socket, VALUE connect)
 
   endpoint = nn_connect(sock, StringValueCStr(connect));
   if (endpoint < 0) 
-    sock_raise_error(endpoint); 
+    RAISE_SOCK_ERROR; 
 
   // TODO do something with the endpoint, returning it in a class for example. 
   return Qnil; 
 }
 
+static void
+sock_init(VALUE socket, int domain, int protocol)
+{
+  struct nmsg_socket *psock = sock_get_ptr(socket); 
+
+  psock->socket = nn_socket(domain, protocol);
+  if (psock->socket < 0)
+    RAISE_SOCK_ERROR;
+}
+
 struct ioop {
-  int last_code; 
+  int nn_errno; 
+  int return_code; 
   int sock; 
   char* buffer; 
   long len; 
@@ -147,11 +153,18 @@ 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 */);
+  // TODO This is buggy. I cannot make the difference between 
+  // 'socket gone away' (=EAGAIN) and 'socket busy' (=EAGAIN). So I err on the
+  // side of 'socket busy' and do not raise the error. As a consequence, we'll
+  // get stuck in an endless loop when the socket is just not answering. 
+
+  while (pio->nn_errno == EAGAIN && !pio->abort) {
+    pio->return_code = nn_send(pio->sock, pio->buffer, pio->len, NN_DONTWAIT /* flags */);
 
-    if (pio->last_code < 0)
-      pio->last_code = errno; 
+    if (pio->return_code < 0)
+      pio->nn_errno = nn_errno(); 
+    else
+      break;
   }
 
   return Qnil;
@@ -170,7 +183,7 @@ sock_send(VALUE socket, VALUE buffer)
   struct ioop io; 
 
   io.sock = sock_get(socket);
-  io.last_code = EAGAIN; 
+  io.nn_errno = EAGAIN;
   io.buffer = StringValuePtr(buffer);
   io.len = RSTRING_LEN(buffer);
   io.abort = Qfalse; 
@@ -182,10 +195,10 @@ sock_send(VALUE socket, VALUE buffer)
   if (io.abort) 
     return Qnil; 
 
-  if (io.last_code < 0)
-    sock_raise_error(io.last_code);
+  if (io.return_code < 0)
+    sock_raise_error(io.nn_errno);
 
-  return INT2NUM(io.last_code);
+  return INT2NUM(io.return_code);
 }
 
 static VALUE
@@ -193,11 +206,18 @@ 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 */);
+  // TODO This is buggy. I cannot make the difference between 
+  // 'socket gone away' (=EAGAIN) and 'socket busy' (=EAGAIN). So I err on the
+  // side of 'socket busy' and do not raise the error. As a consequence, we'll
+  // get stuck in an endless loop when the socket is just not answering. 
+
+  while (pio->nn_errno == EAGAIN && !pio->abort) {
+    pio->return_code = nn_recv(pio->sock, &pio->buffer, NN_MSG, NN_DONTWAIT /* flags */);
 
-    if (pio->last_code < 0)
-      pio->last_code = errno; 
+    if (pio->return_code < 0)
+      pio->nn_errno = nn_errno(); 
+    else
+      break;
   }
 
   return Qnil; 
@@ -220,52 +240,231 @@ sock_recv(VALUE socket)
   io.sock = sock_get(socket);
   io.buffer = (char*) 0; 
   io.abort  = Qfalse; 
-  io.last_code = EAGAIN;
+  io.nn_errno = 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);
+  if (io.return_code < 0)
+    sock_raise_error(io.nn_errno);
 
-  result = rb_str_new(io.buffer, io.last_code);
+  result = rb_str_new(io.buffer, io.return_code);
   nn_freemsg(io.buffer); io.buffer = (char*) 0;
 
   return result;
 }
 
-static VALUE 
-pair_sock_init(VALUE socket)
+static VALUE
+sock_close_no_gvl(void* data)
 {
-  struct nmsg_socket *psock = sock_get_ptr(socket); 
+  struct ioop *pio = (struct ioop*) data; 
 
-  psock->socket = nn_socket(AF_SP, NN_PAIR);
-  if (psock->socket < 0) {
-    sock_raise_error(psock->socket);
-  }
+  pio->return_code = nn_close(pio->sock);
+  if (pio->return_code < 0)
+    pio->nn_errno = nn_errno();
 
-  return socket; 
+  return Qnil;
+}
+
+static VALUE
+sock_close(VALUE socket)
+{
+  struct ioop io; 
+
+  io.sock = sock_get(socket);
+
+  // I've no idea on how to abort a close (which may block for NN_LINGER 
+  // seconds), so we'll be uninterruptible. 
+  rb_thread_blocking_region(sock_close_no_gvl, &io, NULL, NULL);
+
+  if (io.return_code < 0)
+    sock_raise_error(io.nn_errno);
+
+  return Qnil;
+}
+
+#define SOCK_INIT_FUNC(name, type) \
+static VALUE \
+name(int argc, VALUE *argv, VALUE self) \
+{ \
+  VALUE domain; \
+  \
+  rb_scan_args(argc, argv, "01", &domain); \
+  if (NIL_P(domain)) \
+    sock_init(self, AF_SP, (type)); \
+  else \
+    sock_init(self, FIX2INT(domain), (type)); \
+  \
+  return self; \
+}
+
+SOCK_INIT_FUNC(pair_sock_init, NN_PAIR);
+SOCK_INIT_FUNC(req_sock_init, NN_REQ);
+SOCK_INIT_FUNC(rep_sock_init, NN_REP);
+SOCK_INIT_FUNC(pub_sock_init, NN_PUB);
+SOCK_INIT_FUNC(sub_sock_init, NN_SUB);
+SOCK_INIT_FUNC(srvy_sock_init, NN_SURVEYOR);
+SOCK_INIT_FUNC(resp_sock_init, NN_RESPONDENT);
+SOCK_INIT_FUNC(push_sock_init, NN_PUSH);
+SOCK_INIT_FUNC(pull_sock_init, NN_PULL);
+SOCK_INIT_FUNC(bus_sock_init, NN_BUS);
+
+static VALUE
+sub_sock_subscribe(VALUE socket, VALUE channel)
+{
+  int sock = sock_get(socket);
+  int err;
+
+  err = nn_setsockopt(
+    sock, NN_SUB, NN_SUB_SUBSCRIBE,
+    StringValuePtr(channel),
+    RSTRING_LEN(channel)
+  );
+  if (err < 0)
+    RAISE_SOCK_ERROR;
+
+  return socket;
+}
+
+static VALUE
+srvy_set_deadline(VALUE self, VALUE deadline)
+{
+  int sock = sock_get(self);
+  VALUE miliseconds = rb_funcall(deadline, rb_intern("*"), 1, INT2NUM(1000));
+  int timeout = FIX2INT(miliseconds);
+  int err; 
+
+  err = nn_setsockopt(sock, NN_SURVEYOR, NN_SURVEYOR_DEADLINE, &timeout, sizeof(int));
+  if (err < 0)
+    RAISE_SOCK_ERROR;
+
+  return deadline; 
+}
+
+static VALUE
+srvy_get_deadline(VALUE self)
+{
+  int sock = sock_get(self);
+  int deadline; 
+  size_t size = sizeof(int);
+
+  int err; 
+
+  err = nn_getsockopt(sock, NN_SURVEYOR, NN_SURVEYOR_DEADLINE, &deadline, &size);
+  if (err < 0)
+    RAISE_SOCK_ERROR; 
+
+  return rb_funcall(INT2NUM(deadline), rb_intern("/"), 1, rb_float_new(1000));  
+}
+
+static VALUE
+nanomsg_terminate(VALUE self)
+{
+  nn_term(); 
+
+  return Qnil; 
+}
+
+struct device_op {
+  int sa, sb; 
+  int err; 
+};
+
+static VALUE
+nanomsg_run_device_no_gvl(void* data)
+{
+  struct device_op *pop = (struct device_op*) data;
+
+  pop->err = nn_device(pop->sa, pop->sb);
+
+  return Qnil; 
+}
+
+static VALUE
+nanomsg_run_device(VALUE self, VALUE a, VALUE b)
+{
+  struct device_op dop; 
+
+  dop.sa = sock_get(a);
+  dop.sb = sock_get(b);
+
+  rb_thread_blocking_region(nanomsg_run_device_no_gvl, &dop, NULL, NULL);
+  if (dop.err < 0)
+    RAISE_SOCK_ERROR;
+
+  return Qnil; 
+}
+
+static VALUE
+nanomsg_run_loopback(VALUE self, VALUE a)
+{
+  struct device_op dop; 
+
+  dop.sa = sock_get(a);
+  dop.sb = -1;          // invalid socket, see documentation
+
+  rb_thread_blocking_region(nanomsg_run_device_no_gvl, &dop, NULL, NULL);
+  if (dop.err < 0)
+    RAISE_SOCK_ERROR;
+
+  return Qnil; 
 }
 
 void
 Init_nanomsg(void)
 {
-  printf("loading nanomsg extension\n");
+  mNanoMsg = rb_define_module("NanoMsg"); 
+  cSocket = rb_define_class_under(mNanoMsg, "Socket", rb_cObject);
+  cPairSocket = rb_define_class_under(mNanoMsg, "PairSocket", cSocket);
+  
+  cReqSocket = rb_define_class_under(mNanoMsg, "ReqSocket", cSocket);
+  cRepSocket = rb_define_class_under(mNanoMsg, "RepSocket", cSocket);
+  
+  cPubSocket = rb_define_class_under(mNanoMsg, "PubSocket", cSocket);
+  cSubSocket = rb_define_class_under(mNanoMsg, "SubSocket", cSocket);
+
+  cSurveySocket = rb_define_class_under(mNanoMsg, "SurveySocket", cSocket);
+  cRespondSocket = rb_define_class_under(mNanoMsg, "RespondSocket", cSocket);
+
+  cPushSocket = rb_define_class_under(mNanoMsg, "PushSocket", cSocket);
+  cPullSocket = rb_define_class_under(mNanoMsg, "PullSocket", cSocket);
+
+  cBusSocket = rb_define_class_under(mNanoMsg, "BusSocket", cSocket);
 
-  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(mNanoMsg, "SocketError", rb_eIOError);
 
-  ceSocketError = rb_define_class_under(cNanoMsg, "SocketError", rb_eIOError);
+  rb_define_singleton_method(mNanoMsg, "terminate", nanomsg_terminate, 0);
+  rb_define_singleton_method(mNanoMsg, "run_device", nanomsg_run_device, 2);
+  rb_define_singleton_method(mNanoMsg, "run_loopback", nanomsg_run_loopback, 1);
 
+  rb_define_alloc_func(cSocket, sock_alloc);
   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_method(cSocket, "close", sock_close, 0);
+
+  rb_define_method(cPairSocket, "initialize", pair_sock_init, -1);
+
+  rb_define_method(cReqSocket, "initialize", req_sock_init, -1);
+  rb_define_method(cRepSocket, "initialize", rep_sock_init, -1);
+
+  rb_define_method(cPubSocket, "initialize", pub_sock_init, -1);
+  rb_define_method(cSubSocket, "initialize", sub_sock_init, -1);
+  rb_define_method(cSubSocket, "subscribe", sub_sock_subscribe, 1);
+
+  rb_define_method(cSurveySocket, "initialize", srvy_sock_init, -1);
+  rb_define_method(cSurveySocket, "deadline=", srvy_set_deadline, 1);
+  rb_define_method(cSurveySocket, "deadline", srvy_get_deadline, 0);
+  rb_define_method(cRespondSocket, "initialize", resp_sock_init, -1);
+
+  rb_define_method(cPushSocket, "initialize", push_sock_init, -1);
+  rb_define_method(cPullSocket, "initialize", pull_sock_init, -1);
+
+  rb_define_method(cBusSocket, "initialize", bus_sock_init, -1);
 
-  rb_define_alloc_func(cPairSocket, sock_alloc);
-  rb_define_method(cPairSocket, "initialize", pair_sock_init, 0);
+  Init_constants(mNanoMsg);
 }
 

data/spec/lib/nanomsg/bus_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'BUS sockets' do
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      describe "using a broker topology" do
+        let!(:a) { NanoMsg::BusSocket.new }
+        let!(:b) { NanoMsg::BusSocket.new }
+
+        after(:each) do
+          [a, b].each(&:close)
+        end
+
+        it 'forwards messages to everyone (except the producer)' do
+          a.bind(tbind)
+          b.connect(tbind)
+          sleep 0.01
+
+          a.send 'test'
+          b.recv.should == 'test'
+
+          b.send 'ing'
+          a.recv.should == 'ing'
+        end
+      end
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/bus1.ipc"
+  examples_for_transport "tcp://127.0.0.1:5558"
+  examples_for_transport "inproc://bus1"
+end

data/spec/lib/nanomsg/device_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'timeout'
+
+describe 'Devices' do
+  describe "connecting two BUSes" do
+    let(:a) { NanoMsg::BusSocket.new(NanoMsg::AF_SP_RAW) }
+    let(:b) { NanoMsg::BusSocket.new(NanoMsg::AF_SP_RAW) }
+    let(:c) { NanoMsg::BusSocket.new }
+    let(:d) { NanoMsg::BusSocket.new }
+
+    let(:adr1) { 'inproc://a' }
+    let(:adr2) { 'inproc://b' }
+
+    before(:each) do
+      a.bind(adr1)
+      b.bind(adr2)
+
+      c.connect adr1
+      d.connect adr2
+    end
+
+    let!(:thread) {
+      Thread.start do
+        begin
+          NanoMsg.run_device(a, b)
+        rescue NanoMsg::Errno::ETERM
+          # Ignore, spec shutdown
+        end
+      end
+    }
+    
+    it "forwards messages" do
+      sleep 0.01
+      c.send 'test'
+      timeout(1) do
+        d.recv.should == 'test'
+      end
+    end
+  end
+end

data/spec/lib/nanomsg/pair_socket_spec.rb

@@ -4,6 +4,11 @@ describe NanoMsg::PairSocket do
   let(:sock1) { NanoMsg::PairSocket.new }
   let(:sock2) { NanoMsg::PairSocket.new }
 
+  after(:each) do
+    sock1.close
+    sock2.close
+  end
+
   def self.examples_for_transport tbind
     name = tbind.split('://').first
     

data/spec/lib/nanomsg/pub_sub_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+require 'timeout'
+
+describe 'PUB/SUB sockets' do
+  describe 'PUB socket' do
+    it 'has no #recv method'
+  end
+  describe 'SUB socket' do
+    it 'has no #send method'
+    it 'allows subscribing to channels'
+    it 'allows unsubscribing to channels'
+  end
+
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      let(:pub) { NanoMsg::PubSocket.new }
+      let(:sub1) { NanoMsg::SubSocket.new }
+      let(:sub2) { NanoMsg::SubSocket.new }
+
+      after(:each) {
+        pub.close
+        sub1.close
+        sub2.close
+      }
+
+      around(:each) { |example| 
+        timeout(1) { example.run }}
+
+      it 'allows simple pub/sub' do
+        pub.bind(tbind)
+        sub1.connect(tbind)
+        sub2.connect(tbind)
+
+        sub1.subscribe 'foo'
+        sub2.subscribe 'foo'
+
+        sub1.subscribe 'bar'
+        sleep 0.1
+
+        pub.send 'foo1234'
+        sub1.recv.should == 'foo1234'
+        sub2.recv.should == 'foo1234'
+
+        pub.send 'bar4567'
+        pub.send 'foo9999'
+        sub1.recv.should == 'bar4567'
+        sub2.recv.should == 'foo9999'
+      end      
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/pubsub.ipc"
+  examples_for_transport "tcp://127.0.0.1:5557"
+  examples_for_transport "inproc://pubsub"
+end

data/spec/lib/nanomsg/push_pull_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe 'PUSH/PULL pipeline sockets' do
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      describe 'fanout' do
+        let(:producer)  { NanoMsg::PushSocket.new }
+        let(:consumer1) { NanoMsg::PullSocket.new }
+        let(:consumer2) { NanoMsg::PullSocket.new }
+
+        after(:each) do
+          [producer, consumer2, consumer1].each(&:close)
+        end
+
+        it 'distributes load evenly' do
+          producer.bind(tbind)
+          consumer1.connect(tbind)          
+          consumer2.connect(tbind)
+          sleep 0.1
+
+          100.times do |i|
+            producer.send i.to_s
+          end
+
+          n = [0, 0]
+          50.times do
+            [consumer1, consumer2].each_with_index do |consumer, idx|
+              v = consumer.recv.to_i
+              n[idx] += 1
+            end
+          end
+
+          # This is about a 5% level of the binominal distribution
+          (n.first - n.last).abs.should < 10
+        end
+      end
+      describe 'fanin' do
+        let(:producer1) { NanoMsg::PushSocket.new }
+        let(:producer2) { NanoMsg::PushSocket.new }
+        let(:consumer) { NanoMsg::PullSocket.new }
+
+        after(:each) do
+          [producer1, producer2, consumer].each(&:close)
+        end
+
+        it 'consumes results fairly' do
+          consumer.bind(tbind)
+          producer1.connect(tbind)
+          producer2.connect(tbind)
+
+          100.times do |i|
+            producer = [producer1, producer2][i%2]
+
+            producer.send i.to_s
+          end
+
+          100.times do |i|
+            consumer.recv.to_i.should == i
+          end
+        end
+      end
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/reqrep.ipc"
+  examples_for_transport "tcp://127.0.0.1:5555"
+  examples_for_transport "inproc://reqrep"
+end

data/spec/lib/nanomsg/req_rep_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'REQ/REP sockets' do
+  let(:req) { NanoMsg::ReqSocket.new }
+  let(:rep) { NanoMsg::RepSocket.new }
+
+  after(:each) do
+    req.close
+    rep.close
+  end
+
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      it 'allows simple req/rep' do
+        req.bind(tbind)
+        rep.connect(tbind)
+
+        req.send 'req1'
+
+        rep.recv.should == 'req1'
+        rep.send 'rep1'
+        
+        req.recv.should == 'rep1'
+      end      
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/reqrep.ipc"
+  examples_for_transport "tcp://127.0.0.1:5555"
+  examples_for_transport "inproc://reqrep"
+end

data/spec/lib/nanomsg/survey_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'SURVEY sockets' do
+  let(:surveyor)  { NanoMsg::SurveySocket.new }
+  let(:resp1)     { NanoMsg::RespondSocket.new }
+  let(:resp2)     { NanoMsg::RespondSocket.new }
+
+  after(:each) do
+    [surveyor, resp2, resp1].each(&:close)
+  end
+
+  def self.examples_for_transport tbind
+    name = tbind.split('://').first
+    
+    describe "transport #{name}" do
+      it 'allows simple surveys' do
+        surveyor.deadline.should == 1 # default: 1 second
+        surveyor.deadline = 0.1 # 100ms
+        surveyor.deadline.should == 0.1
+
+        surveyor.bind(tbind)
+
+        resp1.connect(tbind)
+        resp2.connect(tbind)
+
+        sleep 0.1
+        surveyor.send 'u there?'
+        resp1.recv.should == 'u there?'
+        resp2.recv.should == 'u there?'
+
+        resp1.send 'KTHNXBYE'
+        surveyor.recv.should == 'KTHNXBYE'
+
+        # nanomsg/tests/survey.c says this should be EFSM, the documentation 
+        # says it should be ETIMEDOUT. Reality wins. 
+        begin
+          surveyor.recv
+        rescue NanoMsg::Errno::EFSM
+        end
+      end      
+    end
+  end
+
+  examples_for_transport "ipc:///tmp/reqrep.ipc"
+  examples_for_transport "tcp://127.0.0.1:5555"
+  examples_for_transport "inproc://reqrep"
+end

data/spec/lib/nanomsg_spec.rb

@@ -0,0 +1,11 @@
+
+require 'spec_helper'
+
+describe NanoMsg do
+  it 'has NN_LINGER constant set to an integer value' do
+    NanoMsg::NN_LINGER.should >= 0
+  end  
+  it 'allows shutting down using nn_term' do
+    NanoMsg.should respond_to(:terminate)
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,10 @@
 
 
 $:.unshift File.dirname(__FILE__) + "/../ext"
-require 'nanomsg'
+require 'nanomsg'
+
+RSpec.configure do |rspec|
+  rspec.after(:suite) {
+    NanoMsg.terminate
+  }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nanomsg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-22 00:00:00.000000000 Z
+date: 2013-08-26 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
+description: ! "    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"
+  applications \n    communicate to form a single distributed application. WARNING:
+  nanomsg is still in alpha stage!\n"
 email: kaspar.schiess@absurd.li
 executables: []
 extensions:
@@ -34,16 +27,26 @@ files:
 - README
 - lib/nanomsg/pair_socket.rb
 - lib/nanomsg.rb
+- ext/constants.c
+- ext/constants.h
+- ext/constants.o
 - ext/extconf.rb
 - ext/init.c
 - ext/init.o
 - ext/Makefile
-- ext/mkmf.log
 - ext/nanomsg.bundle
-- ext/nanomsg.o
+- examples/bus.rb
+- examples/bus_device.rb
 - examples/pair.rb
 - examples/roundtrip_latency.rb
+- spec/lib/nanomsg/bus_spec.rb
+- spec/lib/nanomsg/device_spec.rb
 - spec/lib/nanomsg/pair_socket_spec.rb
+- spec/lib/nanomsg/pub_sub_spec.rb
+- spec/lib/nanomsg/push_pull_spec.rb
+- spec/lib/nanomsg/req_rep_spec.rb
+- spec/lib/nanomsg/survey_spec.rb
+- spec/lib/nanomsg_spec.rb
 - spec/spec_helper.rb
 homepage: https://bitbucket.org/kschiess/nanomsg
 licenses: []

data/ext/mkmf.log

@@ -1,22 +0,0 @@
-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 */
-
---------------------
-