iodine 0.2.7 → 0.2.8

data/ext/iodine/websockets.h

@@ -1,3 +1,9 @@
+/*
+copyright: Boaz segev, 2016-2017
+license: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
 #ifndef WEBSOCKETS_H
 #define WEBSOCKETS_H
 

data/ext/iodine/xor-crypt.c

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-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).
 */

data/ext/iodine/xor-crypt.h

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-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).
 */

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.7'.freeze
+  VERSION = '0.2.8'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-31 00:00:00.000000000 Z
+date: 2017-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -145,19 +145,18 @@ files:
 - ext/iodine/libserver.h
 - ext/iodine/libsock.c
 - ext/iodine/libsock.h
+- ext/iodine/mempool.h
 - ext/iodine/misc.c
 - ext/iodine/misc.h
 - ext/iodine/random.c
 - ext/iodine/random.h
 - ext/iodine/rb-call.c
-- ext/iodine/rb-call.c_old
 - ext/iodine/rb-call.h
 - ext/iodine/rb-libasync.h
 - ext/iodine/rb-rack-io.c
 - ext/iodine/rb-rack-io.h
 - ext/iodine/rb-registry.c
 - ext/iodine/rb-registry.h
-- ext/iodine/rb-registry_old.c_old
 - ext/iodine/sha1.c
 - ext/iodine/sha1.h
 - ext/iodine/sha2.c

data/ext/iodine/rb-call.c_old

@@ -1,127 +0,0 @@
-#include "rb-call.h"
-#include <ruby.h>
-#include <ruby/thread.h>
-#include <pthread.h>
-
-///////////////
-// this is a simple helper that calls Ruby methods on Ruby objects while within
-// a non-GVL ruby thread zone.
-
-// a structure for Ruby API calls
-struct RubySimpleCall {
-  VALUE obj;
-  VALUE returned;
-  ID method;
-};
-struct RubyArgCall {
-  VALUE obj;
-  int argc;
-  VALUE *argv;
-  VALUE returned;
-  ID method;
-};
-
-#if __STDC_VERSION__ < 201112L || __STDC_NO_THREADS__
-#define _Thread_local __thread
-#endif
-
-// a thread specific global variable that lets us know if we're in the GVL
-static _Thread_local char in_gvl = 0;
-static char check_in_gvl(void) { return in_gvl; }
-
-////////////////////////////////////////////////////////////////////////////
-// Calling C functions.
-static void *call_c(void *(*func)(void *), void *arg) {
-  if (in_gvl) {
-    return func(arg);
-  }
-  void *ret;
-  in_gvl = 1;
-  ret = rb_thread_call_with_gvl(func, arg);
-  in_gvl = 0;
-  return ret;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// Handling exceptions (printing the backtrace doesn't really work well).
-static void *handle_exception(void *_) {
-  VALUE exc = rb_errinfo();
-  if (exc != Qnil) {
-    VALUE msg = RubyCaller.call(exc, rb_intern("message"));
-    VALUE exc_class = rb_class_name(CLASS_OF(exc));
-    VALUE bt = RubyCaller.call(exc, rb_intern("backtrace"));
-    if (TYPE(bt) == T_ARRAY) {
-      bt = rb_ary_join(bt, rb_str_new_literal("\n"));
-      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n%s",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg), StringValueCStr(bt));
-    } else {
-      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n"
-                      "No backtrace available.\n",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
-    }
-    rb_backtrace();
-    rb_set_errinfo(Qnil);
-  }
-  return (void *)Qnil;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// A simple (and a bit lighter) design for when there's no need for arguments.
-
-// running the actual method call
-static VALUE run_ruby_method_unsafe(VALUE _tsk) {
-  struct RubySimpleCall *task = (void *)_tsk;
-  return rb_funcall2(task->obj, task->method, 0, NULL);
-}
-
-// GVL gateway
-static void *run_ruby_method_within_gvl(void *_tsk) {
-  struct RubySimpleCall *task = _tsk;
-  int state = 0;
-  task->returned = rb_protect(run_ruby_method_unsafe, (VALUE)(task), &state);
-  if (state)
-    handle_exception(NULL);
-  return task;
-}
-
-// wrapping any API calls for exception management AND GVL entry
-static VALUE call(VALUE obj, ID method) {
-  struct RubySimpleCall task = {.obj = obj, .method = method};
-  call_c(run_ruby_method_within_gvl, &task);
-  return task.returned;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// A heavier (memory) design for when we're passing arguments around.
-
-// running the actual method call
-static VALUE run_argv_method_unsafe(VALUE _tsk) {
-  struct RubyArgCall *task = (void *)_tsk;
-  return rb_funcall2(task->obj, task->method, task->argc, task->argv);
-}
-
-// GVL gateway
-static void *run_argv_method_within_gvl(void *_tsk) {
-  struct RubyArgCall *task = _tsk;
-  int state = 0;
-  task->returned = rb_protect(run_argv_method_unsafe, (VALUE)(task), &state);
-  if (state)
-    handle_exception(NULL);
-  return task;
-}
-
-// wrapping any API calls for exception management AND GVL entry
-static VALUE call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
-  struct RubyArgCall task = {
-      .obj = obj, .method = method, .argc = argc, .argv = argv};
-  call_c(run_argv_method_within_gvl, &task);
-  return task.returned;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// the API interface
-struct _Ruby_Method_Caller_Class_ RubyCaller = {
-    .call = call, .call2 = call_arg, .call_c = call_c, .in_gvl = check_in_gvl,
-};

data/ext/iodine/rb-registry_old.c_old

@@ -1,213 +0,0 @@
-#include "rb-registry.h"
-#include "spnlock.h"
-#include <ruby.h>
-
-// #define RUBY_REG_DBG
-
-// the registry global
-static struct Registry {
-  struct Object *obj_pool;
-  struct Object *first;
-  VALUE owner;
-  spn_lock_i lock;
-} registry = {
-    .obj_pool = NULL, .first = NULL, .owner = 0, .lock = SPN_LOCK_INIT};
-
-#define try_lock_registry() spn_trylock(&registry.lock)
-#define unlock_registry() spn_unlock(&registry.lock)
-#define lock_registry() spn_lock(&registry.lock)
-
-// the references struct (bin-tree)
-struct Object {
-  struct Object *next;
-  VALUE obj;
-  int count;
-};
-
-// manage existing objects - add a reference
-int add_reference(VALUE obj) {
-  struct Object *line;
-  lock_registry();
-  line = registry.first;
-  while (line) {
-    if (line->obj == obj) {
-      line->count++;
-      unlock_registry();
-      return 1;
-    }
-    line = line->next;
-  }
-  unlock_registry();
-  return 0;
-}
-
-// add an object to the registry
-//
-// allow multiple registrartions (bag)
-static VALUE register_object(VALUE obj) {
-  if (!obj || obj == Qnil)
-    return 0;
-  if (add_reference(obj))
-    return obj;
-  struct Object *line;
-  lock_registry();
-  if (registry.obj_pool) {
-    line = registry.obj_pool;
-    registry.obj_pool = registry.obj_pool->next;
-  } else {
-    line = malloc(sizeof(struct Object));
-  }
-  if (!line) {
-    perror("No Memory!");
-    unlock_registry();
-    return 0;
-  }
-  line->obj = obj;
-  line->next = registry.first;
-  line->count = 1;
-  registry.first = line;
-  unlock_registry();
-  return obj;
-}
-
-// free a single registry
-//
-// free only one.
-static void unregister_object(VALUE obj) {
-  if (!obj || obj == Qnil)
-    return;
-  lock_registry();
-  struct Object *line = registry.first;
-  struct Object *prev = NULL;
-  while (line) {
-    if (line->obj == obj) {
-      line->count--;
-      if (!line->count) {
-        if (line == registry.first)
-          registry.first = line->next;
-        else if (prev) // must be true, really
-          prev->next = line->next;
-        // move the object container to the discarded object pool
-        line->next = registry.obj_pool;
-        registry.obj_pool = line;
-      }
-      goto finish;
-    }
-    prev = line;
-    line = line->next;
-  }
-finish:
-  unlock_registry();
-}
-
-// // Replaces one registry object with another,
-// // allowing updates to the Registry with no memory allocations.
-// //
-// // returns 0 if all OK, returns -1 if it couldn't replace the object.
-// static int replace_object(VALUE obj, VALUE new_obj) {
-//   int ret = -1;
-//   if (obj == new_obj)
-//     return 0;
-//   pthread_mutex_lock(&registry_lock);
-//   struct Object* line = registry.first;
-//   while (line) {
-//     if (line->obj == obj) {
-//       line->obj = new_obj;
-//       ret = 0;
-//       goto finish;
-//     }
-//     line = line->next;
-//   }
-// finish:
-//   pthread_mutex_unlock(&registry_lock);
-//   return ret;
-// }
-
-// a callback for the GC (marking active objects)
-static void registry_mark(void *ignore) {
-#ifdef RUBY_REG_DBG
-  Registry.print();
-#endif
-  lock_registry();
-  struct Object *line = registry.first;
-  while (line) {
-    if (line->obj)
-      rb_gc_mark(line->obj);
-    line = line->next;
-  }
-  unlock_registry();
-}
-
-// clear the registry (end of lifetime)
-static void registry_clear(void *ignore) {
-  lock_registry();
-  struct Object *line;
-  struct Object *to_free;
-  // free active object references
-  line = registry.first;
-  while (line) {
-    to_free = line;
-    line = line->next;
-    free(to_free);
-  }
-  registry.first = NULL;
-  // free container pool
-  line = registry.obj_pool;
-  while (line) {
-    to_free = line;
-    line = line->next;
-    free(to_free);
-  }
-  registry.obj_pool = NULL;
-  registry.owner = 0;
-  unlock_registry();
-}
-
-// the data-type used to identify the registry
-// this sets the callbacks.
-static struct rb_data_type_struct my_registry_type_struct = {
-    .wrap_struct_name = "RubyReferencesIn_C_Land",
-    .function.dfree = (void (*)(void *))registry_clear,
-    .function.dmark = (void (*)(void *))registry_mark,
-};
-
-// initialize the registry
-static void init(VALUE owner) {
-  lock_registry();
-  if (registry.owner)
-    goto finish;
-  if (!owner)
-    owner = rb_cObject;
-  registry.owner = owner;
-  VALUE rReferences =
-      rb_define_class_under(owner, "RubyObjectRegistry_for_C_land", rb_cData);
-  VALUE r_registry =
-      TypedData_Wrap_Struct(rReferences, &my_registry_type_struct, &registry);
-  rb_ivar_set(owner, rb_intern("registry"), r_registry);
-finish:
-  unlock_registry();
-}
-
-// print data, for testing
-static void print(void) {
-  lock_registry();
-  struct Object *line = registry.first;
-  fprintf(stderr, "Registry owner is %lu\n", registry.owner);
-  long index = 0;
-  while (line) {
-    fprintf(stderr, "[%lu] => %d X obj %lu type %d at %p\n", index++,
-            line->count, line->obj, TYPE(line->obj), line);
-    line = line->next;
-  }
-  fprintf(stderr, "Total of %lu registered objects being marked\n", index);
-  unlock_registry();
-}
-
-////////////////////////////////////////////
-// The API gateway
-struct ___RegistryClass___ Registry = {
-    .init = init,
-    .remove = unregister_object,
-    .add = register_object,
-    .print = print,
-};