rage-iodine 1.7.58

data/ext/iodine/redis_engine.h

@@ -0,0 +1,79 @@
+/*
+Copyright: Boaz segev, 2016-2019
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_REDIS_ENGINE_H
+#define H_REDIS_ENGINE_H
+
+#include <fio.h>
+#include <fiobj.h>
+
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** possible arguments for the `redis_engine_create` function call */
+struct redis_engine_create_args {
+  /** Redis server's address, defaults to localhost. */
+  fio_str_info_s address;
+  /** Redis server's port, defaults to 6379. */
+  fio_str_info_s port;
+  /** Redis server's password, if any. */
+  fio_str_info_s auth;
+  /** A `ping` will be sent every `ping_interval` interval or inactivity. */
+  uint8_t ping_interval;
+};
+
+/**
+ * See the {fio.h} file for documentation about engines.
+ *
+ * The engine is active only after facil.io starts running.
+ *
+ * A `ping` will be sent every `ping_interval` interval or inactivity. The
+ * default value (0) will fallback to facil.io's maximum time of inactivity (5
+ * minutes) before polling on the connection's protocol.
+ *
+ * function names speak for themselves ;-)
+ *
+ * Note: The Redis engine assumes it will stay alive until all the messages and
+ * callbacks have been called (or facil.io exits)... If the engine is destroyed
+ * midway, memory leaks might occur (and little puppies might cry).
+ */
+fio_pubsub_engine_s *redis_engine_create(struct redis_engine_create_args);
+#define redis_engine_create(...)                                               \
+  redis_engine_create((struct redis_engine_create_args){__VA_ARGS__})
+
+/**
+ * Sends a Redis command through the engine's connection.
+ *
+ * The response will be sent back using the optional callback. `udata` is passed
+ * along untouched.
+ *
+ * The message will be resent on network failures, until a response validates
+ * the fact that the command was sent (or the engine is destroyed).
+ *
+ * Note: NEVER call Pub/Sub commands using this function, as it will violate the
+ * Redis connection's protocol (best case scenario, a disconnection will occur
+ * before and messages are lost).
+ */
+intptr_t redis_engine_send(fio_pubsub_engine_s *engine, FIOBJ command,
+                           void (*callback)(fio_pubsub_engine_s *e, FIOBJ reply,
+                                            void *udata),
+                           void *udata);
+
+/**
+ * See the {pubsub.h} file for documentation about engines.
+ *
+ * function names speak for themselves ;-)
+ */
+void redis_engine_destroy(fio_pubsub_engine_s *engine);
+
+/* support C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H_REDIS_ENGINE_H */

data/ext/iodine/resp_parser.h

@@ -0,0 +1,317 @@
+/*
+Copyright: Boaz segev, 2016-2019
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_RESP_PARSER_H
+/**
+ * This single file library is a RESP parser for Redis connections.
+ *
+ * To use this file, the `.c` file in which this file is included MUST define a
+ * number of callbacks, as later inticated.
+ *
+ * When feeding the parser, the parser will inform of any trailing bytes (bytes
+ * at the end of the buffer that could not be parsed). These bytes should be
+ * resent to the parser along with more data. Zero is a valid return value.
+ *
+ * Note: mostly, callback return vaslues are ignored.
+ */
+#define H_RESP_PARSER_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* *****************************************************************************
+The Parser
+***************************************************************************** */
+
+typedef struct resp_parser_s {
+  /* for internal use - (array / object countdown) */
+  intptr_t obj_countdown;
+  /* for internal use - (string byte consumption) */
+  intptr_t expecting;
+} resp_parser_s;
+
+/**
+ * Returns the number of bytes to be resent. i.e., for a return value 5, the
+ * last 5 bytes in the buffer need to be resent to the parser.
+ */
+static size_t resp_parse(resp_parser_s *parser, const void *buffer,
+                         size_t length);
+
+/* *****************************************************************************
+Required Parser Callbacks (to be defined by the including file)
+***************************************************************************** */
+
+/** a local static callback, called when the RESP message is complete. */
+static int resp_on_message(resp_parser_s *parser);
+
+/** a local static callback, called when a Number object is parsed. */
+static int resp_on_number(resp_parser_s *parser, int64_t num);
+/** a local static callback, called when a OK message is received. */
+static int resp_on_okay(resp_parser_s *parser);
+/** a local static callback, called when NULL is received. */
+static int resp_on_null(resp_parser_s *parser);
+
+/**
+ * a local static callback, called when a String should be allocated.
+ *
+ * `str_len` is the expected number of bytes that will fill the final string
+ * object, without any NUL byte marker (the string might be binary).
+ *
+ * If this function returns any value besides 0, parsing is stopped.
+ */
+static int resp_on_start_string(resp_parser_s *parser, size_t str_len);
+/** a local static callback, called as String objects are streamed. */
+static int resp_on_string_chunk(resp_parser_s *parser, void *data, size_t len);
+/** a local static callback, called when a String object had finished streaming.
+ */
+static int resp_on_end_string(resp_parser_s *parser);
+
+/** a local static callback, called an error message is received. */
+static int resp_on_err_msg(resp_parser_s *parser, void *data, size_t len);
+
+/**
+ * a local static callback, called when an Array should be allocated.
+ *
+ * `array_len` is the expected number of objects that will fill the Array
+ * object.
+ *
+ * There's no `resp_on_end_array` callback since the RESP protocol assumes the
+ * message is finished along with the Array (`resp_on_message` is called).
+ * However, just in case a non-conforming client/server sends nested Arrays, the
+ * callback should test against possible overflow or nested Array endings.
+ *
+ * If this function returns any value besides 0, parsing is stopped.
+ */
+static int resp_on_start_array(resp_parser_s *parser, size_t array_len);
+
+/** a local static callback, called when a parser / protocol error occurs. */
+static int resp_on_parser_error(resp_parser_s *parser);
+
+/* *****************************************************************************
+Seeking the new line...
+***************************************************************************** */
+
+#if FIO_MEMCHAR
+
+/**
+ * This seems to be faster on some systems, especially for smaller distances.
+ *
+ * On newer systems, `memchr` should be faster.
+ */
+static inline int seek2ch(uint8_t **buffer, register const uint8_t *limit,
+                          const uint8_t c) {
+  if (**buffer == c)
+    return 1;
+
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+  /* too short for this mess */
+  if ((uintptr_t)limit <= 16 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
+    goto finish;
+
+  /* align memory */
+  {
+    const uint8_t *alignment =
+        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+    if (limit >= alignment) {
+      while (*buffer < alignment) {
+        if (**buffer == c)
+          return 1;
+        *buffer += 1;
+      }
+    }
+  }
+  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+#else
+  const uint8_t *limit64 = (uint8_t *)limit - 7;
+#endif
+  uint64_t wanted1 = 0x0101010101010101ULL * c;
+  for (; *buffer < limit64; *buffer += 8) {
+    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
+    if ((t0 & t1)) {
+      break;
+    }
+  }
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+finish:
+#endif
+  while (*buffer < limit) {
+    if (**buffer == c)
+      return 1;
+    (*buffer)++;
+  }
+  return 0;
+}
+
+#else
+
+/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
+inline static uint8_t seek2ch(uint8_t **pos, const uint8_t *limit, uint8_t ch) {
+  /* This is library based alternative that is sometimes slower  */
+  if (*pos >= limit || **pos == ch) {
+    return 0;
+  }
+  uint8_t *tmp = (uint8_t *)memchr(*pos, ch, limit - (*pos));
+  if (tmp) {
+    *pos = tmp;
+    return 1;
+  }
+  *pos = (uint8_t *)limit;
+  return 0;
+}
+
+#endif
+
+/* *****************************************************************************
+Parsing RESP requests
+***************************************************************************** */
+
+/**
+ * Returns the number of bytes to be resent. i.e., for a return value 5, the
+ * last 5 bytes in the buffer need to be resent to the parser.
+ */
+static size_t resp_parse(resp_parser_s *parser, const void *buffer,
+                         size_t length) {
+  if (!parser->obj_countdown)
+    parser->obj_countdown = 1; /* always expect something... */
+  uint8_t *pos = (uint8_t *)buffer;
+  const uint8_t *stop = pos + length;
+  while (pos < stop) {
+    uint8_t *eol;
+    if (parser->expecting) {
+      if (pos + parser->expecting + 2 > stop) {
+        /* read, but make sure the buffer includes the new line markers */
+        size_t tmp = (size_t)((uintptr_t)stop - (uintptr_t)pos);
+        if ((intptr_t)tmp >= parser->expecting)
+          tmp = parser->expecting - 1;
+        resp_on_string_chunk(parser, (void *)pos, tmp);
+        parser->expecting -= tmp;
+        return (size_t)((uintptr_t)stop - ((uintptr_t)pos + tmp)); /* 0 or 1 */
+      } else {
+        resp_on_string_chunk(parser, (void *)pos, parser->expecting);
+        resp_on_end_string(parser);
+        pos += parser->expecting;
+        if (pos[0] == '\r')
+          ++pos;
+        if (pos[0] == '\n')
+          ++pos;
+        parser->expecting = 0;
+        --parser->obj_countdown;
+        if (parser->obj_countdown <= 0) {
+          parser->obj_countdown = 1;
+          if (resp_on_message(parser))
+            goto finish;
+        }
+        continue;
+      }
+    }
+    eol = pos;
+    if (seek2ch(&eol, stop, '\n') == 0)
+      break;
+    switch (*pos) {
+    case '+':
+      if (pos[1] == 'O' && pos[2] == 'K' && pos[3] == '\r' && pos[4] == '\n') {
+        resp_on_okay(parser);
+        --parser->obj_countdown;
+        break;
+      }
+      if (resp_on_start_string(parser,
+                               (size_t)((uintptr_t)eol - (uintptr_t)pos - 2))) {
+        pos = eol + 1;
+        goto finish;
+      }
+      resp_on_string_chunk(parser, (void *)(pos + 1),
+                           (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
+      resp_on_end_string(parser);
+      --parser->obj_countdown;
+      break;
+    case '-':
+      resp_on_err_msg(parser, pos,
+                      (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
+      --parser->obj_countdown;
+      break;
+    case '*': /* fallthrough */
+    case '$': /* fallthrough */
+    case ':': {
+      uint8_t id = *pos;
+      uint8_t inv = 0;
+      int64_t i = 0;
+      ++pos;
+      if (pos[0] == '-') {
+        inv = 1;
+        ++pos;
+      }
+      while ((size_t)(pos[0] - (uint8_t)'0') <= 9) {
+        i = (i * 10) + (pos[0] - ((uint8_t)'0'));
+        ++pos;
+      }
+      if (inv)
+        i = i * -1;
+
+      switch (id) {
+      case ':':
+        resp_on_number(parser, i);
+        --parser->obj_countdown;
+        break;
+      case '$':
+        if (i < 0) {
+          resp_on_null(parser);
+          --parser->obj_countdown;
+        } else if (i == 0) {
+          resp_on_start_string(parser, 0);
+          resp_on_end_string(parser);
+          --parser->obj_countdown;
+          eol += 2; /* consume the extra "\r\n" */
+        } else {
+          if (resp_on_start_string(parser, i)) {
+            pos = eol + 1;
+            goto finish;
+          }
+          parser->expecting = i;
+        }
+        break;
+      case '*':
+        if (i < 0) {
+          resp_on_null(parser);
+        } else {
+          if (resp_on_start_array(parser, i)) {
+            pos = eol + 1;
+            goto finish;
+          }
+          parser->obj_countdown += i;
+        }
+        --parser->obj_countdown;
+        break;
+      }
+    } break;
+    default:
+      if (!parser->obj_countdown && !parser->expecting) {
+        /* possible (probable) inline command... for server authoring. */
+        /* Not Supported, PRs are welcome. */
+        resp_on_parser_error(parser);
+        return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+      } else {
+        resp_on_parser_error(parser);
+        return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+      }
+    }
+    pos = eol + 1;
+    if (parser->obj_countdown <= 0 && !parser->expecting) {
+      parser->obj_countdown = 1;
+      resp_on_message(parser);
+    }
+  }
+finish:
+  return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+}
+
+#endif /* H_RESP_PARSER_H */

data/ext/iodine/scheduler.c

@@ -0,0 +1,173 @@
+#include "iodine.h"
+#include "iodine_store.h"
+#include "ruby.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+// clang-format on
+
+#include "fio.h"
+
+#define IO_MAX_READ 8192
+
+static ID call_id;
+static uint8_t ATTACH_ON_READ_READY_CALLBACK;
+static uint8_t ATTACH_ON_WRITE_READY_CALLBACK;
+
+/* *****************************************************************************
+Fiber Scheduler API
+***************************************************************************** */
+
+static void noop(intptr_t uuid, fio_protocol_s *protocol) {
+  (void)uuid;
+  (void)protocol;
+}
+
+typedef struct {
+  fio_protocol_s p;
+  VALUE block;
+} scheduler_protocol_s;
+
+static void iodine_scheduler_perform(intptr_t uuid, fio_protocol_s *fio_protocol) {
+  scheduler_protocol_s *protocol = (scheduler_protocol_s *)fio_protocol;
+  VALUE block = protocol->block;
+
+  IodineCaller.call(block, call_id);
+
+  IodineStore.remove(block);
+  fio_free(protocol);
+
+  (void)uuid;
+}
+
+static VALUE iodine_scheduler_attach(VALUE self, VALUE r_fd, VALUE r_waittype, VALUE r_timeout) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  Check_Type(r_waittype, T_FIXNUM);
+  size_t waittype = FIX2UINT(r_waittype);
+
+  Check_Type(r_timeout, T_FIXNUM);
+  size_t timeout = FIX2UINT(r_timeout);
+
+  fio_set_non_block(fd);
+
+  rb_need_block();
+  VALUE block = IodineStore.add(rb_block_proc());
+
+  scheduler_protocol_s *protocol = fio_malloc(sizeof(*protocol));
+  FIO_ASSERT_ALLOC(protocol);
+
+  if ((waittype & ATTACH_ON_READ_READY_CALLBACK) && (waittype & ATTACH_ON_WRITE_READY_CALLBACK)) {
+    *protocol = (scheduler_protocol_s){
+        .p.on_data = iodine_scheduler_perform,
+        .p.on_ready = iodine_scheduler_perform,
+        .p.on_close = noop,
+        .p.ping = noop,
+        .block = block,
+    };
+  } else if (waittype & ATTACH_ON_READ_READY_CALLBACK) {
+    *protocol = (scheduler_protocol_s){
+        .p.on_data = iodine_scheduler_perform,
+        .p.on_ready = noop,
+        .p.on_close = noop,
+        .p.ping = noop,
+        .block = block,
+    };
+  } else if (waittype & ATTACH_ON_WRITE_READY_CALLBACK) {
+    *protocol = (scheduler_protocol_s){
+        .p.on_data = noop,
+        .p.on_ready = iodine_scheduler_perform,
+        .p.on_close = noop,
+        .p.ping = noop,
+        .block = block,
+    };
+  }
+
+  intptr_t uuid = fio_fd2uuid(fd);
+  if (timeout) {
+    fio_timeout_set(uuid, timeout);
+  }
+
+  fio_watch(uuid, (fio_protocol_s *)protocol);
+
+  return LONG2NUM(uuid);
+  (void)self;
+}
+
+static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  Check_Type(r_buffer, T_STRING);
+  char *buffer = RSTRING_PTR(r_buffer);
+
+  Check_Type(r_length, T_FIXNUM);
+  int length = FIX2INT(r_length);
+
+  Check_Type(r_offset, T_FIXNUM);
+  int offset = FIX2INT(r_offset);
+
+  fio_write2(fio_fd2uuid(fd), .data.buffer = buffer, .length = length, .offset = offset,
+             .after.dealloc = FIO_DEALLOC_NOOP);
+
+  return r_length;
+
+  (void)self;
+}
+
+static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_length, VALUE r_offset) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  Check_Type(r_length, T_FIXNUM);
+  int length = FIX2INT(r_length);
+
+  if (length == 0) {
+    length = IO_MAX_READ;
+  }
+
+  intptr_t uuid = fio_fd2uuid(fd);
+  char buffer[length];
+
+  ssize_t len = fio_read_unsafe(uuid, &buffer, length);
+  if (len == -1) {
+    return Qnil;
+  }
+
+  return rb_str_new(buffer, len);
+
+  (void)self;
+  (void)r_offset;
+}
+
+static VALUE iodine_scheduler_close(VALUE self) {
+  fio_defer_perform();
+  while (fio_flush_all()) {}
+
+  return Qtrue;
+  (void)self;
+}
+
+/* *****************************************************************************
+Scheduler initialization
+***************************************************************************** */
+
+void iodine_scheduler_initialize(void) {
+  call_id = rb_intern2("call", 4);
+
+  VALUE SchedulerModule = rb_define_module_under(IodineModule, "Scheduler");
+
+  rb_define_module_function(SchedulerModule, "attach", iodine_scheduler_attach, 3);
+  rb_define_module_function(SchedulerModule, "write", iodine_scheduler_write, 4);
+  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 3);
+  rb_define_module_function(SchedulerModule, "close", iodine_scheduler_close, 0);
+
+  VALUE cIO = rb_const_get(rb_cObject, rb_intern2("IO", 2));
+  VALUE io_readable = rb_const_get(cIO, rb_intern2("READABLE", 8));
+  VALUE io_writable = rb_const_get(cIO, rb_intern2("WRITABLE", 8));
+
+  ATTACH_ON_READ_READY_CALLBACK = NUM2SHORT(io_readable);
+  ATTACH_ON_WRITE_READY_CALLBACK = NUM2SHORT(io_writable);
+}

data/ext/iodine/scheduler.h

@@ -0,0 +1,6 @@
+#ifndef H_SCHEDULER_H
+#define H_SCHEDULER_H
+
+void iodine_scheduler_initialize(void);
+
+#endif