asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/rb_utilities.c

@@ -0,0 +1,54 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "debug.h"
+#include "rb_utilities.h"
+
+
+void init_rb_utilities(void)
+{
+  AE_TRACE();
+
+  symbol_encoding_external = ID2SYM(rb_intern("external"));
+  symbol_encoding_utf8 = ID2SYM(rb_intern("utf8"));
+  symbol_encoding_ascii = ID2SYM(rb_intern("ascii"));
+}
+
+
+VALUE ae_rb_str_new(char* s, long len, enum_string_encoding enc, int tainted)
+{
+  AE_TRACE();
+
+  switch(enc) {
+    case string_encoding_external:
+      return ( tainted ? AE_RB_STR_TAINTED_EXTERNAL_NEW(s, len) : AE_RB_STR_EXTERNAL_NEW(s, len) );
+      break;
+    case string_encoding_utf8:
+      return ( tainted ? AE_RB_STR_TAINTED_UTF8_NEW(s, len) : AE_RB_STR_UTF8_NEW(s, len) );
+      break;
+    case string_encoding_ascii:
+      return ( tainted ? AE_RB_STR_TAINTED_ASCII_NEW(s, len) : AE_RB_STR_ASCII_NEW(s, len) );
+      break;
+    default:
+      AE_ABORT("invalid enum_string_encoding %d", enc);
+  }
+}
+
+
+VALUE ae_encoding_to_rb_symbol(enum_string_encoding enc)
+{
+  AE_TRACE();
+
+  switch(enc) {
+    case string_encoding_external:
+      return symbol_encoding_external;
+      break;
+    case string_encoding_utf8:
+      return symbol_encoding_utf8;
+      break;
+    case string_encoding_ascii:
+      return symbol_encoding_ascii;
+      break;
+    default:
+      AE_ABORT("invalid enum_string_encoding %d", enc);
+  }
+}

data/ext/asyncengine/rb_utilities.h

@@ -0,0 +1,63 @@
+#ifndef _AE_RB_UTILITIES_H
+#define _AE_RB_UTILITIES_H
+
+
+/*
+ * Macros for checking variable arguments number in Ruby C methods.
+ * NOTE: These macros assume that the Ruby C method is defined as:
+ *   VALUE xxx(int argc, VALUE *argv, VALUE self)
+ */
+#define AE_RB_CHECK_NUM_ARGS(min,max)  \
+if (argc < min || argc > max)  \
+  rb_raise(rb_eArgError, "wrong number of arguments")
+
+#define AE_RB_GET_BLOCK_OR_PROC(num_arg, target_proc)  \
+  if (rb_block_given_p())  \
+    target_proc = rb_block_proc();  \
+  else if (argc >= num_arg) {  \
+    target_proc = argv[num_arg-1];  \
+    if (! rb_obj_is_proc(target_proc))  \
+      rb_raise(rb_eTypeError, "argument %d is not a Proc", num_arg);  \
+    }  \
+  else  \
+    target_proc = Qnil;
+
+#define AE_RB_ENSURE_BLOCK_OR_PROC(num_arg, save_to)  \
+  AE_RB_GET_BLOCK_OR_PROC(num_arg, save_to);  \
+  if (NIL_P(save_to))  \
+    rb_raise(rb_eArgError, "no block or proc given");
+
+/*
+ * Macros for generating Ruby strings with specified encoding.
+ */
+#define AE_RB_STR_EXTERNAL_NEW(s, len) (rb_enc_str_new(s, len, rb_default_external_encoding()))
+#define AE_RB_STR_TAINTED_EXTERNAL_NEW(s, len) (rb_external_str_new_with_enc(s, len, rb_default_external_encoding()))
+#define AE_RB_STR_UTF8_NEW(s, len) (rb_enc_str_new(s, len, rb_utf8_encoding()))
+#define AE_RB_STR_TAINTED_UTF8_NEW(s, len) (rb_external_str_new_with_enc(s, len, rb_utf8_encoding()))
+#define AE_RB_STR_ASCII_NEW(s, len) (rb_enc_str_new(s, len, rb_ascii8bit_encoding()))
+#define AE_RB_STR_TAINTED_ASCII_NEW(s, len) (rb_external_str_new_with_enc(s, len, rb_ascii8bit_encoding()))
+
+
+/* Exported C variables. */
+
+typedef enum {
+  string_encoding_external = 0,
+  string_encoding_utf8,
+  string_encoding_ascii
+} enum_string_encoding;
+
+
+/* Exported Ruby symbols. */
+
+VALUE symbol_encoding_external;
+VALUE symbol_encoding_utf8;
+VALUE symbol_encoding_ascii;
+
+
+void init_rb_utilities(void);
+
+VALUE ae_rb_str_new(char* ptr, long len, enum_string_encoding enc, int tainted);
+VALUE ae_encoding_to_rb_symbol(enum_string_encoding encoding);
+
+
+#endif  /* _AE_RB_UTILITIES_H */

data/lib/asyncengine.rb

@@ -1,65 +1,72 @@
-# AsyncEngine native C extension.
-require "asyncengine/asyncengine_ext.so"
+unless RUBY_VERSION >= "1.9.2"
+  raise LoadError, "AsyncEngine requires Ruby version >= 1.9.2 (current version is #{RUBY_VERSION})"
+end
 
-# AsyncEngine Ruby library files.
+
+require "asyncengine/uv_error.rb"
+require "asyncengine/asyncengine_ext.so"
 require "asyncengine/version.rb"
-require "asyncengine/errors.rb"
+require "asyncengine/handle.rb"
 require "asyncengine/timer.rb"
-require "asyncengine/next_tick.rb"
 require "asyncengine/udp.rb"
+require "asyncengine/tcp.rb"
+require "asyncengine/utils.rb"
+require "asyncengine/debug.rb"  # TODO: Temporal.
 
+require "socket"
 
-module AsyncEngine
 
-  @_is_running = false
-  @_exception_manager = nil
-  @_blocks = {}
-  @_next_ticks = []
+module AsyncEngine
 
-  def self.run
-    #raise AsyncEngine::Error, "AsyncEngine already running"  if @_is_running
-    @_is_running = true
+  @_handles = {}
+  @_procs = {}
+  @_next_tick_procs = []
+  @_call_from_other_thread_procs = []
+  @_user_error_handler = nil
+  @_exit_error = nil
+  @_on_exit_procs = []
 
-    yield  if block_given?
+  def self.stop
+    return false  unless check_status()
 
-    if _c_run
-      # _c_run does not terminate (it blocks) until all the handles end.
-      # If so, let's set again @_is_running to false and return true.
-      @_is_running = false
-      return true
+    if running_thread?
+      next_tick { release_loop() }
     else
-      raise AsyncEngine::Error, "AsyncEngine failed to run"
+      call_from_other_thread { release_loop() }
     end
+    true
   end
 
-  def self.running?
-    @_is_running
+  def self.on_error pr=nil, &bl
+    block = pr || bl
+    raise ::ArgumentError, "no block given"  unless block.is_a? ::Proc
+
+    @_user_error_handler = block
   end
 
-  def self.exception_manager block1=nil, &block2
-    if (block = block1 || block2)
-      raise AsyncEngine::Error, "no block provided"  unless block.respond_to? :call
-      @_exception_manager = block
-    else
-      @_exception_manager = nil
-    end
+  def self.unset_on_error
+    @_user_error_handler = nil
   end
 
-  def self.manage_exception e
-    if @_exception_manager
-      @_exception_manager.call e
-    else
-      raise e
-    end
+  def self.on_exit pr=nil, &bl
+    block = pr || bl
+    raise ::ArgumentError, "no block given"  unless block.is_a? ::Proc
+
+    @_on_exit_procs << block
   end
 
+  def self.unset_on_exit
+    @_on_exit_procs.clear
+  end
+
+
   class << self
-    private :_c_run
-    private :manage_exception
+    private :release_loop
+    private :check_status
   end
 
 end
 
 
 # Let's allow AE.xxxxx usage.
-AE = AsyncEngine
+AE = AsyncEngine

data/lib/asyncengine/debug.rb

@@ -0,0 +1,37 @@
+module AsyncEngine
+
+  def self.ensure_released
+    raise AE::Error, "still running"  if running?()
+    raise AE::Error, "num_uv_active_handles = #{num_uv_active_handles()} (> 0)"  unless num_uv_active_handles() == 0
+    raise AE::Error, "num_uv_active_reqs = #{num_uv_active_reqs()} (> 0)"  unless num_uv_active_reqs() == 0
+    raise AE::Error, "@_handles not empty"  unless @_handles.empty?
+    raise AE::Error, "@_procs not empty"  unless @_procs.empty?
+    raise AE::Error, "@_next_tick_procs not empty"  unless @_next_tick_procs.empty?
+    raise AE::Error, "@_call_from_other_thread_procs not empty"  unless @_call_from_other_thread_procs.empty?
+    @_call_from_other_thread_procs
+    true
+  end
+
+  def self.debug
+    puts "\nDBG: AsyncEngine debug:"
+    puts "- AE.running: #{running?}"
+    puts "- UV active handles: #{num_uv_active_handles()}"
+    puts "- UV active reqs: #{num_uv_active_reqs()}"
+    puts "- @_handles (#{@_handles.size}):\n"
+      @_handles.to_a[0..10].each {|k,v| puts "  - #{k}: #{v.inspect}"}
+    puts "- @_procs (#{@_procs.size}):\n"
+      @_procs.to_a[0..10].each {|k,v| puts "  - #{k}: #{v.inspect}"}
+    puts "- @_next_tick_procs (#{@_next_tick_procs.size}):\n"
+      @_next_tick_procs[0..10].each {|n| puts "  - #{n.inspect}"}
+    puts "- @_call_from_other_thread_procs (#{@_call_from_other_thread_procs.size}):\n"
+      @_call_from_other_thread_procs[0..10].each {|n| puts "  - #{n.inspect}"}
+    puts
+  end
+
+
+  class << self
+    private :num_uv_active_handles
+    private :num_uv_active_reqs
+  end
+
+end

data/lib/asyncengine/handle.rb

@@ -0,0 +1,9 @@
+module AsyncEngine
+
+  class Handle
+    def closed?
+      ! alive?
+    end
+  end
+
+end

data/lib/asyncengine/tcp.rb

@@ -0,0 +1,28 @@
+module AsyncEngine
+
+  # TODO: Wrong, take a look to timer.rb.
+  def self.tcp_connect dest_ip, dest_port, bind_ip=nil, bind_port=nil, klass=AsyncEngine::TCPSocket
+    klass.new dest_ip, dest_port, bind_ip, bind_port
+  end
+
+  class TCPSocket < Handle
+    private
+
+    def on_connected
+      puts "#{inspect}: connected: local address: #{local_address().inspect}, peer address: #{peer_address().inspect}"
+    end
+
+    def on_connection_error error
+      puts "#{inspect}: connection error: #{error.inspect}"
+    end
+
+    def on_data_received data
+      puts "#{inspect}: received data: #{data.inspect}"
+    end
+
+    def on_disconnected error
+      puts "#{inspect}: disconnected: #{error.inspect}"
+    end
+  end  # class TCPSocket
+
+end

data/lib/asyncengine/timer.rb

@@ -1,46 +1,36 @@
 module AsyncEngine
 
-  def self.add_timer delay, block1=nil, &block2
-    _c_add_timer((delay*1000).to_i, nil, block1 || block2, nil)
-    true
+  def self.add_timer *params, &bl
+    Timer.new *params, &bl
   end
 
-  def self.add_periodic_timer interval, delay=nil, block1=nil, &block2
-    if delay
-      _c_add_timer((delay*1000).to_i, (interval*1000).to_i, block1 || block2, nil)
-    else
-      interval = (interval*1000).to_i
-      _c_add_timer(interval, interval, block1 || block2, nil)
-    end
-    true
-  end
-
-  class << self
-    private :_c_add_timer
+  def self.add_periodic_timer *params, &bl
+    PeriodicTimer.new *params, &bl
   end
 
 
-  class Timer
-    def initialize delay, block1=nil, &block2
-      @_cdata = AsyncEngine.send(:_c_add_timer, (delay*1000).to_i, nil, block1 || block2, self)
+  class Timer < Handle
+    alias orig_to_s to_s
+    def to_s
+      if alive?
+        "#{orig_to_s} (delay: #{delay()})"
+      else
+        "#{orig_to_s} (not alive)"
+      end
     end
+    alias :inspect :to_s
   end
 
 
   class PeriodicTimer < Timer
-    def initialize interval, delay=nil, block1=nil, &block2
-      if delay
-        @_cdata = AsyncEngine.send(:_c_add_timer, (delay*1000).to_i, (interval*1000).to_i, block1 || block2, self)
+    def to_s
+      if alive?
+        "#{orig_to_s} (delay: #{delay()}, interval: #{interval()})"
       else
-        interval = (interval*1000).to_i
-        @_cdata = AsyncEngine.send(:_c_add_timer, interval, interval, block1 || block2, self)
+        "#{orig_to_s} (not alive)"
       end
     end
-
-    def set_interval interval
-      _c_set_interval (interval*1000).to_i
-    end
-    alias :interval= :set_interval
+    alias :inspect :to_s
   end
 
 end

data/lib/asyncengine/udp.rb

@@ -1,5 +1,34 @@
 module AsyncEngine
 
+  def self.open_udp_socket *params
+    sock = UDPSocket.new *params
 
+    # Run the given block.
+    yield sock  if block_given?
+
+    # Return the instance.
+    sock
+  end
+
+
+  class UDPSocket < Handle
+    alias orig_to_s to_s
+    def to_s
+      ip, port = local_address()
+      if alive?
+        "#{orig_to_s} (#{ip_type().inspect} : #{ip} : #{port})"
+      else
+        "#{orig_to_s} (not alive)"
+      end
+    end
+    alias :inspect :to_s
+
+
+    private
+
+    def on_datagram_received datagram, src_ip, src_port
+      puts "#{inspect}: received datagram from #{src_ip} : #{src_port}: #{datagram.inspect}"
+    end
+  end  # class UDPSocket
 
 end

data/lib/asyncengine/utils.rb

@@ -0,0 +1,32 @@
+module AsyncEngine::Utils
+
+  class NetworkInterface
+    attr_reader :name, :ip_type, :ip
+
+    def internal?
+      @is_internal
+    end
+
+    alias :orig_to_s :to_s
+    def to_s
+      "#{self.orig_to_s} (name: #{@name}, internal?: #{@is_internal.inspect}, ip: #{@ip})"
+    end
+    alias :inspect :to_s
+  end
+
+  class CpuInfo
+    attr_reader :model, :speed
+    attr_reader :time_sys, :time_user, :time_idle, :time_irq, :time_nice
+
+    alias :orig_to_s :to_s
+    def to_s
+      "#{self.orig_to_s} (model: #{@model}, speed: #{speed} MHz)"
+    end
+
+    def inspect
+      sprintf("%s sys: %.2f%%, user: %.2f%%, idle: %.2f%%, irq: %.2f%%, nice: %.2f%%",
+              to_s, @time_sys, @time_user, @time_idle, @time_irq, @time_nice)
+    end
+  end
+
+end

data/lib/asyncengine/uv_error.rb

@@ -0,0 +1,17 @@
+module AsyncEngine
+
+  class Error < StandardError ; end
+
+  class UvError < Error
+    attr_reader :errno, :type, :description
+
+    def initialize errno, type, description
+      @errno = errno
+      @type = type
+      @description = description
+
+      super "#{@type.inspect} (errno #{@errno}), #{@description}"
+    end
+  end
+
+end