ftw 0.0.1

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

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

data/lib/net/ftw/machine.rb

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,139 @@
+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

data/test/net/ftw/crlf.rb

@@ -0,0 +1,12 @@
+require File.join(File.expand_path(__FILE__).sub(/\/net\/ftw\/.*/, "/testing"))
+require "net/ftw/crlf"
+
+describe Net::FTW::CRLF do
+  test "CRLF is as expected" do
+    class Foo
+      include Net::FTW::CRLF
+    end
+
+    assert_equal("\r\n", Foo::CRLF)
+  end
+end

data/test/net/ftw/http/dns.rb

@@ -0,0 +1,6 @@
+require File.join(File.expand_path(__FILE__).sub(/\/net\/ftw\/.*/, "/testing"))
+require "net/ftw/dns"
+
+describe Net::FTW::DNS do
+  # TODO(sissel): mock Socket.gethostbyname
+end

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

@@ -0,0 +1,50 @@
+require File.join(File.expand_path(__FILE__).sub(/\/net\/ftw\/.*/, "/testing"))
+require "net/ftw/http/headers"
+
+describe Net::FTW::HTTP::Headers do
+  before do
+    @headers = Net::FTW::HTTP::Headers.new
+  end
+
+  test "add adds" do
+    @headers.add("foo", "bar")
+    @headers.add("baz", "fizz")
+    assert_equal("fizz", @headers.get("baz"))
+    assert_equal("bar", @headers.get("foo"))
+  end
+
+  test "add dup field name makes an array" do
+    @headers.add("foo", "bar")
+    @headers.add("foo", "fizz")
+    assert_equal(["bar", "fizz"], @headers.get("foo"))
+  end
+
+  test "set replaces" do
+    @headers.add("foo", "bar")
+    @headers.set("foo", "hello")
+    assert_equal("hello", @headers.get("foo"))
+  end
+
+  test "remove field" do
+    @headers.add("foo", "one")
+    @headers.add("bar", "two")
+    assert_equal("one", @headers.get("foo"))
+    assert_equal("two", @headers.get("bar"))
+
+    @headers.remove("bar")
+    assert_equal("one", @headers.get("foo"))
+     # bar was removed, must not be present
+    assert(!@headers.include?("bar"))
+  end
+
+  test "remove field value" do
+    @headers.add("foo", "one")
+    @headers.add("foo", "two")
+    assert_equal(["one", "two"], @headers.get("foo"))
+
+    @headers.remove("foo", "three") # nothing to remove
+    assert_equal(["one", "two"], @headers.get("foo"))
+    @headers.remove("foo", "two")
+    assert_equal("one", @headers.get("foo"))
+  end
+end # describe Net::FTW::HTTP::Headers

data/test/testing.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+require "minitest/spec"
+require "minitest/autorun"
+
+# Add '../lib' to the require path.
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+# I don't really like monkeypatching, but whatever, this is probably better
+# than overriding the 'describe' method.
+class MiniTest::Spec
+  class << self
+    # 'it' sounds wrong, call it 'test'
+    alias :test :it
+  end
+end
+
+if __FILE__ == $0
+  glob = File.join(File.dirname(__FILE__), "net", "**", "*.rb")
+  Dir.glob(glob).each do |path|
+    puts "Loading tests from #{path}"
+    require File.expand_path(path)
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: ftw
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jordan Sissel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-08 00:00:00.000000000 Z
+dependencies: []
+description: Trying to build a solid and sane API for client and server web stuff.
+email:
+- jls@semicomplete.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ftw/agent.rb
+- lib/ftw/http/headers.rb
+- lib/ftw/http/message.rb
+- lib/ftw/connection.rb
+- lib/ftw/request.rb
+- lib/ftw/namespace.rb
+- lib/ftw/dns.rb
+- lib/ftw/crlf.rb
+- lib/ftw/version.rb
+- lib/net/ftw/protocol/tls.rb
+- lib/net/ftw/connection2.rb
+- lib/net/ftw/agent.rb
+- lib/net/ftw/machine.rb
+- lib/net/ftw/http/headers.rb
+- lib/net/ftw/http/machine.rb
+- lib/net/ftw/http/server.rb
+- lib/net/ftw/http/client2.rb
+- lib/net/ftw/http/message.rb
+- lib/net/ftw/http/connection.rb
+- lib/net/ftw/http/request.rb
+- lib/net/ftw/http/response.rb
+- lib/net/ftw/http/client.rb
+- lib/net/ftw/connection.rb
+- lib/net/ftw/namespace.rb
+- lib/net/ftw/dns.rb
+- lib/net/ftw/websocket.rb
+- lib/net/ftw/http.rb
+- lib/net/ftw/crlf.rb
+- lib/net/ftw.rb
+- lib/net-ftw.rb
+- test/testing.rb
+- test/net/ftw/http/headers.rb
+- test/net/ftw/http/dns.rb
+- test/net/ftw/crlf.rb
+- README.md
+homepage: http://github.com/jordansissel/ruby-ftw
+licenses:
+- Apache License (2.0)
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: For The Web. HTTP, WebSockets, SPDY, etc.
+test_files: []