iodine 0.4.19 → 0.5.0

data/ext/iodine/iodine_json.c

@@ -0,0 +1,304 @@
+#include "iodine.h"
+
+#include "fio_ary.h"
+#include "fio_json_parser.h"
+#include "fio_mem.h"
+#include "fiobj.h"
+#include "rb-fiobj2rb.h"
+#include "rb-registry.h"
+
+static VALUE max_nesting;
+static VALUE allow_nan;
+static VALUE symbolize_names;
+static VALUE create_additions;
+static VALUE object_class;
+static VALUE array_class;
+
+/* *****************************************************************************
+JSON Callacks - these must be implemented in the C file that uses the parser
+***************************************************************************** */
+
+/* *****************************************************************************
+JSON Parser handling (practically copied from the FIOBJ library)
+***************************************************************************** */
+
+typedef struct {
+  json_parser_s p;
+  VALUE key;
+  VALUE top;
+  VALUE target;
+  fio_ary_s stack;
+  uint8_t is_hash;
+  uint8_t symbolize;
+} iodine_json_parser_s;
+
+static inline void iodine_json_add2parser(iodine_json_parser_s *p, VALUE o) {
+  if (p->top) {
+    if (p->is_hash) {
+      if (p->key) {
+        rb_hash_aset(p->top, p->key, o);
+        Registry.remove(p->key);
+        p->key = (VALUE)0;
+      } else {
+        // if (p->symbolize) {
+        //   o = rb_to_symbol(o);
+        // }
+        p->key = o;
+        Registry.add(o);
+      }
+    } else {
+      rb_ary_push(p->top, o);
+    }
+  } else {
+    Registry.add(o);
+    p->top = o;
+  }
+}
+
+/** a NULL object was detected */
+static void fio_json_on_null(json_parser_s *p) {
+  iodine_json_add2parser((iodine_json_parser_s *)p, Qnil);
+}
+/** a TRUE object was detected */
+static void fio_json_on_true(json_parser_s *p) {
+  iodine_json_add2parser((iodine_json_parser_s *)p, Qtrue);
+}
+/** a FALSE object was detected */
+static void fio_json_on_false(json_parser_s *p) {
+  iodine_json_add2parser((iodine_json_parser_s *)p, Qfalse);
+}
+/** a Numberl was detected (long long). */
+static void fio_json_on_number(json_parser_s *p, long long i) {
+  iodine_json_add2parser((iodine_json_parser_s *)p, LONG2NUM(i));
+}
+/** a Float was detected (double). */
+static void fio_json_on_float(json_parser_s *p, double f) {
+  iodine_json_add2parser((iodine_json_parser_s *)p, DBL2NUM(f));
+}
+/** a String was detected (int / float). update `pos` to point at ending */
+static void fio_json_on_string(json_parser_s *p, void *start, size_t length) {
+  /* Ruby overhead for a rb_str_buf_new is very high. Double copy is faster. */
+  char *tmp = fio_malloc(length);
+  size_t new_len = fio_json_unescape_str(tmp, start, length);
+  VALUE buf;
+  if (((iodine_json_parser_s *)p)->symbolize &&
+      ((iodine_json_parser_s *)p)->is_hash &&
+      !((iodine_json_parser_s *)p)->key) {
+    ID id = rb_intern2(tmp, new_len);
+    buf = rb_id2sym(id);
+  } else {
+    buf = rb_str_new(tmp, new_len);
+  }
+  iodine_json_add2parser((iodine_json_parser_s *)p, buf);
+  fio_free(tmp);
+}
+/** a dictionary object was detected, should return 0 unless error occurred. */
+static int fio_json_on_start_object(json_parser_s *p) {
+  iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
+  if (pr->target) {
+    /* push NULL, don't free the objects */
+    fio_ary_push(&pr->stack, (void *)pr->top);
+    pr->top = pr->target;
+    pr->target = 0;
+  } else {
+    VALUE h = rb_hash_new();
+    iodine_json_add2parser(pr, h);
+    fio_ary_push(&pr->stack, (void *)pr->top);
+    pr->top = h;
+  }
+  pr->is_hash = 1;
+  return 0;
+}
+/** a dictionary object closure detected */
+static void fio_json_on_end_object(json_parser_s *p) {
+  iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
+  if (pr->key) {
+    fprintf(stderr, "WARNING: (JSON parsing) malformed JSON, "
+                    "ignoring dangling Hash key.\n");
+    Registry.remove(pr->key);
+    pr->key = (VALUE)0;
+  }
+  pr->top = (VALUE)fio_ary_pop(&pr->stack);
+  pr->is_hash = (TYPE(pr->top) == T_HASH);
+}
+/** an array object was detected */
+static int fio_json_on_start_array(json_parser_s *p) {
+  iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
+  if (pr->target)
+    return -1;
+  VALUE ary = rb_ary_new();
+  iodine_json_add2parser(pr, ary);
+  fio_ary_push(&pr->stack, (void *)pr->top);
+  pr->top = ary;
+  pr->is_hash = 0;
+  return 0;
+}
+/** an array closure was detected */
+static void fio_json_on_end_array(json_parser_s *p) {
+  iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
+  pr->top = (VALUE)fio_ary_pop(&pr->stack);
+  pr->is_hash = (TYPE(pr->top) == T_HASH);
+}
+/** the JSON parsing is complete */
+static void fio_json_on_json(json_parser_s *p) { (void)p; /* do nothing */ }
+/** the JSON parsing is complete */
+static void fio_json_on_error(json_parser_s *p) {
+  iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
+#if DEBUG
+  fprintf(stderr, "ERROR: JSON on error called.\n");
+#endif
+  Registry.remove((VALUE)fio_ary_index(&pr->stack, 0));
+  Registry.remove(pr->key);
+  fio_ary_free(&pr->stack);
+  *pr = (iodine_json_parser_s){.top = 0};
+}
+
+/* *****************************************************************************
+Iodine JSON Implementation
+***************************************************************************** */
+
+static inline VALUE iodine_json_convert(VALUE str, fiobj2rb_settings_s s) {
+
+  iodine_json_parser_s p = {.top = 0, .symbolize = s.str2sym};
+  size_t consumed = fio_json_parse(&p.p, RSTRING_PTR(str), RSTRING_LEN(str));
+  if (!consumed || p.p.depth) {
+    Registry.remove((VALUE)fio_ary_index(&p.stack, 0));
+    p.top = FIOBJ_INVALID;
+  }
+  fio_ary_free(&p.stack);
+  if (p.key) {
+    Registry.remove((VALUE)p.key);
+  }
+  if (!p.top) {
+    rb_raise(rb_eEncodingError, "Malformed JSON format.");
+  }
+  Registry.remove(p.top);
+  return p.top;
+}
+
+// static inline VALUE iodine_json_convert2(VALUE str, fiobj2rb_settings_s s) {
+//   FIOBJ json;
+//   if (!fiobj_json2obj(&json, RSTRING_PTR(str), RSTRING_LEN(str)) || !json) {
+//     rb_raise(rb_eRuntimeError, "JSON parsing failed. Not JSON?");
+//     return Qnil;
+//   }
+//   VALUE ret = fiobj2rb_deep(json, s.str2sym);
+//   fiobj_free(json);
+//   return ret;
+// }
+
+static inline void iodine_json_update_settings(VALUE h,
+                                               fiobj2rb_settings_s *s) {
+  VALUE tmp;
+  if (rb_hash_aref(h, max_nesting) != Qnil)
+    fprintf(stderr,
+            "WARNING: max_nesting ignored on this JSON implementation.\n");
+  if (rb_hash_aref(h, allow_nan) != Qnil)
+    fprintf(stderr, "WARNING: allow_nan ignored on this JSON implementation. "
+                    "NaN always allowed.\n");
+  if (rb_hash_aref(h, create_additions) != Qnil)
+    fprintf(stderr,
+            "WARNING: create_additions ignored on this JSON implementation.\n");
+  if (rb_hash_aref(h, object_class) != Qnil)
+    fprintf(stderr,
+            "WARNING: object_class ignored on this JSON implementation.\n");
+  if (rb_hash_aref(h, array_class) != Qnil)
+    fprintf(stderr,
+            "WARNING: array_class ignored on this JSON implementation.\n");
+  if ((tmp = rb_hash_aref(h, symbolize_names)) != Qnil) {
+    if (tmp == Qtrue)
+      s->str2sym = 1;
+    else if (tmp == Qfalse)
+      s->str2sym = 0;
+  }
+}
+
+/**
+Parse a JSON string using the iodine lenient parser (it's also faster).
+*/
+static VALUE iodine_json_parse(int argc, VALUE *argv, VALUE self) {
+  fiobj2rb_settings_s s = {.str2sym = 0};
+  if (argc > 2)
+    rb_raise(rb_eTypeError, "function requires supports up to two arguments.");
+  if (argc == 2) {
+    Check_Type(argv[1], T_HASH);
+    iodine_json_update_settings(argv[1], &s);
+  }
+  if (argc >= 1)
+    Check_Type(argv[0], T_STRING);
+  else
+    rb_raise(rb_eTypeError, "function requires at least one argument.");
+  return iodine_json_convert(argv[0], s);
+  (void)self;
+}
+
+/**
+Parse a JSON string using the iodine lenient parser with a default Symbol
+rather than String key (this is often faster than the regular
+{Iodine::JSON.parse} function).
+*/
+static VALUE iodine_json_parse_bang(int argc, VALUE *argv, VALUE self) {
+  fiobj2rb_settings_s s = {.str2sym = 0};
+  if (argc > 2)
+    rb_raise(rb_eTypeError, "function requires supports up to two arguments.");
+  if (argc == 2) {
+    Check_Type(argv[1], T_HASH);
+    iodine_json_update_settings(argv[1], &s);
+  }
+  if (argc >= 1)
+    Check_Type(argv[0], T_STRING);
+  else
+    rb_raise(rb_eTypeError, "function requires at least one argument.");
+  return iodine_json_convert(argv[0], s);
+  (void)self;
+}
+
+void Iodine_init_json(void) {
+  /**
+  Iodine::JSON offers a fast(er) JSON parser that is also lenient and supports
+  some JSON extensions such as Hex number recognition and comments.
+
+  You can test the parser using:
+
+      JSON_FILENAME="foo.json"
+
+      require 'json'
+      require 'iodine'
+      TIMES = 100
+      STR = IO.binread(JSON_FILENAME); nil
+
+      JSON.parse(STR) == Iodine::JSON.parse(STR) # => true
+      JSON.parse(STR,
+          symbolize_names: true) == Iodine::JSON.parse(STR,
+           symbolize_names: true) # => true
+      JSON.parse!(STR) == Iodine::JSON.parse!(STR) # => true/false (unknown)
+
+      # warm-up
+      TIMES.times { JSON.parse STR }
+      TIMES.times { Iodine::JSON.parse STR }
+
+      Benchmark.bm do |b|
+        sys = b.report("system") { TIMES.times { JSON.parse STR } }
+        sys_sym = b.report("system sym") { TIMES.times { JSON.parse STR,
+                                                 symbolize_names: true } }
+        iodine = b.report("iodine") { TIMES.times { Iodine::JSON.parse STR } }
+        iodine_sym = b.report("iodine sym") do
+                           TIMES.times { Iodine::JSON.parse STR,
+                                                  symbolize_names: true }
+                      end
+        puts "System    /    Iodine: #{sys/iodine}"
+        puts "System-sym/Iodine-sym: #{sys_sym/iodine_sym}"
+      end; nil
+
+
+  */
+  VALUE tmp = rb_define_module_under(Iodine, "JSON");
+  max_nesting = ID2SYM(rb_intern("max_nesting"));
+  allow_nan = ID2SYM(rb_intern("allow_nan"));
+  symbolize_names = ID2SYM(rb_intern("symbolize_names"));
+  create_additions = ID2SYM(rb_intern("create_additions"));
+  object_class = ID2SYM(rb_intern("object_class"));
+  array_class = ID2SYM(rb_intern("array_class"));
+  rb_define_module_function(tmp, "parse", iodine_json_parse, -1);
+  rb_define_module_function(tmp, "parse!", iodine_json_parse_bang, -1);
+}

data/ext/iodine/iodine_json.h

@@ -0,0 +1,6 @@
+#ifndef H_IODINE_JSON_H
+#define H_IODINE_JSON_H
+
+void Iodine_init_json(void);
+
+#endif

data/ext/iodine/iodine_protocol.c

@@ -5,9 +5,16 @@ License: MIT
 Feel free to copy, use and enjoy according to the license provided.
 */
 #include "iodine_protocol.h"
+#include "iodine_pubsub.h"
+
+#include "fio_llist.h"
+#include "fiobj4sock.h"
+#include "pubsub.h"
 
 #include <ruby/io.h>
 
+static ID iodine_close_func_id;
+
 /* *****************************************************************************
 The protocol object
 ***************************************************************************** */
@@ -15,6 +22,7 @@ The protocol object
 typedef struct {
   protocol_s protocol;
   VALUE handler;
+  fio_ls_s subscriptions;
 } iodine_protocol_s;
 
 VALUE IodineProtocol;
@@ -30,12 +38,15 @@ static void iodine_clear_task(intptr_t origin, void *block_) {
   (void)origin;
 }
 
-static void iodine_perform_task(intptr_t uuid, protocol_s *pr, void *block_) {
-  if (pr->service == iodine_protocol_service) {
-    RubyCaller.call2((VALUE)block_, iodine_call_proc_id, 1, (VALUE *)(pr + 1));
-  }
-  (void)uuid;
-}
+// static void iodine_perform_task(intptr_t uuid, protocol_s *pr, void *block_)
+// {
+//   if (pr->service == iodine_protocol_service) {
+//     RubyCaller.call2((VALUE)block_, iodine_call_proc_id, 1, (VALUE *)(pr +
+//     1));
+//   }
+//   (void)uuid;
+// }
+
 static void iodine_perform_task_and_free(intptr_t uuid, protocol_s *pr,
                                          void *block_) {
   if (pr->service == iodine_protocol_service) {
@@ -65,6 +76,20 @@ static VALUE not_implemented(VALUE self) {
   return Qnil;
 }
 
+/** DEPRECATED! Please override {on_drained} instead. */
+static VALUE not_implemented_on_ready(VALUE self, VALUE data) {
+  (void)(self);
+  (void)(data);
+  return Qnil;
+}
+
+/** Override this callback to handle the event. */
+static VALUE not_implemented_drained(VALUE self) {
+  RubyCaller.call(self, rb_intern2("on_ready", 8));
+  (void)(self);
+  return Qnil;
+}
+
 /** Override this callback to handle the event. */
 static VALUE not_implemented2(VALUE self, VALUE data) {
   (void)(self);
@@ -95,42 +120,62 @@ static VALUE default_on_data(VALUE self) {
 }
 
 /* *****************************************************************************
-Published functions
+Pub/Sub functions
 ***************************************************************************** */
 
-/** Returns the number of total connections managed by Iodine. */
-static VALUE dyn_count(VALUE self) {
-  size_t count = facil_count(iodine_protocol_service);
-  return ULL2NUM(count);
-  (void)self;
-}
-
+// clang-format off
 /**
-Runs a task for each dynamic connection (not websockets or HTTP).
+Subscribes the connection to a Pub/Sub channel.
+
+Since this connection's data packaging is unknown, a block (or handler) is required to handle  pub/sub events.
+
+The method accepts 1-2 arguments and an optional block. These are all valid ways
+to call the method:
+
+      subscribe("my_stream") {|from, msg| p msg }
+      subscribe("my_stream", match: :redis) {|from, msg| p msg }
+      subscribe(to: "my_stream")  {|from, msg| p msg }
+      subscribe to: "my_stream", match: :redis, handler: MyProc
 
-Requires a block and returns it as an object.
+The first argument must be either a String or a Hash.
 
-i.e., will write to every open dynamic connection:
+The second, optional, argument must be a Hash (if given).
 
-      Iodine.each {|obj| obj.write "hello!" }
+The options Hash supports the following possible keys (other keys are ignored, all keys are Symbols):
+
+:match :: The channel / subject name matching type to be used. Valid value is: `:redis`. Future versions hope to support `:nats` and `:rabbit` patern matching as well.
+
+:to :: The channel / subject to subscribe to.
+
+:handler :: and Proc like object, must answer to `call(from, msg)`.
+
+Returns an {Iodine::PubSub::Subscription} object that answers to:
+
+close :: closes the connection.
+to_s :: returns the subscription's target (stream / channel / subject).
+==(str) :: returns true if the string is an exact match for the target (even if the target itself is a pattern).
 
 */
-static VALUE dyn_run_each(VALUE self) {
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  if (block == Qnil)
+static VALUE iodine_proto_subscribe(int argc, VALUE *argv, VALUE self) {
+  // clang-format on
+  intptr_t uuid = iodine_get_fd(self);
+  if (!uuid || (VALUE)uuid == Qnil || uuid < 0)
+    return Qfalse;
+  VALUE sub = iodine_subscribe(argc, argv, NULL, IODINE_PUBSUB_GLOBAL);
+  if (sub == Qnil || sub == Qfalse)
     return Qfalse;
-  intptr_t origin = iodine_get_fd(self);
-  if (!origin)
-    origin = -1;
+  Registry.add(sub);
 
-  Registry.add(block);
-  facil_each(.arg = (void *)block, .service = "IodineDynamic", .origin = origin,
-             .task_type = FIO_PR_LOCK_TASK, .task = iodine_perform_task,
-             .on_complete = iodine_clear_task);
-  return block;
+  iodine_protocol_s *pr = iodine_get_cdata(self);
+
+  fio_ls_push(&pr->subscriptions, (void *)sub);
+  return sub;
 }
 
+/* *****************************************************************************
+Published functions
+***************************************************************************** */
+
 /**
 Reads up to `n` bytes from the network connection.
 The number of bytes to be read (n) is:
@@ -222,7 +267,7 @@ static VALUE dyn_write_move(VALUE self, VALUE data) {
   Registry.add(data);
   intptr_t fd = iodine_get_fd(self);
   if (sock_write2(.uuid = fd, .buffer = RSTRING_PTR(data),
-                  .length = RSTRING_LEN(data), .move = 1,
+                  .length = RSTRING_LEN(data),
                   .dealloc = (void (*)(void *))Registry.remove))
     return Qfalse;
   return self;
@@ -352,7 +397,7 @@ static VALUE dyn_defer(int argc, VALUE *argv, VALUE self) {
     return Qfalse;
   Registry.add(block);
   facil_defer(.uuid = fd, .task = iodine_perform_task_and_free,
-              .task_type = FIO_PR_LOCK_TASK, .arg = (void *)block,
+              .type = FIO_PR_LOCK_TASK, .arg = (void *)block,
               .fallback = iodine_clear_task);
   return block;
 }
@@ -370,7 +415,7 @@ static void dyn_protocol_on_data(intptr_t fduuid, protocol_s *protocol) {
 /** called when the socket is ready to be written to. */
 static void dyn_protocol_on_ready(intptr_t fduuid, protocol_s *protocol) {
   (void)(fduuid);
-  RubyCaller.call(dyn_prot(protocol)->handler, iodine_on_ready_func_id);
+  RubyCaller.call(dyn_prot(protocol)->handler, iodine_on_drained_func_id);
 }
 /** called when the server is shutting down,
  * but before closing the connection. */
@@ -378,11 +423,23 @@ static void dyn_protocol_on_shutdown(intptr_t fduuid, protocol_s *protocol) {
   (void)(fduuid);
   RubyCaller.call(dyn_prot(protocol)->handler, iodine_on_shutdown_func_id);
 }
+
+static void *clear_subscriptions_inGVL(void *pr_) {
+  iodine_protocol_s *pr = pr_;
+  while (fio_ls_any(&pr->subscriptions)) {
+    RubyCaller.call((VALUE)fio_ls_pop(&pr->subscriptions),
+                    iodine_close_func_id);
+  }
+  return NULL;
+}
+
 /** called when the connection was closed, but will not run concurrently */
 static void dyn_protocol_on_close(intptr_t uuid, protocol_s *protocol) {
   RubyCaller.call(dyn_prot(protocol)->handler, iodine_on_close_func_id);
   iodine_set_fd(dyn_prot(protocol)->handler, 0);
+  iodine_set_cdata(dyn_prot(protocol)->handler, NULL);
   Registry.remove(dyn_prot(protocol)->handler);
+  RubyCaller.call_c(clear_subscriptions_inGVL, protocol);
   free(protocol);
   (void)uuid;
 }
@@ -401,7 +458,6 @@ Connection management API
 static inline protocol_s *dyn_set_protocol(intptr_t fduuid, VALUE handler,
                                            uint8_t timeout) {
   Registry.add(handler);
-  iodine_set_fd(handler, fduuid);
   iodine_protocol_s *protocol = malloc(sizeof(*protocol));
   if (protocol == NULL) {
     Registry.remove(handler);
@@ -416,16 +472,23 @@ static inline protocol_s *dyn_set_protocol(intptr_t fduuid, VALUE handler,
       .protocol.ping = dyn_protocol_ping,
       .protocol.service = iodine_protocol_service,
       .handler = handler,
+      .subscriptions = FIO_LS_INIT(protocol->subscriptions),
   };
+  iodine_set_fd(handler, fduuid);
+  iodine_set_cdata(handler, protocol);
   RubyCaller.call(handler, iodine_on_open_func_id);
   return &protocol->protocol;
 }
 
-static protocol_s *on_open_dyn_protocol(intptr_t fduuid, void *udata) {
+static void on_open_dyn_protocol(intptr_t fduuid, void *udata) {
   VALUE rb_tout = rb_ivar_get((VALUE)udata, iodine_timeout_var_id);
   uint8_t timeout = (TYPE(rb_tout) == T_FIXNUM) ? FIX2UINT(rb_tout) : 0;
   VALUE handler = RubyCaller.call((VALUE)udata, iodine_new_func_id);
-  return dyn_set_protocol(fduuid, handler, timeout);
+  if (handler == Qnil) {
+    sock_close(fduuid);
+    return;
+  }
+  facil_attach(fduuid, dyn_set_protocol(fduuid, handler, timeout));
 }
 
 /** Sets up a listening socket. Conncetions received at the assigned port will
@@ -483,12 +546,12 @@ VALUE dyn_switch_prot(VALUE self, VALUE handler) {
   return handler;
 }
 
-static protocol_s *on_open_dyn_protocol_instance(intptr_t fduuid, void *udata) {
+static void on_open_dyn_protocol_instance(intptr_t fduuid, void *udata) {
   VALUE rb_tout = rb_ivar_get((VALUE)udata, iodine_timeout_var_id);
   uint8_t timeout = (TYPE(rb_tout) == T_FIXNUM) ? FIX2UINT(rb_tout) : 0;
   protocol_s *pr = dyn_set_protocol(fduuid, (VALUE)udata, timeout);
   Registry.remove((VALUE)udata);
-  return pr;
+  facil_attach(fduuid, pr);
 }
 
 /**
@@ -587,9 +650,9 @@ Library Initialization
 // between Lib-Server and Ruby.
 void Iodine_init_protocol(void) {
 
+  iodine_close_func_id = rb_intern("close");
+
   /* add Iodine module functions */
-  // rb_define_module_function(Iodine, "defer", dyn_defer, -1);
-  // rb_define_module_function(Iodine, "each", dyn_run_each, 0);
   rb_define_module_function(Iodine, "listen", iodine_listen, 2);
   rb_define_module_function(Iodine, "connect", iodine_connect, 3);
   rb_define_module_function(Iodine, "attach_io", iodine_attach_io, 2);
@@ -601,20 +664,17 @@ void Iodine_init_protocol(void) {
   rb_define_method(IodineProtocol, "on_close", not_implemented, 0);
   rb_define_method(IodineProtocol, "on_message", not_implemented2, 1);
   rb_define_method(IodineProtocol, "on_data", default_on_data, 0);
-  rb_define_method(IodineProtocol, "on_ready", not_implemented, 0);
+  rb_define_method(IodineProtocol, "on_ready", not_implemented_on_ready, 0);
+  rb_define_method(IodineProtocol, "on_drained", not_implemented_drained, 0);
   rb_define_method(IodineProtocol, "on_shutdown", not_implemented, 0);
   rb_define_method(IodineProtocol, "ping", not_implemented_ping, 0);
 
   /* Add module functions */
   rb_define_singleton_method(IodineProtocol, "defer", dyn_defer, -1);
-  rb_define_singleton_method(IodineProtocol, "count", dyn_count, 0);
-  rb_define_singleton_method(IodineProtocol, "each", dyn_run_each, 0);
 
   /* Add module instance methods */
-  // rb_define_method(IodineProtocol, "each", dyn_run_each, 0);
   rb_define_method(IodineProtocol, "open?", dyn_is_open, 0);
   rb_define_method(IodineProtocol, "conn_id", dyn_uuid, 0);
-  rb_define_method(IodineProtocol, "count", dyn_count, 0);
   rb_define_method(IodineProtocol, "read", dyn_read, -1);
   rb_define_method(IodineProtocol, "write", dyn_write, 1);
   rb_define_method(IodineProtocol, "write!", dyn_write_move, 1);
@@ -624,4 +684,6 @@ void Iodine_init_protocol(void) {
   rb_define_method(IodineProtocol, "switch_protocol", dyn_switch_prot, 1);
   rb_define_method(IodineProtocol, "timeout=", dyn_set_timeout, 1);
   rb_define_method(IodineProtocol, "timeout", dyn_get_timeout, 0);
+  rb_define_method(IodineProtocol, "subscribe", iodine_proto_subscribe, -1);
+  rb_define_method(IodineProtocol, "publish", iodine_publish, -1);
 }