nng 0.1.0 → 1.0.1

data/ext/rbnng/stats.c

@@ -0,0 +1,106 @@
+#include "rbnng.h"
+
+/* ── Recursive stat tree → Ruby Hash ──────────────────────────── */
+
+static VALUE unit_sym(int unit)
+{
+    switch (unit) {
+    case NNG_UNIT_BYTES:    return ID2SYM(rb_intern("bytes"));
+    case NNG_UNIT_MESSAGES: return ID2SYM(rb_intern("messages"));
+    case NNG_UNIT_MILLIS:   return ID2SYM(rb_intern("millis"));
+    case NNG_UNIT_EVENTS:   return ID2SYM(rb_intern("events"));
+    default:                return Qnil;
+    }
+}
+
+static VALUE stat_value(nng_stat *s)
+{
+    switch (nng_stat_type(s)) {
+    case NNG_STAT_COUNTER:
+    case NNG_STAT_LEVEL:
+    case NNG_STAT_ID:
+        return ULL2NUM(nng_stat_value(s));
+    case NNG_STAT_STRING: {
+        const char *v = nng_stat_string(s);
+        return v ? rb_str_new_cstr(v) : Qnil;
+    }
+    case NNG_STAT_BOOLEAN:
+        return nng_stat_bool(s) ? Qtrue : Qfalse;
+    default:
+        return Qnil;
+    }
+}
+
+static VALUE stat_to_hash(nng_stat *s)
+{
+    VALUE hash = rb_hash_new();
+
+    for (nng_stat *c = nng_stat_child(s); c; c = nng_stat_next(c)) {
+        const char *name = nng_stat_name(c);
+        VALUE key = ID2SYM(rb_intern(name));
+
+        if (nng_stat_type(c) == NNG_STAT_SCOPE) {
+            /* recurse into scopes */
+            rb_hash_aset(hash, key, stat_to_hash(c));
+        } else {
+            /* leaf: {value:, desc:, unit:} or just value for simple cases */
+            VALUE entry = rb_hash_new();
+            rb_hash_aset(entry, ID2SYM(rb_intern("value")), stat_value(c));
+
+            const char *desc = nng_stat_desc(c);
+            if (desc && desc[0])
+                rb_hash_aset(entry, ID2SYM(rb_intern("desc")), rb_str_new_cstr(desc));
+
+            VALUE u = unit_sym(nng_stat_unit(c));
+            if (!NIL_P(u))
+                rb_hash_aset(entry, ID2SYM(rb_intern("unit")), u);
+
+            rb_hash_aset(hash, key, entry);
+        }
+    }
+
+    return hash;
+}
+
+/* ── NNG.stats → Hash ─────────────────────────────────────────── */
+
+static VALUE
+nng_rb_stats(VALUE self)
+{
+    nng_stat *root;
+    int rv = nng_stats_get(&root);
+    if (rv != 0)
+        raise_nng_error(rv);
+
+    VALUE result = stat_to_hash(root);
+    nng_stats_free(root);
+    return result;
+}
+
+/* ── NNG.stats_for(socket) → Hash ─────────────────────────────── */
+
+static VALUE
+nng_rb_stats_for(VALUE self, VALUE socket_obj)
+{
+    rbnng_socket_t *s;
+    TypedData_Get_Struct(socket_obj, rbnng_socket_t, &rbnng_socket_type, s);
+
+    nng_stat *root;
+    int rv = nng_stats_get(&root);
+    if (rv != 0)
+        raise_nng_error(rv);
+
+    nng_stat *ss = nng_stat_find_socket(root, s->socket);
+    VALUE result = ss ? stat_to_hash(ss) : rb_hash_new();
+    nng_stats_free(root);
+    return result;
+}
+
+/* ── Init ──────────────────────────────────────────────────────── */
+
+void
+rbnng_stats_init(VALUE nng_module)
+{
+    rb_define_singleton_method(nng_module, "stats", nng_rb_stats, 0);
+    rb_define_singleton_method(nng_module, "stats_for", nng_rb_stats_for, 1);
+}

data/ext/rbnng/tls.c

@@ -0,0 +1,127 @@
+#include "rbnng.h"
+#include <nng/supplemental/tls/tls.h>
+#include <nng/transport/tls/tls.h>
+
+/*
+ * rbnng_tls_listen / rbnng_tls_dial — two-step listener/dialer with TLS config.
+ *
+ * Called from socket_listen_tls / socket_dial_tls in socket.c.
+ * TLS kwargs are parsed in Ruby; C receives PEM strings directly.
+ */
+
+/* ── Helpers ───────────────────────────────────────────────────────── */
+
+static nng_tls_config *
+build_tls_config(nng_tls_mode mode, VALUE cert_pem, VALUE key_pem,
+                 VALUE ca_pem, int verify, VALUE server_name)
+{
+    nng_tls_config *cfg;
+    int rv = nng_tls_config_alloc(&cfg, mode);
+    if (rv != 0)
+        raise_nng_error(rv);
+
+    /* Own certificate + key (server identity, or client mTLS) */
+    if (!NIL_P(cert_pem) && !NIL_P(key_pem)) {
+        rv = nng_tls_config_own_cert(cfg,
+                                     StringValueCStr(cert_pem),
+                                     StringValueCStr(key_pem),
+                                     NULL);
+        if (rv != 0) {
+            nng_tls_config_free(cfg);
+            raise_nng_error(rv);
+        }
+    }
+
+    /* CA chain for peer verification */
+    if (!NIL_P(ca_pem)) {
+        rv = nng_tls_config_ca_chain(cfg, StringValueCStr(ca_pem), NULL);
+        if (rv != 0) {
+            nng_tls_config_free(cfg);
+            raise_nng_error(rv);
+        }
+    }
+
+    /* Auth mode */
+    nng_tls_auth_mode auth = verify ? NNG_TLS_AUTH_MODE_REQUIRED
+                                    : NNG_TLS_AUTH_MODE_NONE;
+    rv = nng_tls_config_auth_mode(cfg, auth);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    /* Server name (SNI / certificate matching) — client only */
+    if (!NIL_P(server_name)) {
+        rv = nng_tls_config_server_name(cfg, StringValueCStr(server_name));
+        if (rv != 0) {
+            nng_tls_config_free(cfg);
+            raise_nng_error(rv);
+        }
+    }
+
+    return cfg;
+}
+
+/* ── Public C API (called from socket.c) ──────────────────────────── */
+
+void
+rbnng_tls_listen(nng_socket sock, const char *url,
+                 VALUE cert_pem, VALUE key_pem, VALUE ca_pem,
+                 int verify, VALUE server_name)
+{
+    nng_tls_config *cfg = build_tls_config(NNG_TLS_MODE_SERVER,
+                                           cert_pem, key_pem, ca_pem,
+                                           verify, server_name);
+
+    nng_listener listener;
+    int rv = nng_listener_create(&listener, sock, url);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    rv = nng_listener_set_ptr(listener, NNG_OPT_TLS_CONFIG, cfg);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    rv = nng_listener_start(listener, 0);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    nng_tls_config_free(cfg);
+}
+
+void
+rbnng_tls_dial(nng_socket sock, const char *url,
+               VALUE cert_pem, VALUE key_pem, VALUE ca_pem,
+               int verify, VALUE server_name)
+{
+    nng_tls_config *cfg = build_tls_config(NNG_TLS_MODE_CLIENT,
+                                           cert_pem, key_pem, ca_pem,
+                                           verify, server_name);
+
+    nng_dialer dialer;
+    int rv = nng_dialer_create(&dialer, sock, url);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    rv = nng_dialer_set_ptr(dialer, NNG_OPT_TLS_CONFIG, cfg);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    rv = nng_dialer_start(dialer, 0);
+    if (rv != 0) {
+        nng_tls_config_free(cfg);
+        raise_nng_error(rv);
+    }
+
+    nng_tls_config_free(cfg);
+}

data/lib/nng/socket/base.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Base
+      alias_method :send_msg, :send
+      alias_method :get_msg, :receive
+      alias_method :_listen, :listen
+      alias_method :_dial, :dial
+
+      def raw?
+        @raw
+      end
+
+
+      def listen(url, cert: nil, key: nil, ca: nil, verify: false, server_name: nil)
+        resolved = if cert || key || ca
+          cert_pem = cert ? TLS.coerce_pem(cert) : nil
+          key_pem  = key  ? TLS.coerce_pem(key)  : nil
+          ca_pem   = ca   ? TLS.coerce_pem(ca)   : nil
+          _listen_tls(url, cert_pem, key_pem, ca_pem, verify, server_name)
+        else
+          _listen(url)
+        end
+        (@urls ||= []) << (resolved || url)
+        self
+      end
+
+      def dial(url, cert: nil, key: nil, ca: nil, verify: nil, server_name: nil)
+        if cert || key || ca || verify == false
+          verify = !ca.nil? if verify.nil?
+          cert_pem = cert ? TLS.coerce_pem(cert) : nil
+          key_pem  = key  ? TLS.coerce_pem(key)  : nil
+          ca_pem   = ca   ? TLS.coerce_pem(ca)   : nil
+          server_name ||= TLS.extract_host(url)
+          _dial_tls(url, cert_pem, key_pem, ca_pem, verify, server_name)
+        else
+          _dial(url)
+        end
+        (@urls ||= []) << url
+        self
+      end
+
+      def urls
+        (@urls ||= []).dup.freeze
+      end
+
+      def name
+        get_opt_string('socket-name')
+      end
+
+      def name=(value)
+        set_opt_string('socket-name', value)
+      end
+
+      def recv_timeout
+        ms = get_opt_ms('recv-timeout')
+        ms.negative? ? nil : ms / 1000.0
+      end
+
+      def recv_timeout=(seconds)
+        set_opt_ms('recv-timeout', seconds ? (seconds * 1000).to_i : -1)
+      end
+
+      def send_timeout
+        ms = get_opt_ms('send-timeout')
+        ms.negative? ? nil : ms / 1000.0
+      end
+
+      def send_timeout=(seconds)
+        set_opt_ms('send-timeout', seconds ? (seconds * 1000).to_i : -1)
+      end
+
+      def recv_buffer
+        get_opt_int('recv-buffer')
+      end
+
+      def recv_buffer=(n)
+        set_opt_int('recv-buffer', n.to_i)
+      end
+
+      def send_buffer
+        get_opt_int('send-buffer')
+      end
+
+      def send_buffer=(n)
+        set_opt_int('send-buffer', n.to_i)
+      end
+
+      def recv_max_size
+        get_opt_size('recv-size-max')
+      end
+
+      def recv_max_size=(n)
+        set_opt_size('recv-size-max', n.to_i)
+      end
+
+      def reconnect_time
+        min_ms = get_opt_ms('reconnect-time-min')
+        max_ms = get_opt_ms('reconnect-time-max')
+        (min_ms / 1000.0)..(max_ms / 1000.0)
+      end
+
+      def reconnect_time=(range)
+        set_opt_ms('reconnect-time-min', (range.begin * 1000).to_i)
+        set_opt_ms('reconnect-time-max', (range.end * 1000).to_i)
+      end
+
+      def protocol_name
+        get_opt_string('protocol-name')
+      end
+
+      def peer_name
+        get_opt_string('peer-name')
+      end
+
+      def on_pipe_event
+        pipe_notify_start
+        @pipe_notify_io ||= IO.for_fd(pipe_notify_fd, autoclose: false)
+        return to_enum(:on_pipe_event) unless block_given?
+
+        loop do
+          @pipe_notify_io.wait_readable
+          while (event = recv_pipe_event)
+            yield event
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nng/socket/bus0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Bus0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/pair0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Pair0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/pair1.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Pair1
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/pub0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Pub0
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/pull0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Pull0
+      include Readable
+    end
+  end
+end

data/lib/nng/socket/push0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Push0
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/readable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    module Readable
+      def wait_readable(timeout = recv_timeout)
+        @recv_io ||= IO.for_fd(recv_fd, autoclose: false)
+        @recv_io.wait_readable(timeout)
+      end
+
+      def receive(timeout: recv_timeout)
+        wait_readable(timeout) or raise Timeout::Error, 'receive timed out'
+        super()
+      end
+    end
+  end
+end

data/lib/nng/socket/rep0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Rep0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/req0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Req0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/respondent0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Respondent0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/sub0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Sub0
+      include Readable
+    end
+  end
+end

data/lib/nng/socket/surveyor0.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    class Surveyor0
+      include Readable
+      include Writable
+    end
+  end
+end

data/lib/nng/socket/writable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NNG
+  module Socket
+    module Writable
+      def wait_writable(timeout = send_timeout)
+        @send_io ||= IO.for_fd(send_fd, autoclose: false)
+        @send_io.wait_readable(timeout)
+      end
+
+      def send(data, timeout: send_timeout)
+        wait_writable(timeout) or raise Timeout::Error, 'send timed out'
+        super(data)
+      end
+    end
+  end
+end

data/lib/nng/tls.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module NNG
+  module TLS
+    module_function
+
+    def coerce_pem(val)
+      case val
+      when Pathname then val.read
+      else
+        val = val.to_pem if val.respond_to?(:to_pem)
+        val.to_s
+      end
+    end
+
+    def extract_host(url)
+      uri = URI.parse(url.sub(%r{\Atls\+tcp://}, 'tcp://'))
+      uri.host
+    rescue URI::InvalidURIError
+      nil
+    end
+  end
+end

data/lib/nng/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NNG
-  VERSION = '0.1.0'
+  VERSION = '1.0.1'
 end

data/lib/nng.rb

@@ -1,2 +1,25 @@
-require 'nng/rbnng'   # Import the extension
+# frozen_string_literal: true
+
+require 'timeout'
+require 'nng/rbnng'
 require 'nng/version'
+require 'nng/tls'
+require 'nng/socket/base'
+require 'nng/socket/readable'
+require 'nng/socket/writable'
+require 'nng/socket/pair0'
+require 'nng/socket/pair1'
+require 'nng/socket/bus0'
+require 'nng/socket/pub0'
+require 'nng/socket/sub0'
+require 'nng/socket/push0'
+require 'nng/socket/pull0'
+require 'nng/socket/req0'
+require 'nng/socket/rep0'
+require 'nng/socket/surveyor0'
+require 'nng/socket/respondent0'
+
+module NNG
+  Msg = Message
+  Error::Error = Error # backwards compatibility
+end

metadata

@@ -1,66 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: nng
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Adib Saad
-autorequire:
+- Patrik Wenger
 bindir: bin
 cert_chain: []
-date: 2021-11-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description:
+description: Native C extension providing Ruby bindings for nng (nanomsg next generation),
+  a lightweight broker-less messaging library. Supports all scalability protocols,
+  TLS transport, and async I/O.
 email:
 - adib.saad@gmail.com
+- paddor@gmail.com
 executables: []
 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"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- ext/rbnng/device.c
+- ext/rbnng/exceptions.c
 - ext/rbnng/extconf.rb
-homepage: https://github.com/adibsaad/rbnng
+- ext/rbnng/message.c
+- ext/rbnng/pipe.c
+- ext/rbnng/rbnng.c
+- ext/rbnng/rbnng.h
+- ext/rbnng/socket.c
+- ext/rbnng/stats.c
+- ext/rbnng/tls.c
+- lib/nng.rb
+- lib/nng/socket/base.rb
+- lib/nng/socket/bus0.rb
+- lib/nng/socket/pair0.rb
+- lib/nng/socket/pair1.rb
+- lib/nng/socket/pub0.rb
+- lib/nng/socket/pull0.rb
+- lib/nng/socket/push0.rb
+- lib/nng/socket/readable.rb
+- lib/nng/socket/rep0.rb
+- lib/nng/socket/req0.rb
+- lib/nng/socket/respondent0.rb
+- lib/nng/socket/sub0.rb
+- lib/nng/socket/surveyor0.rb
+- lib/nng/socket/writable.rb
+- lib/nng/tls.rb
+- lib/nng/version.rb
+homepage: https://github.com/paddor/rbnng
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/paddor/rbnng
+  changelog_uri: https://github.com/paddor/rbnng/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/paddor/rbnng/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
-- ext
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby bindings for nng (nanomsg-ng).
 test_files: []