reel 0.2.0 → 0.3.0.pre

data/lib/reel/rack_worker.rb

@@ -1,18 +1,57 @@
 module Reel
   class RackWorker
     include Celluloid
+    include Celluloid::Logger
+
+    INITIAL_BODY = ''
+
+    # Freeze some HTTP header names & values
+    CONTENT_TYPE_ORIG   = 'Content-Type'.freeze
+    CONTENT_LENGTH_ORIG = 'Content-Length'.freeze
+    CONTENT_TYPE        = 'CONTENT_TYPE'.freeze
+    CONTENT_LENGTH      = 'CONTENT_LENGTH'.freeze
+
+    SERVER_SOFTWARE     = 'SERVER_SOFTWARE'.freeze
+    SERVER_NAME         = 'SERVER_NAME'.freeze
+    SERVER_PORT         = 'SERVER_PORT'.freeze
+    SERVER_PROTOCOL     = 'SERVER_PROTOCOL'.freeze
+    GATEWAY_INTERFACE   = "GATEWAY_INTERFACE".freeze
+    LOCALHOST           = 'localhost'.freeze
+    HTTP_VERSION        = 'HTTP_VERSION'.freeze
+    CGI_1_1             = 'CGI/1.1'.freeze
+    REMOTE_ADDR         = 'REMOTE_ADDR'.freeze
+    CONNECTION          = 'HTTP_CONNECTION'.freeze
+    SCRIPT_NAME         = 'SCRIPT_NAME'.freeze
+    PATH_INFO           = 'PATH_INFO'.freeze
+    REQUEST_METHOD      = 'REQUEST_METHOD'.freeze
+    QUERY_STRING        = 'QUERY_STRING'.freeze
+    HTTP_1_0            = 'HTTP/1.0'.freeze
+    HTTP_1_1            = 'HTTP/1.1'.freeze
+    HTTP_               = 'HTTP_'.freeze
+    HOST                = 'Host'.freeze
+    
+    # Freeze some Rack header names
+    RACK_INPUT          = 'rack.input'.freeze
+    RACK_LOGGER         = 'rack.logger'.freeze
+    RACK_VERSION        = 'rack.version'.freeze
+    RACK_ERRORS         = 'rack.errors'.freeze
+    RACK_MULTITHREAD    = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS   = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE       = 'rack.run_once'.freeze
+    RACK_URL_SCHEME     = 'rack.url_scheme'.freeze
+    RACK_WEBSOCKET      = 'rack.websocket'.freeze
 
     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"
+      RACK_VERSION      => ::Rack::VERSION,
+      RACK_ERRORS       => STDERR,
+      RACK_MULTITHREAD  => true,
+      RACK_MULTIPROCESS => false,
+      RACK_RUN_ONCE     => false,
+      RACK_URL_SCHEME   => "http".freeze,
+      SCRIPT_NAME       => ENV[SCRIPT_NAME] || "",
+      SERVER_PROTOCOL   => HTTP_1_1,
+      SERVER_SOFTWARE   => "Reel/#{Reel::VERSION}".freeze,
+      GATEWAY_INTERFACE => CGI_1_1
     }.freeze
 
     def initialize(handler)
@@ -21,67 +60,72 @@ module Reel
 
     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)
+        case request
+        when Request
+          handle_request(request, connection)
+        when WebSocket
+          handle_websocket(request, connection)
         end
       end
     end
 
-    def rack_env(request, connection)
-      env = PROTO_RACK_ENV.dup
-
-      env["SERVER_NAME"] = @handler[:host]
-      env["SERVER_PORT"] = @handler[:port]
-
-      env["REMOTE_ADDR"] = connection.remote_ip
-      env["REMOTE_HOST"] = connection.remote_host
-
-      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)
+    def handle_request(request, connection)
+      status, headers, body_parts = @app.call(request_env(request, connection))
+      body, is_stream = response_body(body_parts)
+      connection.respond (is_stream ? StreamResponse : Response).new(status, headers, body)
+    end
 
-      env["rack.input"]  = rack_input
-      env["rack.logger"] = @app if Rack::CommonLogger === @app
+    def handle_websocket(request, connection)
+      status, *rest = @app.call(websocket_env(request))
+      request.close unless status < 300
+    end
 
-      env["REQUEST_PATH"]      = request.path
-      env["ORIGINAL_FULLPATH"] = request.path
+    def request_env request, connection
+      env = env(request)
+      env[REMOTE_ADDR] = connection.remote_ip
+      env
+    end
 
-      query_string = request.query_string || ""
-      query_string += "##{request.fragment}" if request.fragment
+    def websocket_env request
+      env = env(request)
+      env[REMOTE_ADDR]    = request.remote_ip
+      env[RACK_WEBSOCKET] = request
+      env
+    end
 
-      env["QUERY_STRING"] = query_string
+    def response_body(body_parts)
+      if body_parts.respond_to?(:to_path)
+        ::File.new(body_parts.to_path)
+      else
+        body = ''
+        body_parts.each do |c|
+          return [c, true] if c.is_a?(Reel::Stream)
+          body << c
+        end
+        body_parts.close if body_parts.respond_to?(:close)
+        body
+      end
+    end
 
-      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
-      }
+    private
+    def env request
+      env = Hash[PROTO_RACK_ENV]
 
-      host = env['HTTP_HOST'] || env["SERVER_NAME"]
+      env[RACK_INPUT] = StringIO.new(request.body || INITIAL_BODY)
+      env[RACK_INPUT].set_encoding(Encoding::BINARY) if env[RACK_INPUT].respond_to?(:set_encoding)
+      env[SERVER_NAME], env[SERVER_PORT] = (request[HOST]||'').split(':', 2)
+      env[SERVER_PORT] ||= @handler[:port].to_s
+      env[HTTP_VERSION]   = request.version || env[SERVER_PROTOCOL]
+      env[REQUEST_METHOD] = request.method
+      env[PATH_INFO]      = request.path
+      env[QUERY_STRING]   = request.query_string || ''
 
-      env["REQUEST_URI"] = "#{env['rack.url_scheme']}://#{host}#{request.path}"
+      (_ = request.headers.delete CONTENT_TYPE_ORIG) && (env[CONTENT_TYPE] = _)
+      (_ = request.headers.delete CONTENT_LENGTH_ORIG) && (env[CONTENT_LENGTH] = _)
 
+      request.headers.each_pair do |key, val|
+        env[HTTP_ + key.gsub('-', '_').upcase] = val
+      end
       env
     end
   end

data/lib/reel/request.rb

@@ -1,8 +1,16 @@
-require 'uri'
+require 'forwardable'
 
 module Reel
   class Request
-    attr_accessor :method, :version, :url, :headers
+    extend Forwardable
+    include RequestMixin
+
+    UPGRADE   = 'Upgrade'.freeze
+    WEBSOCKET = 'websocket'.freeze
+
+    # Array#include? seems slow compared to Hash lookup
+    request_methods = Http::METHODS.map { |m| m.to_s.upcase }
+    REQUEST_METHODS = Hash[request_methods.zip(request_methods)].freeze
 
     def self.read(connection)
       parser = connection.parser
@@ -12,44 +20,21 @@ module Reel
         parser << data
       end until parser.headers
 
-      headers = {}
-      parser.headers.each do |field, value|
-        headers[Http.canonicalize_header(field)] = value
-      end
+      REQUEST_METHODS[parser.http_method] ||
+        raise(ArgumentError, "Unknown Request Method: %s" % parser.http_method)
 
-      upgrade = headers['Upgrade']
-      if upgrade && upgrade.downcase == 'websocket'
-        WebSocket.new(connection.socket, parser.url, headers)
+      upgrade = parser.headers[UPGRADE]
+      if upgrade && upgrade.downcase == WEBSOCKET
+        WebSocket.new(parser, connection.socket)
       else
-        Request.new(parser.http_method, parser.url, parser.http_version, headers, connection)
+        Request.new(parser, 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 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_delegators :@connection, :respond, :finish_response, :close, :read
 
-    def fragment
-      uri.fragment
+    def initialize(http_parser, connection = nil)
+      @http_parser, @connection = http_parser, connection
     end
 
     def body

data/lib/reel/request_parser.rb

@@ -1,6 +1,7 @@
 module Reel
   class Request
     class Parser
+      include HTTPVersionsMixin
       attr_reader :headers
 
       def initialize
@@ -8,6 +9,12 @@ module Reel
         reset
       end
 
+      [:request_path, :query_string].each do |m|
+        define_method m do
+          @parser.send m
+        end
+      end
+
       def add(data)
         @parser << data
       end
@@ -18,17 +25,20 @@ module Reel
       end
 
       def http_method
-        @parser.http_method.downcase.to_sym
+        @parser.http_method
       end
 
       def http_version
-        @parser.http_version.join(".")
+        # TODO: add extra HTTP_VERSION handler when HTTP/1.2 released
+        @parser.http_version[1] == 1 ? HTTP_VERSION_1_1 : HTTP_VERSION_1_0
       end
 
       def url
         @parser.request_url
       end
 
+      def finished?; @finished; end
+
       #
       # Http::Parser callbacks
       #

data/lib/reel/response.rb

@@ -1,5 +1,10 @@
 module Reel
   class Response
+
+    CONTENT_LENGTH     = 'Content-Length'.freeze
+    TRANSFER_ENCODING  = 'Transfer-Encoding'.freeze
+    CHUNKED            = 'chunked'.freeze
+
     # Use status code tables from the Http gem
     STATUS_CODES          = Http::Response::STATUS_CODES
     SYMBOL_TO_STATUS_CODE = Http::Response::SYMBOL_TO_STATUS_CODE
@@ -20,30 +25,19 @@ module Reel
         @body = body_or_headers
       end
 
-      @headers = {}
-      headers.each do |name, value|
-        name = name.to_s
-        key = name[Http::CANONICAL_HEADER]
-        key ||= canonicalize_header(name)
-        @headers[key] = value.to_s
-      end
-
       case @body
       when String
-        @headers['Content-Length'] ||= @body.bytesize
+        headers[CONTENT_LENGTH] ||= @body.bytesize
       when IO
-        @headers['Content-Length'] ||= @body.stat.size
+        headers[CONTENT_LENGTH] ||= @body.stat.size
       when Enumerable
-        @headers['Transfer-Encoding'] ||= 'chunked'
+        headers[TRANSFER_ENCODING] ||= CHUNKED
       when NilClass
       else raise TypeError, "can't render #{@body.class} as a response body"
       end
 
-      # Prevent modification through the accessor
-      @headers.freeze
-
-      # FIXME: real HTTP versioning
-      @version = "HTTP/1.1"
+      @headers = canonicalize_headers(headers)
+      @version = http_version
     end
 
     # Set the status
@@ -71,22 +65,26 @@ module Reel
       when String
         socket << @body
       when IO
-        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
+        begin
+          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
+        ensure
+          @body.close
         end
       when Enumerable
         @body.each do |chunk|
-          chunk_header = chunk.bytesize.to_s(16) + CRLF
-          socket << chunk_header
-          socket << chunk
+          chunk_header = chunk.bytesize.to_s(16)
+          socket << chunk_header + CRLF
+          socket << chunk + CRLF
         end
 
-        socket << "0" << CRLF * 2
+        socket << "0#{CRLF * 2}"
       end
     end
 
@@ -105,10 +103,18 @@ module Reel
     end
     private :render_header
 
-    # Transform to canonical HTTP header capitalization
-    def canonicalize_header(header)
-      header.to_s.split(/[\-_]/).map(&:capitalize).join('-')
+    def canonicalize_headers headers
+      headers.inject({}) do |headers, (header, value)|
+        headers.merge Http.canonicalize_header(header) => value.to_s
+      end.freeze
     end
-    private :canonicalize_header
+    private :canonicalize_headers
+
+    def http_version
+      # FIXME: real HTTP versioning
+      "HTTP/1.1".freeze
+    end
+    private :http_version
+
   end
 end

data/lib/reel/server.rb

@@ -1,22 +1,26 @@
 module Reel
   class Server
     include Celluloid::IO
-    
+
+    # FIXME: remove respond_to? check after Celluloid 1.0
+    finalizer :finalize if respond_to?(:finalizer)
+
     def initialize(host, port, &callback)
       # This is actually an evented Celluloid::IO::TCPServer
       @server = TCPServer.new(host, port)
+      @server.listen(1024)
       @callback = callback
-      run!
+      async.run
     end
-    
+
     def finalize
       @server.close
     end
-    
+
     def run
-      loop { handle_connection! @server.accept }
+      loop { async.handle_connection @server.accept }
     end
-    
+
     def handle_connection(socket)
       connection = Connection.new(socket)
       begin
@@ -31,4 +35,4 @@ module Reel
       # TODO: log this?
     end
   end
-end
+end