asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/ae_handle_common.h

@@ -2,19 +2,46 @@
 #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);
+#define AE_CLOSE_UV_HANDLE(handle)  \
+  uv_close((uv_handle_t *)handle, ae_uv_handle_close_callback);
+
+#define GET_CDATA_FROM_SELF  \
+  struct_cdata* cdata;  \
+  Data_Get_Struct(self, struct_cdata, cdata)
+
+#define CHECK_UV_HANDLE_IS_OPEN  \
+  if (! (cdata->_uv_handle))  \
+    return Qfalse;
+
+#define GET_CDATA_FROM_SELF_AND_CHECK_UV_HANDLE_IS_OPEN  \
+  GET_CDATA_FROM_SELF;  \
+  CHECK_UV_HANDLE_IS_OPEN
+
+
+void init_ae_handle_common(void);
+
+VALUE ae_store_handle(VALUE);
+VALUE ae_get_handle(VALUE);
+VALUE ae_remove_handle(VALUE);
+
+VALUE ae_store_proc(VALUE);
+VALUE ae_get_proc(VALUE);
+VALUE ae_remove_proc(VALUE);
+
+void ae_uv_handle_close_callback(uv_handle_t*);
+int ae_get_last_uv_error_int(void);
+VALUE ae_get_uv_error(int uv_errno);
+VALUE ae_get_last_uv_error(void);
+void ae_raise_uv_error(int uv_errno);
+void ae_raise_last_uv_error(void);
+
+VALUE ae_proc_call_0(VALUE proc);
+VALUE ae_proc_call_1(VALUE proc, VALUE param);
+VALUE ae_proc_call_2(VALUE proc, VALUE param1, VALUE param2);
+VALUE ae_proc_call_3(VALUE proc, VALUE param1, VALUE param2, VALUE param3);
+
+VALUE ae_run_with_error_handler(void* function, VALUE param);
+VALUE ae_take_gvl_and_run_with_error_handler(void* function);
 
 
 #endif  /* AE_HANDLE_COMMON_H */

data/ext/asyncengine/ae_ip_utils.c

@@ -0,0 +1,246 @@
+#include "asyncengine_ruby.h"
+#include "ae_handle_common.h"
+#include "ae_ip_utils.h"
+
+
+/* TODO: Temporary hack: libuv should provide uv_inet_pton and uv_inet_ntop. */
+#ifdef AE_OS_WINDOWS
+  #include <inet_net_pton.h>
+  #include <inet_ntop.h>
+  #define ae_inet_pton ares_inet_pton
+  #define ae_inet_ntop ares_inet_ntop
+#else /* AE_OS_UNIX */
+  #include <arpa/inet.h>
+  #define ae_inet_pton inet_pton
+  #define ae_inet_ntop inet_ntop
+#endif
+
+
+static VALUE mAsyncEngineIpUtils;
+
+
+void init_ae_ip_utils()
+{
+  AE_TRACE();
+
+  mAsyncEngineIpUtils = rb_define_module_under(mAsyncEngine, "IpUtils");
+
+  rb_define_module_function(mAsyncEngineIpUtils, "ip_type", AsyncEngineIpUtils_ip_type, 1);
+  rb_define_module_function(mAsyncEngineIpUtils, "compare_ips", AsyncEngineIpUtils_compare_ips, -1);
+
+  symbol_ipv4 = ID2SYM(rb_intern("ipv4"));
+  symbol_ipv6 = ID2SYM(rb_intern("ipv6"));
+  symbol_ipv6_reference = ID2SYM(rb_intern("ipv6_reference"));
+}
+
+
+VALUE AsyncEngineIpUtils_ip_type(VALUE self, VALUE _rb_str)
+{
+  AE_TRACE();
+
+  char *str;
+  long len;
+
+  if (TYPE(_rb_str) != T_STRING)
+    rb_raise(rb_eTypeError, "argument must be a String");
+
+  str = RSTRING_PTR(_rb_str);
+  len = RSTRING_LEN(_rb_str);
+
+  switch(ae_ip_parser_execute(str, len)) {
+    case(ip_type_ipv4):
+      return symbol_ipv4;
+      break;
+    case(ip_type_ipv6):
+      return symbol_ipv6;
+      break;
+    case(ip_type_ipv6_reference):
+      return symbol_ipv6_reference;
+      break;
+    default:
+      return Qfalse;
+      break;
+  }
+}
+
+
+/*
+ * Return 1 if both pure IP's are equal, 0 otherwise.
+ */
+static
+int compare_pure_ips(char *ip1, size_t len1, enum_ip_type ip1_type, char *ip2, size_t len2, enum_ip_type ip2_type)
+{
+  AE_TRACE();
+
+  struct in_addr in_addr1, in_addr2;
+  struct in6_addr in6_addr1, in6_addr2;
+  //INET6_ADDRSTRLEN = 46
+  char _ip1[46], _ip2[46];
+
+  // Not same IP type, return false.
+  if (ip1_type != ip2_type)
+    return 0;
+
+  memcpy(_ip1, ip1, len1);
+  _ip1[len1] = '\0';
+  memcpy(_ip2, ip2, len2);
+  _ip2[len2] = '\0';
+
+  switch(ip1_type) {
+    // Comparing IPv4 with IPv4.
+    case(ip_type_ipv4):
+      if (ae_inet_pton(AF_INET, _ip1, &in_addr1) == 0)  return 0;
+      if (ae_inet_pton(AF_INET, _ip2, &in_addr2) == 0)  return 0;
+      if (in_addr1.s_addr == in_addr2.s_addr)
+        return 1;
+      else
+        return 0;
+      break;
+    // Comparing IPv6 with IPv6.
+    case(ip_type_ipv6):
+      if (ae_inet_pton(AF_INET6, _ip1, &in6_addr1) != 1)  return 0;
+      if (ae_inet_pton(AF_INET6, _ip2, &in6_addr2) != 1)  return 0;
+      if (memcmp(in6_addr1.s6_addr, in6_addr2.s6_addr, sizeof(in6_addr1.s6_addr)) == 0)
+        return 1;
+      else
+        return 0;
+      break;
+    default:
+      return 0;
+      break;
+  }
+}
+
+
+/*
+ * Returns true if both IP's are equal (binary comparison). It allows comparison
+ * between IPv4, IPv6 and IPv6 references.
+ * Returns true when comparing an IPv6 with its IPv6 reference in case
+ * parameter _allow_ipv6_reference_ is set to true, it returns false otherwise.
+ *
+ * Returns nil if at least one of the IP's is not valid IPv4, IPv6 or IPv6 reference.
+ */
+VALUE AsyncEngineIpUtils_compare_ips(int argc, VALUE *argv, VALUE self)
+{
+  AE_TRACE();
+
+  char *str1, *str2;
+  long len1, len2;
+  enum_ip_type ip1_type, ip2_type;
+  int allow_ipv6_reference = 0;
+  int ipv6_references_found = 0;
+
+  AE_RB_CHECK_NUM_ARGS(2,3);
+
+  if (! RB_TYPE_P(argv[0], T_STRING) || ! RB_TYPE_P(argv[1], T_STRING))
+    rb_raise(rb_eTypeError, "first and second arguments must be String");
+
+  if (argc == 3 && RB_TYPE_P(argv[2], T_TRUE))
+    allow_ipv6_reference = 1;
+
+  str1 = RSTRING_PTR(argv[0]);
+  len1 = RSTRING_LEN(argv[0]);
+  str2 = RSTRING_PTR(argv[1]);
+  len2 = RSTRING_LEN(argv[1]);
+
+  switch(ip1_type = ae_ip_parser_execute(str1, len1)) {
+    case(ip_type_no_ip):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      ipv6_references_found++;
+      str1 += 1;
+      len1 -= 2;
+      ip1_type = ip_type_ipv6;
+      break;
+    default:
+      break;
+  }
+  switch(ip2_type = ae_ip_parser_execute(str2, len2)) {
+    case(ip_type_no_ip):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      ipv6_references_found++;
+      str2 += 1;
+      len2 -= 2;
+      ip2_type = ip_type_ipv6;
+      break;
+    default:
+      break;
+  }
+
+  if (ipv6_references_found == 1 && allow_ipv6_reference == 0)
+    return Qfalse;
+
+  if (compare_pure_ips(str1, len1, ip1_type, str2, len2, ip2_type))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+
+int ae_ip_utils_is_valid_port(int port)
+{
+  AE_TRACE();
+
+  if (port >= 0 && port <= 65535)
+    return 1;
+  else
+    return 0;
+}
+
+
+VALUE ae_ip_utils_get_ip_port(struct sockaddr_storage *addr, enum_ip_type ip_type)
+{
+  AE_TRACE();
+
+  struct sockaddr_in *addr4;
+  struct sockaddr_in6 *addr6;
+  char ip[INET6_ADDRSTRLEN + 1];
+  int port;
+  VALUE _rb_array_ip_port;
+
+  switch(ip_type) {
+    case ip_type_ipv4:
+      addr4 = (struct sockaddr_in*)addr;
+      AE_ASSERT(ae_inet_ntop(AF_INET, &addr4->sin_addr, ip, INET_ADDRSTRLEN));
+      port = (int)htons(addr4->sin_port);
+      break;
+    case ip_type_ipv6:
+      addr6 = (struct sockaddr_in6*)addr;
+      AE_ASSERT(ae_inet_ntop(AF_INET6, &addr6->sin6_addr, ip, INET6_ADDRSTRLEN));
+      port = (int)htons(addr6->sin6_port);
+      break;
+    default:
+      AE_ASSERT("invalid ip_type");
+  }
+
+  _rb_array_ip_port = rb_ary_new2(2);
+  rb_ary_store(_rb_array_ip_port, 0, rb_str_new2(ip));
+  rb_ary_store(_rb_array_ip_port, 1, INT2FIX(port));
+
+  return _rb_array_ip_port;
+}
+
+
+VALUE ae_ip_type_to_rb_symbol(enum_ip_type ip_type)
+{
+  AE_TRACE();
+
+  switch(ip_type) {
+    case ip_type_ipv4:
+      return symbol_ipv4;
+      break;
+    case ip_type_ipv6:
+      return symbol_ipv6;
+      break;
+    case ip_type_ipv6_reference:
+      return symbol_ipv6_reference;
+      break;
+    case ip_type_no_ip:
+      return Qnil;
+    default:
+      AE_ABORT("invalid enum_ip_type %d", ip_type);
+  }
+}

data/ext/asyncengine/ae_ip_utils.h

@@ -0,0 +1,25 @@
+#ifndef AE_IP_UTILS_H
+#define AE_IP_UTILS_H
+
+
+#include "ip_parser.h"
+
+
+/* Exported Ruby symbols. */
+
+VALUE symbol_ipv4;
+VALUE symbol_ipv6;
+VALUE symbol_ipv6_reference;
+
+
+void init_ae_ip_utils(void);
+
+VALUE AsyncEngineIpUtils_ip_type(VALUE self, VALUE _rb_str);
+VALUE AsyncEngineIpUtils_compare_ips(int argc, VALUE *argv, VALUE self);
+
+int ae_ip_utils_is_valid_port(int port);
+VALUE ae_ip_utils_get_ip_port(struct sockaddr_storage *addr, enum_ip_type ip_type);
+VALUE ae_ip_type_to_rb_symbol(enum_ip_type ip_type);
+
+
+#endif  /* AE_IP_UTILS_H */

data/ext/asyncengine/ae_next_tick.c

@@ -3,49 +3,109 @@
 #include "ae_next_tick.h"
 
 
-// C variable indicating whether there are pending next_ticks.
-static int pending_next_ticks;
+static ID att_next_tick_procs;
 
-static ID id_method_execute_next_ticks;
+static uv_idle_t* ae_next_tick_uv_idle;
 
 
-void init_ae_next_tick()
+/** Pre-declaration of static functions. */
+
+static void _uv_idle_callback(uv_idle_t* handle, int status);
+static VALUE _ae_idle_callback(void);
+
+
+void init_ae_next_tick(void)
 {
-  pending_next_ticks = 0;
+  AE_TRACE();
+
+  rb_define_module_function(mAsyncEngine, "next_tick", AsyncEngine_next_tick, -1);
 
-  rb_define_module_function(mAsyncEngine, "_c_next_tick", AsyncEngine_c_next_tick, 0);
+  att_next_tick_procs = rb_intern("@_next_tick_procs");
 
-  id_method_execute_next_ticks = rb_intern("execute_next_ticks");
+  ae_next_tick_uv_idle = NULL;
+}
+
+
+void load_ae_next_tick_uv_idle(void)
+{
+  AE_TRACE();
+  int r;
+
+  AE_ASSERT(ae_next_tick_uv_idle == NULL);
+
+  ae_next_tick_uv_idle = ALLOC(uv_idle_t);
+  r = uv_idle_init(AE_uv_loop, ae_next_tick_uv_idle);
+  AE_ASSERT(r == 0);
+}
+
+
+void unload_ae_next_tick_uv_idle(void)
+{
+  AE_TRACE();
+
+  AE_ASSERT(ae_next_tick_uv_idle != NULL);
+
+  AE_CLOSE_UV_HANDLE(ae_next_tick_uv_idle);
+  ae_next_tick_uv_idle = NULL;
 }
 
 
 static
-void execute_next_tick_with_gvl()
+VALUE AsyncEngine_next_tick(int argc, VALUE *argv, VALUE self)
 {
   AE_TRACE();
-  rb_funcall(mAsyncEngine, id_method_execute_next_ticks, 0, 0);
+  VALUE proc;
+  int r;
+
+  AE_ASSERT(ae_next_tick_uv_idle != NULL);
+
+  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_next_tick_procs), proc);
+  if (! uv_is_active((uv_handle_t *)ae_next_tick_uv_idle)) {
+    r = uv_idle_start(ae_next_tick_uv_idle, _uv_idle_callback);
+    AE_ASSERT(r == 0);
+  }
+
+  return Qtrue;
 }
 
 
 static
-void next_tick_callback(uv_idle_t* handle, int status)
+void _uv_idle_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);
+  ae_take_gvl_and_run_with_error_handler(_ae_idle_callback);
 }
 
 
-VALUE AsyncEngine_c_next_tick(VALUE self)
+static
+VALUE _ae_idle_callback(void)
 {
   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);
+  VALUE procs;
+  long i;
+
+  AE_ASSERT(AE_status == AE_RUNNING);
+
+  // procs = @_next_tick_procs
+  procs = rb_ivar_get(mAsyncEngine, att_next_tick_procs);
+  // @_next_tick_procs = []
+  rb_ivar_set(mAsyncEngine, att_next_tick_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));
   }
-  return Qtrue;
-}
+  procs = Qnil;
+
+  return Qnil;
+}