reel 0.1.0 → 0.2.0.pre

data/.travis.yml

@@ -1,13 +1,10 @@
 rvm:
   - 1.9.2
   - 1.9.3
-  - ruby-head
+#  - ruby-head http_parser.rb not working :(
   - jruby-19mode
   - jruby-head
-
-# Rubies I would like to support, but they deadlock
-#  - rbx-18mode
-#  - rbx-19mode
+#  - rbx-19mode choking on string encodings
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,4 +1,8 @@
+HEAD
+----
+* Initial WebSockets support via Reel::WebSocket
+* Experimental Rack adapter by Alberto Fernández-Capel
+
 0.1.0
 -----
-
-* First official release
+* Initial release

data/README.md

@@ -3,14 +3,14 @@
 [![Build Status](https://secure.travis-ci.org/celluloid/reel.png?branch=master)](http://travis-ci.org/celluloid/reel)
 
 Reel is a fast, non-blocking "evented" web server built on [http_parser.rb][parser],
-[Celluloid::IO][celluloidio], and [nio4r][nio4r]. It's probably most similar to
-[Goliath][goliath], but thanks to Celluloid also works great for multithreaded
-applications and provides traditional multithreaded blocking I/O support too.
+[libwebsocket][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
 [celluloidio]: https://github.com/celluloid/celluloid-io
 [nio4r]: https://github.com/tarcieri/nio4r
-[Goliath]: http://postrank-labs.github.com/goliath/
 
 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,12 +63,24 @@ Reel provides an extremely simple API:
 require 'reel'
 
 Reel::Server.supervise("0.0.0.0", 3000) do |connection|
-  request = connection.request
-  puts "Client requested: #{request.method} #{request.url}"
-  connection.respond :ok, "hello, world"
+  while request = connection.request
+    when Reel::Request
+      puts "Client requested: #{request.method} #{request.url}"
+      connection.respond :ok, "hello, world"
+    when Reel::WebSocket
+      puts "Client made a WebSocket request to: #{request.url}"
+      request << "Hello there"
+      connection.close
+      break
+    end
+  end
 end
 ```
 
+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
 ------
 

data/bin/reel

@@ -2,13 +2,57 @@
 
 require 'reel'
 
-host, port = "0.0.0.0", 3000
+options = {}
 
-Reel::Logger.info "A Reel good HTTP server!"
-Reel::Logger.info "Listening on #{host}:#{port}"
+parser = OptionParser.new do |opts|
+  opts.on "-p", "--port PORT", Integer,
+  "Define what port TCP port to bind to (default: 3000)" do |arg|
+    options[:port] = arg
+  end
+
+  opts.on "-a", "--address HOST",
+  "bind to HOST address (default: 0.0.0.0)" do |arg|
+    options[:host] = arg
+  end
+
+  opts.on "-q", "--quiet", "Quiet down the output" do
+    options[:quiet] = true
+  end
+
+  opts.on "-e", "--environment ENVIRONMENT",
+  "The environment to run the Rack app on (default: development)" do |arg|
+    options[:environment] = arg
+  end
+
+  opts.on "-t", "--threads NUM", Integer,
+  "The number of worker threads (default: 10)" do |arg|
+    options[:workers] = arg
+  end
+
+  opts.on "-r", "--rackup FILE",
+  "Load Rack config from this file (default: config.ru)" do |arg|
+    options[:rackup] = arg
+  end
+end
+
+parser.banner = "reel <options> <rackup file>"
 
-Reel::Server.supervise("0.0.0.0", 3000) do |connection|
-  p connection
+parser.on_tail "-h", "--help", "Show help" do
+  puts parser
+  exit 1
 end
 
+parser.parse(ARGV)
+
+if ARGV.last =~ /\.ru$/
+  options[:rackup] = @argv.shift
+end
+
+handler = Rack::Handler::Reel.new(options)
+
+Reel::Logger.info "A Reel good HTTP server!"
+Reel::Logger.info "Listening on #{handler[:host]}:#{handler[:port]}"
+
+handler.start
+
 sleep

data/examples/hello_world.rb

@@ -6,7 +6,13 @@ addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on #{addr}:#{port}"
 Reel::Server.new(addr, port) do |connection|
-  connection.respond :ok, "hello, world!"
-end
+  # 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
 
-sleep
+  # Reel takes care of closing the connection
+end

data/examples/websockets.rb

@@ -0,0 +1,124 @@
+# FIXME: not quite complete yet, but it should give you an idea
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+class TimeServer
+  include Celluloid
+  include Celluloid::Notifications
+
+  def initialize
+    run!
+  end
+
+  def run
+    now = Time.now.to_f
+    sleep now.ceil - now + 0.001
+
+    every(1) { publish 'time_change', Time.now }
+  end
+end
+
+class TimeClient
+  include Celluloid
+  include Celluloid::Notifications
+  include Celluloid::Logger
+
+  def initialize(websocket)
+    info "Streaming time changes to client"
+    @socket = websocket
+    subscribe('time_change', :notify_time_change)
+  end
+
+  def notify_time_change(topic, new_time)
+    @socket << new_time.inspect
+  rescue Reel::SocketError
+    info "Time client disconnected"
+    terminate
+  end
+end
+
+class WebServer < Reel::Server
+  include Celluloid::Logger
+
+  def initialize(host = "127.0.0.1", port = 1234)
+    info "Time server 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 == "/timeinfo"
+      TimeClient.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 time server 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>
+      <script>
+        var SocketKlass = "MozWebSocket" in window ? MozWebSocket : WebSocket;
+        var ws = new SocketKlass('ws://' + window.location.host + '/timeinfo');
+        ws.onmessage = function(msg){
+          document.getElementById('current-time').innerHTML = msg.data;
+        }
+      </script>
+      <body>
+        <div id="content">
+          <h1>Time Server Example</h1>
+          <div>The time is now: <span id="current-time">...</span></div>
+        </div>
+      </body>
+      </html>
+    HTML
+  end
+end
+
+TimeServer.supervise_as :time_server
+WebServer.supervise_as :reel
+
+sleep

data/lib/rack/handler/reel.rb

@@ -0,0 +1,84 @@
+require 'reel'
+
+module Rack
+  module Handler
+    class Reel
+      attr_reader :options
+
+      # Don't mess with Rack::File
+      File = ::File
+
+      DEFAULT_OPTIONS = {
+        :host    => "0.0.0.0",
+        :port    => 3000,
+        :quiet   => false,
+        :workers => 10,
+        :rackup  => "config.ru"
+      }
+
+      def self.run(app, options = {})
+
+        handler = Reel.new(options)
+
+        ::Reel::Logger.info "A Reel good HTTP server!"
+        ::Reel::Logger.info "Listening on #{handler[:host]}:#{handler[:port]}"
+
+        handler.start
+      end
+
+      def initialize(opts = {})
+        opts  = normalize_options(opts)
+
+        @options = DEFAULT_OPTIONS.merge(opts)
+
+        if @options[:environment]
+          ENV['RACK_ENV'] = @options[:environment].to_s
+        end
+      end
+
+      def start
+        Celluloid::Actor[:reel_rack_pool] = ::Reel::RackWorker.pool(size: options[:workers], args: [self])
+
+        ::Reel::Server.supervise_as(:reel_server, options[:host], options[:port]) do |connection|
+          Celluloid::Actor[:reel_rack_pool].handle(connection.detach)
+        end
+
+        sleep
+      end
+
+      def [](option)
+        @options[option]
+      end
+
+      def rack_app
+        return @options[:app] if @options[:app]
+
+        path = @options[:rackup]
+
+        unless File.exists?(path)
+          raise "Missing rackup file '#{path}'"
+        end
+
+        @options[:app], options = Rack::Builder.parse_file path
+        @options.merge! options
+
+        unless @options[:quiet]
+          @options[:app] = Rack::CommonLogger.new(@options[:app], STDOUT)
+        end
+
+        @options[:app]
+      end
+
+      private
+
+      # Transform the options that rails s reel passes
+      def normalize_options(options)
+        options.inject({}) { |h, (k,v)|  h[k.downcase] = v ; h }
+        options[:rackup] = options[:config] if options[:config]
+        options
+      end
+    end
+
+    register :reel, Reel
+  end
+end

data/lib/reel.rb

@@ -10,9 +10,24 @@ require 'reel/request'
 require 'reel/request_parser'
 require 'reel/response'
 require 'reel/server'
+require 'reel/websocket'
+
+require 'rack'
+require 'rack/handler'
+require 'rack/handler/reel'
+require 'reel/rack_worker'
 
 # A Reel good HTTP server
 module Reel
+  # Error reading a request
+  class RequestError < StandardError; end
+
+  # Error occured performing IO on a socket
+  class SocketError < RequestError; end
+
+  # Error occured during a WebSockets handshake
+  class HandshakeError < RequestError; end
+
   # The method given was not understood
   class UnsupportedMethodError < ArgumentError; end
 end

data/lib/reel/connection.rb

@@ -3,15 +3,16 @@ module Reel
   class Connection
     class StateError < RuntimeError; end # wrong state for a given operation
 
-    attr_reader :request
+    attr_reader :socket, :parser
 
     # Attempt to read this much data
     BUFFER_SIZE = 4096
 
     def initialize(socket)
-      @socket = socket
+      @attached  = true
+      @socket    = socket
       @keepalive = true
-      @parser = Request::Parser.new
+      @parser    = Request::Parser.new
       reset_request
 
       @response_state = :header
@@ -21,44 +22,59 @@ module Reel
     # Is the connection still active?
     def alive?; @keepalive; end
 
+    # Is the connection still attached to a Reel::Server?
+    def attached?; @attached; end
+
+    # Detach this connection from the Reel::Server and manage it independently
+    def detach
+      @attached = false
+      self
+    end
+
     # Reset the current request state
-    def reset_request
-      @request_state = :header
-      @request = nil
+    def reset_request(state = :header)
+      @request_state = state
+      @header_buffer = "" # Buffer headers in case of an upgrade request
       @parser.reset
     end
 
-    # Read a request object from the connection
-    def read_request
-      raise StateError, "can't read header" unless @request_state == :header
-
-      begin
-        @parser << @socket.readpartial(BUFFER_SIZE) until @parser.headers
-      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-        @keepalive = false
-        @socket.close unless @socket.closed?
-        return
-      end
-
-      @request_state = :body
+    def peer_address
+      @socket.peeraddr(false)
+    end
 
-      headers = {}
-      @parser.headers.each do |field, value|
-        headers[Http.canonicalize_header(field)] = value
-      end
+    def local_address
+      @socket.addr(false)
+    end
 
-      if headers['Connection']
-        @keepalive = false if headers['Connection'] == 'close'
-      elsif @parser.http_version == "1.0"
-        @keepalive = false
+    # 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 == "1.0"
+        @body_remaining = Integer(req['Content-Length']) if req['Content-Length']
+      when WebSocket
+        @request_state = @response_state = :websocket
+        @body_remaining = nil
+        @socket = nil
+      else raise "unexpected request type: #{req.class}"
       end
 
-      @body_remaining = Integer(headers['Content-Length']) if headers['Content-Length']
-      @request = Request.new(@parser.http_method, @parser.url, @parser.http_version, headers, self)
+      req
+    rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+      # The client is disconnected
+      @request_state = :closed
+      @keepalive = false
+      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
+
       if @body_remaining and @body_remaining > 0
         chunk = @parser.chunk
         unless chunk
@@ -110,11 +126,10 @@ module Reel
       @keepalive = false
     ensure
       if @keepalive
-        reset_request
-        @request_state = :header
+        reset_request(:header)
       else
         @socket.close unless @socket.closed?
-        @request_state = :closed
+        reset_request(:closed)
       end
     end