asyncengine 0.0.1.testing → 0.0.1.testing1

data/asyncengine.gemspec

@@ -11,15 +11,15 @@ Gem::Specification.new do |spec|
   spec.summary = "Ruby asynchronous event driven library based on libuv"
   spec.homepage = "https://github.com/ibc/AsyncEngine"
   spec.description = "Ruby asynchronous event driven library based on libuv"
-  spec.extensions = ["ext/asyncengine_ext/extconf.rb"]
+  spec.extensions = ["ext/asyncengine/extconf.rb"]
   spec.required_ruby_version = ">= 1.9.2"
 
   files = %w{
     asyncengine.gemspec
     README.markdown
     lib/**/**
-    ext/asyncengine_ext/{*.c,*.h,*.rb}
-    ext/asyncengine_ext/libuv/**/**/**/**/**/**/**/**/**
+    ext/asyncengine/{*.c,*.h,*.rb}
+    ext/asyncengine/libuv/**/**/**/**/**/**/**/**/**
   }.join(",")
   spec.files = Dir.glob "{#{files}}"
   spec.require_paths = ["lib"]

data/ext/asyncengine/ae_handle_common.c

@@ -0,0 +1,100 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+
+
+// Global variables defined in asyncengine_ruby.c.
+extern VALUE mAsyncEngine;
+
+// C variable holding current block number.
+static long block_id = 0;
+
+// Ruby class for saving C data inside.
+VALUE cAsyncEngineCData;
+
+// 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()
+{
+  cAsyncEngineCData = rb_define_class_under(mAsyncEngine, "CData", rb_cObject);
+
+  att_blocks = rb_intern("@_blocks");
+  att_cdata = rb_intern("@_cdata");
+  att_handle_terminated = rb_intern("@_handle_terminated");
+
+  id_method_call = rb_intern("call");
+  id_manage_exception = rb_intern("manage_exception");
+}
+
+
+VALUE ae_store_block(VALUE block)
+{
+  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;
+}
+
+
+VALUE ae_get_block(VALUE rb_block_id)
+{
+  AE_TRACE();
+  return rb_hash_aref(rb_ivar_get(mAsyncEngine, att_blocks), rb_block_id);
+}
+
+
+VALUE ae_remove_block(VALUE rb_block_id)
+{
+  AE_TRACE();
+  return rb_hash_delete(rb_ivar_get(mAsyncEngine, att_blocks), rb_block_id);
+}
+
+
+void ae_manage_exception(int exception_tag)
+{
+  AE_TRACE();
+
+  // rb_errinfo() gives the current exception object in this thread.
+  VALUE exception = rb_errinfo();
+
+  // 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);
+}
+
+
+void ae_handle_close_callback_0(uv_handle_t* handle)
+{
+  AE_TRACE();
+  xfree(handle);
+}
+
+
+static VALUE wrapper_rb_funcall_0(VALUE block)
+{
+  rb_funcall(block, id_method_call, 0, 0);
+  return Qnil;
+}
+
+
+int ae_protect_block_call_0(VALUE block)
+{
+  int exception = 0;
+
+  rb_protect(wrapper_rb_funcall_0, block, &exception);
+  return exception;
+}

data/ext/asyncengine/ae_handle_common.h

@@ -0,0 +1,20 @@
+#ifndef AE_HANDLE_COMMON_H
+#define AE_HANDLE_COMMON_H
+
+
+VALUE cAsyncEngineCData;
+ID att_cdata;
+ID att_handle_terminated;
+ID id_method_call;
+
+void init_ae_handle_common();
+
+VALUE ae_store_block(VALUE);
+VALUE ae_get_block(VALUE);
+VALUE ae_remove_block(VALUE);
+void ae_manage_exception(int);
+void ae_handle_close_callback_0(uv_handle_t*);
+int ae_protect_block_call_0(VALUE);
+
+
+#endif  /* AE_HANDLE_COMMON_H */

data/ext/asyncengine/ae_next_tick.c

@@ -0,0 +1,51 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_next_tick.h"
+
+
+// C variable indicating whether there are pending next_ticks.
+static int pending_next_ticks;
+
+static ID id_method_execute_next_ticks;
+
+
+void init_ae_next_tick()
+{
+  pending_next_ticks = 0;
+
+  rb_define_module_function(mAsyncEngine, "_c_next_tick", AsyncEngine_c_next_tick, 0);
+
+  id_method_execute_next_ticks = rb_intern("execute_next_ticks");
+}
+
+
+static
+void execute_next_tick_with_gvl()
+{
+  AE_TRACE();
+  rb_funcall(mAsyncEngine, id_method_execute_next_ticks, 0, 0);
+}
+
+
+static
+void next_tick_callback(uv_idle_t* handle, int status)
+{
+  AE_TRACE();
+  uv_idle_stop(handle);
+  uv_close((uv_handle_t *)handle, ae_handle_close_callback_0);
+  pending_next_ticks = 0;
+  rb_thread_call_with_gvl(execute_next_tick_with_gvl, NULL);
+}
+
+
+VALUE AsyncEngine_c_next_tick(VALUE self)
+{
+  AE_TRACE();
+  if (pending_next_ticks == 0) {
+    uv_idle_t* _uv_handle = ALLOC(uv_idle_t);
+    uv_idle_init(uv_default_loop(), _uv_handle);
+    pending_next_ticks = 1;
+    uv_idle_start(_uv_handle, next_tick_callback);
+  }
+  return Qtrue;
+}

data/ext/asyncengine/ae_next_tick.h

@@ -0,0 +1,10 @@
+#ifndef AE_NEXT_TICK_H
+#define AE_NEXT_TICK_H
+
+
+void init_ae_next_tick();
+
+VALUE AsyncEngine_c_next_tick(VALUE self);
+
+
+#endif  /* AE_NEXT_TICK_H */

data/ext/asyncengine/ae_timer.c

@@ -0,0 +1,152 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_timer.h"
+
+
+static VALUE cAsyncEngineTimer;
+
+
+typedef struct {
+  uv_timer_t *_uv_handle;
+  int periodic;
+  VALUE rb_block_id;
+  int has_rb_instance;
+  VALUE rb_instance;  // Points to the owner AE::Timer (if there is).
+} struct_ae_timer_cdata;
+
+
+void init_ae_timer()
+{
+  cAsyncEngineTimer = rb_define_class_under(mAsyncEngine, "Timer", rb_cObject);
+  rb_define_module_function(mAsyncEngine, "_c_add_timer", AsyncEngine_c_add_timer, 4);
+  rb_define_method(cAsyncEngineTimer, "cancel", AsyncEngineTimer_cancel, 0);
+  rb_define_alias(cAsyncEngineTimer, "stop", "cancel");
+  rb_define_private_method(cAsyncEngineTimer, "_c_set_interval", AsyncEngineTimer_c_set_interval, 1);
+}
+
+
+static
+void deallocate(struct_ae_timer_cdata* cdata)
+{
+  AE_TRACE();
+
+  // Let the GC work.
+  ae_remove_block(cdata->rb_block_id);
+  // Close the timer so it's unreferenced by uv.
+  uv_close((uv_handle_t *)cdata->_uv_handle, ae_handle_close_callback_0);
+  // Free memory.
+  xfree(cdata);
+}
+
+
+static
+void execute_timer_with_gvl(uv_timer_t* handle)
+{
+  AE_TRACE();
+
+  struct_ae_timer_cdata* cdata = (struct_ae_timer_cdata*)handle->data;
+  VALUE block = ae_get_block(cdata->rb_block_id);
+  int exception_tag;
+
+  exception_tag = ae_protect_block_call_0(block);
+
+  // Terminate the timer if it is not periodic.
+  if (cdata->periodic == 0) {
+    // If the timer has a ruby AE::Timer instance then set its attribute
+    // @_handle_terminated to true.
+    if (cdata->has_rb_instance == 1)
+      rb_ivar_set(cdata->rb_instance, att_handle_terminated, Qtrue);
+    deallocate(cdata);
+  }
+
+  if (exception_tag)
+    ae_manage_exception(exception_tag);
+}
+
+
+static
+void timer_callback(uv_timer_t* handle, int status)
+{
+  AE_TRACE();
+  rb_thread_call_with_gvl(execute_timer_with_gvl, handle);
+}
+
+
+VALUE AsyncEngine_c_add_timer(VALUE self, VALUE rb_delay, VALUE rb_interval, VALUE block, VALUE instance)
+{
+  AE_TRACE();
+  uv_timer_t* _uv_handle = ALLOC(uv_timer_t);
+  struct_ae_timer_cdata* cdata = ALLOC(struct_ae_timer_cdata);
+  long delay, interval;
+
+  cdata->_uv_handle = _uv_handle;
+
+  delay = NUM2LONG(rb_delay);
+  if (NIL_P(rb_interval)) {
+    interval = 0;
+    cdata->periodic = 0;
+  }
+  else {
+    interval = NUM2LONG(rb_interval);
+    if (interval == 0)  interval = 1;
+    cdata->periodic = 1;
+  }
+
+  // Save the block from being GC'd.
+  cdata->rb_block_id = ae_store_block(block);
+
+  if (NIL_P(instance))
+    cdata->has_rb_instance = 0;
+  else {
+    cdata->has_rb_instance = 1;
+    cdata->rb_instance = instance;
+  }
+
+  // Initialize.
+  uv_timer_init(uv_default_loop(), _uv_handle);
+  _uv_handle->data = cdata;
+
+  uv_timer_start(_uv_handle, timer_callback, delay, interval);
+
+  return Data_Wrap_Struct(cAsyncEngineCData, NULL, NULL, cdata);
+}
+
+
+VALUE AsyncEngineTimer_cancel(VALUE self)
+{
+  AE_TRACE();
+  struct_ae_timer_cdata* cdata;
+
+  if (! NIL_P(rb_ivar_get(self, att_handle_terminated)))
+    return Qfalse;
+  rb_ivar_set(self, att_handle_terminated, Qtrue);
+
+  Data_Get_Struct(rb_ivar_get(self, att_cdata), struct_ae_timer_cdata, cdata);
+
+  // Stop timer.
+  uv_timer_stop(cdata->_uv_handle);
+
+  // Terminate the timer.
+  deallocate(cdata);
+
+  return Qtrue;
+}
+
+
+VALUE AsyncEngineTimer_c_set_interval(VALUE self, VALUE rb_interval)
+{
+  AE_TRACE();
+  struct_ae_timer_cdata* cdata;
+  long interval;
+  
+  if (! NIL_P(rb_ivar_get(self, att_handle_terminated)))
+    return Qfalse;
+
+  Data_Get_Struct(rb_ivar_get(self, att_cdata), struct_ae_timer_cdata, cdata);
+
+  interval = NUM2LONG(rb_interval);
+  if (interval == 0)  interval = 1;
+  
+  uv_timer_set_repeat(cdata->_uv_handle, interval);
+  return rb_interval;
+}

data/ext/asyncengine/ae_timer.h

@@ -0,0 +1,12 @@
+#ifndef AE_TIMER_H
+#define AE_TIMER_H
+
+
+void init_ae_timer();
+
+VALUE AsyncEngine_c_add_timer(VALUE self, VALUE delay, VALUE interval, VALUE block, VALUE instance);
+VALUE AsyncEngineTimer_cancel(VALUE self);
+VALUE AsyncEngineTimer_c_set_interval(VALUE self, VALUE interval);
+
+
+#endif  /* AE_TIMER_H */

data/ext/asyncengine/ae_udp.c

@@ -0,0 +1,24 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_udp.h"
+
+
+void init_ae_udp()
+{
+  rb_define_module_function(mAsyncEngine, "test_ipv4", AsyncEngine_test_ipv4, 2);
+}
+
+
+VALUE AsyncEngine_test_ipv4(VALUE self, VALUE rb_ip, VALUE rb_port)
+{
+  char* ip = StringValueCStr(rb_ip);
+  int port = FIX2INT(rb_port);
+  struct sockaddr_in addr;
+  
+  //printf("AsyncEngine_ip4():  ip=%s, port=%d\n", ip, port);
+  /* Convert string ip addresses to binary structures */
+  
+  //UV_EXTERN struct sockaddr_in uv_ip4_addr(const char* ip, int port);
+  addr = uv_ip4_addr(ip, port);
+  
+}

data/ext/asyncengine/ae_udp.h

@@ -0,0 +1,10 @@
+#ifndef AE_UDP_H
+#define AE_UDP_H
+
+
+void init_ae_udp();
+
+VALUE AsyncEngine_test_ipv4(VALUE self, VALUE rb_ip, VALUE rb_port);
+
+
+#endif  /* AE_UDP_H */

data/ext/asyncengine/asyncengine_ruby.c

@@ -0,0 +1,72 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_timer.h"
+#include "ae_next_tick.h"
+#include "ae_udp.h"
+
+
+static
+void prepare_callback(uv_prepare_t* handle, int status)
+{
+  AE_TRACE();
+
+  // Check received interruptions in Ruby land.
+  rb_thread_call_with_gvl(rb_thread_check_ints, NULL);
+
+  // If this uv_prepare is the only existing handle, then terminate the loop.
+  if (uv_loop_refcount(uv_default_loop()) == 1)
+    uv_close((uv_handle_t *)handle, ae_handle_close_callback_0);
+}
+
+
+static
+VALUE run_uv_without_gvl(void* param)
+{
+  AE_TRACE();
+
+  if (! uv_run(uv_default_loop())) {
+    return Qtrue;
+  }
+  else
+    return Qfalse;
+}
+
+
+VALUE AsyncEngine_c_run(VALUE self)
+{
+  AE_TRACE();
+  uv_prepare_t *_uv_prepare = ALLOC(uv_prepare_t);
+
+  uv_prepare_init(uv_default_loop(), _uv_prepare);
+  uv_prepare_start(_uv_prepare, prepare_callback);
+
+  return rb_thread_call_without_gvl(run_uv_without_gvl, NULL, RUBY_UBF_IO, NULL);
+}
+
+
+/*
+ * Returns the number of handlers in the loop.
+ * NOTE: The returned number is the real number of handles minus 1 (the prepare handle).
+ */
+VALUE AsyncEngine_num_handles(VALUE self)
+{
+  return INT2FIX(uv_loop_refcount(uv_default_loop()) - 1);
+}
+
+
+
+
+void Init_asyncengine_ext()
+{
+  AE_TRACE();
+
+  mAsyncEngine = rb_define_module("AsyncEngine");
+
+  rb_define_module_function(mAsyncEngine, "_c_run", AsyncEngine_c_run, 0);
+  rb_define_module_function(mAsyncEngine, "num_handles", AsyncEngine_num_handles, 0);
+
+  init_ae_handle_common();
+  init_ae_timer();
+  init_ae_next_tick();
+  init_ae_udp();
+}

data/ext/asyncengine/asyncengine_ruby.h

@@ -0,0 +1,22 @@
+#ifndef ASYNCENGINE_RUBY_H
+#define ASYNCENGINE_RUBY_H
+
+
+#include <ruby.h>
+#include <libuv/include/uv.h>  // NOTE: Not needed if dir_config() line is enabled in extconf.rb.
+//#include <uv.h>              // so this line becomes enough.
+
+
+// Uncomment this line for enabling TRACE() function.
+//#define AE_DEBUG
+#ifdef AE_DEBUG
+#define AE_TRACE()  fprintf(stderr, "AE_TRACE: %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define AE_TRACE()
+#endif
+
+
+VALUE mAsyncEngine;
+
+
+#endif  /* #ifndef ASYNCENGINE_RUBY_H */

data/ext/{asyncengine_ext → asyncengine}/extconf.rb

@@ -4,7 +4,7 @@ require "fileutils"
 
 
 def sys cmd
-  puts "system command:  #{cmd}"
+  puts "system command in #{File.expand_path(File.dirname(__FILE__))}:  #{cmd}"
   unless ret = xsystem(cmd)
     raise "system command `#{cmd}' failed, please report to https://github.com/ibc/AsyncEngine/issues"
   end
@@ -35,13 +35,13 @@ end
 $CFLAGS = RbConfig::CONFIG["CFLAGS"] = " #{cflags} "
 $LDFLAGS = RbConfig::CONFIG["LDFLAGS"] = " #{ldflags} "
 
-here = File.expand_path(File.dirname(__FILE__), "libuv/")
-
-Dir.chdir(here) do
+libuv_dir = File.expand_path(File.dirname(__FILE__), "libuv/")
+Dir.chdir(libuv_dir) do
   sys "CFLAGS='#{cflags}' make"
   FileUtils.mv "uv.a", "../libuv.a"
 end
 
-dir_config("uv", File.expand_path("../libuv/include", __FILE__), File.expand_path("../libuv", __FILE__))
-have_library("uv")
-create_makefile("asyncengine_ext")
+#dir_config("uv", File.expand_path("../libuv/include", __FILE__), File.expand_path("../libuv", __FILE__))
+have_library("uv") or raise "have_library('uv') returns false"
+
+create_makefile("asyncengine/asyncengine_ext")

data/ext/asyncengine/libuv/mkmf.log

@@ -0,0 +1,24 @@
+"CFLAGS='-shared -fPIC' make"
+ar rcs uv.a src/unix/async.o src/unix/cares.o src/unix/check.o src/unix/core.o src/unix/dl.o src/unix/error.o src/unix/fs.o src/unix/idle.o src/unix/loop.o src/unix/pipe.o src/unix/prepare.o src/unix/process.o src/unix/stream.o src/unix/tcp.o src/unix/thread.o src/unix/timer.o src/unix/tty.o src/unix/udp.o src/unix/linux/core.o src/unix/linux/inotify.o src/unix/linux/syscalls.o src/uv-common.o src/unix/uv-eio.o src/unix/ev/ev.o src/unix/eio/eio.o  src/ares/ares__close_sockets.o src/ares/ares__get_hostent.o src/ares/ares__read_line.o src/ares/ares__timeval.o src/ares/ares_cancel.o src/ares/ares_data.o src/ares/ares_destroy.o src/ares/ares_expand_name.o src/ares/ares_expand_string.o src/ares/ares_fds.o src/ares/ares_free_hostent.o src/ares/ares_free_string.o src/ares/ares_gethostbyaddr.o src/ares/ares_gethostbyname.o src/ares/ares_getnameinfo.o src/ares/ares_getopt.o src/ares/ares_getsock.o src/ares/ares_init.o src/ares/ares_library_init.o src/ares/ares_llist.o src/ares/ares_mkquery.o src/ares/ares_nowarn.o src/ares/ares_options.o src/ares/ares_parse_a_reply.o src/ares/ares_parse_aaaa_reply.o src/ares/ares_parse_mx_reply.o src/ares/ares_parse_ns_reply.o src/ares/ares_parse_ptr_reply.o src/ares/ares_parse_srv_reply.o src/ares/ares_parse_txt_reply.o src/ares/ares_process.o src/ares/ares_query.o src/ares/ares_search.o src/ares/ares_send.o src/ares/ares_strcasecmp.o src/ares/ares_strdup.o src/ares/ares_strerror.o src/ares/ares_timeout.o src/ares/ares_version.o src/ares/ares_writev.o src/ares/bitncmp.o src/ares/inet_net_pton.o src/ares/inet_ntop.o
+have_library: checking for main() in -luv... -------------------- yes
+
+"gcc -o conftest -I/usr/include/ruby-1.9.1/x86_64-linux -I/usr/include/ruby-1.9.1/ruby/backward -I/usr/include/ruby-1.9.1 -I.     -shared -fPIC  conftest.c  -L. -L/usr/lib        -lruby-1.9.1-static  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main() {return 0;}
+/* end */
+
+"gcc -o conftest -I/usr/include/ruby-1.9.1/x86_64-linux -I/usr/include/ruby-1.9.1/ruby/backward -I/usr/include/ruby-1.9.1 -I.     -shared -fPIC  conftest.c  -L. -L/usr/lib        -lruby-1.9.1-static -luv  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: /*top*/
+4: int main() {return 0;}
+5: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+