steamcannon-thin 1.2.8

data/benchmark/benchmarker.rb

@@ -0,0 +1,80 @@
+require 'rack/lobster'
+
+class Benchmarker
+  PORT    = 7000
+  ADDRESS = '0.0.0.0'
+  
+  attr_accessor :requests, :concurrencies, :servers, :keep_alive
+  
+  def initialize
+    @servers = %w(Mongrel EMongrel Thin)
+    @requests = 1000
+    @concurrencies = [1, 10, 100]
+  end
+  
+  def writer(&block)
+    @writer = block
+  end
+  
+  def run!
+    @concurrencies.each do |concurrency|
+      @servers.each do |server|
+        req_sec, failed = run_one(server, concurrency)
+        @writer.call(server, @requests, concurrency, req_sec, failed)
+      end
+    end
+  end
+  
+  private
+    def start_server(handler_name)
+      @server = fork do
+        [STDOUT, STDERR].each { |o| o.reopen "/dev/null" }
+
+        case handler_name
+        when 'EMongrel'
+          require 'swiftcore/evented_mongrel'
+          handler_name = 'Mongrel'
+        end
+
+        app = proc do |env|
+          [200, {'Content-Type' => 'text/html', 'Content-Length' => '11'}, ['hello world']]
+        end
+
+        handler = Rack::Handler.const_get(handler_name)
+        handler.run app, :Host => ADDRESS, :Port => PORT
+      end
+    
+      sleep 2
+    end
+  
+    def stop_server
+      Process.kill('SIGKILL', @server)
+      Process.wait
+    end
+  
+    def run_ab(concurrency)
+      `nice -n20 ab -c #{concurrency} -n #{@requests} #{@keep_alive ? '-k' : ''} #{ADDRESS}:#{PORT}/ 2> /dev/null`
+    end
+  
+    def run_one(handler_name, concurrency)
+      start_server(handler_name)
+
+      out = run_ab(concurrency)
+
+      stop_server
+
+      req_sec = if matches = out.match(/^Requests.+?(\d+\.\d+)/)
+        matches[1].to_i
+      else
+        0
+      end
+    
+      failed = if matches = out.match(/^Failed requests.+?(\d+)/)
+        matches[1].to_i
+      else
+        0
+      end
+    
+      [req_sec, failed]
+    end
+end

data/benchmark/runner

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# Simple benchmark to compare Thin performance against
+# other webservers supported by Rack.
+#
+# Run with:
+#
+#  ruby simple.rb [num of request] [print|graph] [concurrency levels]
+#
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'thin'
+
+require File.dirname(__FILE__) + '/benchmarker'
+require 'optparse'
+
+options = {
+  :requests      => 1000,
+  :concurrencies => [1, 10, 100],
+  :keep_alive    => false,
+  :output        => :table
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on("-n", "--requests NUM", "Number of requests")         { |num| options[:requests] = num.to_i }
+  opts.on("-c", "--concurrencies EXP", "Concurrency levels")    { |exp| options[:concurrencies] = eval(exp).to_a }
+  opts.on("-k", "--keep-alive", "Use persistent connections")   { options[:keep_alive] = true }
+  opts.on("-t", "--table", "Output as text table")              { options[:output] = :table }
+  opts.on("-g", "--graph", "Output as graph")                   { options[:output] = :graph }
+  
+  opts.on_tail("-h", "--help", "Show this message")     { puts opts; exit }
+end.parse!(ARGV)
+
+# benchmark output_type, %w(WEBrick Mongrel EMongrel Thin), request, levels
+b = Benchmarker.new
+b.requests = options[:requests]
+b.concurrencies = options[:concurrencies]
+b.keep_alive = options[:keep_alive]
+
+case options[:output]
+when :table
+  puts 'server     request   concurrency   req/s    failures'
+  puts '=' * 52
+  
+  b.writer do |server, requests, concurrency, req_sec, failed|
+    puts "#{server.ljust(8)}   #{requests}      #{concurrency.to_s.ljust(4)}          #{req_sec.to_s.ljust(8)} #{failed}"
+  end
+  
+  b.run!
+
+when :graph
+  require '/usr/local/lib/ruby/gems/1.8/gems/gruff-0.2.9/lib/gruff'
+  g = Gruff::Area.new
+  g.title = "#{options[:requests]} requests"
+  g.title << ' w/ Keep-Alive' if options[:keep_alive]
+  
+  g.x_axis_label  = 'Concurrency'
+  g.y_axis_label  = 'Requests / sec'
+  g.maximum_value = 0
+  g.minimum_value = 0
+  g.labels        = {}
+  b.concurrencies.each_with_index { |c, i| g.labels[i] = c.to_s }
+  
+  results = {}
+  
+  b.writer do |server, requests, concurrency, req_sec, failed|
+    print '.'
+    results[server] ||= []
+    results[server] << req_sec
+  end
+  
+  b.run!
+  puts
+  
+  results.each do |server, concurrencies|
+    g.data(server, concurrencies)    
+  end
+  
+  g.write('bench.png')
+  `open bench.png`
+end

data/bin/thin

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# Thin command line interface script.
+# Run <tt>thin -h</tt> to get more usage.
+
+require 'thin'
+Thin::Runner.new(ARGV).run!

data/example/adapter.rb

@@ -0,0 +1,32 @@
+# Run with: ruby adapter.rb
+# Then browse to http://localhost:3000/test
+# and http://localhost:3000/files/adapter.rb
+require 'thin'
+
+class SimpleAdapter
+  def call(env)
+    body = ["hello!"]
+    [
+      200,
+      { 'Content-Type' => 'text/plain' },
+      body
+    ]
+  end
+end
+
+Thin::Server.start('0.0.0.0', 3000) do
+  use Rack::CommonLogger
+  map '/test' do
+    run SimpleAdapter.new
+  end
+  map '/files' do
+    run Rack::File.new('.')
+  end
+end
+
+# You could also start the server like this:
+#
+#   app = Rack::URLMap.new('/test'  => SimpleAdapter.new,
+#                          '/files' => Rack::File.new('.'))
+#   Thin::Server.start('0.0.0.0', 3000, app)
+#

data/example/async_app.ru

@@ -0,0 +1,126 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_app.ru
+#  raggi/thin
+#   
+#   A second demo app for async rack + thin app processing!
+#   Now using http status code 100 instead.
+# 
+#  Created by James Tucker on 2008-06-17.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+#
+#--
+# Benchmark Results:
+#
+# raggi@mbk:~$ ab -c 100 -n 500 http://127.0.0.1:3000/
+# This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0
+# Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+# Copyright 2006 The Apache Software Foundation, http://www.apache.org/
+# 
+# Benchmarking 127.0.0.1 (be patient)
+# Completed 100 requests
+# Completed 200 requests
+# Completed 300 requests
+# Completed 400 requests
+# Finished 500 requests
+# 
+# 
+# Server Software:        thin
+# Server Hostname:        127.0.0.1
+# Server Port:            3000
+# 
+# Document Path:          /
+# Document Length:        12 bytes
+# 
+# Concurrency Level:      100
+# Time taken for tests:   5.263089 seconds
+# Complete requests:      500
+# Failed requests:        0
+# Write errors:           0
+# Total transferred:      47000 bytes
+# HTML transferred:       6000 bytes
+# Requests per second:    95.00 [#/sec] (mean)
+# Time per request:       1052.618 [ms] (mean)
+# Time per request:       10.526 [ms] (mean, across all concurrent requests)
+# Transfer rate:          8.55 [Kbytes/sec] received
+# 
+# Connection Times (ms)
+#               min  mean[+/-sd] median   max
+# Connect:        0    3   2.2      3       8
+# Processing:  1042 1046   3.1   1046    1053
+# Waiting:     1037 1042   3.6   1041    1050
+# Total:       1045 1049   3.1   1049    1057
+# 
+# Percentage of the requests served within a certain time (ms)
+#   50%   1049
+#   66%   1051
+#   75%   1053
+#   80%   1053
+#   90%   1054
+#   95%   1054
+#   98%   1056
+#   99%   1057
+#  100%   1057 (longest request)
+
+class DeferrableBody
+  include EventMachine::Deferrable
+
+  def call(body)
+    body.each do |chunk|
+      @body_callback.call(chunk)
+    end
+  end
+
+  def each &blk
+    @body_callback = blk
+  end
+
+end
+
+class AsyncApp
+  
+  # This is a template async response. N.B. Can't use string for body on 1.9
+  AsyncResponse = [-1, {}, []].freeze
+    
+  def call(env)
+    
+    body = DeferrableBody.new
+    
+    # Get the headers out there asap, let the client know we're alive...
+    EventMachine::next_tick { env['async.callback'].call [200, {'Content-Type' => 'text/plain'}, body] }
+    
+    # Semi-emulate a long db request, instead of a timer, in reality we'd be 
+    # waiting for the response data. Whilst this happens, other connections 
+    # can be serviced.
+    # This could be any callback based thing though, a deferrable waiting on 
+    # IO data, a db request, an http request, an smtp send, whatever.
+    EventMachine::add_timer(1) {
+      body.call ["Woah, async!\n"]
+      
+      EventMachine::next_tick {
+        # This could actually happen any time, you could spawn off to new 
+        # threads, pause as a good looking lady walks by, whatever.
+        # Just shows off how we can defer chunks of data in the body, you can
+        # even call this many times.
+        body.call ["Cheers then!"]
+        body.succeed
+      }
+    }
+    
+    # throw :async # Still works for supporting non-async frameworks...
+    
+    AsyncResponse # May end up in Rack :-)
+  end
+  
+end
+
+# The additions to env for async.connection and async.callback absolutely 
+# destroy the speed of the request if Lint is doing it's checks on env.
+# It is also important to note that an async response will not pass through 
+# any further middleware, as the async response notification has been passed 
+# right up to the webserver, and the callback goes directly there too.
+# Middleware could possibly catch :async, and also provide a different 
+# async.connection and async.callback.
+
+# use Rack::Lint
+run AsyncApp.new

data/example/async_chat.ru

@@ -0,0 +1,247 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_chat.ru
+#  raggi/thin
+#  
+#  Created by James Tucker on 2008-06-19.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+# Uncomment if appropriate for you..
+EM.epoll
+# EM.kqueue # bug on OS X in 0.12?
+
+class DeferrableBody
+  include EventMachine::Deferrable
+  
+  def initialize
+    @queue = []
+  end
+  
+  def schedule_dequeue
+    return unless @body_callback
+    EventMachine::next_tick do
+      next unless body = @queue.shift
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+      schedule_dequeue unless @queue.empty?
+    end
+  end 
+
+  def call(body)
+    @queue << body
+    schedule_dequeue
+  end
+
+  def each &blk
+    @body_callback = blk
+    schedule_dequeue
+  end
+
+end
+
+class Chat
+  
+  module UserBody
+    attr_accessor :username
+  end
+  
+  def initialize
+    @users = {}
+  end
+  
+  def render_page
+    [] << <<-EOPAGE
+  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+  <html>
+    <head>
+      <style>
+        body {
+          font-family: sans-serif;
+          margin: 0; 
+          padding: 0;
+          margin-top: 4em;
+          margin-bottom: 1em;
+        }
+        #header {
+          background: silver;
+          height: 4em;
+          width: 100%;
+          position: fixed;
+          top: 0px;
+          border-bottom: 1px solid black;
+          padding-left: 0.5em;
+        }
+        #messages {
+          width: 100%;
+          height: 100%;
+        }
+        .message {
+          margin-left: 1em;
+        }
+        #send_form {
+          position: fixed;
+          bottom: 0px;
+          height: 1em;
+          width: 100%;
+        }
+        #message_box {
+          background: silver;
+          width: 100%;
+          border: 0px;
+          border-top: 1px solid black;
+        }
+        .gray {
+          color: gray;
+        }
+      </style>
+      <script type="text/javascript" src="http://ra66i.org/tmp/jquery-1.2.6.min.js"></script>
+      <script type="text/javascript">
+        XHR = function() {
+          var request = false;
+          try { request = new ActiveXObject('Msxml2.XMLHTTP');    } catch(e) {
+            try { request = new ActiveXObject('Microsoft.XMLHTTP'); } catch(e1) {
+      		    try {	request = new XMLHttpRequest();                 	}	catch(e2) { 
+      		      return false; 
+    		      }
+  		      }
+  	      }
+          return request;
+        }
+        scroll = function() {
+        	window.scrollBy(0,50);
+        	setTimeout('scroll()',100);
+        }
+        focus = function() {
+          $('#message_box').focus();
+        }
+        send_message = function(message_box) {
+          xhr = XHR();
+          xhr.open("POST", "/", true); 
+      		xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+      		xhr.setRequestHeader("X_REQUESTED_WITH", "XMLHttpRequest");
+      		xhr.send("message="+escape(message_box.value));
+          scroll();
+          message_box.value = '';
+          focus();
+          return false;
+        }
+        new_message = function(username, message) {
+          // TODO html escape message
+          formatted_message = "<div class='message'>" + username + ": " + message + "</div>";
+          messages_div = $('#messages');
+          $(formatted_message).appendTo(messages_div);
+          scroll();
+          return true;
+        }
+      </script>
+      <title>Async Chat</title>
+    </head>
+    <body>
+      <div id="header">
+        <h1>Async Chat</h1>
+      </div>
+      <div id="messages" onclick="focus();">
+        <span class="gray">Your first message will become your nickname!</span>
+        <span>Users: #{@users.map{|k,u|u.username}.join(', ')}</span>
+      </div>
+      <form id="send_form" onSubmit="return send_message(this.message)">
+        <input type="text" id="message_box" name="message"></input>
+      </form>
+      <script type="text/javascript">focus();</script>
+    </body>
+  </html>
+  EOPAGE
+  end
+  
+  def register_user(user_id, renderer)
+    body = create_user(user_id)
+    body.call render_page
+    body.errback { delete_user user_id }
+    body.callback { delete_user user_id }
+    
+    EventMachine::next_tick do
+      renderer.call [200, {'Content-Type' => 'text/html'}, body]
+    end
+  end
+  
+  def new_message(user_id, message)
+    return unless @users[user_id]
+    if @users[user_id].username == :anonymous
+      username = unique_username(message)
+      log "User: #{user_id} is #{username}"
+      @users[user_id].username = message
+      message = "<span class='gray'>-> #{username} signed on.</span>"
+    end
+    username ||= @users[user_id].username
+    log "User: #{username} sent: #{message}"
+    @users.each do |id, body|
+      EventMachine::next_tick { body.call [js_message(username, message)] }
+    end
+  end
+  
+  private
+  def unique_username(name)
+    name.concat('_') while @users.any? { |id,u| name == u.username }
+    name
+  end
+  
+  def log(str)
+    print str, "\n"
+  end
+  
+  def add_user(id, body)
+    @users[id] = body
+  end
+  
+  def delete_user(id)
+    message = "User: #{id} - #{@users[id].username if @users[id]} disconnected."
+    log message
+    new_message(id, message)
+    @users.delete id
+  end
+  
+  def js_message(username, message)
+    %(<script type="text/javascript">new_message("#{username}","#{message}");</script>)
+  end
+  
+  def create_user(id)
+    message = "User: #{id} connected."
+    log message
+    new_message(id, message)
+    body = DeferrableBody.new
+    body.extend UserBody
+    body.username = :anonymous
+    add_user(id, body)
+    body
+  end
+  
+end
+
+class AsyncChat
+  
+  AsyncResponse = [-1, {}, []].freeze
+  AjaxResponse = [200, {}, []].freeze
+  
+  def initialize
+    @chat = Chat.new
+  end
+  
+  def call(env)  
+    request = Rack::Request.new(env)
+    # TODO - cookie me, baby
+    user_id = request.env['REMOTE_ADDR']
+    if request.xhr?
+      message = request['message']
+      @chat.new_message(user_id, Rack::Utils.escape_html(message))
+      AjaxResponse
+    else
+      renderer = request.env['async.callback']
+      @chat.register_user(user_id, renderer)
+      AsyncResponse
+    end
+  end
+  
+end
+
+run AsyncChat.new