asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/README.markdown

@@ -0,0 +1,3 @@
+# AsyncEngine
+
+In development status. I won't write the README until AsyncEngine becomes robust, usable, full-featured and tested. And it will.

data/Rakefile

@@ -0,0 +1,38 @@
+require "rake/testtask"
+require "rake/clean"
+
+AE_EXTEN_DIR = "ext/asyncengine"
+AE_EXTEN_NAME_SO = "asyncengine_ext.so"
+AE_LIB_SO = "lib/asyncengine/asyncengine_ext.so"
+
+# Rule to build the extension: this says that the extension should be rebuilt
+# after any change to the files in the extension dir.
+file AE_LIB_SO =>
+  Dir.glob("#{AE_EXTEN_DIR}/*{.rb,.c,.h}") do
+    Dir.chdir(AE_EXTEN_DIR) do
+      ruby "extconf.rb"
+      sh "make"
+    end
+    cp "#{AE_EXTEN_DIR}/#{AE_EXTEN_NAME_SO}", AE_LIB_SO
+  end
+
+# Use 'rake clean' and 'rake clobber' to easily delete generated files.
+CLEAN.include("#{AE_EXTEN_DIR}/*{.o,.log,.so,.a}")
+CLEAN.include("#{AE_EXTEN_DIR}/Makefile")
+CLEAN.include(AE_LIB_SO)
+CLOBBER.include("#{AE_EXTEN_DIR}/libuv/**/*{.o,.a}")
+
+
+task :default => :compile
+
+desc "Compile"
+task :compile => AE_LIB_SO
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+end
+
+# Make the :test task depend on the shared object, so it will be built automatically
+# before running the tests.
+desc "Run tests"
+task :test => AE_LIB_SO

data/asyncengine.gemspec

@@ -8,19 +8,23 @@ Gem::Specification.new do |spec|
   spec.date = Time.now
   spec.authors = ["Inaki Baz Castillo"]
   spec.email = "ibc@aliax.net"
-  spec.summary = "Ruby asynchronous event driven library based on libuv"
+  spec.summary = "Ruby asynchronous event driven framework on top of libuv"
   spec.homepage = "https://github.com/ibc/AsyncEngine"
-  spec.description = "Ruby asynchronous event driven library based on libuv"
-  spec.extensions = ["ext/asyncengine/extconf.rb"]
+  spec.description = "Ruby asynchronous event driven framework on top of libuv"
   spec.required_ruby_version = ">= 1.9.2"
 
   files = %w{
     asyncengine.gemspec
+    Rakefile
     README.markdown
-    lib/**/**
+    lib/**/**/**
     ext/asyncengine/{*.c,*.h,*.rb}
     ext/asyncengine/libuv/**/**/**/**/**/**/**/**/**
+    test/{ae_test_helper.rb}
+    test/{test_*.rb}
   }.join(",")
+
   spec.files = Dir.glob "{#{files}}"
   spec.require_paths = ["lib"]
+  spec.extensions = ["ext/asyncengine/extconf.rb"]
 end

data/ext/asyncengine/ae_call_from_other_thread.c

@@ -0,0 +1,106 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_call_from_other_thread.h"
+
+
+static ID att_call_from_other_thread_procs;
+
+static uv_async_t* ae_call_from_other_thread_uv_async;
+
+
+/** Pre-declaration of static functions. */
+
+static void _uv_async_callback(uv_async_t* handle, int status);
+static VALUE _ae_async_callback(void);
+
+
+void init_ae_call_from_other_thread(void)
+{
+  AE_TRACE();
+
+  rb_define_module_function(mAsyncEngine, "call_from_other_thread", AsyncEngine_call_from_other_thread, -1);
+
+  att_call_from_other_thread_procs = rb_intern("@_call_from_other_thread_procs");
+
+  ae_call_from_other_thread_uv_async = NULL;
+}
+
+
+void load_ae_call_from_other_thread(void)
+{
+  AE_TRACE();
+  int r;
+
+  AE_ASSERT(ae_call_from_other_thread_uv_async == NULL);
+
+  ae_call_from_other_thread_uv_async = ALLOC(uv_async_t);
+  r = uv_async_init(AE_uv_loop, ae_call_from_other_thread_uv_async, _uv_async_callback);
+  AE_ASSERT(r == 0);
+}
+
+
+void unload_ae_call_from_other_thread(void)
+{
+  AE_TRACE();
+
+  AE_ASSERT(ae_call_from_other_thread_uv_async != NULL);
+
+  AE_CLOSE_UV_HANDLE(ae_call_from_other_thread_uv_async);
+  ae_call_from_other_thread_uv_async = NULL;
+}
+
+
+static
+VALUE AsyncEngine_call_from_other_thread(int argc, VALUE *argv, VALUE self)
+{
+  AE_TRACE();
+  VALUE proc;
+  int r;
+
+  AE_CHECK_STATUS();
+  AE_RB_CHECK_NUM_ARGS(0,1);
+  AE_RB_ENSURE_BLOCK_OR_PROC(1, proc);
+
+  rb_ary_push(rb_ivar_get(mAsyncEngine, att_call_from_other_thread_procs), proc);
+  r = uv_async_send(ae_call_from_other_thread_uv_async);
+  AE_ASSERT(r == 0);
+
+  return Qtrue;
+}
+
+
+static
+void _uv_async_callback(uv_async_t* handle, int status)
+{
+  AE_TRACE();
+
+  ae_take_gvl_and_run_with_error_handler(_ae_async_callback);
+}
+
+
+static
+VALUE _ae_async_callback(void)
+{
+  AE_TRACE();
+  VALUE procs;
+  long i;
+
+  AE_ASSERT(AE_status == AE_RUNNING);
+
+  // procs = @_call_from_other_thread_procs
+  procs = rb_ivar_get(mAsyncEngine, att_call_from_other_thread_procs);
+  // @_call_from_other_thread_procs = []
+  rb_ivar_set(mAsyncEngine, att_call_from_other_thread_procs, rb_ary_new());
+
+  // Iterate procs Array and call each proc.
+  for(i=0 ; i<RARRAY_LEN(procs) ; i++) {
+    // It could occur that one of these procs is a release_loop() method, so
+    // stop iterating.
+    if (AE_status != AE_RUNNING)
+      break;
+    ae_run_with_error_handler(ae_proc_call_0, rb_ary_entry(procs, i));
+  }
+  procs = Qnil;
+
+  return Qnil;
+}

data/ext/asyncengine/ae_call_from_other_thread.h

@@ -0,0 +1,12 @@
+#ifndef AE_CALL_FROM_OTHER_THREAD_H
+#define AE_CALL_FROM_OTHER_THREAD_H
+
+
+void init_ae_call_from_other_thread(void);
+void load_ae_call_from_other_thread_uv_async(void);
+void unload_ae_call_from_other_thread_uv_async(void);
+
+static VALUE AsyncEngine_call_from_other_thread(int argc, VALUE *argv, VALUE self);
+
+
+#endif  /* AE_CALL_FROM_OTHER_THREAD_H */

data/ext/asyncengine/ae_handle_common.c

@@ -2,99 +2,244 @@
 #include "ae_handle_common.h"
 
 
-// Global variables defined in asyncengine_ruby.c.
-extern VALUE mAsyncEngine;
+// Ruby modules/classes.
+static VALUE mKernel;
 
-// C variable holding current block number.
-static long block_id = 0;
+// Ruby method names.
+static ID method_call;
+static ID method_handle_error;
+static ID method_raise;
 
-// Ruby class for saving C data inside.
-VALUE cAsyncEngineCData;
+// C variable holding current proc number.
+static long proc_long_id;
 
-// Ruby attributes.
-static ID att_blocks;
-ID att_cdata;
-ID att_handle_terminated;
 
-// Ruby method names.
-ID id_method_call;
-ID id_manage_exception;
+void init_ae_handle_common(void)
+{
+  AE_TRACE();
+
+  mKernel = rb_define_module("Kernel");
+
+  method_call = rb_intern("call");
+  method_handle_error = rb_intern("handle_error");
+  method_raise = rb_intern("raise");
+
+  proc_long_id = 0;
+}
 
 
-void init_ae_handle_common()
+VALUE ae_store_handle(VALUE ae_handle)
 {
-  cAsyncEngineCData = rb_define_class_under(mAsyncEngine, "CData", rb_cObject);
+  AE_TRACE();
 
-  att_blocks = rb_intern("@_blocks");
-  att_cdata = rb_intern("@_cdata");
-  att_handle_terminated = rb_intern("@_handle_terminated");
+  VALUE ae_handle_id = rb_obj_id(ae_handle);
+  rb_hash_aset(AE_handles, ae_handle_id, ae_handle);
 
-  id_method_call = rb_intern("call");
-  id_manage_exception = rb_intern("manage_exception");
+  return ae_handle_id;
 }
 
 
-VALUE ae_store_block(VALUE block)
+VALUE ae_get_handle(VALUE ae_handle_id)
 {
   AE_TRACE();
-  VALUE rb_block_id = LONG2FIX(++block_id);
 
-  rb_hash_aset(rb_ivar_get(mAsyncEngine, att_blocks), rb_block_id, block);
-  return rb_block_id;
+  return rb_hash_aref(AE_handles, ae_handle_id);
 }
 
 
-VALUE ae_get_block(VALUE rb_block_id)
+VALUE ae_remove_handle(VALUE ae_handle_id)
 {
   AE_TRACE();
-  return rb_hash_aref(rb_ivar_get(mAsyncEngine, att_blocks), rb_block_id);
+
+  return rb_hash_delete(AE_handles, ae_handle_id);
 }
 
 
-VALUE ae_remove_block(VALUE rb_block_id)
+VALUE ae_store_proc(VALUE proc)
 {
   AE_TRACE();
-  return rb_hash_delete(rb_ivar_get(mAsyncEngine, att_blocks), rb_block_id);
+
+  VALUE proc_id = LONG2FIX(++proc_long_id);
+  rb_hash_aset(AE_procs, proc_id, proc);
+
+  return proc_id;
 }
 
 
-void ae_manage_exception(int exception_tag)
+VALUE ae_get_proc(VALUE proc_id)
 {
   AE_TRACE();
 
-  // rb_errinfo() gives the current exception object in this thread.
-  VALUE exception = rb_errinfo();
+  return rb_hash_aref(AE_procs, proc_id);
+}
 
-  // Just check the exception in the user provided AE.exception_manager block if
-  // it is a StandardError. Otherwise raise it and terminate.
-  if (rb_obj_is_kind_of(exception, rb_eStandardError) == Qtrue) {
-    rb_funcall(mAsyncEngine, id_manage_exception, 1, exception);
-    // Dissable the current thread exception.
-    rb_set_errinfo(Qnil);
-  }
-  else
-    rb_jump_tag(exception_tag);
+
+VALUE ae_remove_proc(VALUE proc_id)
+{
+  AE_TRACE();
+
+  return rb_hash_delete(AE_procs, proc_id);
 }
 
 
-void ae_handle_close_callback_0(uv_handle_t* handle)
+void ae_uv_handle_close_callback(uv_handle_t* handle)
 {
   AE_TRACE();
+
   xfree(handle);
 }
 
 
-static VALUE wrapper_rb_funcall_0(VALUE block)
+int ae_get_last_uv_error_int(void)
+{
+  AE_TRACE();
+
+  return uv_last_error(AE_uv_loop).code;
+}
+
+
+VALUE ae_get_uv_error(int uv_errno)
+{
+  AE_TRACE();
+
+  VALUE ae_uv_error;
+
+  if (NIL_P(ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(uv_errno))))
+    ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(-1));
+
+  return ae_uv_error;
+}
+
+
+VALUE ae_get_last_uv_error(void)
+{
+  AE_TRACE();
+
+  VALUE ae_uv_error;
+
+  if (NIL_P(ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(uv_last_error(AE_uv_loop).code))))
+    ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(-1));
+
+  return ae_uv_error;
+}
+
+
+void ae_raise_uv_error(int uv_errno)
+{
+  AE_TRACE();
+
+  VALUE ae_uv_error = ae_get_uv_error(uv_errno);
+
+  rb_funcall2(mKernel, method_raise, 1, &ae_uv_error);
+}
+
+
+void ae_raise_last_uv_error(void)
 {
-  rb_funcall(block, id_method_call, 0, 0);
-  return Qnil;
+  AE_TRACE();
+
+  VALUE ae_uv_error = ae_get_last_uv_error();
+
+  rb_funcall2(mKernel, method_raise, 1, &ae_uv_error);
 }
 
 
-int ae_protect_block_call_0(VALUE block)
+VALUE ae_proc_call_0(VALUE proc)
 {
-  int exception = 0;
+  AE_TRACE();
 
-  rb_protect(wrapper_rb_funcall_0, block, &exception);
-  return exception;
+  AE_ASSERT(! NIL_P(proc));
+  return rb_funcall2(proc, method_call, 0, NULL);
 }
+
+
+VALUE ae_proc_call_1(VALUE proc, VALUE param)
+{
+  AE_TRACE();
+
+  AE_ASSERT(! NIL_P(proc));
+  return rb_funcall2(proc, method_call, 1, &param);
+}
+
+
+VALUE ae_proc_call_2(VALUE proc, VALUE param1, VALUE param2)
+{
+  AE_TRACE();
+
+  AE_ASSERT(! NIL_P(proc));
+  return rb_funcall(proc, method_call, 2, param1, param2);
+}
+
+
+VALUE ae_proc_call_3(VALUE proc, VALUE param1, VALUE param2, VALUE param3)
+{
+  AE_TRACE();
+
+  AE_ASSERT(! NIL_P(proc));
+  return rb_funcall(proc, method_call, 3, param1, param2, param3);
+}
+
+
+/*
+ * When any AsyncEngine handler runs a handle method having the GVL,
+ * it must use this function, which can receive an optional VALUE parameter.
+ */
+VALUE ae_run_with_error_handler(void* function, VALUE param)
+{
+  AE_TRACE();
+
+  VALUE ret, error;
+  int error_tag;
+
+  if (param)
+    ret = rb_protect(function, (VALUE)param, &error_tag);
+  else
+    ret = rb_protect(function, Qnil, &error_tag);
+
+  /*
+   * If an error occurs while in function() it can be due:
+   *
+   * - An Exception (including SystemExit), this is "rescue-able" via "rescue Exception"
+   *   and will run the "ensure" code if present. In this case rb_errinfo() returns the
+   *   exact Exception object.
+   *
+   * - A Thread#kill. This is NOT "rescue-able" via "rescue Exception" but it WILL run
+   *   the "ensure" code if present. In this case rb_errinfo() returns FIXNUM 8.
+   *
+   * So, check the class of the object returned by rb_errinfo(). If it's an Exception then
+   * store it, release the loop and raise it. Otherwise (Thread#kill) then don't store the
+   * exception returned by rb_errinfo() and just release the loop. Ruby will do the rest.
+   */
+
+  if (error_tag) {
+    // TODO: This could return Fixnum 8: https://github.com/ibc/AsyncEngine/issues/4,
+    // so the error handler must check it. Maybe it's better to set error=Qnil and
+    // pass it to the error handler? NO, let's ae_handle_error(error) to do it.
+    error = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    AE_DEBUG("error class: %s", rb_obj_classname(error));
+
+    // NOTE: This function should never been called when releasing.
+    if (AE_status == AE_RELEASING)
+      AE_ABORT("error (class: %s) rescued while in releasing status", rb_obj_classname(error));  // TODO: testing, not sure yet.
+
+    AE_DEBUG("error (class: %s) rescued, passing it to the error handler", rb_obj_classname(error));
+    ae_handle_error(error);
+    return Qnil;
+  }
+  else
+    return ret;
+}
+
+
+/*
+ * When any AsyncEngine handler runs a Ruby callback, it must
+ * use this function, which must be called without the GVL.
+ * TODO: Allow passing a VALUE parameter...?
+ */
+VALUE ae_take_gvl_and_run_with_error_handler(void* function)
+{
+  AE_TRACE();
+
+  return rb_thread_call_with_gvl(ae_run_with_error_handler, function);
+}