reel 0.0.0 → 0.0.1

data/.rspec

@@ -0,0 +1,4 @@
+--color 
+--format documentation 
+--backtrace
+--default_path spec

data/.travis.yml

@@ -0,0 +1,10 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+
+# Rubies I would like to support, but they deadlock
+#  - rbx-18mode
+#  - rbx-19mode

data/Gemfile

@@ -1,6 +1,9 @@
-source 'https://rubygems.org'
+source :rubygems
+
+gem 'celluloid',    :git => 'https://github.com/celluloid/celluloid.git'
+gem 'celluloid-io', :git => 'https://github.com/celluloid/celluloid-io.git'
+gem 'jruby-openssl' if defined? JRUBY_VERSION
 
 # Specify your gem's dependencies in reel.gemspec
 gemspec
 
-gem 'celluloid-io', :git => 'https://github.com/tarcieri/celluloid-io.git'

data/README.md

@@ -1,29 +1,90 @@
-# Reel
+![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)
 
-TODO: Write a gem description
+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.
 
-## Installation
+[parser]: https://github.com/tmm1/http_parser.rb
+[celluloidio]: https://github.com/celluloid/celluloid-io
+[nio4r]: https://github.com/tarcieri/nio4r
+[Goliath]: http://postrank-labs.github.com/goliath/
 
-Add this line to your application's Gemfile:
+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.
 
-    gem 'reel'
+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.
 
-And then execute:
+### Is It Good?
 
-    $ bundle
+Yes, 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.
 
-Or install it yourself as:
+Reel performance on various Ruby VMs:
 
-    $ gem install reel
+```
+# httperf --num-conns=50 --num-calls=1000
 
-## Usage
+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)
+rbx HEAD            2288 reqs/s   (0.4 ms/req)
+```
 
-TODO: Write usage instructions here
+Comparison with other web servers:
 
-## Contributing
+```
+Web Server          Throughput    Latency
+----------          ----------    -------
+Goliath (0.9.4)     2058 reqs/s   (0.5 ms/req)
+Thin    (1.2.11)    7502 reqs/s   (0.1 ms/req)
+Node.js (0.6.5)     11735 reqs/s  (0.1 ms/req)
+```
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+All Ruby benchmarks done on Ruby 1.9.3. Latencies given are average-per-request
+and are not amortized across all concurrent requests.
+
+Usage
+-----
+
+Reel provides an extremely simple API:
+
+```ruby
+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"
+end
+```
+
+Status
+------
+
+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.
+
+Contributing
+------------
+
+* Fork this repository on github
+* Make your changes and send me a pull request
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for commit access
+
+License
+-------
+
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
+LICENSE.txt for further details.

data/Rakefile

@@ -1,2 +1,6 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+Dir[File.expand_path("../tasks/**/*.rake", __FILE__)].each { |task| load task }
+
+task :default => :spec

data/benchmarks/hello_goliath.rb

@@ -0,0 +1,11 @@
+# Run with: ruby hello_goliath.rb -sv -e production
+require 'goliath'
+
+class Hello < Goliath::API
+  # default to JSON output, allow Yaml as secondary
+  use Goliath::Rack::Render, ['json', 'yaml']
+
+  def response(env)
+    [200, {}, "Hello World"]
+  end
+end

data/benchmarks/hello_node.js

@@ -0,0 +1,8 @@
+/* Run with: node hello_node.js */
+
+var http = require('http');
+http.createServer(function (req, res) {
+    res.writeHead(200, {'Content-Type': 'text/plain'});
+      res.end('Hello World\n');
+}).listen(1337, "127.0.0.1");
+console.log('Server running at http://127.0.0.1:1337/');

data/benchmarks/hello_rack.ru

@@ -0,0 +1,5 @@
+# Run with: thin -e production -R hello_rack.ru start
+require 'rack'
+
+body = "Hello World"
+run proc { |env| [200, {}, body] }

data/benchmarks/hello_reel.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+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
+
+sleep

data/bin/reel

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'reel'
+
+host, port = "0.0.0.0", 3000
+
+Reel::Logger.info "A Reel good HTTP server!"
+Reel::Logger.info "Listening on #{host}:#{port}"
+
+Reel::Server.supervise("0.0.0.0", 3000) do |connection|
+  p connection
+end
+
+sleep

data/examples/hello_world.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+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
+
+sleep

data/lib/reel.rb

@@ -1,5 +1,18 @@
-require "reel/version"
+require 'http/parser'
+require 'http'
+require 'celluloid/io'
 
+require 'reel/version'
+
+require 'reel/connection'
+require 'reel/logger'
+require 'reel/request'
+require 'reel/request/parser'
+require 'reel/response'
+require 'reel/server'
+
+# A Reel good HTTP server
 module Reel
-  # Your code goes here...
+  # The method given was not understood
+  class UnsupportedMethodError < ArgumentError; end
 end

data/lib/reel/connection.rb

@@ -0,0 +1,103 @@
+module Reel
+  # A connection to the HTTP server
+  class Connection
+    class StateError < RuntimeError; end # wrong state for a given request
+
+    attr_reader :request
+
+    # Attempt to read this much data
+    BUFFER_SIZE = 4096
+
+    def initialize(socket)
+      @socket = socket
+      @keepalive = true
+      reset
+
+      @response_state = :header
+      @body_remaining = nil
+    end
+
+    # Is the connection still active?
+    def alive?; @keepalive; end
+
+    def read_request
+      raise StateError, "can't read header" unless @request_state == :header
+
+      begin
+        until @parser.headers
+          @parser << @socket.readpartial(BUFFER_SIZE)
+        end
+      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+        @keepalive = false
+        @socket.close unless @socket.closed?
+        return
+      end
+
+      @request_state = :body
+
+      headers = {}
+      @parser.headers.each do |header, value|
+        headers[Http.canonicalize_header(header)] = value
+      end
+
+      if headers['Connection']
+        @keepalive = false if headers['Connection'] == 'close'
+      elsif @parser.http_version == "1.0"
+        @keepalive = false
+      end
+
+      @body_remaining = Integer(headers['Content-Length']) if headers['Content-Length']
+      @request = Request.new(@parser.http_method, @parser.url, @parser.http_version, headers, self)
+    end
+
+    def readpartial(size = BUFFER_SIZE)
+      if @body_remaining and @body_remaining > 0
+        chunk = @parser.chunk
+        unless chunk
+          @parser << @socket.readpartial(size)
+          chunk = @parser.chunk
+          return unless chunk
+        end
+
+        @body_remaining -= chunk.length
+        @body_remaining = nil if @body_remaining < 1
+
+        chunk
+      end
+    end
+
+    def respond(response, body = nil)
+      if @keepalive
+        headers = {'Connection' => 'Keep-Alive'}
+      else
+        headers = {'Connection' => 'close'}
+      end
+
+      case response
+      when Symbol
+        response = Response.new(response, headers, body)
+      when Response
+      else raise TypeError, "invalid response: #{response.inspect}"
+      end
+
+      response.render(@socket)
+    rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+      # The client disconnected early
+      @keepalive = false
+    ensure
+      if @keepalive
+        reset
+        @request_state = :header
+      else
+        @socket.close unless @socket.closed?
+        @request_state = :closed
+      end
+    end
+
+    def reset
+      @request_state = :header
+      @parser = Request::Parser.new
+      @request = nil
+    end
+  end
+end

data/lib/reel/logger.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+module Reel
+  module Logger
+    @logger = ::Logger.new STDERR
+    module_function
+    
+    def logger=(logger)
+      @logger = logger
+    end
+    
+    def logger
+      @logger
+    end
+    
+    def debug(msg); @logger.debug(msg); end
+    def info(msg);  @logger.info(msg);  end
+    def warn(msg);  @logger.warn(msg);  end
+    def error(msg); @logger.error(msg); end
+  end
+end

data/lib/reel/request.rb

@@ -0,0 +1,33 @@
+module Reel
+  class Request
+    attr_accessor :method, :version, :url
+    METHODS = [:get, :head, :post, :put, :delete, :trace, :options, :connect, :patch]
+    
+    def initialize(method, url, version = "1.1", headers = {}, connection = nil)
+      @method = method.to_s.downcase.to_sym
+      raise UnsupportedArgumentError, "unknown method: #{method}" unless METHODS.include? @method
+      
+      @url, @version, @headers, @connection = url, version, headers, connection
+    end
+    
+    def [](header)
+      @headers[header]
+    end
+    
+    def body
+      @body ||= begin
+        raise "no connection given" unless @connection
+        
+        body = "" unless block_given?
+        while (chunk = @connection.readpartial)
+          if block_given?
+            yield chunk
+          else
+            body << chunk
+          end
+        end
+        body unless block_given?
+      end
+    end
+  end
+end

data/lib/reel/request/parser.rb

@@ -0,0 +1,63 @@
+module Reel
+  # Parses incoming HTTP requests
+  class Request
+    class Parser
+      attr_reader :headers
+
+      def initialize
+        @parser = Http::Parser.new(self)
+        @headers = nil
+        @finished = false
+        @chunk = nil
+      end
+
+      def add(data)
+        @parser << data
+      end
+      alias_method :<<, :add
+
+      def headers?
+        !!@headers
+      end
+
+      def http_method
+        @parser.http_method.downcase.to_sym
+      end
+
+      def http_version
+        @parser.http_version.join(".")
+      end
+
+      def url
+        @parser.request_url
+      end
+
+      #
+      # Http::Parser callbacks
+      #
+
+      def on_headers_complete(headers)
+        @headers = headers
+      end
+
+      def on_body(chunk)
+        if @chunk
+          @chunk << chunk
+        else
+          @chunk = chunk
+        end
+      end
+
+      def chunk
+        if (chunk = @chunk)
+          @chunk = nil
+          chunk
+        end
+      end
+
+      def on_message_complete
+        @finished = true
+      end
+    end
+  end
+end

data/lib/reel/response.rb

@@ -0,0 +1,68 @@
+module Reel
+  class Response
+    # Use status code tables from the Http gem
+    STATUS_CODES          = Http::Response::STATUS_CODES
+    SYMBOL_TO_STATUS_CODE = Http::Response::SYMBOL_TO_STATUS_CODE
+    CRLF = "\r\n"
+    
+    attr_reader   :status # Status has a special setter to coerce symbol names
+    attr_accessor :reason
+
+    def initialize(status, body_or_headers = nil, body = nil)
+      self.status = status
+
+      if body_or_headers and not body
+        @body = body_or_headers
+        @headers = {}
+      else
+        @body = body
+        @headers = body_or_headers
+      end
+
+      if @body
+        @headers['Content-Length'] ||= @body.length
+      end
+
+      # FIXME: real HTTP versioning
+      @version = "HTTP/1.1"
+    end
+
+    # Set the status
+    def status=(status, reason=nil)
+      case status
+      when Integer
+        @status = status
+        @reason ||= STATUS_CODES[status]
+      when Symbol 
+        if code = SYMBOL_TO_STATUS_CODE[status]
+          self.status = code
+        else
+          raise ArgumentError, "unrecognized status symbol: #{status}"
+        end
+      else
+        raise TypeError, "invalid status type: #{status.inspect}"
+      end
+    end
+
+    # Write the response out to the wire
+    def render(socket)
+      socket << render_header
+      socket << @body
+    end
+
+    # Convert headers into a string
+    # FIXME: this should probably be factored elsewhere, SRP and all
+    def render_header
+      response_header = "#{@version} #{@status} #{@reason}#{CRLF}"
+
+      unless @headers.empty?
+        response_header << @headers.map do |header, value|
+          "#{header}: #{value}"
+        end.join(CRLF) << CRLF
+      end
+
+      response_header << CRLF
+    end
+    private :render_header
+  end
+end

data/lib/reel/server.rb

@@ -0,0 +1,31 @@
+module Reel
+  class Server
+    include Celluloid::IO
+    
+    def initialize(host, port, &callback)
+      # This is actually an evented Celluloid::IO::TCPServer
+      @server = TCPServer.new(host, port)
+      @callback = callback
+      run!
+    end
+    
+    def finalize
+      @server.close
+    end
+    
+    def run
+      loop { handle_connection! @server.accept }
+    end
+    
+    def handle_connection(socket)
+      connection = Connection.new(socket)
+      begin
+        connection.read_request
+        @callback[connection]
+      end while connection.alive?
+    rescue EOFError
+      # Client disconnected prematurely
+      # FIXME: should probably do something here
+    end
+  end
+end

data/lib/reel/version.rb

@@ -1,3 +1,3 @@
 module Reel
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/reel.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["tony.arcieri@gmail.com"]
   gem.description   = "A Celluloid::IO-powered HTTP server"
   gem.summary       = "A reel good HTTP server"
-  gem.homepage      = "https://github.com/tarcieri/reel"
+  gem.homepage      = "https://github.com/celluloid/reel"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
@@ -15,9 +15,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Reel::VERSION
   
-  gem.add_dependency 'celluloid-io', '>= 0.8.0'
-  gem.add_dependency 'http_parser'
+  gem.add_dependency 'celluloid-io',   '>= 0.8.0'
+  gem.add_dependency 'http',           '>= 0.2.0'
+  gem.add_dependency 'http_parser.rb', '>= 0.5.3'
   
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 2.7.0'
+  gem.add_development_dependency 'rspec'
 end

data/spec/reel/connection_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Reel::Connection do
+  it "reads requests without bodies" do
+    with_socket_pair do |client, connection|
+      client << ExampleRequest.new.to_s
+      request = connection.read_request
+
+      request.url.should     eq "/"
+      request.version.should eq "1.1"
+
+      request['Host'].should eq "www.example.com"
+      request['Connection'].should eq "keep-alive"
+      request['User-Agent'].should eq "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S"
+      request['Accept'].should eq "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      request['Accept-Encoding'].should eq "gzip,deflate,sdch"
+      request['Accept-Language'].should eq "en-US,en;q=0.8"
+      request['Accept-Charset'].should eq "ISO-8859-1,utf-8;q=0.7,*;q=0.3"
+    end
+  end
+
+  it "reads requests with bodies" do
+    with_socket_pair do |client, connection|
+      body = "Hello, world!"
+      example_request = ExampleRequest.new
+      example_request.body = body
+
+      client << example_request.to_s
+      request = connection.read_request
+
+      request.url.should     eq "/"
+      request.version.should eq "1.1"
+      request['Content-Length'].should == body.length.to_s
+      request.body.should == example_request.body
+    end
+  end
+
+  def with_socket_pair
+    host = '127.0.0.1'
+    port = 10103
+
+    server = TCPServer.new(host, port)
+    client = TCPSocket.new(host, port)
+    peer   = server.accept
+
+    yield client, Reel::Connection.new(peer)
+
+    server.close
+    client.close
+    peer.close
+  end
+end

data/spec/reel/server_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'net/http'
+
+describe Reel::Server do
+  let(:endpoint) { URI("http://#{example_addr}:#{example_port}#{example_url}") }
+  let(:response_body) { "ohai thar" }
+  
+  it "receives HTTP requests and sends responses" do
+    handler_called = false
+    handler = proc do |connection|
+      handler_called = true
+      request = connection.request
+      request.method.should eq :get
+      request.version.should eq "1.1"
+      request.url.should eq example_url
+      
+      connection.respond :ok, response_body
+    end
+    
+    with_reel(handler) do
+      response = Net::HTTP.get endpoint
+      response.should eq response_body
+    end
+    
+    handler_called.should be_true
+  end
+  
+  it "echoes request bodies as response bodies" do
+    handler_called = false
+    handler = proc do |connection|
+      handler_called = true
+      request = connection.request
+      request.method.should eq :post
+      connection.respond :ok, request.body
+    end
+    
+    with_reel(handler) do
+      http = Net::HTTP.new(endpoint.host, endpoint.port)
+      request = Net::HTTP::Post.new(endpoint.request_uri)
+      request['connection'] = 'close'
+      request.body = response_body
+      response = http.request(request)
+      response.should be_a Net::HTTPOK
+      response.body.should == response_body
+    end
+    
+    handler_called.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'bundler/setup'
+require 'reel'
+
+def example_addr; '127.0.0.1'; end
+def example_port; 1234; end
+def example_url;  "/example"; end
+
+def with_reel(handler)
+  server = Reel::Server.new(example_addr, example_port, &handler)
+  yield server
+ensure
+  server.terminate
+end
+
+class ExampleRequest
+  extend Forwardable
+  def_delegators :@headers, :[], :[]=
+  attr_accessor  :path, :version, :body
+
+  def initialize(verb = :get, path = "/", version = "1.1", headers = {}, body = nil)
+    @verb = verb.to_s.upcase
+    @path = path
+    @version = "1.1"
+    @headers = {
+      'Host'       => 'www.example.com',
+      'Connection' => 'keep-alive',
+      'User-Agent' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S',
+      'Accept'     => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Encoding' => 'gzip,deflate,sdch',
+      'Accept-Language' => 'en-US,en;q=0.8',
+      'Accept-Charset'  => 'ISO-8859-1,utf-8;q=0.7,*;q=0.3'
+    }.merge(headers)
+
+    @body = nil
+  end
+
+  def to_s
+    if @body && !@headers['Content-Length']
+      @headers['Content-Length'] = @body.length
+    end
+
+    "#{@verb} #{@path} HTTP/#{@version}\r\n" <<
+    @headers.map { |k, v| "#{k}: #{v}" }.join("\r\n") << "\r\n\r\n" <<
+    (@body ? @body : '')
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,7 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+    task.rcov = true
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reel
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-30 00:00:00.000000000 Z
+date: 2012-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
-  requirement: &70178153658100 !ruby/object:Gem::Requirement
+  requirement: &70219946901960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,21 +21,32 @@ dependencies:
         version: 0.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *70178153658100
+  version_requirements: *70219946901960
 - !ruby/object:Gem::Dependency
-  name: http_parser
-  requirement: &70178153657640 !ruby/object:Gem::Requirement
+  name: http
+  requirement: &70219946917780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70219946917780
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: &70219946917260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.3
   type: :runtime
   prerelease: false
-  version_requirements: *70178153657640
+  version_requirements: *70219946917260
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70178153657160 !ruby/object:Gem::Requirement
+  requirement: &70219946916780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,34 +54,54 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70178153657160
+  version_requirements: *70219946916780
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70178153656660 !ruby/object:Gem::Requirement
+  requirement: &70219946916200 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70178153656660
+  version_requirements: *70219946916200
 description: A Celluloid::IO-powered HTTP server
 email:
 - tony.arcieri@gmail.com
-executables: []
+executables:
+- reel
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
-- LICENSE
+- LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/hello_goliath.rb
+- benchmarks/hello_node.js
+- benchmarks/hello_rack.ru
+- benchmarks/hello_reel.rb
+- bin/reel
+- examples/hello_world.rb
 - lib/reel.rb
+- lib/reel/connection.rb
+- lib/reel/logger.rb
+- lib/reel/request.rb
+- lib/reel/request/parser.rb
+- lib/reel/response.rb
+- lib/reel/server.rb
 - lib/reel/version.rb
+- logo.png
 - reel.gemspec
-homepage: https://github.com/tarcieri/reel
+- spec/reel/connection_spec.rb
+- spec/reel/server_spec.rb
+- spec/spec_helper.rb
+- tasks/rspec.rake
+homepage: https://github.com/celluloid/reel
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -94,5 +125,8 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A reel good HTTP server
-test_files: []
+test_files:
+- spec/reel/connection_spec.rb
+- spec/reel/server_spec.rb
+- spec/spec_helper.rb
 has_rdoc: