ebb 0.0.1

data/README

@@ -0,0 +1,119 @@
+# A Web Server Called *Ebb*
+
+Ebb aims to be a small and fast web server specifically for hosting 
+web frameworks like Rails, Merb, and in the future Django.
+
+It is not meant to be a full featured web server like Lighttpd, Apache, or
+Nginx. Rather it should be used in multiplicity behind a 
+[load balancer](http://brainspl.at/articles/2007/11/09/a-fair-proxy-balancer-for-nginx-and-mongrel) 
+and a front-end server. It is not meant to serve static files in production.
+
+## Design
+
+The design is similar to the 
+[Evented Mongrel](http://swiftiply.swiftcore.org/mongrel.html) web server; 
+except instead of using EventMachine (a ruby binding to libevent), the Ebb 
+web server is written in C and uses the 
+[libev](http://software.schmorp.de/pkg/libev.html) event loop library.
+
+Connections are processed as follows:
+
+1. libev loops and waits for incoming connections.
+
+2. When Ebb receives a connection, it passes the request into the
+   [mongrel state machine](http://mongrel.rubyforge.org/browser/tags/rel_1-0-1/ext/http11/http11_parser.rl) 
+   which securely parses the headers.
+
+3. When the request is complete, Ebb passes the information to a user
+   supplied callback.
+
+4. The Ruby binding supplying this callback transforms the
+   request into a [Rack](http://rack.rubyforge.org/) compatible `env` hash 
+   and passes it on a Rack adapter.
+
+Because Ebb is written mostly in C, other language bindings can be added to
+make it useful to Non-Ruby frameworks. For example, a Python WSGI interface is
+forthcoming.
+
+## Download
+
+The Ruby binding is available as a Ruby Gem. It can be install by executing
+
+  `gem install ebb`
+
+Ebb depends on having glib2 headers and libraries installed. (Easily available
+on any UNIX system.) A manual downloads can be found at
+the [RubyForge project page](http://rubyforge.org/frs/?group_id=5640).
+
+## Why?
+
+Because by building the server in C one is able to side-step the 
+limitations on speed of many scripting languages. Inefficiencies are okay
+for quick and beautiful code, but for production web servers that might handle
+thousands of requests a second, an attempt should be made to be as efficient
+as possible in processing connections.
+
+Following are some benchmarks. Please take these measurements with a grain
+of salt. Benchmarks like these are notorious for presenting an inaccurate
+or highly slanted view of how software performs. 
+The code for these can be found in the `benchmark` directory.
+
+![Response Size](http://s3.amazonaws.com/four.livejournal/20080227/response_size.png)
+
+This shows how the web servers perform with respect to throughput (using a 
+simple Rack application). Concurrency is at 50 clients.
+
+![Concurrency](http://s3.amazonaws.com/four.livejournal/20080227/concurrency.png)
+
+A simple concurrent clients benchmark serving a *hello world* page.
+
+![Uploads](http://s3.amazonaws.com/four.livejournal/20080227/post_size.png)
+
+Ebb processes uploads before handing it over to the web application. This 
+allows Ebb to continue to process other clients while the upload is in 
+progress. The cliff at 40k here is because Ebb's internal request
+buffer is set at 40 kilobytes before it writes to file.
+
+
+## Contributions
+
+
+Contributions (patches, criticism, advice) are very welcome! The source code
+is hosted at [repo.or.cz](http://repo.or.cz/w/ebb.git). It can be retrieved 
+by executing
+
+`git clone http://repo.or.cz/r/ebb.git`
+
+I intend to keep the C code base very small, so do email me before writing any
+large additions. Here are some features that I would like to add:
+
+* Multipart parser
+* Streaming responses
+* Optimize and clean up upload handling
+* Option to listen on unix sockets instead of TCP
+* Python binding
+
+## (The MIT) License
+
+Copyright © 2008 [Ry Dahl](http://tinyclouds.org) (ry at tiny clouds dot org)
+
+<div id="license">
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+</div>

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/benchmark/application.rb

@@ -0,0 +1,84 @@
+DIR = File.dirname(__FILE__)
+
+def fib(n)
+  return 1 if n <= 1
+  fib(n-1) + fib(n-2)
+end
+
+def wait(seconds)
+  n = (seconds / 0.01).to_i
+  n.times do 
+    sleep(0.01)
+    #File.read(DIR + '/yahoo.html') 
+  end
+end
+
+class SimpleApp
+  @@responses = {}
+  
+  def initialize
+    @count = 0
+  end
+  
+  def call(env)
+    commands = env['PATH_INFO'].split('/')
+    
+    @count += 1
+    if commands.include?('periodical_activity') and @count % 10 != 1
+      return [200, {'Content-Type'=>'text/plain'}, "quick response!\r\n"]
+    end
+    
+    if commands.include?('fibonacci')
+      n = commands.last.to_i
+      raise "fibonacci called with n <= 0" if n <= 0
+      body = (1..n).to_a.map { |i| fib(i).to_s }.join(' ')
+      status = 200
+    
+    elsif commands.include?('wait')
+      n = commands.last.to_i
+      raise "wait called with n <= 0" if n <= 0
+      wait(n)
+      body = "waited about #{n} seconds"
+      status = 200
+    
+    elsif commands.include?('bytes')
+      n = commands.last.to_i
+      raise "bytes called with n <= 0" if n <= 0
+      body = @@responses[n] || "C"*n
+      status = 200
+      
+    elsif commands.include?('test_post_length')
+      input_body = ""
+      while chunk = env['rack.input'].read(512)
+        input_body << chunk 
+      end
+      if env['HTTP_CONTENT_LENGTH'].to_i == input_body.length
+        body = "Content-Length matches input length"
+        status = 200
+      else
+        body = "Content-Length doesn't matches input length! 
+          content_length = #{env['HTTP_CONTENT_LENGTH'].to_i}
+          input_body.length = #{input_body.length}"
+        status = 500
+      end
+    
+    else
+      status = 404
+      body = "Undefined url"
+    end
+    
+    [status, {'Content-Type' => 'text/plain'}, body + "\r\n\r\n"]
+  end
+end
+
+
+if $0 == __FILE__
+  require DIR + '/../ruby_lib/ebb'
+  require 'rubygems'
+  require 'ruby-debug'
+  Debugger.start
+  
+  server = Ebb::Server.new(SimpleApp.new, :port => 4001)
+  puts "Ebb started on http://0.0.0.0:4001/"
+  server.start
+end

data/benchmark/bench_results.rb

@@ -0,0 +1,45 @@
+# supply the benchmark dump file as an argumetn to this program
+require 'rubygems'
+require 'google_chart'
+require 'server_test'
+
+class Array
+  def avg
+    sum.to_f / length
+  end
+  def sum
+    inject(0) { |i, s| s += i }
+  end
+end
+
+
+
+colors = %w{F74343 444130 7DA478 E4AC3D}
+max_x = 0
+max_y = 0
+results = ServerTestResults.open(ARGV[0])
+all_m = []
+response_chart = GoogleChart::LineChart.new('400x300', Time.now.strftime('%Y.%m.%d'), true)
+results.servers.each do |server|
+  data = results.data(server).sort
+  response_chart.data(server, data, colors.shift)
+  x = data.map { |d| d[0] }.max
+  y = data.map { |d| d[1] }.max
+  max_x = x if x > max_x
+  max_y = y if y > max_y
+end
+
+label = case results.benchmark
+when "response_size"
+  "kilobytes served"
+when "wait_fib", "concurrency"
+  "concurrency"
+when "post_size"
+  "kilobytes uploaded"
+end
+
+response_chart.axis(:y, :range => [0,max_y])
+response_chart.axis(:y, :labels => ['req/s'], :positions => [50])
+response_chart.axis(:x, :range => [0,max_x])
+response_chart.axis(:x, :labels => [label], :positions => [50])
+puts response_chart.to_url

data/benchmark/server_test.rb

@@ -0,0 +1,152 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rack'
+require 'application'
+
+
+class Array
+  def avg
+    sum.to_f / length
+  end
+  
+  def sum
+    inject(0) { |i, s| s += i }
+  end
+  
+  def rand_each(&block)
+    sort_by{ rand }.each &block
+  end
+end
+
+class ServerTestResults
+  def self.open(filename)
+    if File.readable?(filename)
+      new(Marshal.load(File.read(filename))) 
+    else
+      new
+    end
+  end
+
+  def initialize(results = [])
+    @results = results
+  end
+  
+  def benchmark
+    @results.first[:benchmark]
+  end
+  
+  def write(filename='results.dump')
+    puts "writing dump file to #{filename}"
+    File.open(filename, 'w+') do |f|
+      f.write Marshal.dump(@results)
+    end
+  end
+  
+  def <<(r)
+    @results << r
+  end
+  
+  def length
+    @results.length
+  end
+
+  def servers
+    @results.map {|r| r[:server] }.uniq.sort
+  end
+
+  def data(server)
+    server_data = @results.find_all { |r| r[:server] == server }
+    ticks = server_data.map { |d| d[:input] }.uniq
+    datas = []
+    ticks.each do |c|
+      measurements = server_data.find_all { |d| d[:input] == c }.map { |d| d[:rps] }
+      datas << [c, measurements.avg]
+    end
+    datas
+  end
+
+end
+
+class ServerTest
+  attr_reader :name, :port, :app, :pid
+  def initialize(name, port, &start_block)
+    @name = name
+    @port = port.to_i
+  end
+  
+  def <=>(a)
+    @name <=> a.name
+  end
+  
+  def kill
+    Process.kill('KILL', @pid)
+  end
+  
+  def running?
+    !@pid.nil?
+  end
+  
+  def start
+    puts "Starting #{name}"
+    case name
+    when 'emongrel'
+      @pid = fork { start_emongrel }
+    when 'ebb'
+      @pid = fork { start_ebb }
+    when 'mongrel'
+      @pid = fork { start_mongrel }
+    when 'thin'
+      @pid = fork { start_thin }
+    end
+  end
+  
+  def app
+    SimpleApp.new
+  end
+  
+  def start_emongrel
+    require 'mongrel'
+    require 'swiftcore/evented_mongrel'
+    ENV['EVENT'] = "1"
+    Rack::Handler::Mongrel.run(app, :Host => '0.0.0.0', :Port => @port.to_i)
+  end
+  
+  def start_ebb
+    require File.dirname(__FILE__) + '/../ruby_lib/ebb'
+    server = Ebb::Server.run(app, :port => @port)
+  end
+  
+  def start_mongrel
+   require 'mongrel'
+   ENV.delete('EVENT')
+   Rack::Handler::Mongrel.run(app, :Port => @port)
+  end
+  
+  def start_thin
+    require 'thin'
+    Rack::Handler::Thin.run(app, :Port => @port)
+  end
+  
+  def trial(ab_cmd)
+    cmd = ab_cmd.sub('PORT', @port.to_s)
+    
+    puts "#{@name} (#{cmd})"
+    
+    r = %x{#{cmd}}
+    
+    return nil unless r =~ /Requests per second:\s*(\d+\.\d\d)/
+    rps = $1.to_f
+    if r =~ /Complete requests:\s*(\d+)/
+      requests_completed = $1.to_i
+    end
+    puts "   #{rps} req/sec (#{requests_completed} completed)"
+    
+    {
+      :server => @name,
+      :rps => rps,
+      :requests_completed => requests_completed,
+      :ab_cmd => cmd
+    }
+  end
+end

data/benchmark/test.rb

@@ -0,0 +1,141 @@
+require  File.dirname(__FILE__) + '/../ruby_lib/ebb'
+require 'test/unit'
+require 'net/http'
+require 'base64'
+
+
+class EbbTest < Test::Unit::TestCase
+  def setup
+    @pid = fork do
+      server = Ebb::Server.new(self, :port => 4044)
+      server.start
+    end
+    sleep 0.5
+  end
+  
+  def teardown
+    Process.kill('KILL', @pid)
+    sleep 0.5
+  end
+  
+  def get(path)
+    Net::HTTP.get_response(URI.parse("http://0.0.0.0:4044#{path}"))
+  end
+  
+  def post(path, data)
+    Net::HTTP.post_form(URI.parse("http://0.0.0.0:4044#{path}"), data)
+  end
+  
+  @@responses = {}
+  def call(env)
+    commands = env['PATH_INFO'].split('/')
+    
+    if commands.include?('bytes')
+      n = commands.last.to_i
+      raise "bytes called with n <= 0" if n <= 0
+      body = @@responses[n] || "C"*n
+      status = 200
+    
+    elsif commands.include?('env')
+      env.delete('rack.input') # delete this because it's hard to marshal
+      env.delete('rack.errors')
+      body = Base64.encode64(Marshal.dump(env))
+      status = 200
+      
+    elsif commands.include?('test_post_length')
+      input_body = ""
+      while chunk = env['rack.input'].read(512)
+        input_body << chunk 
+      end
+      
+      content_length_header = env['HTTP_CONTENT_LENGTH'].to_i
+      
+      if content_length_header == input_body.length
+        body = "Content-Length matches input length"
+        status = 200
+      else
+        body = "Content-Length header is #{content_length_header} but body length is #{input_body.length}"
+        #  content_length = #{env['HTTP_CONTENT_LENGTH'].to_i}
+        #  input_body.length = #{input_body.length}"
+        status = 500
+      end
+    
+    else
+      status = 404
+      body = "Undefined url"
+    end
+    
+    [status, {'Content-Type' => 'text/plain'}, body]
+  end
+  
+  def test_get_bytes
+    [1,10,1000].each do |i|
+      response = get("/bytes/#{i}")
+      assert_equal "#{'C'*i.to_i}", response.body
+    end
+  end
+  
+  def test_get_unknown
+    response = get('/blah')
+    assert_equal "Undefined url", response.body
+  end
+  
+  def test_small_posts
+    [1,10,321,123,1000].each do |i|
+      response = post("/test_post_length", 'C'*i)
+      assert_equal 200, response.code.to_i, response.body
+    end
+  end
+  
+  # this is rough but does detect major problems
+  def test_ab
+    r = %x{ab -n 1000 -c 50 -q http://0.0.0.0:4044/bytes/123}
+    assert r =~ /Requests per second:\s*(\d+)/, r
+    assert $1.to_i > 100, r
+  end
+  
+  def test_large_post
+    [50,60,100].each do |i|
+      response = post("/test_post_length", 'C'*1024*i)
+      assert_equal 200, response.code.to_i, response.body
+    end
+  end
+  
+  def test_env
+    response = get('/env')
+    env = Marshal.load(Base64.decode64(response.body))
+    assert_equal '/env', env['PATH_INFO']
+    assert_equal '/env', env['REQUEST_PATH']
+    assert_equal 'HTTP/1.1', env['SERVER_PROTOCOL']
+    assert_equal 'CGI/1.2', env['GATEWAY_INTERFACE']
+    assert_equal '0.0.0.0', env['SERVER_NAME']
+    assert_equal '4044', env['SERVER_PORT']
+    assert_equal 'GET', env['REQUEST_METHOD']
+  end
+end
+
+class EbbRailsTest < Test::Unit::TestCase
+  # just to make sure there isn't some load error
+  def test_ebb_rails_version
+    out = %x{ruby #{Ebb::LIBDIR}/../bin/ebb_rails -v}
+    assert_match %r{Ebb #{Ebb::VERSION}}, out
+  end
+end
+
+
+# 
+# class SocketTest < Test::Unit::TestCase
+#   def test_socket_creation
+#     filename = '/tmp/ebb.socket'
+#     @pid = fork do
+#       server = Ebb::Server.new(TestApp.new, {:socket => filename})
+#       server.start
+#     end
+#     sleep(1)
+#     assert File.exists?(filename)
+#     
+#     Process.kill('KILL', @pid)
+#     
+#     assert !File.exists?(filename)
+#   end
+# end