reel 0.2.0 → 0.3.0.pre

data/.travis.yml

@@ -1,10 +1,9 @@
 rvm:
-  - 1.9.2
   - 1.9.3
-#  - ruby-head http_parser.rb not working :(
+  - ruby-head
   - jruby-19mode
   - jruby-head
-#  - rbx-19mode choking on string encodings
+  - rbx-19mode
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,5 +1,15 @@
-HEAD
-----
+0.3.0
+-----
+* Reel::App: Sinatra-like DSL for defining Reel apps using Octarine
+* Chunked upload support
+* Lots of additional work on the Rack adapter
+* Expose websockets through Rack as rack.websocket
+* Performance optimization work
+* Bugfix: Send CRLF after chunks
+* Bugfix: Increase TCP connection backlog to 1024
+
+0.2.0
+-----
 * Initial WebSockets support via Reel::WebSocket
 * Experimental Rack adapter by Alberto Fernández-Capel
 * Octarine (Sinatra-like DSL) support by Grant Rodgers

data/README.md

@@ -1,14 +1,16 @@
 ![Reel](https://github.com/celluloid/reel/raw/master/logo.png)
 =======
 [![Build Status](https://secure.travis-ci.org/celluloid/reel.png?branch=master)](http://travis-ci.org/celluloid/reel)
+[![Dependency Status](https://gemnasium.com/celluloid/reel.png)](https://gemnasium.com/celluloid/reel)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/celluloid/reel)
 
 Reel is a fast, non-blocking "evented" web server built on [http_parser.rb][parser],
-[libwebsocket][websockets],[ Celluloid::IO][celluloidio], and [nio4r][nio4r]. Thanks
+[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/imanel/websocket-ruby
+[websockets]: https://github.com/afcapel/websocket_parser
 [celluloidio]: https://github.com/celluloid/celluloid-io
 [nio4r]: https://github.com/tarcieri/nio4r
 
@@ -24,9 +26,10 @@ primarily I/O bound, and threads for where you're compute bound.
 
 ### Is it any good?
 
-[Yes](http://news.ycombinator.com/item?id=3067434),
-but it has room for improvement. A "hello world" web server benchmark,
-run on a 2GHz i7 (OS X 10.7.3). All servers used in a single-threaded mode.
+[Yes](http://news.ycombinator.com/item?id=3067434)
+
+Here's a "hello world" web server benchmark, run on a 2GHz i7 (OS X 10.7.3).
+All servers used in a single-threaded mode.
 
 Reel performance on various Ruby VMs:
 
@@ -35,10 +38,9 @@ Reel performance on various Ruby VMs:
 
 Ruby Version        Throughput    Latency
 ------------        ----------    -------
-JRuby HEAD          5650 reqs/s   (0.2 ms/req)
-Ruby 1.9.3          5263 reqs/s   (0.2 ms/req)
-JRuby 1.6.7         4303 reqs/s   (0.2 ms/req)
+JRuby 1.7.0         3978 req/s    (0.3 ms/req)
 rbx HEAD            2288 reqs/s   (0.4 ms/req)
+Ruby 1.9.3          2071 req/s    (0.5 ms/req)
 ```
 
 Comparison with other web servers:
@@ -54,10 +56,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.
 
-Usage
------
+API
+---
+
+Reel also provides a "bare metal" API which was used in the benchmarks above.
+Here are some examples:
+
+### Block Form
 
-Reel provides an extremely simple API:
+Reel lets you pass a block to initialize which receives connections:
 
 ```ruby
 require 'reel'
@@ -67,11 +74,11 @@ Reel::Server.supervise("0.0.0.0", 3000) do |connection|
     case request
     when Reel::Request
       puts "Client requested: #{request.method} #{request.url}"
-      connection.respond :ok, "hello, world"
+      request.respond :ok, "Hello, world!"
     when Reel::WebSocket
       puts "Client made a WebSocket request to: #{request.url}"
-      request << "Hello there"
-      connection.close
+      request << "Hello everyone out there in WebSocket land"
+      request.close
       break
     end
   end
@@ -82,12 +89,91 @@ When we read a request from the incoming connection, we'll either get back
 a Reel::Request object, indicating a normal HTTP connection, or a
 Reel::WebSocket object for WebSockets connections.
 
-Status
-------
+### Subclass Form
+
+You can also subclass Reel, which allows additional customizations:
+
+```ruby
+require 'reel'
+
+class MyServer < Reel::Server
+  def initialize(host = "127.0.0.1", port = 3000)
+    super(host, port, &method(:on_connection))
+  end
+
+  def on_connection(connection)
+    while request = connection.request
+      case request
+      when Reel::Request
+        handle_request(request)
+      when Reel::WebSocket
+        handle_websocket(request)
+      end
+    end
+  end
+
+  def handle_request(request)
+    request.respond :ok, "Hello, world!"
+  end
+
+  def handle_websocket(sock)
+    sock << "Hello everyone out there in WebSocket land!"
+    sock.close
+  end
+end
+
+MyServer.run
+```
+
+Framework Adapters
+------------------
+### Rack
+
+Reel can be used as a standard Rack server via the "reel" command line
+application. Please be aware that Rack support is experimental and that there
+are potential complications between using large numbers of rack middlewares
+and the limited 4kB stack depth of Ruby Fibers, which are used extensively
+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 really leverage Reel's capabilities, you must use Reel via its own API,
+or another Ruby library with direct Reel support.
+
+### Webmachine
+
+The most notable library with native Reel support is
+[webmachine-ruby](https://github.com/seancribbs/webmachine-ruby),
+an advanced HTTP framework for Ruby with a complete state machine for proper
+processing of HTTP/1.1 requests. Together with Reel, Webmachine provides
+full streaming support for both requests and responses.
+
+To use Reel with Webmachine, add the following to your Gemfile:
+
+```ruby
+gem 'webmachine', git: 'git://github.com/seancribbs/webmachine-ruby.git'
+```
+
+Then use `config.adapter = :Reel` when configuring a Webmachine app, e.g:
+
+```ruby
+MyApp = Webmachine::Application.new do |app|
+  app.routes do
+    add ['*'], MyHome
+  end
+
+  app.configure do |config|
+    config.ip      = MYAPP_IP
+    config.port    = MYAPP_PORT
+    config.adapter = :Reel
+  end
+end
+
+MyApp.run
+```
 
-Reel is still in an extremely early stage of development and may be
-missing a lot of features. It seems to be doing a rudimentary job of
-speaking HTTP and has basic keep-alive support.
+See the [Webmachine documentation](http://rubydoc.info/gems/webmachine/frames/file/README.md)
+for further information
 
 Contributing
 ------------

data/bin/reel

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'reel'
+require 'optparse'
 
 options = {}
 
@@ -55,4 +56,4 @@ Reel::Logger.info "Listening on #{handler[:host]}:#{handler[:port]}"
 
 handler.start
 
-sleep
+sleep

data/examples/chunked.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+app = Rack::Builder.new do
+  map '/' do
+    run lambda { |env|
+      body = Reel::ChunkStream.new do |body|
+        # sending a payload to make sure browsers will render chunks as received
+        body << "<html>#{' '*1024}\n"
+        ('A'..'Z').each do |l|
+          body << "<div>#{l}</div>\n"
+          sleep 0.5
+        end
+        body << "</html>\n"
+        body.finish
+      end
+      [200, {
+        'Content-Type' => 'text/html'
+        }, body]
+    }
+  end
+end.to_app
+
+Rack::Handler::Reel.run app, Port: 9292

data/examples/hello_world.rb

@@ -1,3 +1,6 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/hello_world.rb
+
 require 'rubygems'
 require 'bundler/setup'
 require 'reel'
@@ -5,7 +8,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.run(addr, port) 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

data/examples/roundtrip.rb

@@ -0,0 +1,157 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+
+class RoundtripServer 
+  include Celluloid
+  include Celluloid::Notifications
+
+  def initialize
+    async.run
+  end
+
+  def run
+    now = Time.now.to_f
+    sleep now.ceil - now + 0.001
+    every(1) do 
+      publish 'read_message'
+      end
+  end
+end
+
+class Writer
+  include Celluloid
+  include Celluloid::Notifications
+  include Celluloid::Logger
+
+  def initialize(websocket)
+    info "Writing to socket"
+    @socket = websocket
+    subscribe('write_message', :new_message)
+  end
+
+  def new_message(topic, new_time)
+    @socket << new_time.inspect
+  rescue Reel::SocketError
+    info "WS client disconnected"
+    terminate
+  end
+
+end
+
+class Reader
+  include Celluloid
+  include Celluloid::Notifications
+  include Celluloid::Logger
+
+  def initialize(websocket)
+    info "Reading socket"
+    @socket = websocket
+    subscribe('read_message', :new_message)
+  end
+
+   def new_message(topic)
+    msg = @socket.read
+    publish 'write_message', msg 
+  rescue Reel::SocketError, EOFError
+    info "WS client disconnected"
+    terminate
+  end
+end
+
+class WebServer < Reel::Server
+  include Celluloid::Logger
+
+  def initialize(host = "0.0.0.0", port = 9000)
+    info "Roundtrip example starting on #{host}:#{port}"
+    super(host, port, &method(:on_connection))
+  end
+
+  def on_connection(connection)
+    while request = connection.request
+      case request
+      when Reel::Request
+        route_request connection, request
+      when Reel::WebSocket
+        info "Received a WebSocket connection"
+        route_websocket request
+      end
+    end
+  end
+
+  def route_request(connection, request)
+    if request.url == "/"
+      return render_index(connection)
+    end
+
+    info "404 Not Found: #{request.path}"
+    connection.respond :not_found, "Not found"
+  end
+
+  def route_websocket(socket)
+    if socket.url == "/ws"
+      Writer.new(socket)
+      Reader.new(socket)
+    else
+      info "Received invalid WebSocket request for: #{socket.url}"
+      socket.close
+    end
+  end
+
+  def render_index(connection)
+    info "200 OK: /"
+    connection.respond :ok, <<-HTML
+      <!doctype html>
+      <html lang="en">
+      <head>
+        <meta charset="utf-8">
+        <title>Reel WebSockets roundtrip example</title>
+        <style>
+          body {
+            font-family: "HelveticaNeue-Light", "Helvetica Neue Light", "Helvetica Neue", Helvetica, Arial, "Lucida Grande", sans-serif;
+            font-weight: 300;
+            text-align: center;
+          }
+
+          #content {
+            width: 800px;
+            margin: 0 auto;
+            background: #EEEEEE;
+            padding: 1em;
+          }
+        </style>
+      </head>
+      <body>
+        <div id="content">
+          <h1>Roundtrip communication with websockets</h1>
+          <div>
+           <input id="text_input" type="text" name="q" value="" autocomplete="off"/>
+           Latest message is: <span id="current-time">...</span></div>
+        </div>
+      </body>
+      <script>
+        var SocketKlass = "MozWebSocket" in window ? MozWebSocket : WebSocket;
+        var ws = new SocketKlass('ws://' + window.location.host + '/ws');
+        ws.onmessage = function(msg){
+          document.getElementById('current-time').innerHTML = msg.data;
+        };
+        var input = document.getElementById("text_input");
+        input.focus();     
+        input.onkeydown = function(evt) {       
+          var evt = evt || window.event;
+          if (evt.keyCode === 13) {
+            ws.send(input.value);console.log(input.value); 
+            input.value = "";  
+          }
+        };
+      </script>
+      </html>
+    HTML
+  end
+end
+
+RoundtripServer.supervise_as :roundtrip_server
+WebServer.supervise_as :reel
+
+sleep

data/examples/server-sent-events.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+Connections = []
+Body = DATA.read
+app = Rack::Builder.new do
+  map '/' do
+    run lambda { |env|
+      [200, {'Content-Type' => 'text/html'}, [Body]]
+    }
+  end
+
+  map '/subscribe' do
+    run lambda { |env|
+      body = Reel::EventStream.new do |socket|
+        Connections << socket
+        socket.on_error { Connections.delete socket }
+      end
+      [200, {'Content-Type' => 'text/event-stream'}, body]
+    }
+  end
+
+  map '/wall' do
+    run lambda { |env|
+      msg = env['PATH_INFO'].gsub(/\/+/, '').strip
+      msg = Time.now if msg.empty?
+      Connections.each { |s| s.data msg }
+      [200, {'Content-Type' => 'text/html'}, ["Sent \"#{msg}\" to #{Connections.size} clients"]]
+    }
+  end
+end.to_app
+
+Rack::Handler::Reel.run app, Port: 9292
+
+__END__
+<!doctype html>
+<html lang="en">
+<body>
+  <div id="content">Waiting for messages...</div>
+</body>
+<script type="text/javascript">
+var evs = new EventSource('/subscribe');
+evs.onmessage = function(e){
+  document.getElementById('content').innerHTML = e.data;
+}
+</script>
+</html>