rev 0.2.2 → 0.2.3

data/ext/rev/rev.h

@@ -10,10 +10,16 @@
 #include "ruby.h"
 #include "rubyio.h"
 
-#if HAVE_RB_IO_T
-#define FPTR_TO_FD(fptr) fptr->fd
+#ifdef GetReadFile
+#define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #else
+
+#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
 #define FPTR_TO_FD(fptr) fileno(fptr->f)
+#else
+#define FPTR_TO_FD(fptr) fptr->fd
+#endif
+
 #endif
 
 struct Rev_Event

data/ext/rev/rev_buffer.c

@@ -7,8 +7,7 @@
 #include "ruby.h"
 #include "rubyio.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.h"
+#include "ev_wrap.h"
 
 #include "rev.h"
 
@@ -627,4 +626,4 @@ static int buffer_read_from(struct buffer *buf, int fd)
 	} while(bytes_read == nbytes);
 	
 	return total_bytes_read;
-}
+}

data/ext/rev/rev_ext.c

@@ -4,10 +4,11 @@
  * See LICENSE for details
  */
 
-#include "ruby.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.c"
+#include "ruby.h" // allow for an error "OpenFile redeclared" to not exist, somehow.
+
+#include "ev_wrap.h"
+
 
 #include "rev.h"
 

data/ext/rev/rev_io_watcher.c

@@ -7,8 +7,7 @@
 #include "ruby.h"
 #include "rubyio.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.h"
+#include "ev_wrap.h"
 
 #include "rev.h"
 #include "rev_watcher.h"

data/ext/rev/rev_loop.c

@@ -8,8 +8,7 @@
 #include "ruby.h"
 #include "rubysig.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.h"
+#include "ev_wrap.h"
 
 #include "rev.h"
 
@@ -208,7 +207,7 @@ static VALUE Rev_Loop_ev_loop_oneshot_blocking(void *ptr)
 static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 {
   /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
-  rb_thread_blocking_region(Rev_Loop_ev_loop_oneshot_blocking, loop_data, RB_UBF_DFL, 0);
+  rb_thread_blocking_region(Rev_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
 }
 #endif
 
@@ -220,6 +219,7 @@ static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 /* Stub for scheduler's ev_timer callback */
 static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {
+   ev_timer_again (ev_loop, timer);
 }
 
 /* Run the event loop, calling rb_thread_schedule every 10ms */
@@ -284,4 +284,4 @@ static void Rev_Loop_dispatch_events(struct Rev_Loop *loop_data)
     Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Rev_Watcher, watcher_data);
     watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
   }
-}
+}

data/ext/rev/rev_timer_watcher.c

@@ -6,8 +6,7 @@
 
 #include "ruby.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.h"
+#include "ev_wrap.h"
 
 #include "rev.h"
 #include "rev_watcher.h"

data/ext/rev/rev_utils.c

@@ -6,7 +6,9 @@
 
 #include "ruby.h"
 
+#ifdef HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
+#endif
 
 #ifdef HAVE_SYS_SYSCTL_H
 #include <sys/param.h>
@@ -80,12 +82,18 @@ static VALUE Rev_Utils_ncpus(VALUE self)
  */
 static VALUE Rev_Utils_maxfds(VALUE self)
 {
+#ifdef HAVE_SYS_RESOURCE_H
   struct rlimit rlim;
 
   if(getrlimit(RLIMIT_NOFILE, &rlim) < 0)
     rb_sys_fail("getrlimit");
 
   return INT2NUM(rlim.rlim_cur);
+#endif
+
+#ifndef HAVE_SYS_RESOURCE_H
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
 }
 
 /**
@@ -97,6 +105,7 @@ static VALUE Rev_Utils_maxfds(VALUE self)
  */
 static VALUE Rev_Utils_setmaxfds(VALUE self, VALUE max)
 {
+#ifdef HAVE_SYS_RESOURCE_H
   struct rlimit rlim;
 
   rlim.rlim_cur = NUM2INT(max);
@@ -105,4 +114,9 @@ static VALUE Rev_Utils_setmaxfds(VALUE self, VALUE max)
     rb_sys_fail("setrlimit");
 
   return max;
+#endif
+
+#ifndef HAVE_SYS_RESOURCE_H
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
 }

data/ext/rev/rev_watcher.c

@@ -6,8 +6,7 @@
 
 #include "ruby.h"
 
-#define EV_STANDALONE 1
-#include "../libev/ev.h"
+#include "ev_wrap.h"
 
 #include "rev.h"
 
@@ -99,7 +98,8 @@ static VALUE Rev_Watcher_attach(VALUE self, VALUE loop)
   loop_watchers = rb_iv_get(loop, "@watchers");
 
   if(loop_watchers == Qnil) {
-    loop_watchers = rb_ary_new();
+    /* we should never get here */
+    loop_watchers = rb_hash_new();
     rb_iv_set(loop, "@watchers", loop_watchers);
   }
 
@@ -108,7 +108,7 @@ static VALUE Rev_Watcher_attach(VALUE self, VALUE loop)
    * with a loop (and also lets you see within Ruby which watchers are
    * associated with a given loop), but isn't really necessary for any 
    * other reason */
-  rb_ary_push(loop_watchers, self);
+  rb_hash_aset(loop_watchers, self, Qtrue);
 
   active_watchers = rb_iv_get(loop, "@active_watchers");
   if(active_watchers == Qnil)
@@ -142,8 +142,9 @@ static VALUE Rev_Watcher_detach(VALUE self)
 
   /* Remove us from the loop's array of active watchers.  This likely
    * has negative performance and scalability characteristics as this
-   * isn't an O(1) operation.  Hopefully there's a better way... */
-  rb_ary_delete(loop_watchers, self);
+   * isn't an O(1) operation.  Hopefully there's a better way...
+   * Trying a hash for now... */
+  rb_hash_delete(loop_watchers, self);
 
   if(watcher_data->enabled) {
     rb_iv_set(

data/lib/rev.rb

@@ -24,6 +24,6 @@ require File.dirname(__FILE__) + '/rev/server'
 require File.dirname(__FILE__) + '/rev/http_client'
 
 module Rev
-  Rev::VERSION = '0.2.2' unless defined? Rev::VERSION
+  Rev::VERSION = '0.2.3' unless defined? Rev::VERSION
   def self.version() VERSION end
 end

data/lib/rev/dns_resolver.rb

@@ -11,7 +11,6 @@
 #
 # If you do know what you're doing with DNS, feel free to improve this! 
 #++
-
 module Rev
   # A non-blocking DNS resolver.  It provides interfaces for querying both
   # /etc/hosts and nameserves listed in /etc/resolv.conf, or nameservers of
@@ -25,12 +24,16 @@ module Rev
   # automatically detach themselves from the event loop and cannot be used
   # again.
   class DNSResolver < IOWatcher
+   #--
+   # TODO check if it's caching right
     RESOLV_CONF = '/etc/resolv.conf'
     HOSTS = '/etc/hosts'
     DNS_PORT = 53
     DATAGRAM_SIZE = 512
     TIMEOUT = 3 # Retry timeout for each datagram sent
     RETRIES = 4 # Number of retries to attempt
+    # so currently total is 12s before it will err due to timeouts
+    # if it errs due to inability to reach the DNS server [Errno::EHOSTUNREACH], same
 
     # Query /etc/hosts (or the specified hostfile) for the given host
     def self.hosts(host, hostfile = HOSTS)
@@ -50,8 +53,8 @@ module Rev
     # use nameservers listed in /etc/resolv.conf
     def initialize(hostname, *nameservers)
       if nameservers.empty?
-        nameservers = File.read(RESOLV_CONF).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten
-        raise RuntimeError, "no nameservers found in #{RESOLV_CONF}" if nameservers.empty?
+        nameservers = File.read(RESOLV_CONF).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten # TODO could optimize this to just read once
+        raise RuntimeError, "no nameservers found in #{RESOLV_CONF}" if nameservers.empty? # TODO just call resolve_failed, not raise [also handle Errno::ENOENT)]
       end
 
       @nameservers = nameservers
@@ -84,8 +87,10 @@ module Rev
     def on_failure; end
     event_callback :on_failure
 
-    # Called if we don't receive a response, defaults to on_failure
-    alias_method :on_timeout, :on_failure
+    # Called if we don't receive a response, defaults to calling on_failure
+    def on_timeout
+	on_failure
+    end
 
     #########
     protected
@@ -93,13 +98,23 @@ module Rev
 
     # Send a request to the DNS server
     def send_request
+      nameserver = @nameservers.shift
+      @nameservers << nameserver # rotate them
       @socket.connect @nameservers.first, DNS_PORT
-      @socket.send request_message, 0
+      begin
+         @socket.send request_message, 0
+      rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
+
+      end   
     end
 
     # Called by the subclass when the DNS response is available
     def on_readable
-      datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+      datagram = nil
+      begin
+	datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+      rescue Errno::ECONNREFUSED
+      end
       address = response_address datagram rescue nil
       address ? on_success(address) : on_failure
       detach
@@ -184,8 +199,13 @@ module Rev
 
       def on_timer
         @attempts += 1
-        return @resolver.__send__(:send_request) if @attempts <= RETRIES 
-
+        if @attempts <= RETRIES
+          begin
+            return @resolver.__send__(:send_request)
+          rescue Errno::EHOSTUNREACH # if the DNS is toast try again after the timeout occurs again
+            return nil
+          end 
+        end
         @resolver.__send__(:on_timeout)
         @resolver.detach
       end

data/lib/rev/io.rb

@@ -21,7 +21,7 @@ module Rev
 
     def initialize(io)
       @_io = io
-      @_write_buffer  = Rev::Buffer.new
+      @_write_buffer  ||= Rev::Buffer.new
       @_read_watcher  = Watcher.new(io, self, :r)
       @_write_watcher = Watcher.new(io, self, :w)
     end
@@ -31,10 +31,10 @@ module Rev
     #
     
     # Attach to the event loop
-    def attach(loop); @_read_watcher.attach loop; self; end
+    def attach(loop); @_read_watcher.attach loop; schedule_write if !@_write_buffer.empty?; self; end
     
     # Detach from the event loop
-    def detach; @_read_watcher.detach; self; end
+    def detach; @_read_watcher.detach; self; end # TODO should these detect write buffers, as well?
     
     # Enable the watcher
     def enable; @_read_watcher.enable; self; end
@@ -128,6 +128,8 @@ module Rev
 
     # Schedule a write to be performed when the IO object becomes writable 
     def schedule_write
+      return unless @_io # this would mean 'we are still pre DNS here'
+      return unless attached? # this would mean 'currently unattached' -- ie still pre DNS, or just plain not attached, which is ok
       begin
         enable_write_watcher      
       rescue IOError
@@ -162,4 +164,4 @@ module Rev
       def on_writable; @rev_io.__send__(:on_writable); end
     end
   end
-end
+end

data/lib/rev/listener.rb

@@ -32,7 +32,11 @@ module Rev
 
     # Rev callback for handling new connections
     def on_readable
-      on_connection @listen_socket.accept_nonblock
+      begin
+        on_connection @listen_socket.accept_nonblock
+      rescue Errno::EAGAIN
+        STDERR.puts "warning: listener socket spuriously readable"
+      end
     end
   end
 

data/lib/rev/loop.rb

@@ -15,10 +15,8 @@ end
 
 module Rev
   class Loop
-    attr_reader :watchers
-    
     # In Ruby 1.9 we want a Rev::Loop per thread, but Ruby 1.8 is unithreaded
-    if RUBY_VERSION.gsub('.', '').to_i >= 190
+    if RUBY_VERSION >= "1.9.0"
       # Retrieve the default event loop for the current thread
       def self.default
         Thread.current._rev_loop
@@ -49,7 +47,7 @@ module Rev
     #     :port   (Solaris 10)
     #
     def initialize(options = {})
-      @watchers = []
+      @watchers = {}
       @active_watchers = 0
       
       flags = 0
@@ -97,6 +95,7 @@ module Rev
       while @running and not @active_watchers.zero?
         run_once
       end
+      @running = false
     end
 
     # Stop the event loop if it's running
@@ -110,6 +109,11 @@ module Rev
       @active_watchers > 0
     end
     
+    # All watchers attached to the current loop
+    def watchers
+      @watchers.keys
+    end
+    
     #######
     private
     #######

data/lib/rev/server.rb

@@ -39,7 +39,8 @@ module Rev
   end
 
   # TCP server class.  Listens on the specified host and port and creates
-  # new connection objects of the given class.
+  # new connection objects of the given class. This is the most common server class.
+  # Note that the new connection objects will be bound by default to the same event loop that the server is attached to.
   class TCPServer < Server
     def initialize(host, port, klass = TCPSocket, *args, &block)
       listen_socket = ::TCPServer.new(host, port)
@@ -55,4 +56,4 @@ module Rev
       super(::UNIXServer.new(*args), klass, *args, &block)
     end
   end
-end
+end

data/lib/rev/socket.rb

@@ -10,6 +10,7 @@ require 'resolv'
 module Rev
   class Socket < IO    
     def self.connect(socket, *args)
+
       new(socket, *args).instance_eval do
         @_connector = Connector.new(self, socket)
         self
@@ -38,8 +39,10 @@ module Rev
     event_callback :on_connect_failed
     
     # Called if a hostname failed to resolve when connecting
-    # Defaults to being aliased to on_connect_failed
-    alias_method :on_resolve_failed, :on_connect_failed
+    # Defaults to  calling on_connect_failed
+    def on_resolve_failed
+       on_connect_failed
+    end
     
     #########
     protected
@@ -58,6 +61,9 @@ module Rev
         if connect_successful?
           @rev_socket.instance_eval { @_connector = nil }
           @rev_socket.attach(evl)
+          @ruby_socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, [1].pack("l"))
+          @ruby_socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+
           @rev_socket.__send__(:on_connect)
         else
           @rev_socket.instance_eval { @_failed = true }
@@ -93,6 +99,8 @@ module Rev
     end
     
     # Perform a non-blocking connect to the given host and port
+    # see examples/echo_client.rb
+    # addr is a string, can be an IP address or a hostname.
     def self.connect(addr, port, *args)
       family = nil
 
@@ -103,11 +111,11 @@ module Rev
       end
  
       if family
-        return super(TCPConnectSocket.new(family, addr, port), *args)
+        return super(TCPConnectSocket.new(family, addr, port), *args) # this creates a 'real' write buffer so we're ok there with regards to already having a write buffer from the get go
       end
 
       if host = Rev::DNSResolver.hosts(addr)
-        return connect(host, port, *args)
+        return connect(host, port, *args) # calls this same function
       end
 
       precreate(addr, port, *args)
@@ -115,6 +123,7 @@ module Rev
     
     # Called by precreate during asyncronous DNS resolution
     def preinitialize(addr, port, *args)
+      @_write_buffer = Rev::Buffer.new # allow for writing BEFORE the DNS has resolved
       @remote_host, @remote_addr, @remote_port = addr, addr, port
       @_resolver = TCPConnectResolver.new(self, addr, port, *args)
     end
@@ -141,7 +150,7 @@ module Rev
 
     class TCPConnectSocket < ::Socket
       def initialize(family, addr, port, host = addr)
-        @host, @addr, @port = host, addr, port
+        @host,  addr, @port = host, addr, port
         @address_family = nil
 
         @socket = super(family, ::Socket::SOCK_STREAM, 0)