reel 0.4.0 → 0.5.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea63b536704d29dc28c875c4160bc25937d989b5
-  data.tar.gz: e3d5d422b33b49c35932238dc00dd0847eaca7f1
+  metadata.gz: 96b038743e66387d895d56854f1f09709b55200c
+  data.tar.gz: 03f4a385c206da2723ba5850014da73468b89e09
 SHA512:
-  metadata.gz: f5d23ce9c146c86b313f5aa35f218e37e172001a7e29f8a39945a68e995ed9dcaf61bebc987558224b2c950917628a10f39b5428c50fd3451eda7e4ea15eb2f9
-  data.tar.gz: 73f35c9e99d133135d39ec18d77a04f2a71ce56170f23ccb36f766194a722595b31fa3856769b5c701a8e468c77293a317302711544f13aef89d9375c847e805
+  metadata.gz: 1563d75814c208fda3080219201950714a2167c70afa07e3346a7624d31e9d66cf0dd56e15d97fa1438bb6781f083080164eae391fd3fc9ec938a647a46408ed
+  data.tar.gz: 8f3f2fb7aa0cdd0bae37495a7f5185abfb76e8bf11c5a1b082db9dfc8221b0accde6dff5b6cdce25756dca87537ca4cf490cbad5ffc818a3c41da33d0a4feed9

data/.travis.yml

@@ -1,15 +1,18 @@
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
   - ruby-head
-  - jruby-19mode
+  - jruby
   - jruby-head
-  - rbx-19mode
+  - rbx
 
 matrix:
   allow_failures:
     - rvm: ruby-head
+    - rvm: jruby
     - rvm: jruby-head
+    - rvm: rbx
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/Gemfile

@@ -14,3 +14,9 @@ group :development do
   gem 'guard-rspec'
   gem 'pry'
 end
+
+platforms :rbx do
+  gem 'racc'
+  gem 'rubinius-coverage'
+  gem 'rubysl', '~> 2.0'
+end

data/README.md

@@ -7,10 +7,11 @@
 
 > "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
-to Celluloid, Reel also works great for multithreaded applications and provides
-traditional multithreaded blocking I/O support too.
+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 to Celluloid,
+Reel also works great for multithreaded applications
+and provides traditional multithreaded blocking I/O support too.
 
 [parser]: https://github.com/tmm1/http_parser.rb
 [websockets]: https://github.com/afcapel/websocket_parser
@@ -18,11 +19,13 @@ traditional multithreaded blocking I/O support too.
 [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
-threads where they will perform ordinary blocking IO. Reel provides no
-built-in thread pool, however you can build one yourself using Celluloid.pool,
-or because Celluloid already pools threads to begin with, you can simply use
-an actor per connection.
+the Reel::Server thread (handling HTTP, HTTPS, or UNIX sockets),
+or the same connections can be dispatched to worker threads
+where they will perform ordinary blocking IO.
+Reel provides no built-in thread pool,
+however you can build one yourself using Celluloid.pool,
+or because Celluloid already pools threads to begin with,
+you can simply use an actor per connection.
 
 This gives you the best of both worlds: non-blocking I/O for when you're
 primarily I/O bound, and threads for where you're compute bound.
@@ -59,6 +62,15 @@ Node.js (0.6.5)     11735 reqs/s  (0.1 ms/req)
 All Ruby benchmarks done on Ruby 1.9.3. Latencies given are average-per-request
 and are not amortized across all concurrent requests.
 
+Documentation
+-------------
+
+[Please see the Reel Wiki](https://github.com/celluloid/reel/wiki)
+for detailed documentation and usage notes.
+
+[YARD documentation](http://rubydoc.info/github/celluloid/reel/master/frames) is
+also available.
+
 Framework Adapters
 ------------------
 
@@ -97,8 +109,8 @@ MyApp = Webmachine::Application.new do |app|
 
     # Optional: handler for incoming websockets
     config.adapter_options[:websocket_handler] = proc do |websocket|
-      # socket is a Reel::WebSocket
-      socket << "hello, world"
+      # websocket is a Reel::WebSocket
+      websocket << "hello, world"
     end
   end
 end
@@ -112,8 +124,6 @@ for further information
 Ruby API
 --------
 
-*NOTE: these examples are for the Reel 0.4.0.pre2 API*
-
 Reel aims to provide a "bare metal" API that other frameworks (such as Rack
 and Webmachine) can leverage. This API can also be nice in performance critical
 applications.
@@ -125,7 +135,7 @@ Reel lets you pass a block to initialize which receives connections:
 ```ruby
 require 'reel'
 
-Reel::Server.supervise("0.0.0.0", 3000) do |connection|
+Reel::Server::HTTP.supervise("0.0.0.0", 3000) do |connection|
   # Support multiple keep-alive requests per connection
   connection.each_request do |request|
     # WebSocket support
@@ -156,7 +166,7 @@ You can also subclass Reel, which allows additional customizations:
 ```ruby
 require 'reel'
 
-class MyServer < Reel::Server
+class MyServer < Reel::Server::HTTP
   def initialize(host = "127.0.0.1", port = 3000)
     super(host, port, &method(:on_connection))
   end
@@ -164,7 +174,7 @@ class MyServer < Reel::Server
   def on_connection(connection)
     connection.each_request do |request|
       if request.websocket?
-        handle_websocket(request)
+        handle_websocket(request.websocket)
       else
         handle_request(request)
       end

data/benchmarks/hello_reel.rb

@@ -5,7 +5,7 @@ require 'reel'
 addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on #{addr}:#{port}"
-Reel::Server.new(addr, port) do |connection|
+Reel::Server::HTTP.new(addr, port) do |connection|
   connection.respond :ok, "Hello World"
 end
 

data/benchmarks/reel_pool.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'reel'
+
+class MyConnectionHandler
+  include Celluloid
+
+  def handle_connection(connection)
+    connection.each_request { |req| handle_request(req) }
+  rescue Reel::SocketError
+    connection.close
+  end
+
+  def handle_request(request)
+    request.respond :ok, ''
+  end
+end
+
+connectionPool = MyConnectionHandler.pool
+
+Reel::Server::HTTP.run('127.0.0.1', 3000) do |connection|
+  # We're handing this connection off to another actor, so
+  # we detach it first before handing it off
+  connection.detach
+
+  # Let a Connection Pool handle the connections for Roflscale Applications
+  connectionPool.async.handle_connection(connection)
+end

data/examples/hello_world.rb

@@ -7,8 +7,8 @@ require 'reel'
 
 addr, port = '127.0.0.1', 1234
 
-puts "*** Starting server on #{addr}:#{port}"
-Reel::Server.run(addr, port) do |connection|
+puts "*** Starting server on http://#{addr}:#{port}"
+Reel::Server::HTTP.run(addr, port) do |connection|
   # For keep-alive support
   connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.

data/examples/{ssl_hello_world.rb → https_hello_world.rb}

@@ -12,7 +12,7 @@ options = {
 }
 
 puts "*** Starting server on #{addr}:#{port}"
-Reel::SSLServer.supervise(addr, port, options) do |connection|
+Reel::Server::HTTPS.supervise(addr, port, options) do |connection|
   # For keep-alive support
   connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.

data/examples/roundtrip.rb

@@ -61,7 +61,7 @@ class Reader
   end
 end
 
-class WebServer < Reel::Server
+class WebServer < Reel::Server::HTTP
   include Celluloid::Logger
 
   def initialize(host = "0.0.0.0", port = 9000)

data/examples/server_sent_events.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# See: http://www.w3.org/TR/eventsource/
 # Run with: bundle exec examples/server_sent_events.rb
 # Test with: curl -vNH 'Accept: text/event-stream' -H 'Last-Event-ID: 1' -H 'Cache-Control: no-cache' http://localhost:63310
 
@@ -6,62 +7,65 @@ require 'bundler/setup'
 require 'time'
 require 'reel'
 
-class ServerSentEvents < Reel::Server
+
+class ServerSentEvents < Reel::Server::HTTP
   include Celluloid::Logger
   
   def initialize(ip = '127.0.0.1', port = 63310)
     @connections = []
     @history = []
-    @lastMessageId = 0
+    @lastEventId = 0
     async.ping
-    async.ring
+    async.ring #not needed for Production, only to have some events here.
     super(ip, port, &method(:on_connection))
   end
 
+  #broadcasts events to all clients
   def broadcast(event, data)
     #only keep the last 5000 Events
     if @history.size >= 6000
       @history.slice!(0, @history.size - 1000)
     end
-    @lastMessageId += 1
-    @history << {id: @lastMessageId, event: event, data: data}
+    @lastEventId += 1
+    @history << {id: @lastEventId, event: event, data: data}
     info "Sending Event: #{event} Data: #{data} to #{@connections.count} Clients"
     @connections.each do |socket|
-      async.send_sse(socket, data, event, @lastMessageId)
+      async.send_sse(socket, data, event, @lastEventId)
     end
     true
   end
 
   private
-  #event and id are optional
+  #event and id are optional, Eventsource only needs data
   def send_sse(socket, data, event = nil, id = nil)
     begin
       socket.id id if id
       socket.event event if event
       socket.data data
-    rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-      @connections.delete(socket)
+    rescue Reel::SocketError, NoMethodError
+      @connections.delete(socket) if @connections.include?(socket)
     end
   end
 
+  #Lines that start with a Colon are Comments and will be ignored
   def send_ping
     @connections.each do |socket|
       begin
-        #Lines that start with a Colon are Comments and will be ignored
         socket << ":\n"
-      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+      rescue Reel::SocketError
         @connections.delete(socket)
       end
     end
   end
 
+  #apache 2.2 closes connections after five seconds when nothing is send, see this as a poor mans Keep-Alive
   def ping
-    #apache 2.2 closes connections after five seconds when nothing is send
     every(5) do
       send_ping
     end
   end
 
+  #only used to have some events here, not needed for Production.
   def ring
     every(2) do
       broadcast(:time, Time.now.httpdate)
@@ -77,19 +81,19 @@ class ServerSentEvents < Reel::Server
         query[key] = value
       end
     end
-    body = Reel::EventStream.new do |socket|
+    #see https://github.com/celluloid/reel/blob/master/lib/reel/stream.rb#L35
+    eventStream = Reel::EventStream.new do |socket|
       @connections << socket
       socket.retry 5000
-      #after a Connection reset resend newer Messages to the Client
+      #after a Connection reset resend newer Messages to the Client, query['lastEventId'] is needed for https://github.com/Yaffle/EventSource
       if @history.count > 0 && id = (request.headers['Last-Event-ID'] || query['lastEventId'])
         begin
-          id = Integer(id)
-          if history = @history.select {|h| h[:id] >= id}.map {|a| "id: %d\nevent: %s\ndata: %s" % [a[:id], a[:event], a[:data]]}.join("\n\n")
+          if history = @history.select {|h| h[:id] >= Integer(id)}.map {|a| "id: %d\nevent: %s\ndata: %s" % [a[:id], a[:event], a[:data]]}.join("\n\n")
             socket << "%s\n\n" % [history]
           else
             socket << "id\n\n"
           end
-        rescue ArgumentError, IOError, Errno::ECONNRESET, Errno::EPIPE
+        rescue ArgumentError, Reel::SocketError
           @connections.delete(socket)
           request.close
         end
@@ -102,7 +106,7 @@ class ServerSentEvents < Reel::Server
       'Content-Type' => 'text/event-stream; charset=utf-8',
       'Cache-Control' => 'no-cache',
       'X-Accel-Buffering' => 'no',
-      'Access-Control-Allow-Origin' => '*'}, body)
+      'Access-Control-Allow-Origin' => '*'}, eventStream)
   end
 
   def on_connection(connection)

data/examples/spy_hello_world.rb

@@ -0,0 +1,22 @@
+#!/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', 1234
+
+puts "*** Starting server on http://#{addr}:#{port}"
+Reel::Server::HTTP.run(addr, port, spy: true) do |connection|
+  # For keep-alive support
+  connection.each_request do |request|
+    # Ordinarily we'd route the request here, e.g.
+    # route request.url
+    request.respond :ok, "hello, world!\n"
+  end
+
+  # Reel takes care of closing the connection for you
+  # If you would like to hand the connection off to another thread or actor,
+  # use, connection.detach and then manually call connection.close when done
+end

data/examples/websockets.rb

@@ -38,7 +38,7 @@ class TimeClient
   end
 end
 
-class WebServer < Reel::Server
+class WebServer < Reel::Server::HTTP
   include Celluloid::Logger
 
   def initialize(host = "127.0.0.1", port = 1234)
@@ -53,11 +53,11 @@ class WebServer < Reel::Server
 
         # 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
+        # Reel::Server::HTTP 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
+        # need to detach it from the Reel::Server (in this case, Reel::Server::HTTP)
         connection.detach
 
         route_websocket request.websocket

data/lib/reel.rb

@@ -2,29 +2,24 @@ require 'uri'
 
 require 'http/parser'
 require 'http'
-
-require 'celluloid/autostart'
 require 'celluloid/io'
 
 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/server/http'
+require 'reel/server/https'
+
 require 'reel/websocket'
 require 'reel/stream'
 
 # A Reel good HTTP server
 module Reel
-
   # Error reading a request
   class RequestError < StandardError; end
 
@@ -44,4 +39,6 @@ module Reel
   # The method given was not understood
   class UnsupportedMethodError < ArgumentError; end
 
+  # wrong state for a given operation
+  class StateError < RuntimeError; end
 end

data/lib/reel/connection.rb

@@ -1,17 +1,18 @@
+require 'reel/request'
+
 module Reel
   # A connection to the HTTP server
   class Connection
     include HTTPVersionsMixin
     include ConnectionMixin
 
-    class StateError < RuntimeError; end # wrong state for a given operation
-
     CONNECTION         = 'Connection'.freeze
     TRANSFER_ENCODING  = 'Transfer-Encoding'.freeze
     KEEP_ALIVE         = 'Keep-Alive'.freeze
     CLOSE              = 'close'.freeze
 
-    attr_reader :socket, :parser
+    attr_reader   :socket, :parser, :current_request
+    attr_accessor :request_state, :response_state
 
     # Attempt to read this much data
     BUFFER_SIZE = 16384
@@ -23,10 +24,10 @@ module Reel
       @keepalive   = true
       @buffer_size = buffer_size || BUFFER_SIZE
       @parser      = Request::Parser.new(self)
-      @writer      = Response::Writer.new(socket)
+      @request_fsm = Request::StateMachine.new(@socket)
 
       reset_request
-      @response_state = :header
+      @response_state = :headers
     end
 
     # Is the connection still active?
@@ -42,12 +43,11 @@ module Reel
     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
+      unless @request_fsm.state == :headers || @request_fsm.state == :body
+        raise StateError, "can't read in the '#{@request_fsm.state}' request state"
+      end
 
-    def current_request
-      @current_request
+      @parser.readpartial(size)
     end
 
     # Read a request object from the connection
@@ -55,14 +55,13 @@ module Reel
       raise StateError, "already processing a request" if current_request
 
       req = @parser.current_request
-      @request_state = :ready
+      @request_fsm.transition :headers
       @keepalive = false if req[CONNECTION] == CLOSE || req.version == HTTP_VERSION_1_0
       @current_request = req
 
       req
     rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-      # The client is disconnected
-      @request_state = :closed
+      @request_fsm.transition :closed
       @keepalive = false
       nil
     end
@@ -83,7 +82,7 @@ module Reel
     # 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 != :headers
 
       if headers_or_body.is_a? Hash
         headers = headers_or_body
@@ -105,36 +104,26 @@ module Reel
       else raise TypeError, "invalid response: #{response.inspect}"
       end
 
-      @writer.handle_response(response)
+      if current_request
+        current_request.handle_response(response)
+      else
+        raise RequestError
+      end
 
       # Enable streaming mode
       if response.chunked? and response.body.nil?
         @response_state = :chunked_body
-      end
-    rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-      # The client disconnected early
-      @keepalive = false
-    ensure
-      if @keepalive
-        reset_request(:ready)
+      elsif @keepalive
+        reset_request
       else
-        @socket.close unless @socket.closed?
-        reset_request(:closed)
+        @current_request = nil
+        @parser.reset
+        @request_fsm.transition :closed
       end
-    end
-
-    # Write body chunks directly to the connection
-    def write(chunk)
-      raise StateError, "not in chunked body mode" unless @response_state == :chunked_body
-      @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
-      @writer.finish_response
-      @response_state = :header
+    rescue IOError, Errno::ECONNRESET, Errno::EPIPE, RequestError
+      # The client disconnected early, or there is no request
+      @keepalive = false
+      @request_fsm.transition :closed
     end
 
     # Close the connection
@@ -149,11 +138,12 @@ module Reel
     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
+      if @request_fsm != :ready && @response_state != :headers
         raise StateError, "connection is not in a hijackable state"
       end
 
-      @request_state = @response_state = :hijacked
+      @request_fsm.transition :hijacked
+      @response_state = :hijacked
       socket  = @socket
       @socket = nil
       socket
@@ -166,11 +156,19 @@ module Reel
     end
 
     # Reset the current request state
-    def reset_request(state = :ready)
-      @request_state = state
+    def reset_request
+      @request_fsm.transition :headers
       @current_request = nil
       @parser.reset
     end
     private :reset_request
+
+    # Set response state for the connection.
+    def response_state=(state)
+      if state == :headers
+        reset_request
+      end
+      @response_state = state
+    end
   end
 end