iodine 0.3.6 → 0.4.0

data/ext/iodine/redis_connection.c

@@ -0,0 +1,277 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#include "spnlock.inc"
+
+#include "fio_list.h"
+#include "redis_connection.h"
+#include <errno.h>
+#include <math.h>
+#include <signal.h>
+#include <string.h>
+#include <strings.h>
+
+/* *****************************************************************************
+Memory and Data structures - The protocol object.
+***************************************************************************** */
+#ifndef REDIS_POOL_SIZES /* per protocol */
+#define REDIS_POOL_SIZES 256
+#endif
+
+#ifndef REDIS_READ_BUFFER /* during network data events */
+#define REDIS_READ_BUFFER 2048
+#endif
+
+/* a protocol ID string */
+static const char *REDIS_PROTOCOL_ID =
+    "Redis Protocol for the facil.io framework";
+/* Pings */
+#define REDIS_PING_LEN 24
+static const char REDIS_PING_STR[] = "*2\r\n"
+                                     "$4\r\nPING\r\n"
+                                     "$24\r\nfacil.io connection PING\r\n";
+static const char REDIS_PING_PAYLOAD[] = "facil.io connection PING";
+
+typedef struct {
+  protocol_s protocol;
+  struct redis_context_args *settings;
+  unsigned authenticated : 1;
+} redis_protocol_s;
+
+static inline size_t ul2a(char *dest, size_t num) {
+  uint8_t digits = 1;
+  size_t tmp = num;
+  while ((tmp /= 10))
+    ++digits;
+
+  if (dest) {
+    dest += digits;
+    *(dest--) = 0;
+  }
+  for (size_t i = 0; i < digits; i++) {
+    num = num - (10 * (tmp = (num / 10)));
+    if (dest)
+      *(dest--) = '0' + num;
+    num = tmp;
+  }
+  return digits;
+}
+
+/* *****************************************************************************
+The Protocol Context
+***************************************************************************** */
+#undef redis_create_context
+void *redis_create_context(struct redis_context_args args) {
+  if (!args.on_message || !args.parser) {
+    fprintf(stderr, "A Redix connection context requires both an `on_message` "
+                    "callback and a parser.\n");
+    exit(EINVAL);
+  }
+  if (args.auth) {
+    if (!args.auth_len)
+      args.auth_len = strlen(args.auth);
+    args.auth_len++;
+  }
+  struct redis_context_args *c = malloc(sizeof(*c) + args.auth_len);
+  *c = args;
+  if (args.auth) {
+    c->auth_len--;
+    c->auth = (char *)(c + 1);
+    memcpy(c->auth, args.auth, c->auth_len);
+    c->auth[c->auth_len] = 0;
+  }
+  return c;
+}
+
+/* *****************************************************************************
+The Protocol Callbacks
+***************************************************************************** */
+
+void redis_protocol_cleanup(intptr_t uuid, void *settings) {
+  struct redis_context_args *s = settings;
+  if (s->on_close)
+    s->on_close(uuid, s->udata);
+  if (s->autodestruct)
+    free(settings);
+}
+
+static void redis_on_close_client(intptr_t uuid, protocol_s *pr) {
+  redis_protocol_s *r = (redis_protocol_s *)pr;
+  // if (r->settings->on_close)
+  //   r->settings->on_close(uuid, r->settings->udata);
+  redis_protocol_cleanup(uuid, r->settings);
+  free(r);
+}
+
+static void redis_on_close_server(intptr_t uuid, protocol_s *pr) {
+  redis_protocol_s *r = (redis_protocol_s *)pr;
+  if (r->settings->on_close)
+    r->settings->on_close(uuid, r->settings->udata);
+  free(r);
+}
+
+/** called when a connection's timeout was reached */
+static void redis_ping(intptr_t uuid, protocol_s *pr) {
+  /* We cannow write directly to the socket in case `redis_send` has scheduled
+   * callbacks. */
+  sock_write2(.uuid = uuid, .buffer = REDIS_PING_STR,
+              .length = sizeof(REDIS_PING_STR) - 1, .move = 1,
+              .dealloc = SOCK_DEALLOC_NOOP);
+  (void)pr;
+}
+
+/** called when a data is available, but will not run concurrently */
+static void redis_on_data_deferred(intptr_t uuid, protocol_s *pr, void *d);
+static void redis_on_data(intptr_t uuid, protocol_s *pr) {
+  redis_protocol_s *r = (redis_protocol_s *)pr;
+  uint8_t buffer[REDIS_READ_BUFFER];
+  ssize_t len, limit, pos;
+  resp_object_s *msg;
+  limit = len = sock_read(uuid, buffer, REDIS_READ_BUFFER);
+  if (len <= 0)
+    return;
+  pos = 0;
+  while (len) {
+    msg = resp_parser_feed(r->settings->parser, buffer + pos, (size_t *)&len);
+    if (!len && !msg) {
+      fprintf(stderr, "ERROR: (RESP Parser) Bad input (%lu):\n%s\n", limit,
+              buffer);
+      /* we'll simply ignore bad input. skip a line. */
+      for (; pos < limit; pos++) {
+        len++;
+        if (buffer[pos] == '\n') {
+          pos++;
+          len++;
+          break; /* from `for` loop */
+        }
+      }
+      continue; /* while loop */
+    }
+    if (msg) {
+      if (!r->authenticated) {
+        r->authenticated = 1;
+        if (msg->type != RESP_OK) {
+          if (msg->type == RESP_ERR) {
+            fprintf(stderr,
+                    "ERROR: (RedisConnection) Authentication FAILED.\n"
+                    "        %s\n",
+                    resp_obj2str(msg)->string);
+          } else {
+            fprintf(stderr,
+                    "ERROR: (RedisConnection) Authentication FAILED "
+                    "(unexpected response %d).\n",
+                    msg->type);
+          }
+        }
+      } else if ((msg->type == RESP_STRING &&
+                  resp_obj2str(msg)->len == REDIS_PING_LEN &&
+                  !memcmp(resp_obj2str(msg)->string, REDIS_PING_PAYLOAD,
+                          REDIS_PING_LEN)) ||
+                 (msg->type == RESP_ARRAY &&
+                  resp_obj2arr(msg)->array[0]->type == RESP_STRING &&
+                  resp_obj2str(resp_obj2arr(msg)->array[0])->len == 4 &&
+                  resp_obj2arr(msg)->array[1]->type == RESP_STRING &&
+                  resp_obj2str(resp_obj2arr(msg)->array[1])->len ==
+                      REDIS_PING_LEN &&
+                  !strncasecmp(
+                      (char *)resp_obj2str(resp_obj2arr(msg)->array[0])->string,
+                      "pong", 4) &&
+                  !memcmp(
+                      (char *)resp_obj2str(resp_obj2arr(msg)->array[0])->string,
+                      REDIS_PING_PAYLOAD, REDIS_PING_LEN))) {
+        /* an internal ping, do not forward. */
+      } else
+        r->settings->on_message(uuid, msg, r->settings->udata);
+      resp_free_object(msg);
+      msg = NULL;
+    }
+    if (len == limit) {
+      /* fragment events, it's edge polling, so we need to read everything */
+      facil_defer(.uuid = uuid, .task = redis_on_data_deferred,
+                  .task_type = FIO_PR_LOCK_TASK);
+      return;
+    }
+    pos += len;
+    limit = len = limit - len;
+  }
+}
+static void redis_on_data_deferred(intptr_t uuid, protocol_s *pr, void *d) {
+  if (!pr || pr->service != REDIS_PROTOCOL_ID)
+    return;
+  redis_on_data(uuid, pr);
+  (void)d;
+}
+
+static void redis_on_open(intptr_t uuid, protocol_s *pr, void *d) {
+  redis_protocol_s *r = (void *)pr;
+  facil_set_timeout(uuid, r->settings->ping);
+  if (r->settings->auth) {
+    size_t n_len = ul2a(NULL, r->settings->auth_len);
+    char *t =
+        malloc(r->settings->auth_len + 20 + n_len); /* 19 is probably enough */
+    memcpy(t, "*2\r\n$4\r\nAUTH\r\n$", 15);
+    ul2a(t + 15, r->settings->auth_len);
+    t[15 + n_len] = '\r';
+    t[16 + n_len] = '\n';
+    memcpy(t + 17 + n_len, r->settings->auth, r->settings->auth_len);
+    t[17 + n_len + r->settings->auth_len] = '\r';
+    t[18 + n_len + r->settings->auth_len] = '\n';
+    t[19 + n_len + r->settings->auth_len] = 0; /* we don't need it, but nice */
+    sock_write2(.uuid = uuid, .buffer = t,
+                .length = (19 + n_len + r->settings->auth_len), .move = 1);
+
+  } else
+    r->authenticated = 1;
+  r->settings->on_open(uuid, r->settings->udata);
+  (void)d;
+}
+
+/**
+ * This function is used as a function pointer for the `facil_connect` and
+ * calls (the `on_connect` callback).
+ */
+protocol_s *redis_create_client_protocol(intptr_t uuid, void *settings) {
+  redis_protocol_s *r = malloc(sizeof(*r));
+  *r = (redis_protocol_s){
+      .protocol =
+          {
+              .service = REDIS_PROTOCOL_ID,
+              .on_data = redis_on_data,
+              .on_close = redis_on_close_client,
+              .ping = redis_ping,
+          },
+      .settings = settings,
+  };
+  facil_set_timeout(uuid, r->settings->ping);
+  if (r->settings->on_open)
+    facil_defer(.task = redis_on_open, .uuid = uuid);
+  return &r->protocol;
+  (void)uuid;
+}
+
+/**
+ * This function is used as a function pointer for the `facil_listen` calls (the
+ * `on_open` callbacks).
+ */
+protocol_s *redis_create_server_protocol(intptr_t uuid, void *settings) {
+  redis_protocol_s *r = malloc(sizeof(*r));
+  *r = (redis_protocol_s){
+      .protocol =
+          {
+              .service = REDIS_PROTOCOL_ID,
+              .on_data = redis_on_data,
+              .on_close = redis_on_close_server,
+              .ping = redis_ping,
+          },
+      .settings = settings,
+  };
+  facil_set_timeout(uuid, r->settings->ping);
+  if (r->settings->on_open)
+    facil_defer(.task = redis_on_open, .uuid = uuid);
+  return &r->protocol;
+  (void)uuid;
+}

data/ext/iodine/redis_connection.h

@@ -0,0 +1,77 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef H_REDIS_CONNECTION_H
+#define H_REDIS_CONNECTION_H
+#include "facil.h"
+#include "resp.h"
+
+/* *****************************************************************************
+Connectivity
+***************************************************************************** */
+
+/**
+To create a new Redis connection, create a Redis context object using the
+following optings and the `redis_create_context` function.
+
+The context should be passed along as the `udata` parameter to either
+`facil_connect` or `facil_listen`.
+
+The `on_connect` / `on_open` argument for `facil_connect` and
+`facil_listen`should be the `redis_create_protocol` function pointer.
+
+The `on_fail` / `on_finish` argument for `facil_connect` and
+`facil_listen`should be the `redis_protocol_cleanup` function pointer.
+*/
+
+struct redis_context_args {
+  /** REQUIRED: the RESP parser used by the connection. */
+  resp_parser_pt parser;
+  /** REQUIRED: called when the RESP messages are received. */
+  void (*on_message)(intptr_t uuid, resp_object_s *msg, void *udata);
+  /** called when the Redix connection closes or fails to open. */
+  void (*on_close)(intptr_t uuid, void *udata);
+  /** called when the Redix connection opens. */
+  void (*on_open)(intptr_t uuid, void *udata);
+  /** Authentication string (password). */
+  char *auth;
+  /** Authentication string (password) length. */
+  size_t auth_len;
+  /** Opaque user data. */
+  void *udata;
+  /** PING intervals. */
+  uint8_t ping;
+  /** The context, not the computer... */
+  uint8_t autodestruct;
+};
+
+void *redis_create_context(struct redis_context_args);
+
+#define redis_create_context(...)                                              \
+  redis_create_context((struct redis_context_args){__VA_ARGS__})
+
+/**
+ * This function is used as a function pointer for the `facil_connect` and
+ * calls (the `on_connect` callback).
+ */
+protocol_s *redis_create_client_protocol(intptr_t uuid, void *settings);
+
+/**
+ * This function is used as a function pointer for the `facil_listen` calls (the
+ * `on_open` callbacks).
+ */
+protocol_s *redis_create_server_protocol(intptr_t uuid, void *settings);
+
+/**
+ * This function is used as a function pointer for both `facil_connect` and
+ * `facil_listen` calls (the `on_fail` / `on_finish` callbacks).
+ *
+ * It's main responsibility is to free the context and protocol resources.
+ */
+void redis_protocol_cleanup(intptr_t uuid, void *settings);
+
+#endif

data/ext/iodine/redis_engine.c

@@ -0,0 +1,398 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#include "spnlock.inc"
+
+#include "fio_list.h"
+#include "redis_connection.h"
+#include "redis_engine.h"
+#include "resp.h"
+
+#include <string.h>
+/* *****************************************************************************
+Data Structures / State
+***************************************************************************** */
+
+typedef struct {
+  pubsub_engine_s engine;
+  resp_parser_pt sub_parser;
+  resp_parser_pt pub_parser;
+  intptr_t sub;
+  intptr_t pub;
+  void *sub_ctx;
+  void *pub_ctx;
+  char *address;
+  char *port;
+  fio_list_s callbacks;
+  uint16_t ref;
+  volatile uint8_t active;
+  volatile uint8_t sub_state;
+  volatile uint8_t pub_state;
+  spn_lock_i lock;
+} redis_engine_s;
+
+typedef struct {
+  fio_list_s node;
+  void (*callback)(pubsub_engine_s *e, resp_object_s *reply, void *udata);
+  void *udata;
+  size_t len;
+  uint8_t sent;
+} callbacks_s;
+
+static int dealloc_engine(redis_engine_s *r) {
+  if (!spn_sub(&r->ref, 1)) {
+    resp_parser_destroy(r->sub_parser);
+    resp_parser_destroy(r->pub_parser);
+    free(r);
+    return -1;
+  }
+  return 0;
+}
+
+/* *****************************************************************************
+Writing commands
+***************************************************************************** */
+static void redis_pub_send(void *e, void *uuid) {
+  redis_engine_s *r = e;
+  callbacks_s *cb;
+  spn_lock(&r->lock);
+
+  if (fio_list_any(r->callbacks)) {
+    cb = fio_node2obj(callbacks_s, node, r->callbacks.next);
+    if (cb->sent == 0) {
+      cb->sent = 1;
+      sock_write2(.uuid = r->pub, .buffer = (uint8_t *)(cb + 1),
+                  .length = cb->len, .move = 1, .dealloc = SOCK_DEALLOC_NOOP);
+    }
+  }
+  spn_unlock(&r->lock);
+  dealloc_engine(r);
+  (void)uuid;
+}
+
+static void schedule_pub_send(redis_engine_s *r, intptr_t uuid) {
+  spn_add(&r->ref, 1);
+  defer(redis_pub_send, r, (void *)uuid);
+}
+
+/* *****************************************************************************
+Engine Bridge
+***************************************************************************** */
+
+static void on_message_sub(intptr_t uuid, resp_object_s *msg, void *udata) {
+  if (msg->type == RESP_PUBSUB) {
+    pubsub_engine_distribute(
+            .engine = udata,
+            .channel =
+                {.name =
+                     (char *)resp_obj2str(resp_obj2arr(msg)->array[1])->string,
+                 .len = resp_obj2str(resp_obj2arr(msg)->array[1])->len},
+            .msg = {
+                .data =
+                    (char *)resp_obj2str(resp_obj2arr(msg)->array[2])->string,
+                .len = resp_obj2str(resp_obj2arr(msg)->array[2])->len});
+    return;
+  }
+  (void)uuid;
+}
+
+static void on_message_pub(intptr_t uuid, resp_object_s *msg, void *udata) {
+  redis_engine_s *r = udata;
+  callbacks_s *cb;
+  spn_lock(&r->lock);
+  cb = fio_list_shift(callbacks_s, node, r->callbacks);
+  spn_unlock(&r->lock);
+  if (cb) {
+    schedule_pub_send(r, uuid);
+    if (cb->callback)
+      cb->callback(&r->engine, msg, cb->udata);
+    free(cb);
+  } else {
+    uint8_t buffer[64] = {0};
+    size_t len = 63;
+    resp_format(NULL, buffer, &len, msg);
+    fprintf(stderr,
+            "WARN: (RedisEngine) Possible issue, "
+            "received unknown message (%lu bytes):\n%s\n",
+            len, (char *)buffer);
+  }
+  (void)uuid;
+}
+
+/* *****************************************************************************
+Connections
+***************************************************************************** */
+
+static inline int connect_sub(redis_engine_s *r) {
+  spn_add(&r->ref, 1);
+  return (r->sub = facil_connect(.address = r->address, .port = r->port,
+                                 .on_connect = redis_create_client_protocol,
+                                 .udata = r->sub_ctx,
+                                 .on_fail = redis_protocol_cleanup));
+}
+
+static inline int connect_pub(redis_engine_s *r) {
+  spn_add(&r->ref, 1);
+  return (r->pub = facil_connect(.address = r->address, .port = r->port,
+                                 .on_connect = redis_create_client_protocol,
+                                 .udata = r->pub_ctx,
+                                 .on_fail = redis_protocol_cleanup));
+}
+
+static void on_close_sub(intptr_t uuid, void *p) {
+  redis_engine_s *r = p;
+  if (!defer_fork_is_active()) {
+    dealloc_engine(r);
+    return;
+  }
+  if (r->sub == uuid && r->active) {
+    if (r->sub_state) {
+      r->sub_state = 0;
+      fprintf(stderr,
+              "ERROR: (RedisEngine) redis Sub "
+              "connection LOST: %s:%s\n",
+              r->address ? r->address : "0.0.0.0", r->port);
+    }
+    connect_sub(r);
+    facil_run_every(50, 1, (void (*)(void *))pubsub_engine_resubscribe,
+                    (void *)&r->engine, NULL);
+  }
+  dealloc_engine(r);
+}
+
+static void on_close_pub(intptr_t uuid, void *p) {
+  redis_engine_s *r = p;
+  if (!defer_fork_is_active()) {
+    dealloc_engine(r);
+    return;
+  }
+  if (r->pub == uuid && r->active) {
+    connect_pub(r);
+    if (r->pub_state) {
+      r->pub_state = 0;
+      fprintf(stderr,
+              "ERROR: (RedisEngine) redis Pub "
+              "connection LOST: %s:%s\n",
+              r->address ? r->address : "0.0.0.0", r->port);
+    }
+  }
+  dealloc_engine(r);
+}
+
+static void on_open_pub(intptr_t uuid, void *e) {
+  redis_engine_s *r = e;
+  if (r->pub != uuid)
+    return;
+  if (!r->pub_state) /* no message on first connection */
+    fprintf(stderr,
+            "INFO: (RedisEngine) redis Pub "
+            "connection (re)established: %s:%s\n",
+            r->address ? r->address : "0.0.0.0", r->port);
+  r->pub_state = 1;
+  spn_lock(&r->lock);
+  callbacks_s *cb;
+  fio_list_for_each(callbacks_s, node, cb, r->callbacks) { cb->sent = 0; }
+  spn_unlock(&r->lock);
+  schedule_pub_send(r, uuid);
+}
+
+static void on_open_sub(intptr_t uuid, void *e) {
+  redis_engine_s *r = e;
+  if (r->sub != uuid)
+    return;
+  if (!r->sub_state) /* no message on first connection */
+    fprintf(stderr,
+            "INFO: (RedisEngine) redis Sub "
+            "connection (re)established: %s:%s\n",
+            r->address ? r->address : "0.0.0.0", r->port);
+  r->sub_state = 1;
+  pubsub_engine_resubscribe(&r->engine);
+  (void)uuid;
+}
+
+/* *****************************************************************************
+Callbacks
+***************************************************************************** */
+
+/** Should return 0 on success and -1 on failure. */
+static int subscribe(const pubsub_engine_s *eng, const char *ch, size_t ch_len,
+                     uint8_t use_pattern) {
+  redis_engine_s *e = (redis_engine_s *)eng;
+  if (!sock_isvalid(e->sub)) {
+    return 0;
+  }
+  resp_object_s *cmd = resp_arr2obj(2, NULL);
+  if (!cmd) {
+    return -1;
+  }
+  resp_obj2arr(cmd)->array[0] = use_pattern ? resp_str2obj("PSUBSCRIBE", 10)
+                                            : resp_str2obj("SUBSCRIBE", 9);
+  resp_obj2arr(cmd)->array[1] =
+      (ch ? resp_str2obj(ch, ch_len) : resp_nil2obj());
+  void *buffer = malloc(32 + ch_len);
+  size_t size = 32 + ch_len;
+  if (resp_format(e->sub_parser, buffer, &size, cmd))
+    fprintf(stderr, "ERROR: RESP format? size = %lu ch = %lu\n", size, ch_len);
+  sock_write2(.uuid = e->sub, .buffer = buffer, .length = size, .move = 1);
+  resp_free_object(cmd);
+  return 0;
+}
+
+/** Return value is ignored. */
+static void unsubscribe(const pubsub_engine_s *eng, const char *ch,
+                        size_t ch_len, uint8_t use_pattern) {
+  redis_engine_s *e = (redis_engine_s *)eng;
+
+  if (!sock_isvalid(e->sub))
+    return;
+  resp_object_s *cmd = resp_arr2obj(2, NULL);
+  if (!cmd)
+    return;
+  resp_obj2arr(cmd)->array[0] = use_pattern ? resp_str2obj("PUNSUBSCRIBE", 12)
+                                            : resp_str2obj("UNSUBSCRIBE", 11);
+  resp_obj2arr(cmd)->array[1] =
+      (ch ? resp_str2obj(ch, ch_len) : resp_nil2obj());
+  void *buffer = malloc(32 + ch_len);
+  size_t size = 32 + ch_len;
+  if (!resp_format(e->sub_parser, buffer, &size, cmd) && size <= (32 + ch_len))
+    sock_write2(.uuid = e->sub, .buffer = buffer, .length = size, .move = 1);
+  resp_free_object(cmd);
+}
+
+/** Should return 0 on success and -1 on failure. */
+static int publish(const pubsub_engine_s *eng, const char *ch, size_t ch_len,
+                   const char *msg, size_t msg_len, uint8_t use_pattern) {
+  if (!msg || use_pattern || !ch)
+    return -1;
+  resp_object_s *cmd = resp_arr2obj(3, NULL);
+  if (!cmd)
+    return -1;
+  resp_obj2arr(cmd)->array[0] = resp_str2obj("PUBLISH", 7);
+  resp_obj2arr(cmd)->array[1] = resp_str2obj(ch, ch_len);
+  resp_obj2arr(cmd)->array[2] = resp_str2obj(msg, msg_len);
+  redis_engine_send((pubsub_engine_s *)eng, cmd, NULL, NULL);
+  resp_free_object(cmd);
+  return 0;
+}
+
+/* *****************************************************************************
+Creation / Destruction
+***************************************************************************** */
+
+static void initialize_engine(void *en_, void *ig) {
+  redis_engine_s *r = (redis_engine_s *)en_;
+  (void)ig;
+  connect_sub(r);
+  connect_pub(r);
+}
+
+/**
+See the {pubsub.h} file for documentation about engines.
+
+function names speak for themselves ;-)
+*/
+#undef redis_engine_create
+pubsub_engine_s *redis_engine_create(struct redis_engine_create_args a) {
+  if (!a.port) {
+    return NULL;
+  }
+  size_t addr_len = a.address ? strlen(a.address) : 0;
+  size_t port_len = strlen(a.port);
+  redis_engine_s *e = malloc(sizeof(*e) + addr_len + port_len + 2);
+  *e = (redis_engine_s){
+      .engine = {.subscribe = subscribe,
+                 .unsubscribe = unsubscribe,
+                 .publish = publish},
+      .address = (char *)(e + 1),
+      .port = ((char *)(e + 1) + addr_len + 1),
+      .ref = 1,
+      .sub_parser = resp_parser_new(),
+      .pub_parser = resp_parser_new(),
+      .callbacks = FIO_LIST_INIT_STATIC(e->callbacks),
+      .active = 1,
+      .sub_state = 1,
+      .pub_state = 1,
+  };
+  if (a.address)
+    memcpy(e->address, a.address, addr_len);
+  else
+    e->address = NULL;
+  e->address[addr_len] = 0;
+  memcpy(e->port, a.port, port_len);
+  e->port[port_len] = 0;
+
+  e->sub_ctx =
+      redis_create_context(.parser = e->sub_parser, .auth = (char *)a.auth,
+                           .auth_len = a.auth_len, .on_message = on_message_sub,
+                           .on_close = on_close_sub, .on_open = on_open_sub,
+                           .udata = e, .ping = a.ping_interval),
+
+  e->pub_ctx =
+      redis_create_context(.parser = e->pub_parser, .auth = (char *)a.auth,
+                           .auth_len = a.auth_len, .on_message = on_message_pub,
+                           .on_close = on_close_pub, .on_open = on_open_pub,
+                           .udata = e, .ping = a.ping_interval, ),
+
+  defer(initialize_engine, e, NULL);
+  return (pubsub_engine_s *)e;
+}
+
+/* *****************************************************************************
+Sending Data
+***************************************************************************** */
+
+/**
+Sends a Redis message through the engine's connection. The response will be sent
+back using the optional callback. `udata` is passed along untouched.
+*/
+intptr_t redis_engine_send(pubsub_engine_s *e, resp_object_s *data,
+                           void (*callback)(pubsub_engine_s *e,
+                                            resp_object_s *reply, void *udata),
+                           void *udata) {
+  if (!e || !data)
+    return -1;
+
+  redis_engine_s *r = (redis_engine_s *)e;
+  size_t len = 0;
+  resp_format(r->pub_parser, NULL, &len, data);
+  if (!len)
+    return -1;
+
+  callbacks_s *cb = malloc(sizeof(*cb) + len);
+  *cb = (callbacks_s){
+      .node = FIO_LIST_INIT_STATIC(cb->node),
+      .callback = callback,
+      .udata = udata,
+      .len = len,
+  };
+  resp_format(r->pub_parser, (uint8_t *)(cb + 1), &len, data);
+  spn_lock(&r->lock);
+  fio_list_push(callbacks_s, node, r->callbacks, cb);
+  spn_unlock(&r->lock);
+  schedule_pub_send(r, r->pub);
+  return 0;
+}
+
+/**
+See the {pubsub.h} file for documentation about engines.
+
+function names speak for themselves ;-)
+*/
+void redis_engine_destroy(pubsub_engine_s *engine) {
+  redis_engine_s *r = (redis_engine_s *)engine;
+
+  spn_lock(&r->lock);
+  callbacks_s *cb;
+  fio_list_for_each(callbacks_s, node, cb, r->callbacks) free(cb);
+  sock_force_close(r->pub);
+  sock_force_close(r->sub);
+
+  r->active = 0;
+  if (dealloc_engine(r))
+    return;
+  spn_unlock(&r->lock);
+}