reel 0.4.0.pre → 0.4.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e1a822cd1a5dff03e573f0220f40e9c0990ebd7
-  data.tar.gz: a560a182cfede95adaf56b9e7adadb51871cc0b2
+  metadata.gz: 4c139c2fa0dcd5e9456cb8867fbe296eddc1c9f6
+  data.tar.gz: 0ba97001f92ac212ba4184ba5059580e0e124245
 SHA512:
-  metadata.gz: bf75fd111a422d070f574895cd2866e515e6645daab72f2bd654562af56419140826aaec4695f5f7a4c58d115ac4ae5025af74b2a3d4d06aead1134c9bb76ef9
-  data.tar.gz: a126435e2b5c33a7256ad8ecd9e3aed5396b3a791a88d6dd643f134e9c06869b369a8bba52cb710e4a01e9bf556dc485421d55a1b45da5960c7beab9ee5921bf
+  metadata.gz: 02cfe9e2b456d5f6abb5c7810df4d6133ef5a1acfb49917de65f245d6bfadfe48c525b527ed060348ff8b306c071ac6714fa274c47aef693e08d79330aa639d9
+  data.tar.gz: a9ebba27cce7485bae2ae2236311d5fe43e59fc8e2d03c2d3b5a2f2ca4b728b6cccf430b6962d6abad639b614da846b1367c0880095cae2e420cbdf91bbefedf

data/CHANGES.md

@@ -1,6 +1,14 @@
-HEAD
-----
-* Remove on_error callback system
+0.4.0.pre2
+----------
+* Pipelining support
+* Reel::Connection#each_request for iterating through keep-alive requests
+* Reel::Request#body now returns a Reel::RequestBody object instead of a String
+* New WebSocket API: obtain WebSockets through Reel::Request#websocket instead
+  of through Reel::Connection#request. Allows processing of WebSockets through
+  other means than the built-in WebSocket support
+* Allow Reel to stop cleanly
+* Remove `on_error` callback system
+* Increase buffer size
 
 0.3.0
 -----

data/Gemfile

@@ -9,3 +9,7 @@ gem 'coveralls', require: false
 # Specify your gem's dependencies in reel.gemspec
 gemspec
 
+group :development do
+  gem 'guard-rspec'
+  gem 'pry'
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -6,7 +6,7 @@
 [![Code Climate](https://codeclimate.com/github/celluloid/reel.png)](https://codeclimate.com/github/celluloid/reel)
 [![Coverage Status](https://coveralls.io/repos/celluloid/reel/badge.png?branch=master)](https://coveralls.io/r/celluloid/reel)
 
-> "A dizzying lifetime... Reeling by on Celluloid" _-- Rush / Between The Wheels_
+> "A dizzying lifetime... reeling by on Celluloid" _-- Rush / Between The Wheels_
 
 Reel is a fast, non-blocking "evented" web server built on [http_parser.rb][parser],
 [websocket_parser][websockets], [Celluloid::IO][celluloidio], and [nio4r][nio4r]. Thanks
@@ -16,7 +16,7 @@ traditional multithreaded blocking I/O support too.
 [parser]: https://github.com/tmm1/http_parser.rb
 [websockets]: https://github.com/afcapel/websocket_parser
 [celluloidio]: https://github.com/celluloid/celluloid-io
-[nio4r]: https://github.com/tarcieri/nio4r
+[nio4r]: https://github.com/celluloid/nio4r
 
 Connections to Reel can be either non-blocking and handled entirely within
 the Reel::Server thread, or the same connections can be dispatched to worker
@@ -63,6 +63,8 @@ and are not amortized across all concurrent requests.
 API
 ---
 
+*NOTE: these examples are for the Reel 0.4.0.pre2 API*
+
 Reel also provides a "bare metal" API which was used in the benchmarks above.
 Here are some examples:
 
@@ -74,16 +76,18 @@ Reel lets you pass a block to initialize which receives connections:
 require 'reel'
 
 Reel::Server.supervise("0.0.0.0", 3000) do |connection|
-  while request = connection.request
-    case request
-    when Reel::Request
+  # Support multiple keep-alive requests per connection
+  connection.each_request do |request|
+    # WebSocket support
+    if request.websocket?
+      puts "Client made a WebSocket request to: #{request.url}"
+      websocket = request.websocket
+
+      websocket << "Hello everyone out there in WebSocket land"
+      websocket.close
+    else
       puts "Client requested: #{request.method} #{request.url}"
       request.respond :ok, "Hello, world!"
-    when Reel::WebSocket
-      puts "Client made a WebSocket request to: #{request.url}"
-      request << "Hello everyone out there in WebSocket land"
-      request.close
-      break
     end
   end
 end
@@ -108,12 +112,11 @@ class MyServer < Reel::Server
   end
 
   def on_connection(connection)
-    while request = connection.request
-      case request
-      when Reel::Request
-        handle_request(request)
-      when Reel::WebSocket
+    connection.each_request do |request|
+      if request.websocket?
         handle_websocket(request)
+      else
+        handle_request(request)
       end
     end
   end
@@ -133,6 +136,7 @@ MyServer.run
 
 Framework Adapters
 ------------------
+
 ### Rack
 
 Reel can be used as a standard Rack server via the "reel" command line
@@ -143,6 +147,12 @@ by Celluloid. In addition, the Rack specification mandates that request bodies
 are rewindable, which prevents streaming request bodies as the spec dictates
 they must be written to disk.
 
+To run `.ru` file using Reel w/ 16 workers
+
+```
+rackup -p 1234 -s reel config.ru -Enone -O "workers=16" 
+```
+
 To really leverage Reel's capabilities, you must use Reel via its own API,
 or another Ruby library with direct Reel support.
 
@@ -173,7 +183,7 @@ MyApp = Webmachine::Application.new do |app|
     config.port    = MYAPP_PORT
     config.adapter = :Reel
 
-    # Optional: (WM master only) handler for incoming websockets
+    # Optional: handler for incoming websockets
     config.adapter_options[:websocket_handler] = proc do |websocket|
       # socket is a Reel::WebSocket
       socket << "hello, world"

data/examples/ssl_hello_world.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/hello_world.rb
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+addr, port = '127.0.0.1', 4430
+options = {
+  :cert => File.read(File.expand_path("../../spec/fixtures/server.crt", __FILE__)),
+  :key  => File.read(File.expand_path("../../spec/fixtures/server.key", __FILE__))
+}
+
+puts "*** Starting server on #{addr}:#{port}"
+Reel::SSLServer.supervise(addr, port, options) do |connection|
+  # To use keep-alive with Reel, use a while loop that repeatedly calls
+  # connection.request and consumes connection objects
+  while request = connection.request
+    # Ordinarily we'd route the request here, e.g.
+    # route request.url
+    connection.respond :ok, "hello, world!"
+  end
+
+  # Reel takes care of closing the connection
+end
+
+sleep

data/examples/websocket_rack.sh

@@ -1 +1 @@
-rackup -s reel websocket.ru -Enone
+rackup -s reel websocket.ru -Enone -O "workers=16"

data/examples/websockets.rb

@@ -48,12 +48,22 @@ class WebServer < Reel::Server
 
   def on_connection(connection)
     while request = connection.request
-      case request
-      when Reel::Request
-        route_request connection, request
-      when Reel::WebSocket
+      if request.websocket?
         info "Received a WebSocket connection"
-        route_websocket request
+
+        # We're going to hand off this connection to another actor (TimeClient)
+        # However, initially Reel::Connections are "attached" to the
+        # Reel::Server actor, meaning that the server manages the connection
+        # lifecycle (e.g. error handling) for us.
+        # 
+        # If we want to hand this connection off to another actor, we first
+        # need to detach it from the Reel::Server
+        connection.detach
+
+        route_websocket request.websocket
+        return
+      else
+        route_request connection, request
       end
     end
   end

data/lib/rack/handler/reel.rb

@@ -83,6 +83,7 @@ module Rack
         options = options.inject({}) { |h, (k,v)| h[k.downcase] = v ; h }
         options[:rackup] = options[:config] if options[:config]
         options[:port] = options[:port].to_i if options[:port]
+        options[:workers] = options[:workers].to_i if options[:workers]
         options
       end
     end

data/lib/reel.rb

@@ -11,10 +11,14 @@ require 'reel/version'
 require 'reel/mixins'
 require 'reel/connection'
 require 'reel/logger'
+require 'reel/request_info'
 require 'reel/request'
+require 'reel/request_body'
 require 'reel/request_parser'
 require 'reel/response'
+require 'reel/response_writer'
 require 'reel/server'
+require 'reel/ssl_server'
 require 'reel/websocket'
 require 'reel/stream'
 
@@ -29,9 +33,16 @@ module Reel
   # Error reading a request
   class RequestError < StandardError; end
 
-  # Error occured performing IO on a socket
+  # Error occurred performing IO on a socket
   class SocketError < RequestError; end
 
+  # Error occurred when trying to use the socket after it was upgraded
+  class SocketUpgradedError < NilClass
+    def self.method_missing(m, *)
+      raise(Reel::RequestError, 'Reel::Connection#socket can not be used anymore as it was upgraded. Use Reel::WebSocket instance instead.')
+    end
+  end
+
   # Error occured during a WebSockets handshake
   class HandshakeError < RequestError; end
 

data/lib/reel/app.rb

@@ -16,7 +16,7 @@ module Reel
       super()
       @server = Reel::Server.supervise(host, port) do |connection|
         while request = connection.request
-          status, headers, body = call Rack::MockRequest.env_for(request.url, :method => request.method, :input => request.body)
+          status, headers, body = call Rack::MockRequest.env_for(request.url, :method => request.method, :input => request.body.to_s)
           response_klass = body.is_a?(Stream) ? StreamResponse : Response
           connection.respond(response_klass.new(status_symbol(status), headers, body))
         end

data/lib/reel/connection.rb

@@ -10,18 +10,20 @@ module Reel
     TRANSFER_ENCODING  = 'Transfer-Encoding'.freeze
     KEEP_ALIVE         = 'Keep-Alive'.freeze
     CLOSE              = 'close'.freeze
-    CHUNKED            = 'chunked'.freeze
 
     attr_reader :socket, :parser
 
     # Attempt to read this much data
     BUFFER_SIZE = 16384
+    attr_reader :buffer_size
 
-    def initialize(socket)
+    def initialize(socket, buffer_size = nil)
       @attached  = true
       @socket    = socket
       @keepalive = true
-      @parser    = Request::Parser.new
+      @parser    = Request::Parser.new(socket, self)
+      @writer    = Response::Writer.new(socket, self)
+      @buffer_size = buffer_size.nil? ? BUFFER_SIZE : buffer_size
       reset_request
 
       @response_state = :header
@@ -40,26 +42,29 @@ module Reel
     end
 
     # Reset the current request state
-    def reset_request(state = :header)
+    def reset_request(state = :ready)
       @request_state = state
-      @header_buffer = "" # Buffer headers in case of an upgrade request
+      @current_request = nil
       @parser.reset
     end
 
+    def readpartial(size = @buffer_size)
+      raise StateError, "can't read in the '#{@request_state}' request state" unless @request_state == :ready
+      @parser.readpartial(size)
+    end
+
+    def current_request
+      @current_request
+    end
+
     # Read a request object from the connection
     def request
-      return if @request_state == :websocket
-      req = Request.read(self)
-
-      case req
-      when Request
-        @request_state = :body
-        @keepalive = false if req[CONNECTION] == CLOSE || req.version == HTTP_VERSION_1_0
-      when WebSocket
-        @request_state = @response_state = :websocket
-        @socket = nil
-      else raise "unexpected request type: #{req.class}"
-      end
+      raise StateError, "already processing a request" if current_request
+
+      req = @parser.current_request
+      @request_state = :ready
+      @keepalive = false if req[CONNECTION] == CLOSE || req.version == HTTP_VERSION_1_0
+      @current_request = req
 
       req
     rescue IOError, Errno::ECONNRESET, Errno::EPIPE
@@ -69,45 +74,23 @@ module Reel
       nil
     end
 
-    # Read a chunk from the request
-    def readpartial(size = BUFFER_SIZE)
-      raise StateError, "can't read in the `#{@request_state}' state" unless @request_state == :body
+    # Enumerate the requests from this connection, since we might receive
+    # many if the client is using keep-alive
+    def each_request
+      while req = request
+        yield req
 
-      chunk = @parser.chunk
-      unless chunk || @parser.finished?
-        @parser << @socket.readpartial(size)
-        chunk = @parser.chunk
+        # Websockets upgrade the connection to the Websocket protocol
+        # Once we have finished processing a Websocket, we can't handle
+        # additional requests
+        break if req.websocket?
       end
-
-      chunk
-    end
-
-    # read length bytes from request body
-    def read(length = nil, buffer = nil)
-      raise ArgumentError, "negative length #{length} given" if length && length < 0
-
-      return '' if length == 0
-
-      res = buffer.nil? ? '' : buffer.clear
-
-      chunk_size = length.nil? ? 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
 
     # Send a response back to the client
     # Response can be a symbol indicating the status code or a Reel::Response
     def respond(response, headers_or_body = {}, body = nil)
-      raise StateError "not in header state" if @response_state != :header
+      raise StateError, "not in header state" if @response_state != :header
 
       if headers_or_body.is_a? Hash
         headers = headers_or_body
@@ -129,10 +112,10 @@ module Reel
       else raise TypeError, "invalid response: #{response.inspect}"
       end
 
-      response.render(@socket)
+      @writer.handle_response(response)
 
       # Enable streaming mode
-      if response.headers[TRANSFER_ENCODING] == CHUNKED and response.body.nil?
+      if response.chunked? and response.body.nil?
         @response_state = :chunked_body
       end
     rescue IOError, Errno::ECONNRESET, Errno::EPIPE
@@ -140,7 +123,7 @@ module Reel
       @keepalive = false
     ensure
       if @keepalive
-        reset_request(:header)
+        reset_request(:ready)
       else
         @socket.close unless @socket.closed?
         reset_request(:closed)
@@ -150,23 +133,43 @@ module Reel
     # Write body chunks directly to the connection
     def write(chunk)
       raise StateError, "not in chunked body mode" unless @response_state == :chunked_body
-      chunk_header = chunk.bytesize.to_s(16)
-      @socket << chunk_header + Response::CRLF
-      @socket << chunk + Response::CRLF
+      @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 @response_state != :chunked_body
-      @socket << "0#{Response::CRLF * 2}"
+      @writer.finish_response
       @response_state = :header
     end
 
     # Close the connection
     def close
+      raise StateError, "socket has been hijacked from this connection" unless @socket
+
       @keepalive = false
       @socket.close unless @socket.closed?
     end
+
+    # Hijack the socket from the connection
+    def hijack_socket
+      # FIXME: this doesn't do a great job of ensuring we can hijack the socket
+      # in its current state. Improve the state detection.
+      if @request_state != :ready && @response_state != :header
+        raise StateError, "connection is not in a hijackable state"
+      end
+
+      @request_state = @response_state = :hijacked
+      socket  = @socket
+      @socket = nil
+      socket
+    end
+
+    # Raw access to the underlying socket
+    def socket
+      raise StateError, "socket has already been hijacked" unless @socket
+      @socket
+    end
   end
 end