ftw 0.0.1

data/lib/ftw/http/message.rb

@@ -0,0 +1,92 @@
+require "ftw/namespace"
+require "ftw/http/headers"
+require "ftw/crlf"
+
+# HTTP Message, RFC2616
+module FTW::HTTP::Message
+  include FTW::CRLF
+
+  # The HTTP headers. See FTW::HTTP::Headers
+  # RFC2616 5.3 - <http://tools.ietf.org/html/rfc2616#section-5.3>
+  attr_reader :headers
+
+  # The HTTP version. See VALID_VERSIONS for valid versions.
+  # This will always be a Numeric object.
+  # Both Request and Responses have version, so put it in the parent class.
+  attr_accessor :version
+  VALID_VERSIONS = [1.0, 1.1]
+
+  # A new HTTP Message. You probably won't use this class much. 
+  # See RFC2616 section 4: <http://tools.ietf.org/html/rfc2616#section-4>
+  # See Request and Response.
+  public
+  def initialize
+    @headers = FTW::HTTP::Headers.new
+    @body = nil
+  end # def initialize
+
+  # get a header value
+  public
+  def [](header)
+    return @headers[header]
+  end # def []
+
+  public
+  def []=(header, value)
+    @headers[header] = header
+  end # def []=
+
+  # See RFC2616 section 4.3: <http://tools.ietf.org/html/rfc2616#section-4.3>
+  public
+  def body=(message_body)
+    # TODO(sissel): if message_body is a string, set Content-Length header
+    # 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.
+    @body = message_body
+  end # def body=
+
+  public
+  def body
+    # TODO(sissel): verification todos follow...
+    # TODO(sissel): RFC2616 section 4.3 - if there is a message body
+    # then one of "Transfer-Encoding" *or* "Content-Length" MUST be present.
+    # otherwise, if neither header is present, no body is present.
+    # TODO(sissel): Responses to HEAD requests or those with status 1xx, 204,
+    # or 304 MUST NOT have a body. All other requests have a message body,
+    # even if that body is of zero length.
+    return @body
+  end # def body
+
+  # Does this message have a message body?
+  public
+  def body?
+    return @body.nil?
+  end # def body?
+
+  # Set the HTTP version. Must be a valid version. See VALID_VERSIONS.
+  public
+  def version=(ver)
+    # Accept string "1.0" or simply "1", etc.
+    ver = ver.to_f if !ver.is_a?(Float)
+
+    if !VALID_VERSIONS.include?(ver)
+      raise ArgumentError.new("#{self.class.name}#version = #{ver.inspect} is" \
+        "invalid. It must be a number, one of #{VALID_VERSIONS.join(", ")}")
+    end
+    @version = ver
+  end # def version=
+
+  # Serialize this Request according to RFC2616
+  # Note: There is *NO* trailing CRLF. This is intentional.
+  # The RFC defines:
+  #     generic-message = start-line
+  #                       *(message-header CRLF)
+  #                       CRLF
+  #                       [ message-body ]
+  # Thus, the CRLF between header and body is not part of the header.
+  public
+  def to_s
+    return [start_line, @headers].join(CRLF)
+  end
+end # class FTW::HTTP::Message

data/lib/ftw/namespace.rb

@@ -0,0 +1,3 @@
+module FTW
+  module HTTP; end
+end

data/lib/ftw/request.rb

@@ -0,0 +1,102 @@
+require "ftw/namespace"
+require "ftw/http/message"
+require "addressable/uri" # gem addressable
+require "uri" # ruby stdlib
+require "http/parser" # gem http_parser.rb
+require "ftw/crlf"
+
+# An HTTP Request.
+#
+# See RFC2616 section 5: <http://tools.ietf.org/html/rfc2616#section-5>
+class FTW::Request
+  include FTW::HTTP::Message
+  include FTW::CRLF
+
+  # The http method. Like GET, PUT, POST, etc..
+  # RFC2616 5.1.1 - <http://tools.ietf.org/html/rfc2616#section-5.1.1>
+  #
+  # Warning: this accessor obscures the ruby Kernel#method() method.
+  # I would like to call this 'verb', but my preference is first to adhere to
+  # RFC terminology. Further, ruby's stdlib Net::HTTP calls this 'method' as
+  # well (See Net::HTTPGenericRequest).
+  attr_accessor :method
+
+  # This is the Request-URI. Many people call this the 'path' of the request.
+  # RFC2616 5.1.2 - <http://tools.ietf.org/html/rfc2616#section-5.1.2>
+  attr_accessor :request_uri
+
+  # Lemmings. Everyone else calls Request-URI the 'path' - so I should too.
+  alias_method :path, :request_uri
+
+  public
+  def initialize(uri=nil)
+    super()
+    use_uri(uri) if !uri.nil?
+    @version = 1.1
+  end # def initialize
+
+  # Set the connection to use for this request.
+  public
+  def connection=(connection)
+    @connection = connection
+  end # def connection=
+
+  public
+  def execute(connection)
+    connection.write(to_s + CRLF)
+
+    parser = HTTP::Parser.new
+    parser.on_headers_complete = proc { state = :body; :stop }
+
+    data = connection.read(16384)
+    parser << data
+    # TODO(sissel): use connection.unread() if we finish reading headers
+    # and there's still some data left that is part of the body.
+  end # def execute
+
+  # TODO(sissel): Methods to write:
+  # 1. Parsing a request, use HTTP::Parser from http_parser.rb
+  # 2. Building a request from a URI or Addressable::URI
+
+  public
+  def use_uri(uri)
+    # Convert URI objects to Addressable::URI
+    uri = Addressable::URI.parse(uri.to_s) if uri.is_a?(URI)
+
+    # TODO(sissel): Use normalized versions of these fields?
+    # uri.host
+    # uri.port
+    # uri.scheme
+    # uri.path
+    # uri.password
+    # uri.user
+    @request_uri = uri.path
+    @headers.set("Host", uri.host)
+    
+    # TODO(sissel): support authentication
+  end # def use_uri
+
+  # Set the method for this request. Usually something like "GET" or "PUT"
+  # etc. See <http://tools.ietf.org/html/rfc2616#section-5.1.1>
+  public
+  def method=(method)
+    # RFC2616 5.1.1 doesn't say the method has to be uppercase.
+    # It can be any 'token' besides the ones defined in section 5.1.1:
+    # The grammar for 'token' is:
+    #          token          = 1*<any CHAR except CTLs or separators>
+    # TODO(sissel): support section 5.1.1 properly. Don't upcase, but 
+    # maybe upcase things that are defined in 5.1.1 like GET, etc.
+    @method = method.upcase
+  end # def method=
+
+  # Get the request line (first line of the http request)
+  # From the RFC: Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
+  #
+  # Note: I skip the trailing CRLF. See the to_s method where it is provided.
+  def request_line
+    return "#{method} #{request_uri} HTTP/#{version}"
+  end # def request_line
+
+  # Define the Message's start_line as request_line
+  alias_method :start_line, :request_line
+end # class FTW::Request < Message

data/lib/ftw/version.rb

@@ -0,0 +1,5 @@
+require "ftw/namespace"
+
+module FTW
+  VERSION = "0.0.1"
+end

data/lib/net-ftw.rb

@@ -0,0 +1 @@
+require "net/ftw"

data/lib/net/ftw.rb

@@ -0,0 +1,5 @@
+require "net/ftw/http/client"
+require "net/ftw/connection"
+require "net/ftw/dns"
+require "net/ftw/websocket"
+#require "net/ftw/spdy"

data/lib/net/ftw/agent.rb

@@ -0,0 +1,10 @@
+require "net/ftw/namespace"
+
+# Goal: Provide a nice way to sanely access web crap.
+#   * websockets
+#   * http
+#   * spdy
+#   * https
+class Net::FTW::UserAgent
+  
+end

data/lib/net/ftw/connection.rb

@@ -0,0 +1,296 @@
+require "cabin" # rubygem "cabin"
+require "net/ftw/dns"
+require "net/ftw/namespace"
+require "socket"
+require "timeout" # ruby stdlib, just for the Timeout exception.
+require "backport-bij" # for Array#rotate, IO::WaitWritable, etc, in ruby < 1.9
+
+# TODO(sissel): What's the API look like here?
+# EventMachine::Connection has these:
+#   * events: post_init (and connection_completed), receive_data, unbind
+#   * methods: send_data, close
+# Socket has
+#   * no events
+#   * methods: connect, read, write, close
+#
+# Actual events:
+#   * connected
+#   * disconnected(reason)
+#     * timeout, connection reset, connection refused, write error, read
+#        error, etc
+#   * data received
+#
+# Methods
+#   * send data
+#   * reconnect
+#   * get socket
+#   * disconnect
+#
+
+# A network connection. This is TCP.
+#
+# Example:
+#
+#     conn = Net::FTW::Connection.new("www.google.com:80")
+#     conn.on(CONNECTED) do |address| 
+#       puts "Connected to #{address} (#{conn.peer})"
+#       conn.write("GET / HTTP/1.0\r\n\r\n")
+#     end
+#     conn.on(DATA) do |data|
+#       puts data
+#     end
+#     conn.run
+#
+# You can use IO::select on this objects of this type.
+class Net::FTW::Connection
+
+  # Events
+  CONNECTED = :connected
+  DISCONNECTED = :disconnected
+  READER_CLOSED = :reader_closed
+  DATA = :data
+
+  # Disconnection reasons
+  TIMEOUT = :timeout
+  REFUSED = :refused
+  LOST = :lost
+  INTENTIONAL = :intentional
+
+  # A new network connection.
+  # The 'destination' argument can be an array of strings or a single string.
+  # String format is expected to be "host:port"
+  #
+  # Example:
+  #
+  #     conn = Net::FTW::Connection.new(["1.2.3.4:80", "1.2.3.5:80"])
+  #
+  # If you specify multiple destinations, they are used in a round-robin
+  # decision made during reconnection.
+  public
+  def initialize(destinations)
+    if destinations.is_a?(String)
+      @destinations = [destinations]
+    else
+      @destinations = destinations
+    end
+
+    # Handlers are key => array of callbacks
+    @handlers = Hash.new { |h,k| h[k] = [] }
+
+    on(CONNECTED) { |address| connected(address) }
+    on(DISCONNECTED) { |reason, error| disconnected(reason, error) }
+
+    @connect_timeout = 2
+
+    # Use a fixed-size string that we set to BINARY encoding.
+    # Not all byte sequences are UTF-8 friendly :0
+    @read_size = 16384
+    @read_buffer = " " * @read_size
+
+    # Tell Ruby 1.9 that this string is a binary string, not utf-8 or somesuch.
+    if @read_buffer.respond_to?(:force_encoding)
+      @read_buffer.force_encoding("BINARY")
+    end
+
+    # TODO(sissel): Validate @destinations
+  end # def initialize
+
+  # Register an event callback
+  # Valid events:
+  #
+  # * Net::FTW::Connection::CONNECTED - 1 argument, the host:port string connected to.
+  # * Net::FTW::Connection::DISCONNECTED - 2 arguments, the reason and the
+  #   exception (if any)
+  # * Net::FTW::Connection::DATA - 1 argument to block, the data read
+  #
+  # Disconnection reasons:
+  #   * :timeout
+  #   * :refused
+  #   * :closed
+  #   * :lost
+  public
+  def on(event, &block)
+    @handlers[event] << block
+  end # def on
+
+  # Trigger an event with arguments.
+  # All callbacks for the event will be invoked in the order they were
+  # registered. See the 'on' method for registering callbacks.
+  public
+  def trigger(event, *args)
+    @handlers[event].each do |block|
+      block.call(*args)
+    end
+  end # def trigger
+
+  public
+  def connect(timeout=nil)
+    # TODO(sissel): Raise if we're already connected?
+    close if connected?
+    host, port = @destinations.first.split(":")
+    @destinations = @destinations.rotate # round-robin
+
+    # Do dns resolution on the host. If there are multiple
+    # addresses resolved, return one at random.
+    @remote_address = Net::FTW::DNS.singleton.resolve_random(host)
+
+    family = @remote_address.include?(":") ? Socket::AF_INET6 : Socket::AF_INET
+    @socket = Socket.new(family, Socket::SOCK_STREAM, 0)
+    sockaddr = Socket.pack_sockaddr_in(port, @remote_address)
+    # TODO(sissel): Support local address binding
+
+    # Connect with timeout
+    begin
+      @socket.connect_nonblock(sockaddr)
+    rescue IO::WaitWritable
+      # Ruby actually raises Errno::EINPROGRESS, but for some reason
+      # the documentation says to use this IO::WaitWritable thing...
+      # I don't get it, but whatever :(
+      if writable?(timeout)
+        begin
+          @socket.connect_nonblock(sockaddr) # check connection failure
+        rescue Errno::EISCONN # Ignore, we're already connected.
+        rescue Errno::ECONNREFUSED => e
+          # Fire 'disconnected' event with reason :refused
+          trigger(DISCONNECTED, :refused, e)
+        end
+      else
+        # Connection timeout
+        # Fire 'disconnected' event with reason :timeout
+        trigger(DISCONNECTED, :connect_timeout, nil)
+      end
+    end
+
+    # We're now connected.
+    trigger(CONNECTED, "#{host}:#{port}")
+  end # def connect
+
+  # Is this Connection connected?
+  public
+  def connected?
+    return @connected
+  end # def connected?
+
+  # Write data to this connection.
+  # This method blocks until the write succeeds unless a timeout is given.
+  #
+  # Returns the number of bytes written (See IO#syswrite)
+  public
+  def write(data, timeout=nil)
+    #connect if !connected?
+    if writable?(timeout)
+      return @socket.syswrite(data)
+    else
+      raise Timeout::Error.new
+    end
+  end # def write
+
+  # Read data from this connection
+  # This method blocks until the read succeeds unless a timeout is given.
+  #
+  # This method is not guaranteed to read exactly 'length' bytes. See
+  # IO#sysread
+  public
+  def read(length, timeout=nil)
+    if readable?(timeout)
+      begin
+        @socket.sysread(length, @read_buffer)
+        return @read_buffer
+      rescue EOFError
+        trigger(READER_CLOSED)
+      end
+    else
+      raise Timeout::Error.new
+    end
+  end # def read
+
+  # End this connection
+  public
+  def disconnect(reason=INTENTIONAL)
+    begin 
+      #@reader_closed = true
+      @socket.close_read
+    rescue IOError => e
+      # Ignore
+    end
+
+    begin 
+      @socket.close_write
+    rescue IOError => e
+      # Ignore
+    end
+
+    trigger(DISCONNECTED, reason)
+  end # def disconnect
+
+  # Is this connection writable? Returns true if it is writable within
+  # the timeout period. False otherwise.
+  #
+  # The time out is in seconds. Fractional seconds are OK.
+  public
+  def writable?(timeout)
+    ready = IO.select(nil, [@socket], nil, timeout)
+    return !ready.nil?
+  end # def writable?
+
+  # Is this connection readable? Returns true if it is readable within
+  # the timeout period. False otherwise.
+  #
+  # The time out is in seconds. Fractional seconds are OK.
+  public
+  def readable?(timeout)
+    #return false if @reader_closed
+    ready = IO.select([@socket], nil, nil, timeout)
+    return !ready.nil?
+  end # def readable?
+
+  protected
+  def connected(address)
+    @remote_address = nil
+    @connected = true
+  end # def connected
+
+  protected
+  def disconnected(reason, error)
+    @remote_address = nil
+    @connected = false
+  end # def disconnected
+
+  # The host:port
+  public
+  def peer
+    return @remote_address
+  end # def peer
+
+  # Run this Connection.
+  # This is generally meant for Threaded or synchronous operation. 
+  # For EventMachine, see TODO(sissel): Implement EventMachine support.
+  public
+  def run
+    connect(@connect_timeout) if not connected?
+    while connected?
+      read_and_trigger
+    end
+  end # def run
+
+  # Read data and trigger data callbacks.
+  #
+  # This is mainly useful if you are implementing your own run loops
+  # and IO::select shenanigans.
+  public
+  def read_and_trigger
+    data = read(@read_size)
+    if data.length == 0
+      disconnect(EOFError)
+    else
+      trigger(DATA, data)
+    end
+  end # def read_and_trigger
+
+  # Support 'to_io' so you can use IO::select on this object.
+  public
+  def to_io
+    return @socket
+  end
+end # class Net::FTW::Connection
+