thin 1.0.0 → 1.2.1

data/CHANGELOG

@@ -1,3 +1,29 @@
+== 1.2.1 Asynctilicious Ultra Supreme release
+ * Require Rack 1.0.0
+ * Require EventMachine 0.12.6
+ * Use Rails Rack based dispatcher when available
+ * Allow String for response body
+ * Require openssl before eventmachine to prevent crash in 1.9
+
+== 1.2.0 Asynctilicious Supreme release 
+ * Add support for Windows mingw Ruby distro [Juan C. Rodriguez]
+ * Add async response support, see example/async_*.ru [raggi]
+
+== 1.1.1 Super Disco Power Plus release 
+ * Fix bug when running with only options [hasimo]
+
+== 1.1.0 Super Disco Power release
+ * Require EventMachine 0.12.4
+ * Remove Thin handler, now part of Rack 0.9.1
+ * Fix Rack protocol version to 0.1 in environment hash.
+ * Fix error when passing no_epoll option to a cluster.
+ * Omit parsing #defined strings [Jérémy Zurcher]
+ * Defaults SERVER_NAME to localhost like webrick does [#87 state:resolved]
+ * Namespace parser to prevent error when mongrel is required [cliffmoon]
+ * Set RACK_ENV based on environment option when loading rackup file [Curtis Summers] [#83 state:resolved]
+ * Fixes a warning RE relative_url_root when using a prefix with Rails 2.1.1 [seriph] [#85 state:resolved]
+ * --only can work as a sequence number (if < 80) or a port number (if >= 80) [jmay] [#81 state:resolved]
+
 == 1.0.0 That's What She Said release
  * Fixed vlad.rake to allow TCP or socket [hellekin]
  * Updated Mack adapter to handle both <0.8.0 and >0.8.0 [Mark Bates]

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

data/example/async_tailer.ru

@@ -0,0 +1,100 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_tailer.ru
+#  raggi/thin
+#
+#  Tested with 150 spawned tails on OS X
+#  
+#  Created by James Tucker on 2008-06-18.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+# Uncomment if appropriate for you..
+# EM.epoll
+# EM.kqueue
+
+class DeferrableBody
+  include EventMachine::Deferrable
+  
+  def initialize
+    @queue = []
+    # make sure to flush out the queue before closing the connection
+    callback{
+      until @queue.empty?
+        @queue.shift.each{|chunk| @body_callback.call(chunk) }
+      end
+    }
+  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
+
+module TailRenderer
+  attr_accessor :callback
+
+  def receive_data(data)
+    @callback.call([data])
+  end
+
+  def unbind
+    @callback.succeed
+  end
+end
+
+class AsyncTailer
+  
+  AsyncResponse = [-1, {}, []].freeze
+    
+  def call(env)
+    
+    body = DeferrableBody.new
+    
+    EventMachine::next_tick do
+      
+      env['async.callback'].call [200, {'Content-Type' => 'text/html'}, body]
+      
+      body.call ["<h1>Async Tailer</h1><pre>"]
+      
+    end
+    
+    EventMachine::popen('tail -f /var/log/system.log', TailRenderer) do |t|
+      
+      t.callback = body
+      
+      # If for some reason we 'complete' body, close the tail.
+      body.callback do
+        t.close_connection
+      end
+      
+      # If for some reason the client disconnects, close the tail.
+      body.errback do
+        t.close_connection
+      end
+      
+    end
+    
+    AsyncResponse
+  end
+  
+end
+
+run AsyncTailer.new