rev 0.1.1 → 0.1.2

data/lib/rev/http_client.rb

@@ -146,7 +146,7 @@ module Rev
       @parser_nbytes = 0
 
       @state = :response_header
-      @data = ''
+      @data = Rev::Buffer.new
 
       @response_header = HttpResponseHeader.new
       @chunk_header = HttpChunkHeader.new
@@ -224,9 +224,8 @@ module Rev
     end
 
     def on_read(data)
-      until @state == :finished or @state == :invalid or data.empty?
-        @state, data = dispatch_data(@state, data)
-      end
+      @data << data
+      dispatch
     end
 
     #
@@ -273,147 +272,145 @@ module Rev
     # Response processing
     #
 
-    def dispatch_data(state, data)
-      case state
-      when :response_header
-        parse_response_header(data)
-      when :chunk_header
-        parse_chunk_header(data)
-      when :chunk_body
-        process_chunk_body(data)
-      when :chunk_footer
-        process_chunk_footer(data)
-      when :response_footer
-        process_response_footer(data)
-      when :body
-        process_body(data)
-      else raise RuntimeError, "invalid state: #{@state}"
+    def dispatch
+      while case @state
+        when :response_header
+          parse_response_header
+        when :chunk_header
+          parse_chunk_header
+        when :chunk_body
+          process_chunk_body
+        when :chunk_footer
+          process_chunk_footer
+        when :response_footer
+          process_response_footer
+        when :body
+          process_body
+        when :finished, :invalid
+          break
+        else raise RuntimeError, "invalid state: #{@state}"
+        end
       end
     end
 
-    def parse_header(header, data)
-      @data << data
-      @parser_nbytes = @parser.execute(header, @data, @parser_nbytes)
-      return unless @parser.finished?
+    def parse_header(header)
+      return false if @data.empty?
+      
+      @parser_nbytes = @parser.execute(header, @data.to_str, @parser_nbytes)
+      return false unless @parser.finished?
 
-      remainder = @data.slice(@parser_nbytes, @data.size)
-      @data = ''
+      # Clear parsed data from the buffer
+      @data.read(@parser_nbytes)
       @parser.reset
       @parser_nbytes = 0
-
-      remainder
+      
+      true
     end
 
-    def parse_response_header(data)
-      data = parse_header(@response_header, data)
-      return :response_header, '' if data.nil?
+    def parse_response_header
+      return false unless parse_header(@response_header)
 
       unless @response_header.http_status and @response_header.http_reason
         on_error "no HTTP response"
-        return :invalid
+        @state = :invalid
+        return false
       end
 
       on_response_header(@response_header)
 
       if @response_header.chunked_encoding?
-        return :chunk_header, data
+        @state = :chunk_header
       else
+        @state = :body
         @bytes_remaining = @response_header.content_length
-        return :body, data
       end
+      
+      true
     end
 
-    def parse_chunk_header(data)
-      data = parse_header(@chunk_header, data)
-      return :chunk_header, '' if data.nil?
+    def parse_chunk_header
+      return false unless parse_header(@chunk_header)
 
       @bytes_remaining = @chunk_header.chunk_size
       @chunk_header = HttpChunkHeader.new
 
-      if @bytes_remaining > 0
-        return :chunk_body, data
-      else
-        @bytes_remaining = 2
-        return :response_footer, data
-      end
+      @state = @bytes_remaining > 0 ? :chunk_body : :response_footer      
+      true
     end
 
-    def process_chunk_body(data)
-      if data.size < @bytes_remaining
-        @bytes_remaining -= data.size
-        on_body_data data
-        return :chunk_body, ''
+    def process_chunk_body
+      if @data.size < @bytes_remaining
+        @bytes_remaining -= @data.size
+        on_body_data @data.read
+        return false
       end
 
-      on_body_data data.slice!(0, @bytes_remaining)
-      @bytes_remaining = 2
-      return :chunk_footer, data
+      on_body_data @data.read(@bytes_remaining)
+      @bytes_remaining = 0
+      
+      @state = :chunk_footer      
+      true
     end
 
-    def process_crlf(data)
-      @data << data.slice!(0, @bytes_remaining)
-      @bytes_remaining = 2 - @data.size
-      return unless @bytes_remaining == 0
+    def process_chunk_footer
+      return false if @data.size < 2
 
-      matches_crlf = (@data == CRLF)
-      @data = ''
-
-      return matches_crlf, data
-    end
-
-    def process_chunk_footer(data)
-      result, data = process_crlf(data)
-      return :chunk_footer, '' if result.nil?
-
-      if result
-        return :chunk_header, data
+      if @data.read(2) == CRLF
+        @state = :chunk_header
       else
         on_error "non-CRLF chunk footer"
-        return :invalid
+        @state = :invalid
       end
-    end
-
-    def process_response_footer(data)
-      result, data = process_crlf(data)
-      return :response_footer, '' if result.nil?
-      if result
-        unless data.empty?
+      
+      true
+    end
+
+    def process_response_footer
+      return false if @data.size < 2
+      
+      if @data.read(2) == CRLF
+        if @data.empty?
+          on_request_complete
+          @state = :finished
+        else
           on_error "garbage at end of chunked response"
-          return :invalid
+          @state = :invalid
         end
-
-        on_request_complete
-        return :finished
       else
         on_error "non-CRLF response footer"
-        return :invalid
+        @state = :invalid
       end
+      
+      false
     end
 
-    def process_body(data)
+    def process_body
       # FIXME the proper thing to do here is probably to keep reading until
       # the socket closes, then assume that's the end of the body, provided
       # the server has specified Connection: close
       if @bytes_remaining.nil?
         on_error "no content length specified"
-        return :invalid
+        @state = :invalid
       end
 
-      if data.size < @bytes_remaining
-        @bytes_remaining -= data.size
-        on_body_data data
-        return :body, ''
+      if @data.size < @bytes_remaining
+        @bytes_remaining -= @data.size
+        on_body_data @data.read
+        return false
       end
 
-      on_body_data data.slice!(0, @bytes_remaining)
+      on_body_data @data.read(@bytes_remaining)
+      @bytes_remaining = 0
 
-      unless data.empty?
+      if @data.empty?
+        on_request_complete
+        @state = :finished
+      else
         on_error "garbage at end of body"
-        return :invalid
+        @state = :invalid
       end
 
-      on_request_complete
-      return :finished
+      false
     end
   end
-end
+end

data/lib/rev/listener.rb

@@ -8,11 +8,20 @@ require 'socket'
 require File.dirname(__FILE__) + '/../rev'
 
 module Rev
+  # Listeners wait for incoming connections.  When a listener receives a
+  # connection it fires the on_connection event with the newly accepted
+  # socket as a parameter.
   class Listener < IOWatcher
     def initialize(listen_socket)
       @listen_socket = listen_socket
       super(@listen_socket)
     end
+    
+    # Close the listener
+    def close
+      detach if attached?
+      @listen_socket.close
+    end
 
     # Called whenever the server receives a new connection
     def on_connection(socket); end
@@ -29,12 +38,20 @@ module Rev
   end
 
   class TCPListener < Listener
-    # Create a new Rev::TCPListener
+    DEFAULT_BACKLOG = 1024
+    
+    # Create a new Rev::TCPListener on the specified address and port.
+    # Accepts the following options:
     #
-    # Accepts the same arguments as TCPServer.new
-    def initialize(*args)
-      listen_socket = ::TCPServer.new(*args)
-      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+    #  :backlog - Max size of the pending connection queue (default 1024)
+    #  :reverse_lookup - Retain BasicSocket's reverse DNS functionality (default false)
+    #
+    def initialize(addr, port, options = {})
+      BasicSocket.do_not_reverse_lookup = true unless options[:reverse_lookup]
+      options[:backlog] ||= DEFAULT_BACKLOG
+      
+      listen_socket = ::TCPServer.new(addr, port)
+      listen_socket.instance_eval { listen(options[:backlog]) }
       super(listen_socket)
     end
   end

data/lib/rev/loop.rb

@@ -8,7 +8,20 @@ require File.dirname(__FILE__) + '/../rev'
 
 module Rev
   class Loop
+    @@default_loop = {}
     attr_reader :watchers
+    
+    # Retrieve the default event loop for the current thread
+    def self.default
+      # Well awesome, variables stashed in Thread.current[]
+      # are only accessible in the context of the Fiber where
+      # they were stored.  Soo... we need to make our own
+      # thread-local store if we want Fiber compatibility
+      #
+      # I think this should be sufficient... but it may need
+      # a mutex or something, got me.
+      @@default_loop[Thread.current] ||= Loop.new
+    end
 
     # Create a new Rev::Loop
     #

data/lib/rev/server.rb

@@ -8,10 +8,13 @@ require File.dirname(__FILE__) + '/../rev'
 
 module Rev
   class Server < Listener
+    # Servers listen for incoming connections and create new connection objects
+    # whenever incoming connections are received.  The default class for new
+    # connections is a Socket, but any subclass of IOWatcher is acceptable.
     def initialize(listen_socket, klass = Socket, *args, &block)
       # Ensure the provided class responds to attach
-      unless (klass.instance_method(:attach) rescue nil)
-        raise ArgumentError, "provided class must respond to 'attach'"
+      unless klass.allocate.is_a? IOWatcher
+        raise ArgumentError, "provided class must descend from IOWatcher"
       end
 
       # Verify the arity of the provided arguments
@@ -37,6 +40,8 @@ module Rev
     end
   end
 
+  # TCP server class.  Listens on the specified host and port and creates
+  # new connection objects of the given class.
   class TCPServer < Server
     def initialize(host, port, klass = TCPSocket, *args, &block)
       listen_socket = ::TCPServer.new(host, port)
@@ -45,9 +50,11 @@ module Rev
     end
   end
 
+  # UNIX server class.  Listens on the specified UNIX domain socket and
+  # creates new connection objects of the given class.
   class UNIXServer < Server
     def initialize(path, klass = UNIXSocket, *args, &block)
       super(::UNIXServer.new(*args), klass, *args, &block)
     end
   end
-end
+end

data/lib/rev/socket.rb

@@ -9,7 +9,7 @@ require 'resolv'
 require File.dirname(__FILE__) + '/../rev'
 
 module Rev
-  class Socket < BufferedIO
+  class Socket < BufferedIO    
     def self.connect(socket, *args)
       new(socket, *args).instance_eval {
         @connector = Connector.new(self, socket)
@@ -38,6 +38,10 @@ module Rev
     def on_connect_failed; end
     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
+    
     #########
     protected
     #########
@@ -76,6 +80,17 @@ module Rev
     attr_reader :remote_host, :remote_addr, :remote_port, :address_family
     watcher_delegate :@resolver
     
+    # Similar to .new, but used in cases where the resulting object is in a
+    # "half-open" state.  This is primarily used for when asynchronous
+    # DNS resolution is taking place.  We don't actually have a handle to
+    # the socket we want to use to create the watcher yet, since we don't
+    # know the IP address to connect to.
+    def self.precreate(*args, &block)
+      obj = allocate
+      obj.__send__(:preinitialize, *args, &block)
+      obj
+    end
+    
     # Perform a non-blocking connect to the given host and port
     def self.connect(addr, port, *args)
       family = nil
@@ -94,13 +109,17 @@ module Rev
         return connect(host, port, *args)
       end
 
-      return allocate.instance_eval {
-        @remote_host, @remote_addr, @remote_port = addr, addr, port
-        @resolver = TCPConnectResolver.new(self, addr, port, *args)
-        self
-      }
+      precreate(addr, port, *args)
     end
     
+    # Called by precreate during asyncronous DNS resolution
+    def preinitialize(addr, port, *args)
+      @remote_host, @remote_addr, @remote_port = addr, addr, port
+      @resolver = TCPConnectResolver.new(self, addr, port, *args)
+    end
+    
+    private :preinitialize
+    
     def initialize(socket)
       unless socket.is_a?(::TCPSocket) or socket.is_a?(TCPConnectSocket)
         raise TypeError, "socket must be a TCPSocket"
@@ -111,6 +130,10 @@ module Rev
       @address_family, @remote_port, @remote_host, @remote_addr = socket.peeraddr  
     end
     
+    def peeraddr
+      [@address_family, @remote_port, @remote_host, @remote_addr]
+    end
+    
     #########
     protected
     #########
@@ -157,15 +180,13 @@ module Rev
       end
 
       def on_failure
-        @sock.on_connect_failed
+        @sock.__send__(:on_resolve_failed)
         @sock.instance_eval { 
           @resolver = nil 
           @failed = true
         }
         return
       end
-
-      alias_method :on_timeout, :on_failure
     end
   end
   

data/lib/rev/watcher.rb

@@ -39,8 +39,10 @@ module Rev
               @#{method}_callback = block
               return
             end
-
-            @#{method}_callback.(*([self] + args)) if @#{method}_callback
+            
+            if @#{method}_callback
+              instance_exec(*args, &@#{method}_callback) 
+            end
           end
         EOD
       end