iodine 0.5.2 → 0.6.0

data/ext/iodine/iodine_http.h

@@ -1,7 +1,7 @@
 #ifndef H_IODINE_HTTP_H
 #define H_IODINE_HTTP_H
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz segev, 2016-2018
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -13,6 +13,6 @@ extern VALUE IODINE_R_HIJACK;
 extern VALUE IODINE_R_HIJACK_IO;
 extern VALUE IODINE_R_HIJACK_CB;
 
-void Iodine_init_http(void);
+void iodine_init_http(void);
 
 #endif

data/ext/iodine/iodine_json.c

@@ -4,8 +4,8 @@
 #include "fio_json_parser.h"
 #include "fio_mem.h"
 #include "fiobj.h"
-#include "rb-fiobj2rb.h"
-#include "rb-registry.h"
+#include "iodine_fiobj2rb.h"
+#include "iodine_store.h"
 
 static VALUE max_nesting;
 static VALUE allow_nan;
@@ -37,20 +37,20 @@ static inline void iodine_json_add2parser(iodine_json_parser_s *p, VALUE o) {
     if (p->is_hash) {
       if (p->key) {
         rb_hash_aset(p->top, p->key, o);
-        Registry.remove(p->key);
+        IodineStore.remove(p->key);
         p->key = (VALUE)0;
       } else {
         // if (p->symbolize) {
         //   o = rb_to_symbol(o);
         // }
         p->key = o;
-        Registry.add(o);
+        IodineStore.add(o);
       }
     } else {
       rb_ary_push(p->top, o);
     }
   } else {
-    Registry.add(o);
+    IodineStore.add(o);
     p->top = o;
   }
 }
@@ -115,7 +115,7 @@ static void fio_json_on_end_object(json_parser_s *p) {
   if (pr->key) {
     fprintf(stderr, "WARNING: (JSON parsing) malformed JSON, "
                     "ignoring dangling Hash key.\n");
-    Registry.remove(pr->key);
+    IodineStore.remove(pr->key);
     pr->key = (VALUE)0;
   }
   pr->top = (VALUE)fio_ary_pop(&pr->stack);
@@ -147,8 +147,8 @@ static void fio_json_on_error(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);
+  IodineStore.remove((VALUE)fio_ary_index(&pr->stack, 0));
+  IodineStore.remove(pr->key);
   fio_ary_free(&pr->stack);
   *pr = (iodine_json_parser_s){.top = 0};
 }
@@ -162,17 +162,17 @@ 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));
+    IodineStore.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);
+    IodineStore.remove((VALUE)p.key);
   }
   if (!p.top) {
     rb_raise(rb_eEncodingError, "Malformed JSON format.");
   }
-  Registry.remove(p.top);
+  IodineStore.remove(p.top);
   return p.top;
 }
 
@@ -253,7 +253,7 @@ static VALUE iodine_json_parse_bang(int argc, VALUE *argv, VALUE self) {
   (void)self;
 }
 
-void Iodine_init_json(void) {
+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.
@@ -292,7 +292,7 @@ void Iodine_init_json(void) {
 
 
   */
-  VALUE tmp = rb_define_module_under(Iodine, "JSON");
+  VALUE tmp = rb_define_module_under(IodineModule, "JSON");
   max_nesting = ID2SYM(rb_intern("max_nesting"));
   allow_nan = ID2SYM(rb_intern("allow_nan"));
   symbolize_names = ID2SYM(rb_intern("symbolize_names"));

data/ext/iodine/iodine_json.h

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

data/ext/iodine/iodine_pubsub.c

@@ -1,946 +1,696 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
 #include "iodine_pubsub.h"
-#include "rb-call.h"
-
+#include "iodine_fiobj2rb.h"
 #include "pubsub.h"
-#include "rb-fiobj2rb.h"
 #include "redis_engine.h"
-#include "websockets.h"
-
-VALUE IodineEngine;
-ID iodine_engine_pubid;
-
-static VALUE IodinePubSub;
-static VALUE IodinePubSubSubscription;
-static ID engine_varid;
-static ID engine_subid;
-static ID engine_unsubid;
-static ID default_pubsubid;
-
-static ID to_str_shadow_id;
-
-static VALUE as_sym_id;
-static VALUE binary_sym_id;
-static VALUE handler_sym_id;
-static VALUE match_sym_id;
-static VALUE message_sym_id;
-static VALUE redis_sym_id;
-static VALUE text_sym_id;
-static VALUE to_sym_id;
-static VALUE channel_sym_id;
 
-/* *****************************************************************************
-Mock Functions
-***************************************************************************** */
+/*
+NOTE:
 
-/**
-Override this method to handle (un)subscription requests.
+This file defines Pub/Sub management and settings, not Pub/Sub usage.
 
-This function will be called by Iodine during pub/sub (un)subscription. Don't
-call this function from your own code / application.
+This file doen't include the `Iodine.subscribe`, `Iodine.unsubscribe` and
+`Iodine.publish` methods.
 
-The function should return `true` on success and `nil` or `false` on failure.
+These methods are all defined in the Connection module (iodine_connection.h).
 */
-static VALUE engine_sub_placeholder(VALUE self, VALUE channel,
-                                    VALUE use_pattern) {
-  return Qnil;
-  (void)self;
-  (void)channel;
-  (void)use_pattern;
-}
+
+/* *****************************************************************************
+static consts
+***************************************************************************** */
+
+static ID subscribe_id;
+static ID unsubscribe_id;
+static ID publish_id;
+static ID default_id;
+static ID redis_id;
+static ID call_id;
 
 /**
-Override this method to handle message publishing to the underlying engine (i.e.
-from Ruby to Redis or from Ruby to MongoDB).
+The {Iodine::PubSub::Engine} class is the parent for all engines to inherit
+from.
 
-This function will be called by Iodine during pub/sub publication. Don't
-call this function from your own code / application.
+Engines should inherit this class and override the `subscribe`, `unsubscribe`
+and `publish` callbacks (which shall be called by {Iodine}).
 
-The function should return `true` on success and `nil` or `false` on failure.
+After creation, Engines should attach themselves to Iodine using
+{Iodine::PubSub.attach} or their callbacks will never get called.
+
+Engines can also set themselves to be the default engine using
+{Iodine::PubSub.default=}.
 */
-static VALUE engine_pub_placeholder(VALUE self, VALUE channel, VALUE msg) {
-  { /* test for built-in C engines */
-    iodine_engine_s *engine;
-    Data_Get_Struct(self, iodine_engine_s, engine);
-    if (engine->p != &engine->engine) {
-      FIOBJ ch = fiobj_str_new(RSTRING_PTR(channel), RSTRING_LEN(channel));
-      FIOBJ m = fiobj_str_new(RSTRING_PTR(msg), RSTRING_LEN(msg));
-      pubsub_publish(.engine = engine->p, .channel = ch, .message = m);
-      fiobj_free(ch);
-      fiobj_free(msg);
-      return Qtrue;
-    }
-  }
-  return Qnil;
-  (void)self;
-  (void)msg;
-  (void)channel;
-}
+static VALUE EngineClass;
 
 /* *****************************************************************************
-Engine registration and resetting
+Ruby <=> C Callbacks
 ***************************************************************************** */
 
-/**
-This method adds the engine to the pub/sub system, allowing it to recieve system
-wide notifications.
-*/
-static VALUE iodine_engine_register2(VALUE self, VALUE engine) {
-  iodine_engine_s *e;
-  Registry.add(engine);
-  Data_Get_Struct(engine, iodine_engine_s, e);
-  if (e->p) {
-    e->handler = engine;
-    pubsub_engine_register(e->p);
-    return Qtrue;
-  }
-  return Qfalse;
-  (void)self;
-  (void)engine;
+typedef struct {
+  iodine_pubsub_s *eng;
+  FIOBJ ch;
+  FIOBJ msg;
+  uint8_t pattern;
+} iodine_pubsub_task_s;
+
+#define iodine_engine(eng) ((iodine_pubsub_s *)(eng))
+
+/* calls an engine's `subscribe` callback within the GVL */
+static void *iodine_pubsub_GIL_subscribe(void *tsk_) {
+  iodine_pubsub_task_s *task = tsk_;
+  VALUE args[2];
+  fio_cstr_s tmp = fiobj_obj2cstr(task->ch);
+  args[0] = rb_str_new(tmp.data, tmp.len);
+  args[1] = task->pattern ? Qtrue : Qnil; // TODO: Qtrue should be :redis
+  IodineCaller.call2(task->eng->handler, subscribe_id, 2, args);
+  return NULL;
 }
 
-/**
-This method adds the engine to the pub/sub system, allowing it to recieve system
-wide notifications.
-*/
-static VALUE iodine_engine_register(VALUE self) {
-  return iodine_engine_register2(self, self);
+/** Must subscribe channel. Failures are ignored. */
+static void iodine_pubsub_on_subscribe(const pubsub_engine_s *eng,
+                                       FIOBJ channel, uint8_t use_pattern) {
+  if (iodine_engine(eng)->handler == Qnil) {
+    return;
+  }
+  iodine_pubsub_task_s task = {
+      .eng = iodine_engine(eng), .ch = channel, .pattern = use_pattern};
+  IodineCaller.enterGVL(iodine_pubsub_GIL_subscribe, &task);
+}
+
+/* calls an engine's `unsubscribe` callback within the GVL */
+static void *iodine_pubsub_GIL_unsubscribe(void *tsk_) {
+  iodine_pubsub_task_s *task = tsk_;
+  VALUE args[2];
+  fio_cstr_s tmp = fiobj_obj2cstr(task->ch);
+  args[0] = rb_str_new(tmp.data, tmp.len);
+  args[1] = task->pattern ? Qtrue : Qnil; // TODO: Qtrue should be :redis
+  IodineCaller.call2(task->eng->handler, unsubscribe_id, 2, args);
+  return NULL;
 }
 
-/**
-This method removes the engine from the pub/sub system.
-*/
-static VALUE iodine_engine_deregister2(VALUE self, VALUE engine) {
-  iodine_engine_s *e;
-  Data_Get_Struct(engine, iodine_engine_s, e);
-  if (e->p) {
-    pubsub_engine_deregister(e->p);
-    Registry.remove(engine);
-    return Qtrue;
-  }
-  Registry.remove(engine);
-  return Qfalse;
-  (void)self;
-  (void)engine;
+/** Must unsubscribe channel. Failures are ignored. */
+static void iodine_pubsub_on_unsubscribe(const pubsub_engine_s *eng,
+                                         FIOBJ channel, uint8_t use_pattern) {
+  if (iodine_engine(eng)->handler == Qnil) {
+    return;
+  }
+  iodine_pubsub_task_s task = {
+      .eng = iodine_engine(eng), .ch = channel, .pattern = use_pattern};
+  IodineCaller.enterGVL(iodine_pubsub_GIL_unsubscribe, &task);
+}
+
+/* calls an engine's `unsubscribe` callback within the GVL */
+static void *iodine_pubsub_GIL_publish(void *tsk_) {
+  iodine_pubsub_task_s *task = tsk_;
+  VALUE args[2];
+  fio_cstr_s tmp = fiobj_obj2cstr(task->ch);
+  args[0] = rb_str_new(tmp.data, tmp.len);
+  tmp = fiobj_obj2cstr(task->msg);
+  args[1] = rb_str_new(tmp.data, tmp.len);
+  IodineCaller.call2(task->eng->handler, publish_id, 2, args);
+  return NULL;
 }
 
-/**
-This method removes the engine from the pub/sub system.
-*/
-static VALUE iodine_engine_deregister(VALUE self) {
-  return iodine_engine_deregister2(self, self);
+/** Should return 0 on success and -1 on failure. */
+static int iodine_pubsub_on_publish(const pubsub_engine_s *eng, FIOBJ channel,
+                                    FIOBJ msg) {
+  if (iodine_engine(eng)->handler == Qnil) {
+    return -1;
+  }
+  iodine_pubsub_task_s task = {
+      .eng = iodine_engine(eng), .ch = channel, .msg = msg};
+  IodineCaller.enterGVL(iodine_pubsub_GIL_publish, &task);
+  return 0;
 }
+/**
+ * facil.io will call this callback whenever starting, or restarting, the
+ * reactor.
+ *
+ * but iodine engines should probably use the `before_fork` and `after_fork`
+ * hooks.
+ */
+static void iodine_pubsub_on_startup(const pubsub_engine_s *eng) { (void)eng; }
+
+/* *****************************************************************************
+Ruby methods
+***************************************************************************** */
 
 /**
-This method resets the engine, (re)sending all the current subscription data as
-if the {register} method was just called.
+OVERRIDE this callback - it will be called by {Iodine} whenever the process
+CLUSTER (not just this process) subscribes to a stream / channel.
 */
-static VALUE iodine_engine_reset2(VALUE self, VALUE engine) {
-  iodine_engine_s *e;
-  Data_Get_Struct(engine, iodine_engine_s, e);
-  if (e->p) {
-    e->handler = engine;
-    pubsub_engine_resubscribe(e->p);
-    return Qtrue;
+static VALUE iodine_pubsub_subscribe(VALUE self, VALUE to, VALUE match) {
+  return Qnil;
+#if 0
+  iodine_pubsub_s *e = iodine_pubsub_CData(self);
+  if (e->engine == &e->do_not_touch) {
+    /* this is a Ruby engine, nothing to do. */
+    return Qnil;
   }
-  return Qfalse;
+  FIOBJ ch = fiobj_str_new(RSTRING_PTR(to), RSTRING_LEN(to));
+  e->engine->subscribe(e->engine, ch, SYM2ID(match) == redis_id);
+  fiobj_free(ch);
+  return to;
+#endif
   (void)self;
-  (void)engine;
+  (void)to;
+  (void)match;
 }
 
 /**
-This method resets the engine, (re)sending all the current subscription data as
-if the {register} method was just called.
+OVERRIDE this callback - it will be called by {Iodine} whenever the whole
+process CLUSTER (not just this process) unsubscribes from a stream / channel.
 */
-static VALUE iodine_engine_reset(VALUE self) {
-  return iodine_engine_reset2(self, self);
-}
-
-/* *****************************************************************************
-Ruby Subscription Object
-***************************************************************************** */
-typedef struct {
-  uintptr_t subscription;
-  intptr_t uuid;
-  void *owner;
-  iodine_pubsub_type_e type;
-} iodine_subscription_s;
-
-static inline iodine_subscription_s subscription_data(VALUE self) {
-  iodine_subscription_s data = {.uuid = iodine_get_fd(self)};
-  if (data.uuid && !sock_isvalid(data.uuid)) {
-    iodine_set_fd(self, -1);
-    data.uuid = -1;
-    return data;
-  }
-
-  data.subscription =
-      ((uintptr_t)NUM2LL(rb_ivar_get(self, iodine_timeout_var_id)));
-  data.owner = iodine_get_cdata(self);
-  if (!data.owner) {
-    data.type = IODINE_PUBSUB_GLOBAL;
-  } else if ((uintptr_t)data.owner & 1) {
-    data.owner = (void *)((uintptr_t)data.owner & (~(uintptr_t)1));
-    data.type = IODINE_PUBSUB_SSE;
-  } else {
-    data.type = IODINE_PUBSUB_WEBSOCKET;
+static VALUE iodine_pubsub_unsubscribe(VALUE self, VALUE to, VALUE match) {
+  return Qnil;
+#if 0
+  iodine_pubsub_s *e = iodine_pubsub_CData(self);
+  if (e->engine == &e->do_not_touch) {
+    /* this is a Ruby engine, nothing to do. */
+    return Qnil;
   }
-  return data;
+  FIOBJ ch = fiobj_str_new(RSTRING_PTR(to), RSTRING_LEN(to));
+  e->engine->unsubscribe(e->engine, ch, SYM2ID(match) == redis_id);
+  fiobj_free(ch);
+  return to;
+#endif
+  (void)self;
+  (void)to;
+  (void)match;
 }
 
-static inline VALUE subscription_initialize(uintptr_t sub, intptr_t uuid,
-                                            void *owner,
-                                            iodine_pubsub_type_e type,
-                                            VALUE channel) {
-  VALUE self = RubyCaller.call(IodinePubSubSubscription, iodine_new_func_id);
-  if (type == IODINE_PUBSUB_SSE)
-    owner = (void *)((uintptr_t)owner | (uintptr_t)1);
-  iodine_set_cdata(self, owner);
-  iodine_set_fd(self, uuid);
-  rb_ivar_set(self, to_str_shadow_id, channel);
-  rb_ivar_set(self, iodine_timeout_var_id, ULL2NUM(sub));
-  return self;
-}
+/**
+OVERRIDE this callback - it will be called by {Iodine} whenever the
+{Iodine.publish} (or {Iodine::Connection#publish}) is called for this engine.
 
-// static void set_subscription(VALUE self, pubsub_sub_pt sub) {
-//   iodine_set_cdata(self, sub);
-// }
+If this {Engine} is set as the default {Engine}, then any call to
+{Iodine.publish} (or {Iodine::Connection#publish} will invoke this callback
+(unless another {Engine} was specified).
 
-/** Closes (cancels) a subscription. */
-static VALUE close_subscription(VALUE self) {
-  iodine_subscription_s data = subscription_data(self);
-  if (!data.subscription)
+NOTE: this callback is called per process event (not per cluster event) and the
+{Engine} is responsible for message propagation.
+*/
+static VALUE iodine_pubsub_publish(VALUE self, VALUE to, VALUE message) {
+  iodine_pubsub_s *e = iodine_pubsub_CData(self);
+  if (e->engine == &e->do_not_touch) {
+    /* this is a Ruby engine, nothing to do. */
     return Qnil;
-  switch (data.type) {
-  case IODINE_PUBSUB_GLOBAL:
-    pubsub_unsubscribe((pubsub_sub_pt)data.subscription);
-    break;
-  case IODINE_PUBSUB_WEBSOCKET:
-    websocket_unsubscribe(data.owner, data.subscription);
-    break;
-  case IODINE_PUBSUB_SSE:
-    http_sse_unsubscribe(data.owner, data.subscription);
-    break;
-  }
-  rb_ivar_set(self, iodine_timeout_var_id, ULL2NUM(0));
-  return Qnil;
-}
-
-/** Test if the subscription's target is equal to String. */
-static VALUE subscription_eq_s(VALUE self, VALUE str) {
-  return rb_str_equal(rb_attr_get(self, to_str_shadow_id), str);
-}
-
-/** Returns the target stream / channel / pattern as a String object. */
-static VALUE subscription_to_s(VALUE self) {
-  return rb_attr_get(self, to_str_shadow_id);
-}
-
-/* *****************************************************************************
-Ruby API
-***************************************************************************** */
-
-pubsub_engine_s *iodine_engine_ruby2facil(VALUE ruby_engine) {
-  if (ruby_engine == Qnil || ruby_engine == Qfalse)
-    return NULL;
-  iodine_engine_s *engine;
-  Data_Get_Struct(ruby_engine, iodine_engine_s, engine);
-  if (engine)
-    return engine->p;
-  return NULL;
+  }
+  FIOBJ ch, msg;
+  ch = fiobj_str_new(RSTRING_PTR(to), RSTRING_LEN(to));
+  msg = fiobj_str_new(RSTRING_PTR(message), RSTRING_LEN(message));
+  e->engine->publish(e->engine, ch, msg);
+  fiobj_free(ch);
+  fiobj_free(msg);
+  return self;
+  (void)self;
+  (void)to;
+  (void)message;
 }
 
 /* *****************************************************************************
-C => Ruby Bridge
+Ruby <=> C Data Type
 ***************************************************************************** */
 
-struct engine_gvl_args_s {
-  const pubsub_engine_s *eng;
-  FIOBJ ch;
-  FIOBJ msg;
-  uint8_t use_pattern;
-};
-
-static void *engine_subscribe_inGVL(void *a_) {
-  struct engine_gvl_args_s *args = a_;
-  VALUE eng = ((iodine_engine_s *)args->eng)->handler;
-  if (!eng || eng == Qnil || eng == Qfalse)
-    return NULL;
-  VALUE data[2];
-  fio_cstr_s tmp = fiobj_obj2cstr(args->ch);
-  data[1] = args->use_pattern ? Qtrue : Qnil;
-  data[0] = rb_str_new(tmp.data, tmp.len);
-  eng = RubyCaller.call2(eng, engine_subid, 2, data);
-  return NULL;
-}
-
-/* Should return 0 on success and -1 on failure. */
-static void engine_subscribe(const pubsub_engine_s *eng, FIOBJ ch,
-                             uint8_t use_pattern) {
-  struct engine_gvl_args_s args = {
-      .eng = eng, .ch = ch, .use_pattern = use_pattern,
-  };
-  RubyCaller.call_c(engine_subscribe_inGVL, &args);
+/* a callback for the GC (marking active objects) */
+static void iodine_pubsub_data_mark(void *c_) {
+  iodine_pubsub_s *c = c_;
+  if (c->handler != Qnil) {
+    rb_gc_mark(c->handler);
+  }
 }
-
-static void *engine_unsubscribe_inGVL(void *a_) {
-  struct engine_gvl_args_s *args = a_;
-  VALUE eng = ((iodine_engine_s *)args->eng)->handler;
-  if (!eng || eng == Qnil || eng == Qfalse)
-    return NULL;
-  VALUE data[2];
-  fio_cstr_s tmp = fiobj_obj2cstr(args->ch);
-  data[1] = args->use_pattern ? Qtrue : Qnil;
-  data[0] = rb_str_new(tmp.data, tmp.len);
-  RubyCaller.call2(eng, engine_unsubid, 2, data);
-  return NULL;
+/* a callback for the GC (marking active objects) */
+static void iodine_pubsub_data_free(void *c_) {
+  iodine_pubsub_s *data = c_;
+  if (data->dealloc) {
+    data->dealloc(data->engine);
+  }
+  free(data);
 }
 
-/* Return value is ignored - nothing should be returned. */
-static void engine_unsubscribe(const pubsub_engine_s *eng, FIOBJ ch,
-                               uint8_t use_pattern) {
-  struct engine_gvl_args_s args = {
-      .eng = eng, .ch = ch, .use_pattern = use_pattern,
-  };
-  RubyCaller.call_c(engine_unsubscribe_inGVL, &args);
+static size_t iodine_pubsub_data_size(const void *c_) {
+  return sizeof(iodine_pubsub_s);
+  (void)c_;
 }
 
-static void *engine_publish_inGVL(void *a_) {
-  struct engine_gvl_args_s *args = a_;
-  VALUE eng = ((iodine_engine_s *)args->eng)->handler;
-  if (!eng || eng == Qnil || eng == Qfalse)
-    return NULL;
-  VALUE data[2];
-  fio_cstr_s tmp = fiobj_obj2cstr(args->ch);
-  data[0] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(data[0]);
-  tmp = fiobj_obj2cstr(args->msg);
-  data[1] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(data[1]);
-  eng = RubyCaller.call2(eng, iodine_engine_pubid, 2, data);
-  Registry.remove(data[0]);
-  Registry.remove(data[1]);
-  return ((eng == Qfalse || eng == Qnil) ? (void *)-1 : 0);
-}
+const rb_data_type_t iodine_pubsub_data_type = {
+    .wrap_struct_name = "IodinePubSubData",
+    .function =
+        {
+            .dmark = iodine_pubsub_data_mark,
+            .dfree = iodine_pubsub_data_free,
+            .dsize = iodine_pubsub_data_size,
+        },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
-/* Should return 0 on success and -1 on failure. */
-static int engine_publish(const pubsub_engine_s *eng, FIOBJ ch, FIOBJ msg) {
-  struct engine_gvl_args_s args = {
-      .eng = eng, .ch = ch, .msg = msg,
+/* Iodine::PubSub::Engine.allocate */
+static VALUE iodine_pubsub_data_alloc_c(VALUE self) {
+  iodine_pubsub_s *c = malloc(sizeof(*c));
+  *c = (iodine_pubsub_s){
+      .do_not_touch =
+          {
+              .subscribe = iodine_pubsub_on_subscribe,
+              .unsubscribe = iodine_pubsub_on_unsubscribe,
+              .publish = iodine_pubsub_on_publish,
+              .on_startup = iodine_pubsub_on_startup,
+          },
+      .handler = Qnil,
+      .engine = &c->do_not_touch,
   };
-  return RubyCaller.call_c(engine_publish_inGVL, &args) ? 0 : -1;
+  return TypedData_Wrap_Struct(self, &iodine_pubsub_data_type, c);
 }
 
 /* *****************************************************************************
-C <=> Ruby Data allocation
+C engines
 ***************************************************************************** */
 
-/* a callback for the GC (marking active objects) */
-static void engine_mark(void *eng_) {
-  iodine_engine_s *eng = eng_;
-  rb_gc_mark(eng->handler);
-}
-/* a callback for the GC (marking active objects) */
-static void engine_free(void *eng_) {
-  iodine_engine_s *eng = eng_;
-  if (eng->dealloc)
-    eng->dealloc(eng->p);
-  free(eng);
-}
-
-/* Iodine::PubSub::Engine.allocate */
-static VALUE engine_alloc_c(VALUE self) {
-  iodine_engine_s *eng = malloc(sizeof(*eng));
-  if (TYPE(self) == T_CLASS)
-    *eng = (iodine_engine_s){
-        .handler = (VALUE)0,
-        .engine =
-            {
-                .subscribe = engine_subscribe,
-                .unsubscribe = engine_unsubscribe,
-                .publish = engine_publish,
-            },
-        .p = &eng->engine,
-    };
-
-  return Data_Wrap_Struct(self, engine_mark, engine_free, eng);
-}
-
-static VALUE engine_initialize(VALUE self) {
-  iodine_engine_s *engine;
-  Data_Get_Struct(self, iodine_engine_s, engine);
-  if (TYPE(self) == T_CLASS) {
-    fprintf(stderr, "This sucks...\n");
+static VALUE iodine_pubsub_make_C_engine(const pubsub_engine_s *e) {
+  VALUE engine = IodineCaller.call(EngineClass, rb_intern2("new", 3));
+  if (engine == Qnil) {
+    return Qnil;
   }
-  engine->handler = self;
-  return self;
+  iodine_pubsub_CData(engine)->engine = (pubsub_engine_s *)e;
+  return engine;
 }
 
 /* *****************************************************************************
-Redis
+PubSub module methods
 ***************************************************************************** */
 
-struct redis_callback_data {
-  FIOBJ msg;
-  VALUE block;
-};
-
-/*
-Perform a Redis message callback in the GVL
-*/
-static void *perform_redis_callback_inGVL(void *data) {
-  struct redis_callback_data *a = data;
-  VALUE reply = fiobj2rb_deep(a->msg, 1);
-  Registry.add(reply);
-  rb_funcallv(a->block, iodine_call_proc_id, 1, &reply);
-  Registry.remove(a->block);
-  Registry.remove(reply);
-  return NULL;
-}
-
-/*
-Redis message callback
-*/
-static void redis_callback(pubsub_engine_s *e, FIOBJ reply, void *block) {
-  struct redis_callback_data d = {
-      .msg = reply, .block = (VALUE)block,
-  };
-  RubyCaller.call_c(perform_redis_callback_inGVL, &d);
-  (void)e;
-}
-
-/**
-Sends commands / messages to the underlying Redis Pub connection.
-
-The method accepts an optional callback block. i.e.:
-
-      redis.send("Echo", "Hello World!") do |reply|
-         p reply # => ["Hello World!"]
-      end
-
-This connection is only for publishing and database commands. The Sub commands,
-such as SUBSCRIBE and PSUBSCRIBE, will break the engine.
-*/
-static VALUE redis_send(int argc, VALUE *argv, VALUE self) {
-  if (argc < 1)
-    rb_raise(rb_eArgError,
-             "wrong number of arguments (given %d, expected at least 1).",
-             argc);
-  Check_Type(argv[0], T_STRING);
-  FIOBJ data = FIOBJ_INVALID;
-  FIOBJ cmd = FIOBJ_INVALID;
-  if (argc > 1) {
-    for (int i = 0; i < argc; ++i) {
-      if (TYPE(argv[i]) == T_SYMBOL)
-        argv[i] = rb_sym2str(argv[i]);
-      if (TYPE(argv[i]) != T_FIXNUM)
-        Check_Type(argv[i], T_STRING);
-    }
-    data = fiobj_ary_new();
-    for (int i = 0; i < argc; ++i) {
-      if (TYPE(argv[i]) == T_FIXNUM)
-        fiobj_ary_push(data, fiobj_num_new(FIX2LONG(argv[i])));
-      else
-        fiobj_ary_push(
-            data, fiobj_str_new(RSTRING_PTR(argv[i]), RSTRING_LEN(argv[i])));
-    }
+/** Sets the default {Iodine::PubSub::Engine} for pub/sub methods. */
+static VALUE iodine_pubsub_default_set(VALUE self, VALUE engine) {
+  if (engine == Qnil) {
+    engine = rb_const_get(self, rb_intern2("CLUSTER", 7));
   }
-  cmd = fiobj_str_new(RSTRING_PTR(argv[0]), RSTRING_LEN(argv[0]));
-  iodine_engine_s *e;
-  Data_Get_Struct(self, iodine_engine_s, e);
-
-  if (rb_block_given_p()) {
-    VALUE block = rb_block_proc();
-    Registry.add(block);
-    redis_engine_send(e->p, cmd, data, redis_callback, (void *)block);
-    return block;
-  } else {
-    redis_engine_send(e->p, cmd, data, NULL, NULL);
+  iodine_pubsub_s *e = iodine_pubsub_CData(engine);
+  if (!e) {
+    rb_raise(rb_eTypeError, "not a valid engine");
+    return Qnil;
   }
-  fiobj_free(cmd);
-  fiobj_free(data);
-  return Qtrue;
+  if (e->handler == Qnil) {
+    e->handler = engine;
+  }
+  PUBSUB_DEFAULT_ENGINE = e->engine;
+  rb_ivar_set(self, rb_intern2("default_engine", 14), engine);
+  return engine;
 }
 
-/**
-Initializes a new RedisEngine for Pub/Sub.
-
-use:
-
-    RedisEngine.new(address, port = 6379, ping_interval = 0)
-
-Accepts:
-
-address:: the Redis server's address. Required.
-port:: the Redis Server port. Default: 6379
-ping:: the PING interval up to 255 seconds. Default: 0 (~5 minutes).
-auth:: authentication password. Default: none.
-*/
-static VALUE redis_engine_initialize(int argc, VALUE *argv, VALUE self) {
-  if (argc < 1 || argc > 4)
-    rb_raise(rb_eArgError,
-             "wrong number of arguments (given %d, expected 1..4).", argc);
-  VALUE address = argv[0];
-  VALUE port = argc >= 2 ? argv[1] : Qnil;
-  VALUE ping = argc >= 3 ? argv[2] : Qnil;
-  VALUE auth = argc >= 4 ? argv[3] : Qnil;
-  Check_Type(address, T_STRING);
-  if (port != Qnil) {
-    if (TYPE(port) == T_FIXNUM)
-      port = rb_fix2str(port, 10);
-    Check_Type(port, T_STRING);
-  }
-  if (ping != Qnil)
-    Check_Type(ping, T_FIXNUM);
-  if (auth != Qnil) {
-    Check_Type(auth, T_STRING);
-  }
-  size_t iping = FIX2LONG(ping);
-  if (iping > 255)
-    rb_raise(rb_eRangeError, "ping_interval too big (0..255)");
-
-  iodine_engine_s *engine;
-  Data_Get_Struct(self, iodine_engine_s, engine);
-  engine->handler = self;
-  engine->p =
-      redis_engine_create(.address = StringValueCStr(address),
-                          .port =
-                              (port == Qnil ? "6379" : StringValueCStr(port)),
-                          .ping_interval = iping,
-                          .auth = (auth == Qnil ? NULL : StringValueCStr(auth)),
-                          .auth_len = (auth == Qnil ? 0 : RSTRING_LEN(auth)));
-  engine->dealloc = redis_engine_destroy;
-  if (!engine->p)
-    rb_raise(rb_eRuntimeError, "unknown error, can't initialize RedisEngine.");
-  return self;
+/** Returns the default {Iodine::PubSub::Engine} for pub/sub methods. */
+static VALUE iodine_pubsub_default_get(VALUE self) {
+  VALUE def = rb_ivar_get(self, rb_intern2("default_engine", 14));
+  if (def == Qnil) {
+    def = rb_const_get(self, rb_intern2("CLUSTER", 7));
+    iodine_pubsub_default_set(self, def);
+  }
+  return def;
 }
 
-/* *****************************************************************************
-PubSub settings
-***************************************************************************** */
-
 /**
-Sets the default Pub/Sub engine to be used.
-
-See {Iodine::PubSub} and {Iodine::PubSub::Engine} for more details.
-*/
-static VALUE ips_set_default(VALUE self, VALUE en) {
-  iodine_engine_s *e;
-  Data_Get_Struct(en, iodine_engine_s, e);
-  if (!e)
-    rb_raise(rb_eArgError, "deafult engine must be an Iodine::PubSub::Engine.");
-  if (!e->p)
-    rb_raise(rb_eArgError, "This Iodine::PubSub::Engine is broken.");
-  rb_ivar_set(Iodine, default_pubsubid, en);
-  PUBSUB_DEFAULT_ENGINE = e->p;
-  return en;
+ * Attaches an {Iodine::PubSub::Engine} to the pub/sub system (more than a
+ * single engine can be attached at the same time).
+ *
+ * After an engine was attached, it's callbacks will be called
+ * ({Iodine::PubSub::Engine#subscribe} and {Iodine::PubSub::Engine#unsubscribe})
+ * in response to Pub/Sub events.
+ */
+static VALUE iodine_pubsub_attach(VALUE self, VALUE engine) {
+  iodine_pubsub_s *e = iodine_pubsub_CData(engine);
+  if (!e) {
+    rb_raise(rb_eTypeError, "not a valid engine");
+    return Qnil;
+  }
+  if (e->handler == Qnil) {
+    e->handler = engine;
+  }
+  IodineStore.add(engine);
+  pubsub_engine_register(e->engine);
+  return engine;
   (void)self;
 }
 
-/** Deprecated. Use {Iodine::PubSub.default_engine=}. */
-static VALUE ips_set_default_dep(VALUE self, VALUE en) {
-  fprintf(stderr, "WARNING: Iodine.default_pubsub is deprecated. Use "
-                  "Iodine::PubSub.default_engine.\n");
-  return ips_set_default(self, en);
-}
-
 /**
-Returns the default Pub/Sub engine (if any).
-
-See {Iodine::PubSub} and {Iodine::PubSub::Engine} for more details.
-*/
-static VALUE ips_get_default(VALUE self) {
-  return rb_ivar_get(Iodine, default_pubsubid);
+ * Removes an {Iodine::PubSub::Engine} from the pub/sub system.
+ *
+ * After an {Iodine::PubSub::Engine} was detached, Iodine will no longer call
+ * the {Iodine::PubSub::Engine}'s callbacks ({Iodine::PubSub::Engine#subscribe}
+ * and {Iodine::PubSub::Engine#unsubscribe})
+ */
+static VALUE iodine_pubsub_dettach(VALUE self, VALUE engine) {
+  iodine_pubsub_s *e = iodine_pubsub_CData(engine);
+  if (!e) {
+    rb_raise(rb_eTypeError, "not a valid engine");
+    return Qnil;
+  }
+  if (e->handler == Qnil) {
+    e->handler = engine;
+  }
+  IodineStore.remove(engine);
+  pubsub_engine_deregister(e->engine);
+  return engine;
   (void)self;
 }
 
 /**
-Deprecated. Use {Iodine::PubSub.default_engine}.
-*/
-static VALUE ips_get_default_dep(VALUE self) {
-  fprintf(stderr, "WARNING: Iodine.default_pubsub is deprecated. Use "
-                  "Iodine::PubSub.default_engine.\n");
-  return ips_get_default(self);
+ * Forces {Iodine} to call the {Iodine::PubSub::Engine#subscribe} callback for
+ * all existing subscriptions (i.e., when reconnecting to a Pub/Sub backend such
+ * as Redis).
+ */
+static VALUE iodine_pubsub_reset(VALUE self, VALUE engine) {
+  iodine_pubsub_s *e = iodine_pubsub_CData(engine);
+  if (!e) {
+    rb_raise(rb_eTypeError, "not a valid engine");
+    return Qnil;
+  }
+  if (e->handler == Qnil) {
+    e->handler = engine;
+  }
+  pubsub_engine_resubscribe(e->engine);
+  return engine;
+  (void)self;
 }
 
 /* *****************************************************************************
-Pub/Sub API
+Redis Engine
 ***************************************************************************** */
 
-static void iodine_on_unsubscribe(void *u1, void *u2) {
-  if (u1 && (VALUE)u1 != Qnil && u1 != (VALUE)Qfalse)
-    Registry.remove((VALUE)u1);
-  (void)u2;
-}
+/**
+Initializes a new {Iodine::PubSub::Redis} engine.
 
-static void *on_pubsub_notificationinGVL(pubsub_message_s *n) {
-  VALUE rbn[2];
-  fio_cstr_s tmp = fiobj_obj2cstr(n->channel);
-  rbn[0] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(rbn[0]);
-  tmp = fiobj_obj2cstr(n->message);
-  rbn[1] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(rbn[1]);
-  RubyCaller.call2((VALUE)n->udata1, iodine_call_proc_id, 2, rbn);
-  Registry.remove(rbn[0]);
-  Registry.remove(rbn[1]);
-  return NULL;
-}
+    Iodine::PubSub::Redis.new(url, opt = {})
 
-static void on_pubsub_notificationin(pubsub_message_s *n) {
-  RubyCaller.call_c((void *(*)(void *))on_pubsub_notificationinGVL, n);
-}
+use:
 
-static void iodine_on_unsubscribe_ws(void *u) {
-  if (u && (VALUE)u != Qnil && u != (VALUE)Qfalse)
-    Registry.remove((VALUE)u);
-}
+    REDIS_URL = "redis://localhost:6379/"
+    Iodine::PubSub::Redis.new(REDIS_URL, ping: 50) #pings every 50 seconds
 
-static void *
-on_pubsub_notificationinGVL_ws(websocket_pubsub_notification_s *n) {
-  VALUE rbn[2];
-  fio_cstr_s tmp = fiobj_obj2cstr(n->channel);
-  rbn[0] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(rbn[0]);
-  tmp = fiobj_obj2cstr(n->message);
-  rbn[1] = rb_str_new(tmp.data, tmp.len);
-  Registry.add(rbn[1]);
-  RubyCaller.call2((VALUE)n->udata, iodine_call_proc_id, 2, rbn);
-  Registry.remove(rbn[0]);
-  Registry.remove(rbn[1]);
-  return NULL;
-}
+To use Redis authentication, add the password to the URL. i.e.:
 
-static void on_pubsub_notificationin_ws(websocket_pubsub_notification_s n) {
-  RubyCaller.call_c((void *(*)(void *))on_pubsub_notificationinGVL_ws, &n);
-}
+    REDIS_URL = "redis://redis:password@localhost:6379/"
+    Iodine::PubSub::Redis.new(REDIS_URL, ping: 50) #pings every 50 seconds
 
-static void on_pubsub_notificationin_sse(http_sse_s *sse, FIOBJ channel,
-                                         FIOBJ message, void *udata) {
-  websocket_pubsub_notification_s n = {
-      .channel = channel, .message = message, .udata = udata};
-  RubyCaller.call_c((void *(*)(void *))on_pubsub_notificationinGVL, &n);
-  (void)sse;
-}
+The options hash accepts:
 
-/** Subscribes to a Pub/Sub channel - internal implementation */
-VALUE iodine_subscribe(int argc, VALUE *argv, void *owner,
-                       iodine_pubsub_type_e type) {
-
-  VALUE rb_ch = Qnil;
-  VALUE rb_opt = 0;
-  VALUE block = 0;
-  uint8_t use_pattern = 0, force_text = 1, force_binary = 0;
-  intptr_t uuid = 0;
-
-  switch (argc) {
-  case 2:
-    rb_ch = argv[0];
-    rb_opt = argv[1];
-    break;
-  case 1:
-    /* single argument must be a Hash / channel name */
-    if (TYPE(argv[0]) == T_HASH) {
-      rb_opt = argv[0];
-      rb_ch = rb_hash_aref(argv[0], to_sym_id);
-      if (rb_ch == Qnil || rb_ch == Qfalse) {
-        /* temporary backport support */
-        rb_ch = rb_hash_aref(argv[0], channel_sym_id);
-        if (rb_ch) {
-          fprintf(stderr,
-                  "WARNING: use of :channel in subscribe is deprecated.\n");
-        }
-      }
-    } else {
-      rb_ch = argv[0];
-    }
-    break;
-  default:
-    rb_raise(rb_eArgError, "method accepts 1 or 2 arguments.");
+:ping:: the PING interval up to 255 seconds. Default: 0 (~5 minutes).
+*/
+static VALUE iodine_pubsub_redis_new(int argc, VALUE *argv, VALUE self) {
+  if (!argc) {
+    rb_raise(rb_eArgError, "Iodine::PubSub::Redis.new(address, opt={}) "
+                           "requires at least 1 argument.");
+  }
+  VALUE url = argv[0];
+  Check_Type(url, T_STRING);
+  if (RSTRING_LEN(url) > 4096) {
+    rb_raise(rb_eArgError, "Redis URL too long.");
+  }
+  FIOBJ port = FIOBJ_INVALID;
+  FIOBJ address = FIOBJ_INVALID;
+  FIOBJ auth = FIOBJ_INVALID;
+  uint8_t ping = 0;
+
+  iodine_pubsub_s *e = iodine_pubsub_CData(self);
+  if (!e) {
+    rb_raise(rb_eTypeError, "not a valid engine");
     return Qnil;
   }
 
-  if (rb_ch == Qnil || rb_ch == Qfalse) {
-    rb_raise(rb_eArgError,
-             "a target (:to) subject / stream / channel is required.");
+  /* extract options */
+  if (argc == 2) {
+    Check_Type(argv[1], T_HASH);
+    VALUE tmp = rb_hash_aref(argv[1], rb_id2sym(rb_intern2("ping", 4)));
+    if (tmp != Qnil) {
+      Check_Type(tmp, T_FIXNUM);
+      if (NUM2SIZET(tmp) > 255) {
+        rb_raise(rb_eArgError,
+                 ":ping must be a non-negative integer under 255 seconds.");
+      }
+      ping = (uint8_t)NUM2SIZET(tmp);
+    }
   }
 
-  if (TYPE(rb_ch) == T_SYMBOL)
-    rb_ch = rb_sym2str(rb_ch);
-  Check_Type(rb_ch, T_STRING);
-
-  if (rb_opt) {
-    if (type == IODINE_PUBSUB_WEBSOCKET &&
-        rb_hash_aref(rb_opt, as_sym_id) == binary_sym_id) {
-      force_text = 0;
-      force_binary = 1;
+  /* parse URL assume redis://redis:password@localhost:6379 */
+  {
+    size_t l = RSTRING_LEN(url);
+    char *str = RSTRING_PTR(url);
+    char *pointers[5];
+    char *end = str + l;
+    uint8_t flag = 1;
+    uint8_t counter = 0;
+    for (size_t i = 0; i < l; i++) {
+      if (counter > 4)
+        goto finish;
+      if (str[i] == ':' && str[i + 1] == '/' && str[i + 2] == '/') {
+        pointers[counter++] = str + i + 3;
+        i = i + 2;
+        flag = 0;
+        continue;
+      }
+      if (str[i] == '@' && counter == 1 - flag) {
+        rb_raise(rb_eArgError, "malformed URL");
+      }
+      if (str[i] == ':' || str[i] == '@') {
+        pointers[counter++] = str + i + 1;
+        continue;
+      }
+      if (str[i] == '/') {
+        end = str + i;
+        break;
+      }
     }
-    if (rb_hash_aref(rb_opt, match_sym_id) == redis_sym_id) {
-      use_pattern = 1;
+    if (flag) {
+      if (counter > 3) {
+        rb_raise(rb_eArgError, "malformed URL");
+      }
+      /* move pointers one step forward and set 0 to str... */
+      char *pointers_2[5];
+      for (size_t i = 0; i < counter; ++i) {
+        pointers_2[i + 1] = pointers[i];
+      }
+      pointers_2[0] = str;
+      ++counter;
+      for (size_t i = 0; i < counter; ++i) {
+        pointers[i] = pointers_2[i];
+      }
+    }
+    /* review results */
+    switch (counter) {
+    case 1:
+      /* redis://localhost */
+      if (pointers[0] == end) {
+        goto finish;
+      }
+      address = fiobj_str_new(pointers[0], end - pointers[0]);
+      break;
+    case 2:
+      /* redis://localhost:6379 */
+      if (pointers[1] - pointers[0] - 1 == 0) {
+        goto finish;
+      }
+      address = fiobj_str_new(pointers[0], pointers[1] - pointers[0] - 1);
+      if (pointers[1] != end) {
+        port = fiobj_str_new(pointers[1], end - pointers[1]);
+      }
+      break;
+    case 3:
+      /* redis://redis:password@localhost */
+      if (pointers[2] - pointers[1] - 1 == 0 || end - pointers[2] == 0) {
+        goto finish;
+      }
+      address = fiobj_str_new(pointers[2], end - pointers[2]);
+      auth = fiobj_str_new(pointers[1], pointers[2] - pointers[1] - 1);
+      break;
+    case 4:
+      /* redis://redis:password@localhost:6379 */
+      if (pointers[2] - pointers[1] - 1 == 0 ||
+          pointers[3] - pointers[2] - 1 == 0 || end - pointers[3] == 0) {
+        goto finish;
+      }
+      port = fiobj_str_new(pointers[3], end - pointers[3]);
+      address = fiobj_str_new(pointers[2], pointers[3] - pointers[2] - 1);
+      auth = fiobj_str_new(pointers[1], pointers[2] - pointers[1] - 1);
+      break;
+    default:
+      goto finish;
     }
-    block = rb_hash_aref(rb_opt, handler_sym_id);
-    if (block != Qnil)
-      Registry.add(block);
+  }
+  fprintf(
+      stderr,
+      "INFO: Initializing Redis engine for address: %s - port: %s -  auth %s\n",
+      fiobj_obj2cstr(address).data, fiobj_obj2cstr(port).data,
+      fiobj_obj2cstr(auth).data);
+  /* create engine */
+  e->engine = redis_engine_create(
+          .address = fiobj_obj2cstr(address)
+          .data,
+          .port = (port == FIOBJ_INVALID ? "6379" : fiobj_obj2cstr(port).data),
+          .ping_interval = ping,
+          .auth = (auth == FIOBJ_INVALID ? NULL : fiobj_obj2cstr(auth).data),
+          .auth_len = (auth == FIOBJ_INVALID ? 0 : fiobj_obj2cstr(auth).len));
+  if (!e->engine) {
+    e->engine = &e->do_not_touch;
+  } else {
+    e->dealloc = redis_engine_destroy;
   }
 
+finish:
+  fiobj_free(port);
+  fiobj_free(address);
+  fiobj_free(auth);
+  if (e->engine == &e->do_not_touch) {
+    rb_raise(rb_eArgError,
+             "Error initializing the Redis engine - malformed URL?");
+  }
+  return self;
+  (void)self;
+  (void)argc;
+  (void)argv;
+}
+
+/** A callback for Redis commands. */
+static void iodine_pubsub_redis_callback(pubsub_engine_s *e, FIOBJ response,
+                                         void *udata) {
+  VALUE block = (VALUE)udata;
   if (block == Qnil) {
-    if (rb_block_given_p()) {
-      block = rb_block_proc();
-      Registry.add(block);
-    } else if (type == IODINE_PUBSUB_GLOBAL) {
-      rb_need_block();
-      return Qnil;
-    }
+    return;
   }
-  if (block == Qnil)
-    block = 0;
-
-  FIOBJ ch = fiobj_str_new(RSTRING_PTR(rb_ch), RSTRING_LEN(rb_ch));
-
-  uintptr_t sub = 0;
-  switch (type) {
-  case IODINE_PUBSUB_GLOBAL:
-    sub = (uintptr_t)pubsub_subscribe(.channel = ch, .use_pattern = use_pattern,
-                                      .on_message = on_pubsub_notificationin,
-                                      .on_unsubscribe = iodine_on_unsubscribe,
-                                      .udata1 = (void *)block);
-    break;
-  case IODINE_PUBSUB_WEBSOCKET:
-    uuid = websocket_uuid(owner);
-    sub = websocket_subscribe(
-        owner, .channel = ch, .use_pattern = use_pattern,
-        .force_text = force_text, .force_binary = force_binary,
-        .on_message = (block ? on_pubsub_notificationin_ws : NULL),
-        .on_unsubscribe = (block ? iodine_on_unsubscribe_ws : NULL),
-        .udata = (void *)block);
-    break;
-  case IODINE_PUBSUB_SSE:
-    uuid = http_sse2uuid(owner);
-    sub = http_sse_subscribe(
-        owner, .channel = ch, .use_pattern = use_pattern,
-        .on_message = (block ? on_pubsub_notificationin_sse : NULL),
-        .on_unsubscribe = (block ? iodine_on_unsubscribe_ws : NULL),
-        .udata = (void *)block);
-
-    break;
+  VALUE rb = Qnil;
+  if (!FIOBJ_IS_NULL(response)) {
+    rb = IodineStore.add(fiobj2rb_deep(response, 0));
   }
-
-  fiobj_free(ch);
-  if (!sub)
-    return Qnil;
-  return subscription_initialize(sub, uuid, owner, type, rb_ch);
+  IodineCaller.call2(block, call_id, 1, &rb);
+  IodineStore.remove(rb);
+  IodineStore.remove(block);
+  (void)e;
 }
 
 // clang-format off
 /**
-Subscribes to a Pub/Sub channel.
+Sends a Redis command. Accepts an optional block that will recieve the response.
 
-The method accepts 1-2 arguments and an optional block. These are all valid ways
-to call the method:
+i.e.:
 
-      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
-
-The first argument must be either a String or a Hash.
-
-The second, optional, argument must be a Hash (if given).
-
-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.
-
-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 iodine_subscribe_global(int argc, VALUE *argv, VALUE self) {
-  // clang-format on
-  return iodine_subscribe(argc, argv, NULL, IODINE_PUBSUB_GLOBAL);
-  (void)self;
+    REDIS_URL = "redis://redis:password@localhost:6379/"
+    redis = Iodine::PubSub::Redis.new(REDIS_URL, ping: 50) #pings every 50 seconds
+    Iodine::PubSub.default = redis
+    redis.cmd("KEYS", "*") {|result| p result
 }
 
-/**
-Publishes a message to a channel.
-
-Can be used using two Strings:
-
-      publish(to, message)
-
-The method accepts an optional `engine` argument:
-
-      publish(to, message, my_pubsub_engine)
-
-
-Alternatively, accepts the following named arguments:
-
-:to :: The channel to publish to (required).
-
-:message :: The message to be published (required).
-
-:engine :: If provided, the engine to use for pub/sub. Otherwise the default
-engine is used.
 
 */
-VALUE iodine_publish(int argc, VALUE *argv, VALUE self) {
-  VALUE rb_ch, rb_msg, rb_engine = Qnil;
-  const pubsub_engine_s *engine = NULL;
-  switch (argc) {
-  case 3:
-    /* fallthrough */
-    rb_engine = argv[2];
-  case 2:
-    rb_ch = argv[0];
-    rb_msg = argv[1];
-    break;
-  case 1: {
-    /* single argument must be a Hash */
-    Check_Type(argv[0], T_HASH);
-    rb_ch = rb_hash_aref(argv[0], to_sym_id);
-    if (rb_ch == Qnil || rb_ch == Qfalse) {
-      rb_ch = rb_hash_aref(argv[0], channel_sym_id);
-    }
-    rb_msg = rb_hash_aref(argv[0], message_sym_id);
-    rb_engine = rb_hash_aref(argv[0], engine_varid);
-  } break;
-  default:
-    rb_raise(rb_eArgError, "method accepts 1-3 arguments.");
+static VALUE iodine_pubsub_redis_cmd(int argc, VALUE *argv, VALUE self) {
+  // clang-format on
+  if (argc <= 0) {
+    rb_raise(rb_eArgError, "Iodine::PubSub::Redis#cmd(command, ...) is missing "
+                           "the required command argument.");
   }
-
-  if (rb_msg == Qnil || rb_msg == Qfalse) {
-    rb_raise(rb_eArgError, "message is required.");
+  iodine_pubsub_s *e = iodine_pubsub_CData(self);
+  if (!e || !e->engine || e->engine == &e->do_not_touch) {
+    rb_raise(rb_eTypeError,
+             "Iodine::PubSub::Redis internal error - obsolete object?");
   }
-  Check_Type(rb_msg, T_STRING);
-
-  if (rb_ch == Qnil || rb_ch == Qfalse)
-    rb_raise(rb_eArgError, "target / channel is required .");
-  if (TYPE(rb_ch) == T_SYMBOL)
-    rb_ch = rb_sym2str(rb_ch);
-  Check_Type(rb_ch, T_STRING);
-
-  if (rb_engine == Qfalse) {
-    engine = PUBSUB_PROCESS_ENGINE;
-  } else if (rb_engine == Qnil) {
-    engine = NULL;
-  } else {
-    engine = iodine_engine_ruby2facil(rb_engine);
+  VALUE block = Qnil;
+  if (rb_block_given_p()) {
+    block = IodineStore.add(rb_block_proc());
   }
+  FIOBJ data = fiobj_ary_new2((size_t)argc);
+  for (int i = 0; i < argc; ++i) {
+    switch (TYPE(argv[i])) {
+    case T_SYMBOL:
+      argv[i] = rb_sym2str(argv[i]);
+    /* overflow */
+    case T_STRING:
+      fiobj_ary_push(data,
+                     fiobj_str_new(RSTRING_PTR(argv[i]), RSTRING_LEN(argv[i])));
+      break;
+    case T_FIXNUM:
+      fiobj_ary_push(data, fiobj_num_new(NUM2SSIZET(argv[i])));
+      break;
+    case T_FLOAT:
+      fiobj_ary_push(data, fiobj_float_new(rb_float_value(argv[i])));
+      break;
+    case T_NIL:
+      fiobj_ary_push(data, fiobj_null());
+      break;
+    case T_TRUE:
+      fiobj_ary_push(data, fiobj_true());
+      break;
+    case T_FALSE:
+      fiobj_ary_push(data, fiobj_false());
+      break;
+    default:
+      goto wrong_type;
+    }
+  }
+  FIOBJ cmd = fiobj_ary_shift(data);
+  if (redis_engine_send(e->engine, cmd, data, iodine_pubsub_redis_callback,
+                        (void *)block)) {
+    iodine_pubsub_redis_callback(e->engine, fiobj_null(), (void *)block);
+  }
+  fiobj_free(cmd);
+  fiobj_free(data);
+  return self;
 
-  FIOBJ ch = fiobj_str_new(RSTRING_PTR(rb_ch), RSTRING_LEN(rb_ch));
-  FIOBJ msg = fiobj_str_new(RSTRING_PTR(rb_msg), RSTRING_LEN(rb_msg));
-
-  intptr_t ret =
-      pubsub_publish(.engine = engine, .channel = ch, .message = msg);
-  fiobj_free(ch);
-  fiobj_free(msg);
-  if (!ret)
-    return Qfalse;
-  return Qtrue;
-  (void)self;
+wrong_type:
+  fiobj_free(data);
+  rb_raise(rb_eArgError,
+           "only String, Number (with limits), Symbol, true, false and nil "
+           "arguments can be used.");
 }
 
 /* *****************************************************************************
-Initialization
+Module initialization
 ***************************************************************************** */
-void Iodine_init_pubsub(void) {
-  default_pubsubid = rb_intern("default_pubsub");
-  engine_subid = rb_intern("subscribe");
-  engine_unsubid = rb_intern("unsubscribe");
-  engine_varid = rb_intern("engine");
-  iodine_engine_pubid = rb_intern("publish");
-  to_str_shadow_id = rb_intern("@to_s");
-
-  as_sym_id = ID2SYM(rb_intern("as"));
-  binary_sym_id = ID2SYM(rb_intern("binary"));
-  handler_sym_id = ID2SYM(rb_intern("handler"));
-  match_sym_id = ID2SYM(rb_intern("match"));
-  message_sym_id = ID2SYM(rb_intern("message"));
-  redis_sym_id = ID2SYM(rb_intern("redis"));
-  text_sym_id = ID2SYM(rb_intern("text"));
-  to_sym_id = ID2SYM(rb_intern("to"));
-
-  channel_sym_id = ID2SYM(rb_intern("channel")); /* bawards compatibility */
-
-  IodinePubSub = rb_define_module_under(Iodine, "PubSub");
-  IodineEngine = rb_define_class_under(IodinePubSub, "Engine", rb_cObject);
-  IodinePubSubSubscription =
-      rb_define_class_under(IodinePubSub, "Subscription", rb_cObject);
-
-  rb_define_method(IodinePubSubSubscription, "close", close_subscription, 0);
-  rb_define_method(IodinePubSubSubscription, "==", subscription_eq_s, 1);
-  rb_attr(IodinePubSubSubscription, rb_intern("to_s"), 1, 0, 1);
-  rb_define_method(IodinePubSubSubscription, "to_s", subscription_to_s, 1);
-
-  rb_define_alloc_func(IodineEngine, engine_alloc_c);
-  rb_define_method(IodineEngine, "initialize", engine_initialize, 0);
-
-  rb_define_method(IodineEngine, "subscribe", engine_sub_placeholder, 2);
-  rb_define_method(IodineEngine, "unsubscribe", engine_sub_placeholder, 2);
-  rb_define_method(IodineEngine, "publish", engine_pub_placeholder, 2);
-  rb_define_method(IodineEngine, "register", iodine_engine_register, 0);
-  rb_define_method(IodineEngine, "deregister", iodine_engine_deregister, 0);
-  rb_define_method(IodineEngine, "reset", iodine_engine_reset, 0);
-
-  rb_define_module_function(Iodine, "subscribe", iodine_subscribe_global, -1);
-  rb_define_module_function(Iodine, "publish", iodine_publish, -1);
-  rb_define_module_function(Iodine, "default_engine=", ips_set_default, 1);
-  rb_define_module_function(Iodine, "default_engine", ips_get_default, 0);
-
-  rb_define_module_function(IodinePubSub, "default_engine=", ips_set_default,
-                            1);
-  rb_define_module_function(IodinePubSub, "default_engine", ips_get_default, 0);
-  rb_define_method(IodinePubSub, "register", iodine_engine_register2, 1);
-  rb_define_method(IodinePubSub, "deregister", iodine_engine_deregister2, 1);
-  rb_define_method(IodinePubSub, "reset", iodine_engine_reset2, 1);
-
-  rb_define_module_function(IodinePubSub, "subscribe", iodine_subscribe_global,
-                            -1);
-  rb_define_module_function(IodinePubSub, "publish", iodine_publish, -1);
 
-  /* deprecated */
+/** Initializes the Connection Ruby class. */
+void iodine_pubsub_init(void) {
+  subscribe_id = rb_intern2("subscribe", 9);
+  unsubscribe_id = rb_intern2("unsubscribe", 11);
+  publish_id = rb_intern2("publish", 7);
+  default_id = rb_intern2("default_engine", 14);
+  redis_id = rb_intern2("redis", 5);
+  call_id = rb_intern2("call", 4);
 
-  rb_define_module_function(Iodine, "default_pubsub=", ips_set_default_dep, 1);
-  rb_define_module_function(Iodine, "default_pubsub", ips_get_default_dep, 0);
+  /* Define the PubSub module and it's methods */
 
-  /* *************************
-  Initialize C pubsub engines
-  ************************** */
-  VALUE engine_in_c;
-  iodine_engine_s *engine;
-
-  engine_in_c = rb_funcallv(IodineEngine, iodine_new_func_id, 0, NULL);
-  Data_Get_Struct(engine_in_c, iodine_engine_s, engine);
-  engine->p = (pubsub_engine_s *)PUBSUB_CLUSTER_ENGINE;
-
-  /** This is the (currently) default pub/sub engine. It will distribute
-   * messages to all subscribers in the process cluster. */
-  rb_define_const(IodinePubSub, "CLUSTER", engine_in_c);
-
-  // rb_const_set(IodineEngine, rb_intern("CLUSTER"), e);
-
-  engine_in_c = rb_funcallv(IodineEngine, iodine_new_func_id, 0, NULL);
-  Data_Get_Struct(engine_in_c, iodine_engine_s, engine);
-  engine->p = (pubsub_engine_s *)PUBSUB_PROCESS_ENGINE;
-
-  /** This is a single process pub/sub engine. It will distribute messages to
-   * all subscribers sharing the same process. */
-  rb_define_const(IodinePubSub, "SINGLE_PROCESS", engine_in_c);
-
-  // rb_const_set(IodineEngine, rb_intern("SINGLE_PROCESS"), e);
-
-  engine_in_c =
-      rb_define_class_under(IodinePubSub, "RedisEngine", IodineEngine);
-  rb_define_method(engine_in_c, "initialize", redis_engine_initialize, -1);
-  rb_define_method(engine_in_c, "send", redis_send, -1);
+  VALUE PubSubModule = rb_define_module_under(IodineModule, "PubSub");
+  rb_define_module_function(PubSubModule, "default=", iodine_pubsub_default_set,
+                            1);
+  rb_define_module_function(PubSubModule, "default", iodine_pubsub_default_get,
+                            0);
+  rb_define_module_function(PubSubModule, "attach", iodine_pubsub_attach, 1);
+  rb_define_module_function(PubSubModule, "dettach", iodine_pubsub_dettach, 1);
+  rb_define_module_function(PubSubModule, "reset", iodine_pubsub_reset, 1);
+
+  /* Define the Engine class and it's methods */
+
+  /**
+  The {Iodine::PubSub::Engine} class is the parent for all engines to inherit
+  from.
+
+  Engines should inherit this class and override the `subscribe`, `unsubscribe`
+  and `publish` callbacks (which shall be called by {Iodine}).
+
+  After creation, Engines should attach themselves to Iodine using
+  {Iodine::PubSub.attach} or their callbacks will never get called.
+
+  Engines can also set themselves to be the default engine using
+  {Iodine::PubSub.default=}.
+  */
+  EngineClass = rb_define_class_under(PubSubModule, "Engine", rb_cObject);
+  rb_define_alloc_func(EngineClass, iodine_pubsub_data_alloc_c);
+  rb_define_method(EngineClass, "subscribe", iodine_pubsub_subscribe, 2);
+  rb_define_method(EngineClass, "unsubscribe", iodine_pubsub_unsubscribe, 2);
+  rb_define_method(EngineClass, "publish", iodine_pubsub_publish, 2);
+
+  /* Define the CLUSTER and PROCESS engines */
+
+  /* CLUSTER publishes data to all the subscribers in the process cluster. */
+  rb_define_const(PubSubModule, "CLUSTER",
+                  iodine_pubsub_make_C_engine(PUBSUB_CLUSTER_ENGINE));
+  /* PROCESS publishes data to all the subscribers in a single process. */
+  rb_define_const(PubSubModule, "PROCESS",
+                  iodine_pubsub_make_C_engine(PUBSUB_PROCESS_ENGINE));
+
+  VALUE RedisClass = rb_define_class_under(PubSubModule, "Redis", EngineClass);
+  rb_define_method(RedisClass, "initialize", iodine_pubsub_redis_new, -1);
+  rb_define_method(RedisClass, "cmd", iodine_pubsub_redis_cmd, -1);
 }