ftw 0.0.13 → 0.0.14

data/lib/ftw.rb

@@ -3,3 +3,4 @@ require "ftw/connection"
 require "ftw/dns"
 require "ftw/version"
 require "ftw/server"
+require "ftw/webserver"

data/lib/ftw/agent.rb

@@ -40,6 +40,8 @@ class FTW::Agent
   require "ftw/agent/configuration"
   include FTW::Agent::Configuration
 
+  # Thrown when too many redirects are encountered
+  # See also {FTW::Agent::Configuration::REDIRECTION_LIMIT}
   class TooManyRedirects < StandardError
     attr_accessor :response
     def initialize(reason, response)
@@ -202,7 +204,7 @@ class FTW::Agent
         # Throw away the body
         response.body = connection
         # read_body will consume the body and release this connection
-        response.read_body { |chunk| }
+        response.read_http_body { |chunk| }
       end
 
       # TODO(sissel): If this response has any cookies, store them in the

data/lib/ftw/agent/configuration.rb

@@ -1,9 +1,13 @@
 require "ftw"
 
+# Experimentation with an agent configuration similar to Firefox's about:config
 module FTW::Agent::Configuration
+  # The config key for setting how many redirects will be followed before
+  # giving up.
   REDIRECTION_LIMIT = "redirection-limit".freeze
 
+  # Get the configuration hash
   def configuration
     return @configuration ||= Hash.new
-  end
-end
+  end # def configuration
+end # def FTW::Agent::Configuration

data/lib/ftw/http/message.rb

@@ -33,7 +33,7 @@ module FTW::HTTP::Message
   #
   # @param [String] the name of the field. (case insensitive)
   def [](field)
-    return @headers[header]
+    return @headers[field]
   end # def []
 
   # Set a header field
@@ -41,7 +41,7 @@ module FTW::HTTP::Message
   # @param [String] the name of the field. (case insensitive)
   # @param [String] the value to set for this field
   def []=(field, value)
-    @headers[field] = header
+    @headers[field] = value
   end # def []=
 
   # Set the body of this message
@@ -54,7 +54,7 @@ module FTW::HTTP::Message
     # TODO(sissel): if it's an IO object, set Transfer-Encoding to chunked
     # TODO(sissel): if it responds to each or appears to be Enumerable, then
     # set Transfer-Encoding to chunked.
-    if message_body.is_a?(IO)
+    if message_body.respond_to?(:read) or message_body.respond_to?(:each)
       headers["Transfer-Encoding"] = "chunked"
     else
       headers["Content-Length"] = message_body.length

data/lib/ftw/protocol.rb

@@ -1,9 +1,12 @@
 require "ftw/namespace"
+require "ftw/crlf"
 require "cabin"
 require "logger"
 
 # This module provides web protocol handling as a mixin.
 module FTW::Protocol
+  include FTW::CRLF
+
   # Read an HTTP message from a given connection
   #
   # This method blocks until a full http message header has been consumed
@@ -56,5 +59,104 @@ module FTW::Protocol
     end
   end # def read_http_message
 
-  public(:read_http_message)
+  def write_http_body(body, io, chunked=false)
+    if chunked
+      write_http_body_chunked(body, io)
+    else
+      write_http_body_normal(body, io)
+    end
+  end # def write_http_body
+
+  # Encode the given text as in 'chunked' encoding.
+  def encode_chunked(text)
+    return sprintf("%x%s%s%s", text.size, CRLF, text, CRLF)
+  end # def encode_chunked
+
+  def write_http_body_chunked(body, io)
+    if body.is_a?(String)
+      io.write(encode_chunked(body))
+    elsif body.respond_to?(:sysread)
+      true while io.write(encode_chunked(body.sysread(16384)))
+    elsif body.respond_to?(:read)
+      true while io.write(encode_chunked(body.read(16384)))
+    elsif body.respond_to?(:each)
+      body.each { |s| io.write(encode_chunked(s)) }
+    end
+
+    # The terminating chunk is an empty one.
+    io.write(encode_chunked(""))
+  end # def write_http_body_chunked
+
+  def write_http_body_normal(body, io)
+    if body.is_a?(String)
+      io.write(body)
+    elsif body.respond_to?(:read)
+      true while io.write(body.read(16384))
+    elsif body.respond_to?(:each)
+      body.each { |s| io.write(s) }
+    end
+  end # def write_http_body_normal
+
+  # Read the body of this message. The block is called with chunks of the
+  # response as they are read in.
+  #
+  # This method is generally only called by http clients, not servers.
+  def read_http_body(&block)
+    if @body.respond_to?(:read)
+      if headers.include?("Content-Length") and headers["Content-Length"].to_i > 0
+        @logger.debug("Reading body with Content-Length")
+        read_http_body_length(headers["Content-Length"].to_i, &block)
+      elsif headers["Transfer-Encoding"] == "chunked"
+        @logger.debug("Reading body with chunked encoding")
+        read_http_body_chunked(&block)
+      end
+
+      # If this is a poolable resource, release it (like a FTW::Connection)
+      @body.release if @body.respond_to?(:release)
+    elsif !@body.nil?
+      yield @body
+    end
+  end # def read_http_body
+
+  # Old api compat
+  alias_method :read_body, :read_http_body
+
+  # Read the length bytes from the body. Yield each chunk read to the block
+  # given. This method is generally only called by http clients, not servers.
+  def read_http_body_length(length, &block)
+    remaining = length
+    while remaining > 0
+      data = @body.read
+      @logger.debug("Read bytes", :length => data.size)
+      if data.size > remaining
+        # Read too much data, only wanted part of this. Push the rest back.
+        yield data[0..remaining]
+        remaining = 0
+        @body.pushback(data[remaining .. -1]) if remaining < 0
+      else
+        yield data
+        remaining -= data.size
+      end
+    end
+  end # def read_http_body_length
+
+  # This is kind of messed, need to fix it.
+  def read_http_body_chunked(&block)
+    parser = HTTP::Parser.new
+
+    # Fake fill-in the response we've already read into the parser.
+    parser << to_s
+    parser << CRLF
+    parser.on_body = block
+    done = false
+    parser.on_message_complete = proc { done = true }
+
+    while !done # will break on special conditions below
+      data = @body.read
+      offset = parser << data
+      if offset != data.length
+        raise "Parser did not consume all data read?"
+      end
+    end
+  end # def read_http_body_chunked
 end # module FTW::Protocol

data/lib/ftw/request.rb

@@ -56,6 +56,7 @@ class FTW::Request
     @protocol = "http"
     @version = 1.1
     use_uri(uri) if !uri.nil?
+    @logger = Cabin::Channel.get
   end # def initialize
 
   # Execute this request on a given connection: Writes the request, returns a
@@ -72,18 +73,15 @@ class FTW::Request
     tries = 3
     begin
       connection.write(to_s + CRLF)
-
       if body?
-        if body.is_a?(String)
-          connection.write(body)
-        else
-          connection.write(data) while data = body.read(16384)
-        end
+        write_http_body(body, connection,
+                        headers["Transfer-Encoding"] == "chunked") 
       end
     rescue => e
       # TODO(sissel): Rescue specific exceptions, not just anything.
       # Reconnect and retry
       if tries > 0
+        tries -= 1
         connection.connect
         retry
       else

data/lib/ftw/response.rb

@@ -1,4 +1,5 @@
 require "ftw/namespace"
+require "ftw/protocol"
 require "ftw/http/message"
 require "cabin" # gem cabin
 require "http/parser" # gem http_parser.rb
@@ -8,6 +9,7 @@ require "http/parser" # gem http_parser.rb
 # See RFC2616 section 6: <http://tools.ietf.org/html/rfc2616#section-6>
 class FTW::Response 
   include FTW::HTTP::Message
+  include FTW::Protocol
 
   # The http status code (RFC2616 6.1.1)
   # See RFC2616 section 6.1.1: <http://tools.ietf.org/html/rfc2616#section-6.1.1>
@@ -45,8 +47,6 @@ class FTW::Response
     406 => "Not Acceptable"
   } # STATUS_REASON_MAP
 
-  attr_accessor :body
-
   private
 
   # Create a new Response.
@@ -90,66 +90,6 @@ class FTW::Response
   # Define the Message's start_line as status_line
   alias_method :start_line, :status_line
 
-  # Read the body of this Response. The block is called with chunks of the
-  # response as they are read in.
-  #
-  # This method is generally only called by http clients, not servers.
-  def read_body(&block)
-    if @body.respond_to?(:read)
-      if headers.include?("Content-Length") and headers["Content-Length"].to_i > 0
-        @logger.debug("Reading body with Content-Length")
-        read_body_length(headers["Content-Length"].to_i, &block)
-      elsif headers["Transfer-Encoding"] == "chunked"
-        @logger.debug("Reading body with chunked encoding")
-        read_body_chunked(&block)
-      end
-
-      # If this is a poolable resource, release it (like a FTW::Connection)
-      @body.release if @body.respond_to?(:release)
-    elsif !@body.nil?
-      yield @body
-    end
-  end # def read_body
-
-  # Read the length bytes from the body. Yield each chunk read to the block
-  # given. This method is generally only called by http clients, not servers.
-  def read_body_length(length, &block)
-    remaining = length
-    while remaining > 0
-      data = @body.read
-      @logger.debug("Read bytes", :length => data.size)
-      if data.size > remaining
-        # Read too much data, only wanted part of this. Push the rest back.
-        yield data[0..remaining]
-        remaining = 0
-        @body.pushback(data[remaining .. -1]) if remaining < 0
-      else
-        yield data
-        remaining -= data.size
-      end
-    end
-  end # def read_body_length
-
-  # This is kind of messed, need to fix it.
-  def read_body_chunked(&block)
-    parser = HTTP::Parser.new
-
-    # Fake fill-in the response we've already read into the parser.
-    parser << to_s
-    parser << CRLF
-    parser.on_body = block
-    done = false
-    parser.on_message_complete = proc { done = true }
-
-    while !done # will break on special conditions below
-      data = @body.read
-      offset = parser << data
-      if offset != data.length
-        raise "Parser dis not consume all data read?"
-      end
-    end
-  end # def read_body_chunked
-
   # Is this Response the result of a successful Upgrade request?
   def upgrade?
     return false unless status == 101 # "Switching Protocols"
@@ -158,6 +98,6 @@ class FTW::Response
   end # def upgrade?
 
   public(:status=, :status, :reason, :initialize, :upgrade?, :redirect?,
-         :error?, :status_line, :read_body)
+         :error?, :status_line)
 end # class FTW::Response
 

data/lib/ftw/version.rb

@@ -3,5 +3,5 @@ require "ftw/namespace"
 # :nodoc:
 module FTW
   # The version of this library
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/lib/ftw/webserver.rb

@@ -0,0 +1,105 @@
+require "ftw"
+require "ftw/protocol"
+require "ftw/crlf"
+require "socket"
+require "cabin"
+
+# An attempt to invent a simple FTW web server.
+class FTW::WebServer
+  include FTW::Protocol
+  include FTW::CRLF
+
+  def initialize(host, port, &block)
+    @host = host
+    @port = port
+    @handler = block
+
+    @logger = Cabin::Channel.get
+    @threads = []
+  end # def initialize
+
+  # Run the server.
+  #
+  # Connections are farmed out to threads.
+  def run
+    logger.info("Starting server", :config => @config)
+    @server = FTW::Server.new([@host, @port].join(":"))
+    @server.each_connection do |connection|
+      @threads << Thread.new do
+        handle_connection(connection)
+      end
+    end
+  end # def run
+
+  def stop
+    @server.stop unless @server.nil?
+    @threads.each(&:join)
+  end # def stop
+
+  # Handle a new connection.
+  #
+  # This method parses http requests and passes them on to #handle_request
+  #
+  # @param connection The FTW::Connection being handled.
+  def handle_connection(connection)
+    while true
+      begin
+        request = read_http_message(connection)
+      rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, HTTP::Parser::Error, IOError
+        # Connection EOF'd or errored before we finished reading a full HTTP
+        # message, shut it down.
+        break
+      end
+
+      if request["Content-Length"] || request["Transfer-Encoding"]
+        request.body = connection
+      end
+
+      begin
+        handle_request(request, connection)
+      rescue => e
+        puts e.inspect
+        puts e.backtrace
+        raise e
+      end
+    end
+    connection.disconnect("Fun")
+  end # def handle_connection
+
+  # Handle a request. This will set up the rack 'env' and invoke the
+  # application associated with this handler.
+  def handle_request(request, connection)
+    response = FTW::Response.new
+    response.version = request.version
+    response["Connection"] = request.headers["Connection"] || "close"
+
+    # Process this request with the handler
+    @handler.call(request, response, connection)
+
+    # Write the response
+    begin
+      connection.write(response.to_s + CRLF)
+      if response.body?
+        write_http_body(response.body, connection,
+                        response["Transfer-Encoding"] == "chunked") 
+      end
+    rescue => e
+      @logger.error(e)
+      connection.disconnect(e.inspect)
+    end
+
+    if response["Connection"] == "close" or response["Connection"].nil?
+      connection.disconnect("'Connection' header was close or nil")
+    end
+  end # def handle_request
+
+  # Get the logger.
+  def logger
+    if @logger.nil?
+      @logger = Cabin::Channel.get
+    end
+    return @logger
+  end # def logger
+
+  public(:run, :initialize, :stop)
+end # class FTW::WebServer

data/lib/ftw/websocket/writer.rb

@@ -116,8 +116,9 @@ class FTW::WebSocket::Writer
     end
     data << (maskbit | lengthbits)
     pack << "C"
-  end
+  end # def pack_maskbit_and_length
 
+  # Pack the extended length. 16 bits or 64 bits
   def pack_extended_length(data, pack, length)
     data << length
     if length >= (1 << 16)

data/lib/rack/handler/ftw.rb

@@ -202,9 +202,14 @@ class Rack::Handler::FTW
     end
     response.body = body
 
-    connection.write(response.to_s + CRLF)
-    body.each do |chunk|
-      connection.write(chunk)
+    begin
+      connection.write(response.to_s + CRLF)
+      body.each do |chunk|
+        connection.write(chunk)
+      end
+    rescue => e
+      @logger.error(e)
+      connection.disconnect(e.inspect)
     end
   end # def handle_request
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ftw
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-03 00:00:00.000000000 Z
+date: 2012-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -141,6 +141,7 @@ files:
 - lib/ftw/cookies.rb
 - lib/ftw/singleton.rb
 - lib/ftw/crlf.rb
+- lib/ftw/webserver.rb
 - test/testing.rb
 - test/docs.rb
 - test/ftw/http/dns.rb