ftw 0.0.1 → 0.0.4

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

@@ -1,91 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/http/headers"
-
-# HTTP Message, RFC2616
-class Net::FTW::HTTP::Message
-  include Net::FTW::CRLF
-
-  # The HTTP headers. See Net::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 = Net::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 Net::FTW::HTTP::Message

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

@@ -1,80 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/http/message"
-require "addressable/uri" # gem addressable
-require "uri" # ruby stdlib
-require "http/parser" # gem http_parser.rb
-
-# An HTTP Request.
-#
-# See RFC2616 section 5: <http://tools.ietf.org/html/rfc2616#section-5>
-class Net::FTW::HTTP::Request < Net::FTW::HTTP::Message
-  include Net::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
-
-  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
-  # 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
-end # class Net::FTW::HTTP::Request < Message

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

@@ -1,80 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/http/message"
-require "http/parser" # gem http_parser.rb
-
-class Net::FTW::HTTP::Response < Net::FTW::HTTP::Message
-  # The HTTP version number
-  # See RFC2616 section 6.1: <http://tools.ietf.org/html/rfc2616#section-6.1>
-  attr_reader :version
-
-  # The http status code (RFC2616 6.1.1)
-  # See RFC2616 section 6.1.1: <http://tools.ietf.org/html/rfc2616#section-6.1.1>
-  attr_reader :status
-
-  # The reason phrase (RFC2616 6.1.1)
-  # See RFC2616 section 6.1.1: <http://tools.ietf.org/html/rfc2616#section-6.1.1>
-  attr_reader :reason
-
-  # Translated from the recommendations listed in RFC2616 section 6.1.1
-  # See RFC2616 section 6.1.1: <http://tools.ietf.org/html/rfc2616#section-6.1.1>
-  STATUS_REASON_MAP =  {
-    100 => "Continue",
-    101 => "Switching Protocols",
-    200 => "OK",
-    201 => "Created",
-    202 => "Accepted",
-    203 => "Non-Authoritative Information",
-    204 => "No Content",
-    205 => "Reset Content",
-    206 => "Partial Content",
-    300 => "Multiple Choices",
-    301 => "Moved Permanently",
-    302 => "Found",
-    303 => "See Other",
-    304 => "Not Modified",
-    305 => "Use Proxy",
-    307 => "Temporary Redirect",
-    400 => "Bad Request",
-    401 => "Unauthorized",
-    402 => "Payment Required",
-    403 => "Forbidden",
-    404 => "Not Found",
-    405 => "Method Not Allowed",
-    406 => "Not Acceptable"
-  } # STATUS_REASON_MAP
-
-  public
-  def initialize
-    super
-    @reason = "" # Empty reason string by default. It is not required.
-  end # def initialize
-
-  # Set the status code
-  public
-  def status=(code)
-    code = code.to_i if !code.is_a?(Fixnum)
-    # TODO(sissel): Validate that 'code' is a 3 digit number
-    @status = code
-
-    # Attempt to set the reason if the status code has a known reason
-    # recommendation. If one is not found, default to the current reason.
-    @reason = STATUS_REASON_MAP.fetch(@status, @reason)
-  end # def status=
-
-  # Get the status-line string, like "HTTP/1.0 200 OK"
-  public
-  def status_line
-    # First line is 'Status-Line' from RFC2616 section 6.1
-    # Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
-    # etc...
-    return "HTTP-#{version} #{status} #{reason}"
-  end # def status_line
-
-  # Define the Message's start_line as status_line
-  alias_method :start_line, :status_line
-
-  # 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
-end # class Net::FTW::HTTP::Response
-

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

@@ -1,5 +0,0 @@
-require "net/ftw/namespace"
-
-# TODO(sissel): Implement
-class Net::FTW::HTTP::Server
-end # class Net::FTW::HTTP::Server

data/lib/net/ftw/machine.rb

@@ -1,59 +0,0 @@
-require "net/ftw/namespace"
-
-# Protocol state machine
-class Net::FTW::Machine
-  class InvalidTransition < StandardError
-    public
-    def initialize(instance, current_state, next_state)
-      @instance = instance
-      @current_state = current_state
-      @next_state = next_state
-    end
-
-    public
-    def to_s
-      return "Invalid transition: #{@current_state} => #{@next_state} on object: #{instance}"
-    end
-  end # class InvalidTransition
-
-  # Always the first state.
-  START = :start
-  ERROR = :error
-
-  public
-  def initialize
-    @state = START
-  end # def initialize
-
-  # Feed data input into this machine
-  public
-  def feed(input)
-    # Invoke whatever method of state we are in when we have data.
-    # like state_headers(input), etc
-    method("state_#{@state}")(input)
-  end # def feed
-
-  public
-  def state?(state)
-    return @state == state
-  end # def state?
-
-  public
-  def transition(new_state)
-    if valid_transition?(new_state)
-      @state = new_state
-    else
-      raise InvalidTransition.new(@state, new_state, self.class)
-    end
-  end # def transition
-
-  public
-  def valid_transition?(new_state)
-    allowed = TRANSITIONS[@state]
-    if allowed.is_a?(Array)
-      return allowed.include?(new_state)
-    else
-      return allowed == new_state
-    end
-  end # def valid_transition
-end # class Net:FTW::Machine

data/lib/net/ftw/namespace.rb

@@ -1,6 +0,0 @@
-module Net
-  module FTW
-    module HTTP; end # Net::FTW::HTTP
-    module Protocol; end # Net::FTW::Protocol
-  end # Net::FTW
-end # Net

data/lib/net/ftw/protocol/tls.rb

@@ -1,12 +0,0 @@
-require "net/ftw/namespace"
-require "openssl"
-
-class Net::FTW::Protocol::TLS
-  def read
-    # Do TLS read
-  end
-
-  def write
-    # Do TLS write
-  end
-end

data/lib/net/ftw/websocket.rb

@@ -1,139 +0,0 @@
-require "net/ftw/namespace"
-require "net/ftw/http/request"
-require "net/ftw/http/response"
-require "openssl"
-require "base64" # stdlib 
-require "digest/sha1" # stdlib
-
-# WebSockets, RFC6455.
-#
-# TODO(sissel): Find a comfortable way to make this websocket stuff 
-# both use HTTP::Connection for the HTTP handshake and also be usable
-# from HTTP::Client
-# TODO(sissel): Also consider SPDY and the kittens.
-class Net::FTW::WebSocket
-  include Net::FTW::CRLF
-
-  WEBSOCKET_ACCEPT_UUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-
-  # Protocol phases
-  # 1. tcp connect
-  # 2. http handshake (RFC6455 section 4)
-  # 3. websocket protocol
-
-  def initialize(uri)
-    uri = Addressable::URI.parse(uri.to_s) if [URI, String].include?(uri.class)
-    uri.port ||= 80
-    @uri = uri
-
-    @connection = Net::FTW::HTTP::Connection.new("#{@uri.host}:#{@uri.port}")
-    @key_nonce = generate_key_nonce
-    prepare
-  end # def initialize
-
-  private
-  def prepare
-    request = Net::FTW::HTTP::Request.new(@uri)
-    response = Net::FTW::HTTP::Response.new
-
-    # RFC6455 section 4.1:
-    #  "2.   The method of the request MUST be GET, and the HTTP version MUST
-    #        be at least 1.1."
-    request.method = "GET"
-    request.version = 1.1
-
-    # RFC6455 section 4.2.1 bullet 3
-    request.headers.set("Upgrade", "websocket") 
-    # RFC6455 section 4.2.1 bullet 4
-    request.headers.set("Connection", "Upgrade") 
-    # RFC6455 section 4.2.1 bullet 5
-    request.headers.set("Sec-WebSocket-Key", @key_nonce)
-    # RFC6455 section 4.2.1 bullet 6
-    request.headers.set("Sec-WebSocket-Version", 13)
-    # RFC6455 section 4.2.1 bullet 7 (optional)
-    # The Origin header is optional for non-browser clients.
-    #request.headers.set("Origin", ...)
-    # RFC6455 section 4.2.1 bullet 8 (optional)
-    #request.headers.set("Sec-Websocket-Protocol", ...)
-    # RFC6455 section 4.2.1 bullet 9 (optional)
-    #request.headers.set("Sec-Websocket-Extensions", ...)
-    # RFC6455 section 4.2.1 bullet 10 (optional)
-    # TODO(sissel): Any other headers like cookies, auth headers, are allowed.
-
-    # TODO(sissel): This is starting to feel like not the best way to implement
-    # protocols.
-    @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|
-      puts :HEADERS
-      response.status = status
-      response.version = version
-      headers.each { |field, value| response.headers.add(field, value) }
-
-      # TODO(sissel): Respect redirects
-
-      if websocket_handshake_ok?(request, response)
-        @connection.on(@connection.class::MESSAGE_BODY) do |data|
-          websocket_read(data)
-        end
-      elsif response.status == 101
-        # WebSocket handshake failed. Bad headers or bad hash?
-        @connection.disconnect("Invalid WebSocket handshake response")
-      else
-        # Handle this http response normally, don't switch protocols
-        # Maybe this is a 302 redirect or something else
-        # TODO(sissel): handle the response normally
-        puts "Non-websocket response"
-        puts response.to_s
-        @connection.on(@connection.class::MESSAGE_BODY) do |data|
-          puts data
-        end
-      end
-    end # @connection.on HEADERS_COMPLETE
-    @connection.run
-  end # def prepare
-
-  def websocket_read(data)
-    p :data => data
-  end # def websocket_read
-
-  private
-  def generate_key_nonce
-    # RFC6455 section 4.1 says:
-    # ---
-    # 7.   The request MUST include a header field with the name
-    #      |Sec-WebSocket-Key|.  The value of this header field MUST be a
-    #      nonce consisting of a randomly selected 16-byte value that has
-    #      been base64-encoded (see Section 4 of [RFC4648]).  The nonce
-    #      MUST be selected randomly for each connection.
-    # ---
-    #
-    # It's not totally clear to me how cryptographically strong this random
-    # nonce needs to be, and if it does not need to be strong and it would
-    # benefit users who do not have ruby with openssl enabled, maybe just use
-    # rand() to generate this string.
-    #
-    # Thus, generate a random 16 byte string and encode i with base64.
-    # Array#pack("m") packs with base64 encoding.
-    return Base64.strict_encode64(OpenSSL::Random.random_bytes(16))
-  end # def generate_key_nonce
-
-  private
-  def websocket_handshake_ok?(request, response)
-    # See RFC6455 section 4.2.2
-    return false unless response.status == 101 # "Switching Protocols"
-    return false unless response.headers.get("upgrade") == "websocket"
-    return false unless response.headers.get("connection") == "Upgrade"
-
-    # Now verify Sec-WebSocket-Accept. It should be the SHA-1 of the
-    # Sec-WebSocket-Key (in base64) + WEBSOCKET_ACCEPT_UUID
-    expected = request.headers.get("Sec-WebSocket-Key") + WEBSOCKET_ACCEPT_UUID
-    expected_hash = Digest::SHA1.base64digest(expected)
-    return false unless response.headers.get("Sec-WebSocket-Accept") == expected_hash
-
-    return true
-  end # def websocket_handshake_ok
-
-end # class Net::FTW::WebSocket