rev 0.1.4 → 0.2.0

data/lib/rev/dns_resolver.rb

@@ -2,11 +2,7 @@
 # Copyright (C)2007 Tony Arcieri
 # You can redistribute this under the terms of the Ruby license
 # See file LICENSE for details
-#++
-
-require File.dirname(__FILE__) + '/../rev'
-
-#--
+#
 # Gimpy hacka asynchronous DNS resolver
 #
 # Word to the wise: I don't know what I'm doing here.  This was cobbled together as
@@ -110,6 +106,8 @@ module Rev
     end
 
     def request_question(hostname)
+      raise ArgumentError, "hostname cannot be nil" if hostname.nil?
+      
       # Query name
       message = hostname.split('.').map { |s| [s.size].pack('C') << s }.join + "\0"
 
@@ -142,15 +140,15 @@ module Rev
       return unless id == 2
 
       # Check the QR value and confirm this message is a response
-      qr = message[2].unpack('B1').first.to_i
+      qr = message[2..2].unpack('B1').first.to_i
       return unless qr == 1
 
       # Check the RCODE (lower nibble) and ensure there wasn't an error
-      rcode = message[3].unpack('B8').first[4..7].to_i(2)
+      rcode = message[3..3].unpack('B8').first[4..7].to_i(2)
       return unless rcode == 0
 
       # Extract the question and answer counts
-      qdcount, ancount = message[4..7].unpack('nn').map(&:to_i)
+      qdcount, ancount = message[4..7].unpack('nn').map { |n| n.to_i }
 
       # We only asked one question
       return unless qdcount == 1

data/lib/rev/http_client.rb

@@ -5,7 +5,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../rev'
 require File.dirname(__FILE__) + '/../http11_client'
 
 module Rev
@@ -79,13 +78,13 @@ module Rev
       remote_host + (remote_port.to_i != 80 ? ":#{remote_port}" : "")
     end
 
-    def encode_request(method, uri, query)
-      HTTP_REQUEST_HEADER % [method.to_s.upcase, encode_query(uri, query)]
+    def encode_request(method, path, query)
+      HTTP_REQUEST_HEADER % [method.to_s.upcase, encode_query(path, query)]
     end
 
-    def encode_query(uri, query)
-      return uri unless query
-      uri + "?" + query.map { |k, v| encode_param(k, v) }.join('&')
+    def encode_query(path, query)
+      return path unless query
+      path + "?" + query.map { |k, v| encode_param(k, v) }.join('&')
     end
 
     # URL encodes a single k=v parameter.
@@ -167,27 +166,21 @@ module Rev
     #   body: String
     #     Specify the request body (you must encode it for now)
     #
-    def request(method, uri, options = {})
+    def request(method, path, options = {})
+      raise ArgumentError, "invalid request path" unless path[0] == '/'
       raise RuntimeError, "request already sent" if @requested
 
-      @method, @uri, @options = method, uri, options
+      @method, @path, @options = method, path, options
       @requested = true
 
       return unless @connected
       send_request
     end
-
-    # Requests can be made through method missing by invoking the HTTP method to use, i.e.:
-    #
-    #   httpclient.get(path, options)
-    #
-    # Valid for: get, post, put, delete, head
-    #
-    # To use other HTTP methods, invoke the request method directly
-    #
-    def method_missing(method, *args)
-      raise NoMethodError, "method not supported" unless ALLOWED_METHODS.include? method.to_sym
-      request method, *args
+    
+    # Enable the HttpClient if it has been disabled
+    def enable
+      super
+      dispatch unless @data.empty?
     end
 
     # Called when response header has been received
@@ -205,8 +198,9 @@ module Rev
       close
     end
 
-    # Called when an error occurs during the request
+    # Called when an error occurs dispatching the request
     def on_error(reason)
+      close
       raise RuntimeError, reason
     end
 
@@ -217,10 +211,10 @@ module Rev
     #
     # Rev callbacks
     #
-    
+        
     def on_connect
       @connected = true
-      send_request if @method and @uri
+      send_request if @method and @path
     end
 
     def on_read(data)
@@ -256,7 +250,7 @@ module Rev
       head['connection'] ||= 'close'
 
       # Build the request
-      request_header = encode_request(@method, @uri, query)
+      request_header = encode_request(@method, @path, query)
       request_header << encode_headers(head)
       request_header << encode_cookies(cookies) if cookies
       request_header << CRLF
@@ -273,7 +267,7 @@ module Rev
     #
 
     def dispatch
-      while case @state
+      while enabled? and case @state
         when :response_header
           parse_response_header
         when :chunk_header
@@ -296,7 +290,13 @@ module Rev
     def parse_header(header)
       return false if @data.empty?
       
-      @parser_nbytes = @parser.execute(header, @data.to_str, @parser_nbytes)
+      begin
+        @parser_nbytes = @parser.execute(header, @data.to_str, @parser_nbytes)
+      rescue Rev::HttpClientParserError
+        on_error "invalid HTTP format, parsing fails"
+        @state = :invalid
+      end
+      
       return false unless @parser.finished?
 
       # Clear parsed data from the buffer
@@ -385,12 +385,15 @@ module Rev
     end
 
     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"
-        @state = :invalid
+        on_body_data @data.read
+        return false
+      end
+      
+      if @bytes_remaining.zero?
+        on_request_complete
+        @state = :finished
+        return false
       end
 
       if @data.size < @bytes_remaining
@@ -413,4 +416,4 @@ module Rev
       false
     end
   end
-end
+end

data/lib/rev/io.rb

@@ -4,12 +4,10 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../rev'
-
 module Rev
   # A buffered I/O class witch fits into the Rev Watcher framework.
   # It provides both an observer which reads data as it's received
-  # from the wire and a buffered writer which stores data and writes
+  # from the wire and a buffered write watcher which stores data and writes
   # it out each time the socket becomes writable.
   #
   # This class is primarily meant as a base class for other streams
@@ -20,11 +18,8 @@ module Rev
     INPUT_SIZE = 16384
 
     def initialize(io)
-      # Output buffer
+      @io = io
       @write_buffer = Rev::Buffer.new
-
-      # Coerce the argument into an IO object if possible
-      @io = ::IO.try_convert(io)
       super(@io)
     end
 
@@ -50,7 +45,9 @@ module Rev
 
     # Write data in a buffered, non-blocking manner
     def write(data)
-      buffered_write data
+      @write_buffer << data
+      schedule_write
+      data.size
     end
 
     # Number of bytes are currently in the output buffer
@@ -61,7 +58,7 @@ module Rev
     # Close the IO stream
     def close
       detach if attached?
-      @writer.detach if @writer and @writer.attached?
+      detach_write_watcher
       @io.close unless @io.closed?
 
       on_close
@@ -76,62 +73,69 @@ module Rev
     #########
     protected
     #########
- 
-    # Buffered writer
-    def buffered_write(data) 
-      @write_buffer << data
-      schedule_write
-      data.size
-    end
 
-    # Attempt to write the contents of the output buffer
-    def write_output_buffer
+    # Read from the input buffer and dispatch to on_read
+    def on_readable
+      begin
+        on_read @io.read_nonblock(INPUT_SIZE)
+      rescue Errno::ECONNRESET, EOFError
+        close
+      end
+    end
+    
+    # Write the contents of the output buffer
+    def on_writable
       begin
         @write_buffer.write_to(@io)
-      rescue Errno::EPIPE
+      rescue Errno::EPIPE, Errno::ECONNRESET
         return close
       end
       
       if @write_buffer.empty?
-        @writer.disable if @writer and @writer.enabled?
+        disable_write_watcher
         on_write_complete
       end
     end
 
-    # Inherited callback from IOWatcher
-    def on_readable
+    # Schedule a write to be performed when the IO object becomes writable 
+    def schedule_write
       begin
-        on_read @io.read_nonblock(INPUT_SIZE)
-      rescue Errno::ECONNRESET, EOFError
-        close
+        enable_write_watcher      
+      rescue IOError
       end
     end
     
-    # Schedule a write to be performed when the IO object becomes writable 
-    def schedule_write
-      return if @writer and @writer.enabled?
-      if @writer 
-        @writer.enable
+    # Return a handle to the writing IOWatcher
+    def write_watcher
+      @write_watcher ||= WriteWatcher.new(@io, self)
+    end
+    
+    def enable_write_watcher
+      if write_watcher.attached?
+        write_watcher.enable unless write_watcher.enabled?
       else
-        begin
-          @writer = Writer.new(@io, self)
-        rescue IOError
-          return
-        end
-
-        @writer.attach(evloop)
+        write_watcher.attach(evloop)
       end
     end
+    
+    def disable_write_watcher
+      @write_watcher.disable if @write_watcher and @write_watcher.enabled?
+    end
+    
+    def detach_write_watcher
+      @write_watcher.detach if @write_watcher and @write_watcher.attached?
+    end
 
-    class Writer < IOWatcher
-      def initialize(io, buffered_io)
-        @buffered_io = buffered_io
-        super(io, :w)
+    class WriteWatcher < IOWatcher
+      def initialize(ruby_io, rev_io)
+        @rev_io = rev_io
+        super(ruby_io, :w)
       end
 
+      # Delegate on_writable to the Rev::IO object
       def on_writable
-        @buffered_io.__send__(:write_output_buffer)
+        @rev_io.__send__(:on_writable)
       end
     end
   end
-end
+end

data/lib/rev/io_watcher.rb

@@ -4,8 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../rev'
-
 module Rev
   class IOWatcher
     # The actual implementation of this class resides in the C extension

data/lib/rev/listener.rb

@@ -5,7 +5,6 @@
 #++
 
 require 'socket'
-require File.dirname(__FILE__) + '/../rev'
 
 module Rev
   # Listeners wait for incoming connections.  When a listener receives a

data/lib/rev/loop.rb

@@ -4,7 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../rev'
 require 'thread'
 
 # Monkeypatch Thread to include a method for obtaining the default Rev::Loop
@@ -18,9 +17,17 @@ module Rev
   class Loop
     attr_reader :watchers
     
-    # Retrieve the default event loop for the current thread
-    def self.default
-      Thread.current._rev_loop
+    # In Ruby 1.9 we want a Rev::Loop per thread, but Ruby 1.8 is unithreaded
+    if RUBY_VERSION.gsub('.', '').to_i >= 190
+      # Retrieve the default event loop for the current thread
+      def self.default
+        Thread.current._rev_loop
+      end
+    else
+      # Retrieve the default event loop
+      def self.default
+        @@_rev_loop ||= Rev::Loop.new
+      end
     end
 
     # Create a new Rev::Loop

data/lib/rev/server.rb

@@ -4,8 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../rev'
-
 module Rev
   class Server < Listener
     # Servers listen for incoming connections and create new connection objects
@@ -35,8 +33,8 @@ module Rev
     
     def on_connection(socket)
       connection = @klass.new(socket, *@args).attach(evloop)
-      @block.(connection) if @block
-      connection.on_connect
+      connection.__send__(:on_connect)
+      @block.call(connection) if @block
     end
   end
 

data/lib/rev/socket.rb

@@ -6,7 +6,6 @@
 
 require 'socket'
 require 'resolv'
-require File.dirname(__FILE__) + '/../rev'
 
 module Rev
   class Socket < IO    
@@ -173,7 +172,7 @@ module Rev
           # DNSResolver only supports IPv4 so we can safely assume an IPv4 address
           socket = TCPConnectSocket.new(::Socket::AF_INET, addr, port, host)
           initialize(socket, *args)
-          @connector = Connector.new(self, socket)
+          @connector = Socket::Connector.new(self, socket)
           @resolver = nil
         }
         @sock.attach(evloop)

data/lib/rev/ssl.rb

@@ -0,0 +1,184 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'openssl'
+
+# --
+# Rev implements SSL by subclassing OpenSSL::SSL::SSLSocket in C
+# and adding implementations for non-blocking versions of the
+# methods it provides.  Unfortunately, this relies on hacks specific
+# to Ruby 1.9.  If you'd like to find a workaround which is compatible
+# with Ruby 1.8, have a look at rev_ssl.c and find out if you can
+# properly initialize an OpenSSL::SSL::SSLSocket.
+# ++
+if RUBY_VERSION.gsub('.', '').to_i < 190
+  raise LoadError, "Rev::SSL not supported in this Ruby version, sorry"
+end
+
+module Rev
+  # Monkeypatch Rev::IO to include SSL support.  This can be accomplished
+  # by extending any Rev:IO (or subclass) object with Rev::SSL after the
+  # connection has completed, e.g.
+  #
+  #   class MySocket < Rev::TCPSocket
+  #     def on_connect
+  #       extend Rev::SSL
+  #       ssl_client_start
+  #     end
+  #   end
+  #
+  # Please be aware that SSL is only supported on Ruby 1.9 at the present time.
+  # 
+  module SSL
+    # Start SSL explicitly in client mode.  After calling this, callbacks
+    # will fire for checking the peer certificate (ssl_peer_cert) and
+    # its validity (ssl_verify_result)
+    def ssl_client_start
+      raise "ssl already started" if @ssl_socket
+      
+      context = respond_to?(:ssl_context) ? ssl_context : OpenSSL::SSL::SSLContext.new
+      @ssl_socket = SSL::IO.new(@io, context)
+      @ssl_init = proc { @ssl_socket.connect_nonblock }
+      
+      ssl_init
+    end
+    
+    # Start SSL explicitly in server mode. After calling this, callbacks
+    # will fire for checking the peer certificate (ssl_peer_cert) and
+    # its validity (ssl_verify_result)
+    def ssl_server_start
+      raise "ssl already started" if @ssl_socket
+      
+      @ssl_socket = SSL::IO.new(@io, ssl_context)
+      @ssl_init = proc { @ssl_socket.accept_nonblock }
+      
+      ssl_init
+    end
+    
+    #########
+    protected
+    #########
+    
+    def ssl_init
+      begin
+        @ssl_init.call
+        ssl_init_complete
+      rescue SSL::IO::ReadAgain
+        enable unless enabled?
+      rescue SSL::IO::WriteAgain
+        enable_write_watcher
+      rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET
+        close
+      rescue => ex
+        if respond_to? :on_ssl_error
+          on_ssl_error(ex)
+        else raise ex
+        end
+      end
+    end
+    
+    def ssl_init_complete
+      @ssl_init = nil
+      enable unless enabled?
+      
+      on_peer_cert(@ssl_socket.peer_cert) if respond_to? :on_peer_cert
+      on_ssl_result(@ssl_socket.verify_result) if respond_to? :on_ssl_result
+      on_ssl_connect if respond_to? :on_ssl_connect
+    end
+    
+    def on_readable
+      if @ssl_init
+        disable
+        ssl_init
+        return
+      end
+      
+      begin
+        on_read @ssl_socket.read_nonblock(Rev::IO::INPUT_SIZE)
+      rescue Errno::AGAIN, SSL::IO::ReadAgain
+        return
+      rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, EOFError
+        close
+      end
+    end
+    
+    def on_writable
+      if @ssl_init
+        disable_write_watcher
+        ssl_init
+        return
+      end
+      
+      begin
+        nbytes = @ssl_socket.write_nonblock @write_buffer.to_str
+      rescue Errno::EAGAIN, SSL::IO::WriteAgain
+        return
+      rescue OpenSSL::SSL::SSLError, Errno::EPIPE, Errno::ECONNRESET
+        close
+        return
+      end
+      
+      @write_buffer.read(nbytes)
+      
+      if @write_buffer.empty?
+        disable_write_watcher
+        on_write_complete
+      end
+    end
+  end
+  
+  # A socket class for outgoing and incoming SSL connections.  Please be aware
+  # that SSL is only supported on Ruby 1.9 at the present time.
+  class SSLSocket < TCPSocket
+    # Perform a non-blocking connect to the given host and port
+    def self.connect(addr, port, *args)
+      super.instance_eval { @connecting = true; self }
+    end
+    
+    # Returns the OpenSSL::SSL::SSLContext for to use for the session.
+    # By default no certificates will be checked.  If you would like 
+    # any certificate checking to be performed, please override this 
+    # class and return a context loaded with the appropriate certificates.
+    def ssl_context
+      @ssl_context ||= OpenSSL::SSL::SSLContext.new
+    end
+    
+    # Called when SSL handshaking has successfully completed
+    def on_ssl_connect; end
+    event_callback :on_ssl_connect
+    
+    # Called when peer certificate has successfully been received.
+    # Equivalent to OpenSSL::SSL::SSLSocket#peer_cert
+    def on_peer_cert(peer_cert); end
+    event_callback :on_peer_cert
+    
+    # Called when SSL handshaking has been completed successfully.
+    # Equivalent to OpenSSL::SSL::SSLSocket#verify_result
+    def on_ssl_result(result);  end
+    event_callback :on_ssl_result
+    
+    # Called if an error occurs during SSL session initialization
+    def on_ssl_error(exception); end
+    event_callback :on_ssl_error
+    
+    #########
+    protected
+    #########
+    
+    def on_connect
+      extend SSL
+      @connecting ? ssl_client_start : ssl_server_start
+    end
+  end
+  
+  # A class for implementing SSL servers.  Please be aware that SSL is only
+  # supported on Ruby 1.9 at the present time.
+  class SSLServer < TCPServer
+    def initialize(host, port, klass = SSLSocket, *args, &block)
+      super
+    end
+  end
+end