rev 0.1.0 → 0.1.1

data/ext/http11_client/http11_parser.h

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
+typedef void (*element_cb)(void *data, const char *at, size_t length);
+typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
+
+typedef struct httpclient_parser { 
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+
+  void *data;
+
+  field_cb http_field;
+  element_cb reason_phrase;
+  element_cb status_code;
+  element_cb chunk_size;
+  element_cb http_version;
+  element_cb header_done;
+  element_cb last_chunk;
+  
+  
+} httpclient_parser;
+
+int httpclient_parser_init(httpclient_parser *parser);
+int httpclient_parser_finish(httpclient_parser *parser);
+size_t httpclient_parser_execute(httpclient_parser *parser, const char *data, size_t len, size_t off);
+int httpclient_parser_has_error(httpclient_parser *parser);
+int httpclient_parser_is_finished(httpclient_parser *parser);
+
+#define httpclient_parser_nread(parser) (parser)->nread 
+
+#endif

data/ext/rev/rev_watcher.c

@@ -28,6 +28,7 @@ static VALUE Rev_Watcher_enable(VALUE self);
 static VALUE Rev_Watcher_disable(VALUE self);
 static VALUE Rev_Watcher_evloop(VALUE self);
 static VALUE Rev_Watcher_attached(VALUE self);
+static VALUE Rev_Watcher_enabled(VALUE self);
 
 void Init_rev_watcher()
 {
@@ -42,6 +43,7 @@ void Init_rev_watcher()
   rb_define_method(cRev_Watcher, "disable", Rev_Watcher_disable, 0);
   rb_define_method(cRev_Watcher, "evloop", Rev_Watcher_evloop, 0);
   rb_define_method(cRev_Watcher, "attached?", Rev_Watcher_attached, 0);
+  rb_define_method(cRev_Watcher, "enabled?", Rev_Watcher_enabled, 0);
 }
 
 static VALUE Rev_Watcher_allocate(VALUE klass)
@@ -220,3 +222,17 @@ static VALUE Rev_Watcher_attached(VALUE self)
 {
   return Rev_Watcher_evloop(self) != Qnil;
 }
+
+/**
+ *  call-seq:
+ *    Rev::Watcher.enabled? -> Boolean
+ * 
+ * Is the watcher currently enabled?
+ */
+static VALUE Rev_Watcher_enabled(VALUE self)
+{
+	struct Rev_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Rev_Watcher, watcher_data);
+  
+	return watcher_data->enabled ? Qtrue : Qfalse;
+}

data/lib/rev/buffered_io.rb

@@ -8,6 +8,9 @@ require File.dirname(__FILE__) + '/../rev'
 
 module Rev
   class BufferedIO < IOWatcher
+    # Maximum number of bytes to consume at once
+    INPUT_SIZE = 16384
+
     def initialize(io)
       # Output buffer
       @write_buffer = ''
@@ -41,7 +44,7 @@ module Rev
     def write(data)
       # Attempt a zero copy write
       if @write_buffer.empty?
-        written = @io.write_nonblock data
+        written = write_nonblock data
 
         # If we lucked out and wrote out the whole buffer, return
         if written == data.size
@@ -49,12 +52,11 @@ module Rev
           return data.size
         end
 
-        # Otherwise append the remaining data to the buffer 
-        @write_buffer << data[written..data.size]
-      else
-        @write_buffer << data
+        # Otherwise slice what we wrote out and begin buffered writing
+        data.slice!(0, written) if written
       end
-
+      
+      @write_buffer << data
       schedule_write
       data.size
     end
@@ -64,37 +66,47 @@ module Rev
       @write_buffer.size
     end
 
+    # Close the BufferedIO stream
+    def close
+      detach if attached?
+      @writer.detach if @writer and @writer.attached?
+      @io.close unless @io.closed?
+
+      on_close
+    end
+
+    #########
+    protected
+    #########
+ 
     # Attempt to write the contents of the output buffer
     def write_output_buffer
       return if @write_buffer.empty?
 
-      written = @io.write_nonblock @write_buffer
-      @write_buffer.slice!(written, @write_buffer.size)
+      written = write_nonblock @write_buffer
+      @write_buffer.slice!(0, written) if written
 
       return unless @write_buffer.empty?
 
       @writer.disable if @writer and @writer.enabled?
       on_write_complete
     end
-    
-    # Close the BufferedIO stream
-    def close
-      detach if attached?
-      @writer.detach if @writer and @writer.attached?
-      @io.close
-
-      on_close
+ 
+    # Wrapper for handling reset connections and EAGAIN
+    def write_nonblock(data)
+      begin
+        @io.write_nonblock(data)
+      rescue Errno::ECONNRESET, Errno::EPIPE
+        close
+      rescue Errno::EAGAIN
+      end
     end
 
-    #########
-    protected
-    #########
-    
     # Inherited callback from IOWatcher
     def on_readable
       begin
-        on_read @io.read_nonblock(4096)
-      rescue EOFError
+        on_read @io.read_nonblock(INPUT_SIZE)
+      rescue Errno::ECONNRESET, EOFError
         close
       end
     end
@@ -103,8 +115,13 @@ module Rev
       return if @writer and @writer.enabled?
       if @writer 
         @writer.enable
-      else 
-        @writer = Writer.new(@io, self)
+      else
+        begin
+          @writer = Writer.new(@io, self)
+        rescue IOError
+          return
+        end
+
         @writer.attach(evloop)
       end
     end
@@ -116,7 +133,7 @@ module Rev
       end
 
       def on_writable
-        @buffered_io.write_output_buffer
+        @buffered_io.__send__(:write_output_buffer)
       end
     end
   end

data/lib/rev/dns_resolver.rb

@@ -37,17 +37,17 @@ module Rev
     end
 
     def initialize(hostname, *nameservers)
-      if nameservers.nil? or nameservers.empty?
+      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?
       end
 
       @nameservers = nameservers
-      @request = request_message hostname
       @question = request_question hostname
 
       @socket = UDPSocket.new
       @timer = Timeout.new(self)
+      
       super(@socket)
     end
 
@@ -65,7 +65,7 @@ module Rev
     # Send a request to the DNS server
     def send_request
       @socket.connect @nameservers.first, DNS_PORT
-      @socket.send @request, 0
+      @socket.send request_message, 0
     end
 
     # Called when the name has successfully resolved to an address
@@ -83,7 +83,7 @@ module Rev
     #########
     protected
     #########
-    
+
     # Called by the subclass when the DNS response is available
     def on_readable
       datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
@@ -92,23 +92,9 @@ module Rev
       detach
     end
 
-    def request_message(hostname)
-      # Standard query header
-      message = "\000\002\001\000"
-
-      # One entry
-      qdcount = 1
-
-      # No answer, authority, or additional records
-      ancount = nscount = arcount = 0 
-
-      message << [qdcount, ancount, nscount, arcount].pack('nnnn')
-      message << request_question(hostname)
-   end
-
     def request_question(hostname)
       # Query name
-      message = hostname.split('.').map { |s| [s.size].pack('C') << s }.join + "\000"
+      message = hostname.split('.').map { |s| [s.size].pack('C') << s }.join + "\0"
 
       # Host address query
       qtype = 1
@@ -119,6 +105,20 @@ module Rev
       message << [qtype, qclass].pack('nn')
     end
 
+    def request_message
+      # Standard query header
+      message = [2, 1, 0].pack('nCC')
+
+      # One entry
+      qdcount = 1
+
+      # No answer, authority, or additional records
+      ancount = nscount = arcount = 0 
+
+      message << [qdcount, ancount, nscount, arcount].pack('nnnn')
+      message << @question
+    end
+
     def response_address(message)
       # Confirm the ID field
       id = message[0..1].unpack('n').first.to_i
@@ -128,7 +128,7 @@ module Rev
       qr = message[2].unpack('B1').first.to_i
       return unless qr == 1
 
-      # Check the RCODE and ensure there wasn't an error
+      # Check the RCODE (lower nibble) and ensure there wasn't an error
       rcode = message[3].unpack('B8').first[4..7].to_i(2)
       return unless rcode == 0
 
@@ -137,22 +137,23 @@ module Rev
 
       # We only asked one question
       return unless qdcount == 1
-      message = message[12..message.size] # slice! would be nice but I think I hit a 1.9 bug...
+      message.slice!(0, 12)
 
       # Make sure it's the same question
       return unless message[0..(@question.size-1)] == @question
-      message = message[@question.size..message.size]
+      message.slice!(0, @question.size)
 
       # Extract the RDLENGTH
       while not message.empty?
         type = message[2..3].unpack('n').first.to_i
         rdlength = message[10..11].unpack('n').first.to_i
         rdata = message[12..(12 + rdlength - 1)]
-        message = message[(12+rdlength)..message.size]
+        message.slice!(0, 12 + rdlength)
 
         # Only IPv4 supported
         next unless rdlength == 4
 
+        # If we got an Internet address back, return it
         return rdata.unpack('CCCC').join('.') if type == 1
       end
 
@@ -169,10 +170,10 @@ module Rev
       def on_timer
         @attempts += 1
         return @resolver.send_request if @attempts <= RETRIES 
-        
-        @resolver.on_timeout
+
+        @resolver.__send__(:on_timeout)
         @resolver.detach
       end
     end
   end
-end
+end