reel 0.1.0 → 0.2.0.pre

data/lib/reel/rack_worker.rb

@@ -0,0 +1,90 @@
+module Reel
+  class RackWorker
+    include Celluloid
+
+    PROTO_RACK_ENV = {
+      "rack.version".freeze      => Rack::VERSION,
+      "rack.errors".freeze       => STDERR,
+      "rack.multithread".freeze  => true,
+      "rack.multiprocess".freeze => false,
+      "rack.run_once".freeze     => false,
+      "rack.url_scheme".freeze   => "http",
+      "SCRIPT_NAME".freeze       => ENV['SCRIPT_NAME'] || "",
+      "SERVER_PROTOCOL".freeze   => "HTTP/1.1",
+      "SERVER_SOFTWARE".freeze   => "Reel/#{Reel::VERSION}",
+      "GATEWAY_INTERFACE".freeze => "CGI/1.1"
+    }.freeze
+
+    def initialize(handler)
+      @handler, @app = handler, handler.rack_app
+    end
+
+    def handle(connection)
+      while request = connection.request
+        begin
+          env = rack_env(request, connection)
+          status, headers, body_parts = @handler.rack_app.call(env)
+
+          body = if body_parts.respond_to?(:to_path)
+            File.new(body_parts.to_path)
+          else
+            body_text = ""
+            body_parts.each { |part| body_text += part }
+            body_text
+          end
+
+          connection.respond Response.new(status, headers, body)
+        ensure
+          body.close if body.respond_to?(:close)
+          body_parts.close if body_parts.respond_to?(:close)
+        end
+      end
+    end
+
+    def rack_env(request, connection)
+      env = PROTO_RACK_ENV.dup
+
+      env["SERVER_NAME"] = @handler[:host]
+      env["SERVER_PORT"] = @handler[:port]
+
+      peer_address = connection.peer_address
+
+      env["REMOTE_ADDR"] = peer_address[3]
+      env["REMOTE_HOST"] = peer_address[2]
+
+      env["PATH_INFO"]   = request.path
+      env["REQUEST_METHOD"] = request.method.to_s.upcase
+
+      body = request.body || ""
+
+      rack_input = StringIO.new(body)
+      rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+      env["rack.input"]  = rack_input
+      env["rack.logger"] = @app if Rack::CommonLogger === @app
+
+      env["REQUEST_PATH"]      = request.path
+      env["ORIGINAL_FULLPATH"] = request.path
+
+      query_string = request.query_string || ""
+      query_string += "##{request.fragment}" if request.fragment
+
+      env["QUERY_STRING"] = query_string
+
+      request.headers.each{|key, val|
+        next if /^content-type$/i =~ key
+        next if /^content-length$/i =~ key
+        name = "HTTP_" + key
+        name.gsub!(/-/o, "_")
+        name.upcase!
+        env[name] = val
+      }
+
+      host = env['HTTP_HOST'] || env["SERVER_NAME"]
+
+      env["REQUEST_URI"] = "#{env['rack.url_scheme']}://#{host}#{request.path}"
+
+      env
+    end
+  end
+end

data/lib/reel/request.rb

@@ -1,23 +1,61 @@
+require 'uri'
+
 module Reel
   class Request
     attr_accessor :method, :version, :url, :headers
-    METHODS = [:get, :head, :post, :put, :delete, :trace, :options, :connect, :patch]
-    
+
+    def self.read(connection)
+      parser = connection.parser
+
+      begin
+        data = connection.socket.readpartial(Connection::BUFFER_SIZE)
+        parser << data
+      end until parser.headers
+
+      headers = {}
+      parser.headers.each do |field, value|
+        headers[Http.canonicalize_header(field)] = value
+      end
+
+      upgrade = headers['Upgrade']
+      if upgrade && upgrade.downcase == 'websocket'
+        WebSocket.new(connection.socket, parser.url, headers)
+      else
+        Request.new(parser.http_method, parser.url, parser.http_version, headers, connection)
+      end
+    end
+
     def initialize(method, url, version = "1.1", headers = {}, connection = nil)
       @method = method.to_s.downcase.to_sym
-      raise UnsupportedArgumentError, "unknown method: #{method}" unless METHODS.include? @method
-      
+      raise UnsupportedArgumentError, "unknown method: #{method}" unless Http::METHODS.include? @method
+
       @url, @version, @headers, @connection = url, version, headers, connection
     end
-    
+
     def [](header)
       @headers[header]
     end
-    
+
+    def uri
+      @uri ||= URI(url)
+    end
+
+    def path
+      uri.path
+    end
+
+    def query_string
+      uri.query
+    end
+
+    def fragment
+      uri.fragment
+    end
+
     def body
       @body ||= begin
         raise "no connection given" unless @connection
-        
+
         body = "" unless block_given?
         while (chunk = @connection.readpartial)
           if block_given?
@@ -30,4 +68,4 @@ module Reel
       end
     end
   end
-end
+end

data/lib/reel/response.rb

@@ -36,7 +36,7 @@ module Reel
       when Enumerable
         @headers['Transfer-Encoding'] ||= 'chunked'
       when NilClass
-      else raise ArgumentError, "can't render #{@body.class} as a response body"
+      else raise TypeError, "can't render #{@body.class} as a response body"
       end
 
       # Prevent modification through the accessor
@@ -71,9 +71,13 @@ module Reel
       when String
         socket << @body
       when IO
-        # TODO: IO.copy_stream when it works cross-platform
-        while data = @body.read(4096)
-          socket << data
+        if !defined?(JRUBY_VERSION)
+          IO.copy_stream(@body, socket)
+        else
+          # JRuby 1.6.7 doesn't support IO.copy_stream :(
+          while data = @body.read(4096)
+            socket << data
+          end
         end
       when Enumerable
         @body.each do |chunk|

data/lib/reel/server.rb

@@ -20,12 +20,15 @@ module Reel
     def handle_connection(socket)
       connection = Connection.new(socket)
       begin
-        connection.read_request
         @callback[connection]
-      end while connection.alive?
-    rescue EOFError
+      ensure
+        if connection.attached?
+          connection.close rescue nil
+        end
+      end
+    rescue RequestError, EOFError
       # Client disconnected prematurely
-      # FIXME: should probably do something here
+      # TODO: log this?
     end
   end
 end

data/lib/reel/version.rb

@@ -1,3 +1,3 @@
 module Reel
-  VERSION = "0.1.0"
+  VERSION = "0.2.0.pre"
 end

data/lib/reel/websocket.rb

@@ -0,0 +1,64 @@
+require 'websocket_parser'
+
+module Reel
+  class WebSocket
+    attr_reader :url, :headers
+
+    def initialize(socket, url, headers)
+      @socket, @url, @headers = socket, url, headers
+
+      handshake = ::WebSocket::ClientHandshake.new(:get, url, headers)
+
+      if handshake.valid?
+        response = handshake.accept_response
+        response.render(socket)
+      else
+        error = handshake.errors.first
+
+        response = Response.new(400)
+        response.reason = handshake.errors.first
+        response.render(@socket)
+
+        raise HandshakeError, "error during handshake: #{error}"
+      end
+
+      @parser = ::WebSocket::Parser.new
+
+      @parser.on_close do |status, reason|
+        # According to the spec the server must respond with another
+        # close message before closing the connection
+        @socket << ::WebSocket::Message.close.to_data
+        close
+      end
+
+      @parser.on_ping do
+        @socket << ::WebSocket::Message.pong.to_data
+      end
+    end
+
+    def [](header)
+      @headers[header]
+    end
+
+    def read
+      @parser.append @socket.readpartial(Connection::BUFFER_SIZE) until msg = @parser.next_message
+      msg
+    end
+
+    def write(msg)
+      @socket << ::WebSocket::Message.new(msg).to_data
+      msg
+    rescue Errno::EPIPE
+      raise SocketError, "error writing to socket"
+    end
+    alias_method :<<, :write
+
+    def closed?
+      @socket.closed?
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/reel.gemspec

@@ -14,11 +14,13 @@ Gem::Specification.new do |gem|
   gem.name          = "reel"
   gem.require_paths = ["lib"]
   gem.version       = Reel::VERSION
-  
-  gem.add_dependency 'celluloid-io',   '>= 0.8.0'
-  gem.add_dependency 'http',           '>= 0.2.0'
-  gem.add_dependency 'http_parser.rb', '>= 0.5.3'
-  
+
+  gem.add_runtime_dependency 'celluloid-io',     '>= 0.8.0'
+  gem.add_runtime_dependency 'http',             '>= 0.2.0'
+  gem.add_runtime_dependency 'http_parser.rb',   '>= 0.5.3'
+  gem.add_runtime_dependency 'websocket_parser', '>= 0.1.0'
+  gem.add_runtime_dependency 'rack',             '>= 1.4.0'
+
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
 end

data/spec/reel/connection_spec.rb

@@ -6,7 +6,7 @@ describe Reel::Connection do
   it "reads requests without bodies" do
     with_socket_pair do |client, connection|
       client << ExampleRequest.new.to_s
-      request = connection.read_request
+      request = connection.request
 
       request.url.should     eq "/"
       request.version.should eq "1.1"
@@ -28,7 +28,7 @@ describe Reel::Connection do
       example_request.body = body
 
       client << example_request.to_s
-      request = connection.read_request
+      request = connection.request
 
       request.url.should     eq "/"
       request.version.should eq "1.1"
@@ -40,14 +40,15 @@ describe Reel::Connection do
   it "serves static files" do
     with_socket_pair do |client, connection|
       client << ExampleRequest.new.to_s
-      request = connection.read_request
+      request = connection.request
 
       fixture_text = File.read(fixture_path)
       File.open(fixture_path) do |file|
         connection.respond :ok, file
+        connection.close
       end
 
-      response = client.readpartial(4096)
+      response = client.read(4096)
       response[(response.length - fixture_text.length)..-1].should eq fixture_text
     end
   end
@@ -55,7 +56,7 @@ describe Reel::Connection do
   it "streams responses when transfer-encoding is chunked" do
     with_socket_pair do |client, connection|
       client << ExampleRequest.new.to_s
-      request = connection.read_request
+      request = connection.request
 
       # Sending transfer_encoding chunked without a body enables streaming mode
       connection.respond :ok, :transfer_encoding => :chunked
@@ -81,20 +82,16 @@ describe Reel::Connection do
     end
   end
 
-  def with_socket_pair
-    host = '127.0.0.1'
-    port = 10103
+  it "reset the request after a response is sent" do
+    with_socket_pair do |client, connection|
+      example_request = ExampleRequest.new(:get, "/", "1.1", {'Connection' => 'close'})
+      client << example_request
+
+      connection.request.should_not be_false
 
-    server = TCPServer.new(host, port)
-    client = TCPSocket.new(host, port)
-    peer   = server.accept
+      connection.respond :ok, "Response sent"
 
-    begin
-      yield client, Reel::Connection.new(peer)
-    ensure
-      server.close rescue nil
-      client.close rescue nil
-      peer.close   rescue nil
+      connection.request.should be_false
     end
   end
 end

data/spec/reel/rack_worker_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Reel::RackWorker do
+
+  let(:endpoint) { URI("http://#{example_addr}:#{example_port}#{example_url}") }
+
+  let(:worker) do
+    app = Proc.new do |env|
+      [200, {'Content-Type' => 'text/plain'}, ['Hello world!']]
+      [200, {'Content-Type' => 'text/plain'}, ['Hello rack world!']]
+    end
+
+    handler = Rack::Handler::Reel.new
+    handler.options[:app] = app
+
+    Reel::RackWorker.new(handler)
+  end
+
+  it "creates a rack env from a request" do
+    with_socket_pair do |client, connection|
+      client << ExampleRequest.new(:get, '/test?hello=true').to_s
+      request = connection.request
+      env = worker.rack_env(request, connection)
+
+      Reel::RackWorker::PROTO_RACK_ENV.each do |k, v|
+        env[k].should == v
+      end
+
+      env["SERVER_NAME"].should == '0.0.0.0'
+      env["SERVER_PORT"].should == 3000
+      env["REMOTE_ADDR"].should == "127.0.0.1"
+      env["REMOTE_HOST"].should == "127.0.0.1"
+      env["PATH_INFO"].should == "/test"
+      env["REQUEST_METHOD"].should == "GET"
+      env["REQUEST_PATH"].should == "/test"
+      env["ORIGINAL_FULLPATH"].should == "/test"
+      env["QUERY_STRING"].should == "hello=true"
+      env["HTTP_HOST"].should == 'www.example.com'
+      env["HTTP_ACCEPT_LANGUAGE"].should == "en-US,en;q=0.8"
+      env["REQUEST_URI"].should == 'http://www.example.com/test'
+
+      env["rack.input"].should be_kind_of(StringIO)
+      env["rack.input"].string.should == ''
+    end
+  end
+
+  it "delegates web requests to the rack app" do
+    ex = nil
+
+    handler = proc do |connection|
+      begin
+        worker.handle!(connection.detach)
+      rescue => ex
+      end
+    end
+
+    with_reel(handler) do
+      http = Net::HTTP.new(endpoint.host, endpoint.port)
+      request = Net::HTTP::Get.new(endpoint.request_uri)
+      response = http.request(request)
+      response.should be_a Net::HTTPOK
+      response.body.should == 'Hello rack world!'
+    end
+
+    raise ex if ex
+  end
+end

data/spec/reel/response_spec.rb

@@ -4,31 +4,15 @@ describe Reel::Response do
   it "streams enumerables" do
     with_socket_pair do |client, connection|
       client << ExampleRequest.new.to_s
-      request = connection.read_request
+      request = connection.request
 
       connection.respond Reel::Response.new(:ok, ["Hello", "World"])
+      connection.close
 
-      response = client.readpartial(4096)
+      response = client.read(4096)
       crlf = "\r\n"
       fixture = "5#{crlf}Hello5#{crlf}World0#{crlf*2}"
       response[(response.length - fixture.length)..-1].should eq fixture
     end
   end
-
-  def with_socket_pair
-    host = '127.0.0.1'
-    port = 10103
-
-    server = TCPServer.new(host, port)
-    client = TCPSocket.new(host, port)
-    peer   = server.accept
-
-    begin
-      yield client, Reel::Connection.new(peer)
-    ensure
-      server.close
-      client.close
-      peer.close
-    end
-  end
 end