nng 0.1.0.alpha.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d81bda694b3cd8462da25c8164aa36f2f3deef9c193137676685dfcca23b8f
-  data.tar.gz: cc226d519edf60e5d6c11f07cd712a256f5a2bb38ff173b0d2d35afd308189da
+  metadata.gz: '059fd5f5fe9ba741fbbbfc57ead871921b2ead9eb5fb5f9ddce30b99cbcb8e8f'
+  data.tar.gz: 6cfb7d0644296c8d2c99f50c7626717139d40a24a59e70c87bb81a29a9db6845
 SHA512:
-  metadata.gz: 46a65accea3794de74022cb7d053a80f508089dd10e920e82ba3ff18a02013e21c66010c85bdcc536a07183cf11464a84a0d47e728c9c6d0720f2ad280344e37
-  data.tar.gz: 85a52e9c5814801b73a2ec7ea8bcba92a1f5d053f3c04dcc56c45c9d7bd8279532fad11b080109d5a08895e51bc7c32e685d70dd0bf40ff86ab717bc31ae2070
+  metadata.gz: be9d6c590d943a1396cbe3e3c3cb7b6086d52633fe4cf23e03c7c8664d051c6d8183bea23cfb7daf4121df2cbb86589600f4756b6f3c859bd93c946820a33d85
+  data.tar.gz: 4417ea199f3eb0bd1130cd92c375986b5e27ab72c2a68c1cfb7204740fdb3274882e3910bebf99c2b983f4bd803b3e3476e401ea8c57faa12415a3a093f3c7c9

data/ext/rbnng/bus0.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/bus0/bus.h>
+#include <ruby.h>
+
+static VALUE
+socket_bus0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_bus0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  if ((rv = nng_socket_set_ms(p_rbnngSocket->socket, NNG_OPT_RECVTIMEO, 100)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_bus0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketBus0Class =
+    rb_define_class_under(rbnng_SocketModule, "Bus0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketBus0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketBus0Class, "initialize", socket_bus0_initialize, 0);
+  rb_define_method(rbnng_SocketBus0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketBus0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketBus0Class, "listen", socket_listen, 1);
+  rb_define_method(rbnng_SocketBus0Class, "dial", socket_dial, 1);
+}

data/ext/rbnng/exceptions.c

@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include <nng/nng.h>
+#include <ruby.h>
+
+VALUE rbnng_eBase = Qnil;
+
+VALUE rbnng_eInterrupted = Qnil;
+VALUE rbnng_eOutOfMemory = Qnil;
+VALUE rbnng_eInvalidArgument = Qnil;
+VALUE rbnng_eResourceBusy = Qnil;
+VALUE rbnng_eTimedOut = Qnil;
+VALUE rbnng_eConnectionRefused = Qnil;
+VALUE rbnng_eObjectClosed = Qnil;
+VALUE rbnng_eTryAgain = Qnil;
+VALUE rbnng_eNotSupported = Qnil;
+VALUE rbnng_eAddressInUse = Qnil;
+VALUE rbnng_eIncorrectState = Qnil;
+VALUE rbnng_eEntryNotFound = Qnil;
+VALUE rbnng_eProtocolError = Qnil;
+VALUE rbnng_eDestinationUnreachable = Qnil;
+VALUE rbnng_eAddressInvalid = Qnil;
+VALUE rbnng_ePermissionDenied = Qnil;
+VALUE rbnng_eMessageTooLarge = Qnil;
+VALUE rbnng_eConnectionReset = Qnil;
+VALUE rbnng_eConnectionAborted = Qnil;
+VALUE rbnng_eOperationCanceled = Qnil;
+VALUE rbnng_eOutOfFiles = Qnil;
+VALUE rbnng_eOutOfSpace = Qnil;
+VALUE rbnng_eResourceAlreadyExists = Qnil;
+VALUE rbnng_eReadOnlyResource = Qnil;
+VALUE rbnng_eWriteOnlyResource = Qnil;
+VALUE rbnng_eCryptographicError = Qnil;
+VALUE rbnng_ePeerCouldNotBeAuthenticated = Qnil;
+VALUE rbnng_eOptionRequiresArgument = Qnil;
+VALUE rbnng_eAmbiguousOption = Qnil;
+VALUE rbnng_eIncorrectType = Qnil;
+VALUE rbnng_eConnectionShutdown = Qnil;
+VALUE rbnng_eInternalErrorDetected = Qnil;
+
+void
+rbnng_exceptions_Init(VALUE nng_module)
+{
+  VALUE errorModule = rb_define_module_under(nng_module, "Error");
+  rbnng_eBase = rb_define_class_under(errorModule, "Error", rb_eRuntimeError);
+
+  rbnng_eInterrupted =
+    rb_define_class_under(errorModule, "Interrupted", rbnng_eBase);
+  rbnng_eOutOfMemory =
+    rb_define_class_under(errorModule, "OutOfMemory", rbnng_eBase);
+  rbnng_eInvalidArgument =
+    rb_define_class_under(errorModule, "InvalidArgument", rbnng_eBase);
+  rbnng_eResourceBusy =
+    rb_define_class_under(errorModule, "ResourceBusy", rbnng_eBase);
+  rbnng_eTimedOut = rb_define_class_under(errorModule, "TimedOut", rbnng_eBase);
+  rbnng_eConnectionRefused =
+    rb_define_class_under(errorModule, "ConnectionRefused", rbnng_eBase);
+  rbnng_eObjectClosed =
+    rb_define_class_under(errorModule, "ObjectClosed", rbnng_eBase);
+  rbnng_eTryAgain = rb_define_class_under(errorModule, "TryAgain", rbnng_eBase);
+  rbnng_eNotSupported =
+    rb_define_class_under(errorModule, "NotSupported", rbnng_eBase);
+  rbnng_eAddressInUse =
+    rb_define_class_under(errorModule, "AddressInUse", rbnng_eBase);
+  rbnng_eIncorrectState =
+    rb_define_class_under(errorModule, "IncorrectState", rbnng_eBase);
+  rbnng_eEntryNotFound =
+    rb_define_class_under(errorModule, "EntryNotFound", rbnng_eBase);
+  rbnng_eProtocolError =
+    rb_define_class_under(errorModule, "ProtocolError", rbnng_eBase);
+  rbnng_eDestinationUnreachable =
+    rb_define_class_under(errorModule, "DestinationUnreachable", rbnng_eBase);
+  rbnng_eAddressInvalid =
+    rb_define_class_under(errorModule, "AddressInvalid", rbnng_eBase);
+  rbnng_ePermissionDenied =
+    rb_define_class_under(errorModule, "PermissionDenied", rbnng_eBase);
+  rbnng_eMessageTooLarge =
+    rb_define_class_under(errorModule, "MessageTooLarge", rbnng_eBase);
+  rbnng_eConnectionReset =
+    rb_define_class_under(errorModule, "ConnectionReset", rbnng_eBase);
+  rbnng_eConnectionAborted =
+    rb_define_class_under(errorModule, "ConnectionAborted", rbnng_eBase);
+  rbnng_eOperationCanceled =
+    rb_define_class_under(errorModule, "OperationCanceled", rbnng_eBase);
+  rbnng_eOutOfFiles =
+    rb_define_class_under(errorModule, "OutOfFiles", rbnng_eBase);
+  rbnng_eOutOfSpace =
+    rb_define_class_under(errorModule, "OutOfSpace", rbnng_eBase);
+  rbnng_eResourceAlreadyExists =
+    rb_define_class_under(errorModule, "ResourceAlreadyExists", rbnng_eBase);
+  rbnng_eReadOnlyResource =
+    rb_define_class_under(errorModule, "ReadOnlyResource", rbnng_eBase);
+  rbnng_eWriteOnlyResource =
+    rb_define_class_under(errorModule, "WriteOnlyResource", rbnng_eBase);
+  rbnng_eCryptographicError =
+    rb_define_class_under(errorModule, "CryptographicError", rbnng_eBase);
+  rbnng_ePeerCouldNotBeAuthenticated = rb_define_class_under(
+    errorModule, "PeerCouldNotBeAuthenticated", rbnng_eBase);
+  rbnng_eOptionRequiresArgument =
+    rb_define_class_under(errorModule, "OptionRequiresArgument", rbnng_eBase);
+  rbnng_eAmbiguousOption =
+    rb_define_class_under(errorModule, "AmbiguousOption", rbnng_eBase);
+  rbnng_eIncorrectType =
+    rb_define_class_under(errorModule, "IncorrectType", rbnng_eBase);
+  rbnng_eConnectionShutdown =
+    rb_define_class_under(errorModule, "ConnectionShutdown", rbnng_eBase);
+  rbnng_eInternalErrorDetected =
+    rb_define_class_under(errorModule, "InternalErrorDetected", rbnng_eBase);
+}
+
+void
+raise_error(int nng_errno)
+{
+  switch (nng_errno) {
+    case NNG_EINTR:
+      rb_raise(rbnng_eInterrupted, "");
+      break;
+    case NNG_ENOMEM:
+      rb_raise(rbnng_eOutOfMemory, "");
+      break;
+    case NNG_EINVAL:
+      rb_raise(rbnng_eInvalidArgument, "");
+      break;
+    case NNG_EBUSY:
+      rb_raise(rbnng_eResourceBusy, "");
+      break;
+    case NNG_ETIMEDOUT:
+      rb_raise(rbnng_eTimedOut, "");
+      break;
+    case NNG_ECONNREFUSED:
+      rb_raise(rbnng_eConnectionRefused, "");
+      break;
+    case NNG_ECLOSED:
+      rb_raise(rbnng_eObjectClosed, "");
+      break;
+    case NNG_EAGAIN:
+      rb_raise(rbnng_eTryAgain, "");
+      break;
+    case NNG_ENOTSUP:
+      rb_raise(rbnng_eNotSupported, "");
+      break;
+    case NNG_EADDRINUSE:
+      rb_raise(rbnng_eAddressInUse, "");
+      break;
+    case NNG_ESTATE:
+      rb_raise(rbnng_eIncorrectState, "");
+      break;
+    case NNG_ENOENT:
+      rb_raise(rbnng_eEntryNotFound, "");
+      break;
+    case NNG_EPROTO:
+      rb_raise(rbnng_eProtocolError, "");
+      break;
+    case NNG_EUNREACHABLE:
+      rb_raise(rbnng_eDestinationUnreachable, "");
+      break;
+    case NNG_EADDRINVAL:
+      rb_raise(rbnng_eAddressInvalid, "");
+      break;
+    case NNG_EPERM:
+      rb_raise(rbnng_ePermissionDenied, "");
+      break;
+    case NNG_EMSGSIZE:
+      rb_raise(rbnng_eMessageTooLarge, "");
+      break;
+    case NNG_ECONNRESET:
+      rb_raise(rbnng_eConnectionReset, "");
+      break;
+    case NNG_ECONNABORTED:
+      rb_raise(rbnng_eConnectionAborted, "");
+      break;
+    case NNG_ECANCELED:
+      rb_raise(rbnng_eOperationCanceled, "");
+      break;
+    case NNG_ENOFILES:
+      rb_raise(rbnng_eOutOfFiles, "");
+      break;
+    case NNG_ENOSPC:
+      rb_raise(rbnng_eOutOfSpace, "");
+      break;
+    case NNG_EEXIST:
+      rb_raise(rbnng_eResourceAlreadyExists, "");
+      break;
+    case NNG_EREADONLY:
+      rb_raise(rbnng_eReadOnlyResource, "");
+      break;
+    case NNG_EWRITEONLY:
+      rb_raise(rbnng_eWriteOnlyResource, "");
+      break;
+    case NNG_ECRYPTO:
+      rb_raise(rbnng_eCryptographicError, "");
+      break;
+    case NNG_EPEERAUTH:
+      rb_raise(rbnng_ePeerCouldNotBeAuthenticated, "");
+      break;
+    case NNG_ENOARG:
+      rb_raise(rbnng_eOptionRequiresArgument, "");
+      break;
+    case NNG_EAMBIGUOUS:
+      rb_raise(rbnng_eAmbiguousOption, "");
+      break;
+    case NNG_EBADTYPE:
+      rb_raise(rbnng_eIncorrectType, "");
+      break;
+    case NNG_ECONNSHUT:
+      rb_raise(rbnng_eConnectionShutdown, "");
+      break;
+    case NNG_EINTERNAL:
+      rb_raise(rbnng_eInternalErrorDetected, "");
+      break;
+    default:
+      rb_raise(rbnng_eBase, "errno %d, %s", nng_errno, nng_strerror(nng_errno));
+      break;
+  }
+}

data/ext/rbnng/exceptions.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#ifndef RBNNG_EXCEPTIONS_H
+#define RBNNG_EXCEPTIONS_H
+
+extern void
+raise_error(int);
+
+#endif

data/ext/rbnng/msg.c

@@ -2,7 +2,6 @@
  * Copyright (c) 2021 Adib Saad
  *
  */
-
 #include "msg.h"
 #include <nng/protocol/reqrep0/rep.h>
 #include <ruby.h>
@@ -11,11 +10,10 @@
 VALUE rbnng_MsgClass = Qnil;
 
 void
-msg_free(void* ptr)
+msg_free(RbnngMsg* p_rbnngMsg)
 {
-  RbnngMsg* p_rbnngMsg = ptr;
-  if (p_rbnngMsg->msg) {
-    nng_msg_free(p_rbnngMsg->msg);
+  if (p_rbnngMsg->p_msg) {
+    nng_msg_free(p_rbnngMsg->p_msg);
   }
   xfree(p_rbnngMsg);
 }
@@ -32,9 +30,9 @@ msg_body(VALUE self)
 {
   RbnngMsg* p_rbnngMsg;
   Data_Get_Struct(self, RbnngMsg, p_rbnngMsg);
-  if (p_rbnngMsg->msg) {
-    return rb_str_new(nng_msg_body(p_rbnngMsg->msg),
-                      nng_msg_len(p_rbnngMsg->msg));
+  if (p_rbnngMsg->p_msg) {
+    return rb_str_new(nng_msg_body(p_rbnngMsg->p_msg),
+                      nng_msg_len(p_rbnngMsg->p_msg));
   } else {
     return rb_str_new_cstr("");
   }
@@ -45,9 +43,9 @@ msg_header(VALUE self)
 {
   RbnngMsg* p_rbnngMsg;
   Data_Get_Struct(self, RbnngMsg, p_rbnngMsg);
-  if (p_rbnngMsg->msg) {
-    return rb_str_new(nng_msg_header(p_rbnngMsg->msg),
-                      nng_msg_header_len(p_rbnngMsg->msg));
+  if (p_rbnngMsg->p_msg) {
+    return rb_str_new(nng_msg_header(p_rbnngMsg->p_msg),
+                      nng_msg_header_len(p_rbnngMsg->p_msg));
   } else {
     return rb_str_new_cstr("");
   }

data/ext/rbnng/msg.h

@@ -13,7 +13,7 @@ extern VALUE rbnng_MsgClass;
 
 typedef struct
 {
-  nng_msg* msg;
+  nng_msg* p_msg;
 } RbnngMsg;
 
 extern void

data/ext/rbnng/pair.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/pair0/pair.h>
+#include <nng/protocol/pair1/pair.h>
+#include <ruby.h>
+#include <ruby/thread.h>
+
+static VALUE
+socket_pair0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_pair0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+static VALUE
+socket_pair1_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_pair1_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_pair_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+
+  VALUE rbnng_SocketPair1Class =
+    rb_define_class_under(rbnng_SocketModule, "Pair1", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketPair1Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketPair1Class, "initialize", socket_pair1_initialize, 0);
+  rb_define_method(rbnng_SocketPair1Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketPair1Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketPair1Class, "listen", socket_listen, 1);
+  rb_define_method(rbnng_SocketPair1Class, "dial", socket_dial, 1);
+
+  VALUE rbnng_SocketPair0Class =
+    rb_define_class_under(rbnng_SocketModule, "Pair0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketPair0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketPair0Class, "initialize", socket_pair0_initialize, 0);
+  rb_define_method(rbnng_SocketPair0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketPair0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketPair0Class, "listen", socket_listen, 1);
+  rb_define_method(rbnng_SocketPair0Class, "dial", socket_dial, 1);
+}

data/ext/rbnng/pub0.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/pubsub0/pub.h>
+#include <ruby.h>
+
+static VALUE
+socket_pub0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_pub0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_pub0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketPub0Class =
+    rb_define_class_under(rbnng_SocketModule, "Pub0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketPub0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketPub0Class, "initialize", socket_pub0_initialize, 0);
+  rb_define_method(rbnng_SocketPub0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketPub0Class, "listen", socket_listen, 1);
+}

data/ext/rbnng/pull0.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/pipeline0/pull.h>
+#include <ruby.h>
+
+static VALUE
+socket_pull0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_pull0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_pull0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketPull0Class =
+    rb_define_class_under(rbnng_SocketModule, "Pull0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketPull0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketPull0Class, "initialize", socket_pull0_initialize, 0);
+  rb_define_method(rbnng_SocketPull0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketPull0Class, "listen", socket_listen, 1);
+}

data/ext/rbnng/push0.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/pipeline0/push.h>
+#include <ruby.h>
+
+static VALUE
+socket_push0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_push0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_push0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketPush0Class =
+    rb_define_class_under(rbnng_SocketModule, "Push0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketPush0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketPush0Class, "initialize", socket_push0_initialize, 0);
+  rb_define_method(rbnng_SocketPush0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketPush0Class, "dial", socket_dial, 1);
+}

data/ext/rbnng/rbnng.c

@@ -2,15 +2,12 @@
  * Copyright (c) 2021 Adib Saad
  *
  */
-
 #include <nng/nng.h>
 #include <ruby.h>
 
+#include "msg.h"
 #include "rbnng.h"
 #include "socket.h"
-#include "msg.h"
-
-VALUE rbnng_exceptionClass = Qnil;
 
 static VALUE
 library_version(VALUE self_)
@@ -26,9 +23,16 @@ Init_rbnng()
 {
   VALUE nng_module = rb_define_module("NNG");
   rb_define_singleton_method(nng_module, "nng_version", library_version, 0);
-  rbnng_exceptionClass = rb_define_class_under(nng_module, "Error", rb_eRuntimeError);
-
+  rbnng_exceptions_Init(nng_module);
+  rbnng_msg_Init(nng_module);
   rbnng_rep0_Init(nng_module);
   rbnng_req0_Init(nng_module);
-  rbnng_msg_Init(nng_module);
+  rbnng_pub0_Init(nng_module);
+  rbnng_sub0_Init(nng_module);
+  rbnng_pair_Init(nng_module);
+  rbnng_bus0_Init(nng_module);
+  rbnng_surveyor0_Init(nng_module);
+  rbnng_respondent0_Init(nng_module);
+  rbnng_push0_Init(nng_module);
+  rbnng_pull0_Init(nng_module);
 }

data/ext/rbnng/rbnng.h

@@ -6,8 +6,28 @@
 #ifndef RBNNG_H
 #define RBNNG_H
 
+#include "exceptions.h"
 #include <ruby.h>
 
-extern VALUE rbnng_exceptionClass;
+extern void
+rbnng_rep0_Init(VALUE nng_module);
+extern void
+rbnng_req0_Init(VALUE nng_module);
+extern void
+rbnng_pair_Init(VALUE nng_module);
+extern void
+rbnng_pub0_Init(VALUE nng_module);
+extern void
+rbnng_sub0_Init(VALUE nng_module);
+extern void
+rbnng_bus0_Init(VALUE nng_module);
+extern void
+rbnng_surveyor0_Init(VALUE nng_module);
+extern void
+rbnng_respondent0_Init(VALUE nng_module);
+extern void
+rbnng_push0_Init(VALUE nng_module);
+extern void
+rbnng_pull0_Init(VALUE nng_module);
 
 #endif

data/ext/rbnng/rep0.c

@@ -2,7 +2,6 @@
  * Copyright (c) 2021 Adib Saad
  *
  */
-
 #include "msg.h"
 #include "rbnng.h"
 #include "socket.h"
@@ -19,51 +18,49 @@ socket_rep0_listen(VALUE self, VALUE url)
   Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
   if ((rv = nng_listen(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
       0) {
-    rb_raise(rbnng_exceptionClass, "nng_listen %d", rv);
+    raise_error(rv);
   }
-  return self;
 }
 
 void*
-rep0_get_msg_blocking(void* data)
+rep0_get_msg_blocking(RbnngSocket* p_rbnngSocket)
 {
-  VALUE self = (VALUE)data;
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
-
   nng_aio* p_aio;
   int rv;
   if ((rv = nng_aio_alloc(&p_aio, 0, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_aio_alloc %d", rv);
+    return rv;
   }
 
   nng_ctx_recv(p_rbnngSocket->ctx, p_aio);
   nng_aio_wait(p_aio);
 
   if ((rv = nng_aio_result(p_aio)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_aio_result %d", rv);
+    return rv;
   }
 
   nng_msg* p_msg = nng_aio_get_msg(p_aio);
+  p_rbnngSocket->p_getMsgResult = p_msg;
   nng_aio_free(p_aio);
-  return p_msg;
+  return 0;
 }
 
 static VALUE
 socket_rep0_get_msg(VALUE self)
 {
-  nng_msg* nng_msg_ptr =
-    rb_thread_call_without_gvl(rep0_get_msg_blocking, self, 0, 0);
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv =
+    rb_thread_call_without_gvl(rep0_get_msg_blocking, p_rbnngSocket, 0, 0);
 
-  if (nng_msg_ptr) {
-    RbnngMsg* rbnng_new_msg_ptr;
+  if (rv == 0) {
+    RbnngMsg* p_newMsg;
     VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
-    Data_Get_Struct(newMsg, RbnngMsg, rbnng_new_msg_ptr);
-    rbnng_new_msg_ptr->msg = nng_msg_ptr;
+    Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
+    p_newMsg->p_msg = p_rbnngSocket->p_getMsgResult;
     return newMsg;
   } else {
-    VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
-    return newMsg;
+    raise_error(rv);
+    return Qnil;
   }
 }
 
@@ -77,28 +74,32 @@ rep0_send_msg_blocking(void* data)
   nng_aio* p_aio;
   int rv;
   if ((rv = nng_aio_alloc(&p_aio, 0, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_aio_alloc %d", rv);
+    return rv;
   }
 
   nng_msg* p_msg;
   if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_msg_alloc %d", rv);
+    return rv;
   }
 
   nng_msg_clear(p_msg);
-  nng_msg_append(p_msg,
-                 StringValuePtr(p_sendMsgReq->nextMsg),
-                 RSTRING_LEN(p_sendMsgReq->nextMsg));
+  rv = nng_msg_append(p_msg,
+                      StringValuePtr(p_sendMsgReq->nextMsg),
+                      RSTRING_LEN(p_sendMsgReq->nextMsg));
+  if (rv != 0) {
+    return rv;
+  }
 
   nng_aio_set_msg(p_aio, p_msg);
   nng_ctx_send(p_rbnngSocket->ctx, p_aio);
   nng_aio_wait(p_aio);
 
   if ((rv = nng_aio_result(p_aio)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_aio_result %d", rv);
+    return rv;
   }
 
   nng_aio_free(p_aio);
+  return 0;
 }
 
 static VALUE
@@ -110,21 +111,25 @@ socket_rep0_send_msg(VALUE self, VALUE rb_strMsg)
     .socketObj = self,
     .nextMsg = rb_strMsg,
   };
-  rb_thread_call_without_gvl(rep0_send_msg_blocking, &sendMsgReq, 0, 0);
+  int rv =
+    rb_thread_call_without_gvl(rep0_send_msg_blocking, &sendMsgReq, 0, 0);
+  if (rv != 0) {
+    raise_error(rv);
+  }
 }
 
 static VALUE
 socket_rep0_initialize(VALUE self)
 {
-  int rv;
   RbnngSocket* p_rbnngSocket;
   Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
   if ((rv = nng_rep0_open(&p_rbnngSocket->socket)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_rep0_open %d", rv);
+    raise_error(rv);
   }
 
   if ((rv = nng_ctx_open(&p_rbnngSocket->ctx, p_rbnngSocket->socket)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_ctx_open %d", rv);
+    raise_error(rv);
   }
 
   return self;

data/ext/rbnng/req0.c

@@ -2,7 +2,6 @@
  * Copyright (c) 2021 Adib Saad
  *
  */
-
 #include "msg.h"
 #include "rbnng.h"
 #include "socket.h"
@@ -11,100 +10,16 @@
 #include <ruby/thread.h>
 
 static VALUE
-socket_req0_dial(VALUE self, VALUE url)
-{
-  Check_Type(url, T_STRING);
-  int rv;
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
-  if ((rv = nng_dial(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
-      0) {
-    rb_raise(rbnng_exceptionClass, "nng_dial %d", rv);
-  }
-  return self;
-}
-
-void*
-req0_get_msg_blocking(void* data)
+socket_req0_initialize(VALUE self)
 {
-  VALUE self = (VALUE)data;
   RbnngSocket* p_rbnngSocket;
   Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
-
   int rv;
-  nng_msg* p_msg;
-  if ((rv = nng_recvmsg(p_rbnngSocket->socket, &p_msg, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_recvmsg %d", rv);
+  if ((rv = nng_req0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
   }
 
-  return p_msg;
-}
-
-static VALUE
-socket_req0_get_msg(VALUE self)
-{
-  nng_msg* p_msg =
-    rb_thread_call_without_gvl(req0_get_msg_blocking, self, 0, 0);
-
-  if (p_msg) {
-    RbnngMsg* p_newMsg;
-    VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
-    Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
-    p_newMsg->msg = p_msg;
-    return newMsg;
-  } else {
-    VALUE newMsg = rb_funcall(rbnng_MsgClass, rb_intern("new"), 0);
-    return newMsg;
-  }
-}
-
-void*
-req0_send_msg_blocking(void* data)
-{
-  RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(p_sendMsgReq->socketObj, RbnngSocket, p_rbnngSocket);
-  int rv;
-  nng_msg* msg;
-  if ((rv = nng_msg_alloc(&msg, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_msg_alloc %d", rv);
-  }
-
-  nng_msg_append(msg,
-                 StringValuePtr(p_sendMsgReq->nextMsg),
-                 RSTRING_LEN(p_sendMsgReq->nextMsg));
-
-  if ((rv = nng_sendmsg(p_rbnngSocket->socket, msg, 0)) != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_sendmsg %d", rv);
-  }
-
-  nng_msg_free(msg);
-
-  return 0;
-}
-
-static VALUE
-socket_req0_send_msg(VALUE self, VALUE rb_strMsg)
-{
-  Check_Type(rb_strMsg, T_STRING);
-  RbnngSendMsgReq sendMsgReq = {
-    .socketObj = self,
-    .nextMsg = rb_strMsg,
-  };
-  rb_thread_call_without_gvl(req0_send_msg_blocking, &sendMsgReq, 0, 0);
-
-  return Qnil;
-}
-
-static VALUE
-socket_req0_initialize(VALUE self)
-{
-  RbnngSocket* p_rbnngSocket;
-  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
-  int rv = nng_req0_open(&p_rbnngSocket->socket);
-  if (rv != 0) {
-    rb_raise(rbnng_exceptionClass, "nng_req0_open %d", rv);
-  }
   return self;
 }
 
@@ -112,12 +27,12 @@ void
 rbnng_req0_Init(VALUE nng_module)
 {
   VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
-  VALUE rbnng_SocketRep0Class =
+  VALUE rbnng_SocketReq0Class =
     rb_define_class_under(rbnng_SocketModule, "Req0", rb_cObject);
-  rb_define_alloc_func(rbnng_SocketRep0Class, socket_alloc);
+  rb_define_alloc_func(rbnng_SocketReq0Class, socket_alloc);
   rb_define_method(
-    rbnng_SocketRep0Class, "initialize", socket_req0_initialize, 0);
-  rb_define_method(rbnng_SocketRep0Class, "get_msg", socket_req0_get_msg, 0);
-  rb_define_method(rbnng_SocketRep0Class, "send_msg", socket_req0_send_msg, 1);
-  rb_define_method(rbnng_SocketRep0Class, "dial", socket_req0_dial, 1);
+    rbnng_SocketReq0Class, "initialize", socket_req0_initialize, 0);
+  rb_define_method(rbnng_SocketReq0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketReq0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketReq0Class, "dial", socket_dial, 1);
 }

data/ext/rbnng/respondent0.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/survey0/respond.h>
+#include <ruby.h>
+
+static VALUE
+socket_respondent0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_respondent0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_respondent0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketRespondent0Class =
+    rb_define_class_under(rbnng_SocketModule, "Respondent0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketRespondent0Class, socket_alloc);
+  rb_define_method(rbnng_SocketRespondent0Class,
+                   "initialize",
+                   socket_respondent0_initialize,
+                   0);
+  rb_define_method(
+    rbnng_SocketRespondent0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketRespondent0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketRespondent0Class, "dial", socket_dial, 1);
+}

data/ext/rbnng/socket.c

@@ -3,6 +3,10 @@
  *
  */
 #include "socket.h"
+#include "msg.h"
+#include "rbnng.h"
+#include <ruby.h>
+#include <ruby/thread.h>
 
 static void
 socket_free(void* ptr)
@@ -18,3 +22,105 @@ socket_alloc(VALUE klass)
   RbnngSocket* p_rbnngSocket = ZALLOC(RbnngSocket);
   return rb_data_object_wrap(klass, p_rbnngSocket, 0, socket_free);
 }
+
+void*
+socket_get_msg_blocking(RbnngSocket* p_rbnngSocket)
+{
+  nng_msg* p_msg = NULL;
+  int rv;
+  if ((rv = nng_recvmsg(p_rbnngSocket->socket, &p_msg, 0)) != 0) {
+    return rv;
+  }
+
+  p_rbnngSocket->p_getMsgResult = p_msg;
+  return 0;
+}
+
+VALUE
+socket_get_msg(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+
+  int rv =
+    rb_thread_call_without_gvl(socket_get_msg_blocking, p_rbnngSocket, 0, 0);
+
+  if (rv == 0) {
+    RbnngMsg* p_newMsg;
+    VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
+    Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
+    p_newMsg->p_msg = p_rbnngSocket->p_getMsgResult;
+    return newMsg;
+  } else {
+    raise_error(rv);
+    return Qnil;
+  }
+}
+
+void*
+socket_send_msg_blocking(void* data)
+{
+  RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(p_sendMsgReq->socketObj, RbnngSocket, p_rbnngSocket);
+  int rv;
+  nng_msg* p_msg;
+  if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
+    return rv;
+  }
+
+  rv = nng_msg_append(p_msg,
+                      StringValuePtr(p_sendMsgReq->nextMsg),
+                      RSTRING_LEN(p_sendMsgReq->nextMsg));
+  if (rv != 0) {
+    return rv;
+  }
+
+  // nng_sendmsg takes ownership of p_msg, so no need to free it afterwards.
+  if ((rv = nng_sendmsg(p_rbnngSocket->socket, p_msg, 0)) != 0) {
+    return rv;
+  }
+
+  return 0;
+}
+
+VALUE
+socket_send_msg(VALUE self, VALUE rb_strMsg)
+{
+  Check_Type(rb_strMsg, T_STRING);
+  RbnngSendMsgReq sendMsgReq = {
+    .socketObj = self,
+    .nextMsg = rb_strMsg,
+  };
+  int rv =
+    rb_thread_call_without_gvl(socket_send_msg_blocking, &sendMsgReq, 0, 0);
+  if (rv != 0) {
+    raise_error(rv);
+  }
+}
+
+VALUE
+socket_dial(VALUE self, VALUE url)
+{
+  Check_Type(url, T_STRING);
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_dial(p_rbnngSocket->socket, StringValueCStr(url), 0, 0)) != 0) {
+    raise_error(rv);
+  }
+}
+
+VALUE
+socket_listen(VALUE self, VALUE url)
+{
+  Check_Type(url, T_STRING);
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+
+  int rv;
+  if ((rv = nng_listen(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
+      0) {
+    raise_error(rv);
+  }
+}

data/ext/rbnng/socket.h

@@ -7,27 +7,30 @@
 #define RBNNG_SOCKET_H
 
 #include <nng/nng.h>
+#include <pthread.h>
 #include <ruby.h>
 #include <stdbool.h>
-#include <pthread.h>
 
 typedef struct
 {
   nng_socket socket;
   // Not all socket types will use a context
   nng_ctx ctx;
+
+  // for get_msg
+  nng_msg* p_getMsgResult;
 } RbnngSocket;
 
-typedef struct {
+typedef struct
+{
   VALUE socketObj; // A socket class instnace
   VALUE nextMsg;   // Ruby string
 } RbnngSendMsgReq;
 
-extern void
-rbnng_rep0_Init(VALUE nng_module);
-extern void
-rbnng_req0_Init(VALUE nng_module);
-extern VALUE
-socket_alloc(VALUE);
+extern VALUE socket_alloc(VALUE);
+extern VALUE socket_get_msg(VALUE);
+extern VALUE socket_send_msg(VALUE, VALUE);
+extern VALUE socket_dial(VALUE, VALUE);
+extern VALUE socket_listen(VALUE, VALUE);
 
 #endif

data/ext/rbnng/sub0.c

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/pubsub0/sub.h>
+#include <ruby.h>
+
+static VALUE
+socket_sub0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_sub0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  if ((rv = nng_socket_set(p_rbnngSocket->socket, NNG_OPT_SUB_SUBSCRIBE, "", 0)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_sub0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketSub0Class =
+    rb_define_class_under(rbnng_SocketModule, "Sub0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketSub0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketSub0Class, "initialize", socket_sub0_initialize, 0);
+  rb_define_method(rbnng_SocketSub0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketSub0Class, "dial", socket_dial, 1);
+}

data/ext/rbnng/surveyor0.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ 
+  // NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 50));
+  // NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
+ */
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/survey0/survey.h>
+#include <ruby.h>
+
+static VALUE
+socket_surveyor0_initialize(VALUE self)
+{
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  int rv;
+  if ((rv = nng_surveyor0_open(&p_rbnngSocket->socket)) != 0) {
+    raise_error(rv);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void
+rbnng_surveyor0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketSurveyor0Class =
+    rb_define_class_under(rbnng_SocketModule, "Surveyor0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketSurveyor0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketSurveyor0Class, "initialize", socket_surveyor0_initialize, 0);
+  rb_define_method(rbnng_SocketSurveyor0Class, "send_msg", socket_send_msg, 1);
+  rb_define_method(rbnng_SocketSurveyor0Class, "get_msg", socket_get_msg, 0);
+  rb_define_method(rbnng_SocketSurveyor0Class, "listen", socket_listen, 1);
+}

data/lib/nng/version.rb

@@ -1,3 +1,3 @@
 module NNG
-  VERSION = '0.1.0.alpha.0'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nng
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Adib Saad
@@ -18,14 +18,24 @@ extensions:
 - ext/rbnng/extconf.rb
 extra_rdoc_files: []
 files:
+- "./ext/rbnng/bus0.c"
+- "./ext/rbnng/exceptions.c"
+- "./ext/rbnng/exceptions.h"
 - "./ext/rbnng/msg.c"
 - "./ext/rbnng/msg.h"
+- "./ext/rbnng/pair.c"
+- "./ext/rbnng/pub0.c"
+- "./ext/rbnng/pull0.c"
+- "./ext/rbnng/push0.c"
 - "./ext/rbnng/rbnng.c"
 - "./ext/rbnng/rbnng.h"
 - "./ext/rbnng/rep0.c"
 - "./ext/rbnng/req0.c"
+- "./ext/rbnng/respondent0.c"
 - "./ext/rbnng/socket.c"
 - "./ext/rbnng/socket.h"
+- "./ext/rbnng/sub0.c"
+- "./ext/rbnng/surveyor0.c"
 - "./lib/nng.rb"
 - "./lib/nng/version.rb"
 - ext/rbnng/extconf.rb
@@ -45,9 +55,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
 signing_key: