reel 0.4.0 → 0.5.0.pre

data/lib/reel/mixins.rb

@@ -19,6 +19,7 @@ module Reel
       # NOTE: Celluloid::IO does not yet support non-blocking reverse DNS
       socket.peeraddr(true)[2]
     end
+
   end
 
   module RequestMixin
@@ -31,7 +32,7 @@ module Reel
       @request_info.headers
     end
 
-    def [] header
+    def [](header)
       headers[header]
     end
 
@@ -60,4 +61,5 @@ module Reel
     end
 
   end
+
 end

data/lib/reel/request.rb

@@ -1,11 +1,19 @@
 require 'forwardable'
 
+require 'reel/request/body'
+require 'reel/request/info'
+require 'reel/request/parser'
+require 'reel/request/state_machine'
+
+require 'reel/response/writer'
+
 module Reel
   class Request
     extend Forwardable
     include RequestMixin
 
-    def_delegators :@connection, :<<, :write, :remote_addr, :respond, :finish_response
+    def_delegators :@connection, :remote_addr, :respond
+    def_delegator  :@response_writer, :handle_response
     attr_reader :body
 
     # request_info is a RequestInfo object including the headers and
@@ -13,13 +21,14 @@ module Reel
     #
     # 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
+      @request_info    = request_info
+      @connection      = connection
+      @finished        = false
+      @buffer          = ""
+      @finished_read   = false
+      @websocket       = nil
+      @body            = Request::Body.new(self)
+      @response_writer = Response::Writer.new(connection.socket)
     end
 
     # Returns true if request fully finished reading
@@ -65,7 +74,7 @@ module Reel
         @buffer = ""
       else
         unless finished_reading? || (length && length <= @buffer.length)
-          @connection.readpartial(length ? length - @buffer.length : Connection::BUFFER_SIZE)
+          @connection.readpartial(length ? length - @buffer.length : @connection.buffer_size)
         end
 
         if length
@@ -79,6 +88,23 @@ module Reel
       slice && slice.length == 0 ? nil : slice
     end
 
+    # Write body chunks directly to the connection
+    def write(chunk)
+      unless @connection.response_state == :chunked_body
+        raise StateError, "not in chunked body mode"
+      end
+
+      @response_writer.write(chunk)
+    end
+    alias_method :<<, :write
+
+    # Finish the response and reset the response state to header
+    def finish_response
+      raise StateError, "not in body state" if @connection.response_state != :chunked_body
+      @response_writer.finish_response
+      @connection.response_state = :headers
+    end
+
     # Can the current request be upgraded to a WebSocket?
     def websocket?; @request_info.websocket_request?; end
 
@@ -90,5 +116,10 @@ module Reel
         WebSocket.new(@request_info, @connection.hijack_socket)
       end
     end
+
+    # Friendlier inspect
+    def inspect
+      "#<#{self.class} #{method} #{url} HTTP/#{version} @headers=#{headers.inspect}>"
+    end
   end
 end

data/lib/reel/request/body.rb

@@ -0,0 +1,65 @@
+module Reel
+  class Request
+    # Represents the bodies of Requests
+    class Body
+      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_str
+        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
+      alias_method :to_s, :to_str
+
+      # Easier to interpret string inspect
+      def inspect
+        "#<#{self.class}:#{object_id.to_s(16)} @streaming=#{!!@streaming}>"
+      end
+
+      # Assert that the body is actively being streamed
+      def stream!
+        raise StateError, "body has already been consumed" if @streaming == false
+        @streaming = true
+      end
+      private :stream!
+    end
+  end
+end

data/lib/reel/request/info.rb

@@ -0,0 +1,21 @@
+module Reel
+  class Request
+    class Info
+      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
+
+      def websocket_request?
+        headers[UPGRADE] && headers[UPGRADE].downcase == WEBSOCKET
+      end
+    end
+  end
+end

data/lib/reel/{request_parser.rb → request/parser.rb}

@@ -5,7 +5,7 @@ module Reel
       attr_reader :socket, :connection
 
       def initialize(connection)
-        @parser      = Http::Parser.new(self)
+        @parser      = HTTP::Parser.new(self)
         @connection  = connection
         @socket      = connection.socket
         @buffer_size = connection.buffer_size
@@ -50,7 +50,7 @@ module Reel
       # HTTP::Parser callbacks
       #
       def on_headers_complete(headers)
-        info = RequestInfo.new(http_method, url, http_version, headers)
+        info = Info.new(http_method, url, http_version, headers)
         req  = Request.new(info, connection)
 
         if @currently_reading

data/lib/reel/request/state_machine.rb

@@ -0,0 +1,26 @@
+module Reel
+  class Request
+    # Tracks the state of Reel requests
+    class StateMachine
+      include Celluloid::FSM
+
+      def initialize(socket)
+        @socket   = socket
+        @hijacked = false
+      end
+
+      default_state :headers
+
+      state :headers, :to => [:body, :hijacked, :closed]
+      state :body,    :to => [:headers, :closed]
+
+      state :hijacked do
+        @hijacked = true
+      end
+
+      state :closed do
+        @socket.close unless @hijacked || @socket.closed?
+      end
+    end
+  end
+end

data/lib/reel/response.rb

@@ -1,7 +1,7 @@
+require 'http/headers'
+
 module Reel
   class Response
-    include HTTP::Header
-
     CONTENT_LENGTH     = 'Content-Length'.freeze
     TRANSFER_ENCODING  = 'Transfer-Encoding'.freeze
     CHUNKED            = 'chunked'.freeze
@@ -36,12 +36,12 @@ module Reel
       else raise TypeError, "can't render #{@body.class} as a response body"
       end
 
-      @headers = canonicalize_headers(headers)
+      @headers = HTTP::Headers.coerce(headers)
       @version = http_version
     end
 
     def chunked?
-      headers[TRANSFER_ENCODING] == CHUNKED
+      headers[TRANSFER_ENCODING].to_s == CHUNKED
     end
 
     # Set the status
@@ -61,13 +61,6 @@ module Reel
       end
     end
 
-    def canonicalize_headers(headers)
-      headers.inject({}) do |headers, (header, value)|
-        headers.merge canonicalize_header(header) => value.to_s
-      end.freeze
-    end
-    private :canonicalize_headers
-
     def http_version
       # FIXME: real HTTP versioning
       "HTTP/1.1".freeze

data/lib/reel/response/writer.rb

@@ -0,0 +1,59 @@
+module Reel
+  class Response
+    class Writer
+      CRLF = "\r\n"
+
+      def initialize(socket)
+        @socket = socket
+      end
+
+      # Write body chunks directly to the connection
+      def write(chunk)
+        chunk_header = chunk.bytesize.to_s(16)
+        @socket << chunk_header + CRLF
+        @socket << chunk + CRLF
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET => ex
+        raise Reel::SocketError, ex.to_s
+      end
+
+      # Finish the response and reset the response state to header
+      def finish_response
+        @socket << "0#{CRLF * 2}"
+      end
+
+      # Render a given response object to the network socket
+      def handle_response(response)
+        @socket << render_header(response)
+        return response.render(@socket) if response.respond_to?(:render)
+
+        case response.body
+        when String
+          @socket << response.body
+        when IO
+          Celluloid::IO.copy_stream(response.body, @socket)
+        when Enumerable
+          response.body.each { |chunk| write(chunk) }
+          finish_response
+        when NilClass
+          # Used for streaming Transfer-Encoding chunked responses
+          return
+        else
+          raise TypeError, "don't know how to render a #{response.body.class}"
+        end
+        response.body.close if response.body.respond_to?(:close)
+      end
+
+      # Convert headers into a string
+      def render_header(response)
+        response_header = "#{response.version} #{response.status} #{response.reason}#{CRLF}"
+        unless response.headers.empty?
+          response_header << response.headers.map do |header, value|
+            "#{header}: #{value}"
+          end.join(CRLF) << CRLF
+        end
+        response_header << CRLF
+      end
+      private :render_header
+    end
+  end
+end

data/lib/reel/server.rb

@@ -1,19 +1,32 @@
 module Reel
+  # Base class for Reel servers.
+  #
+  # This class is a Celluloid::IO actor which provides a barebones server
+  # which does not open a socket itself, it just begin handling connections once
+  # initialized with a specific kind of protocol-based server.
+
+  # For specific protocol support, use:
+
+  # Reel::Server::HTTP
+  # Reel::Server::HTTPS
+  # Coming soon: Reel::Server::UNIX
+
   class Server
     include Celluloid::IO
-
     # How many connections to backlog in the TCP accept queue
     DEFAULT_BACKLOG = 100
 
     execute_block_on_receiver :initialize
     finalizer :shutdown
 
-    def initialize(host, port, backlog = DEFAULT_BACKLOG, &callback)
-      # This is actually an evented Celluloid::IO::TCPServer
-      @server = TCPServer.new(host, port)
-      @server.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      @server.listen(backlog)
+    def initialize(server, options={}, &callback)
+      @spy      = STDOUT if options[:spy]
+      @options  = options
       @callback = callback
+      @server   = server
+
+      @server.listen(options.fetch(:backlog, DEFAULT_BACKLOG))
+
       async.run
     end
 
@@ -25,7 +38,18 @@ module Reel
       loop { async.handle_connection @server.accept }
     end
 
+    def optimize(socket)
+      if socket.is_a? TCPSocket
+        socket.setsockopt(Socket::IPPROTO_TCP, :TCP_NODELAY, 1)
+      end
+    end
+
     def handle_connection(socket)
+      if @spy
+        require 'reel/spy'
+        socket = Reel::Spy.new(socket, @spy)
+      end
+
       connection = Connection.new(socket)
 
       begin

data/lib/reel/server/http.rb

@@ -0,0 +1,20 @@
+module Reel
+  class Server
+    class HTTP < Server
+
+      # Create a new Reel HTTP server
+      #
+      # @param [String] host address to bind to
+      # @param [Fixnum] port to bind to
+      # @option options [Fixnum] backlog of requests to accept
+      #
+      # @return [Reel::Server::HTTP] Reel HTTP server actor
+      def initialize(host, port, options={}, &callback)
+        optimize server = Celluloid::IO::TCPServer.new(host, port)
+        options.merge!(host: host, port: port)
+        super(server, options, &callback)
+      end
+
+    end
+  end
+end

data/lib/reel/server/https.rb

@@ -0,0 +1,63 @@
+module Reel
+  class Server
+    class HTTPS < Server
+
+      # Create a new Reel HTTPS server
+      #
+      # @param [String] host address to bind to
+      # @param [Fixnum] port to bind to
+      # @option options [Fixnum] backlog of requests to accept
+      # @option options [String] :cert the server's TLS certificate
+      # @option options [String] :key  the server's TLS key
+      # @option options [Array]  :extra_cert_chain TLS certificate chain
+      #
+      # @return [Reel::Server::HTTPS] Reel HTTPS server actor
+      def initialize(host, port, options={}, &callback)
+
+        # Ideally we can encapsulate this rather than making Ruby OpenSSL a
+        # mandatory part of the Reel API. It would be nice to support
+        # alternatives (e.g. Puma's MiniSSL)
+        ssl_context      = OpenSSL::SSL::SSLContext.new
+        ssl_context.cert = OpenSSL::X509::Certificate.new options.fetch(:cert)
+        ssl_context.key  = OpenSSL::PKey::RSA.new options.fetch(:key)
+
+        ssl_context.ca_file          = options[:ca_file]
+        ssl_context.ca_path          = options[:ca_path]
+        ssl_context.extra_chain_cert = options[:extra_chain_cert]
+
+        # if verify_mode isn't explicitly set, verify peers if we've
+        # been provided CA information that would enable us to do so
+        ssl_context.verify_mode = case
+        when options.include?(:verify_mode)
+          options[:verify_mode]
+        when options.include?(:ca_file)
+          OpenSSL::SSL::VERIFY_PEER
+        when options.include?(:ca_path)
+          OpenSSL::SSL::VERIFY_PEER
+        else
+          OpenSSL::SSL::VERIFY_NONE
+        end
+
+        optimize @tcpserver = Celluloid::IO::TCPServer.new(host, port)
+
+        server = Celluloid::IO::SSLServer.new(@tcpserver, ssl_context)
+        options.merge!(host: host, port: port)
+
+        super(server, options, &callback)
+      end
+
+      def run
+        loop do
+          begin
+            socket = @server.accept
+          rescue OpenSSL::SSL::SSLError => ex
+            Logger.warn "Error accepting SSLSocket: #{ex.class}: #{ex.to_s}"
+            retry
+          end
+
+          async.handle_connection socket
+        end
+      end
+    end
+  end
+end