nng 0.1.0.alpha.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00d81bda694b3cd8462da25c8164aa36f2f3deef9c193137676685dfcca23b8f
+  data.tar.gz: cc226d519edf60e5d6c11f07cd712a256f5a2bb38ff173b0d2d35afd308189da
+SHA512:
+  metadata.gz: 46a65accea3794de74022cb7d053a80f508089dd10e920e82ba3ff18a02013e21c66010c85bdcc536a07183cf11464a84a0d47e728c9c6d0720f2ad280344e37
+  data.tar.gz: 85a52e9c5814801b73a2ec7ea8bcba92a1f5d053f3c04dcc56c45c9d7bd8279532fad11b080109d5a08895e51bc7c32e685d70dd0bf40ff86ab717bc31ae2070

data/ext/rbnng/extconf.rb

@@ -0,0 +1,21 @@
+#
+#    Copyright (c) 2021 Adib Saad
+#
+require 'mkmf'
+dir_config('nng')
+
+def header?
+  have_header('nng/nng.h') ||
+    find_header('nng/nng.h', '/opt/local/include', '/usr/local/include', '/usr/include')
+end
+
+def library?
+  have_library('nng', 'nng_fini') ||
+    find_library('nng', 'nng_fini', '/opt/local/lib', '/usr/local/lib', '/usr/lib')
+end
+
+if header? && library?
+  create_makefile("nng/rbnng")
+else
+  raise "Couldn't find nng library. try setting --with-nng-dir=<path> to tell me where it is."
+end

data/ext/rbnng/msg.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#include "msg.h"
+#include <nng/protocol/reqrep0/rep.h>
+#include <ruby.h>
+#include <signal.h>
+
+VALUE rbnng_MsgClass = Qnil;
+
+void
+msg_free(void* ptr)
+{
+  RbnngMsg* p_rbnngMsg = ptr;
+  if (p_rbnngMsg->msg) {
+    nng_msg_free(p_rbnngMsg->msg);
+  }
+  xfree(p_rbnngMsg);
+}
+
+static VALUE
+msg_alloc(VALUE klass)
+{
+  RbnngMsg* p_rbnngMsg = ZALLOC(RbnngMsg);
+  return rb_data_object_wrap(klass, p_rbnngMsg, 0, msg_free);
+}
+
+static VALUE
+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));
+  } else {
+    return rb_str_new_cstr("");
+  }
+}
+
+static VALUE
+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));
+  } else {
+    return rb_str_new_cstr("");
+  }
+}
+
+void
+rbnng_msg_Init(VALUE nng_module)
+{
+  rbnng_MsgClass = rb_define_class_under(nng_module, "Msg", rb_cObject);
+  rb_define_alloc_func(rbnng_MsgClass, msg_alloc);
+  rb_define_method(rbnng_MsgClass, "body", msg_body, 0);
+  rb_define_method(rbnng_MsgClass, "header", msg_header, 0);
+}

data/ext/rbnng/msg.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#ifndef RBNNG_MSG_H
+#define RBNNG_MSG_H
+
+#include <nng/nng.h>
+#include <ruby.h>
+
+extern VALUE rbnng_MsgClass;
+
+typedef struct
+{
+  nng_msg* msg;
+} RbnngMsg;
+
+extern void
+rbnng_msg_Init(VALUE nng_module);
+
+#endif

data/ext/rbnng/rbnng.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#include <nng/nng.h>
+#include <ruby.h>
+
+#include "rbnng.h"
+#include "socket.h"
+#include "msg.h"
+
+VALUE rbnng_exceptionClass = Qnil;
+
+static VALUE
+library_version(VALUE self_)
+{
+  return rb_ary_new3(3,
+                     INT2NUM(NNG_MAJOR_VERSION),
+                     INT2NUM(NNG_MINOR_VERSION),
+                     INT2NUM(NNG_PATCH_VERSION));
+}
+
+void
+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_rep0_Init(nng_module);
+  rbnng_req0_Init(nng_module);
+  rbnng_msg_Init(nng_module);
+}

data/ext/rbnng/rbnng.h

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#ifndef RBNNG_H
+#define RBNNG_H
+
+#include <ruby.h>
+
+extern VALUE rbnng_exceptionClass;
+
+#endif

data/ext/rbnng/rep0.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/reqrep0/rep.h>
+#include <ruby.h>
+#include <ruby/thread.h>
+
+static VALUE
+socket_rep0_listen(VALUE self, VALUE url)
+{
+  Check_Type(url, T_STRING);
+  int rv;
+  RbnngSocket* p_rbnngSocket;
+  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);
+  }
+  return self;
+}
+
+void*
+rep0_get_msg_blocking(void* data)
+{
+  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);
+  }
+
+  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);
+  }
+
+  nng_msg* p_msg = nng_aio_get_msg(p_aio);
+  nng_aio_free(p_aio);
+  return p_msg;
+}
+
+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);
+
+  if (nng_msg_ptr) {
+    RbnngMsg* rbnng_new_msg_ptr;
+    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;
+    return newMsg;
+  } else {
+    VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
+    return newMsg;
+  }
+}
+
+void*
+rep0_send_msg_blocking(void* data)
+{
+  RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(p_sendMsgReq->socketObj, 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);
+  }
+
+  nng_msg* p_msg;
+  if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
+    rb_raise(rbnng_exceptionClass, "nng_msg_alloc %d", rv);
+  }
+
+  nng_msg_clear(p_msg);
+  nng_msg_append(p_msg,
+                 StringValuePtr(p_sendMsgReq->nextMsg),
+                 RSTRING_LEN(p_sendMsgReq->nextMsg));
+
+  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);
+  }
+
+  nng_aio_free(p_aio);
+}
+
+static VALUE
+socket_rep0_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(rep0_send_msg_blocking, &sendMsgReq, 0, 0);
+}
+
+static VALUE
+socket_rep0_initialize(VALUE self)
+{
+  int rv;
+  RbnngSocket* p_rbnngSocket;
+  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
+  if ((rv = nng_rep0_open(&p_rbnngSocket->socket)) != 0) {
+    rb_raise(rbnng_exceptionClass, "nng_rep0_open %d", rv);
+  }
+
+  if ((rv = nng_ctx_open(&p_rbnngSocket->ctx, p_rbnngSocket->socket)) != 0) {
+    rb_raise(rbnng_exceptionClass, "nng_ctx_open %d", rv);
+  }
+
+  return self;
+}
+
+void
+rbnng_rep0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketRep0Class =
+    rb_define_class_under(rbnng_SocketModule, "Rep0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketRep0Class, socket_alloc);
+  rb_define_method(
+    rbnng_SocketRep0Class, "initialize", socket_rep0_initialize, 0);
+  rb_define_method(rbnng_SocketRep0Class, "get_msg", socket_rep0_get_msg, 0);
+  rb_define_method(rbnng_SocketRep0Class, "send_msg", socket_rep0_send_msg, 1);
+  rb_define_method(rbnng_SocketRep0Class, "listen", socket_rep0_listen, 1);
+}

data/ext/rbnng/req0.c

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#include "msg.h"
+#include "rbnng.h"
+#include "socket.h"
+#include <nng/protocol/reqrep0/req.h>
+#include <ruby.h>
+#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)
+{
+  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);
+  }
+
+  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;
+}
+
+void
+rbnng_req0_Init(VALUE nng_module)
+{
+  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
+  VALUE rbnng_SocketRep0Class =
+    rb_define_class_under(rbnng_SocketModule, "Req0", rb_cObject);
+  rb_define_alloc_func(rbnng_SocketRep0Class, 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);
+}

data/ext/rbnng/socket.c

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+#include "socket.h"
+
+static void
+socket_free(void* ptr)
+{
+  RbnngSocket* p_rbnngSocket = (RbnngSocket*)ptr;
+  nng_close(p_rbnngSocket->socket);
+  xfree(p_rbnngSocket);
+}
+
+VALUE
+socket_alloc(VALUE klass)
+{
+  RbnngSocket* p_rbnngSocket = ZALLOC(RbnngSocket);
+  return rb_data_object_wrap(klass, p_rbnngSocket, 0, socket_free);
+}

data/ext/rbnng/socket.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2021 Adib Saad
+ *
+ */
+
+#ifndef RBNNG_SOCKET_H
+#define RBNNG_SOCKET_H
+
+#include <nng/nng.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;
+} RbnngSocket;
+
+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);
+
+#endif

data/lib/nng/version.rb

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

data/lib/nng.rb

@@ -0,0 +1,2 @@
+require 'nng/rbnng'   # Import the extension
+require 'nng/version'

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: nng
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha.0
+platform: ruby
+authors:
+- Adib Saad
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-11-27 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- adib.saad@gmail.com
+executables: []
+extensions:
+- ext/rbnng/extconf.rb
+extra_rdoc_files: []
+files:
+- "./ext/rbnng/msg.c"
+- "./ext/rbnng/msg.h"
+- "./ext/rbnng/rbnng.c"
+- "./ext/rbnng/rbnng.h"
+- "./ext/rbnng/rep0.c"
+- "./ext/rbnng/req0.c"
+- "./ext/rbnng/socket.c"
+- "./ext/rbnng/socket.h"
+- "./lib/nng.rb"
+- "./lib/nng/version.rb"
+- ext/rbnng/extconf.rb
+homepage: https://github.com/adibsaad/rbnng
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- ext
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Ruby bindings for nng (nanomsg-ng).
+test_files: []