reel 0.4.0.pre → 0.4.0.pre2

data/lib/reel/mixins.rb

@@ -10,25 +10,25 @@ module Reel
 
     # Obtain the IP address of the remote connection
     def remote_ip
-      @socket.peeraddr(false)[3]
+      socket.peeraddr(false)[3]
     end
-    alias_method :remote_addr, :remote_ip
+    alias remote_addr remote_ip
 
     # Obtain the hostname of the remote connection
     def remote_host
       # NOTE: Celluloid::IO does not yet support non-blocking reverse DNS
-      @socket.peeraddr(true)[2]
+      socket.peeraddr(true)[2]
     end
   end
 
   module RequestMixin
 
     def method
-      @http_parser.http_method
+      @request_info.http_method
     end
 
     def headers
-      @http_parser.headers
+      @request_info.headers
     end
 
     def [] header
@@ -36,11 +36,11 @@ module Reel
     end
 
     def version
-      @http_parser.http_version || HTTPVersionsMixin::DEFAULT_HTTP_VERSION
+      @request_info.http_version || HTTPVersionsMixin::DEFAULT_HTTP_VERSION
     end
 
     def url
-      @http_parser.url
+      @request_info.url
     end
 
     def uri
@@ -48,11 +48,15 @@ module Reel
     end
 
     def path
-      @http_parser.request_path
+      uri.path
     end
 
     def query_string
-      @http_parser.query_string
+      uri.query
+    end
+
+    def fragment
+      uri.fragment
     end
 
   end

data/lib/reel/rack_worker.rb

@@ -88,8 +88,8 @@ module Reel
 
     def websocket_env request
       env = env(request)
-      env[REMOTE_ADDR]    = request.remote_ip
-      env[RACK_WEBSOCKET] = request
+      env[RACK_WEBSOCKET] = request.websocket
+      env[REMOTE_ADDR]    = request.websocket.remote_ip
       env
     end
 
@@ -111,7 +111,7 @@ module Reel
     def env request
       env = Hash[PROTO_RACK_ENV]
 
-      env[RACK_INPUT] = StringIO.new(request.body || INITIAL_BODY)
+      env[RACK_INPUT] = StringIO.new(request.body.to_s || 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

data/lib/reel/request.rb

@@ -5,51 +5,89 @@ module Reel
     extend Forwardable
     include RequestMixin
 
-    UPGRADE   = 'Upgrade'.freeze
-    WEBSOCKET = 'websocket'.freeze
+    def_delegators :@connection, :<<, :write, :respond, :finish_response
+    attr_reader :body
 
-    # 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
+    # request_info is a RequestInfo object including the headers and
+    # the url, method and http version.
+    #
+    # Access it through the RequestMixin methods.
+    def initialize(request_info, connection = nil)
+      @request_info  = request_info
+      @connection    = connection
+      @finished      = false
+      @buffer        = ""
+      @body          = RequestBody.new(self)
+      @finished_read = false
+      @websocket     = nil
+    end
 
-    def self.read(connection)
-      parser = connection.parser
+    # Returns true if request fully finished reading
+    def finished_reading?; @finished_read; end
 
-      begin
-        data = connection.socket.readpartial(Connection::BUFFER_SIZE)
-        parser << data
-      end until parser.headers
+    # When HTTP Parser marks the message parsing as complete, this will be set.
+    def finish_reading!
+      raise StateError, "already finished" if @finished_read
+      @finished_read = true
+    end
+
+    # Fill the request buffer with data as it becomes available
+    def fill_buffer(chunk)
+      @buffer << chunk
+    end
 
-      REQUEST_METHODS[parser.http_method] ||
-        raise(ArgumentError, "Unknown Request Method: %s" % parser.http_method)
+    # Read a number of bytes, looping until they are available or until
+    # readpartial returns nil, indicating there are no more bytes to read
+    def read(length = nil, buffer = nil)
+      raise ArgumentError, "negative length #{length} given" if length && length < 0
 
-      upgrade = parser.headers[UPGRADE]
-      if upgrade && upgrade.downcase == WEBSOCKET
-        WebSocket.new(parser, connection.socket)
-      else
-        Request.new(parser, connection)
+      return '' if length == 0
+      res = buffer.nil? ? '' : buffer.clear
+
+      chunk_size = length.nil? ? @connection.buffer_size : length
+      begin
+        while chunk_size > 0
+          chunk = readpartial(chunk_size)
+          break unless chunk
+          res << chunk
+          chunk_size = length - res.length unless length.nil?
+        end
+      rescue EOFError
       end
+      return length && res.length == 0 ? nil : res
     end
 
-    def_delegators :@connection, :respond, :finish_response, :close, :read
+    # Read a string up to the given number of bytes, blocking until some
+    # data is available but returning immediately if some data is available
+    def readpartial(length = nil)
+      if length.nil? && @buffer.length > 0
+        slice = @buffer
+        @buffer = ""
+      else
+        unless finished_reading? || (length && length <= @buffer.length)
+          @connection.readpartial(length ? length - @buffer.length : Connection::BUFFER_SIZE)
+        end
+
+        if length
+          slice = @buffer.slice!(0, length)
+        else
+          slice = @buffer
+          @buffer = ""
+        end
+      end
 
-    def initialize(http_parser, connection = nil)
-      @http_parser, @connection = http_parser, connection
+      slice && slice.length == 0 ? nil : slice
     end
 
-    def body
-      @body ||= begin
-        raise "no connection given" unless @connection
-
-        body = "" unless block_given?
-        while (chunk = @connection.readpartial)
-          if block_given?
-            yield chunk
-          else
-            body << chunk
-          end
-        end
-        body unless block_given?
+    # Can the current request be upgraded to a WebSocket?
+    def websocket?; @request_info.websocket_request?; end
+
+    # Return a Reel::WebSocket for this request, hijacking the socket from
+    # the underlying connection
+    def websocket
+      @websocket ||= begin
+        raise StateError, "can't upgrade this request to a websocket" unless websocket?
+        WebSocket.new(@request_info, @connection.hijack_socket)
       end
     end
   end

data/lib/reel/request_body.rb

@@ -0,0 +1,56 @@
+module Reel
+  # Represents the bodies of Requests
+  class RequestBody
+    include Enumerable
+
+    def initialize(request)
+      @request   = request
+      @streaming = nil
+      @contents  = nil
+    end
+
+    # Read exactly the given amount of data
+    def read(length)
+      stream!
+      @request.read(length)
+    end
+
+    # Read up to length bytes, but return any data that's available
+    def readpartial(length = nil)
+      stream!
+      @request.readpartial(length)
+    end
+
+    # Iterate over the body, allowing it to be enumerable
+    def each
+      while chunk = readpartial
+        yield chunk
+      end
+    end
+
+    # Eagerly consume the entire body as a string
+    def to_s
+      return @contents if @contents
+      raise StateError, "body is being streamed" unless @streaming.nil?
+
+      begin
+        @streaming = false
+        @contents = ""
+        while chunk = @request.readpartial
+          @contents << chunk
+        end
+      rescue
+        @contents = nil
+        raise
+      end
+
+      @contents
+    end
+
+    # Assert that the body is actively being streamed
+    def stream!
+      raise StateError, "body has already been consumed" if @streaming == false
+      @streaming = true
+    end
+  end
+end

data/lib/reel/request_info.rb

@@ -0,0 +1,27 @@
+module Reel
+  class RequestInfo
+    attr_reader :http_method, :url, :http_version, :headers
+
+    def initialize(http_method, url, http_version, headers)
+      @http_method  = http_method
+      @url          = url
+      @http_version = http_version
+      @headers      = headers
+    end
+
+    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 method
+      REQUEST_METHODS[http_method]
+    end
+
+    def websocket_request?
+      headers[UPGRADE] && headers[UPGRADE].downcase == WEBSOCKET
+    end
+  end
+end

data/lib/reel/request_parser.rb

@@ -2,17 +2,17 @@ module Reel
   class Request
     class Parser
       include HTTPVersionsMixin
-      attr_reader :headers
+      attr_reader :socket, :connection
 
-      def initialize
+      def initialize(sock, conn)
         @parser = Http::Parser.new(self)
-        reset
-      end
+        @socket = sock
+        @connection = conn
+        @currently_reading = @currently_responding = nil
+        @pending_reads     = []
+        @pending_responses = []
 
-      [:request_path, :query_string].each do |m|
-        define_method m do
-          @parser.send m
-        end
+        reset
       end
 
       def add(data)
@@ -20,10 +20,6 @@ module Reel
       end
       alias_method :<<, :add
 
-      def headers?
-        !!@headers
-      end
-
       def http_method
         @parser.http_method
       end
@@ -37,39 +33,55 @@ module Reel
         @parser.request_url
       end
 
-      def finished?; @finished; end
+      def current_request
+        until @currently_responding || @currently_reading
+          readpartial
+        end
+        @currently_responding || @currently_reading
+      end
+
+      def readpartial(size = @connection.buffer_size)
+        bytes = @socket.readpartial(size)
+        @parser << bytes
+      end
 
       #
       # Http::Parser callbacks
       #
-
       def on_headers_complete(headers)
-        @headers = headers
-      end
-
-      def on_body(chunk)
-        if @chunk
-          @chunk << chunk
+        info = RequestInfo.new(http_method, url, http_version, headers)
+        req = Request.new(info, connection)
+        if @currently_reading.nil?
+          @currently_reading = req
         else
-          @chunk = chunk
+          @pending_reads << req
         end
       end
 
-      def chunk
-        if (chunk = @chunk)
-          @chunk = nil
-          chunk
-        end
+      # Send body directly to Reel::Response to be buffered.
+      def on_body(chunk)
+        @currently_reading.fill_buffer(chunk)
       end
 
+      # Mark current request as complete, set this as ready to respond.
       def on_message_complete
-        @finished = true
+        @currently_reading.finish_reading! if @currently_reading.is_a?(Request)
+        if @currently_responding.nil?
+          @currently_responding = @currently_reading
+        else
+          @pending_responses << @currently_reading
+        end
+        @currently_reading = @pending_reads.shift
       end
 
       def reset
-        @finished = false
-        @headers  = nil
-        @chunk    = nil
+        popped = @currently_responding
+        if req = @pending_responses.shift
+          @currently_responding = req
+        elsif @currently_responding
+          @currently_responding = nil
+        end
+        popped
       end
     end
   end

data/lib/reel/response.rb

@@ -8,11 +8,10 @@ module Reel
     # Use status code tables from the Http gem
     STATUS_CODES          = Http::Response::STATUS_CODES
     SYMBOL_TO_STATUS_CODE = Http::Response::SYMBOL_TO_STATUS_CODE
-    CRLF = "\r\n"
 
     attr_reader   :status # Status has a special setter to coerce symbol names
     attr_accessor :reason # Reason can be set explicitly if desired
-    attr_reader   :headers, :body
+    attr_reader   :headers, :body, :version
 
     def initialize(status, body_or_headers = nil, body = nil)
       self.status = status
@@ -40,6 +39,10 @@ module Reel
       @version = http_version
     end
 
+    def chunked?
+      headers[TRANSFER_ENCODING] == CHUNKED
+    end
+
     # Set the status
     def status=(status, reason=nil)
       case status
@@ -57,52 +60,6 @@ module Reel
       end
     end
 
-    # Write the response out to the wire
-    def render(socket)
-      socket << render_header
-
-      case @body
-      when String
-        socket << @body
-      when IO
-        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)
-          socket << chunk_header + CRLF
-          socket << chunk + CRLF
-        end
-
-        socket << "0#{CRLF * 2}"
-      end
-    end
-
-    # Convert headers into a string
-    # FIXME: this should probably be factored elsewhere, SRP and all
-    def render_header
-      response_header = "#{@version} #{@status} #{@reason}#{CRLF}"
-
-      unless @headers.empty?
-        response_header << @headers.map do |header, value|
-          "#{header}: #{value}"
-        end.join(CRLF) << CRLF
-      end
-
-      response_header << CRLF
-    end
-    private :render_header
-
     def canonicalize_headers(headers)
       headers.inject({}) do |headers, (header, value)|
         headers.merge Http.canonicalize_header(header) => value.to_s
@@ -115,6 +72,5 @@ module Reel
       "HTTP/1.1".freeze
     end
     private :http_version
-
   end
 end