ftw 0.0.1 → 0.0.4

data/lib/net/ftw/crlf.rb

@@ -1,6 +0,0 @@
-require "net/ftw/namespace"
-
-module Net::FTW::CRLF
-  # carriage-return + line-feed
-  CRLF = "\r\n"
-end

data/lib/net/ftw/dns.rb

@@ -1,57 +0,0 @@
-require "net/ftw/namespace"
-require "socket"
-# TODO(sissel): Switch to using Resolv::DNS since it lets you (the programmer)
-# choose dns configuration (servers, etc)
-# I still need to wrap whatever Ruby provides because it is historically very
-# inconsistent in implementation behavior across ruby platforms and versions.
-#
-# I didn't really want to write a DNS library.
-class Net::FTW::DNS
-  V4_IN_V6_PREFIX = "0:" * 12
-
-  def self.singleton
-    @resolver ||= self.new
-  end # def self.singleton
-
-  # This method is only intended to do A or AAAA lookups
-  # I may add PTR lookups later.
-  def resolve(hostname)
-    official, aliases, family, *addresses = Socket.gethostbyname(hostname)
-    # We ignore family, here. Ruby will return v6 *and* v4 addresses in
-    # the same gethostbyname() call. It is confusing. 
-    #
-    # Let's just rely entirely on the length of the address string.
-    return addresses.collect do |address|
-      if address.length == 16
-        unpack_v6(address)
-      else
-        unpack_v4(address)
-      end
-    end
-  end # def resolve
-
-  def resolve_random(hostname)
-    addresses = resolve(hostname)
-    return addresses[rand(addresses.size)]
-  end # def resolve_random
-
-  private
-  def unpack_v4(address)
-    return address.unpack("C4").join(".")
-  end # def unpack_v4
-
-  private
-  def unpack_v6(address)
-    if address.length == 16
-      # Unpack 16 bit chunks, convert to hex, join with ":"
-      address.unpack("n8").collect { |p| p.to_s(16) } \
-        .join(":").sub(/(?:0:(?:0:)+)/, "::")
-    else 
-      # assume ipv4
-      # Per the following sites, "::127.0.0.1" is valid and correct
-      # http://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
-      # http://www.tcpipguide.com/free/t_IPv6IPv4AddressEmbedding.htm
-      "::" + unpack_v4(address)
-    end
-  end # def unpack_v6
-end # class Net::FTW::DNS

data/lib/net/ftw/http.rb

@@ -1,2 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/http/client"

data/lib/net/ftw/http/client.rb

@@ -1,116 +0,0 @@
-require "net/ftw/http/connection"
-require "net/ftw/http/request"
-require "net/ftw/http/response"
-require "net/ftw/namespace"
-require "socket" # ruby stdlib
-
-# TODO(sissel): Split this out into a general 'client' class (outside http)
-# TODO(sissel): EventMachine support
-
-# A client should be like a web browser. It should support lots of active
-# connections.
-class Net::FTW::HTTP::Client
-  include Net::FTW::CRLF
-
-  # Create a new HTTP client. You probably only need one of these.
-  def initialize
-    @connections = []
-  end # def initialize
-  
-  # TODO(sissel): This method may not stay. I dunno yet.
-  public
-  def get(uri, headers={})
-    # TODO(sissel): enforce uri scheme options? (ws, wss, http, https?)
-    prepare("GET", uri, headers)
-  end # def get
-
-  public
-  def prepare(method, uri, headers={})
-    uri = Addressable::URI.parse(uri.to_s) if uri.is_a?(URI)
-    uri.port ||= 80
-
-    request = Net::FTW::HTTP::Request.new(uri)
-    response = Net::FTW::HTTP::Response.new
-    request.method = method
-    request.version = 1.1
-    headers.each do |key, value|
-      request.headers[key] = value
-    end
-
-    # TODO(sissel): This is starting to feel like not the best way to implement
-    # protocols.
-    connection = Net::FTW::HTTP::Connection.new("#{uri.host}:#{uri.port}")
-    connection.on(connection.class::CONNECTED) do |address|
-      connection.write(request.to_s)
-      connection.write(CRLF)
-    end
-    connection.on(connection.class::HEADERS_COMPLETE) do |version, status, headers|
-      response.status = status
-      response.version = version
-      headers.each { |field, value| response.headers.add(field, value) }
-
-      # TODO(sissel): Split these BODY handlers into separate body-handling
-      # classes.
-      if response.headers.include?("Content-Length")
-        length = response.headers.get("Content-Length").to_i
-        connection.on(connection.class::MESSAGE_BODY) do |data|
-          length -= data.size
-          #$stdout.write data
-          if length <= 0
-            if response.headers.get("Connection") == "close"
-              connection.disconnect
-            else
-              p :response_complete => response.headers.get("Content-Length")
-              # TODO(sissel): This connection is now ready for another HTTP
-              # request.
-            end
-
-            # TODO(sissel): What to do with the extra bytes?
-            if length < 0
-              # Length is negative, will be offset on end of data string
-              $stderr.puts :TOOMANYBYTES => data[length .. -1]
-            end
-          end
-        end 
-      elsif response.headers.get("Transfer-Encoding") == "chunked"
-        connection.on(connection.class::MESSAGE_BODY) do |data|
-          # TODO(sissel): Handle chunked encoding
-          p :chunked => data
-        end
-      elsif response.version == 1.1
-        # No content-length nor transfer-encoding. If this is HTTP/1.1, this is
-        # an error, I think. I need to find the specific part of RFC2616 that
-        # specifies this.
-        connection.disconnect("Invalid HTTP Response received. Response " \
-          "version claimed 1.1 but no Content-Length nor Transfer-Encoding "\
-          "header was set in the response.")
-      end
-    end # connection.on HEADERS_COMPLETE
-    #connection.run
-    return connection
-  end # def prepare
-
-  def prepare2(method, uri, headers={})
-    uri = Addressable::URI.parse(uri.to_s) if uri.is_a?(URI)
-    uri.port ||= 80
-
-    request = Net::FTW::HTTP::Request.new(uri)
-    response = Net::FTW::HTTP::Response.new
-    request.method = method
-    request.version = 1.1
-    headers.each do |key, value|
-      request.headers[key] = value
-    end
-
-    # TODO(sissel): This is starting to feel like not the best way to implement
-    # protocols.
-    id = "#{uri.scheme}://#{uri.host}:#{uri.port}/..."
-    connection = Net::FTW::HTTP::Connection.new("#{uri.host}:#{uri.port}")
-    @connections[id] = connection
-  end # def prepare2
-
-  # TODO(sissel): 
-  def run
-    # Select across all active connections, do read_and_trigger, etc.
-  end # def run
-end # class Net::FTW::HTTP::Client

data/lib/net/ftw/http/client2.rb

@@ -1,80 +0,0 @@
-require "net/ftw/connection2"
-require "net/ftw/http/request"
-require "net/ftw/http/response"
-require "net/ftw/namespace"
-require "socket" # ruby stdlib
-
-# TODO(sissel): Split this out into a general 'client' class (outside http)
-# TODO(sissel): EventMachine support
-
-# A client should be like a web browser. It should support lots of active
-# connections.
-class Net::FTW::HTTP::Client2
-  include Net::FTW::CRLF
-
-  # Create a new HTTP client. You probably only need one of these.
-  def initialize
-    @connections = []
-  end # def initialize
-  
-  # TODO(sissel): This method may not stay. I dunno yet.
-  public
-  def get(uri, headers={})
-    # TODO(sissel): enforce uri scheme options? (ws, wss, http, https?)
-    return prepare("GET", uri, headers)
-  end # def get
-
-  public
-  def prepare(method, uri, headers={})
-    uri = Addressable::URI.parse(uri.to_s) if uri.is_a?(URI)
-    uri.port ||= 80
-
-    request = Net::FTW::HTTP::Request.new(uri)
-    response = Net::FTW::HTTP::Response.new
-    request.method = method
-    request.version = 1.1
-    headers.each do |key, value|
-      request.headers[key] = value
-    end
-
-    connection = Net::FTW::Connection2.new("#{uri.host}:#{uri.port}")
-    return fiberup(connection, request, response)
-  end # def prepare
-
-  def fiberup(connection, request, response)
-    # Body just passes through
-    body = Fiber.new do |data|
-      Fiber.yield data
-    end
-
-    # Parse the HTTP headers
-    headers = Fiber.new do |data|
-      parser = HTTP::Parser.new
-      headers_done = false
-      parser.on_headers_complete = proc { headers_done = true; :stop }
-      while true do
-        offset = parser << data
-        if headers_done
-          version = "#{parser.http_major}.#{parser.http_minor}".to_f
-          p :processing
-          Fiber.yield [version, parser.status_code, parser.headers]
-          p :processing
-          # Transfer control to the 'body' fiber.
-          body.transfer(data[offset..-1])
-        end
-        p :waiting
-        data = Fiber.resume
-      end
-    end
-
-    connect = Fiber.new do
-      connection.connect
-      connection.write(request.to_s + CRLF)
-      while true do
-        data = connection.read(16384)
-        headers.resume data
-      end
-    end
-    return connect
-  end # def fiberup
-end # class Net::FTW::HTTP::Client2

data/lib/net/ftw/http/connection.rb

@@ -1,42 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/connection"
-
-class Net::FTW::HTTP::Connection < Net::FTW::Connection
-  HEADERS_COMPLETE = :headers_complete
-  MESSAGE_BODY = :message_body
-
-  def run
-    # TODO(sissel): Implement retries on certain failures like DNS, connect
-    # timeouts, or connection resets?
-    # TODO(sissel): use HTTPS if the uri.scheme == "https"
-    # TODO(sissel): Resolve the hostname
-    # TODO(sissel): Start a new connection, or reuse an existing one.
-    #
-    # TODO(sissel): This suff belongs in a new class, like HTTP::Connection or something.
-    parser = HTTP::Parser.new
-
-    # Only parse the header of the response
-    state = :headers
-    parser.on_headers_complete = proc { state = :body; :stop }
-
-    on(DATA) do |data|
-      # TODO(sissel): Implement this better. Should be able to swap out the
-      # DATA handler at run-time
-      if state == :headers
-        offset = parser << data
-        if state == :body
-          # headers done parsing.
-          version = "#{parser.http_major}.#{parser.http_minor}".to_f
-          trigger(HEADERS_COMPLETE, version, parser.status_code, parser.headers)
-
-          # Re-call 'data' with the remaining non-header portion of data.
-          trigger(DATA, data[offset..-1])
-        end
-      else
-        trigger(MESSAGE_BODY, data)
-      end
-    end
-
-    super()
-  end # def run
-end # class Net::FTW::HTTP::Connection

data/lib/net/ftw/http/headers.rb

@@ -1,122 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/crlf"
-
-# HTTP Headers
-#
-# See RFC2616 section 4.2: <http://tools.ietf.org/html/rfc2616#section-4.2>
-#
-# Section 14.44 says Field Names in the header are case-insensitive, so
-# this library always forces field names to be lowercase. This includes
-# get() calls.
-#
-#    headers.set("HELLO", "world")
-#    headers.get("hello")   # ===> "world"
-#
-class Net::FTW::HTTP::Headers
-  include Enumerable
-  include Net::FTW::CRLF
-
-  # Make a new headers container. You can pass a hash of 
-  public
-  def initialize(headers={})
-    super()
-    @version = 1.1
-    @headers = headers
-  end # def initialize
-
-  # Set a header field to a specific value.
-  # Any existing value(s) for this field are destroyed.
-  def set(field, value)
-    @headers[field.downcase] = value
-  end # def set
-
-  # Set a header field to a specific value.
-  # Any existing value(s) for this field are destroyed.
-  def include?(field)
-    @headers.include?(field.downcase)
-  end # def include?
-
-  # Add a header field with a value.
-  #
-  # If this field already exists, another value is added.
-  # If this field does not already exist, it is set.
-  def add(field, value)
-    field = field.downcase
-    if @headers.include?(field)
-      if @headers[field].is_a?(Array)
-        @headers[field] << value
-      else
-        @headers[field] = [@headers[field], value]
-      end
-    else
-      set(field, value)
-    end
-  end # def add
-
-  # Removes a header entry. If the header has multiple values
-  # (like X-Forwarded-For can), you can delete a specific entry
-  # by passing the value of the header field to remove.
-  #
-  #     # Remove all X-Forwarded-For entries
-  #     headers.remove("X-Forwarded-For") 
-  #     # Remove a specific X-Forwarded-For entry
-  #     headers.remove("X-Forwarded-For", "1.2.3.4")
-  #
-  # * If you remove a field that doesn't exist, no error will occur.
-  # * If you remove a field value that doesn't exist, no error will occur.
-  # * If you remove a field value that is the only value, it is the same as
-  #   removing that field by name.
-  def remove(field, value=nil)
-    field = field.downcase
-    if value.nil?
-      # no value, given, remove the entire field.
-      @headers.delete(field)
-    else
-      field_value = @headers[field]
-      if field_value.is_a?(Array)
-        # remove a specific value
-        field_value.delete(value)
-        # Down to a String again if there's only one value.
-        if field_value.size == 1
-          set(field, field_value.first)
-        end
-      else
-        # Remove this field if the value matches
-        if field_value == value
-          remove(field)
-        end
-      end
-    end
-  end # def remove
-
-  # Get a field value. 
-  # 
-  # This will return:
-  #   * String if there is only a single value for this field
-  #   * Array of String if there are multiple values for this field
-  def get(field)
-    field = field.downcase
-    return @headers[field]
-  end # def get
-
-  # Iterate over headers. Given to the block are two arguments, the field name
-  # and the field value. For fields with multiple values, you will receive
-  # that same field name multiple times, like:
-  #    yield "Host", "www.example.com"
-  #    yield "X-Forwarded-For", "1.2.3.4"
-  #    yield "X-Forwarded-For", "1.2.3.5"
-  def each(&block)
-    @headers.each do |field_name, field_value|
-      if field_value.is_a?(Array)
-        field_value.map { |value| yield field_name, v }
-      else
-        yield field_name, field_value
-      end
-    end
-  end # end each
-
-  public
-  def to_s
-    return @headers.collect { |name, value| "#{name}: #{value}" }.join(CRLF) + CRLF
-  end # def to_s
-end # class Net::FTW::HTTP::Request < Message

data/lib/net/ftw/http/machine.rb

@@ -1,38 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/machine"
-require "http/parser" # gem http_parser.rb
-
-class Net::FTW::HTTP::Machine
-  # States
-  HEADERS = :headers
-  MESSAGE = :message
-
-  # Valid transitions
-  TRANSITIONS = {
-    START => HEADERS
-    HEADERS => [MESSAGE, ERROR]
-    MESSAGE => [START, ERROR]
-  }
-
-  def initialize
-    super
-    transition(HEADERS)
-    @parser = HTTP::Parser.new
-    @parser.on_headers_complete = proc { transition(MESSAGE) }
-  end # def initialize
-
-  def state_headers(data)
-    offset = parser << data
-    if state?(MESSAGE)
-      # We finished headers and transitioned to message body.
-      yield version, parser.status_code, parser.headers
-
-      # Re-feed any body part we were fed that wasn't part of the headers
-      feed(data[offset..-1])
-    end
-  end # def state_headers
-
-  def state_message(data)
-    yield data
-  end # def state_message
-end # class Net::FTW::HTTP::Connection